@quadient/skillshare 1.9.0 → 1.10.0

package/README.md

@@ -21,12 +21,17 @@ bun run index.ts install --skill-version-id 42 --target ./installed
 
 ## Connected agents
 
-`skillshare agents listen` lets Skillshare run Claude Code (`claude`) or Codex (`codex`) tasks
-on this computer. The listener reports the installed agents with their models and reasoning
-levels. Choose which computer and configuration runs each kind of task under **Connected
-agents** in Skillshare. Agents run with your full local permissions and configuration,
+`skillshare agents listen` lets Skillshare run Claude Code (`claude`) or Codex (`codex`) sessions
+on this computer. Start a session under **Sessions** in Skillshare and keep talking to the agent
+there; Teams 👀 sessions go to the computer chosen under **Connected agents**. The listener
+reports the installed agents with their models and reasoning levels. Agents use the login you
+already have in `claude` and `codex`, and run with your full local permissions and configuration,
 without permission prompts.
 
+Codex runs as `codex app-server` and Claude Code with stream-json input and output. The agent
+keeps running between your messages and stops after 15 quiet minutes; the next message resumes
+the same Codex thread or Claude Code session. Sessions need CLI 1.10.0 or newer.
+
 ```sh
 skillshare agents status
 skillshare agents listen --workdir ~/Research
@@ -38,7 +43,8 @@ and use the Skillshare MCP; Codex runs in its read-only sandbox. A profile can d
 with `"sandbox": true`.
 
 Optional named profiles in `~/.config/skillshare/agents.json` set a working directory and
-extra arguments. Only the name, agent, model, reasoning and the working directory's last
+extra arguments. For Claude Code the arguments are added to `claude`; for Codex only
+configuration overrides (`-c`, `--config`, `--enable`, `--disable`) apply to `codex app-server`. Only the name, agent, model, reasoning and the working directory's last
 segment are sent to Skillshare.
 
 ```json
@@ -85,7 +91,7 @@ permissions, Microsoft session lifetime and file-tool differences in the hosted
 
 Starting with 1.9.0:
 
-- `agents listen` and `agents status` run Claude Code and Codex tasks from Skillshare on this computer (see [Connected agents](#connected-agents)); `--sandbox` keeps them read-only.
+- `agents listen` and `agents status` run Claude Code and Codex sessions from Skillshare on this computer (see [Connected agents](#connected-agents)); `--sandbox` keeps them read-only.
 - Commands print readable text. Scripts that parsed JSON from `whoami`, `list`, `show`, `upload`, `pages list|show|runtime|upload` or `teams status|test|upload` must add `--json`; with `--json` progress goes to stderr and stdout contains only JSON.
 - `show` accepts a skill name as well as an id.
 - `pages upload` refuses build output folder names such as `dist` or `build` without `--slug`, says whether it creates or replaces a page, refuses pages owned by someone else unless you are an admin, and prints the page URL.

package/dist/agents-claude.js

@@ -0,0 +1,274 @@
+import { randomUUID } from 'node:crypto';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { startAgentProcess } from './agents-process.js';
+import { CLAUDE_SANDBOX_TOOLS, DEFAULT, SANDBOX_NOTE, clip, isSandboxed, mcpServerName, mcpTokenEnvironment, oneLine, } from './agents-session.js';
+/**
+ * Claude Code in print mode with stream-json in both directions: the same protocol the Agent SDK speaks, but against the
+ * user's own claude install, so their login and settings apply. MCP config and the session's instructions are passed per
+ * process; tokens only through the environment.
+ */
+export function claudeArgs(context, mcpConfigPath) {
+    const { start } = context;
+    const sandbox = isSandboxed(start.configuration, context);
+    const servers = start.mcpServers ?? [];
+    const args = ['-p', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose', '--include-partial-messages',
+        ...(sandbox
+            // A sandboxed session never prompts: anything outside the read-only allowlist is denied.
+            ? ['--permission-mode', 'dontAsk', '--allowedTools', ...CLAUDE_SANDBOX_TOOLS, ...servers.map((server, index) => `mcp__${mcpServerName(server, index)}`)]
+            : ['--dangerously-skip-permissions'])];
+    if (start.configuration.model !== DEFAULT)
+        args.push('--model', start.configuration.model);
+    if (start.configuration.reasoning !== DEFAULT)
+        args.push('--effort', start.configuration.reasoning);
+    if (mcpConfigPath)
+        args.push('--mcp-config', mcpConfigPath);
+    const instructions = [start.instructions?.trim(), sandbox ? SANDBOX_NOTE : undefined].filter(Boolean).join('\n\n');
+    if (instructions)
+        args.push('--append-system-prompt', instructions);
+    if (start.resumeThreadId)
+        args.push('--resume', start.resumeThreadId);
+    return [...args, ...(context.profile?.args ?? [])];
+}
+export function claudeMcpConfig(servers) {
+    return JSON.stringify({
+        mcpServers: Object.fromEntries(servers.map((server, index) => [mcpServerName(server, index),
+            { type: 'http', url: server.url, headers: { Authorization: `Bearer \${SKILLSHARE_MCP_TOKEN_${index}}` } }])),
+    }, null, 2);
+}
+/** A tool call as a transcript entry: shell commands and file edits get their own kinds, everything else is a tool. */
+export function claudeToolItem(block) {
+    const input = block.input ?? {};
+    const name = String(block.name ?? 'tool');
+    const key = String(block.id);
+    const text = (value) => typeof value === 'string' ? value : '';
+    switch (name) {
+        case 'Bash': return { key, kind: 'command', status: 'inProgress', title: oneLine(text(input.command)), detail: text(input.description) || undefined };
+        case 'Edit':
+        case 'MultiEdit':
+        case 'Write':
+            return { key, kind: 'fileChange', status: 'inProgress', title: text(input.file_path) };
+        case 'NotebookEdit': return { key, kind: 'fileChange', status: 'inProgress', title: text(input.notebook_path) };
+        case 'TodoWrite': {
+            const todos = Array.isArray(input.todos) ? input.todos : [];
+            return { key, kind: 'plan', status: 'completed',
+                text: clip(todos.map((todo) => `- [${todo.status === 'completed' ? 'x' : ' '}] ${todo.content ?? ''}`).join('\n')) };
+        }
+        case 'Task':
+        case 'Agent': return { key, kind: 'tool', status: 'inProgress', title: oneLine(`Subagent: ${text(input.description) || text(input.subagent_type)}`) };
+    }
+    const mcp = /^mcp__(.+?)__(.+)$/.exec(name);
+    if (mcp)
+        return { key, kind: 'tool', status: 'inProgress', title: `${mcp[1]} · ${mcp[2]}` };
+    const subject = text(input.file_path) || text(input.pattern) || text(input.url) || text(input.query) || text(input.path);
+    return { key, kind: 'tool', status: 'inProgress', title: oneLine(subject ? `${name} ${subject}` : name) };
+}
+export function createClaudeDriver(options = {}) {
+    return context => new ClaudeDriver(context, options);
+}
+class ClaudeDriver {
+    context;
+    options;
+    process = null;
+    directory = null;
+    sessionId = null;
+    current = null;
+    controls = new Map();
+    /** Text and tool entries by key, so later frames can update an entry the transcript already shows. */
+    items = new Map();
+    blocks = new Map();
+    streamed = new Map();
+    messageId = '';
+    costSoFar = 0;
+    closing = false;
+    constructor(context, options) {
+        this.context = context;
+        this.options = options;
+    }
+    async open() {
+        const servers = this.context.start.mcpServers ?? [];
+        let mcpConfig;
+        if (servers.length > 0) {
+            this.directory = await mkdtemp(join(tmpdir(), 'skillshare-session-'));
+            mcpConfig = join(this.directory, 'mcp.json');
+            await writeFile(mcpConfig, claudeMcpConfig(servers), { mode: 0o600 });
+        }
+        this.process = startAgentProcess({
+            command: this.options.command ?? 'claude',
+            args: claudeArgs(this.context, mcpConfig),
+            cwd: this.context.profile?.workdir ?? this.context.workdir,
+            env: {
+                ...mcpTokenEnvironment(servers), SKILLSHARE_SESSION_ID: this.context.sessionId,
+                // Claude Code lets auto-memory write to its own folder even under the read-only allowlist; a sandboxed session writes nothing.
+                ...(isSandboxed(this.context.start.configuration, this.context) ? { CLAUDE_CODE_DISABLE_AUTO_MEMORY: '1' } : {}),
+            },
+            spawnAgent: this.options.spawnAgent,
+            onLine: line => this.receive(line),
+        });
+        void this.process.exited.then(code => this.onExit(code));
+        // Claude Code answers initialize once it is ready, which turns a bad install or a bad flag into a clear start failure.
+        await this.control({ subtype: 'initialize' });
+        if (this.context.start.resumeThreadId)
+            this.adopt(this.context.start.resumeThreadId);
+    }
+    turn(message) {
+        return new Promise((resolve, reject) => {
+            this.current = { resolve, interrupted: false };
+            const sent = this.process?.write(JSON.stringify({
+                type: 'user', message: { role: 'user', content: message.text }, parent_tool_use_id: null, session_id: this.sessionId ?? '',
+            }));
+            if (!sent) {
+                this.current = null;
+                reject(new Error('Claude Code is not accepting input.'));
+            }
+        });
+    }
+    async interrupt() {
+        if (!this.current)
+            return;
+        this.current.interrupted = true;
+        await this.control({ subtype: 'interrupt' }).catch(() => { });
+    }
+    async close() {
+        this.closing = true;
+        await this.process?.kill();
+        if (this.directory)
+            await rm(this.directory, { recursive: true, force: true }).catch(() => { });
+    }
+    control(request) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            this.controls.set(requestId, { resolve, reject });
+            if (!this.process?.write(JSON.stringify({ type: 'control_request', request_id: requestId, request }))) {
+                this.controls.delete(requestId);
+                reject(new Error('Claude Code is not accepting input.'));
+            }
+        });
+    }
+    adopt(sessionId) {
+        if (sessionId === this.sessionId)
+            return;
+        this.sessionId = sessionId;
+        this.context.thread(sessionId);
+    }
+    emit(item) {
+        this.items.set(item.key, item);
+        this.context.item(item);
+    }
+    receive(line) {
+        let frame;
+        try {
+            frame = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        switch (frame.type) {
+            case 'control_response': {
+                const response = frame.response ?? {};
+                const waiter = this.controls.get(response.request_id);
+                if (!waiter)
+                    return;
+                this.controls.delete(response.request_id);
+                if (response.subtype === 'error')
+                    waiter.reject(new Error(String(response.error ?? 'Claude Code rejected the request.')));
+                else
+                    waiter.resolve(response.response ?? {});
+                return;
+            }
+            case 'control_request':
+                // Permission prompts never reach a session: it runs without prompts or with a read-only allowlist.
+                this.process?.write(JSON.stringify({ type: 'control_response',
+                    response: { subtype: 'error', request_id: frame.request_id, error: 'Skillshare sessions do not answer this request.' } }));
+                return;
+            case 'system':
+                if (frame.subtype === 'init' && typeof frame.session_id === 'string')
+                    this.adopt(frame.session_id);
+                return;
+            case 'stream_event':
+                return this.streamEvent(frame.event ?? {});
+            case 'assistant':
+                return this.assistant(frame.message ?? {});
+            case 'user':
+                return this.toolResults(frame.message?.content);
+            case 'result':
+                return this.result(frame);
+        }
+    }
+    /** Text arrives in deltas first; the complete assistant frame later replaces it under the same key. */
+    streamEvent(event) {
+        if (event.type === 'message_start' && typeof event.message?.id === 'string')
+            this.messageId = event.message.id;
+        if (event.type !== 'content_block_delta' || !this.messageId)
+            return;
+        const delta = event.delta ?? {};
+        const kind = delta.type === 'text_delta' ? 'assistant' : delta.type === 'thinking_delta' ? 'reasoning' : null;
+        if (!kind)
+            return;
+        const key = `${this.messageId}:${event.index}`;
+        const text = (this.streamed.get(key) ?? '') + String(delta.text ?? delta.thinking ?? '');
+        this.streamed.set(key, text);
+        if (text.trim())
+            this.emit({ key, kind, status: 'inProgress', text });
+    }
+    assistant(message) {
+        const id = String(message.id ?? '');
+        for (const block of Array.isArray(message.content) ? message.content : []) {
+            const index = this.blocks.get(id) ?? 0;
+            this.blocks.set(id, index + 1);
+            const key = `${id}:${index}`;
+            if (block.type === 'text' && typeof block.text === 'string')
+                this.emit({ key, kind: 'assistant', status: 'completed', text: block.text });
+            else if (block.type === 'thinking' && typeof block.thinking === 'string' && block.thinking.trim())
+                this.emit({ key, kind: 'reasoning', status: 'completed', text: block.thinking });
+            else if (block.type === 'tool_use' && block.id)
+                this.emit(claudeToolItem(block));
+        }
+    }
+    toolResults(content) {
+        if (!Array.isArray(content))
+            return;
+        for (const block of content) {
+            if (block?.type !== 'tool_result')
+                continue;
+            const item = this.items.get(String(block.tool_use_id));
+            if (item && item.status === 'inProgress')
+                this.emit({ ...item, status: block.is_error ? 'failed' : 'completed' });
+        }
+    }
+    result(frame) {
+        if (typeof frame.session_id === 'string')
+            this.adopt(frame.session_id);
+        const current = this.current;
+        this.current = null;
+        if (!current)
+            return;
+        // Costs are totals for the process; a turn's share is the difference.
+        const cost = typeof frame.total_cost_usd === 'number' ? frame.total_cost_usd : undefined;
+        const turnCost = cost === undefined ? undefined : Math.max(0, cost - this.costSoFar);
+        if (cost !== undefined)
+            this.costSoFar = cost;
+        const usage = frame.usage ?? {};
+        const input = [usage.input_tokens, usage.cache_creation_input_tokens, usage.cache_read_input_tokens].filter((n) => typeof n === 'number');
+        const stats = { costUsd: turnCost, inputTokens: input.length > 0 ? input.reduce((a, b) => a + b, 0) : undefined,
+            outputTokens: typeof usage.output_tokens === 'number' ? usage.output_tokens : undefined };
+        if (frame.subtype === 'success' && frame.is_error !== true)
+            return current.resolve({ status: 'completed', stats });
+        if (current.interrupted)
+            return current.resolve({ status: 'interrupted', stats });
+        const detail = typeof frame.result === 'string' && frame.result ? frame.result
+            : Array.isArray(frame.errors) && frame.errors.length > 0 ? frame.errors.join(' ') : `Claude Code ended the turn with ${frame.subtype ?? 'an error'}.`;
+        current.resolve({ status: 'failed', error: clip(detail, 2000), stats });
+    }
+    onExit(code) {
+        const reason = `Claude Code exited${code === null ? '' : ` with code ${code}`}${this.process?.stderrTail() ? `: ${this.process.stderrTail()}` : '.'}`;
+        for (const waiter of this.controls.values())
+            waiter.reject(new Error(reason));
+        this.controls.clear();
+        this.current?.resolve({ status: 'failed', error: reason });
+        this.current = null;
+        if (!this.closing)
+            this.context.exited(reason);
+    }
+}

package/dist/agents-codex.js

@@ -0,0 +1,276 @@
+import { startAgentProcess } from './agents-process.js';
+import { DEFAULT, SANDBOX_NOTE, clip, isSandboxed, mcpServerName, mcpTokenEnvironment, oneLine, } from './agents-session.js';
+/** Profile arguments that make sense for a long-running app-server; anything else belongs to codex exec only. */
+export function codexConfigArgs(args) {
+    const kept = [];
+    for (let index = 0; index < args.length; index++) {
+        const arg = args[index];
+        if (['-c', '--config', '--enable', '--disable'].includes(arg) && args[index + 1] !== undefined)
+            kept.push(arg, args[++index]);
+        else if (/^(-c|--config|--enable|--disable)=/.test(arg))
+            kept.push(arg);
+    }
+    return kept;
+}
+/** thread/start and thread/resume share these: where to work, what may run, the session's MCP servers and instructions. */
+export function codexThreadParams(context) {
+    const { start } = context;
+    const sandbox = isSandboxed(start.configuration, context);
+    const servers = start.mcpServers ?? [];
+    const instructions = [start.instructions?.trim(), sandbox ? SANDBOX_NOTE : undefined].filter(Boolean).join('\n\n');
+    return {
+        cwd: context.profile?.workdir ?? context.workdir,
+        ...(start.configuration.model !== DEFAULT ? { model: start.configuration.model } : {}),
+        // Nobody watches for approval prompts, so the agent never asks: full access, or a read-only sandbox.
+        approvalPolicy: 'never',
+        sandbox: sandbox ? 'read-only' : 'danger-full-access',
+        ...(instructions ? { developerInstructions: instructions } : {}),
+        config: {
+            'tools.update_plan.enabled': true,
+            ...(servers.length > 0 ? {
+                mcp_servers: Object.fromEntries(servers.map((server, index) => [mcpServerName(server, index), { url: server.url, bearer_token_env_var: `SKILLSHARE_MCP_TOKEN_${index}` }])),
+            } : {}),
+        },
+    };
+}
+/** Codex errors often arrive as the provider's JSON body; the readable part is its message. */
+export function codexErrorText(message) {
+    if (typeof message !== 'string')
+        return undefined;
+    try {
+        const parsed = JSON.parse(message);
+        const nested = parsed?.error?.message ?? parsed?.message;
+        if (typeof nested === 'string' && nested)
+            return nested;
+    }
+    catch { }
+    return message;
+}
+const STATUS = { inProgress: 'inProgress', completed: 'completed', failed: 'failed', declined: 'failed' };
+/** Turns one Codex thread item into a transcript entry; items the user already sees, such as their own message, are skipped. */
+export function codexItem(item) {
+    const key = typeof item?.id === 'string' ? item.id : null;
+    if (!key)
+        return null;
+    const status = STATUS[item.status] ?? undefined;
+    switch (item.type) {
+        case 'agentMessage': return { key, kind: 'assistant', text: String(item.text ?? '') };
+        case 'reasoning': {
+            const summary = Array.isArray(item.summary) ? item.summary.join('\n\n') : '';
+            return summary ? { key, kind: 'reasoning', text: summary } : null;
+        }
+        case 'plan': return { key, kind: 'plan', text: String(item.text ?? '') };
+        case 'commandExecution':
+            return { key, kind: 'command', status, title: oneLine(String(item.command ?? '')),
+                detail: typeof item.exitCode === 'number' && item.exitCode !== 0 ? `exit code ${item.exitCode}` : undefined };
+        case 'fileChange': {
+            const paths = (Array.isArray(item.changes) ? item.changes : []).map((change) => String(change?.path ?? '')).filter(Boolean);
+            return { key, kind: 'fileChange', status, title: paths.slice(0, 5).join(', ') + (paths.length > 5 ? ` and ${paths.length - 5} more` : '') };
+        }
+        case 'mcpToolCall': return { key, kind: 'tool', status, title: `${item.server} · ${item.tool}` };
+        case 'dynamicToolCall': return { key, kind: 'tool', status, title: String(item.tool ?? 'tool') };
+        case 'webSearch': return { key, kind: 'tool', status: 'completed', title: oneLine(`Web search: ${item.query ?? ''}`) };
+        case 'collabAgentToolCall': return { key, kind: 'tool', status, title: `Subagent: ${item.tool}` };
+        case 'imageView': return { key, kind: 'tool', status: 'completed', title: oneLine(`View image ${item.path ?? ''}`) };
+        case 'imageGeneration': return { key, kind: 'tool', status, title: 'Generate image' };
+        case 'contextCompaction': return { key, kind: 'notice', text: 'Context compacted.' };
+        default: return null;
+    }
+}
+/** Codex through `codex app-server`: JSON-RPC over stdio, one app-server process and one thread per session. */
+export function createCodexDriver(options = {}) {
+    return context => new CodexDriver(context, options);
+}
+class CodexDriver {
+    context;
+    options;
+    process = null;
+    nextId = 0;
+    pending = new Map();
+    threadId = null;
+    current = null;
+    texts = new Map();
+    closing = false;
+    constructor(context, options) {
+        this.context = context;
+        this.options = options;
+    }
+    async open() {
+        const { start } = this.context;
+        const servers = start.mcpServers ?? [];
+        this.process = startAgentProcess({
+            command: this.options.command ?? 'codex',
+            args: ['app-server', ...codexConfigArgs(this.context.profile?.args ?? [])],
+            cwd: this.context.profile?.workdir ?? this.context.workdir,
+            env: { ...mcpTokenEnvironment(servers), SKILLSHARE_SESSION_ID: this.context.sessionId },
+            spawnAgent: this.options.spawnAgent,
+            onLine: line => this.receive(line),
+        });
+        void this.process.exited.then(code => this.onExit(code));
+        await this.request('initialize', {
+            clientInfo: { name: 'skillshare', title: 'Skillshare', version: this.options.clientVersion ?? '0.0.0' },
+            // Unified diffs are not shown in the transcript, so Codex need not send them.
+            capabilities: { experimentalApi: true, optOutNotificationMethods: ['turn/diff/updated', 'mcpServer/startupStatus/updated'] },
+        });
+        this.notify('initialized');
+        const params = codexThreadParams(this.context);
+        const result = start.resumeThreadId
+            ? await this.request('thread/resume', { threadId: start.resumeThreadId, ...params })
+            : await this.request('thread/start', params);
+        const threadId = result?.thread?.id;
+        if (typeof threadId !== 'string')
+            throw new Error('Codex did not return a thread.');
+        this.threadId = threadId;
+        this.context.thread(threadId);
+    }
+    turn(message) {
+        const { configuration } = this.context.start;
+        return new Promise((resolve, reject) => {
+            this.current = { resolve, usage: { input: 0, output: 0 } };
+            this.request('turn/start', {
+                threadId: this.threadId, input: [{ type: 'text', text: message.text }],
+                ...(configuration.reasoning !== DEFAULT ? { effort: configuration.reasoning } : {}),
+            }).then(result => {
+                if (this.current && typeof result?.turn?.id === 'string')
+                    this.current.id ??= result.turn.id;
+            }, error => {
+                this.current = null;
+                reject(error);
+            });
+        });
+    }
+    async interrupt() {
+        if (this.current?.id && this.threadId)
+            await this.request('turn/interrupt', { threadId: this.threadId, turnId: this.current.id });
+    }
+    async close() {
+        this.closing = true;
+        await this.process?.kill();
+    }
+    request(method, params) {
+        if (!this.process)
+            return Promise.reject(new Error('Codex is not running.'));
+        const id = ++this.nextId;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            if (!this.process.write(JSON.stringify({ id, method, params }))) {
+                this.pending.delete(id);
+                reject(new Error('Codex is not accepting input.'));
+            }
+        });
+    }
+    notify(method, params) {
+        this.process?.write(JSON.stringify(params === undefined ? { method } : { method, params }));
+    }
+    receive(line) {
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (message.id !== undefined && typeof message.method === 'string')
+            return this.answer(message);
+        if (message.id !== undefined) {
+            const pending = this.pending.get(message.id);
+            if (!pending)
+                return;
+            this.pending.delete(message.id);
+            if (message.error)
+                pending.reject(new Error(codexErrorText(message.error.message) ?? 'Codex rejected the request.'));
+            else
+                pending.resolve(message.result);
+            return;
+        }
+        if (typeof message.method === 'string')
+            this.notification(message.method, message.params ?? {});
+    }
+    /** Codex asks the client only for approvals and input, which a session never gives: the approval policy is never. */
+    answer(message) {
+        const reply = /requestApproval$/.test(message.method) ? { id: message.id, result: { decision: 'decline' } }
+            : { id: message.id, error: { code: -32601, message: 'Skillshare sessions do not answer this request.' } };
+        this.process?.write(JSON.stringify(reply));
+    }
+    notification(method, params) {
+        // Subagent threads report on the same connection; only the session's own thread is transcribed.
+        if (typeof params.threadId === 'string' && this.threadId && params.threadId !== this.threadId)
+            return;
+        switch (method) {
+            case 'item/started':
+            case 'item/completed': {
+                const item = codexItem(params.item);
+                if (!item)
+                    return;
+                if (item.kind === 'assistant' || item.kind === 'reasoning') {
+                    if (method === 'item/completed' || item.text)
+                        this.texts.set(item.key, item.text ?? '');
+                    else
+                        item.text = this.texts.get(item.key) ?? '';
+                    item.status = method === 'item/completed' ? 'completed' : 'inProgress';
+                }
+                this.context.item(item);
+                return;
+            }
+            case 'item/agentMessage/delta':
+            case 'item/reasoning/summaryTextDelta': {
+                const key = String(params.itemId ?? '');
+                if (!key)
+                    return;
+                const text = (this.texts.get(key) ?? '') + String(params.delta ?? '');
+                this.texts.set(key, text);
+                this.context.item({ key, kind: method === 'item/agentMessage/delta' ? 'assistant' : 'reasoning', status: 'inProgress', text });
+                return;
+            }
+            case 'turn/plan/updated': {
+                const steps = Array.isArray(params.plan) ? params.plan : [];
+                const text = steps.map((step) => `- [${step.status === 'completed' ? 'x' : ' '}] ${step.step ?? ''}`).join('\n');
+                if (text && params.turnId)
+                    this.context.item({ key: `plan-${params.turnId}`, kind: 'plan', text: clip(text) });
+                return;
+            }
+            case 'thread/tokenUsage/updated': {
+                // total covers the whole thread, including turns from before a resume; last is one model request, so a turn adds them up.
+                const last = params.tokenUsage?.last;
+                if (last && this.current) {
+                    this.current.usage.input += Number(last.inputTokens) || 0;
+                    this.current.usage.output += Number(last.outputTokens) || 0;
+                }
+                return;
+            }
+            case 'error': {
+                const text = codexErrorText(params.error?.message);
+                if (this.current && text)
+                    this.current.error = text;
+                return;
+            }
+            case 'turn/started':
+                if (this.current && typeof params.turn?.id === 'string')
+                    this.current.id ??= params.turn.id;
+                return;
+            case 'turn/completed': {
+                const turn = params.turn ?? {};
+                const current = this.current;
+                if (!current || current.id && turn.id && turn.id !== current.id)
+                    return;
+                this.current = null;
+                const status = turn.status === 'completed' ? 'completed' : turn.status === 'interrupted' ? 'interrupted' : 'failed';
+                const stats = { inputTokens: current.usage.input, outputTokens: current.usage.output };
+                current.resolve(status === 'failed'
+                    ? { status, error: codexErrorText(turn.error?.message) ?? current.error ?? 'The turn failed.', stats }
+                    : { status, stats });
+                return;
+            }
+        }
+    }
+    onExit(code) {
+        const reason = `Codex exited${code === null ? '' : ` with code ${code}`}${this.process?.stderrTail() ? `: ${this.process.stderrTail()}` : '.'}`;
+        for (const pending of this.pending.values())
+            pending.reject(new Error(reason));
+        this.pending.clear();
+        this.current?.resolve({ status: 'failed', error: reason });
+        this.current = null;
+        if (!this.closing)
+            this.context.exited(reason);
+    }
+}

package/dist/agents-process.js

@@ -0,0 +1,50 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+/**
+ * Starts an agent that speaks newline-delimited JSON on stdio. Tokens go through the environment only. A separate
+ * process group lets stopping the agent also stop the shell commands it runs.
+ */
+export function startAgentProcess(options) {
+    const posix = process.platform !== 'win32';
+    const child = (options.spawnAgent ?? spawn)(options.command, options.args, {
+        cwd: options.cwd, env: { ...process.env, ...options.env }, stdio: ['pipe', 'pipe', 'pipe'],
+        detached: posix, windowsHide: true, shell: !posix,
+    });
+    let stderr = '';
+    child.stderr?.on('data', chunk => { stderr = (stderr + chunk).slice(-4000); });
+    child.stdin?.on('error', () => { });
+    if (child.stdout)
+        createInterface({ input: child.stdout, crlfDelay: Infinity }).on('line', line => { if (line.trim())
+            options.onLine(line); });
+    const exited = new Promise(resolve => {
+        child.once('error', error => { stderr = (stderr + '\n' + error.message).slice(-4000); resolve(null); });
+        child.once('exit', code => resolve(code));
+    });
+    let killing = null;
+    return {
+        child,
+        exited,
+        stderrTail: () => stderr.trim().split(/\r?\n/).filter(line => line.trim()).slice(-3).join(' ').slice(-300),
+        write: line => child.stdin?.writable ? child.stdin.write(line + '\n') : false,
+        kill() {
+            killing ??= (async () => {
+                const signal = (sig) => {
+                    try {
+                        if (posix && child.pid)
+                            process.kill(-child.pid, sig);
+                        else
+                            child.kill(sig);
+                    }
+                    catch { }
+                };
+                child.stdin?.end();
+                signal('SIGTERM');
+                const timer = setTimeout(() => signal('SIGKILL'), 5000);
+                timer.unref?.();
+                await exited;
+                clearTimeout(timer);
+            })();
+            return killing;
+        },
+    };
+}

package/dist/agents-session.js

@@ -0,0 +1,267 @@
+import { setTimeout as delay } from 'node:timers/promises';
+/** Read-only tools Claude Code may use in a sandboxed session; the session's MCP servers are added per server. */
+export const CLAUDE_SANDBOX_TOOLS = ['Read', 'Grep', 'Glob', 'WebSearch', 'WebFetch'];
+export const SANDBOX_NOTE = 'This session is sandboxed: you can read files, search and use the provided MCP tools, but you cannot change files or ' +
+    'run commands that modify anything.';
+export const DEFAULT = 'default';
+const MAX_TEXT = 50_000;
+export function isSandboxed(configuration, options) {
+    return options.sandbox === true || options.profile?.sandbox === true || configuration.sandbox === true;
+}
+/** MCP server names become tool prefixes and config keys, so they are reduced to a safe alphabet. */
+export function mcpServerName(server, index) {
+    return server.name.replace(/[^A-Za-z0-9_-]/g, '_') || `server_${index}`;
+}
+/** Tokens go to environment variables only, so they never appear in a command line or a protocol frame. */
+export function mcpTokenEnvironment(servers) {
+    return Object.fromEntries(servers.map((server, index) => [`SKILLSHARE_MCP_TOKEN_${index}`, server.bearerToken]));
+}
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function clip(text, length = MAX_TEXT) {
+    return text.length <= length ? text : text.slice(0, length) + '…';
+}
+export function oneLine(text, length = 300) {
+    return clip(text.replace(/\s+/g, ' ').trim(), length);
+}
+/**
+ * Batches a session's events for upload. Updates of the same transcript entry are merged, so a fast stream of text
+ * deltas costs one request per flush, and a slow connection never queues more than one copy of each entry.
+ */
+export class EventQueue {
+    upload;
+    intervalMs;
+    onGone;
+    queue = [];
+    flushing = null;
+    timer = null;
+    gone = false;
+    constructor(upload, intervalMs = 1000, onGone = () => { }) {
+        this.upload = upload;
+        this.intervalMs = intervalMs;
+        this.onGone = onGone;
+    }
+    push(event) {
+        if (this.gone)
+            return;
+        if (event.type === 'item') {
+            const index = this.queue.findIndex(e => e.type === 'item' && e.key === event.key);
+            if (index >= 0) {
+                // Only the latest state of an entry matters; keep its place so the transcript order stays stable.
+                this.queue[index] = { ...this.queue[index], ...event };
+                this.schedule();
+                return;
+            }
+        }
+        this.queue.push(event);
+        if (event.type === 'item')
+            this.schedule();
+        else
+            void this.flush();
+    }
+    schedule() {
+        if (this.timer)
+            return;
+        this.timer = setTimeout(() => { this.timer = null; void this.flush(); }, this.intervalMs);
+    }
+    /** Sends everything queued so far, retrying with backoff until it is accepted or the server rejects the session. */
+    flush() {
+        if (this.flushing)
+            return this.flushing.then(() => this.queue.length > 0 ? this.flush() : undefined);
+        this.flushing = (async () => {
+            let failures = 0;
+            while (this.queue.length > 0 && !this.gone) {
+                const batch = this.queue.slice(0, 200);
+                const result = await this.upload(batch).catch(() => 'retry');
+                if (result === 'gone') {
+                    this.gone = true;
+                    this.queue = [];
+                    this.onGone();
+                    break;
+                }
+                if (result === 'retry') {
+                    await delay(Math.min(30_000, 1000 * 2 ** Math.min(failures++, 5)));
+                    continue;
+                }
+                failures = 0;
+                this.queue.splice(0, batch.length);
+            }
+        })().finally(() => { this.flushing = null; });
+        return this.flushing;
+    }
+}
+/**
+ * Runs one session on this computer: starts the agent, feeds it the user's messages one turn at a time, enforces the turn
+ * timeout, closes the agent after a quiet period and reports everything as SessionEvents. The server decides what happens
+ * next; the runner only reports and obeys.
+ */
+export class SessionRunner {
+    options;
+    sessionId;
+    leaseToken;
+    events;
+    driver;
+    seen = new Set();
+    pending = [];
+    now;
+    opened = null;
+    openSucceeded = false;
+    turnRunning = false;
+    interruptRequested = false;
+    idleTimer = null;
+    closing = null;
+    closedReported = false;
+    done;
+    resolveDone;
+    constructor(options) {
+        this.options = options;
+        this.sessionId = options.sessionId;
+        this.leaseToken = options.leaseToken;
+        this.now = options.now ?? Date.now;
+        this.done = new Promise(resolve => { this.resolveDone = resolve; });
+        // A rejected lease means the server moved on; the agent must stop without reporting anything more.
+        this.events = new EventQueue(options.upload, options.flushIntervalMs, () => void this.stop());
+        this.driver = options.driver({
+            sessionId: options.sessionId,
+            start: options.start,
+            workdir: options.workdir,
+            profile: options.profile,
+            sandbox: options.sandbox,
+            item: item => this.events.push({ type: 'item', ...item, text: item.text === undefined ? undefined : clip(item.text) }),
+            thread: threadId => this.events.push({ type: 'thread', threadId }),
+            exited: error => void this.finish(error ?? 'The agent stopped unexpectedly.'),
+        });
+    }
+    get stopping() { return this.closing !== null; }
+    /** Queues messages for the next turns; the server may send a message again, so repeats are ignored. */
+    send(messages) {
+        for (const message of messages) {
+            if (this.seen.has(message.id))
+                continue;
+            this.seen.add(message.id);
+            this.pending.push(message);
+        }
+        void this.pump();
+    }
+    async interrupt() {
+        if (!this.turnRunning || this.interruptRequested)
+            return;
+        this.interruptRequested = true;
+        await this.driver.interrupt().catch(() => { });
+    }
+    /** Stops the agent and reports the session as closed, so the server can resume it later or finish ending it. */
+    close(error) {
+        return this.finish(error);
+    }
+    /** Stops the agent without reporting, because the server no longer accepts this lease. */
+    stop() {
+        this.closedReported = true;
+        return this.finish();
+    }
+    async pump() {
+        if (this.turnRunning || this.closing)
+            return;
+        const message = this.pending.shift();
+        if (!message) {
+            this.armIdle();
+            return;
+        }
+        this.clearIdle();
+        this.turnRunning = true;
+        this.interruptRequested = false;
+        const started = this.now();
+        if (!this.openSucceeded) {
+            try {
+                this.opened ??= this.driver.open();
+                await this.opened;
+                this.openSucceeded = true;
+            }
+            catch (error) {
+                const reason = errorMessage(error);
+                // A failed resume uses up the message as a failed turn, so the server does not ask for the same start again.
+                // A first start that fails has nothing to resume; the server fails the whole session.
+                if (this.options.start.resumeThreadId) {
+                    this.events.push({ type: 'turnStarted', messageId: message.id });
+                    this.events.push({ type: 'turnCompleted', status: 'failed', error: reason });
+                }
+                this.turnRunning = false;
+                await this.finish(reason);
+                return;
+            }
+        }
+        if (this.closing)
+            return;
+        this.events.push({ type: 'turnStarted', messageId: message.id });
+        let outcome;
+        try {
+            outcome = await this.withTimeout(this.driver.turn(message));
+        }
+        catch (error) {
+            outcome = { status: 'failed', error: errorMessage(error) };
+        }
+        if (this.closing)
+            return;
+        if (this.interruptRequested && outcome.status === 'failed' && !outcome.error)
+            outcome = { ...outcome, status: 'interrupted' };
+        this.events.push({ type: 'turnCompleted', status: outcome.status, error: outcome.error,
+            stats: { ...outcome.stats, durationMs: this.now() - started } });
+        this.turnRunning = false;
+        void this.events.flush();
+        void this.pump();
+    }
+    /** Interrupts a turn that runs past its timeout, and gives up on an agent that does not stop when asked. */
+    async withTimeout(turn) {
+        const timeoutMs = Math.max(1, this.options.start.turnTimeoutSeconds) * 1000;
+        let timer;
+        let expired = false;
+        const timedOut = new Promise(resolve => {
+            timer = setTimeout(async () => {
+                expired = true;
+                await this.interrupt();
+                const stopped = await Promise.race([turn.then(() => true), delay(15_000).then(() => false)]);
+                resolve(stopped ? { status: 'interrupted', error: `The turn did not finish within ${this.options.start.turnTimeoutSeconds} seconds.` }
+                    : { status: 'failed', error: `The agent did not stop after ${this.options.start.turnTimeoutSeconds} seconds.` });
+                if (!stopped)
+                    void this.finish(`The agent did not stop after ${this.options.start.turnTimeoutSeconds} seconds.`);
+            }, timeoutMs);
+        });
+        try {
+            const outcome = await Promise.race([turn, timedOut]);
+            // The interrupt usually ends the turn before the timeout path does; the outcome should still say why it stopped.
+            return expired && outcome.status !== 'completed' && !outcome.error
+                ? { ...outcome, error: `The turn did not finish within ${this.options.start.turnTimeoutSeconds} seconds.` } : outcome;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    armIdle() {
+        this.clearIdle();
+        if (this.closing)
+            return;
+        this.idleTimer = setTimeout(() => void this.close(), this.options.idleMs ?? 15 * 60_000);
+    }
+    clearIdle() {
+        if (this.idleTimer)
+            clearTimeout(this.idleTimer);
+        this.idleTimer = null;
+    }
+    finish(error) {
+        this.closing ??= (async () => {
+            this.clearIdle();
+            await this.driver.close().catch(() => { });
+            if (this.turnRunning && !this.closedReported) {
+                this.events.push({ type: 'turnCompleted', status: 'failed', error: error ?? 'The agent was stopped.' });
+                this.turnRunning = false;
+            }
+            if (!this.closedReported) {
+                this.closedReported = true;
+                this.events.push({ type: 'closed', error });
+            }
+            await this.events.flush();
+            this.resolveDone();
+        })();
+        return this.closing;
+    }
+}

package/dist/agents.js

@@ -3,8 +3,10 @@ import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { hostname, platform } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
+import { createClaudeDriver } from './agents-claude.js';
+import { createCodexDriver } from './agents-codex.js';
 import { detectAgents, profilesPath } from './agents-detect.js';
-import { runAgent } from './agents-run.js';
+import { SessionRunner } from './agents-session.js';
 import { readCliVersion } from './help.js';
 const root = '/api/agents';
 const PROFILE_HINT = 'Declare named profiles in ' + profilesPath() + ' to set a working directory or extra arguments.';
@@ -71,6 +73,7 @@ export async function runAgentsCommand(client, args, flags, appDirectory) {
     console.log(sandbox
         ? 'Sandboxed: agents may read files, search and use the Skillshare MCP tools, but cannot change files or run commands that modify anything.'
         : 'Agents run with your full local permissions and configuration, without permission prompts. Use --sandbox to keep them read-only.');
+    console.log('Sessions keep their agent running between messages and close it after 15 quiet minutes; the next message resumes it.');
     try {
         await listen({ client, listenerId, name: flags.name, workdir, maxConcurrency: max, sandbox, signal: abort.signal, onProgress: console.log });
     }
@@ -100,11 +103,13 @@ export function renderDetected(listenerId, server, detected) {
 }
 export async function listen(options) {
     const detect = options.detect ?? (() => detectAgents());
-    const run = options.run ?? runAgent;
+    const codex = createCodexDriver({ clientVersion: readCliVersion() });
+    const claude = createClaudeDriver();
+    const driver = options.driver ?? (start => start.configuration.agent === 'codex' ? codex : claude);
     const wait = options.wait ?? (async (ms, signal) => { await delay(ms, undefined, { signal }); });
     const now = options.now ?? Date.now;
     const log = options.onProgress ?? (() => { });
-    const running = new Map();
+    const sessions = new Map();
     let detected = await detect();
     let registeredFingerprint = '';
     let detectedAt = now();
@@ -119,48 +124,52 @@ export async function listen(options) {
         registeredFingerprint = fingerprint;
         for (const problem of detected.problems)
             log(`! ${problem}`);
-        log(`Listening as "${registered.name}" with ${registered.effectiveConcurrency} slot(s): ${describe(detected)}. Choose what runs where under Connected agents on ${options.client.baseUrl}.`);
+        log(`Listening as "${registered.name}" with ${registered.effectiveConcurrency} slot(s): ${describe(detected)}. Start sessions and choose routes under Connected agents on ${options.client.baseUrl}.`);
     }
-    async function report(assignment, result) {
-        const path = `${root}/tasks/${assignment.taskId}/${result.ok ? 'result' : 'failure'}`;
-        const body = result.ok ? { leaseToken: assignment.leaseToken, markdown: result.markdown, stats: result.stats }
-            : { leaseToken: assignment.leaseToken, reason: result.reason, cancelled: result.cancelled, stats: result.stats };
-        for (let attempt = 0; attempt < 5; attempt++) {
+    /** Posts a batch of session events: a rejected lease means the server moved on and the agent must stop. */
+    function uploader(sessionId, leaseToken) {
+        return async (events) => {
             try {
-                await send(options.client, 'POST', path, body);
-                return;
+                await send(options.client, 'POST', `${root}/sessions/${sessionId}/events`, { leaseToken, events });
+                return 'ok';
             }
             catch (error) {
-                // A rejected lease means the server already moved on; retrying cannot help.
-                if (error instanceof AgentsHttpError && error.status >= 400 && error.status < 500) {
-                    log(`Task ${assignment.taskId} result was not accepted: ${error.message}`);
-                    return;
-                }
-                if (attempt < 4)
-                    await delay(2000 * (attempt + 1)).catch(() => { });
+                if (error instanceof AgentsHttpError && error.status >= 400 && error.status < 500)
+                    return 'gone';
+                return 'retry';
             }
-        }
-        log(`Task ${assignment.taskId} result could not be delivered; the server will retry the task after its lease expires.`);
+        };
     }
-    function start(assignment) {
-        if (running.has(assignment.taskId))
+    function start(command) {
+        if (!command.start || !command.leaseToken)
             return;
-        const abort = new AbortController();
-        const profile = assignment.configuration.profile ? detected.profiles.find(p => p.name === assignment.configuration.profile) : undefined;
-        log(`Started task ${assignment.taskId} "${assignment.title}" with ${label(assignment)}.`);
-        const done = (async () => {
-            let result;
-            try {
-                result = await run(assignment, { workdir: options.workdir, profile, sandbox: options.sandbox, signal: abort.signal });
-            }
-            catch (error) {
-                result = { ok: false, reason: `The listener could not run the agent: ${error instanceof Error ? error.message : String(error)}`, cancelled: false, stats: {} };
-            }
-            log(result.ok ? `Finished task ${assignment.taskId}.` : `${result.cancelled ? 'Cancelled' : 'Failed'} task ${assignment.taskId}: ${result.reason}`);
-            await report(assignment, result);
-            running.delete(assignment.taskId);
-        })();
-        running.set(assignment.taskId, { assignment, abort, done });
+        // A start for a session already held replaces its agent, for example to hand it fresh credentials.
+        const previous = sessions.get(command.sessionId);
+        if (previous)
+            void previous.stop();
+        const profile = command.start.configuration.profile ? detected.profiles.find(p => p.name === command.start.configuration.profile) : undefined;
+        const runner = new SessionRunner({
+            sessionId: command.sessionId, leaseToken: command.leaseToken, start: command.start, workdir: options.workdir, profile, sandbox: options.sandbox === true,
+            driver: driver(command.start), upload: uploader(command.sessionId, command.leaseToken), idleMs: options.idleMs, flushIntervalMs: options.flushIntervalMs,
+            now,
+        });
+        sessions.set(command.sessionId, runner);
+        log(`${command.start.resumeThreadId ? 'Resumed' : 'Started'} session ${command.sessionId} "${command.start.title}" with ${label(command.start)}.`);
+        void runner.done.then(() => {
+            if (sessions.get(command.sessionId) === runner)
+                sessions.delete(command.sessionId);
+            log(`Closed session ${command.sessionId}.`);
+        });
+        runner.send(command.messages ?? []);
+    }
+    function handle(command) {
+        const runner = sessions.get(command.sessionId);
+        switch (command.type) {
+            case 'start': return start(command);
+            case 'send': return runner?.send(command.messages ?? []);
+            case 'interrupt': return void runner?.interrupt();
+            case 'close': return void runner?.close();
+        }
     }
     try {
         while (!options.signal.aborted) {
@@ -173,17 +182,14 @@ export async function listen(options) {
                     await register();
                 const polledAt = now();
                 const response = await send(options.client, 'POST', `${root}/listeners/${options.listenerId}/poll`, {
-                    // A task that is already stopping is not reported, otherwise the server would answer every poll with its cancellation.
-                    running: [...running.values()].filter(r => !r.abort.signal.aborted)
-                        .map(r => ({ taskId: Number(r.assignment.taskId), leaseToken: r.assignment.leaseToken })),
+                    // A session that is already closing is not reported, so the server treats its agent as gone.
+                    sessions: [...sessions.values()].filter(r => !r.stopping).map(r => ({ sessionId: r.sessionId, leaseToken: r.leaseToken })),
                     waitSeconds: options.pollWaitSeconds ?? 25,
                 }, options.signal);
                 failures = 0;
-                for (const id of response.cancel)
-                    running.get(id)?.abort.abort();
-                for (const assignment of response.assignments)
-                    start(assignment);
-                if (response.assignments.length === 0 && now() - polledAt < 1000)
+                for (const command of response.commands)
+                    handle(command);
+                if (response.commands.length === 0 && now() - polledAt < 1000)
                     await wait(1000, options.signal).catch(() => { });
             }
             catch (error) {
@@ -206,13 +212,12 @@ export async function listen(options) {
         }
     }
     finally {
-        for (const task of running.values())
-            task.abort.abort();
-        await Promise.all([...running.values()].map(task => task.done));
+        // Closing reports each session as closed, so the server knows at once that the next message must resume it.
+        await Promise.all([...sessions.values()].map(runner => runner.close()));
     }
 }
-function label(assignment) {
-    const { configuration } = assignment;
+function label(start) {
+    const { configuration } = start;
     if (configuration.profile)
         return `profile ${configuration.profile}`;
     return [configuration.agent === 'claude' ? 'Claude Code' : 'Codex', configuration.model, configuration.reasoning]

package/dist/help.js

@@ -115,7 +115,7 @@ export const COMMANDS = [
             'agents listen [local] [--name <name>] [--workdir <directory>] [--max-concurrency <1-4>] [--sandbox]',
             'agents status [local] [--json]',
         ],
-        description: 'A listener reports the installed agents, their models and reasoning levels, and the local profiles from ~/.config/skillshare/agents.json. Choose which listener and configuration runs each kind of task under Connected agents in Skillshare. Agents run with your full local permissions, without permission prompts, unless --sandbox (or "sandbox": true in a profile) keeps them read-only.',
+        description: 'A listener reports the installed agents, their models and reasoning levels, and the local profiles from ~/.config/skillshare/agents.json. It runs Claude Code and Codex sessions that you start and continue under Sessions in Skillshare; under Connected agents you choose which listener and configuration runs Teams 👀 sessions. Agents use your own login and run with your full local permissions, without permission prompts, unless --sandbox (or "sandbox": true in a profile) keeps them read-only. An idle agent is stopped after 15 minutes and resumed by the next message.',
         examples: ['skillshare agents status', 'skillshare agents listen --workdir ~/Research'],
         flags: ['name', 'workdir', 'max-concurrency', 'sandbox', 'json'],
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quadient/skillshare",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "Skillshare CLI for installing and publishing Quadient skills",
   "type": "module",
   "bin": {

package/dist/agents-run.js

@@ -1,174 +0,0 @@
-import { spawn } from 'node:child_process';
-import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-const DEFAULT = 'default';
-/** Read-only tools Claude Code may use in a sandboxed run; MCP servers from the assignment are added per server. */
-export const CLAUDE_SANDBOX_TOOLS = ['Read', 'Grep', 'Glob', 'WebSearch', 'WebFetch'];
-export const SANDBOX_NOTE = '\n\nThis run is sandboxed: you can read files, search and use the provided MCP tools, but you cannot change files or run ' +
-    'commands that modify anything. Give your final answer as your last message; writing SKILLSHARE_AGENT_RESULT may not be possible.';
-/**
- * Builds the agent invocation. The prompt goes to stdin and tokens to environment variables, so neither
- * appears in the process list. Agents run without permission prompts, with the user's own configuration.
- */
-export function isSandboxed(assignment, options) {
-    return options.sandbox === true || options.profile?.sandbox === true || assignment.configuration.sandbox === true;
-}
-export function buildAgentCommand(assignment, options) {
-    const sandbox = isSandboxed(assignment, options);
-    const { configuration } = assignment;
-    const env = { SKILLSHARE_AGENT_RESULT: join(options.directory, 'result.md'), SKILLSHARE_TASK_ID: assignment.taskId };
-    const servers = assignment.mcpServers.map((server, index) => {
-        const variable = `SKILLSHARE_MCP_TOKEN_${index}`;
-        env[variable] = server.bearerToken;
-        return { name: server.name.replace(/[^A-Za-z0-9_-]/g, '_') || `server_${index}`, url: server.url, variable };
-    });
-    const cwd = options.profile?.workdir ?? options.workdir;
-    const extra = options.profile?.args ?? [];
-    if (configuration.agent === 'claude') {
-        // A sandboxed run never prompts: anything outside the read-only allowlist is denied.
-        const args = ['-p', '--output-format', 'json', ...(sandbox
-                ? ['--permission-mode', 'dontAsk', '--allowedTools', ...CLAUDE_SANDBOX_TOOLS, ...servers.map(server => `mcp__${server.name}`)]
-                : ['--dangerously-skip-permissions'])];
-        if (configuration.model !== DEFAULT)
-            args.push('--model', configuration.model);
-        if (configuration.reasoning !== DEFAULT)
-            args.push('--effort', configuration.reasoning);
-        if (servers.length > 0)
-            args.push('--mcp-config', join(options.directory, 'mcp.json'));
-        return { command: 'claude', args: [...args, ...extra], env, cwd };
-    }
-    const args = ['exec', '--skip-git-repo-check', ...(sandbox ? ['--sandbox', 'read-only', '-c', 'approval_policy="never"'] : ['--dangerously-bypass-approvals-and-sandbox']),
-        '--output-last-message', join(options.directory, 'last-message.md')];
-    if (configuration.model !== DEFAULT)
-        args.push('-m', configuration.model);
-    if (configuration.reasoning !== DEFAULT)
-        args.push('-c', `model_reasoning_effort=${JSON.stringify(configuration.reasoning)}`);
-    for (const server of servers)
-        args.push('-c', `mcp_servers.${server.name}.url=${JSON.stringify(server.url)}`, '-c', `mcp_servers.${server.name}.bearer_token_env_var=${JSON.stringify(server.variable)}`);
-    return { command: 'codex', args: [...args, ...extra, '-'], env, cwd };
-}
-export function claudeMcpConfig(servers) {
-    return JSON.stringify({
-        mcpServers: Object.fromEntries(servers.map((server, index) => [server.name.replace(/[^A-Za-z0-9_-]/g, '_') || `server_${index}`,
-            { type: 'http', url: server.url, headers: { Authorization: `Bearer \${SKILLSHARE_MCP_TOKEN_${index}}` } }])),
-    }, null, 2);
-}
-/** Reads Claude Code's --output-format json summary. */
-export function parseClaudeOutput(stdout) {
-    try {
-        const data = JSON.parse(stdout.trim().split(/\r?\n/).filter(Boolean).at(-1) ?? '');
-        const usage = data.usage ?? {};
-        const input = [usage.input_tokens, usage.cache_creation_input_tokens, usage.cache_read_input_tokens]
-            .filter((value) => typeof value === 'number');
-        return {
-            result: typeof data.result === 'string' ? data.result : undefined,
-            isError: data.is_error === true,
-            stats: {
-                durationMs: typeof data.duration_ms === 'number' ? data.duration_ms : undefined,
-                turns: typeof data.num_turns === 'number' ? data.num_turns : undefined,
-                costUsd: typeof data.total_cost_usd === 'number' ? data.total_cost_usd : undefined,
-                inputTokens: input.length > 0 ? input.reduce((a, b) => a + b, 0) : undefined,
-                outputTokens: typeof usage.output_tokens === 'number' ? usage.output_tokens : undefined,
-            },
-        };
-    }
-    catch {
-        return { isError: false, stats: {} };
-    }
-}
-export async function runAgent(assignment, options) {
-    const now = options.now ?? Date.now;
-    const started = now();
-    const directory = await mkdtemp(join(tmpdir(), 'skillshare-agent-'));
-    try {
-        const command = buildAgentCommand(assignment, { directory, workdir: options.workdir, profile: options.profile, sandbox: options.sandbox });
-        if (assignment.configuration.agent === 'claude' && assignment.mcpServers.length > 0)
-            await writeFile(join(directory, 'mcp.json'), claudeMcpConfig(assignment.mcpServers), { mode: 0o600 });
-        const prompt = assignment.prompt + (isSandboxed(assignment, options) ? SANDBOX_NOTE : '');
-        const outcome = await execute(command, prompt, Math.max(1, assignment.timeoutSeconds) * 1000, options.signal, options.spawnAgent ?? spawn);
-        const measured = { durationMs: now() - started };
-        const claude = assignment.configuration.agent === 'claude' ? parseClaudeOutput(outcome.stdout) : undefined;
-        const stats = { ...measured, ...Object.fromEntries(Object.entries(claude?.stats ?? {}).filter(([, value]) => value !== undefined)) };
-        if (outcome.cancelled)
-            return { ok: false, reason: 'Cancelled on request.', cancelled: true, stats };
-        if (outcome.timedOut)
-            return { ok: false, reason: `The agent did not finish within ${assignment.timeoutSeconds} seconds.`, cancelled: false, stats };
-        if (outcome.spawnError)
-            return { ok: false, reason: `Could not start ${command.command}: ${outcome.spawnError}`, cancelled: false, stats };
-        const answer = await readAnswer(directory, assignment.configuration.agent, claude?.result);
-        if (outcome.code !== 0 || claude?.isError) {
-            const detail = (claude?.isError ? claude.result : undefined) ?? lastLines(outcome.stderr) ?? `exit code ${outcome.code}`;
-            return { ok: false, reason: `${command.command} failed: ${detail}`.slice(0, 500), cancelled: false, stats };
-        }
-        if (!answer)
-            return { ok: false, reason: 'The agent finished without an answer.', cancelled: false, stats };
-        return { ok: true, markdown: answer, stats };
-    }
-    finally {
-        await rm(directory, { recursive: true, force: true });
-    }
-}
-async function readAnswer(directory, agent, claudeResult) {
-    for (const file of ['result.md', ...(agent === 'codex' ? ['last-message.md'] : [])]) {
-        try {
-            const text = (await readFile(join(directory, file), 'utf8')).trim();
-            if (text)
-                return text;
-        }
-        catch { }
-    }
-    return claudeResult?.trim() || undefined;
-}
-function lastLines(text) {
-    const lines = text.trim().split(/\r?\n/).filter(line => line.trim()).slice(-3).join(' ').trim();
-    return lines ? lines.slice(-300) : undefined;
-}
-function execute(command, input, timeoutMs, signal, spawnAgent) {
-    return new Promise(resolvePromise => {
-        const posix = process.platform !== 'win32';
-        const child = spawnAgent(command.command, command.args, {
-            cwd: command.cwd, env: { ...process.env, ...command.env }, stdio: ['pipe', 'pipe', 'pipe'],
-            // A separate process group lets cancellation stop the agent's own child processes too.
-            detached: posix, windowsHide: true, shell: !posix,
-        });
-        let stdout = '';
-        let stderr = '';
-        let cancelled = false;
-        let timedOut = false;
-        let settled = false;
-        const stop = () => {
-            const kill = (sig) => {
-                try {
-                    if (posix && child.pid)
-                        process.kill(-child.pid, sig);
-                    else
-                        child.kill(sig);
-                }
-                catch { }
-            };
-            kill('SIGTERM');
-            setTimeout(() => kill('SIGKILL'), 5000).unref();
-        };
-        const onAbort = () => { cancelled = true; stop(); };
-        const timer = setTimeout(() => { timedOut = true; stop(); }, timeoutMs);
-        signal.addEventListener('abort', onAbort, { once: true });
-        const finish = (outcome) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            signal.removeEventListener('abort', onAbort);
-            resolvePromise(outcome);
-        };
-        child.stdout?.on('data', chunk => { if (stdout.length < 2_000_000)
-            stdout += chunk; });
-        child.stderr?.on('data', chunk => { stderr = (stderr + chunk).slice(-4000); });
-        child.on('error', error => finish({ code: null, stdout, stderr, cancelled, timedOut, spawnError: error.message }));
-        child.on('close', code => finish({ code, stdout, stderr, cancelled, timedOut }));
-        child.stdin?.on('error', () => { });
-        child.stdin?.end(input);
-        if (signal.aborted)
-            onAbort();
-    });
-}