Commit current desktop and CLI diff

packages/cli/src/commands/daemon/status.ts

@@ -1,12 +1,14 @@
 import type { Command } from "commander";
-import { execFileSync } from "node:child_process";
+import { execFile } from "node:child_process";
 import { createRequire } from "node:module";
+import { promisify } from "node:util";
 import {
   getOrCreateServerId,
   findExecutable,
-  quoteWindowsCommand,
   applyProviderEnv,
 } from "@getpaseo/server";
+
+const execFileAsync = promisify(execFile);
 import { tryConnectToDaemon } from "../../utils/client.js";
 import type { CommandOptions, ListResult, OutputSchema } from "../../output/index.js";
 import { resolveLocalDaemonState, resolveTcpHostFromListen } from "./local-daemon.js";
@@ -171,31 +173,33 @@ const PROVIDER_BINARIES: { label: string; binary: string }[] = [
   { label: "OpenCode", binary: "opencode" },
 ];
 
-function checkProviderBinary(binary: string): { path: string | null; version: string | null } {
-  const binaryPath = findExecutable(binary);
+async function checkProviderBinary(binary: string): Promise<{ path: string | null; version: string | null }> {
+  const binaryPath = await findExecutable(binary);
   if (!binaryPath) {
     return { path: null, version: null };
   }
   const env = applyProviderEnv(process.env);
   try {
-    const output = execFileSync(quoteWindowsCommand(binaryPath), ["--version"], {
+    const { stdout } = await execFileAsync(binaryPath, ["--version"], {
       encoding: "utf8",
       timeout: 5000,
-      stdio: ["ignore", "pipe", "pipe"],
       env,
-      shell: process.platform === "win32",
-    }).trim();
-    return { path: binaryPath, version: output || null };
+      windowsHide: true,
+    });
+    return { path: binaryPath, version: stdout.trim() || null };
   } catch {
     return { path: binaryPath, version: null };
   }
 }
 
-function checkProviderBinaries(): ProviderBinaryStatus[] {
-  return PROVIDER_BINARIES.map(({ label, binary }) => {
-    const result = checkProviderBinary(binary);
-    return { label, ...result };
-  });
+async function checkProviderBinaries(): Promise<ProviderBinaryStatus[]> {
+  const results = await Promise.all(
+    PROVIDER_BINARIES.map(async ({ label, binary }) => {
+      const result = await checkProviderBinary(binary);
+      return { label, ...result };
+    }),
+  );
+  return results;
 }
 
 function resolveOwnerLabel(uid: number | undefined, hostname: string | undefined): string | null {
@@ -295,7 +299,7 @@ export async function runStatusCommand(
     note = appendNote(note, `serverId unavailable: ${shortenMessage(normalizeError(error))}`);
   }
 
-  const providers = checkProviderBinaries();
+  const providers = await checkProviderBinaries();
 
   const daemonStatus: DaemonStatus = {
     serverId,

packages/cli/tests/e2e/opencode-invalid-model.test.ts

@@ -0,0 +1,72 @@
+#!/usr/bin/env npx tsx
+
+import assert from "node:assert";
+import { createE2ETestContext, type TestDaemonContext } from "../helpers/test-daemon.ts";
+
+interface E2EContext extends TestDaemonContext {
+  paseo: (
+    args: string[],
+    opts?: { timeout?: number; cwd?: string },
+  ) => Promise<{
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+  }>;
+}
+
+let ctx: E2EContext;
+
+async function setup(): Promise<void> {
+  ctx = await createE2ETestContext({ timeout: 45_000 });
+}
+
+async function cleanup(): Promise<void> {
+  if (ctx) {
+    await ctx.stop();
+  }
+}
+
+async function test_invalid_opencode_model_does_not_report_completed_while_still_running() {
+  const result = await ctx.paseo(
+    ["run", "--provider", "opencode/adklasldkdas", "hello"],
+    { timeout: 45_000 },
+  );
+
+  const output = `${result.stdout}\n${result.stderr}`;
+  const agentId = output.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i)?.[0];
+
+  if (result.exitCode !== 0) {
+    assert(
+      output.toLowerCase().includes("error") || output.toLowerCase().includes("failed"),
+      `expected invalid model failure output\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`,
+    );
+    return;
+  }
+
+  assert(agentId, `expected run output to include an agent id\nstdout:\n${result.stdout}`);
+
+  const inspect = await ctx.paseo(["inspect", agentId], { timeout: 15_000 });
+  assert.strictEqual(inspect.exitCode, 0, `inspect failed\nstdout:\n${inspect.stdout}\nstderr:\n${inspect.stderr}`);
+
+  const runReportedCompleted = result.stdout.includes("completed");
+  const inspectStillRunning = inspect.stdout.includes("Status              running");
+
+  assert(
+    !(runReportedCompleted && inspectStillRunning),
+    `run reported completed while inspect still showed running\nrun stdout:\n${result.stdout}\ninspect stdout:\n${inspect.stdout}`,
+  );
+}
+
+async function main(): Promise<void> {
+  try {
+    await setup();
+    await test_invalid_opencode_model_does_not_report_completed_while_still_running();
+  } catch (error) {
+    console.error(error);
+    process.exitCode = 1;
+  } finally {
+    await cleanup();
+  }
+}
+
+main();