pi2web 0.2.0 → 0.2.6

package/dist/session-namer.js

@@ -0,0 +1,163 @@
+import { EventEmitter } from 'node:events';
+import { assistantText, authHeaders, clipSummaryField, deadline, endpoint, prepareSummaryInput } from './voice.js';
+// No `temperature`: current reasoning models (gpt-5.x, gpt-6-luna, mai-code-*) reject the request with
+// "Unsupported parameter: 'temperature'", and naming does not need it.
+export const DEFAULT_SESSION_NAMER = {
+    baseUrl: 'http://localhost:8313/',
+    model: 'gpt-5.4-nano',
+    language: 'zh-CN',
+    // Reasoning models (gpt-5.x and friends) burn this budget on hidden reasoning tokens before they
+    // emit the name, so a tight cap yields an empty message with finish_reason "length".
+    maxInputChars: 8000,
+    maxOutputTokens: 2000,
+    requestTimeoutMs: 60000
+};
+export function parseSessionName(text) {
+    const trimmed = text
+        .trim()
+        .replace(/^```(?:json)?\s*/i, '')
+        .replace(/\s*```$/, '');
+    let candidate = trimmed;
+    const start = trimmed.indexOf('{'), end = trimmed.lastIndexOf('}');
+    if (start >= 0 && end > start) {
+        try {
+            const value = JSON.parse(trimmed.slice(start, end + 1));
+            if (typeof value?.sessionName === 'string')
+                candidate = value.sessionName;
+        }
+        catch {
+            /* fall back to the raw text below */
+        }
+    }
+    const name = candidate
+        .replace(/[\r\n\t]+/g, ' ')
+        .replace(/\s{2,}/g, ' ')
+        .replace(/^["'“”‘’]|["'“”‘’]$/g, '')
+        .trim()
+        .slice(0, 60)
+        .trim();
+    return name || undefined;
+}
+export class SessionNamer {
+    fetcher;
+    emitter = new EventEmitter();
+    lastAssistant = new Map();
+    lastPrompt = new Map();
+    pending = new Set();
+    closed = false;
+    config;
+    constructor(config = {}, fetcher = fetch) {
+        this.fetcher = fetcher;
+        this.config = { apiKey: '', ...DEFAULT_SESSION_NAMER, ...strip(config) };
+    }
+    subscribe(listener) {
+        this.emitter.on('event', listener);
+        return () => this.emitter.off('event', listener);
+    }
+    close() {
+        this.closed = true;
+        this.emitter.removeAllListeners();
+        this.lastAssistant.clear();
+        this.lastPrompt.clear();
+    }
+    recordUserPrompt(agentId, prompt) {
+        const value = prompt.trim();
+        if (value)
+            this.lastPrompt.set(agentId, value);
+    }
+    emit(agentId, event) {
+        this.emitter.emit('event', agentId, event);
+    }
+    handleAgentEvent(agentId, event, context = {}) {
+        if (this.closed)
+            return;
+        if (event.type === 'before_agent_start' && typeof event.prompt === 'string')
+            return void this.recordUserPrompt(agentId, event.prompt);
+        if (event.type === 'agent_start') {
+            if (typeof event.message === 'string')
+                this.recordUserPrompt(agentId, event.message);
+            return;
+        }
+        if (event.type === 'message_end') {
+            const text = assistantText(event.message);
+            if (text)
+                this.lastAssistant.set(agentId, text);
+            return;
+        }
+        if (event.type !== 'agent_settled')
+            return;
+        const finalOutput = this.lastAssistant.get(agentId) ?? '', userPrompt = this.lastPrompt.get(agentId) ?? '';
+        this.lastAssistant.delete(agentId);
+        this.lastPrompt.delete(agentId);
+        if (context.sessionName?.trim() || !context.setSessionName)
+            return;
+        if (!userPrompt && !finalOutput)
+            return;
+        void this.nameSession(agentId, userPrompt, finalOutput, context.setSessionName);
+    }
+    /** Generates and applies a name. Exposed so callers can trigger naming outside the event stream. */
+    async nameSession(agentId, userPrompt, finalOutput, apply) {
+        if (this.pending.has(agentId))
+            return;
+        this.pending.add(agentId);
+        try {
+            const name = await this.requestName(userPrompt, finalOutput);
+            if (!name)
+                throw new Error('Naming endpoint returned no session name');
+            await apply(name);
+            this.emit(agentId, { type: 'session_name_generated', name });
+        }
+        catch (error) {
+            this.emit(agentId, { type: 'session_name_error', message: error.message });
+        }
+        finally {
+            this.pending.delete(agentId);
+        }
+    }
+    async requestName(userPrompt, finalOutput) {
+        const promptBudget = Math.max(1, Math.floor(this.config.maxInputChars * 0.6));
+        const body = JSON.stringify({
+            userPrompt: clipSummaryField(userPrompt, promptBudget),
+            piFinalOutput: prepareSummaryInput(finalOutput, Math.max(1, this.config.maxInputChars - promptBudget))
+        });
+        const response = await this.fetcher(endpoint(this.config.baseUrl, '/chat/completions'), {
+            method: 'POST',
+            signal: deadline(this.config.requestTimeoutMs),
+            headers: { 'content-type': 'application/json', ...authHeaders(this.config.apiKey || undefined) },
+            body: JSON.stringify({
+                model: this.config.model,
+                stream: false,
+                max_tokens: this.config.maxOutputTokens,
+                messages: [
+                    { role: 'system', content: this.prompt() },
+                    { role: 'user', content: body }
+                ]
+            })
+        });
+        if (!response.ok)
+            throw new Error(`Session naming request failed (${response.status}): ${(await response.text()).slice(0, 300)}`);
+        const value = await response.json();
+        const choice = value?.choices?.[0];
+        const content = choice?.message?.content;
+        const text = typeof content === 'string'
+            ? content
+            : Array.isArray(content)
+                ? content
+                    .filter((part) => part?.type === 'text' && typeof part.text === 'string')
+                    .map((part) => part.text)
+                    .join('')
+                : '';
+        if (!text.trim())
+            throw new Error(choice?.finish_reason === 'length'
+                ? `Naming endpoint returned no content: the model hit the ${this.config.maxOutputTokens}-token output budget (raise --session-name-max-output-tokens)`
+                : 'Naming endpoint returned no content');
+        return parseSessionName(text);
+    }
+    prompt() {
+        const language = this.config.language.toLowerCase().startsWith('zh')
+            ? '简体中文'
+            : '与用户输入相同的主要语言';
+        return `你负责为一次 Pi 编程会话生成标题。\n\n输入是一个 JSON 对象：\n- userPrompt：用户本轮真正想完成的任务。\n- piFinalOutput：Pi 最后一次回复。\n\n主要依据 userPrompt 概括任务主题，必要时参考 piFinalOutput。标题使用${language}：中文 6 到 18 个字，英文 3 到 8 个词；具体、便于检索，不写“新会话”“任务总结”等空泛名称，不带句号、引号、Emoji、代码或路径。\n\n只输出一个合法 JSON 对象：{"sessionName":"简短标题"}，不要输出 Markdown 代码块、解释或任何额外文字。`;
+    }
+}
+const strip = (value) => Object.fromEntries(Object.entries(value).filter(([, v]) => v !== undefined && v !== ''));

package/dist/terminals.js

@@ -5,7 +5,7 @@ import { randomUUID } from 'node:crypto';
 import * as pty from 'node-pty';
 const defaultFactory = (cwd, cols, rows) => {
     const windows = process.platform === 'win32';
-    const shell = windows ? (process.env.COMSPEC || 'cmd.exe') : (process.env.SHELL || '/bin/sh');
+    const shell = windows ? process.env.COMSPEC || 'cmd.exe' : process.env.SHELL || '/bin/sh';
     const env = Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] !== undefined));
     return pty.spawn(shell, [], { name: 'xterm-256color', cwd, cols, rows, env, useConpty: windows });
 };
@@ -23,13 +23,23 @@ export class TerminalManager {
         this.maxBuffer = maxBuffer;
         this.maxRetained = maxRetained;
     }
-    list() { return [...this.terminals.values()].map(x => ({ ...x.record })).sort((a, b) => b.lastActiveAt.localeCompare(a.lastActiveAt)); }
-    get(id) { const entry = this.terminals.get(id); if (!entry)
-        throw Object.assign(new Error('Terminal not found'), { code: 'TERMINAL_NOT_FOUND' }); return entry; }
+    list() {
+        return [...this.terminals.values()]
+            .map(x => ({ ...x.record }))
+            .sort((a, b) => b.lastActiveAt.localeCompare(a.lastActiveAt));
+    }
+    get(id) {
+        const entry = this.terminals.get(id);
+        if (!entry)
+            throw Object.assign(new Error('Terminal not found'), { code: 'TERMINAL_NOT_FOUND' });
+        return entry;
+    }
     async create(workspaceId, relativeCwd = '.', cols = 80, rows = 24) {
         this.pruneExited();
         if (this.list().filter(x => x.status === 'running').length >= this.maxRunning)
-            throw Object.assign(new Error(`At most ${this.maxRunning} terminals may run at once`), { code: 'TERMINAL_LIMIT' });
+            throw Object.assign(new Error(`At most ${this.maxRunning} terminals may run at once`), {
+                code: 'TERMINAL_LIMIT'
+            });
         const workspace = this.workspaces.get(workspaceId);
         if (!workspace)
             throw Object.assign(new Error('Workspace not found'), { code: 'WORKSPACE_NOT_FOUND' });
@@ -37,34 +47,91 @@ export class TerminalManager {
         if (!(await stat(cwd)).isDirectory())
             throw Object.assign(new Error('cwd is not a directory'), { code: 'NOT_A_DIRECTORY' });
         const terminalId = `terminal-${randomUUID()}`, now = new Date().toISOString(), process = this.factory(cwd, this.dimension(cols, 80), this.dimension(rows, 24));
-        const record = { terminalId, workspaceId, cwd, title: path.basename(cwd) || cwd, status: 'running', createdAt: now, lastActiveAt: now };
+        const record = {
+            terminalId,
+            workspaceId,
+            cwd,
+            title: path.basename(cwd) || cwd,
+            status: 'running',
+            createdAt: now,
+            lastActiveAt: now
+        };
         const entry = { record, process, emitter: new EventEmitter(), buffer: '' };
         this.terminals.set(terminalId, entry);
-        entry.dataSubscription = process.onData(data => { entry.buffer = (entry.buffer + data).slice(-this.maxBuffer); entry.record.lastActiveAt = new Date().toISOString(); entry.emitter.emit('event', { type: 'output', data }); });
-        const exitSubscription = process.onExit(event => { entry.record.status = 'exited'; entry.record.exitCode = event.exitCode; entry.record.lastActiveAt = new Date().toISOString(); entry.emitter.emit('event', { type: 'exit', exitCode: event.exitCode }); this.disposeProcessListeners(entry); this.pruneExited(); });
+        entry.dataSubscription = process.onData(data => {
+            entry.buffer = (entry.buffer + data).slice(-this.maxBuffer);
+            entry.record.lastActiveAt = new Date().toISOString();
+            entry.emitter.emit('event', { type: 'output', data });
+        });
+        const exitSubscription = process.onExit(event => {
+            entry.record.status = 'exited';
+            entry.record.exitCode = event.exitCode;
+            entry.record.lastActiveAt = new Date().toISOString();
+            entry.emitter.emit('event', { type: 'exit', exitCode: event.exitCode });
+            this.disposeProcessListeners(entry);
+            this.pruneExited();
+        });
         if (entry.record.status === 'exited')
             exitSubscription.dispose();
         else
             entry.exitSubscription = exitSubscription;
         return { ...record };
     }
-    snapshot(id) { const entry = this.get(id); return { record: { ...entry.record }, data: entry.buffer }; }
-    write(id, data) { const entry = this.get(id); if (entry.record.status !== 'running')
-        throw Object.assign(new Error('Terminal has exited'), { code: 'TERMINAL_EXITED' }); if (typeof data !== 'string' || data.length > 64 * 1024)
-        throw Object.assign(new Error('Invalid terminal input'), { code: 'INVALID_REQUEST' }); entry.process.write(data); entry.record.lastActiveAt = new Date().toISOString(); }
-    resize(id, cols, rows) { const entry = this.get(id); if (entry.record.status === 'running')
-        entry.process.resize(this.dimension(cols, 80), this.dimension(rows, 24)); }
-    subscribe(id, listener) { const entry = this.get(id); entry.emitter.on('event', listener); return () => entry.emitter.off('event', listener); }
-    close(id) { const entry = this.get(id); this.terminals.delete(id); if (entry.record.status === 'running')
-        entry.emitter.emit('event', { type: 'exit', exitCode: -1 }); this.disposeProcessListeners(entry); if (entry.record.status === 'running')
-        try {
-            entry.process.kill();
-        }
-        catch { } entry.emitter.removeAllListeners(); }
-    closeAll() { for (const id of [...this.terminals.keys()])
-        this.close(id); }
-    disposeProcessListeners(entry) { entry.dataSubscription?.dispose(); entry.exitSubscription?.dispose(); entry.dataSubscription = undefined; entry.exitSubscription = undefined; }
-    pruneExited() { const exited = [...this.terminals.entries()].reverse().filter(([, entry]) => entry.record.status === 'exited').sort((a, b) => b[1].record.lastActiveAt.localeCompare(a[1].record.lastActiveAt)); for (const [id] of exited.slice(this.maxRetained))
-        this.close(id); }
-    dimension(value, fallback) { return Number.isInteger(value) && value > 0 && value <= 1000 ? value : fallback; }
+    snapshot(id) {
+        const entry = this.get(id);
+        return { record: { ...entry.record }, data: entry.buffer };
+    }
+    write(id, data) {
+        const entry = this.get(id);
+        if (entry.record.status !== 'running')
+            throw Object.assign(new Error('Terminal has exited'), { code: 'TERMINAL_EXITED' });
+        if (typeof data !== 'string' || data.length > 64 * 1024)
+            throw Object.assign(new Error('Invalid terminal input'), { code: 'INVALID_REQUEST' });
+        entry.process.write(data);
+        entry.record.lastActiveAt = new Date().toISOString();
+    }
+    resize(id, cols, rows) {
+        const entry = this.get(id);
+        if (entry.record.status === 'running')
+            entry.process.resize(this.dimension(cols, 80), this.dimension(rows, 24));
+    }
+    subscribe(id, listener) {
+        const entry = this.get(id);
+        entry.emitter.on('event', listener);
+        return () => entry.emitter.off('event', listener);
+    }
+    close(id) {
+        const entry = this.get(id);
+        this.terminals.delete(id);
+        if (entry.record.status === 'running')
+            entry.emitter.emit('event', { type: 'exit', exitCode: -1 });
+        this.disposeProcessListeners(entry);
+        if (entry.record.status === 'running')
+            try {
+                entry.process.kill();
+            }
+            catch { }
+        entry.emitter.removeAllListeners();
+    }
+    closeAll() {
+        for (const id of [...this.terminals.keys()])
+            this.close(id);
+    }
+    disposeProcessListeners(entry) {
+        entry.dataSubscription?.dispose();
+        entry.exitSubscription?.dispose();
+        entry.dataSubscription = undefined;
+        entry.exitSubscription = undefined;
+    }
+    pruneExited() {
+        const exited = [...this.terminals.entries()]
+            .reverse()
+            .filter(([, entry]) => entry.record.status === 'exited')
+            .sort((a, b) => b[1].record.lastActiveAt.localeCompare(a[1].record.lastActiveAt));
+        for (const [id] of exited.slice(this.maxRetained))
+            this.close(id);
+    }
+    dimension(value, fallback) {
+        return Number.isInteger(value) && value > 0 && value <= 1000 ? value : fallback;
+    }
 }

package/dist/timeline.js

@@ -0,0 +1,185 @@
+import { toolSummary } from './activity.js';
+/**
+ * Bodies of collapsed kinds (tools, thinking...) up to this many characters travel with the
+ * timeline; larger ones load when expanded. Tool calls and results are 90% of a session's bytes
+ * and rarely opened, so this is kept small.
+ */
+export const INLINE_LIMIT = 256;
+const ALWAYS_INLINE = new Set(['user', 'assistant', 'error']);
+const PREVIEW_LIMIT = 160;
+const memos = new WeakMap();
+/** Entries never change, so anything derived from one entry object can be computed once. */
+function memo(key, compute) {
+    if (!memos.has(key))
+        memos.set(key, compute());
+    return memos.get(key);
+}
+/** Text of message content: strings, text parts, and a marker per image. */
+export function contentText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .map((part) => part?.type === 'text' ? String(part.text ?? '') : part?.type === 'image' ? '[image]' : '')
+        .filter(Boolean)
+        .join('\n');
+}
+/** A failed provider response: Pi persists it as an assistant message with stopReason "error". */
+function assistantError(message) {
+    if (message?.stopReason !== 'error' && !message?.errorMessage)
+        return '';
+    const detail = String(message.errorMessage || 'LLM request failed').trim(), source = [message.provider, message.model].filter(Boolean).join(' · ');
+    return source ? `${detail}\n\n${source}` : detail;
+}
+const preview = (text) => {
+    const line = text.trim().split('\n')[0]?.trim() ?? '';
+    return line.length > PREVIEW_LIMIT ? `${line.slice(0, PREVIEW_LIMIT - 1)}…` : line;
+};
+const timeOf = (message, entry) => {
+    const value = Number(message?.timestamp);
+    if (Number.isFinite(value) && value > 0)
+        return value;
+    const parsed = Date.parse(entry.timestamp ?? '');
+    return Number.isFinite(parsed) ? parsed : undefined;
+};
+function record(item, size, body) {
+    const full = { ...item, size };
+    if (ALWAYS_INLINE.has(item.kind) || size <= INLINE_LIMIT)
+        full.body = body();
+    else if (!full.summary)
+        full.summary = preview(body());
+    for (const key of Object.keys(full))
+        if (full[key] === undefined)
+            delete full[key];
+    return { item: full, body };
+}
+const NESTED_MARK = { ok: '✓', error: '✗', unfinished: '⊘' };
+/** Calls the tool made to other tools (codemode scripts, MCP batches), one line each. */
+function nestedText(nested) {
+    const calls = Array.isArray(nested?.calls) ? nested.calls : [];
+    if (!calls.length)
+        return '';
+    const lines = calls.map((call) => {
+        const target = toolSummary(call.arguments), duration = Number.isFinite(call.durationMs) ? ` · ${call.durationMs} ms` : '';
+        return `${NESTED_MARK[call.status] ?? '•'} ${call.name}${target ? `: ${target}` : ''}${duration}${call.error ? ` · ${call.error}` : ''}`;
+    });
+    return `\n\n— 嵌套调用（${calls.length}${nested.complete === false ? '，不完整' : ''}）—\n${lines.join('\n')}`;
+}
+function text(id, kind, value, item = {}) {
+    return record({ id, kind, ...item }, value.length, () => value);
+}
+/** The items of one entry, computed once per entry object. */
+function entryItems(entry) {
+    return memo(entry, () => {
+        const e = entry, at = timeOf(undefined, entry);
+        if (entry.type === 'compaction')
+            return [
+                text(entry.id, 'compaction', String(e.summary ?? ''), {
+                    timestamp: at,
+                    title: '上下文已压缩',
+                    summary: Number.isFinite(e.tokensBefore) ? `压缩前 ${e.tokensBefore} tokens` : undefined
+                })
+            ];
+        if (entry.type === 'branch_summary')
+            return [text(entry.id, 'branch_summary', String(e.summary ?? ''), { timestamp: at, title: '分支摘要' })];
+        if (entry.type === 'custom_message')
+            return e.display
+                ? [
+                    text(entry.id, 'custom', contentText(e.content), {
+                        timestamp: at,
+                        title: String(e.customType ?? 'custom')
+                    })
+                ]
+                : [];
+        if (entry.type !== 'message')
+            return [];
+        const message = e.message, role = message?.role, timestamp = timeOf(message, entry);
+        if (role === 'user' || role === 'system') {
+            const value = contentText(message.content);
+            return value ? [text(entry.id, role, value, { timestamp })] : [];
+        }
+        if (role === 'bashExecution')
+            return [
+                text(entry.id, 'bash', String(message.output ?? ''), {
+                    timestamp,
+                    title: String(message.command ?? ''),
+                    summary: message.cancelled
+                        ? '已取消'
+                        : message.exitCode === undefined
+                            ? undefined
+                            : `exit ${message.exitCode}${message.truncated ? ' · 输出已截断' : ''}`,
+                    status: message.cancelled ? 'cancelled' : Number(message.exitCode) > 0 ? 'error' : 'ok'
+                })
+            ];
+        if (role === 'toolResult')
+            return [
+                text(entry.id, 'tool_result', (contentText(message.content) || (message.isError ? '执行失败' : '执行完成')) +
+                    nestedText(message.nestedCalls), {
+                    timestamp,
+                    title: String(message.toolName ?? 'tool'),
+                    status: message.isError ? 'error' : 'ok',
+                    durationMs: Number.isFinite(message.durationMs) ? message.durationMs : undefined,
+                    toolCallId: String(message.toolCallId ?? '')
+                })
+            ];
+        if (role !== 'assistant')
+            return [];
+        const items = [];
+        (Array.isArray(message.content) ? message.content : []).forEach((part, index) => {
+            const id = `${entry.id}.${index}`;
+            if (part?.type === 'text' && part.text)
+                items.push(text(id, 'assistant', String(part.text), { timestamp }));
+            else if (part?.type === 'thinking' && (part.thinking || part.text))
+                items.push(text(id, 'thinking', String(part.thinking || part.text), { timestamp }));
+            else if (part?.type === 'toolCall') {
+                const args = part.arguments;
+                items.push(text(id, 'tool_call', args && typeof args === 'object' && Object.keys(args).length ? JSON.stringify(args, null, 2) : '', {
+                    timestamp,
+                    title: String(part.name ?? 'tool'),
+                    summary: toolSummary(args),
+                    toolCallId: String(part.id ?? '')
+                }));
+            }
+        });
+        const error = assistantError(message);
+        if (error)
+            items.push(text(`${entry.id}.error`, 'error', error, { timestamp }));
+        return items;
+    });
+}
+/** Project a branch (root to leaf) into display items. */
+export function buildTimeline(entries) {
+    return entries.flatMap(entryItems);
+}
+/**
+ * About `limit` items before `before` (or the newest ones). A page never splits a tool call from its
+ * result: it starts early enough to include the calls of the results it holds. Undefined when
+ * `before` is not on the timeline.
+ */
+export function pageTimeline(records, limit = 50, before) {
+    const size = Math.min(500, Math.max(1, Math.trunc(Number(limit)) || 50)), end = before === undefined ? records.length : records.findIndex(r => r.item.id === before);
+    if (end < 0)
+        return undefined;
+    let start = Math.max(0, end - size);
+    const callIndex = new Map();
+    records.slice(0, end).forEach((r, index) => {
+        if (r.item.kind === 'tool_call')
+            callIndex.set(r.item.toolCallId, index);
+    });
+    for (let i = end - 1; i >= start; i--) {
+        const call = records[i].item.kind === 'tool_result' ? callIndex.get(records[i].item.toolCallId) : undefined;
+        if (call !== undefined && call < start)
+            start = call; // The loop then also checks what this brought in.
+    }
+    return {
+        items: records.slice(start, end).map(r => r.item),
+        total: records.length,
+        start,
+        hasMore: start > 0
+    };
+}
+/** The full body of one item. */
+export function itemBody(records, id) {
+    return records.find(r => r.item.id === id)?.body();
+}