talentos 0.3.0 → 1.1.0

package/dist/agent-service.js

@@ -0,0 +1,145 @@
+import { spawnSync } from "node:child_process";
+import { chmod, mkdir, open, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { agentLogPath, agentWorkDir, writePrivateFile, } from "./agent-config.js";
+import { homeDir } from "./install.js";
+export function runCommand(command, args) {
+    return (spawnSync(command, args, { stdio: "ignore", timeout: 15_000 }).status ?? 1);
+}
+export async function installAgentService(agent, options = {}) {
+    const home = options.home ?? homeDir();
+    const platform = options.platform ?? process.platform;
+    const run = options.run ?? runCommand;
+    const name = serviceName(agent.agentId);
+    const path = servicePath(agent.agentId, platform, home);
+    const logPath = agentLogPath(agent.agentId, home);
+    await mkdir(agentWorkDir(agent.agentId, home), {
+        recursive: true,
+        mode: 0o700,
+    });
+    const log = await open(logPath, "a", 0o600);
+    await log.close();
+    await chmod(logPath, 0o600);
+    if (!path) {
+        return { path: "", started: false };
+    }
+    const args = [
+        options.nodePath ?? process.execPath,
+        options.cliPath ?? fileURLToPath(new URL("./index.js", import.meta.url)),
+        "agent",
+        "serve",
+        "--agent",
+        agent.agentId,
+    ];
+    const workDir = agentWorkDir(agent.agentId, home);
+    const content = platform === "darwin"
+        ? launchdUnit(name, args, workDir, logPath)
+        : systemdUnit(args, workDir, logPath);
+    const changed = await writePrivateFile(path, content);
+    if (platform === "darwin") {
+        const domain = `gui/${options.uid ?? process.getuid?.() ?? 0}`;
+        const loaded = run("launchctl", ["print", `${domain}/${name}`]) === 0;
+        if (loaded && !changed) {
+            return { path, started: true };
+        }
+        if (loaded) {
+            run("launchctl", ["bootout", domain, path]);
+        }
+        return {
+            path,
+            started: run("launchctl", ["bootstrap", domain, path]) === 0,
+        };
+    }
+    if (changed && run("systemctl", ["--user", "daemon-reload"]) !== 0) {
+        return { path, started: false };
+    }
+    return {
+        path,
+        started: run("systemctl", [
+            "--user",
+            "enable",
+            "--now",
+            `talentos-agent@${agent.agentId}.service`,
+        ]) === 0,
+    };
+}
+export async function uninstallAgentService(agent, options = {}) {
+    const platform = options.platform ?? process.platform;
+    const path = servicePath(agent.agentId, platform, options.home ?? homeDir());
+    if (!path) {
+        return;
+    }
+    const run = options.run ?? runCommand;
+    if (platform === "darwin") {
+        run("launchctl", [
+            "bootout",
+            `gui/${options.uid ?? process.getuid?.() ?? 0}`,
+            path,
+        ]);
+    }
+    else {
+        run("systemctl", [
+            "--user",
+            "disable",
+            "--now",
+            `talentos-agent@${agent.agentId}.service`,
+        ]);
+    }
+    await rm(path, { force: true });
+    if (platform === "linux") {
+        run("systemctl", ["--user", "daemon-reload"]);
+    }
+}
+function serviceName(agentId) {
+    return `so.talentos.agent.${agentId}`;
+}
+function servicePath(agentId, platform, home) {
+    agentWorkDir(agentId, home);
+    if (platform === "darwin") {
+        return join(home, "Library", "LaunchAgents", `${serviceName(agentId)}.plist`);
+    }
+    return platform === "linux"
+        ? join(home, ".config", "systemd", "user", `talentos-agent@${agentId}.service`)
+        : "";
+}
+function launchdUnit(name, args, workDir, logPath) {
+    const xml = (value) => value
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&apos;");
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+<key>Label</key><string>${xml(name)}</string>
+<key>ProgramArguments</key><array>${args.map((arg) => `<string>${xml(arg)}</string>`).join("")}</array>
+<key>WorkingDirectory</key><string>${xml(workDir)}</string>
+<key>EnvironmentVariables</key><dict><key>PATH</key><string>${xml(process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin")}</string></dict>
+<key>RunAtLoad</key><true/><key>KeepAlive</key><true/>
+<key>StandardOutPath</key><string>${xml(logPath)}</string>
+<key>StandardErrorPath</key><string>${xml(logPath)}</string>
+</dict></plist>
+`;
+}
+function systemdUnit(args, workDir, logPath) {
+    const quote = (value) => `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("%", "%%").replaceAll("\n", "\\n").replaceAll("\r", "\\r")}"`;
+    return `[Unit]
+Description=TalentOS agent gateway
+After=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${args.map(quote).join(" ")}
+WorkingDirectory=${quote(workDir)}
+Environment=${quote(`PATH=${process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin"}`)}
+Restart=always
+RestartSec=5
+StandardOutput=${quote(`append:${logPath}`)}
+StandardError=${quote(`append:${logPath}`)}
+
+[Install]
+WantedBy=default.target
+`;
+}

package/dist/args.js

@@ -0,0 +1,52 @@
+import { parseArgs } from "node:util";
+const CLI_OPTIONS = {
+    json: { type: "boolean" },
+    help: { type: "boolean", short: "h" },
+    version: { type: "boolean", short: "v" },
+    key: { type: "string" },
+    "api-url": { type: "string" },
+    name: { type: "string" },
+    out: { type: "string" },
+    to: { type: "string" },
+    id: { type: "string" },
+    mine: { type: "boolean" },
+    company: { type: "boolean" },
+    personal: { type: "boolean" },
+    query: { type: "string", short: "q" },
+    thread: { type: "string" },
+    "no-wait": { type: "boolean" },
+    for: { type: "string" },
+    global: { type: "boolean" },
+    apply: { type: "boolean" },
+    "no-pull": { type: "boolean" },
+    url: { type: "string" },
+    yes: { type: "boolean" },
+    agent: { type: "string" },
+};
+/** Groups whose first positional is a sub-command rather than an argument. */
+const ACTION_GROUPS = new Set(["agent", "mcp", "skills", "memory", "routines"]);
+export function parseArgv(argv) {
+    const { values, positionals } = parse(argv);
+    const group = positionals[0];
+    const hasAction = group !== undefined && ACTION_GROUPS.has(group);
+    const action = hasAction ? positionals[1] : undefined;
+    return {
+        group,
+        action,
+        args: positionals.slice(action === undefined ? 1 : 2),
+        options: values,
+    };
+}
+function parse(argv) {
+    try {
+        return parseArgs({
+            args: argv,
+            options: CLI_OPTIONS,
+            allowPositionals: true,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message.split("\n")[0] : String(error);
+        throw new Error(`${message} Run \`talentos --help\`.`);
+    }
+}

package/dist/client.js

@@ -0,0 +1,87 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { requireCredentials, resolveApiUrl, } from "./config.js";
+const CLIENT_INFO = { name: "talentos-cli", version: "1.0.0" };
+const UNAUTHORIZED_HINT = /\b401\b|unauthoriz/i;
+const UNREACHABLE_HINT = /fetch failed|ECONNREFUSED|ENOTFOUND/i;
+export const UNAUTHORIZED = "Not logged in or key revoked. Run `talentos login`.";
+/** MCP client for the remote TalentOS server, one process-lived connection. */
+export class AgentClient {
+    credentials;
+    client;
+    constructor(credentials) {
+        this.credentials = credentials;
+    }
+    async call(name, args) {
+        const client = await this.connect();
+        const result = (await withFriendlyErrors(() => client.callTool({ name, arguments: args })));
+        const text = firstText(result);
+        if (result.isError) {
+            throw new Error(text || `Tool ${name} failed.`);
+        }
+        return { text, data: result.structuredContent };
+    }
+    async listTools() {
+        const client = await this.connect();
+        return await withFriendlyErrors(() => client.listTools());
+    }
+    async callTool(params) {
+        const client = await this.connect();
+        return (await withFriendlyErrors(() => client.callTool(params)));
+    }
+    async close() {
+        const client = this.client;
+        this.client = undefined;
+        await client?.close();
+    }
+    async connect() {
+        if (this.client) {
+            return this.client;
+        }
+        const client = new Client(CLIENT_INFO, { capabilities: {} });
+        const transport = new StreamableHTTPClientTransport(new URL(`${this.credentials.apiUrl}/mcp`), {
+            requestInit: {
+                headers: { Authorization: `Bearer ${this.credentials.apiKey}` },
+            },
+        });
+        await withFriendlyErrors(() => client.connect(transport));
+        this.client = client;
+        return client;
+    }
+}
+export async function withClient(apiUrlOverride, run) {
+    const credentials = await requireCredentials();
+    const client = new AgentClient({
+        ...credentials,
+        apiUrl: resolveApiUrl(apiUrlOverride, credentials.apiUrl),
+    });
+    try {
+        return await run(client);
+    }
+    finally {
+        await client.close();
+    }
+}
+function firstText(result) {
+    const block = result.content?.[0];
+    return block && block.type === "text" ? block.text : "";
+}
+async function withFriendlyErrors(run) {
+    try {
+        return await run();
+    }
+    catch (error) {
+        throw new Error(describe(error));
+    }
+}
+function describe(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const code = error?.code;
+    if (code === 401 || UNAUTHORIZED_HINT.test(message)) {
+        return UNAUTHORIZED;
+    }
+    if (UNREACHABLE_HINT.test(message)) {
+        return "Cannot reach TalentOS. Check your connection or --api-url.";
+    }
+    return message;
+}

package/dist/commands/agent-serve.js

@@ -0,0 +1,42 @@
+import { spawn } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { childEnvironment, verifyClaudeCode } from "../agent/adapters.js";
+import { serveAgent } from "../agent/serve.js";
+import { agentWorkDir, localAgents } from "../agent-config.js";
+export async function runAgentServe(parsed) {
+    const id = parsed.options.agent;
+    const agents = await localAgents();
+    let config = agents.find((agent) => agent.agentId === id);
+    if (!id && agents.length === 1) {
+        config = agents[0];
+    }
+    if (!config) {
+        throw new Error("Choose a linked agent with `talentos agent serve --agent <id>`.");
+    }
+    if (config.provider === "claude_code") {
+        await verifyClaudeCode();
+    }
+    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 {
+        const updated = await serveAgent(config, dirname(agentWorkDir(config.agentId)), version, stop.signal);
+        if (updated && !stop.signal.aborted) {
+            await new Promise((resolve, reject) => {
+                const child = spawn(process.execPath, [updated, "agent", "serve", "--agent", config.agentId], { env: childEnvironment(), stdio: "inherit", signal: stop.signal });
+                child.once("error", () => reject(new Error("Updated gateway could not start.")));
+                child.once("close", (code) => {
+                    process.exitCode = code ?? 1;
+                    resolve();
+                });
+            });
+        }
+    }
+    finally {
+        process.removeListener("SIGTERM", abort);
+        process.removeListener("SIGINT", abort);
+    }
+}

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/commands/ask.js

@@ -0,0 +1,74 @@
+import { withClient } from "../client.js";
+import { dim, emit, emitJson, emitLink } from "../format.js";
+const POLL_INTERVAL_MS = 2000;
+const MAX_WAIT_MS = 10 * 60 * 1000;
+// The two non-terminal webChannelMessages statuses; anything else means the
+// Talent is done with that message.
+const IN_FLIGHT_STATUSES = new Set(["queued", "claimed"]);
+export function isTerminalStatus(status) {
+    return !IN_FLIGHT_STATUSES.has(status);
+}
+export function replyAfter(messages, messageId) {
+    const index = messages.findIndex((message) => message.id === messageId);
+    const candidates = messages
+        .slice(index + 1)
+        .filter((message) => message.role === "talent");
+    return candidates.at(-1);
+}
+export async function runAsk(parsed) {
+    const message = parsed.args.join(" ").trim();
+    if (message === "") {
+        throw new Error('Usage: talentos ask "<message>" [--thread <id>] [--no-wait]');
+    }
+    await withClient(parsed.options["api-url"], async (client) => {
+        const { data } = await client.call("ask_talent", {
+            message,
+            ...(parsed.options.thread ? { threadId: parsed.options.thread } : {}),
+        });
+        const json = parsed.options.json === true;
+        if (parsed.options["no-wait"]) {
+            reportHandoff(data.threadId, json, data.url);
+            return;
+        }
+        emit(dim(`Asked your Talent. Thread ${data.threadId}`));
+        const reply = await waitForReply(client, data.threadId, data.messageId);
+        if (!reply) {
+            reportHandoff(data.threadId, json, data.url);
+            return;
+        }
+        if (json) {
+            emitJson({ threadId: data.threadId, message: reply });
+            return;
+        }
+        emit(reply.body);
+        emitLink(data.url);
+    });
+}
+async function waitForReply(client, threadId, messageId) {
+    const deadline = Date.now() + MAX_WAIT_MS;
+    while (Date.now() < deadline) {
+        await sleep(POLL_INTERVAL_MS);
+        const { data } = await client.call("get_thread", { threadId });
+        const reply = replyAfter(data.messages, messageId);
+        if (reply && isTerminalStatus(reply.status)) {
+            return reply;
+        }
+        if (!data.active && reply) {
+            return reply;
+        }
+    }
+    return;
+}
+function reportHandoff(threadId, json, url) {
+    if (json) {
+        emitJson({ threadId });
+        return;
+    }
+    emit(`Your Talent is still working. Open thread ${threadId} in TalentOS for the reply, or keep the conversation going with \`talentos ask "<message>" --thread ${threadId}\`.`);
+    emitLink(url);
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}