talentos 1.0.0 → 1.1.0

package/dist/commands/agent.js

@@ -0,0 +1,234 @@
+import { readFileSync } from "node:fs";
+import { chmod, mkdir, open, readFile, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { agentConfigPath, agentLogPath, agentsDir, agentWorkDir, isMissing, localAgents, storeAgent, writePrivateFile, } from "../agent-config.js";
+import { AgentHttpError, fetchAgentStatus, inspectProvider, redeemAgent, setupApiOrigin, unlinkRemoteAgent, waitForHeartbeat, } from "../agent-http.js";
+import { parseAgentLink, redactAgentOutput } from "../agent-link.js";
+import { installAgentService, uninstallAgentService, } from "../agent-service.js";
+import { emit, emitJson, renderTable, warn } from "../format.js";
+import { homeDir } from "../install.js";
+import { defaultDeviceName, hashKey, mintKey } from "../login.js";
+export async function runAgent(parsed) {
+    switch (parsed.action) {
+        case "link": {
+            if (!(parsed.options.yes || (await approveInstall()))) {
+                throw new Error("Link cancelled. Re-run with --yes after approving the user service installation.");
+            }
+            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}`);
+            }
+            const status = await waitForHeartbeat(agent);
+            if (!status) {
+                throw new Error(`Still waiting for agent service (${agent.agentId}). Check talentos agent logs or start talentos agent serve --agent ${agent.agentId}; then run talentos agent status.`);
+            }
+            emit(`Connected as ${redactAgentOutput(status.name)}.`);
+            return;
+        }
+        case "serve": {
+            let command;
+            try {
+                // S6 supplies this module; S3 can install the service before it ships.
+                command = await import(new URL("./agent-serve.js", import.meta.url).href);
+            }
+            catch {
+                throw new Error("Waiting for agent service: this CLI release does not include the gateway yet. Install the published S6 release, then re-run agent link.");
+            }
+            return await command.runAgentServe(parsed);
+        }
+        case "status":
+        case "list":
+            return await showAgents(parsed);
+        case "unlink":
+            return await unlinkLocal(parsed);
+        case "logs":
+            return await showLogs(parsed);
+        default:
+            throw new Error("Use talentos agent link | status | list | unlink | logs.");
+    }
+}
+export async function installLinkedAgent(parsed, dependencies = {}) {
+    if (Number(process.versions.node.split(".")[0]) < 20) {
+        throw new Error("Agent linking requires Node.js 20 or newer.");
+    }
+    const link = parseAgentLink(parsed.options.url ?? "");
+    const home = dependencies.home ?? homeDir();
+    const linkHash = hashKey(link.token);
+    let agent = (await localAgents(home)).find((item) => item.linkHash === linkHash && item.provider === link.provider);
+    if (agent) {
+        await storeAgent(agent, home);
+    }
+    else {
+        const apiUrl = await setupApiOrigin(link, parsed.options["api-url"] ?? process.env.TALENTOS_API_URL);
+        const pendingPath = join(agentsDir(home), `.pending-${linkHash}.json`);
+        let apiKey;
+        let recovered;
+        try {
+            const pending = JSON.parse(await readFile(pendingPath, "utf8"));
+            if (!pending ||
+                typeof pending !== "object" ||
+                !("apiKey" in pending &&
+                    "apiUrl" in pending &&
+                    "provider" in pending) ||
+                typeof pending.apiKey !== "string" ||
+                !pending.apiKey.startsWith("tos_") ||
+                pending.apiUrl !== apiUrl ||
+                pending.provider !== link.provider) {
+                throw new Error("The pending agent link is invalid. Ask for a fresh setup prompt.");
+            }
+            apiKey = pending.apiKey;
+            try {
+                recovered = await fetchAgentStatus({
+                    apiKey,
+                    apiUrl,
+                    provider: link.provider,
+                });
+            }
+            catch (error) {
+                if (!(error instanceof AgentHttpError && error.status === 401)) {
+                    throw error;
+                }
+            }
+        }
+        catch (error) {
+            if (!isMissing(error)) {
+                throw error;
+            }
+            apiKey = mintKey().rawKey;
+            await mkdir(agentsDir(home), { recursive: true, mode: 0o700 });
+            await chmod(agentsDir(home), 0o700);
+            await writePrivateFile(pendingPath, `${JSON.stringify({ apiKey, apiUrl, provider: link.provider })}\n`);
+        }
+        const identity = recovered ??
+            (await redeemAgent(apiUrl, {
+                token: link.token,
+                keyHash: hashKey(apiKey),
+                provider: link.provider,
+                providerVersion: (dependencies.probe ?? inspectProvider)(link.provider),
+                deviceName: parsed.options.name ?? defaultDeviceName(),
+                os: process.platform,
+                cliVersion: packageVersion(),
+            }));
+        agent = {
+            agentId: identity.agentId,
+            name: identity.name,
+            provider: link.provider,
+            apiKey,
+            apiUrl,
+            linkHash,
+            linkedAt: Date.now(),
+        };
+        await storeAgent(agent, home);
+        await rm(pendingPath, { force: true });
+    }
+    const service = await (dependencies.install ?? ((config) => installAgentService(config, { home })))(agent);
+    return { agent, service };
+}
+async function showAgents(parsed) {
+    const agents = await selectAgents(parsed);
+    const rows = [];
+    for (const agent of agents) {
+        try {
+            const status = await fetchAgentStatus(agent);
+            rows.push({
+                agentId: status.agentId,
+                name: redactAgentOutput(status.name),
+                provider: status.provider,
+                state: status.presence,
+                lastSeenAt: status.lastSeenAt,
+            });
+        }
+        catch (error) {
+            rows.push({
+                agentId: agent.agentId,
+                name: redactAgentOutput(agent.name),
+                provider: agent.provider,
+                state: error instanceof AgentHttpError && error.status === 401
+                    ? "disconnected"
+                    : "unreachable",
+                lastSeenAt: null,
+            });
+        }
+    }
+    if (parsed.options.json) {
+        emitJson(rows);
+    }
+    else {
+        emit(rows.length
+            ? renderTable(["Agent", "Provider", "Status", "ID"], rows.map((row) => [row.name, row.provider, row.state, row.agentId]))
+            : "No agents linked on this machine. Get a setup prompt from TalentOS.");
+    }
+}
+async function unlinkLocal(parsed) {
+    const agents = await selectAgents(parsed, true);
+    const agent = agents[0];
+    if (!agent) {
+        emit("Already unlinked on this machine.");
+        return;
+    }
+    const revoked = await unlinkRemoteAgent(agent);
+    await uninstallAgentService(agent);
+    await rm(agentConfigPath(agent.agentId), { force: true });
+    emit(`Unlinked ${redactAgentOutput(agent.name)} on this machine.`);
+    emit(redactAgentOutput(`Kept work folder ${agentWorkDir(agent.agentId)} and gateway log ${agentLogPath(agent.agentId)}.`));
+    if (!revoked) {
+        warn("The server could not confirm revocation. Disconnect the agent in TalentOS to confirm remote removal.");
+    }
+}
+async function showLogs(parsed) {
+    const agent = (await selectAgents(parsed, true))[0];
+    if (!agent) {
+        emit("No linked agent logs on this machine.");
+        return;
+    }
+    let log;
+    try {
+        log = await open(agentLogPath(agent.agentId), "r");
+    }
+    catch (error) {
+        if (isMissing(error)) {
+            emit("Waiting for agent service; no logs yet.");
+            return;
+        }
+        throw error;
+    }
+    try {
+        const size = (await log.stat()).size;
+        const buffer = Buffer.alloc(Math.min(size, 64 * 1024));
+        await log.read(buffer, 0, buffer.length, Math.max(0, size - buffer.length));
+        emit(redactAgentOutput(buffer.toString("utf8"), [agent.apiKey]));
+    }
+    finally {
+        await log.close();
+    }
+}
+async function selectAgents(parsed, single = false) {
+    const selector = parsed.options.agent ?? parsed.args[0];
+    const agents = (await localAgents()).filter((agent) => !selector || agent.agentId === selector || agent.name === selector);
+    if (single && agents.length > 1) {
+        throw new Error("Several agents are linked. Select one by name or --agent <id>.");
+    }
+    return agents;
+}
+async function approveInstall() {
+    if (!process.stdin.isTTY) {
+        return false;
+    }
+    const prompt = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        return ((await prompt.question("Install a TalentOS user service on this machine? [y/N] "))
+            .trim()
+            .toLowerCase() === "y");
+    }
+    finally {
+        prompt.close();
+    }
+}
+function packageVersion() {
+    return JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8")).version;
+}

package/dist/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { readFileSync } from "node:fs";
+import { redactAgentOutput } from "./agent-link.js";
 import { parseArgv } from "./args.js";
 import { emit } from "./format.js";
 const USAGE = `talentos — your team's skills, memory and Talent, from any coding agent.
@@ -8,6 +9,7 @@ Usage: talentos <command> [options]
 
 Commands:
   init                                    Connect this machine's agents to TalentOS
+  agent <link|status|list|unlink|logs>      Bring your own agent into Rooms
   login                                   Authorize this machine
   logout                                  Forget the key stored on this machine
   whoami                                  Show the member and org this key acts as
@@ -26,6 +28,16 @@ Options:
 
 Run \`talentos <command> --help\` for command options.`;
 const GROUP_USAGE = {
+    agent: `talentos agent link --url <setup-url-with-#token> [--yes] [--name <device>]
+talentos agent status | list [--json] [--agent <id>]
+talentos agent unlink [name] [--agent <id>]
+talentos agent logs [--agent <id>]
+talentos agent serve --agent <id>
+
+The link command checks the provider's CLI login, mints the key locally, and
+installs one user service per agent. Only the key hash is sent to redeem.
+Config is private under ~/.talentos/agents. Never print the setup fragment.
+Serve is supplied by the S6 gateway release; Connected requires its heartbeat.`,
     init: `talentos init [--for claude|cursor|codex|all] [--no-pull] [--name <device>]
 
 One command: signs you in (skipped when your stored key still works), writes the
@@ -88,6 +100,8 @@ function helpFor(group) {
 }
 async function dispatch(parsed) {
     switch (parsed.group) {
+        case "agent":
+            return await (await import("./commands/agent.js")).runAgent(parsed);
         case "init":
             return await (await import("./commands/init.js")).runInit(parsed);
         case "login":
@@ -120,6 +134,14 @@ function version() {
 }
 main(process.argv.slice(2)).catch((error) => {
     const message = error instanceof Error ? error.message : String(error);
-    process.stderr.write(`${message.split("\n")[0]}\n`);
+    const fragments = process.argv.flatMap((arg) => {
+        try {
+            return new URLSearchParams(new URL(arg).hash.slice(1)).getAll("token");
+        }
+        catch {
+            return [];
+        }
+    });
+    process.stderr.write(`${redactAgentOutput(message, fragments).split("\n")[0]}\n`);
     process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talentos",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "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": {
@@ -25,6 +25,7 @@
     "prepack": "rm -rf dist && tsc -p tsconfig.build.json"
   },
   "dependencies": {
+    "convex": "^1.43.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "zod": "^4.4.3"
   },