@fulldivevr/workcord-cli 3.0.2 → 3.0.4

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, codexCandidates, 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,18 @@ 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 usable = await checkAdapters(detected, opts.adapter, home, undefined, process.env, await codexCandidates());
+        const adapters = pickAdapters(usable, "auto", home);
         const baseUrl = credential.baseUrl || (await getBaseUrl());
         const installationId = await readOrCreateInstallationId();
         const release = await acquireMachineLock(getMachineLockPath());
@@ -105,7 +108,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 +122,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 +183,49 @@ function collect(value, previous) {
     return [...previous, value];
 }
 const RUNNERS = { claude: runClaude, codex: runCodex };
+/**
+ * Prints the binary each adapter uses. Codex runs from the first candidate that
+ * answers `app-server`; an installed Codex where none does fails the start, since
+ * a legacy Codex CLI cannot run tasks at all.
+ */
+export async function checkAdapters(installed, choice, home, log = (line) => process.stderr.write(line + "\n"), env = process.env, codexCandidates = installed.codex ? [installed.codex] : []) {
+    const usable = {};
+    for (const [name, binary] of Object.entries(installed)) {
+        if (!binary || (choice !== "auto" && choice !== name))
+            continue;
+        if (name === "codex") {
+            const failed = [];
+            for (const candidate of codexCandidates) {
+                const probe = await probeCodex(candidate, env, home);
+                if (probe.ok) {
+                    usable.codex = candidate;
+                    break;
+                }
+                failed.push({ ...probe, binary: candidate });
+            }
+            if (!usable.codex) {
+                for (const probe of failed) {
+                    log(`ERROR: ${probe.message}`);
+                    if (probe.stderr)
+                        log(`machine: codex said: ${probe.stderr.replace(/\s+/g, " ").slice(-300)}`);
+                }
+                throw new Error("codex is installed but none of its copies can run tasks, see the ERROR lines above.");
+            }
+            for (const probe of failed) {
+                log(`machine: warning: skipped codex at ${probe.binary} (version ${probe.version}), it cannot run "codex app-server"`);
+            }
+            log(`machine: codex at ${usable.codex}`);
+            continue;
+        }
+        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, or install the Codex desktop app (it bundles a current codex)`;
+}
+/** 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,6 +112,7 @@ export async function runCodex(input) {
     });
     let nextId = 0;
     const pending = new Map();
+    let initialized = false;
     let threadId = "";
     let turnId = "";
     let finalText = "";
@@ -131,8 +185,11 @@ export async function runCodex(input) {
         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();
@@ -148,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

package/dist/machine/agents.js

@@ -1,4 +1,5 @@
-import { access, constants } from "node:fs/promises";
+import { access, constants, realpath } from "node:fs/promises";
+import { homedir } from "node:os";
 import { delimiter, join } from "node:path";
 export const ADAPTER_NAMES = ["claude", "codex"];
 /**
@@ -12,19 +13,46 @@ export function childEnv(env = process.env, home) {
         return inherited;
     return { ...inherited, HOME: home, CODEX_HOME: join(home, ".codex"), CLAUDE_CONFIG_DIR: join(home, ".claude") };
 }
+/** Codex desktop bundles a current codex that is not on PATH. */
+export function codexDesktopPaths(platform = process.platform, home = homedir()) {
+    if (platform !== "darwin")
+        return [];
+    return ["/Applications", join(home, "Applications")].flatMap((dir) => [
+        join(dir, "ChatGPT.app/Contents/Resources/codex-cli/bin/codex"),
+        join(dir, "Codex.app/Contents/Resources/codex"),
+    ]);
+}
+const isExecutable = (path) => access(path, constants.X_OK).then(() => true, () => false);
+function onPath(name, env) {
+    return String(env.PATH || "").split(delimiter).filter(Boolean).map((dir) => join(dir, name));
+}
+/** Every installed codex, PATH order first, then the desktop bundles, one per real file. */
+export async function codexCandidates(env = process.env, desktop = codexDesktopPaths()) {
+    const seen = new Set();
+    const found = [];
+    for (const candidate of [...onPath("codex", env), ...desktop]) {
+        if (!(await isExecutable(candidate)))
+            continue;
+        const real = await realpath(candidate).catch(() => candidate);
+        if (seen.has(real))
+            continue;
+        seen.add(real);
+        found.push(candidate);
+    }
+    return found;
+}
 /** Absolute path of each installed agent CLI, found the way a shell would find it. */
-export async function detectAdapters(env = process.env) {
+export async function detectAdapters(env = process.env, codexDesktop = codexDesktopPaths()) {
     const found = {};
-    const dirs = String(env.PATH || "").split(delimiter).filter(Boolean);
-    for (const name of ADAPTER_NAMES) {
-        for (const dir of dirs) {
-            const candidate = join(dir, name);
-            if (await access(candidate, constants.X_OK).then(() => true, () => false)) {
-                found[name] = candidate;
-                break;
-            }
+    for (const candidate of onPath("claude", env)) {
+        if (await isExecutable(candidate)) {
+            found.claude = candidate;
+            break;
         }
     }
+    const [codex] = await codexCandidates(env, codexDesktop);
+    if (codex)
+        found.codex = codex;
     return found;
 }
 //# sourceMappingURL=agents.js.map

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.2",
+  "version": "3.0.4",
   "description": "Agent-first CLI using persistent Hermes tenant chat, with advanced API diagnostics.",
   "private": false,
   "license": "UNLICENSED",