pi2web 0.2.1 → 0.2.8

package/dist/session-namer.js

@@ -1,13 +1,22 @@
 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-mini', language: 'zh-CN',
-    // Reasoning models (gpt-5-mini and friends) burn this budget on hidden reasoning tokens before they
+    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
+    maxInputChars: 8000,
+    maxOutputTokens: 2000,
+    requestTimeoutMs: 60000
 };
 export function parseSessionName(text) {
-    const trimmed = text.trim().replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '');
+    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) {
@@ -16,9 +25,17 @@ export function parseSessionName(text) {
             if (typeof value?.sessionName === 'string')
                 candidate = value.sessionName;
         }
-        catch { /* fall back to the raw text below */ }
+        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();
+    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 {
@@ -33,11 +50,24 @@ export class SessionNamer {
         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); }
+    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;
@@ -91,23 +121,42 @@ export class SessionNamer {
             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),
+            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, temperature: 0.2, max_tokens: this.config.maxOutputTokens,
-                messages: [{ role: 'system', content: this.prompt() }, { role: 'user', content: body }] })
+            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('') : '';
+        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');
+            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') ? '简体中文' : '与用户输入相同的主要语言';
+        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 代码块、解释或任何额外文字。`;
     }
 }

package/dist/session-performance.js

@@ -0,0 +1,137 @@
+export const PERFORMANCE_ENTRY = 'pi2web.performance.v1';
+/** Wall-clock spans, collected on the host running Pi. Parallel tool spans deliberately overlap. */
+export class SessionPerformanceTracker {
+    save;
+    now;
+    run = null;
+    model = null;
+    tools = new Map();
+    other = null;
+    constructor(save, now = Date.now) {
+        this.save = save;
+        this.now = now;
+    }
+    finish(span, at) {
+        if (span)
+            span.end = at;
+    }
+    span(kind, at, name) {
+        const span = { kind, start: at, end: at };
+        if (name)
+            span.name = name;
+        this.run.spans.push(span);
+        return span;
+    }
+    apply(event) {
+        const at = this.now(), e = event;
+        if (event.type === 'agent_start' && !this.run)
+            this.run = { start: at, spans: [] };
+        if (!this.run)
+            return;
+        switch (event.type) {
+            case 'turn_start':
+                if (this.other?.kind === 'retry') {
+                    this.finish(this.other, at);
+                    this.other = null;
+                }
+                this.finish(this.model, at);
+                this.model = this.span('model', at);
+                break;
+            case 'message_update':
+                if (this.model && this.model.firstResponse === undefined)
+                    this.model.firstResponse = at;
+                break;
+            case 'message_end':
+                if (e.message?.role === 'assistant') {
+                    this.finish(this.model, at);
+                    this.model = null;
+                }
+                break;
+            case 'tool_execution_start':
+                if (e.parentToolCallId)
+                    break; // nested tools are included in their parent's wall-clock span
+                if (this.model) {
+                    this.finish(this.model, at);
+                    this.model = null;
+                }
+                if (e.toolCallId) {
+                    const span = this.span('tool', at, String(e.toolName ?? 'tool'));
+                    span.toolCallId = String(e.toolCallId);
+                    this.tools.set(span.toolCallId, span);
+                }
+                break;
+            case 'tool_execution_end': {
+                const span = this.tools.get(String(e.toolCallId));
+                if (span) {
+                    this.finish(span, at);
+                    this.tools.delete(String(e.toolCallId));
+                }
+                break;
+            }
+            case 'compaction_start':
+            case 'auto_retry_start':
+                this.finish(this.other, at);
+                this.other = this.span(event.type === 'compaction_start' ? 'compaction' : 'retry', at);
+                break;
+            case 'compaction_end':
+            case 'auto_retry_end':
+                this.finish(this.other, at);
+                this.other = null;
+                if (event.type === 'auto_retry_end' && e.finalError === 'Retry cancelled')
+                    this.run.incomplete = true;
+                break;
+            case 'agent_end':
+                this.finish(this.model, at);
+                this.model = null;
+                if (e.aborted)
+                    this.run.incomplete = true;
+                break;
+            case 'agent_settled':
+                // Unlike agent_end, this also follows post-run compaction or a cancelled retry delay.
+                this.finish(this.model, at);
+                this.finish(this.other, at);
+                for (const span of this.tools.values()) {
+                    this.finish(span, at);
+                    span.incomplete = true;
+                }
+                this.save({
+                    start: this.run.start,
+                    end: at,
+                    spans: this.run.spans,
+                    ...(this.run.incomplete ? { incomplete: true } : {})
+                });
+                this.run = null;
+                this.model = this.other = null;
+                this.tools.clear();
+        }
+    }
+}
+/** Current branch only. Earlier sessions have tool timestamps but no model-call spans. */
+export function sessionPerformance(entries) {
+    const runs = [];
+    const legacyTools = [];
+    for (const entry of entries) {
+        const e = entry;
+        if (e.type === 'custom' &&
+            e.customType === PERFORMANCE_ENTRY &&
+            e.data?.spans &&
+            Number.isFinite(e.data.start) &&
+            Number.isFinite(e.data.end)) {
+            runs.push(e.data);
+        }
+    }
+    for (const entry of entries) {
+        const e = entry;
+        if (e.type !== 'message' || e.message?.role !== 'toolResult')
+            continue;
+        const duration = Number(e.message.durationMs);
+        const end = Number(e.message.timestamp) || Date.parse(e.timestamp ?? '');
+        if (!Number.isFinite(duration) ||
+            duration < 0 ||
+            !Number.isFinite(end) ||
+            runs.some(run => end >= run.start && end <= run.end))
+            continue;
+        legacyTools.push({ kind: 'tool', start: end - duration, end, name: String(e.message.toolName ?? 'tool') });
+    }
+    return { runs, legacyTools };
+}

package/dist/sotto-stt.js

@@ -0,0 +1,217 @@
+import { WebSocket } from 'ws';
+export const DEFAULT_SOTTO_ENDPOINT = 'http://127.0.0.1:8766';
+const invalid = (message, code = 'INVALID_SOTTO_SETTINGS') => Object.assign(new Error(message), { code });
+/** No arbitrary URLs: the Sotto Web API is local-only, and this server is the authenticated proxy. */
+export function validateSottoEndpoint(value) {
+    if (typeof value !== 'string')
+        throw invalid('Sotto endpoint must be a loopback HTTP URL');
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw invalid('Sotto endpoint must be a valid URL');
+    }
+    if (url.protocol !== 'http:' ||
+        url.hostname !== '127.0.0.1' ||
+        !url.port ||
+        url.username ||
+        url.password ||
+        (url.pathname !== '/' && url.pathname !== '') ||
+        url.search ||
+        url.hash)
+        throw invalid('Sotto endpoint must be http://127.0.0.1:<port> with no path or credentials');
+    return url.origin;
+}
+/** An authenticated browser socket relays only audio and start/stop, never a Sotto control API. */
+function proxySottoStream(client, url) {
+    const upstream = new WebSocket(url, { handshakeTimeout: 5000, maxPayload: 65536 });
+    let started = false, finished = false, closed = false;
+    let timer;
+    const close = () => {
+        closed = true;
+        clearTimeout(timer);
+        if (upstream.readyState === WebSocket.OPEN)
+            upstream.close();
+        else if (upstream.readyState === WebSocket.CONNECTING)
+            upstream.terminate();
+    };
+    const fail = (message, code = 1011) => {
+        if (closed)
+            return;
+        if (client.readyState === WebSocket.OPEN) {
+            client.send(JSON.stringify({ type: 'error', message }));
+            client.close(code);
+        }
+        close();
+    };
+    // Silence still contains PCM. Only a stalled capture/connection times out, not a long dictation.
+    const touch = () => {
+        clearTimeout(timer);
+        timer = setTimeout(() => fail('Audio stream stalled: no microphone frames received for 30 seconds'), 30000);
+    };
+    touch();
+    client.on('close', close);
+    client.on('error', close);
+    upstream.on('error', () => fail('Sotto streaming service is unavailable'));
+    upstream.on('close', code => {
+        if (closed)
+            return;
+        if (!finished || code !== 1000)
+            fail('Sotto streaming connection closed unexpectedly');
+        else {
+            clearTimeout(timer);
+            if (client.readyState === WebSocket.OPEN)
+                client.close(1000);
+        }
+    });
+    upstream.on('message', (data, binary) => {
+        if (closed || binary || client.readyState !== WebSocket.OPEN)
+            return;
+        if (client.bufferedAmount > 1_000_000) {
+            fail('Transcription receiver is too slow', 1009);
+            return;
+        }
+        client.send(data.toString());
+    });
+    client.on('message', (data, binary) => {
+        if (closed || finished || client.readyState !== WebSocket.OPEN)
+            return;
+        const length = data.byteLength;
+        if (upstream.readyState !== WebSocket.OPEN) {
+            fail('Sotto streaming service is not ready');
+            return;
+        }
+        if (!binary) {
+            try {
+                const value = JSON.parse(data.toString());
+                if (!started &&
+                    value.type === 'start' &&
+                    value.format === 'float32' &&
+                    Number.isInteger(value.sample_rate) &&
+                    value.sample_rate >= 16000 &&
+                    value.sample_rate <= 96000) {
+                    started = true;
+                    upstream.send(JSON.stringify({ type: 'start', format: 'float32', sample_rate: value.sample_rate }));
+                    touch();
+                }
+                else if (started && value.type === 'stop') {
+                    finished = true;
+                    upstream.send(JSON.stringify({ type: 'stop' }));
+                }
+                else
+                    fail('Invalid audio protocol', 1008);
+            }
+            catch {
+                fail('Invalid audio protocol', 1008);
+            }
+        }
+        else if (started &&
+            length > 0 &&
+            length % 4 === 0 &&
+            length <= 32768 &&
+            upstream.bufferedAmount < 1_000_000) {
+            upstream.send(data, { binary: true });
+            touch();
+        }
+        else
+            fail('Invalid audio frame or Sotto cannot keep up with microphone audio', 1009);
+    });
+    return fail;
+}
+export class SottoSttService {
+    metadata;
+    fetcher;
+    streams = new Set();
+    settings = { enabled: false, endpoint: DEFAULT_SOTTO_ENDPOINT };
+    /** Bumped by every update, so a slow enable probe cannot overwrite a newer choice. */
+    updates = 0;
+    constructor(metadata, fetcher = fetch) {
+        this.metadata = metadata;
+        this.fetcher = fetcher;
+    }
+    load() {
+        const saved = this.metadata.getSetting('sottoStt');
+        if (saved && typeof saved.enabled === 'boolean') {
+            try {
+                this.settings = { enabled: saved.enabled, endpoint: validateSottoEndpoint(saved.endpoint) };
+            }
+            catch {
+                /* Corrupt or obsolete settings must not enable an untrusted destination. */
+            }
+        }
+    }
+    getSettings() {
+        return { ...this.settings };
+    }
+    streamUrl() {
+        if (!this.settings.enabled)
+            throw invalid('Sotto transcription is disabled', 'SOTTO_DISABLED');
+        const port = Number(new URL(this.settings.endpoint).port) + 2;
+        if (port > 65535)
+            throw invalid('Invalid Sotto streaming port');
+        return `ws://127.0.0.1:${port}/asr`;
+    }
+    stream(client) {
+        const stop = proxySottoStream(client, this.streamUrl());
+        this.streams.add(stop);
+        client.once('close', () => this.streams.delete(stop));
+    }
+    async request(endpoint, path, init, timeoutMs) {
+        const response = await this.fetcher(`${endpoint}${path}`, {
+            ...init,
+            redirect: 'error',
+            signal: AbortSignal.timeout(timeoutMs)
+        }).catch(error => {
+            throw invalid(`Cannot reach local Sotto: ${error.message}`, 'SOTTO_UNAVAILABLE');
+        });
+        if (!response.ok) {
+            const message = (await response.json().catch(() => ({})));
+            throw invalid(message.error || `Sotto returned HTTP ${response.status}`, 'SOTTO_UNAVAILABLE');
+        }
+        return response;
+    }
+    async update(input) {
+        if (!input || typeof input !== 'object')
+            throw invalid('enabled and endpoint are required');
+        const { enabled, endpoint } = input;
+        if (typeof enabled !== 'boolean')
+            throw invalid('enabled must be a boolean');
+        const next = { enabled, endpoint: validateSottoEndpoint(endpoint) };
+        const update = ++this.updates;
+        if (enabled) {
+            const capabilities = await (await this.request(next.endpoint, '/api/capabilities', { method: 'GET' }, 4000)).json();
+            if (capabilities?.stt !== true ||
+                capabilities?.format !== 'pcm-f32le' ||
+                capabilities?.sample_rate !== 16000 ||
+                capabilities?.stream_port !== Number(new URL(next.endpoint).port) + 2)
+                throw invalid('Sotto does not support live PCM transcription', 'SOTTO_UNAVAILABLE');
+            if (update !== this.updates)
+                throw invalid('Sotto settings were changed by a newer request', 'SOTTO_SETTINGS_SUPERSEDED');
+        }
+        this.metadata.setSetting('sottoStt', next);
+        const changed = !next.enabled || next.endpoint !== this.settings.endpoint;
+        this.settings = next;
+        if (changed) {
+            for (const stop of this.streams)
+                stop('Sotto 语音输入已关闭或服务地址已更改');
+            this.streams.clear();
+        }
+        return this.getSettings();
+    }
+    async transcribe(audio) {
+        if (!this.settings.enabled)
+            throw invalid('Sotto transcription is disabled', 'SOTTO_DISABLED');
+        if (!audio.length || audio.length % 4 || audio.length > 16000 * 4 * 60)
+            throw invalid('Expected at most 60 seconds of 16 kHz float32 PCM');
+        const response = await this.request(this.settings.endpoint, '/api/transcribe', {
+            method: 'POST',
+            headers: { 'content-type': 'application/octet-stream' },
+            body: new Uint8Array(audio)
+        }, 120000);
+        const body = (await response.json());
+        if (typeof body.text !== 'string')
+            throw invalid('Invalid response from Sotto', 'SOTTO_UNAVAILABLE');
+        return { text: body.text };
+    }
+}

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;
+    }
 }