talentos 1.0.0 → 1.1.1

package/dist/agent-service.js

@@ -0,0 +1,152 @@
+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 { 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 = [
+        gatewayLauncherPath(home),
+        "agent",
+        "serve",
+        "--agent",
+        agent.agentId,
+    ];
+    const workDir = agentWorkDir(agent.agentId, home);
+    const content = platform === "darwin"
+        ? launchdUnit(name, args, workDir, logPath, servicePathEnv(home))
+        : systemdUnit(args, workDir, logPath, servicePathEnv(home));
+    const changed = await writePrivateFile(path, content);
+    if (options.reload === false) {
+        if (platform === "linux" && changed) {
+            run("systemctl", ["--user", "daemon-reload"]);
+        }
+        return { path, started: true };
+    }
+    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, pathEnv) {
+    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(pathEnv)}</string></dict>
+<key>ThrottleInterval</key><integer>60</integer>
+<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, pathEnv) {
+    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=${pathEnv}`)}
+Restart=always
+RestartSec=60
+RestartPreventExitStatus=78
+StandardOutput=${quote(`append:${logPath}`)}
+StandardError=${quote(`append:${logPath}`)}
+
+[Install]
+WantedBy=default.target
+`;
+}

package/dist/args.js

@@ -19,9 +19,12 @@ const CLI_OPTIONS = {
     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(["mcp", "skills", "memory", "routines"]);
+const ACTION_GROUPS = new Set(["agent", "mcp", "skills", "memory", "routines"]);
 export function parseArgv(argv) {
     const { values, positionals } = parse(argv);
     const group = positionals[0];

package/dist/commands/agent-serve.js

@@ -0,0 +1,45 @@
+import { readFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { verifyClaudeCode, verifyCodex } from "../agent/adapters.js";
+import { serveAgent } from "../agent/serve.js";
+import { agentWorkDir, localAgents } from "../agent-config.js";
+import { installAgentService } from "../agent-service.js";
+import { installSharedGateway } from "../gateway-install.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>`.");
+    }
+    try {
+        if (process.platform !== "win32") {
+            await installSharedGateway();
+        }
+        await installAgentService(config, { 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 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);
+    }
+    finally {
+        process.removeListener("SIGTERM", abort);
+        process.removeListener("SIGINT", abort);
+    }
+}

package/dist/commands/agent.js

@@ -0,0 +1,278 @@
+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 { installSharedGateway } from "../gateway-install.js";
+import { homeDir } from "../install.js";
+import { defaultDeviceName, hashKey, mintKey } from "../login.js";
+const MAX_PREVIOUS_AGENT_IDS = 100;
+export async function runAgent(parsed, dependencies = {}) {
+    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 "repair": {
+            if (process.platform === "win32") {
+                throw new Error("Windows agents run in the foreground. Use talentos agent serve.");
+            }
+            const agents = await selectAgents(parsed, false, dependencies.home);
+            if (!agents.length) {
+                throw new Error("No linked agent matches. Run talentos agent list.");
+            }
+            await installSharedGateway({
+                home: dependencies.home,
+                source: dependencies.gatewaySource,
+            });
+            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."}`);
+            }
+            return;
+        }
+        case "mcp": {
+            await import("../agent/mcp-entry.js");
+            return;
+        }
+        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 | repair | 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);
+    const savedAgents = await localAgents(home);
+    let agent = savedAgents.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 candidates = savedAgents
+            .filter((item) => item.provider === link.provider && item.apiUrl === apiUrl)
+            .sort((a, b) => b.linkedAt - a.linkedAt)
+            .slice(0, MAX_PREVIOUS_AGENT_IDS);
+        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,
+                previousAgentIds: candidates.map((item) => item.agentId),
+                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);
+        for (const old of candidates) {
+            if (old.agentId !== agent.agentId &&
+                identity.retiredAgentIds?.includes(old.agentId)) {
+                await uninstallAgentService(old, { home });
+                await rm(agentConfigPath(old.agentId, home), { force: true });
+            }
+        }
+        await rm(pendingPath, { force: true });
+    }
+    const service = await (dependencies.install ??
+        (async (config) => {
+            if (process.platform !== "win32") {
+                await installSharedGateway({ home });
+            }
+            return await 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, home) {
+    const selector = parsed.options.agent ?? parsed.args[0];
+    const agents = (await localAgents(home)).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;
+}