@steerable/agent-cli 0.6.57

package/dist/commands.js

@@ -0,0 +1,308 @@
+const CONFIG_KEYS = [
+    'provider',
+    'vendorId',
+    'model',
+    'baseUrl',
+    'apiKey',
+    'temperature',
+    'systemPrompt',
+    'maxTotalTokens',
+    'execTimeoutSeconds',
+];
+const NUMBER_KEYS = new Set(['temperature', 'maxTotalTokens', 'execTimeoutSeconds']);
+export async function chatCommand(io, stdout, stderr, open, help) {
+    const sub = io.positionals[1];
+    if (io.help && !sub) {
+        stdout.write(`${help}\n`);
+        return 0;
+    }
+    if (sub === 'list')
+        return open((client) => listChats(client, io, stdout, stderr));
+    if (sub === 'show' || sub === 'rm' || sub === 'export') {
+        const id = io.positionals[2];
+        if (!id) {
+            stderr.write(`missing chat id\n${help}\n`);
+            return 2;
+        }
+        if (sub === 'show')
+            return open((client) => showChat(client, id, io, stdout, stderr));
+        if (sub === 'rm')
+            return open((client) => removeChat(client, id, stdout, stderr));
+        const format = io.format ?? 'md';
+        if (format !== 'md' && format !== 'json') {
+            stderr.write(`unknown --format value\n${help}\n`);
+            return 2;
+        }
+        return open((client) => exportChat(client, id, io, stdout, stderr, help));
+    }
+    stderr.write(`${sub ? `unknown chat command: ${sub}\n` : ''}${help}\n`);
+    return 2;
+}
+export async function skillsCommand(io, stdout, stderr, open, help) {
+    if (io.help || io.positionals[1] === undefined) {
+        stdout.write(`${help}\n`);
+        return io.help ? 0 : 2;
+    }
+    if (io.positionals[1] !== 'list') {
+        stderr.write(`unknown skills command: ${io.positionals[1]}\n${help}\n`);
+        return 2;
+    }
+    return open(async (client) => {
+        const listed = await client.request('GET', '/api/v2/chat-agents/skills', undefined);
+        if (listed.status !== 200)
+            return fail(stderr, 'skills list', listed.status);
+        const skills = listed.data.skills ?? [];
+        if (io.json) {
+            stdout.write(`${JSON.stringify(skills)}\n`);
+            return 0;
+        }
+        if (skills.length === 0) {
+            stdout.write('no skills\n');
+            return 0;
+        }
+        for (const skill of skills) {
+            stdout.write(`${skill.name}\t${skill.origin ?? ''}\t${skill.description ?? ''}\n`);
+        }
+        return 0;
+    });
+}
+export async function mcpCommand(io, stdout, stderr, open, help) {
+    const sub = io.positionals[1];
+    if (io.help && !sub) {
+        stdout.write(`${help}\n`);
+        return 0;
+    }
+    if (sub === 'list') {
+        return open(async (client) => {
+            const listed = await client.request('GET', '/api/v2/mcp/servers', undefined);
+            if (listed.status !== 200)
+                return fail(stderr, 'mcp list', listed.status);
+            const servers = listed.data.servers ?? [];
+            if (io.json) {
+                stdout.write(`${JSON.stringify(servers)}\n`);
+                return 0;
+            }
+            if (servers.length === 0) {
+                stdout.write('no mcp servers\n');
+                return 0;
+            }
+            for (const server of servers) {
+                const command = [server.command, ...(server.args ?? [])].filter(Boolean).join(' ');
+                stdout.write(`${server.name}\t${command}\n`);
+            }
+            return 0;
+        });
+    }
+    if (sub === 'add') {
+        const name = io.positionals[2];
+        const command = io.positionals[3];
+        const args = io.positionals.slice(4);
+        if (!name || !command) {
+            stderr.write(`missing mcp command\n${help}\n`);
+            return 2;
+        }
+        return open(async (client) => {
+            const created = await client.request('POST', '/api/v2/mcp/servers', {
+                name,
+                transport: 'stdio',
+                command,
+                args,
+            });
+            if (created.status !== 200)
+                return fail(stderr, 'mcp add', created.status);
+            stdout.write(`added ${name}\n`);
+            return 0;
+        });
+    }
+    if (sub === 'rm') {
+        const name = io.positionals[2];
+        if (!name) {
+            stderr.write(`missing mcp name\n${help}\n`);
+            return 2;
+        }
+        return open(async (client) => {
+            const listed = await client.request('GET', '/api/v2/mcp/servers', undefined);
+            if (listed.status !== 200)
+                return fail(stderr, 'mcp list', listed.status);
+            const servers = listed.data.servers ?? [];
+            const match = servers.find((server) => server.name === name);
+            if (!match?.id) {
+                stderr.write(`mcp server not found: ${name}\n`);
+                return 1;
+            }
+            const removed = await client.request('DELETE', `/api/v2/mcp/servers/${encodeURIComponent(match.id)}`, undefined);
+            if (removed.status !== 200)
+                return fail(stderr, 'mcp rm', removed.status);
+            stdout.write(`removed ${name}\n`);
+            return 0;
+        });
+    }
+    stderr.write(`${sub ? `unknown mcp command: ${sub}\n` : ''}${help}\n`);
+    return 2;
+}
+export async function configCommand(io, stdout, stderr, open, help) {
+    const sub = io.positionals[1];
+    if (io.help && !sub) {
+        stdout.write(`${help}\n`);
+        return 0;
+    }
+    const key = io.positionals[2];
+    if ((sub !== 'get' && sub !== 'set') || !key || !isConfigKey(key)) {
+        stderr.write(`${help}\n`);
+        return 2;
+    }
+    if (sub === 'get') {
+        return open(async (client) => {
+            const current = await readConfig(client, stderr);
+            if (!current)
+                return 1;
+            const value = current[key];
+            stdout.write(`${key}=${value === undefined ? '' : String(value)}\n`);
+            return 0;
+        });
+    }
+    const raw = io.positionals[3];
+    if (raw === undefined) {
+        stderr.write(`missing config value\n${help}\n`);
+        return 2;
+    }
+    const value = coerceConfigValue(key, raw);
+    if (value === undefined) {
+        stderr.write(`invalid config value\n${help}\n`);
+        return 2;
+    }
+    return open(async (client) => {
+        const current = await readConfig(client, stderr);
+        if (!current)
+            return 1;
+        const saved = await client.request('POST', '/api/v2/local-settings/llm', { ...current, [key]: value });
+        if (saved.status !== 200)
+            return fail(stderr, 'config set', saved.status);
+        stdout.write(`${key}=${String(value)}\n`);
+        return 0;
+    });
+}
+async function listChats(client, io, stdout, stderr) {
+    const listed = await client.request('GET', '/api/v2/chats', undefined);
+    if (listed.status !== 200)
+        return fail(stderr, 'chat list', listed.status);
+    const chats = listed.data.chats ?? [];
+    if (io.json) {
+        stdout.write(`${JSON.stringify(chats)}\n`);
+        return 0;
+    }
+    if (chats.length === 0) {
+        stdout.write('no chats\n');
+        return 0;
+    }
+    for (const chat of chats)
+        stdout.write(`${chat.id}\t${chat.title ?? ''}\n`);
+    return 0;
+}
+async function showChat(client, id, io, stdout, stderr) {
+    const loaded = await loadChat(client, id, stderr);
+    if (!loaded)
+        return 1;
+    if (io.json) {
+        stdout.write(`${JSON.stringify(loaded)}\n`);
+        return 0;
+    }
+    stdout.write(`${loaded.chat.id}\t${loaded.chat.title ?? ''}\n`);
+    for (const message of loaded.messages) {
+        stdout.write(`${message.role}\t${oneLine(message.content)}\n`);
+    }
+    return 0;
+}
+async function removeChat(client, id, stdout, stderr) {
+    const removed = await client.request('DELETE', `/api/v2/chats/${encodeURIComponent(id)}`, undefined);
+    if (removed.status === 409) {
+        stderr.write(`${messageOf(removed.data, '该会话正在另一个进程中运行')}\n`);
+        return 6;
+    }
+    if (removed.status === 404) {
+        stderr.write('chat not found\n');
+        return 1;
+    }
+    if (removed.status !== 200)
+        return fail(stderr, 'chat rm', removed.status);
+    stdout.write(`deleted ${id}\n`);
+    return 0;
+}
+async function exportChat(client, id, io, stdout, stderr, help) {
+    const format = io.format ?? 'md';
+    if (format !== 'md' && format !== 'json') {
+        stderr.write(`unknown --format value\n${help}\n`);
+        return 2;
+    }
+    const loaded = await loadChat(client, id, stderr);
+    if (!loaded)
+        return 1;
+    if (format === 'json') {
+        stdout.write(`${JSON.stringify(loaded, null, 2)}\n`);
+        return 0;
+    }
+    const title = loaded.chat.title || loaded.chat.id;
+    const parts = [`# ${title}`, ''];
+    for (const message of loaded.messages) {
+        parts.push(`## ${message.role}`, '', message.content, '');
+    }
+    stdout.write(`${parts.join('\n').replace(/\n$/, '')}\n`);
+    return 0;
+}
+async function loadChat(client, id, stderr) {
+    const encoded = encodeURIComponent(id);
+    const chat = await client.request('GET', `/api/v2/chats/${encoded}`, undefined);
+    if (chat.status === 404) {
+        stderr.write('chat not found\n');
+        return null;
+    }
+    if (chat.status !== 200) {
+        fail(stderr, 'chat', chat.status);
+        return null;
+    }
+    const messages = await client.request('GET', `/api/v2/chats/${encoded}/messages`, undefined);
+    if (messages.status !== 200) {
+        fail(stderr, 'chat messages', messages.status);
+        return null;
+    }
+    return {
+        chat: chat.data,
+        messages: messages.data.messages ?? [],
+    };
+}
+async function readConfig(client, stderr) {
+    const current = await client.request('GET', '/api/v2/local-settings/llm', undefined);
+    if (current.status !== 200 || !current.data || typeof current.data !== 'object') {
+        fail(stderr, 'config get', current.status);
+        return null;
+    }
+    return current.data;
+}
+function isConfigKey(key) {
+    return CONFIG_KEYS.includes(key);
+}
+function coerceConfigValue(key, raw) {
+    if (!NUMBER_KEYS.has(key))
+        return raw;
+    const value = Number(raw);
+    if (!Number.isFinite(value))
+        return undefined;
+    if (key === 'execTimeoutSeconds' && value <= 0)
+        return undefined;
+    return value;
+}
+function fail(stderr, label, status) {
+    stderr.write(`${label} failed (${status})\n`);
+    return 1;
+}
+function messageOf(data, fallback) {
+    if (data && typeof data === 'object' && 'message' in data) {
+        const message = data.message;
+        if (typeof message === 'string' && message)
+            return message;
+    }
+    return fallback;
+}
+function oneLine(content) {
+    return content.replace(/[\r\n\t]+/g, ' ');
+}

package/dist/help.d.ts

@@ -0,0 +1,11 @@
+export declare function rootHelp(commands?: readonly {
+    name: string;
+    summary: string;
+}[]): string;
+export declare function runHelp(): string;
+export declare function chatHelp(): string;
+export declare function skillsHelp(): string;
+export declare function mcpHelp(): string;
+export declare function configHelp(): string;
+export declare function tuiHelp(): string;
+export declare function doctorHelp(): string;

package/dist/help.js

@@ -0,0 +1,118 @@
+const EXAMPLES = `
+Examples:
+  <product> run "列出当前目录" --approve allow-read --stream-json
+  <product> run --chat <id> "继续"
+  <product> chat list
+  <product> chat show <id>
+  <product> chat export <id> --format md
+  <product> skills list
+  <product> mcp list
+  <product> config get model
+  <product> doctor
+  <product> tui
+`.trim();
+export function rootHelp(commands = []) {
+    const extra = commands
+        .map((command) => `  <product> ${command.name}    ${command.summary}`)
+        .join('\n');
+    const pack = extra ? `\n${extra}` : '';
+    return `
+Usage:
+  <product> run "<task>" [--chat <id>] [--approve deny|allow-read|allow-all]
+                         [--json | --stream-json] [--cwd <dir>] [--timeout <dur>]
+                         [--data-dir <dir>] [--agent <id>] [--file <path>...]
+  <product> chat list | show <id> | rm <id> | export <id> [--format md|json]
+  <product> skills list
+  <product> mcp list | add <name> -- <cmd...> | rm <name>
+  <product> config get <key> | set <key> <value>
+  <product> doctor
+  <product> tui${pack}
+
+${EXAMPLES}
+`.trim();
+}
+export function runHelp() {
+    return `
+Usage:
+  <product> run "<task>" [--chat <id>] [--approve deny|allow-read|allow-all]
+                         [--json | --stream-json] [--data-dir <dir>]
+
+--approve deny is the default. A denied approval exits 3. A busy chat exits 6.
+
+${EXAMPLES}
+`.trim();
+}
+export function chatHelp() {
+    return `
+Usage:
+  <product> chat list [--json] [--data-dir <dir>]
+  <product> chat show <id> [--json]
+  <product> chat rm <id>
+  <product> chat export <id> [--format md|json]
+
+rm of a chat held by another process exits 6.
+
+Examples:
+  <product> chat list
+  <product> chat show <id>
+  <product> chat export <id> --format md
+`.trim();
+}
+export function skillsHelp() {
+    return `
+Usage:
+  <product> skills list [--json] [--data-dir <dir>]
+
+Examples:
+  <product> skills list
+`.trim();
+}
+export function mcpHelp() {
+    return `
+Usage:
+  <product> mcp list [--json]
+  <product> mcp add <name> -- <cmd...>
+  <product> mcp rm <name>
+
+Examples:
+  <product> mcp add files -- npx -y @modelcontextprotocol/server-filesystem .
+  <product> mcp rm files
+`.trim();
+}
+export function configHelp() {
+    return `
+Usage:
+  <product> config get <key>
+  <product> config set <key> <value>
+
+Keys: provider, vendorId, model, baseUrl, apiKey, temperature, systemPrompt,
+maxTotalTokens, execTimeoutSeconds.
+
+Examples:
+  <product> config get model
+  <product> config set model demo-model
+`.trim();
+}
+export function tuiHelp() {
+    return `
+Usage:
+  <product> tui [--data-dir <dir>]
+
+Starts the terminal interface. When stdin is not a terminal, use run instead.
+
+/new  /model  /clear  /help
+Ctrl+C interrupts the current turn. Ctrl+L lists chats.
+
+Examples:
+  <product> tui
+`.trim();
+}
+export function doctorHelp() {
+    return `
+Usage:
+  <product> doctor [--data-dir <dir>]
+
+Examples:
+  <product> doctor
+`.trim();
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { createCli } from './cli.js';
+export type { CliOptions } from './cli.js';

package/dist/index.js

@@ -0,0 +1 @@
+export { createCli } from './cli.js';

package/dist/run.d.ts

@@ -0,0 +1,14 @@
+import type { AgentClient } from '@steerable/agent-client';
+import { type ApprovePolicy } from './approve.js';
+export interface RunRequest {
+    task: string;
+    chatId?: string;
+    agentId?: string;
+    cwd?: string;
+    files: string[];
+    policy: ApprovePolicy;
+    json: boolean;
+    streamJson: boolean;
+    timeoutMs?: number;
+}
+export declare function runTurn(client: AgentClient, request: RunRequest, stdout: NodeJS.WritableStream, stderr: NodeJS.WritableStream, signal: AbortSignal): Promise<number>;

package/dist/run.js

@@ -0,0 +1,121 @@
+import { decisionFor, denied } from './approve.js';
+export async function runTurn(client, request, stdout, stderr, signal) {
+    if (request.policy === 'allow-all') {
+        stderr.write('warning: --approve allow-all allows every tool call in this run\n');
+    }
+    let chatId = request.chatId;
+    if (!chatId) {
+        const created = await client.request('POST', '/api/v2/chats/new', {
+            ...(request.agentId ? { agentId: request.agentId } : {}),
+        });
+        if (created.status !== 200) {
+            stderr.write(`failed to create chat (${created.status})\n`);
+            return 1;
+        }
+        chatId = created.data.chatId;
+        if (!chatId) {
+            stderr.write('failed to create chat\n');
+            return 1;
+        }
+    }
+    let exitCode = 0;
+    let deniedApproval = false;
+    const text = [];
+    const approvals = watchApprovals(client, request.policy, () => {
+        deniedApproval = true;
+    });
+    try {
+        for await (const event of client.stream(`/api/v2/chats/${encodeURIComponent(chatId)}/send`, { message: messageText(request), ...(request.agentId ? { agentId: request.agentId } : {}) }, signal)) {
+            const next = observeEvent(event, request, stdout, stderr, text);
+            if (next !== 0)
+                exitCode = next;
+        }
+    }
+    finally {
+        approvals.stop();
+    }
+    if (signal.aborted && exitCode === 0)
+        exitCode = 1;
+    if (deniedApproval)
+        exitCode = 3;
+    if (client.lastStatus === 409)
+        exitCode = 6;
+    if (request.json) {
+        stdout.write(`${JSON.stringify({
+            ok: exitCode === 0,
+            chatId,
+            text: text.join(''),
+            exitCode,
+        })}\n`);
+    }
+    return exitCode;
+}
+function messageText(request) {
+    const lines = [request.task];
+    if (request.cwd)
+        lines.push(`Working directory: ${request.cwd}`);
+    if (request.files.length > 0) {
+        lines.push('Files:');
+        for (const file of request.files)
+            lines.push(`- ${file}`);
+    }
+    return lines.join('\n');
+}
+function watchApprovals(client, policy, onDenied) {
+    let stopped = false;
+    const loop = (async () => {
+        for await (const event of client.events()) {
+            if (stopped)
+                return;
+            if (event.channel === 'approval:request') {
+                const prompt = event.payload;
+                if (!prompt.requestId)
+                    continue;
+                const kind = decisionFor(policy, prompt);
+                if (denied(kind))
+                    onDenied();
+                await client.decideApproval(prompt.requestId, kind);
+            }
+            else if (event.channel === 'ask-user:request') {
+                const prompt = event.payload;
+                if (prompt.requestId)
+                    await client.answerAsk(prompt.requestId, {});
+            }
+        }
+    })();
+    void loop;
+    return {
+        stop() {
+            stopped = true;
+        },
+    };
+}
+function observeEvent(event, request, stdout, stderr, text) {
+    if (request.streamJson)
+        stdout.write(`${JSON.stringify(event)}\n`);
+    if (event.type === 'content' && typeof event.content === 'string') {
+        text.push(event.content);
+        if (!request.json && !request.streamJson)
+            stdout.write(event.content);
+    }
+    if (event.type === 'tool_call' && !request.json && !request.streamJson) {
+        const name = typeof event.payload?.name === 'string' ? event.payload.name : 'tool';
+        stderr.write(`tool ${name}\n`);
+    }
+    if (event.type === 'error') {
+        const message = typeof event.message === 'string' ? event.message : 'error';
+        if (!request.streamJson)
+            stderr.write(`${message}\n`);
+        if (event.code === 'chat_busy')
+            return 6;
+        if (message.includes('storage upgrade blocked') || message.includes('newer than this program'))
+            return 75;
+        return 1;
+    }
+    if (event.type === 'budget_exhausted') {
+        if (!request.streamJson)
+            stderr.write('budget exhausted\n');
+        return 4;
+    }
+    return 0;
+}

package/dist/tui/keys.d.ts

@@ -0,0 +1,55 @@
+import { type Keybinding, type KeybindingsConfig } from '@earendil-works/pi-tui';
+declare module '@earendil-works/pi-tui' {
+    interface Keybindings {
+        'agent.interrupt': true;
+        'agent.chats': true;
+        'agent.approval.allowOnce': true;
+        'agent.approval.allowSession': true;
+        'agent.approval.allowAlways': true;
+        'agent.approval.denyOnce': true;
+        'agent.approval.denySession': true;
+        'agent.approval.denyAlways': true;
+        'agent.approval.abort': true;
+    }
+}
+export declare const AGENT_KEYBINDINGS: {
+    readonly 'agent.interrupt': {
+        readonly defaultKeys: "ctrl+c";
+        readonly description: "Interrupt the current turn or leave";
+    };
+    readonly 'agent.chats': {
+        readonly defaultKeys: "ctrl+l";
+        readonly description: "Show chats";
+    };
+    readonly 'agent.approval.allowOnce': {
+        readonly defaultKeys: "y";
+        readonly description: "Allow this tool once";
+    };
+    readonly 'agent.approval.allowSession': {
+        readonly defaultKeys: "s";
+        readonly description: "Allow this tool for the chat";
+    };
+    readonly 'agent.approval.allowAlways': {
+        readonly defaultKeys: "a";
+        readonly description: "Always allow this tool";
+    };
+    readonly 'agent.approval.denyOnce': {
+        readonly defaultKeys: "n";
+        readonly description: "Deny this tool once";
+    };
+    readonly 'agent.approval.denySession': {
+        readonly defaultKeys: "shift+n";
+        readonly description: "Deny this tool for the chat";
+    };
+    readonly 'agent.approval.denyAlways': {
+        readonly defaultKeys: "shift+a";
+        readonly description: "Always deny this tool";
+    };
+    readonly 'agent.approval.abort': {
+        readonly defaultKeys: "escape";
+        readonly description: "Abort the turn";
+    };
+};
+export declare function installAgentKeybindings(user?: KeybindingsConfig): void;
+export declare function ensureAgentKeybindings(): void;
+export declare function keyLabel(id: Keybinding): string;

package/dist/tui/keys.js

@@ -0,0 +1,40 @@
+import { getKeybindings, KeybindingsManager, setKeybindings, TUI_KEYBINDINGS, } from '@earendil-works/pi-tui';
+export const AGENT_KEYBINDINGS = {
+    'agent.interrupt': { defaultKeys: 'ctrl+c', description: 'Interrupt the current turn or leave' },
+    'agent.chats': { defaultKeys: 'ctrl+l', description: 'Show chats' },
+    'agent.approval.allowOnce': { defaultKeys: 'y', description: 'Allow this tool once' },
+    'agent.approval.allowSession': { defaultKeys: 's', description: 'Allow this tool for the chat' },
+    'agent.approval.allowAlways': { defaultKeys: 'a', description: 'Always allow this tool' },
+    'agent.approval.denyOnce': { defaultKeys: 'n', description: 'Deny this tool once' },
+    'agent.approval.denySession': { defaultKeys: 'shift+n', description: 'Deny this tool for the chat' },
+    'agent.approval.denyAlways': { defaultKeys: 'shift+a', description: 'Always deny this tool' },
+    'agent.approval.abort': { defaultKeys: 'escape', description: 'Abort the turn' },
+};
+const DEFINITIONS = { ...TUI_KEYBINDINGS, ...AGENT_KEYBINDINGS };
+export function installAgentKeybindings(user = {}) {
+    setKeybindings(new KeybindingsManager(DEFINITIONS, user));
+}
+export function ensureAgentKeybindings() {
+    if (getKeybindings().getKeys('agent.interrupt').length === 0)
+        installAgentKeybindings();
+}
+export function keyLabel(id) {
+    ensureAgentKeybindings();
+    const key = getKeybindings().getKeys(id)[0] ?? '';
+    return formatKey(key);
+}
+function formatKey(key) {
+    if (key === 'escape')
+        return 'Esc';
+    if (/^shift\+[a-z]$/.test(key))
+        return key.slice('shift+'.length).toUpperCase();
+    if (!key.includes('+'))
+        return key;
+    return key.split('+').map((part) => {
+        if (part === 'ctrl')
+            return 'Ctrl';
+        if (part.length === 1)
+            return part.toUpperCase();
+        return part[0].toUpperCase() + part.slice(1);
+    }).join('+');
+}

package/dist/tui/run.d.ts

@@ -0,0 +1,8 @@
+import { type Terminal } from '@earendil-works/pi-tui';
+import type { AgentClient } from '@steerable/agent-client';
+export declare function runTui(options: {
+    client: AgentClient;
+    product: string;
+    dataDir?: string;
+    terminal?: Terminal;
+}): Promise<number>;