@fulldivevr/workcord-cli 3.0.1 → 3.0.3

package/dist/commands/machine.js

@@ -7,8 +7,8 @@ import { call, getBaseUrl } from "../client.js";
 import { deleteMachineFile, getMachineLockPath, getMachinePath, getMachineThreadsPath, readMachineFile, readOrCreateInstallationId, saveMachineFile, } from "../config.js";
 import { normalizeBaseUrl } from "../http.js";
 import { runClaude } from "../machine/adapters/claude.js";
-import { runCodex } from "../machine/adapters/codex.js";
-import { ADAPTER_NAMES, detectAdapters } from "../machine/agents.js";
+import { binaryVersion, probeCodex, runCodex } from "../machine/adapters/codex.js";
+import { ADAPTER_NAMES, childEnv, detectAdapters } from "../machine/agents.js";
 import { handleTask, TaskContexts } from "../machine/handler.js";
 import { pairComputer } from "../machine/pair.js";
 import { nextRotationDelay, rotateMachineKey, ROTATE_EVERY_MS } from "../machine/rotate.js";
@@ -78,15 +78,17 @@ export function registerMachine(program) {
     group
         .command("start")
         .description("Connect this computer and run your tasks on it until stopped (foreground). Tasks run with full access, without approvals.")
-        .option("--root <dir>", "directory a task may work in (repeatable); without one, only session search runs", collect, [])
+        .option("--root <dir>", "directory a task may work in (repeatable, default: the current directory)", collect, [])
         .option("--adapter <name>", "coding agent that runs tasks: auto, claude or codex", "auto")
         .option("--home <dir>", "home directory the coding agent runs with (HOME, CODEX_HOME=<dir>/.codex, CLAUDE_CONFIG_DIR=<dir>/.claude)")
         .action(async (opts) => {
         const credential = resolveMachineCredential(process.env, await readMachineFile());
         const roots = await resolveRoots(opts.root);
         const home = await resolveHome(opts.home);
-        const installed = await detectAdapters();
-        const adapters = pickAdapters(installed, opts.adapter, home);
+        const detected = await detectAdapters();
+        pickAdapters(detected, opts.adapter, home);
+        // checkAdapters already narrowed the set to the chosen adapter.
+        const adapters = pickAdapters(await checkAdapters(detected, opts.adapter, home), "auto", home);
         const baseUrl = credential.baseUrl || (await getBaseUrl());
         const installationId = await readOrCreateInstallationId();
         const release = await acquireMachineLock(getMachineLockPath());
@@ -105,7 +107,7 @@ export function registerMachine(program) {
             ...(credential.source === "file" ? { reloadKey: () => savedKeyFor(baseUrl) } : {}),
         });
         const rotation = credential.source === "file" ? scheduleRotation(client) : undefined;
-        process.stderr.write(`machine: full access, agents: ${Object.keys(adapters).join(", ") || "none"}, roots: ${roots.length ? roots.join(", ") : "none (session search only)"}\n`);
+        process.stderr.write(`machine: full access, agents: ${Object.keys(adapters).join(", ") || "none"}, roots: ${roots.join(", ")}\n`);
         process.once("SIGINT", () => client.stop());
         process.once("SIGTERM", () => client.stop());
         const outcome = await client.start().finally(() => {
@@ -119,7 +121,7 @@ export function registerMachine(program) {
     group
         .command("install-service")
         .description("Keep `machine start` running in the background (launchd on macOS, systemd on Linux).")
-        .option("--root <dir>", "directory a task may work in (repeatable)", collect, [])
+        .option("--root <dir>", "directory a task may work in (repeatable, default: the current directory)", collect, [])
         .option("--adapter <name>", "coding agent that runs tasks: auto, claude or codex", "auto")
         .option("--home <dir>", "home directory the coding agent runs with (HOME, CODEX_HOME=<dir>/.codex, CLAUDE_CONFIG_DIR=<dir>/.claude)")
         .action(async (opts) => {
@@ -180,6 +182,33 @@ function collect(value, previous) {
     return [...previous, value];
 }
 const RUNNERS = { claude: runClaude, codex: runCodex };
+/**
+ * Prints the binary each adapter uses and drops one that cannot run tasks, so it is
+ * never advertised to the server. A Codex older than `app-server` exits at once.
+ */
+export async function checkAdapters(installed, choice, home, log = (line) => process.stderr.write(line + "\n"), env = process.env) {
+    const usable = {};
+    for (const [name, binary] of Object.entries(installed)) {
+        if (!binary || (choice !== "auto" && choice !== name))
+            continue;
+        if (name === "codex") {
+            const probe = await probeCodex(binary, env, home);
+            if (!probe.ok) {
+                log(`ERROR: ${probe.message}`);
+                if (probe.stderr)
+                    log(`machine: codex said: ${probe.stderr.replace(/\s+/g, " ").slice(-300)}`);
+                continue;
+            }
+        }
+        else if (name === "claude" && (await binaryVersion(binary, childEnv(env, home))) === "unknown") {
+            log(`ERROR: claude at ${binary} does not answer "claude --version". Reinstall it: npm i -g @anthropic-ai/claude-code@latest`);
+            continue;
+        }
+        log(`machine: ${name} at ${binary}`);
+        usable[name] = binary;
+    }
+    return usable;
+}
 export function pickAdapters(installed, choice, home) {
     const names = choice === "auto" ? ADAPTER_NAMES.filter((name) => installed[name]) : [choice];
     const picked = {};

package/dist/machine/adapters/codex.js

@@ -1,8 +1,11 @@
-import { spawn } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import { createInterface } from "node:readline";
 import { childEnv } from "../agents.js";
 const TASK_TIMEOUT_MS = 20 * 60_000;
 const INTERRUPT_GRACE_MS = 5_000;
+const PROBE_TIMEOUT_MS = 10_000;
+const VERSION_TIMEOUT_MS = 5_000;
+const INITIALIZE_PARAMS = { clientInfo: { name: "workcord", title: "WorkCord machine", version: "1" }, capabilities: null };
 const TOOL_ITEMS = new Set([
     "commandExecution", "fileChange", "mcpToolCall", "dynamicToolCall", "collabAgentToolCall",
     "subAgentActivity", "webSearch", "imageView", "imageGeneration", "sleep",
@@ -39,15 +42,65 @@ export function codexItemEvent(method, item) {
         ...(typeof item.namespace === "string" ? { tool_namespace: item.namespace } : {}),
     };
 }
+/** `<binary> --version`, or "unknown" when it does not answer. */
+export function binaryVersion(binary, env) {
+    return new Promise((resolve) => {
+        execFile(binary, ["--version"], { env, timeout: VERSION_TIMEOUT_MS }, (error, stdout) => {
+            const text = String(stdout || "").trim().split("\n")[0]?.trim();
+            resolve(error || !text ? "unknown" : text);
+        });
+    });
+}
+export function codexUnusableMessage(binary, version) {
+    return `codex at ${binary} (version ${version}) cannot run "codex app-server". Update it: npm i -g @openai/codex@latest`;
+}
+/** Starts `codex app-server` and accepts it once it answers `initialize`; a legacy Codex CLI never does. */
+export async function probeCodex(binary, env, home, timeoutMs = PROBE_TIMEOUT_MS) {
+    const spawnEnv = childEnv(env, home);
+    const stderr = await new Promise((resolve) => {
+        const child = spawn(binary, ["app-server"], { env: spawnEnv, stdio: ["pipe", "pipe", "pipe"] });
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        let tail = "";
+        child.stderr.on("data", (chunk) => {
+            tail = (tail + chunk).slice(-2_000);
+        });
+        const finish = (result) => {
+            clearTimeout(timer);
+            child.stdin.destroy();
+            child.kill();
+            resolve(result);
+        };
+        const timer = setTimeout(() => finish(tail || `no answer to initialize within ${timeoutMs / 1000}s`), timeoutMs);
+        createInterface({ input: child.stdout }).on("line", (line) => {
+            try {
+                const message = JSON.parse(line);
+                if (message?.id === 1 && message.result !== undefined)
+                    finish(undefined);
+            }
+            catch { }
+        });
+        child.on("error", (error) => finish(error.message));
+        child.on("close", (code) => finish(tail || `exited with ${code}`));
+        child.stdin.on("error", () => undefined);
+        child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id: 1, method: "initialize", params: INITIALIZE_PARAMS }) + "\n");
+    });
+    if (stderr === undefined)
+        return { ok: true };
+    const version = await binaryVersion(binary, spawnEnv);
+    return { ok: false, version, stderr: stderr.trim(), message: codexUnusableMessage(binary, version) };
+}
 /**
  * One `codex app-server` per task, spoken to over stdio JSON-RPC as the Codex
  * desktop and mobile clients do: initialize, thread/resume (or thread/start
  * when there is no thread to resume), turn/start, and turn/interrupt for a cancel.
  */
 export async function runCodex(input) {
-    const child = spawn(input.binary ?? "codex", ["app-server"], {
+    const binary = input.binary ?? "codex";
+    const env = childEnv(input.env, input.home);
+    const child = spawn(binary, ["app-server"], {
         cwd: input.cwd,
-        env: childEnv(input.env, input.home),
+        env,
         stdio: ["pipe", "pipe", "pipe"],
     });
     child.stdout.setEncoding("utf8");
@@ -59,10 +112,12 @@ export async function runCodex(input) {
     });
     let nextId = 0;
     const pending = new Map();
+    let initialized = false;
     let threadId = "";
     let turnId = "";
     let finalText = "";
     let lastText = "";
+    const earlyTurns = new Map();
     let settle;
     const done = new Promise((resolve, reject) => { settle = { resolve, reject }; });
     done.catch(() => undefined);
@@ -109,22 +164,32 @@ export async function runCodex(input) {
                     lastText = text;
             }
         }
-        else if (message.method === "turn/completed" && params.turn?.id === turnId) {
-            const turn = params.turn;
-            if (turn.status === "completed")
-                settle.resolve(finalText || lastText);
-            else if (turn.status === "interrupted")
-                settle.reject(new Error("The task was stopped."));
-            else
-                settle.reject(new Error(String(turn.error?.message || `Codex ended the turn as ${turn.status}`)));
+        else if (message.method === "turn/completed" && params.turn?.id) {
+            // Readline emits every line of one stdout chunk synchronously, so a turn that ends
+            // in the chunk carrying the turn/start answer completes before turnId is set.
+            if (!turnId)
+                earlyTurns.set(String(params.turn.id), params.turn);
+            else if (params.turn.id === turnId)
+                finishTurn(params.turn);
         }
     });
+    const finishTurn = (turn) => {
+        if (turn.status === "completed")
+            settle.resolve(finalText || lastText);
+        else if (turn.status === "interrupted")
+            settle.reject(new Error("The task was stopped."));
+        else
+            settle.reject(new Error(String(turn.error?.message || `Codex ended the turn as ${turn.status}`)));
+    };
     child.on("error", (error) => {
         settle.reject(new Error(error.code === "ENOENT" ? "Codex is not installed on this machine (no `codex` on PATH)." : error.message));
     });
     // "close" fires after stdout and stderr have ended, so the stderr tail is complete here.
-    child.on("close", (code) => {
-        const exited = new Error(`Codex exited with ${code}: ${stderr.trim().slice(0, 500)}`);
+    child.on("close", async (code) => {
+        let text = `Codex exited with ${code}: ${stderr.trim().slice(0, 500)}`;
+        if (!initialized)
+            text += `\n${codexUnusableMessage(binary, await binaryVersion(binary, env))}`;
+        const exited = new Error(text);
         for (const waiter of pending.values())
             waiter.reject(exited);
         pending.clear();
@@ -140,7 +205,8 @@ export async function runCodex(input) {
     };
     signal.addEventListener("abort", onAbort, { once: true });
     try {
-        await request("initialize", { clientInfo: { name: "workcord", title: "WorkCord machine", version: "1" }, capabilities: null });
+        await request("initialize", INITIALIZE_PARAMS);
+        initialized = true;
         write({ method: "initialized" });
         const params = codexThreadParams(input.cwd);
         const resumed = input.resume
@@ -152,6 +218,8 @@ export async function runCodex(input) {
             input.onThread?.(threadId);
         const started = await request("turn/start", { threadId, input: [{ type: "text", text: input.prompt, text_elements: [] }] });
         turnId = String(started?.turn?.id || "");
+        if (earlyTurns.has(turnId))
+            finishTurn(earlyTurns.get(turnId));
         if (signal.aborted)
             onAbort();
         return await done;

package/dist/machine/policy.js

@@ -12,8 +12,8 @@ export async function resolveHome(dir) {
         throw new Error(`--home ${absolute} is not a directory.`);
     return absolute;
 }
-export async function resolveRoots(roots) {
-    return Promise.all(roots.map((root) => realpath(root)));
+export async function resolveRoots(roots, cwd = process.cwd()) {
+    return Promise.all((roots.length ? roots : [cwd]).map((root) => realpath(root)));
 }
 /** `roots` are already realpath-resolved, once at start. */
 export async function resolveCwd(roots, requested) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fulldivevr/workcord-cli",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "description": "Agent-first CLI using persistent Hermes tenant chat, with advanced API diagnostics.",
   "private": false,
   "license": "UNLICENSED",