talentos 1.0.0 → 1.1.1

package/README.md

@@ -17,6 +17,9 @@ same server over stdio for clients that cannot speak streamable HTTP.
 Every command below pins `talentos@1`, the major that speaks the hosted MCP endpoint.
 The `0.x` releases are the retired stdio wrapper and no longer work.
 
+Release 1.1.0 includes Rooms agent linking, the gateway, and the `create_deck`
+MCP permission. `talentos@1` picks it up automatically after publication.
+
 ```bash
 npx talentos@1 init
 ```
@@ -77,6 +80,34 @@ before it is sent, and stored only once TalentOS accepts it.
 
 ## Commands
 
+### Agents in Rooms
+
+`talentos agent serve --agent <id>` runs the linked provider in its private
+work folder. It keeps one turn active, resumes the same thread from
+`~/.talentos/agents/<id>/sessions.json`, and posts final text automatically.
+The service heartbeats every 20 seconds and stops the child if its lease is
+lost. A required CLI update installs under the agent directory between turns.
+Signing-key provisioning, real staging latency and provider resume proofs are
+tracked in [Agent access](../../docs/features/agent-access/README.md).
+
+Use the setup prompt from TalentOS to link Claude Code or Codex. The fragment
+token is private; never paste it into logs or commits. Provider CLI login is
+required even when its desktop app is signed in. Approve the user service
+installation interactively or pass `--yes` after approval.
+
+Linking waits for a recent gateway heartbeat before reporting Connected. Real
+provider connection, latency and resume proofs remain staged after publication.
+If the service cannot start, use the printed foreground
+`talentos agent serve --agent <id>` command.
+
+`agent status` and `agent list` show agents linked on this machine. Select one
+with `--agent <id>` for `agent logs` or `agent unlink`. Unlink disconnects the
+agent remotely and removes its local service and configuration.
+
+Re-running the same link repairs the install and reuses its key. Keep the
+private pending receipt if a response is lost; it permits recovery after the
+one-use link has been consumed.
+
 ```
 talentos init [--for claude|cursor|codex|all] [--no-pull] [--name <device>]
 

package/dist/agent/adapters.js

@@ -0,0 +1,363 @@
+import { execFile, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { createInterface } from "node:readline";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { writePrivateFile } from "../agent-config.js";
+import { redactAgentOutput, } from "../agent-link.js";
+import { gatewayLauncherPath } from "../gateway-install.js";
+const CHILD_ENV = [
+    "HOME",
+    "PATH",
+    "USER",
+    "LOGNAME",
+    "LANG",
+    "LC_ALL",
+    "TMPDIR",
+    "TEMP",
+    "TMP",
+    "SystemRoot",
+    "XDG_CONFIG_HOME",
+    "XDG_CACHE_HOME",
+    "CODEX_HOME",
+    "CLAUDE_CONFIG_DIR",
+];
+const CLAUDE_VERSION = /^\d+\.\d+\.\d+/u;
+const CODEX_VERSION = /\b\d+\.\d+\.\d+\b/u;
+const DONT_ASK = /\bdontAsk\b/u;
+// Kept package-local for the published CLI. The launch tests compare both
+// adapters against the server's exported ROOM_AGENT_TOOLS contract.
+const ROOM_TOOLS = [
+    "list_rooms",
+    "read_room",
+    "list_room_files",
+    "read_file",
+    "suggest_change",
+    "create_file",
+    "create_deck",
+    "post_message",
+    "share_link",
+    "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 async function verifyClaudeCode() {
+    const execute = promisify(execFile);
+    const options = {
+        env: childEnvironment(),
+        timeout: 5000,
+        maxBuffer: 256_000,
+    };
+    let version = "unknown";
+    try {
+        const detected = await execute("claude", ["--version"], options);
+        version = CLAUDE_VERSION.exec(detected.stdout.trim())?.[0] ?? "unknown";
+        const help = await execute("claude", ["--help"], options);
+        if (version !== "unknown" && DONT_ASK.test(help.stdout)) {
+            return;
+        }
+    }
+    catch {
+        // Never include provider stderr, which may contain login details.
+    }
+    throw new Error(`Update Claude Code (${version}) to a version that supports --permission-mode dontAsk.`);
+}
+export async function verifyCodex() {
+    const execute = promisify(execFile);
+    const options = {
+        env: childEnvironment(),
+        timeout: 5000,
+        maxBuffer: 256_000,
+    };
+    let version = "unknown";
+    try {
+        const detected = await execute("codex", ["--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);
+            if (![
+                "--json",
+                "--skip-git-repo-check",
+                "--ignore-user-config",
+                "--ignore-rules",
+            ].every((flag) => help.stdout.includes(flag))) {
+                throw new Error("Unsupported Codex flags");
+            }
+        }
+        if (version !== "unknown") {
+            await codexRoomCatalog();
+            return;
+        }
+    }
+    catch {
+        // Provider diagnostics can contain login details.
+    }
+    throw new Error(`Update Codex (${version}) to a version supporting isolated room turns, exec/resume flags and a local model catalog.`);
+}
+async function codexRoomCatalog() {
+    try {
+        const { stdout } = await promisify(execFile)("codex", ["debug", "models", "--bundled"], {
+            env: childEnvironment(),
+            timeout: 5000,
+            maxBuffer: 4_000_000,
+        });
+        const catalog = JSON.parse(stdout);
+        if (!Array.isArray(catalog.models) || catalog.models.length === 0) {
+            throw new Error("Missing model catalog");
+        }
+        const models = catalog.models.map((model) => {
+            if (!model ||
+                typeof model !== "object" ||
+                !("slug" in model) ||
+                !("apply_patch_tool_type" in model)) {
+                throw new Error("Unsupported model catalog");
+            }
+            return {
+                ...model,
+                // apply_patch has no feature toggle: its exposure comes from model
+                // metadata. A local catalog removes it before tool registration.
+                apply_patch_tool_type: null,
+                shell_type: "disabled",
+                experimental_supported_tools: [],
+                // Code-mode-only models route MCP through native execution. Expose
+                // allowed MCP functions directly while native execution stays off.
+                tool_mode: "direct",
+            };
+        });
+        return JSON.stringify({ ...catalog, models });
+    }
+    catch {
+        throw new Error("Update Codex to a version supporting a local room-only model catalog.");
+    }
+}
+export function readProviderEvent(provider, value) {
+    if (!value || typeof value !== "object") {
+        return {};
+    }
+    const event = value;
+    if (provider === "claude_code") {
+        if (event.type === "result") {
+            if (event.is_error) {
+                return { failed: true };
+            }
+            return {
+                ...(typeof event.session_id === "string"
+                    ? { sessionId: event.session_id }
+                    : {}),
+                ...(typeof event.result === "string" ? { text: event.result } : {}),
+            };
+        }
+        const message = event.message;
+        if (event.type === "assistant" &&
+            Array.isArray(message?.content) &&
+            message.content.some((part) => part.type === "tool_use")) {
+            return { status: "Using room tools…" };
+        }
+    }
+    else {
+        if (event.type === "thread.started" &&
+            typeof event.thread_id === "string") {
+            return { sessionId: event.thread_id };
+        }
+        if (event.type === "turn.failed" || event.type === "error") {
+            return { failed: true };
+        }
+        const item = event.item;
+        if (event.type === "item.completed" &&
+            item?.type === "agent_message" &&
+            typeof item.text === "string") {
+            return { text: item.text };
+        }
+        if (event.type === "item.started" && item?.type === "mcp_tool_call") {
+            return { status: "Using room tools…" };
+        }
+    }
+    return {};
+}
+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");
+    let command, args;
+    if (config.provider === "claude_code") {
+        await writePrivateFile(mcpPath, JSON.stringify({
+            mcpServers: {
+                talentos: {
+                    type: "http",
+                    url: new URL("/mcp", config.apiUrl).href,
+                    headers: { Authorization: `Bearer ${config.apiKey}` },
+                },
+            },
+        }));
+        command = "claude";
+        args = [
+            "-p",
+            prompt,
+            "--output-format",
+            "stream-json",
+            "--verbose",
+            "--mcp-config",
+            mcpPath,
+            "--strict-mcp-config",
+            "--append-system-prompt",
+            job.packet.instructions,
+            "--tools",
+            "",
+            "--allowedTools",
+            CLAUDE_TOOLS,
+            "--disallowedTools",
+            "Bash,Agent,Task",
+            "--permission-mode",
+            "dontAsk",
+        ];
+        if (sessionId) {
+            args.push("--resume", sessionId);
+        }
+    }
+    else {
+        command = "codex";
+        const launcher = gatewayLauncherPath();
+        const useLauncher = process.platform !== "win32" && existsSync(launcher);
+        await writePrivateFile(catalogPath, await codexRoomCatalog());
+        // 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 = [
+            "-c",
+            'sandbox_mode="read-only"',
+            "-c",
+            'approval_policy="never"',
+            "-c",
+            "features.shell_tool=false",
+            "-c",
+            "features.unified_exec=false",
+            "-c",
+            'web_search="disabled"',
+            "-c",
+            "features.view_image=false",
+            "-c",
+            "features.image_generation=false",
+            "-c",
+            "features.apps=false",
+            "-c",
+            "features.plugins=false",
+            "-c",
+            "features.multi_agent=false",
+            "-c",
+            "features.skip_host_skill_discovery=true",
+            "-c",
+            "memories.use_memories=false",
+            "-c",
+            "memories.generate_memories=false",
+            "-c",
+            `model_catalog_json=${JSON.stringify(catalogPath)}`,
+            "-c",
+            `mcp_servers.talentos.enabled_tools=${JSON.stringify(ROOM_TOOLS)}`,
+            "-c",
+            `mcp_servers.talentos.command=${JSON.stringify(useLauncher ? launcher : process.execPath)}`,
+            "-c",
+            `mcp_servers.talentos.args=${JSON.stringify([...(useLauncher ? [] : [fileURLToPath(new URL("../index.js", import.meta.url))]), "agent", "mcp", "--agent", config.agentId])}`,
+            "exec",
+        ];
+        if (sessionId) {
+            args.push("resume", sessionId);
+        }
+        args.push("--json", "--skip-git-repo-check", "--ignore-user-config", "--ignore-rules", prompt);
+    }
+    const child = spawn(command, args, {
+        cwd: workDir,
+        env: childEnvironment(),
+        stdio: ["ignore", "pipe", "ignore"],
+        detached: process.platform !== "win32",
+    });
+    let killTimer;
+    const stop = () => {
+        const pid = child.pid;
+        if (!pid || child.exitCode !== null || child.signalCode !== null) {
+            return;
+        }
+        const kill = (signal) => {
+            try {
+                if (process.platform === "win32") {
+                    child.kill(signal);
+                }
+                else {
+                    process.kill(-pid, signal);
+                }
+            }
+            catch {
+                /* The process group may have already exited. */
+            }
+        };
+        kill("SIGTERM");
+        killTimer ??= setTimeout(() => kill("SIGKILL"), 5000);
+    };
+    const ended = new Promise((resolve) => {
+        child.once("error", () => resolve(null));
+        child.once("close", resolve);
+    });
+    signal.addEventListener("abort", stop, { once: true });
+    if (signal.aborted) {
+        stop();
+    }
+    try {
+        let text = "", failed = false, sawResult = false;
+        if (!child.stdout) {
+            throw new Error("Provider output is unavailable.");
+        }
+        const lines = createInterface({ input: child.stdout });
+        for await (const line of lines) {
+            if (line.length > 1_000_000) {
+                throw new Error("Provider output exceeded its limit.");
+            }
+            let value;
+            try {
+                value = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            const event = readProviderEvent(config.provider, value);
+            if (event.failed) {
+                failed = true;
+            }
+            if (event.sessionId) {
+                await input.remember(event.sessionId);
+            }
+            if (event.status) {
+                input.status(event.status);
+            }
+            if (event.text !== undefined) {
+                text = event.text.slice(0, 12_000);
+            }
+            const type = value?.type;
+            if (type === "result" || type === "turn.completed") {
+                sawResult = true;
+            }
+        }
+        const code = await ended;
+        if (code !== 0 || failed || !sawResult || signal.aborted) {
+            throw new Error("Provider could not finish this turn. Check its login and quota.");
+        }
+        return { text: redactAgentOutput(text, [config.apiKey]) };
+    }
+    finally {
+        signal.removeEventListener("abort", stop);
+        stop();
+        await ended;
+        if (killTimer) {
+            clearTimeout(killTimer);
+        }
+        await rm(mcpPath, { force: true });
+        await rm(catalogPath, { force: true });
+    }
+}

package/dist/agent/gateway.js

@@ -0,0 +1,70 @@
+import { ConvexClient } from "convex/browser";
+import { makeFunctionReference } from "convex/server";
+import { isSecureUrl } from "../agent-link.js";
+export class GatewayError extends Error {
+    status;
+    constructor(status) {
+        super(status === 401 || status === 409
+            ? "Agent is no longer available. Re-link it from TalentOS."
+            : "Agent gateway request failed; retrying.");
+        this.status = status;
+    }
+}
+export class AgentGateway {
+    config;
+    constructor(config) {
+        if (!isSecureUrl(new URL(config.apiUrl))) {
+            throw new Error("Agent gateway needs HTTPS or localhost.");
+        }
+        this.config = config;
+    }
+    async request(path, body = {}, signal) {
+        const response = await fetch(new URL(path, this.config.apiUrl), {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.config.apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(body),
+            signal: signal
+                ? AbortSignal.any([signal, AbortSignal.timeout(15_000)])
+                : AbortSignal.timeout(15_000),
+            redirect: "error",
+        });
+        if (!response.ok) {
+            throw new GatewayError(response.status);
+        }
+        return response.status === 204 ? null : (await response.json());
+    }
+    async subscribe(wake, fallback) {
+        const initial = await this.request("/agent-gateway/token");
+        if (!(initial && isSecureUrl(new URL(initial.convexUrl)))) {
+            throw new Error("Agent push is unavailable.");
+        }
+        const client = new ConvexClient(initial.convexUrl, { logger: false });
+        let cached = initial;
+        client.setAuth(async ({ forceRefreshToken }) => {
+            if (forceRefreshToken || cached.expiresAt - Date.now() < 60_000) {
+                const renewed = await this.request("/agent-gateway/token");
+                if (!renewed) {
+                    return null;
+                }
+                cached = renewed;
+            }
+            return cached.token;
+        }, (authenticated) => {
+            if (!authenticated) {
+                fallback();
+            }
+        });
+        const unsubscribe = client.onUpdate(makeFunctionReference("externalAgents/jobs:pendingForAgent"), {}, (count) => {
+            if (count > 0) {
+                wake();
+            }
+        }, () => fallback());
+        return async () => {
+            unsubscribe();
+            await client.close();
+        };
+    }
+}

package/dist/agent/mcp-entry.js

@@ -0,0 +1,11 @@
+import { localAgents } from "../agent-config.js";
+import { parseArgv } from "../args.js";
+import { AgentClient } from "../client.js";
+import { startMcpProxy } from "../mcp-proxy.js";
+// A local stdio entry avoids putting the bearer key in Codex's argv or child
+// environment. Only the MCP proxy reads the linked-agent credential file.
+const config = (await localAgents()).find((agent) => agent.agentId === parseArgv(process.argv.slice(2)).options.agent);
+if (!config) {
+    throw new Error("Linked agent configuration is unavailable.");
+}
+await startMcpProxy(new AgentClient({ apiUrl: config.apiUrl, apiKey: config.apiKey }));