talentos 1.1.1 → 1.1.2

package/dist/agent/adapters.js

@@ -8,6 +8,7 @@ import { promisify } from "node:util";
 import { writePrivateFile } from "../agent-config.js";
 import { redactAgentOutput, } from "../agent-link.js";
 import { gatewayLauncherPath } from "../gateway-install.js";
+import { providerPathEnv, resolveProviderBinary } from "../provider-binary.js";
 const CHILD_ENV = [
     "HOME",
     "PATH",
@@ -42,24 +43,28 @@ const ROOM_TOOLS = [
     "whoami",
 ];
 const CLAUDE_TOOLS = ROOM_TOOLS.map((tool) => `mcp__talentos__${tool}`).join(",");
-export function childEnvironment(source = process.env) {
-    return Object.fromEntries(CHILD_ENV.filter((key) => source[key] !== undefined).map((key) => [
-        key,
-        source[key],
-    ]));
+export function childEnvironment(source = process.env, binary) {
+    return {
+        ...Object.fromEntries(CHILD_ENV.filter((key) => source[key] !== undefined).map((key) => [
+            key,
+            source[key],
+        ])),
+        PATH: providerPathEnv(binary, source.HOME),
+    };
 }
-export async function verifyClaudeCode() {
+export async function verifyClaudeCode(configured) {
+    const binary = resolveProviderBinary("claude_code", configured);
     const execute = promisify(execFile);
     const options = {
-        env: childEnvironment(),
+        env: childEnvironment(process.env, binary),
         timeout: 5000,
         maxBuffer: 256_000,
     };
     let version = "unknown";
     try {
-        const detected = await execute("claude", ["--version"], options);
+        const detected = await execute(binary, ["--version"], options);
         version = CLAUDE_VERSION.exec(detected.stdout.trim())?.[0] ?? "unknown";
-        const help = await execute("claude", ["--help"], options);
+        const help = await execute(binary, ["--help"], options);
         if (version !== "unknown" && DONT_ASK.test(help.stdout)) {
             return;
         }
@@ -69,22 +74,23 @@ export async function verifyClaudeCode() {
     }
     throw new Error(`Update Claude Code (${version}) to a version that supports --permission-mode dontAsk.`);
 }
-export async function verifyCodex() {
+export async function verifyCodex(configured) {
+    const binary = resolveProviderBinary("codex", configured);
     const execute = promisify(execFile);
     const options = {
-        env: childEnvironment(),
+        env: childEnvironment(process.env, binary),
         timeout: 5000,
         maxBuffer: 256_000,
     };
     let version = "unknown";
     try {
-        const detected = await execute("codex", ["--version"], options);
+        const detected = await execute(binary, ["--version"], options);
         version = CODEX_VERSION.exec(detected.stdout)?.[0] ?? "unknown";
         for (const args of [
             ["exec", "--help"],
             ["exec", "resume", "--help"],
         ]) {
-            const help = await execute("codex", args, options);
+            const help = await execute(binary, args, options);
             if (![
                 "--json",
                 "--skip-git-repo-check",
@@ -95,7 +101,7 @@ export async function verifyCodex() {
             }
         }
         if (version !== "unknown") {
-            await codexRoomCatalog();
+            await codexRoomCatalog(binary);
             return;
         }
     }
@@ -104,10 +110,10 @@ export async function verifyCodex() {
     }
     throw new Error(`Update Codex (${version}) to a version supporting isolated room turns, exec/resume flags and a local model catalog.`);
 }
-async function codexRoomCatalog() {
+async function codexRoomCatalog(binary) {
     try {
-        const { stdout } = await promisify(execFile)("codex", ["debug", "models", "--bundled"], {
-            env: childEnvironment(),
+        const { stdout } = await promisify(execFile)(binary, ["debug", "models", "--bundled"], {
+            env: childEnvironment(process.env, binary),
             timeout: 5000,
             maxBuffer: 4_000_000,
         });
@@ -188,6 +194,7 @@ export async function runProvider(input) {
     const { config, job, workDir, sessionId, signal } = input;
     const prompt = JSON.stringify(job.packet), mcpPath = join(dirname(workDir), ".talentos-mcp.json");
     const catalogPath = join(dirname(workDir), ".talentos-codex-models.json");
+    const binary = resolveProviderBinary(config.provider, config.providerPath);
     let command, args;
     if (config.provider === "claude_code") {
         await writePrivateFile(mcpPath, JSON.stringify({
@@ -199,7 +206,7 @@ export async function runProvider(input) {
                 },
             },
         }));
-        command = "claude";
+        command = binary;
         args = [
             "-p",
             prompt,
@@ -225,10 +232,10 @@ export async function runProvider(input) {
         }
     }
     else {
-        command = "codex";
+        command = binary;
         const launcher = gatewayLauncherPath();
         const useLauncher = process.platform !== "win32" && existsSync(launcher);
-        await writePrivateFile(catalogPath, await codexRoomCatalog());
+        await writePrivateFile(catalogPath, await codexRoomCatalog(binary));
         // Resume has a different flag surface. Root overrides are inherited by
         // both exec paths; shell_tool=false enforces ADR 0093's default no-Bash.
         args = [
@@ -275,7 +282,7 @@ export async function runProvider(input) {
     }
     const child = spawn(command, args, {
         cwd: workDir,
-        env: childEnvironment(),
+        env: childEnvironment(process.env, binary),
         stdio: ["ignore", "pipe", "ignore"],
         detached: process.platform !== "win32",
     });

package/dist/agent/gateway.js

@@ -4,7 +4,7 @@ import { isSecureUrl } from "../agent-link.js";
 export class GatewayError extends Error {
     status;
     constructor(status) {
-        super(status === 401 || status === 409
+        super(status === 401 || status === 410
             ? "Agent is no longer available. Re-link it from TalentOS."
             : "Agent gateway request failed; retrying.");
         this.status = status;

package/dist/agent/serve.js

@@ -55,7 +55,7 @@ export async function installGatewayUpdate(directory, minimum, signal) {
         signal,
     });
 }
-export async function serveAgent(config, directory, version, stop) {
+export async function serveAgent(config, directory, version, stop, verify) {
     const release = await acquireLock(directory);
     try {
         const workDir = join(directory, "work"), sessions = new SessionMap(directory), gateway = new AgentGateway(config);
@@ -72,7 +72,8 @@ export async function serveAgent(config, directory, version, stop) {
         let minimum = version, lastJobAt = Date.now(), push = false, dispose;
         let terminalError;
         const failService = (error) => {
-            if (error instanceof GatewayError && error.status === 401) {
+            if (error instanceof GatewayError &&
+                (error.status === 401 || error.status === 410)) {
                 terminalError = error;
                 service.abort();
                 active?.cancel.abort();
@@ -126,6 +127,7 @@ export async function serveAgent(config, directory, version, stop) {
             }
         }, 1000);
         try {
+            await verify?.();
             await heartbeat();
             try {
                 push = true;

package/dist/agent-config.js

@@ -1,6 +1,6 @@
 import { randomBytes } from "node:crypto";
 import { chmod, mkdir, readdir, readFile, rename, rm, writeFile, } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { dirname, isAbsolute, join } from "node:path";
 import { redactAgentOutput } from "./agent-link.js";
 import { warn } from "./format.js";
 import { homeDir } from "./install.js";
@@ -95,6 +95,9 @@ function isLinkedAgent(value) {
         typeof config.name === "string" &&
         typeof config.linkHash === "string" &&
         typeof config.linkedAt === "number" &&
+        (config.providerPath === undefined ||
+            (typeof config.providerPath === "string" &&
+                isAbsolute(config.providerPath))) &&
         (config.provider === "claude_code" || config.provider === "codex"));
 }
 export function isMissing(error) {

package/dist/agent-http.js

@@ -1,12 +1,16 @@
 import { spawnSync } from "node:child_process";
+import { childEnvironment } from "./agent/adapters.js";
 import { isSecureUrl, } from "./agent-link.js";
+import { resolveProviderBinary } from "./provider-binary.js";
 const REQUEST_TIMEOUT_MS = 10_000;
 const HEARTBEAT_WINDOW_MS = 60_000;
 export class AgentHttpError extends Error {
     status;
     retryAfterMs;
     constructor(operation, response) {
-        super(`${operation} (HTTP ${response.status}). Ask for a fresh setup prompt if this link expired.`);
+        super(response.status === 426
+            ? "Update TalentOS CLI: run npx --yes --prefer-online talentos@latest agent link again with your setup URL."
+            : `${operation} (HTTP ${response.status}). Ask for a fresh setup prompt if this link expired.`);
         this.status = response.status;
         const seconds = Number(response.headers.get("Retry-After"));
         this.retryAfterMs = Number.isFinite(seconds)
@@ -37,11 +41,12 @@ export async function setupApiOrigin(link, override) {
     }
     return apiOrigin(apiUrl);
 }
-export function inspectProvider(provider) {
-    const binary = provider === "claude_code" ? "claude" : "codex";
+export function inspectProvider(provider, configured) {
+    const binary = resolveProviderBinary(provider, configured);
     const version = spawnSync(binary, ["--version"], {
         encoding: "utf8",
         timeout: REQUEST_TIMEOUT_MS,
+        env: childEnvironment(process.env, binary),
     });
     if (version.status !== 0 || !version.stdout?.trim()) {
         throw new Error(`Install the official ${binary} CLI and sign in before linking.`);
@@ -52,6 +57,7 @@ export function inspectProvider(provider) {
     const login = spawnSync(binary, args, {
         encoding: "utf8",
         timeout: REQUEST_TIMEOUT_MS,
+        env: childEnvironment(process.env, binary),
     });
     if (login.status !== 0) {
         throw new Error(`Sign in through the official ${binary} CLI before linking.`);

package/dist/agent-service.js

@@ -2,8 +2,9 @@ import { spawnSync } from "node:child_process";
 import { chmod, mkdir, open, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { agentLogPath, agentWorkDir, writePrivateFile, } from "./agent-config.js";
-import { gatewayLauncherPath, servicePathEnv } from "./gateway-install.js";
+import { gatewayLauncherPath } from "./gateway-install.js";
 import { homeDir } from "./install.js";
+import { providerPathEnv } from "./provider-binary.js";
 export function runCommand(command, args) {
     return (spawnSync(command, args, { stdio: "ignore", timeout: 15_000 }).status ?? 1);
 }
@@ -32,9 +33,10 @@ export async function installAgentService(agent, options = {}) {
         agent.agentId,
     ];
     const workDir = agentWorkDir(agent.agentId, home);
+    const pathEnv = providerPathEnv(undefined, home, false);
     const content = platform === "darwin"
-        ? launchdUnit(name, args, workDir, logPath, servicePathEnv(home))
-        : systemdUnit(args, workDir, logPath, servicePathEnv(home));
+        ? launchdUnit(name, args, workDir, logPath, pathEnv)
+        : systemdUnit(args, workDir, logPath, pathEnv);
     const changed = await writePrivateFile(path, content);
     if (options.reload === false) {
         if (platform === "linux" && changed) {
@@ -76,26 +78,34 @@ export async function uninstallAgentService(agent, options = {}) {
         return;
     }
     const run = options.run ?? runCommand;
-    if (platform === "darwin") {
-        run("launchctl", [
-            "bootout",
-            `gui/${options.uid ?? process.getuid?.() ?? 0}`,
-            path,
-        ]);
-    }
-    else {
+    if (platform === "linux") {
         run("systemctl", [
             "--user",
             "disable",
-            "--now",
             `talentos-agent@${agent.agentId}.service`,
         ]);
     }
+    // Delete before asking the supervisor to stop us: it can send SIGTERM immediately.
     await rm(path, { force: true });
-    if (platform === "linux") {
+    if (platform === "darwin") {
+        unloadLaunchAgent(agent, options);
+    }
+    else {
         run("systemctl", ["--user", "daemon-reload"]);
+        run("systemctl", [
+            "--user",
+            "--no-block",
+            "stop",
+            `talentos-agent@${agent.agentId}.service`,
+        ]);
     }
 }
+export function unloadLaunchAgent(agent, options = {}) {
+    (options.run ?? runCommand)("launchctl", [
+        "bootout",
+        `gui/${options.uid ?? process.getuid?.() ?? 0}/${serviceName(agent.agentId)}`,
+    ]);
+}
 function serviceName(agentId) {
     return `so.talentos.agent.${agentId}`;
 }

package/dist/commands/agent-serve.js

@@ -1,13 +1,16 @@
 import { readFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { verifyClaudeCode, verifyCodex } from "../agent/adapters.js";
+import { AgentGateway, GatewayError } from "../agent/gateway.js";
 import { serveAgent } from "../agent/serve.js";
-import { agentWorkDir, localAgents } from "../agent-config.js";
-import { installAgentService } from "../agent-service.js";
+import { agentWorkDir, localAgents, storeAgent, } from "../agent-config.js";
+import { AgentHttpError, fetchAgentStatus } from "../agent-http.js";
+import { installAgentService, uninstallAgentService, unloadLaunchAgent, } from "../agent-service.js";
 import { installSharedGateway } from "../gateway-install.js";
-export async function runAgentServe(parsed) {
+import { ProviderBinaryError, resolveProviderBinary, } from "../provider-binary.js";
+export async function runAgentServe(parsed, options = {}) {
     const id = parsed.options.agent;
-    const agents = await localAgents();
+    const agents = await localAgents(options.home);
     let config = agents.find((agent) => agent.agentId === id);
     if (!id && agents.length === 1) {
         config = agents[0];
@@ -16,30 +19,78 @@ export async function runAgentServe(parsed) {
         throw new Error("Choose a linked agent with `talentos agent serve --agent <id>`.");
     }
     try {
-        if (process.platform !== "win32") {
-            await installSharedGateway();
+        if ((options.platform ?? process.platform) !== "win32") {
+            await installSharedGateway({ home: options.home });
         }
-        await installAgentService(config, { reload: false });
+        await installAgentService(config, { ...options, reload: false });
     }
     catch {
         console.error("Gateway installation unavailable. Serving the loaded version; retry talentos agent repair when the installation is available.");
     }
-    if (config.provider === "claude_code") {
-        await verifyClaudeCode();
-    }
-    else {
-        await verifyCodex();
-    }
+    const agent = config;
     const stop = new AbortController();
     const abort = () => stop.abort();
     process.once("SIGTERM", abort);
     process.once("SIGINT", abort);
     const version = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8")).version;
     try {
-        await serveAgent(config, dirname(agentWorkDir(config.agentId)), version, stop.signal);
+        // Authenticate without publishing presence, including when the binary is gone.
+        await fetchAgentStatus(config);
+        await serveAgent(config, dirname(agentWorkDir(config.agentId, options.home)), version, stop.signal, () => verifyAgent(agent, options));
+    }
+    catch (error) {
+        if ((error instanceof GatewayError || error instanceof AgentHttpError) &&
+            (error.status === 401 || error.status === 410)) {
+            await uninstallAgentService(config, options);
+            console.error("Agent access ended. Removed this agent's local service; link it again from TalentOS to reconnect.");
+            return;
+        }
+        throw error;
     }
     finally {
         process.removeListener("SIGTERM", abort);
         process.removeListener("SIGINT", abort);
     }
 }
+async function verifyAgent(config, options) {
+    try {
+        let binary;
+        try {
+            binary = resolveProviderBinary(config.provider, config.providerPath);
+        }
+        catch (error) {
+            if (!(error instanceof ProviderBinaryError && config.providerPath)) {
+                throw error;
+            }
+            binary = resolveProviderBinary(config.provider);
+        }
+        config.providerPath = binary;
+        await storeAgent(config, options.home);
+        if (config.provider === "claude_code") {
+            await verifyClaudeCode(binary);
+        }
+        else {
+            await verifyCodex(binary);
+        }
+    }
+    catch (error) {
+        if (error instanceof ProviderBinaryError) {
+            try {
+                await new AgentGateway(config).request("/agent-gateway/provider-unavailable");
+            }
+            catch (reportError) {
+                if (reportError instanceof GatewayError &&
+                    (reportError.status === 401 || reportError.status === 410)) {
+                    throw reportError;
+                }
+                // Older servers may not support diagnostics; local shutdown still applies.
+            }
+            console.error(error.message);
+            // launchd cannot exclude exit 78; unload but retain the plist for repair.
+            if ((options.platform ?? process.platform) === "darwin") {
+                unloadLaunchAgent(config, options);
+            }
+        }
+        throw error;
+    }
+}

package/dist/commands/agent.js

@@ -10,6 +10,7 @@ import { emit, emitJson, renderTable, warn } from "../format.js";
 import { installSharedGateway } from "../gateway-install.js";
 import { homeDir } from "../install.js";
 import { defaultDeviceName, hashKey, mintKey } from "../login.js";
+import { resolveProviderBinary } from "../provider-binary.js";
 const MAX_PREVIOUS_AGENT_IDS = 100;
 export async function runAgent(parsed, dependencies = {}) {
     switch (parsed.action) {
@@ -20,7 +21,7 @@ export async function runAgent(parsed, dependencies = {}) {
             const { agent, service } = await installLinkedAgent(parsed);
             emit(`Linked ${redactAgentOutput(agent.name)} (${agent.agentId}). Waiting for agent service…`);
             if (!service.started) {
-                warn(`Start it in the foreground: npx --yes talentos@1 agent serve --agent ${agent.agentId}`);
+                warn(`Start it in the foreground: npx --yes --prefer-online talentos@latest agent serve --agent ${agent.agentId}`);
             }
             const status = await waitForHeartbeat(agent);
             if (!status) {
@@ -52,10 +53,26 @@ export async function runAgent(parsed, dependencies = {}) {
                 home: dependencies.home,
                 source: dependencies.gatewaySource,
             });
+            let failed = 0;
             for (const agent of agents) {
-                const service = await (dependencies.install ??
-                    ((config) => installAgentService(config, { home: dependencies.home })))(agent);
-                emit(`Repaired ${redactAgentOutput(agent.name)} (${agent.agentId}).${service.started ? "" : " Start talentos agent serve in the foreground."}`);
+                try {
+                    agent.providerPath = (dependencies.resolveBinary ?? resolveProviderBinary)(agent.provider);
+                    (dependencies.probe ?? inspectProvider)(agent.provider, agent.providerPath);
+                    await storeAgent(agent, dependencies.home);
+                    const service = await (dependencies.install ??
+                        ((config) => installAgentService(config, { home: dependencies.home })))(agent);
+                    emit(`Repaired ${redactAgentOutput(agent.name)} (${agent.agentId}).${service.started ? "" : " Start talentos agent serve in the foreground."}`);
+                }
+                catch (error) {
+                    failed++;
+                    const reason = error instanceof Error
+                        ? error.message
+                        : "Check the provider installation and login.";
+                    warn(redactAgentOutput(`Could not repair ${agent.name} (${agent.agentId}): ${reason}`, [agent.apiKey]));
+                }
+            }
+            if (failed) {
+                throw new Error(`${failed} agent${failed === 1 ? "" : "s"} could not be repaired. See the messages above.`);
             }
             return;
         }
@@ -81,9 +98,11 @@ export async function installLinkedAgent(parsed, dependencies = {}) {
     const link = parseAgentLink(parsed.options.url ?? "");
     const home = dependencies.home ?? homeDir();
     const linkHash = hashKey(link.token);
+    const providerPath = (dependencies.resolveBinary ?? resolveProviderBinary)(link.provider);
     const savedAgents = await localAgents(home);
     let agent = savedAgents.find((item) => item.linkHash === linkHash && item.provider === link.provider);
     if (agent) {
+        agent.providerPath = providerPath;
         await storeAgent(agent, home);
     }
     else {
@@ -137,7 +156,7 @@ export async function installLinkedAgent(parsed, dependencies = {}) {
                 previousAgentIds: candidates.map((item) => item.agentId),
                 keyHash: hashKey(apiKey),
                 provider: link.provider,
-                providerVersion: (dependencies.probe ?? inspectProvider)(link.provider),
+                providerVersion: (dependencies.probe ?? inspectProvider)(link.provider, providerPath),
                 deviceName: parsed.options.name ?? defaultDeviceName(),
                 os: process.platform,
                 cliVersion: packageVersion(),
@@ -146,6 +165,7 @@ export async function installLinkedAgent(parsed, dependencies = {}) {
             agentId: identity.agentId,
             name: identity.name,
             provider: link.provider,
+            providerPath,
             apiKey,
             apiUrl,
             linkHash,

package/dist/index.js

@@ -3,6 +3,7 @@ import { readFileSync } from "node:fs";
 import { redactAgentOutput } from "./agent-link.js";
 import { parseArgv } from "./args.js";
 import { emit } from "./format.js";
+import { ProviderBinaryError } from "./provider-binary.js";
 const USAGE = `talentos — your team's skills, memory and Talent, from any coding agent.
 
 Usage: talentos <command> [options]
@@ -144,5 +145,5 @@ main(process.argv.slice(2)).catch((error) => {
         }
     });
     process.stderr.write(`${redactAgentOutput(message, fragments).split("\n")[0]}\n`);
-    process.exit(1);
+    process.exit(error instanceof ProviderBinaryError ? error.exitCode : 1);
 });

package/dist/provider-binary.js

@@ -0,0 +1,47 @@
+import { accessSync, constants, statSync } from "node:fs";
+import { delimiter, dirname, isAbsolute, join, resolve } from "node:path";
+import { homeDir } from "./install.js";
+export class ProviderBinaryError extends Error {
+    exitCode = 78;
+}
+export function resolveProviderBinary(provider, configured) {
+    const binary = provider === "claude_code" ? "claude" : "codex";
+    const candidates = configured
+        ? [configured]
+        : (process.env.PATH ?? "")
+            .split(delimiter)
+            .filter(Boolean)
+            .map((directory) => resolve(directory, process.platform === "win32" ? `${binary}.exe` : binary));
+    for (const candidate of candidates) {
+        if (!isAbsolute(candidate)) {
+            continue;
+        }
+        try {
+            accessSync(candidate, constants.X_OK);
+            if (!statSync(candidate).isFile()) {
+                continue;
+            }
+            // Preserve stable provider symlinks; realpaths can point into deleted versions.
+            return candidate;
+        }
+        catch {
+            /* Try the next PATH directory. */
+        }
+    }
+    const label = provider === "claude_code" ? "Claude Code" : "Codex";
+    throw new ProviderBinaryError(`${label} not found at ${configured ?? join(homeDir(), ".local/bin", binary)}; run talentos agent repair`);
+}
+export function providerPathEnv(binary, home = homeDir(), includeRuntimeNode = true) {
+    return [
+        ...new Set([
+            ...(binary ? [dirname(binary)] : []),
+            ...(includeRuntimeNode ? [dirname(process.execPath)] : []),
+            join(home, ".local/bin"),
+            join(home, ".npm-global/bin"),
+            "/opt/homebrew/bin",
+            "/usr/local/bin",
+            "/usr/bin",
+            "/bin",
+        ]),
+    ].join(delimiter);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talentos",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "type": "module",
   "description": "TalentOS CLI: push and pull skills, read and write team memory, and delegate work to your Talent from any coding agent.",
   "repository": {