pi2web 0.2.0

package/dist/main.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+import { RemotePiServer } from './server.js';
+import { VoiceManager } from './voice.js';
+import { MailNotifier } from './mail-notifier.js';
+import pkg from '../package.json' with { type: 'json' };
+const args = process.argv.slice(2);
+const value = (name, fallback) => { const i = args.indexOf(name); return i >= 0 ? args[i + 1] ?? fallback : fallback; };
+const envSecret = (flag) => { const name = value(flag, '').trim(); if (!name)
+    return undefined; const result = process.env[name]; if (!result) {
+    console.error(`${flag} references missing environment variable ${name}`);
+    process.exit(1);
+} return result; };
+if (args.includes('--help') || args.includes('-h')) {
+    console.log(`pi2web ${pkg.version}\n\nUsage: pi2web [options]\n\nOptions:\n  --host <address>                    Listen address (default: 127.0.0.1)\n  --port <number>                     Listen port (default: 11318)\n  --data-dir <path>                   Metadata directory (default: ~/.pi/remote-pi)\n  --maildispatch-endpoint <url>       MailDispatch message API endpoint\n  --maildispatch-api-key-env <name>   Environment variable containing the MailDispatch API key\n  --maildispatch-notify-to <email>    Email address notified when an Agent task settles\n  --maildispatch-sender-id <id>       Optional MailDispatch sender ID\n  --voice-base-url <url>              OpenAI-compatible TTS endpoint, e.g. Speaches or openai-edge-tts\n  --voice-stt-model <id>              Optional speech-to-text model ID; omit for TTS-only mode\n  --voice-tts-model <id>              Text-to-speech model ID\n  --voice-tts-voice <id>              TTS voice ID\n  --voice-tts-format <pcm|mp3>         TTS response format (default: pcm)\n  --voice-api-key-env <name>          Environment variable containing the speech API key\n  --voice-summary-base-url <url>      OpenAI-compatible summary LLM endpoint\n  --voice-summary-model <id>          Summary LLM model ID\n  --voice-summary-api-key-env <name>  Environment variable containing the summary API key\n  --voice-language <tag>              Spoken summary language (default: zh-CN)\n  --voice-request-timeout <ms>        Speech and summary request timeout (default: 120000)\n  --rotate-access-token               Generate a new pairing code and exit\n  --version                           Print version\n  -h, --help                          Show help\n\nMail notifications require endpoint, API-key environment variable, and recipient. Voice is disabled unless --voice-base-url is set. The Web UI is served at the same address. Its pairing code must be entered manually; the browser asks before saving it locally.`);
+    process.exit(0);
+}
+if (args.includes('--version') || args.includes('-v')) {
+    console.log(pkg.version);
+    process.exit(0);
+}
+const host = value('--host', '127.0.0.1'), port = Number(value('--port', '11318'));
+if (!Number.isInteger(port) || port < 0 || port > 65535) {
+    console.error('Invalid --port');
+    process.exit(1);
+}
+const voiceBaseUrl = value('--voice-base-url', '');
+let voice;
+if (voiceBaseUrl) {
+    const required = (name) => { const result = value(name, '').trim(); if (!result) {
+        console.error(`${name} is required when voice is enabled`);
+        process.exit(1);
+    } return result; };
+    const ttsFormat = value('--voice-tts-format', 'pcm').trim();
+    if (ttsFormat !== 'pcm' && ttsFormat !== 'mp3') {
+        console.error('--voice-tts-format must be pcm or mp3');
+        process.exit(1);
+    }
+    const requestTimeoutMs = Number(value('--voice-request-timeout', '120000'));
+    if (!Number.isInteger(requestTimeoutMs) || requestTimeoutMs < 1000) {
+        console.error('--voice-request-timeout must be an integer of at least 1000 milliseconds');
+        process.exit(1);
+    }
+    const config = { speechBaseUrl: voiceBaseUrl, sttModel: value('--voice-stt-model', '').trim() || undefined, ttsModel: required('--voice-tts-model'), ttsVoice: required('--voice-tts-voice'), ttsFormat, speechApiKey: envSecret('--voice-api-key-env'), summaryBaseUrl: required('--voice-summary-base-url'), summaryModel: required('--voice-summary-model'), summaryApiKey: envSecret('--voice-summary-api-key-env'), language: value('--voice-language', 'zh-CN'), requestTimeoutMs };
+    voice = new VoiceManager(config);
+}
+const mailEndpoint = value('--maildispatch-endpoint', '').trim(), mailKeyEnv = value('--maildispatch-api-key-env', '').trim(), mailRecipient = value('--maildispatch-notify-to', '').trim();
+const mailParts = [mailEndpoint, mailKeyEnv, mailRecipient].filter(Boolean).length;
+if (mailParts > 0 && mailParts < 3) {
+    console.error('--maildispatch-endpoint, --maildispatch-api-key-env, and --maildispatch-notify-to must be configured together');
+    process.exit(1);
+}
+let mailNotifier;
+if (mailParts === 3) {
+    let endpoint;
+    try {
+        endpoint = new URL(mailEndpoint);
+    }
+    catch {
+        console.error('--maildispatch-endpoint must be a valid URL');
+        process.exit(1);
+    }
+    if (!['http:', 'https:'].includes(endpoint.protocol)) {
+        console.error('--maildispatch-endpoint must use http or https');
+        process.exit(1);
+    }
+    mailNotifier = new MailNotifier({ endpoint: endpoint.toString(), apiKey: envSecret('--maildispatch-api-key-env'), recipient: mailRecipient, senderId: value('--maildispatch-sender-id', '').trim() || undefined });
+}
+const server = new RemotePiServer({ host, port, dataDir: value('--data-dir', process.env.PI_REMOTE_DIR ?? `${process.env.HOME ?? '.'}/.pi/remote-pi`), voice, mailNotifier });
+if (args.includes('--rotate-access-token')) {
+    await server.auth.init();
+    console.log(await server.auth.rotate());
+    process.exit(0);
+}
+if (args.includes('--print-access-token')) {
+    console.error('The pairing code is only shown on first startup or rotation.');
+    process.exit(1);
+}
+try {
+    await server.start();
+    const address = server.address();
+    console.log(`Remote Pi is ready: http://${host}:${address?.port ?? port}`);
+    console.log('Open this URL and enter the pairing code manually.');
+}
+catch (error) {
+    console.error(`Failed to start Remote Pi: ${error.message}`);
+    process.exit(1);
+}
+const shutdown = async () => { await server.stop(); process.exit(0); };
+process.once('SIGINT', shutdown);
+process.once('SIGTERM', shutdown);

package/dist/metadata-store.js

@@ -0,0 +1,139 @@
+import Database from 'better-sqlite3';
+import { chmodSync, mkdirSync, statSync } from 'node:fs';
+import path from 'node:path';
+const asTime = (value) => { const time = value instanceof Date ? value.getTime() : typeof value === 'number' ? value : Date.parse(value ?? ''); return Number.isFinite(time) ? time : Date.now(); };
+/** SQLite-backed Remote Pi metadata. Pi conversation JSONL files remain the source of truth. */
+export class MetadataStore {
+    dataDir;
+    db;
+    pendingAgents = new Map();
+    archivedAgents = new Set();
+    flushTimer;
+    constructor(dataDir) {
+        this.dataDir = dataDir;
+    }
+    get file() { return path.join(this.dataDir, 'remote-pi.db'); }
+    init() {
+        if (this.db)
+            return;
+        mkdirSync(this.dataDir, { recursive: true });
+        try {
+            chmodSync(this.dataDir, 0o700);
+        }
+        catch { }
+        const db = this.db = new Database(this.file);
+        try {
+            chmodSync(this.file, 0o600);
+        }
+        catch { }
+        db.pragma('journal_mode = WAL');
+        db.pragma('synchronous = NORMAL');
+        db.pragma('busy_timeout = 5000');
+        db.pragma('foreign_keys = ON');
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS workspaces (
+        id TEXT PRIMARY KEY,
+        label TEXT NOT NULL,
+        root_path TEXT NOT NULL UNIQUE,
+        created_at INTEGER NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS agents (
+        id TEXT PRIMARY KEY,
+        workspace_id TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        session_file TEXT,
+        session_name TEXT,
+        cwd TEXT NOT NULL,
+        status TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        last_active_at INTEGER NOT NULL,
+        archived_at INTEGER,
+        FOREIGN KEY(workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE
+      );
+      CREATE TABLE IF NOT EXISTS settings (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS sessions (
+        session_id TEXT PRIMARY KEY,
+        session_file TEXT NOT NULL UNIQUE,
+        workspace_id TEXT,
+        cwd TEXT NOT NULL,
+        name TEXT,
+        parent_session_path TEXT,
+        created_at INTEGER NOT NULL,
+        last_active_at INTEGER NOT NULL,
+        message_count INTEGER NOT NULL DEFAULT 0,
+        first_message TEXT NOT NULL DEFAULT '',
+        file_size INTEGER NOT NULL DEFAULT 0,
+        file_mtime INTEGER NOT NULL DEFAULT 0,
+        archived_at INTEGER,
+        FOREIGN KEY(workspace_id) REFERENCES workspaces(id) ON DELETE SET NULL
+      );
+      CREATE INDEX IF NOT EXISTS agents_active_recent ON agents(last_active_at DESC,id DESC) WHERE archived_at IS NULL;
+      CREATE INDEX IF NOT EXISTS agents_workspace_active_recent ON agents(workspace_id,last_active_at DESC,id DESC) WHERE archived_at IS NULL;
+      CREATE INDEX IF NOT EXISTS sessions_active_recent ON sessions(last_active_at DESC,session_id DESC) WHERE archived_at IS NULL;
+      CREATE INDEX IF NOT EXISTS sessions_workspace_active_recent ON sessions(workspace_id,last_active_at DESC,session_id DESC) WHERE archived_at IS NULL;
+      CREATE INDEX IF NOT EXISTS sessions_cwd_active_recent ON sessions(cwd,last_active_at DESC,session_id DESC) WHERE archived_at IS NULL;
+    `);
+        db.pragma('user_version = 1');
+        this.archivedAgents = new Set(db.prepare('SELECT id FROM agents WHERE archived_at IS NOT NULL').all().map(row => row.id));
+    }
+    get database() { if (!this.db)
+        throw new Error('Metadata store is not initialized'); return this.db; }
+    getSetting(key) { const row = this.database.prepare('SELECT value FROM settings WHERE key=?').get(key); if (!row)
+        return; try {
+        return JSON.parse(row.value);
+    }
+    catch {
+        return;
+    } }
+    setSetting(key, value) { this.database.prepare('INSERT INTO settings(key,value,updated_at) VALUES(?,?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value,updated_at=excluded.updated_at').run(key, JSON.stringify(value), Date.now()); }
+    listWorkspaces() { return this.database.prepare('SELECT id,label,root_path,created_at FROM workspaces ORDER BY created_at,id').all().map(row => ({ id: row.id, label: row.label, rootPath: row.root_path, createdAt: new Date(row.created_at).toISOString() })); }
+    saveWorkspace(workspace) { this.database.prepare(`INSERT INTO workspaces(id,label,root_path,created_at) VALUES(?,?,?,?) ON CONFLICT(id) DO UPDATE SET label=excluded.label,root_path=excluded.root_path`).run(workspace.id, workspace.label, workspace.rootPath, asTime(workspace.createdAt)); }
+    listAgents() { return this.database.prepare('SELECT * FROM agents WHERE archived_at IS NULL ORDER BY last_active_at DESC,id DESC').all().map(row => ({ agentId: row.id, workspaceId: row.workspace_id, sessionId: row.session_id, sessionFile: row.session_file ?? undefined, sessionName: row.session_name ?? undefined, cwd: row.cwd, status: row.status, createdAt: new Date(row.created_at).toISOString(), lastActiveAt: new Date(row.last_active_at).toISOString() })); }
+    writeAgent(record, archivedAt) { this.database.prepare(`INSERT INTO agents(id,workspace_id,session_id,session_file,session_name,cwd,status,created_at,last_active_at,archived_at) VALUES(?,?,?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET workspace_id=excluded.workspace_id,session_id=excluded.session_id,session_file=excluded.session_file,session_name=excluded.session_name,cwd=excluded.cwd,status=excluded.status,last_active_at=excluded.last_active_at,archived_at=excluded.archived_at`).run(record.agentId, record.workspaceId, record.sessionId, record.sessionFile ?? null, record.sessionName ?? null, record.cwd, record.status, asTime(record.createdAt), asTime(record.lastActiveAt), archivedAt); }
+    saveAgent(record) { if (this.archivedAgents.has(record.agentId))
+        return; this.pendingAgents.delete(record.agentId); this.writeAgent(record, null); }
+    scheduleAgent(record) { if (this.archivedAgents.has(record.agentId))
+        return; this.pendingAgents.set(record.agentId, { ...record }); if (!this.flushTimer)
+        this.flushTimer = setTimeout(() => this.flush(), 1000); }
+    archiveAgent(record) { this.archivedAgents.add(record.agentId); this.pendingAgents.delete(record.agentId); this.writeAgent(record, Date.now()); }
+    flush() { if (this.flushTimer) {
+        clearTimeout(this.flushTimer);
+        this.flushTimer = undefined;
+    } if (!this.pendingAgents.size)
+        return; const records = [...this.pendingAgents.values()]; this.pendingAgents.clear(); this.database.transaction((items) => { for (const item of items)
+        this.writeAgent(item, null); })(records); }
+    syncSessions(workspaceId, cwd, sessions) {
+        const db = this.database, upsert = db.prepare(`INSERT INTO sessions(session_id,session_file,workspace_id,cwd,name,parent_session_path,created_at,last_active_at,message_count,first_message,file_size,file_mtime,archived_at) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,NULL) ON CONFLICT(session_id) DO UPDATE SET session_file=excluded.session_file,workspace_id=excluded.workspace_id,cwd=excluded.cwd,name=excluded.name,parent_session_path=excluded.parent_session_path,last_active_at=excluded.last_active_at,message_count=excluded.message_count,first_message=excluded.first_message,file_size=excluded.file_size,file_mtime=excluded.file_mtime,archived_at=NULL`);
+        const remove = db.prepare('DELETE FROM sessions WHERE session_file=?');
+        db.transaction(() => { const paths = new Set(); for (const session of sessions) {
+            paths.add(session.path);
+            let size = 0, mtime = asTime(session.modified);
+            try {
+                const stat = statSync(session.path);
+                size = stat.size;
+                mtime = stat.mtimeMs;
+            }
+            catch { }
+            upsert.run(session.id, session.path, workspaceId, cwd, session.name ?? null, session.parentSessionPath ?? null, asTime(session.created), asTime(session.modified), session.messageCount, session.firstMessage, size, mtime);
+        } for (const row of db.prepare('SELECT session_file FROM sessions WHERE cwd=? AND archived_at IS NULL').all(cwd))
+            if (!paths.has(row.session_file))
+                remove.run(row.session_file); })();
+    }
+    upsertSessionFromAgent(record, summary) { const sessionFile = typeof summary.sessionFile === 'string' ? summary.sessionFile : record.sessionFile; if (!sessionFile)
+        return; let size = 0, mtime = asTime(record.lastActiveAt); try {
+        const stat = statSync(sessionFile);
+        size = stat.size;
+        mtime = stat.mtimeMs;
+    }
+    catch {
+        return;
+    } const sessionId = typeof summary.sessionId === 'string' ? summary.sessionId : record.sessionId, name = typeof summary.sessionName === 'string' ? summary.sessionName : record.sessionName, messageCount = Number(summary.stats?.totalMessages) || 0; this.database.prepare(`INSERT INTO sessions(session_id,session_file,workspace_id,cwd,name,created_at,last_active_at,message_count,first_message,file_size,file_mtime,archived_at) VALUES(?,?,?,?,?,?,?,?,?,?,?,NULL) ON CONFLICT(session_id) DO UPDATE SET session_file=excluded.session_file,workspace_id=excluded.workspace_id,cwd=excluded.cwd,name=excluded.name,last_active_at=excluded.last_active_at,message_count=excluded.message_count,file_size=excluded.file_size,file_mtime=excluded.file_mtime,archived_at=NULL`).run(sessionId, sessionFile, record.workspaceId, record.cwd, name ?? null, asTime(record.createdAt), Math.max(asTime(record.lastActiveAt), mtime), messageCount, '', size, mtime); }
+    listSessions(cwd, limit, offset = 0) { const bounded = limit === undefined ? undefined : Math.min(200, Math.max(1, Math.trunc(limit))); const sql = `SELECT session_file AS path,session_id AS id,cwd,name,parent_session_path AS parentSessionPath,created_at,last_active_at,message_count AS messageCount,first_message AS firstMessage FROM sessions WHERE cwd=? AND archived_at IS NULL ORDER BY last_active_at DESC,session_id DESC${bounded === undefined ? '' : ' LIMIT ? OFFSET ?'}`; const rows = (bounded === undefined ? this.database.prepare(sql).all(cwd) : this.database.prepare(sql).all(cwd, bounded, Math.max(0, Math.trunc(offset)))); return rows.map(row => ({ ...row, created: new Date(row.created_at).toISOString(), modified: new Date(row.last_active_at).toISOString(), allMessagesText: '' })); }
+    hasSession(cwd, sessionFile) { return !!this.database.prepare('SELECT 1 FROM sessions WHERE cwd=? AND session_file=? AND archived_at IS NULL').get(cwd, sessionFile); }
+    close() { if (!this.db)
+        return; this.flush(); this.db.pragma('wal_checkpoint(TRUNCATE)'); this.db.close(); this.db = undefined; }
+}

package/dist/sdk-backend.js

@@ -0,0 +1,85 @@
+import { createAgentSession, SessionManager } from '@earendil-works/pi-coding-agent';
+import { EventEmitter } from 'node:events';
+import { randomUUID } from 'node:crypto';
+/** Real in-process Pi SDK backend with session/model/extension controls exposed to remote clients. */
+export class SdkBackend {
+    session;
+    agentId;
+    cwd;
+    disposed = false;
+    events = new EventEmitter();
+    pendingUi = new Map();
+    constructor(session, agentId, cwd) {
+        this.session = session;
+        this.agentId = agentId;
+        this.cwd = cwd;
+    }
+    static async create(agentId, cwd, sessionFile) {
+        const sessionManager = sessionFile ? SessionManager.open(sessionFile) : SessionManager.create(cwd);
+        const { session, modelFallbackMessage } = await createAgentSession({ cwd, sessionManager });
+        if (modelFallbackMessage && !session.state.model) {
+            session.dispose();
+            throw Object.assign(new Error(modelFallbackMessage), { code: 'PI_MODEL_UNAVAILABLE' });
+        }
+        const backend = new SdkBackend(session, agentId, cwd);
+        await session.bindExtensions({ uiContext: backend.extensionUi() });
+        return backend;
+    }
+    prompt(message) { return this.session.prompt(message); }
+    steer(message) { return this.session.steer(message); }
+    followUp(message) { return this.session.followUp(message); }
+    abort() { return this.session.abort(); }
+    async getState() { return { agentId: this.agentId, sessionId: this.session.sessionId, sessionFile: this.session.sessionFile, sessionName: this.session.sessionName, cwd: this.cwd, status: this.disposed ? 'stopped' : this.session.isStreaming ? 'streaming' : 'idle' }; }
+    async getMessages() { return [...this.session.state.messages]; }
+    async getCapabilities() {
+        const current = this.session.model;
+        const available = this.session.modelRegistry.getAvailable();
+        return { model: current ? this.modelInfo(current) : null, models: available.map(model => this.modelInfo(model)), thinkingLevel: this.session.thinkingLevel, thinkingLevels: this.session.getAvailableThinkingLevels(), supportsThinking: this.session.supportsThinking() };
+    }
+    async getSession() { return { ...await this.getSessionInfo(), leafId: this.session.sessionManager.getLeafId(), entries: this.session.sessionManager.getEntries(), tree: this.session.sessionManager.getTree(), userMessages: this.session.getUserMessagesForForking() }; }
+    async getSessionInfo() { return { sessionId: this.session.sessionId, sessionFile: this.session.sessionFile, sessionName: this.session.sessionName, stats: this.session.getSessionStats(), contextUsage: this.session.getContextUsage() }; }
+    compact(instructions) { return this.session.compact(instructions); }
+    async setModel(provider, modelId) { const model = this.session.modelRegistry.find(provider, modelId); if (!model)
+        throw Object.assign(new Error('Model not found'), { code: 'MODEL_NOT_FOUND' }); await this.session.setModel(model); }
+    async setThinkingLevel(level) { if (!['off', 'minimal', 'low', 'medium', 'high', 'xhigh'].includes(level))
+        throw Object.assign(new Error('Invalid thinking level'), { code: 'INVALID_THINKING_LEVEL' }); this.session.setThinkingLevel(level); }
+    async setSessionName(name) { const value = name.trim(); if (!value || value.length > 200)
+        throw Object.assign(new Error('Session name must be 1-200 characters'), { code: 'INVALID_SESSION_NAME' }); this.session.setSessionName(value); }
+    navigate(entryId) { return this.session.navigateTree(entryId); }
+    async fork(entryId) { const entry = this.session.sessionManager.getEntry(entryId); if (!entry || entry.type !== 'message' || entry.message?.role !== 'user')
+        throw Object.assign(new Error('A user message entry is required'), { code: 'SESSION_ENTRY_NOT_FOUND' }); const content = entry.message.content; const selectedText = typeof content === 'string' ? content : Array.isArray(content) ? content.filter((part) => part.type === 'text').map((part) => part.text).join('\n') : ''; let sessionFile; if (entry.parentId) {
+        sessionFile = this.session.sessionManager.createBranchedSession(entry.parentId);
+    }
+    else {
+        const current = this.session.sessionFile;
+        if (!current)
+            throw Object.assign(new Error('Session persistence is disabled'), { code: 'SESSION_NOT_PERSISTED' });
+        sessionFile = SessionManager.create(this.cwd, this.session.sessionManager.getSessionDir(), { parentSession: current }).getSessionFile();
+    } return { sessionFile, selectedText }; }
+    async extensionResponse(requestId, value) { const pending = this.pendingUi.get(requestId); if (!pending)
+        throw Object.assign(new Error('Extension UI request not found'), { code: 'EXTENSION_REQUEST_NOT_FOUND' }); clearTimeout(pending.timer); this.pendingUi.delete(requestId); pending.resolve(value); }
+    subscribe(listener) { const fromSession = (event) => listener(event); const unsubscribe = this.session.subscribe(fromSession); this.events.on('event', listener); return () => { unsubscribe(); this.events.off('event', listener); }; }
+    async dispose() { if (this.disposed)
+        return; for (const [id, pending] of this.pendingUi) {
+        clearTimeout(pending.timer);
+        pending.resolve(undefined);
+        this.pendingUi.delete(id);
+    } await this.session.abort(); this.session.dispose(); this.disposed = true; }
+    modelInfo(model) { return { provider: model.provider, id: model.id, name: model.name, reasoning: !!model.reasoning, contextWindow: model.contextWindow, maxTokens: model.maxTokens }; }
+    request(kind, payload) { const requestId = randomUUID(); return new Promise(resolve => { const timer = setTimeout(() => { this.pendingUi.delete(requestId); resolve(undefined); }, 5 * 60_000); this.pendingUi.set(requestId, { resolve, timer }); this.events.emit('event', { type: 'extension_ui_request', requestId, kind, ...payload }); }); }
+    extensionUi() {
+        return {
+            select: async (title, options, opts) => await this.request('select', { title, options, opts }),
+            confirm: async (title, message, opts) => Boolean(await this.request('confirm', { title, message, opts })),
+            input: async (title, placeholder, opts) => await this.request('input', { title, placeholder, opts }),
+            editor: async (title, prefill) => await this.request('editor', { title, prefill }),
+            notify: (message, type) => this.events.emit('event', { type: 'extension_ui_notify', message, notificationType: type ?? 'info' }),
+            setStatus: (key, text) => this.events.emit('event', { type: 'extension_ui_status', key, text }),
+            setWidget: (key, content, options) => this.events.emit('event', { type: 'extension_ui_widget', key, content: Array.isArray(content) ? content : undefined, options }),
+            setTitle: (title) => this.events.emit('event', { type: 'extension_ui_title', title }),
+            setWorkingMessage: (message) => this.events.emit('event', { type: 'extension_ui_working_message', message }), setWorkingVisible: () => { }, setWorkingIndicator: () => { }, setHiddenThinkingLabel: () => { },
+            onTerminalInput: () => () => { }, setFooter: () => { }, setHeader: () => { }, pasteToEditor: () => { }, setEditorText: () => { }, getEditorText: () => '', addAutocompleteProvider: () => { }, setEditorComponent: () => { }, custom: async () => { throw Object.assign(new Error('Custom extension components are unsupported'), { code: 'EXTENSION_CUSTOM_UI_UNSUPPORTED' }); }
+        };
+    }
+}
+export const createSdkBackend = (agentId, cwd, sessionFile) => SdkBackend.create(agentId, cwd, sessionFile);