@steerable/agent-cli 0.6.57

package/dist/tui/run.js

@@ -0,0 +1,25 @@
+import { ProcessTerminal, TuiAltScreen } from '@earendil-works/pi-tui';
+import { installAgentKeybindings } from './keys.js';
+import { AgentTui } from './session.js';
+export async function runTui(options) {
+    installAgentKeybindings();
+    const terminal = options.terminal ?? new ProcessTerminal();
+    const tui = new TuiAltScreen(terminal);
+    return new Promise((resolve) => {
+        const session = new AgentTui(options.client, {
+            product: options.product,
+            ...(options.dataDir ? { dataDir: options.dataDir } : {}),
+            onChange() {
+                tui.requestRender();
+            },
+            onExit() {
+                tui.stop();
+                resolve(0);
+            },
+        });
+        tui.addChild(session);
+        tui.setFocus(session);
+        void session.open().then(() => tui.requestRender());
+        tui.start();
+    });
+}

package/dist/tui/screen.d.ts

@@ -0,0 +1,33 @@
+export interface TranscriptLine {
+    kind: 'user' | 'assistant' | 'tool';
+    text?: string;
+    name?: string;
+    args?: string;
+    status?: string;
+}
+export interface ChatRow {
+    id: string;
+    title: string;
+    busy: boolean;
+    selected: boolean;
+}
+export interface TuiScreen {
+    product: string;
+    title: string;
+    modelName: string;
+    lines: TranscriptLine[];
+    approval: {
+        toolName: string;
+        summary: string;
+    } | null;
+    ask: {
+        prompt: string;
+    } | null;
+    chats: ChatRow[] | null;
+    readOnly: boolean;
+    help: boolean;
+    draft: string;
+    status: string;
+}
+export declare function renderScreen(screen: TuiScreen, width: number): string[];
+export declare function visibleText(lines: string[]): string;

package/dist/tui/screen.js

@@ -0,0 +1,59 @@
+import { Box, Text } from '@earendil-works/pi-tui';
+import { keyLabel } from './keys.js';
+export function renderScreen(screen, width) {
+    const box = new Box(0, 0);
+    for (const line of screenLines(screen))
+        box.addChild(new PlainLine(line));
+    return box.render(width);
+}
+export function visibleText(lines) {
+    return lines.map((line) => line.trimEnd()).join('\n');
+}
+function screenLines(screen) {
+    const lines = [`${screen.product} · ${screen.title} · ${screen.modelName}`];
+    if (screen.help) {
+        lines.push('/new 新会话', '/model 查看或切换模型', '/clear 清屏', '/help 帮助');
+    }
+    else if (screen.chats) {
+        lines.push('会话');
+        for (const chat of screen.chats) {
+            const mark = chat.selected ? '*' : ' ';
+            const busy = chat.busy ? '  只读' : '';
+            lines.push(`${mark} ${chat.id}  ${chat.title}${busy}`);
+        }
+    }
+    else {
+        for (const line of screen.lines) {
+            if (line.kind === 'tool')
+                lines.push(`▸ ${line.name}  ${line.args}  ${line.status ?? ''}`.trimEnd());
+            else if (line.kind === 'user')
+                lines.push(`user ${line.text ?? ''}`);
+            else
+                lines.push(line.text ?? '');
+        }
+    }
+    if (screen.readOnly)
+        lines.push('只读 · 另一个进程正在运行');
+    if (screen.approval) {
+        lines.push(`审批 ${screen.approval.toolName} ${screen.approval.summary}`.trimEnd());
+        lines.push(`${keyLabel('agent.approval.allowOnce')} 本次允许  ${keyLabel('agent.approval.allowSession')} 本会话  ${keyLabel('agent.approval.allowAlways')} 总是`);
+        lines.push(`${keyLabel('agent.approval.denyOnce')} 拒绝  ${keyLabel('agent.approval.denySession')} 本会话拒绝  ${keyLabel('agent.approval.denyAlways')} 总是拒绝  ${keyLabel('agent.approval.abort')} 中止`);
+    }
+    if (screen.ask)
+        lines.push(`追问 ${screen.ask.prompt}`);
+    lines.push(`> ${screen.draft}`);
+    if (screen.status)
+        lines.push(screen.status);
+    lines.push(`${keyLabel('agent.interrupt')} 中断 · ${keyLabel('agent.chats')} 会话 · /help`);
+    return lines;
+}
+class PlainLine {
+    text;
+    constructor(text) {
+        this.text = text;
+    }
+    invalidate() { }
+    render(width) {
+        return new Text(this.text.length > 0 ? this.text : ' ', 0, 0).render(width);
+    }
+}

package/dist/tui/session.d.ts

@@ -0,0 +1,48 @@
+import { type Component } from '@earendil-works/pi-tui';
+import { type AgentClient } from '@steerable/agent-client';
+export interface AgentTuiOptions {
+    product: string;
+    dataDir?: string;
+    busyChatIds?: string[];
+    onExit: () => void;
+    onChange?: () => void;
+}
+export declare class AgentTui implements Component {
+    private readonly client;
+    private readonly options;
+    private title;
+    private modelName;
+    private chatId;
+    private lines;
+    private rows;
+    private chats;
+    private selected;
+    private approval;
+    private ask;
+    private readOnly;
+    private help;
+    private draft;
+    private status;
+    private stopped;
+    private turnAbort;
+    private pending;
+    constructor(client: AgentClient, options: AgentTuiOptions);
+    open(): Promise<void>;
+    settled(): Promise<void>;
+    invalidate(): void;
+    render(width: number): string[];
+    handleInput(data: string): void;
+    private screen;
+    private showChats;
+    private loadChats;
+    private markSelection;
+    private openChat;
+    private submit;
+    private slash;
+    private runTurn;
+    private observe;
+    private watch;
+    private decide;
+    private touch;
+    private exit;
+}

package/dist/tui/session.js

@@ -0,0 +1,367 @@
+import { getKeybindings } from '@earendil-works/pi-tui';
+import { listBusyChatIds } from '@steerable/agent-client';
+import { ensureAgentKeybindings } from './keys.js';
+import { renderScreen } from './screen.js';
+export class AgentTui {
+    client;
+    options;
+    title = '新会话';
+    modelName = '';
+    chatId = null;
+    lines = [];
+    rows = [];
+    chats = null;
+    selected = 0;
+    approval = null;
+    ask = null;
+    readOnly = false;
+    help = false;
+    draft = '';
+    status = '';
+    stopped = false;
+    turnAbort = null;
+    pending = Promise.resolve();
+    constructor(client, options) {
+        this.client = client;
+        this.options = options;
+        ensureAgentKeybindings();
+    }
+    async open() {
+        const settings = await this.client.request('GET', '/api/v2/local-settings/llm', undefined);
+        if (settings.status === 200) {
+            const model = settings.data.model;
+            if (model)
+                this.modelName = model;
+        }
+        this.rows = await this.loadChats();
+        const current = this.rows[0];
+        if (current)
+            await this.openChat(current.id);
+        void this.watch();
+        this.touch();
+    }
+    async settled() {
+        await this.pending;
+    }
+    invalidate() { }
+    render(width) {
+        return renderScreen(this.screen(), width);
+    }
+    handleInput(data) {
+        if (data.length > 1 && !data.includes('\x1b')) {
+            for (const char of data)
+                this.handleInput(char);
+            return;
+        }
+        const keys = getKeybindings();
+        if (keys.matches(data, 'agent.interrupt')) {
+            if (this.turnAbort && !this.turnAbort.signal.aborted) {
+                this.turnAbort.abort();
+                this.status = '已中断';
+                return;
+            }
+            if (this.approval) {
+                void this.decide('abort');
+                return;
+            }
+            this.exit();
+            return;
+        }
+        if (this.approval) {
+            const kind = approvalKind(data);
+            if (kind)
+                void this.decide(kind);
+            return;
+        }
+        if (this.help) {
+            if (keys.matches(data, 'tui.select.cancel'))
+                this.help = false;
+            return;
+        }
+        if (this.chats) {
+            if (keys.matches(data, 'tui.select.up'))
+                this.selected = Math.max(0, this.selected - 1);
+            if (keys.matches(data, 'tui.select.down'))
+                this.selected = Math.min(this.chats.length - 1, this.selected + 1);
+            if (keys.matches(data, 'tui.select.cancel')) {
+                this.chats = null;
+                return;
+            }
+            if (keys.matches(data, 'tui.select.confirm')) {
+                const chat = this.chats[this.selected];
+                this.chats = null;
+                if (chat) {
+                    this.readOnly = chat.busy;
+                    this.title = chat.title;
+                    this.chatId = chat.id;
+                    void this.openChat(chat.id);
+                }
+                return;
+            }
+            this.markSelection();
+            return;
+        }
+        if (keys.matches(data, 'agent.chats')) {
+            this.showChats();
+            return;
+        }
+        if (this.ask && keys.matches(data, 'tui.input.submit')) {
+            const requestId = this.ask.requestId;
+            const answer = this.draft;
+            this.draft = '';
+            this.ask = null;
+            void this.client.answerAsk(requestId, { text: answer });
+            return;
+        }
+        if (keys.matches(data, 'tui.input.newLine')) {
+            this.draft += '\n';
+            return;
+        }
+        if (keys.matches(data, 'tui.input.submit')) {
+            void this.submit();
+            return;
+        }
+        if (keys.matches(data, 'tui.editor.deleteCharBackward')) {
+            this.draft = [...this.draft].slice(0, -1).join('');
+            return;
+        }
+        if (data.length > 0 && [...data].every((char) => char >= ' ' && char !== '\x7f'))
+            this.draft += data;
+    }
+    screen() {
+        return {
+            product: this.options.product,
+            title: this.title,
+            modelName: this.modelName,
+            lines: this.lines,
+            approval: this.approval,
+            ask: this.ask ? { prompt: this.ask.prompt } : null,
+            chats: this.chats,
+            readOnly: this.readOnly,
+            help: this.help,
+            draft: this.draft,
+            status: this.status,
+        };
+    }
+    showChats() {
+        const index = this.rows.findIndex((chat) => chat.id === this.chatId);
+        this.selected = index >= 0 ? index : 0;
+        this.chats = this.rows.map((chat, row) => ({ ...chat, selected: row === this.selected }));
+        void this.loadChats().then((rows) => {
+            this.rows = rows;
+            if (this.chats)
+                this.markSelection();
+        });
+    }
+    async loadChats() {
+        const listed = await this.client.request('GET', '/api/v2/chats', undefined);
+        const rows = listed.status === 200
+            ? (listed.data.chats ?? [])
+            : [];
+        const busy = new Set(this.options.busyChatIds ?? (this.options.dataDir ? listBusyChatIds(this.options.dataDir) : []));
+        return rows.map((chat) => ({
+            id: chat.id,
+            title: chat.title || chat.id,
+            busy: busy.has(chat.id),
+            selected: false,
+        }));
+    }
+    markSelection() {
+        this.chats = (this.chats ?? []).map((chat, index) => ({ ...chat, selected: index === this.selected }));
+    }
+    async openChat(id) {
+        const encoded = encodeURIComponent(id);
+        const chat = await this.client.request('GET', `/api/v2/chats/${encoded}`, undefined);
+        const messages = await this.client.request('GET', `/api/v2/chats/${encoded}/messages`, undefined);
+        this.chatId = id;
+        const title = chat.status === 200 ? chat.data.title : '';
+        this.title = title || id;
+        this.readOnly = (this.options.busyChatIds ?? []).includes(id)
+            || (this.options.dataDir ? listBusyChatIds(this.options.dataDir).includes(id) : false);
+        const records = messages.status === 200
+            ? (messages.data.messages ?? [])
+            : [];
+        this.lines = records.map((message) => ({
+            kind: message.role === 'user' ? 'user' : 'assistant',
+            text: message.content ?? '',
+        }));
+        this.help = false;
+        this.touch();
+    }
+    async submit() {
+        const text = this.draft.trim();
+        this.draft = '';
+        if (!text)
+            return;
+        if (text.startsWith('/')) {
+            await this.slash(text);
+            return;
+        }
+        if (this.readOnly) {
+            this.status = '只读 · 另一个进程正在运行';
+            return;
+        }
+        this.lines.push({ kind: 'user', text });
+        this.pending = this.runTurn(text);
+        await this.pending;
+    }
+    async slash(text) {
+        const [command, ...rest] = text.slice(1).split(/\s+/);
+        if (command === 'help') {
+            this.help = true;
+            this.touch();
+            return;
+        }
+        if (command === 'clear') {
+            this.lines = [];
+            this.status = '';
+            this.touch();
+            return;
+        }
+        if (command === 'new') {
+            const created = await this.client.request('POST', '/api/v2/chats/new', {});
+            const chatId = created.data.chatId;
+            if (!chatId) {
+                this.status = 'failed to create chat';
+                return;
+            }
+            this.lines = [];
+            this.readOnly = false;
+            await this.openChat(chatId);
+            return;
+        }
+        if (command === 'model') {
+            const next = rest.join(' ');
+            if (!next) {
+                this.status = this.modelName;
+                return;
+            }
+            const current = await this.client.request('GET', '/api/v2/local-settings/llm', undefined);
+            const body = { ...current.data, model: next };
+            const saved = await this.client.request('POST', '/api/v2/local-settings/llm', body);
+            if (saved.status === 200)
+                this.modelName = next;
+            else
+                this.status = `config set failed (${saved.status})`;
+            this.touch();
+            return;
+        }
+        this.status = `unknown command /${command}`;
+        this.touch();
+    }
+    async runTurn(text) {
+        if (!this.chatId) {
+            const created = await this.client.request('POST', '/api/v2/chats/new', {});
+            this.chatId = created.data.chatId ?? 'draft';
+            this.title = this.chatId;
+            this.touch();
+        }
+        const controller = new AbortController();
+        this.turnAbort = controller;
+        this.status = '';
+        try {
+            for await (const event of this.client.stream(`/api/v2/chats/${encodeURIComponent(this.chatId)}/send`, { message: text }, controller.signal)) {
+                this.observe(event, controller.signal);
+                this.touch();
+            }
+        }
+        finally {
+            if (this.turnAbort === controller)
+                this.turnAbort = null;
+        }
+    }
+    observe(event, signal) {
+        if (event.type === 'tool_call') {
+            const payload = event.payload ?? {};
+            const name = typeof payload.name === 'string' ? payload.name : 'tool';
+            const args = toolArgs(payload.arguments ?? payload.input);
+            this.lines.push({ kind: 'tool', name, args, status: '…' });
+            return;
+        }
+        if (event.type === 'tool_result') {
+            const tool = [...this.lines].reverse().find((line) => line.kind === 'tool' && line.status === '…');
+            if (tool)
+                tool.status = '✓';
+            return;
+        }
+        if (event.type === 'content' && typeof event.content === 'string') {
+            const last = this.lines[this.lines.length - 1];
+            if (last?.kind === 'assistant')
+                last.text = `${last.text ?? ''}${event.content}`;
+            else
+                this.lines.push({ kind: 'assistant', text: event.content });
+            return;
+        }
+        if (event.type === 'error' && !signal.aborted) {
+            this.status = typeof event.message === 'string' ? event.message : 'error';
+        }
+    }
+    async watch() {
+        for await (const event of this.client.events()) {
+            if (this.stopped)
+                return;
+            if (event.channel === 'approval:request') {
+                const payload = event.payload;
+                if (!payload.requestId)
+                    continue;
+                this.approval = {
+                    requestId: payload.requestId,
+                    toolName: payload.toolName || 'tool',
+                    summary: toolArgs(payload.arguments),
+                };
+            }
+            else if (event.channel === 'ask-user:request') {
+                const payload = event.payload;
+                if (payload.requestId)
+                    this.ask = { requestId: payload.requestId, prompt: payload.prompt ?? '' };
+            }
+            this.touch();
+        }
+    }
+    async decide(kind) {
+        const request = this.approval;
+        if (!request)
+            return;
+        this.approval = null;
+        this.touch();
+        await this.client.decideApproval(request.requestId, kind);
+    }
+    touch() {
+        this.options.onChange?.();
+    }
+    exit() {
+        this.stopped = true;
+        this.turnAbort?.abort();
+        this.options.onExit();
+    }
+}
+function approvalKind(data) {
+    const keys = getKeybindings();
+    if (keys.matches(data, 'agent.approval.allowOnce'))
+        return 'allow_once';
+    if (keys.matches(data, 'agent.approval.allowSession'))
+        return 'allow_for_session';
+    if (keys.matches(data, 'agent.approval.allowAlways'))
+        return 'allow_always';
+    if (keys.matches(data, 'agent.approval.denyOnce'))
+        return 'deny_once';
+    if (keys.matches(data, 'agent.approval.denySession'))
+        return 'deny_for_session';
+    if (keys.matches(data, 'agent.approval.denyAlways'))
+        return 'deny_always';
+    if (keys.matches(data, 'agent.approval.abort'))
+        return 'abort';
+    return null;
+}
+function toolArgs(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value && typeof value === 'object' && 'command' in value) {
+        const command = value.command;
+        if (typeof command === 'string')
+            return command;
+    }
+    if (value === undefined)
+        return '';
+    return JSON.stringify(value);
+}

package/dist/tui/smoke-entry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tui/smoke-entry.js

@@ -0,0 +1,70 @@
+import { runTui } from './run.js';
+const queue = [];
+const waiters = [];
+let closed = false;
+let decided = () => { };
+function push(item) {
+    const waiter = waiters.shift();
+    if (waiter)
+        waiter(item);
+    else if (item)
+        queue.push(item);
+}
+const client = {
+    lastStatus: 200,
+    request: async (method, requestPath) => {
+        if (method === 'GET' && requestPath === '/api/v2/chats')
+            return { status: 200, data: { chats: [] } };
+        if (method === 'GET' && requestPath === '/api/v2/local-settings/llm')
+            return { status: 200, data: { model: 'demo-model' } };
+        if (method === 'POST' && requestPath === '/api/v2/chats/new')
+            return { status: 200, data: { chatId: 'chat-1' } };
+        return { status: 200, data: {} };
+    },
+    async *stream(_requestPath, body, signal) {
+        const message = String(body.message ?? '');
+        if (message.includes('hang')) {
+            yield { type: 'content', content: 'running' };
+            await new Promise((resolve) => signal.addEventListener('abort', () => resolve()));
+            yield { type: 'error', message: 'interrupted' };
+            return;
+        }
+        yield { type: 'tool_call', payload: { name: 'local_exec_shell', arguments: { command: 'ls' } } };
+        const approval = new Promise((resolve) => {
+            decided = resolve;
+        });
+        push({
+            channel: 'approval:request',
+            payload: { requestId: 'req-1', toolName: 'local_exec_shell', arguments: { command: 'ls' } },
+        });
+        await approval;
+        yield { type: 'tool_result', payload: { name: 'local_exec_shell' } };
+        yield { type: 'content', content: 'listed' };
+    },
+    async *events() {
+        while (!closed) {
+            const queued = queue.shift();
+            if (queued) {
+                yield queued;
+                continue;
+            }
+            const next = await new Promise((resolve) => waiters.push(resolve));
+            if (!next)
+                return;
+            yield next;
+        }
+    },
+    decideApproval: async () => {
+        decided();
+        return true;
+    },
+    answerAsk: async () => true,
+    close: async () => {
+        closed = true;
+        for (const waiter of waiters.splice(0))
+            waiter(null);
+    },
+};
+await runTui({ client, product: 'Demo' });
+await client.close();
+process.exit(0);

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@steerable/agent-cli",
+  "version": "0.6.57",
+  "description": "Product-neutral command line for a Steerable host. Products supply the bin name and brand.",
+  "license": "Apache-2.0",
+  "homepage": "https://steerableframework.com/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pathlyapp/steerable.git",
+    "directory": "packages/agent-cli/ts"
+  },
+  "bugs": {
+    "url": "https://github.com/pathlyapp/steerable/issues"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "steerable-cli": "dist/bin.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@earendil-works/pi-tui": "0.87.1",
+    "@steerable/agent-client": "0.6.57",
+    "@steerable/agent-protocol": "0.6.57",
+    "@steerable/agent-shell": "0.6.57"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.5",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "gen": "echo agent-cli",
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "lint": "tsc -p tsconfig.json --noEmit",
+    "check:drift": "echo ok"
+  }
+}