pi2web 0.2.0

package/dist/voice.js

@@ -0,0 +1,322 @@
+import { EventEmitter } from 'node:events';
+import { randomUUID } from 'node:crypto';
+const punctuation = new Set(['。', '！', '？', '!', '?', '.']);
+const closing = new Set(['”', '’', '"', '\'', '）', ')', '】', ']']);
+const endpoint = (base, path) => `${base.replace(/\/$/, '')}${base.replace(/\/$/, '').endsWith('/v1') ? '' : '/v1'}${path}`;
+const authHeaders = (key) => key ? { authorization: `Bearer ${key}` } : {};
+const abortError = (error) => error instanceof Error && error.name === 'AbortError';
+const timeoutError = (error) => error instanceof Error && error.name === 'TimeoutError';
+/** Combines caller cancellation with a hard timeout so a stalled speech server cannot block the announcement queue forever. */
+const deadline = (ms, signal) => signal ? AbortSignal.any([signal, AbortSignal.timeout(ms)]) : AbortSignal.timeout(ms);
+export function assistantText(message) {
+    if (typeof message === 'string')
+        return message.trim() || undefined;
+    if (!message || typeof message !== 'object')
+        return;
+    const value = message;
+    if (value.role && value.role !== 'assistant')
+        return;
+    if (typeof value.content === 'string')
+        return value.content.trim() || undefined;
+    if (Array.isArray(value.content)) {
+        const text = value.content.filter((part) => part?.type === 'text' && typeof part.text === 'string').map((part) => part.text).join('\n').trim();
+        return text || undefined;
+    }
+}
+export function prepareSummaryInput(text, maxChars = 32000) {
+    let cleaned = text
+        .replace(/```[\s\S]*?```/g, ' [代码已省略] ')
+        .replace(/<details[\s\S]*?<\/details>/gi, ' [详细内容已省略] ')
+        .replace(/!\[([^\]]*)\]\([^)]*\)/g, '$1')
+        .replace(/\[([^\]]+)\]\([^)]*\)/g, '$1')
+        .replace(/https?:\/\/\S+/g, '链接')
+        .replace(/^\s{0,3}#{1,6}\s+/gm, '')
+        .replace(/^\s*[-*+]\s+/gm, '')
+        .replace(/`([^`]+)`/g, '$1')
+        .replace(/[ \t]+/g, ' ')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+    if (cleaned.length <= maxChars)
+        return cleaned;
+    const head = Math.floor(maxChars * 0.375), tail = maxChars - head;
+    cleaned = `${cleaned.slice(0, head)}\n\n[中间内容已省略]\n\n${cleaned.slice(-tail)}`;
+    return cleaned;
+}
+function clipSummaryField(text, maxChars) {
+    const normalized = text.replace(/[ \t]+/g, ' ').replace(/\n{3,}/g, '\n\n').trim();
+    if (normalized.length <= maxChars)
+        return normalized;
+    const head = Math.floor(maxChars * 0.375), tail = maxChars - head;
+    return `${normalized.slice(0, head)}\n\n[中间内容已省略]\n\n${normalized.slice(-tail)}`;
+}
+export function prepareSummaryContext(input, maxChars = 32000) {
+    const promptBudget = Math.max(1, Math.floor(maxChars * 0.4)), outputBudget = Math.max(1, maxChars - promptBudget);
+    return JSON.stringify({
+        userPrompt: clipSummaryField(input.userPrompt, promptBudget),
+        piFinalOutput: prepareSummaryInput(input.finalOutput, outputBudget),
+        sessionNeedsName: !input.sessionName?.trim()
+    });
+}
+export function parseSummaryResult(text) {
+    const trimmed = text.trim(), candidate = trimmed.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '');
+    let value;
+    try {
+        value = JSON.parse(candidate);
+    }
+    catch {
+        const start = candidate.indexOf('{'), end = candidate.lastIndexOf('}');
+        if (start < 0 || end <= start)
+            throw new Error('Summary endpoint returned invalid JSON');
+        try {
+            value = JSON.parse(candidate.slice(start, end + 1));
+        }
+        catch {
+            throw new Error('Summary endpoint returned invalid JSON');
+        }
+    }
+    const summary = typeof value?.summary === 'string' ? value.summary.trim() : '';
+    if (!summary)
+        throw new Error('Summary endpoint returned no summary');
+    const rawName = typeof value?.sessionName === 'string' ? value.sessionName.trim() : '';
+    const sessionName = rawName.replace(/[\r\n\t]+/g, ' ').replace(/\s{2,}/g, ' ').slice(0, 60).trim();
+    return { summary, ...(sessionName ? { sessionName } : {}) };
+}
+export function formatSpokenSummary(summary, sessionName, language = 'zh-CN') {
+    const name = sessionName?.replace(/[\r\n\t]+/g, ' ').replace(/\s{2,}/g, ' ').slice(0, 60).trim();
+    if (!name)
+        return summary;
+    return language.toLowerCase().startsWith('zh') ? `会话${name}已完成：${summary}` : `Session ${name} completed: ${summary}`;
+}
+export class SentenceChunker {
+    maxChars;
+    buffer = '';
+    constructor(maxChars = 100) {
+        this.maxChars = maxChars;
+    }
+    add(delta) { this.buffer += delta; return this.consume(false); }
+    close() { return this.consume(true); }
+    consume(final) {
+        const chunks = [];
+        while (this.buffer) {
+            let cut = -1;
+            for (let i = 0; i < this.buffer.length; i++)
+                if (punctuation.has(this.buffer[i]) && i >= 3) {
+                    cut = i + 1;
+                    while (cut < this.buffer.length && closing.has(this.buffer[cut]))
+                        cut++;
+                    break;
+                }
+            if (cut < 0 && this.buffer.length >= this.maxChars) {
+                const range = this.buffer.slice(0, this.maxChars + 1), fallback = Math.max(range.lastIndexOf('，'), range.lastIndexOf(','), range.lastIndexOf(' '));
+                cut = fallback >= 8 ? fallback + 1 : this.maxChars;
+            }
+            if (cut < 0) {
+                if (!final)
+                    break;
+                cut = this.buffer.length;
+            }
+            const chunk = this.buffer.slice(0, cut).trim();
+            this.buffer = this.buffer.slice(cut);
+            if (chunk)
+                chunks.push(chunk);
+        }
+        return chunks;
+    }
+}
+async function* sseText(response) {
+    if (!response.body)
+        throw new Error('Summary endpoint returned no response body');
+    const reader = response.body.getReader(), decoder = new TextDecoder();
+    let buffer = '';
+    while (true) {
+        const { done, value } = await reader.read();
+        buffer += decoder.decode(value ?? new Uint8Array(), { stream: !done });
+        const records = buffer.split(/\r?\n\r?\n/);
+        buffer = records.pop() ?? '';
+        for (const record of records) {
+            for (const line of record.split(/\r?\n/)) {
+                if (!line.startsWith('data:'))
+                    continue;
+                const data = line.slice(5).trim();
+                if (!data || data === '[DONE]')
+                    continue;
+                let parsed;
+                try {
+                    parsed = JSON.parse(data);
+                }
+                catch {
+                    continue;
+                }
+                const content = parsed?.choices?.[0]?.delta?.content;
+                if (typeof content === 'string' && content)
+                    yield content;
+                else if (Array.isArray(content))
+                    for (const part of content)
+                        if (part?.type === 'text' && typeof part.text === 'string')
+                            yield part.text;
+            }
+        }
+        if (done)
+            break;
+    }
+}
+export class VoiceManager {
+    fetcher;
+    emitter = new EventEmitter();
+    lastAssistant = new Map();
+    lastPrompt = new Map();
+    active = new Map();
+    generations = new Map();
+    announcementQueue = Promise.resolve();
+    closed = false;
+    config;
+    constructor(config, fetcher = fetch) {
+        this.fetcher = fetcher;
+        this.config = { language: 'zh-CN', maxInputChars: 32000, maxOutputTokens: 160, sampleRate: 24000, ttsFormat: 'pcm', requestTimeoutMs: 120000, ...config };
+    }
+    subscribe(listener) { this.emitter.on('event', listener); return () => this.emitter.off('event', listener); }
+    capabilities() { return { tts: true, stt: !!this.config.sttModel }; }
+    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 (event.type === 'before_agent_start' && typeof event.prompt === 'string') {
+            this.lastPrompt.set(agentId, event.prompt);
+            return;
+        }
+        if (event.type === 'message_end') {
+            const text = assistantText(event.message);
+            if (text)
+                this.lastAssistant.set(agentId, text);
+            return;
+        }
+        if (event.type === 'agent_start') {
+            if (typeof event.message === 'string')
+                this.recordUserPrompt(agentId, event.message);
+            this.cancel(agentId);
+            return;
+        }
+        if (event.type === 'agent_settled') {
+            const finalOutput = this.lastAssistant.get(agentId), userPrompt = this.lastPrompt.get(agentId) ?? '';
+            this.lastAssistant.delete(agentId);
+            this.lastPrompt.delete(agentId);
+            if (finalOutput)
+                void this.announce(agentId, { userPrompt, finalOutput, ...context });
+        }
+    }
+    cancel(agentId) { this.generations.set(agentId, (this.generations.get(agentId) ?? 0) + 1); const controller = this.active.get(agentId); if (controller) {
+        controller.abort();
+        this.active.delete(agentId);
+        this.emit(agentId, { type: 'voice_cancelled' });
+    } }
+    close() { this.closed = true; for (const id of [...new Set([...this.active.keys(), ...this.generations.keys()])])
+        this.cancel(id); this.emitter.removeAllListeners(); }
+    async transcribe(audio, mimeType = 'audio/webm', filename = 'recording.webm') {
+        if (!this.config.sttModel)
+            throw Object.assign(new Error('Voice STT model is not configured'), { code: 'VOICE_STT_DISABLED' });
+        const copy = new Uint8Array(audio.byteLength);
+        copy.set(audio);
+        const form = new FormData();
+        form.append('file', new Blob([copy.buffer], { type: mimeType }), filename);
+        form.append('model', this.config.sttModel);
+        form.append('response_format', 'json');
+        const response = await this.fetcher(endpoint(this.config.speechBaseUrl, '/audio/transcriptions'), { method: 'POST', signal: deadline(this.config.requestTimeoutMs), headers: authHeaders(this.config.speechApiKey), body: form }).catch(error => { throw timeoutError(error) ? Object.assign(new Error(`Speech transcription timed out after ${this.config.requestTimeoutMs} ms`), { code: 'VOICE_STT_FAILED' }) : error; });
+        if (!response.ok)
+            throw Object.assign(new Error(`Speech transcription failed (${response.status}): ${(await response.text()).slice(0, 500)}`), { code: 'VOICE_STT_FAILED' });
+        const value = await response.json();
+        const text = typeof value === 'string' ? value : value?.text;
+        if (typeof text !== 'string')
+            throw Object.assign(new Error('Speech transcription returned no text'), { code: 'VOICE_STT_FAILED' });
+        return { text: text.trim(), language: value?.language };
+    }
+    async announce(agentId, value) {
+        const input = typeof value === 'string' ? { userPrompt: '', finalOutput: value } : value;
+        this.cancel(agentId);
+        const generation = this.generations.get(agentId);
+        const job = this.announcementQueue.then(() => this.closed || this.generations.get(agentId) !== generation ? undefined : this.runAnnouncement(agentId, input, generation));
+        this.announcementQueue = job.then(() => undefined, () => undefined);
+        return job;
+    }
+    async runAnnouncement(agentId, input, generation) {
+        const controller = new AbortController(), playbackId = randomUUID();
+        this.active.set(agentId, controller);
+        this.emit(agentId, { type: 'voice_start', playbackId, encoding: this.config.ttsFormat === 'mp3' ? 'mp3' : 'pcm_s16le', sampleRate: this.config.sampleRate, channels: 1 });
+        let rawResult = '', spokenSummary = '';
+        try {
+            const summaryInput = prepareSummaryContext(input, this.config.maxInputChars);
+            const response = await this.fetcher(endpoint(this.config.summaryBaseUrl, '/chat/completions'), { method: 'POST', signal: deadline(this.config.requestTimeoutMs, controller.signal), headers: { 'content-type': 'application/json', ...authHeaders(this.config.summaryApiKey) }, body: JSON.stringify({ model: this.config.summaryModel, stream: true, temperature: 0.2, max_tokens: this.config.maxOutputTokens, messages: [{ role: 'system', content: this.summaryPrompt() }, { role: 'user', content: summaryInput }] }) });
+            if (!response.ok)
+                throw new Error(`Summary request failed (${response.status}): ${(await response.text()).slice(0, 500)}`);
+            for await (const delta of sseText(response))
+                rawResult += delta;
+            const result = parseSummaryResult(rawResult), sessionName = input.sessionName?.trim() || result.sessionName;
+            spokenSummary = formatSpokenSummary(result.summary, sessionName, this.config.language);
+            if (!input.sessionName?.trim() && result.sessionName && input.setSessionName) {
+                try {
+                    await input.setSessionName(result.sessionName);
+                }
+                catch (error) {
+                    this.emit(agentId, { type: 'voice_session_name_error', playbackId, message: error.message });
+                }
+            }
+            this.emit(agentId, { type: 'voice_summary_delta', playbackId, text: spokenSummary });
+            const chunker = new SentenceChunker();
+            for (const sentence of [...chunker.add(spokenSummary), ...chunker.close()])
+                await this.speak(agentId, playbackId, sentence, controller.signal);
+            if (this.active.get(agentId) === controller)
+                this.emit(agentId, { type: 'voice_end', playbackId, summary: spokenSummary, sessionName: result.sessionName });
+        }
+        catch (error) {
+            if (!abortError(error) && this.active.get(agentId) === controller) {
+                this.emit(agentId, { type: 'voice_error', playbackId, message: error.message });
+                const fallback = this.config.language.toLowerCase().startsWith('zh') ? 'Agent 已完成，等待输入。' : 'The agent has finished and is ready for input.';
+                if (!spokenSummary)
+                    try {
+                        this.emit(agentId, { type: 'voice_summary_delta', playbackId, text: fallback });
+                        await this.speak(agentId, playbackId, fallback, controller.signal);
+                        this.emit(agentId, { type: 'voice_end', playbackId, summary: fallback });
+                    }
+                    catch { /* The text notification remains available when TTS also fails. */ }
+                else
+                    this.emit(agentId, { type: 'voice_end', playbackId, summary: spokenSummary, partial: true });
+            }
+        }
+        finally {
+            if (this.active.get(agentId) === controller)
+                this.active.delete(agentId);
+            if (this.generations.get(agentId) !== generation)
+                controller.abort();
+        }
+    }
+    summaryPrompt() { const language = this.config.language.toLowerCase().startsWith('zh') ? '简体中文' : '与用户输入相同的主要语言'; return `你负责把一次 Pi 编程任务压缩成准确、自然、可直接朗读的完成通知，并在需要时为 Session 命名。\n\n输入是一个 JSON 对象：\n- userPrompt：用户本轮真正想完成的任务。\n- piFinalOutput：Pi 最后一次回复，包含完成情况、改动、验证结果和后续事项。\n- sessionNeedsName：只有为 true 时才需要生成 Session 名称。\n\n先结合 userPrompt 判断目标，再以 piFinalOutput 为事实依据总结。不要把用户的要求误说成已经完成；没有明确证据时不要声称测试通过或任务成功。摘要使用${language}，写 2 到 4 个短句，最多 120 个中文字符或 70 个英文单词。优先交代：是否完成、最重要的结果或修改、测试/验证结果、失败原因，以及用户必须采取的下一步。省略代码、命令、URL、完整路径、哈希、冗长文件清单、日志和 Markdown；不要使用标题、列表、“总结如下”等套话。\n\n如果 sessionNeedsName 为 true，请根据 userPrompt 生成一个具体、简短、便于检索的名称：中文建议 6 到 18 个字，英文建议 3 到 8 个词；使用任务主题或目标，不写“新会话”“任务总结”等空泛名称，不带句号、引号、Emoji 或路径。如果 sessionNeedsName 为 false，sessionName 必须为 null。\n\n只输出一个合法 JSON 对象，不要输出 Markdown 代码块、解释或任何额外文字。有名称时使用 {"summary":"适合直接朗读的摘要","sessionName":"简短名称"}；无需命名时使用 {"summary":"适合直接朗读的摘要","sessionName":null}。summary 必须是 JSON 字符串，sessionName 必须是 JSON 字符串或 null。`; }
+    async speak(agentId, playbackId, text, signal) {
+        const response = await this.fetcher(endpoint(this.config.speechBaseUrl, '/audio/speech'), { method: 'POST', signal: deadline(this.config.requestTimeoutMs, signal), headers: { 'content-type': 'application/json', ...authHeaders(this.config.speechApiKey) }, body: JSON.stringify({ model: this.config.ttsModel, voice: this.config.ttsVoice, input: text, response_format: this.config.ttsFormat, sample_rate: this.config.sampleRate, stream_format: 'audio' }) });
+        if (!response.ok)
+            throw new Error(`Speech synthesis failed (${response.status}): ${(await response.text()).slice(0, 500)}`);
+        if (this.config.ttsFormat === 'mp3') {
+            const audio = Buffer.from(await response.arrayBuffer());
+            if (!audio.length)
+                throw new Error('Speech synthesis returned no audio');
+            this.emit(agentId, { type: 'voice_audio_chunk', playbackId, encoding: 'mp3', audio: audio.toString('base64') });
+            return;
+        }
+        if (!response.body)
+            throw new Error('Speech synthesis returned no audio');
+        const reader = response.body.getReader();
+        let pending;
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (!value?.length)
+                continue;
+            const bytes = pending ? Buffer.concat([pending, Buffer.from(value)]) : Buffer.from(value);
+            const evenLength = bytes.length & ~1;
+            if (evenLength)
+                this.emit(agentId, { type: 'voice_audio_chunk', playbackId, sampleRate: this.config.sampleRate, audio: bytes.subarray(0, evenLength).toString('base64') });
+            pending = evenLength < bytes.length ? Buffer.from(bytes.subarray(evenLength)) : undefined;
+        }
+        if (pending)
+            throw new Error('Speech synthesis returned an incomplete PCM16 sample');
+    }
+}

package/dist/workspaces.js

@@ -0,0 +1,60 @@
+import path from 'node:path';
+import { statSync } from 'node:fs';
+import { lstat, open, realpath, readdir, stat } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+export class WorkspaceStore {
+    items;
+    constructor(items = []) {
+        this.items = items;
+    }
+    list() { return this.items.map(x => ({ ...x })); }
+    replace(items) { this.items = items.map(item => ({ ...item, rootPath: path.resolve(item.rootPath) })); }
+    add(label, rootPath) { const root = path.resolve(rootPath); let rootStat; try {
+        rootStat = statSync(root);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT' || error.code === 'ENOTDIR')
+            throw Object.assign(new Error('Workspace root does not exist'), { code: 'WORKSPACE_ROOT_NOT_FOUND' });
+        throw error;
+    } if (!rootStat.isDirectory())
+        throw Object.assign(new Error('Workspace root is not a directory'), { code: 'WORKSPACE_ROOT_NOT_DIRECTORY' }); const key = process.platform === 'win32' ? root.toLowerCase() : root; if (this.items.some(item => (process.platform === 'win32' ? item.rootPath.toLowerCase() : item.rootPath) === key))
+        throw Object.assign(new Error('Workspace root already exists'), { code: 'WORKSPACE_ALREADY_EXISTS' }); const item = { id: randomUUID(), label, rootPath: root, createdAt: new Date().toISOString() }; this.items.push(item); return item; }
+    get(id) { return this.items.find(x => x.id === id); }
+    async resolve(ws, relative = '.') { const candidate = path.resolve(ws.rootPath, relative); const root = await realpath(ws.rootPath); let actual; try {
+        actual = await realpath(candidate);
+    }
+    catch {
+        throw Object.assign(new Error('Path does not exist'), { code: 'PATH_NOT_FOUND' });
+    } if (actual !== root && !actual.startsWith(root + path.sep))
+        throw Object.assign(new Error('Path is outside the workspace root'), { code: 'WORKSPACE_PATH_OUTSIDE_ROOT' }); return actual; }
+    async tree(id, relative = '.') { const ws = this.get(id); if (!ws)
+        throw Object.assign(new Error('Workspace not found'), { code: 'WORKSPACE_NOT_FOUND' }); const dir = await this.resolve(ws, relative); if (!(await stat(dir)).isDirectory())
+        throw new Error('Not a directory'); const entries = await readdir(dir, { withFileTypes: true }); return Promise.all(entries.sort((a, b) => Number(b.isDirectory()) - Number(a.isDirectory()) || a.name.localeCompare(b.name)).map(async (e) => { const p = path.join(dir, e.name); const s = await lstat(p); return { name: e.name, type: e.isDirectory() ? 'directory' : 'file', size: s.size, modifiedAt: s.mtime.toISOString() }; })); }
+    async stat(id, relative = '.') { const ws = this.get(id); if (!ws)
+        throw Object.assign(new Error('Workspace not found'), { code: 'WORKSPACE_NOT_FOUND' }); const p = await this.resolve(ws, relative); const s = await lstat(p); return { path: relative, type: s.isDirectory() ? 'directory' : s.isFile() ? 'file' : 'other', size: s.size, modifiedAt: s.mtime.toISOString() }; }
+    async file(id, relative, offset = 0, limit = 1024 * 1024) {
+        const ws = this.get(id);
+        if (!ws)
+            throw Object.assign(new Error('Workspace not found'), { code: 'WORKSPACE_NOT_FOUND' });
+        if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(limit) || limit < 1)
+            throw Object.assign(new Error('Invalid file range'), { code: 'INVALID_REQUEST' });
+        if (limit > 1024 * 1024)
+            throw Object.assign(new Error('File limit exceeded'), { code: 'FILE_TOO_LARGE' });
+        const p = await this.resolve(ws, relative), s = await stat(p);
+        if (!s.isFile())
+            throw new Error('Not a file');
+        if (s.size > 10 * 1024 * 1024)
+            throw Object.assign(new Error('File limit exceeded'), { code: 'FILE_TOO_LARGE' });
+        const length = Math.min(limit, Math.max(0, s.size - offset)), handle = await open(p, 'r');
+        let chunk;
+        try {
+            const buffer = Buffer.alloc(length), result = await handle.read(buffer, 0, length, offset);
+            chunk = buffer.subarray(0, result.bytesRead);
+        }
+        finally {
+            await handle.close();
+        }
+        const binary = chunk.includes(0);
+        return { path: relative, size: s.size, modifiedAt: s.mtime.toISOString(), binary, content: binary ? undefined : chunk.toString('utf8'), offset, limit: chunk.length };
+    }
+}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "pi2web",
+  "version": "0.2.0",
+  "description": "Secure remote web and Android client server for Pi coding agent",
+  "type": "module",
+  "author": "sxwxs",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sxwxs/pi2web.git"
+  },
+  "bugs": {
+    "url": "https://github.com/sxwxs/pi2web/issues"
+  },
+  "homepage": "https://github.com/sxwxs/pi2web#readme",
+  "bin": {
+    "pi2web": "dist/main.js"
+  },
+  "files": [
+    "dist/",
+    "web/",
+    "packages/protocol/",
+    "packages/edge-tts-server/src/remote_pi_edge_tts/",
+    "packages/edge-tts-server/pyproject.toml",
+    "packages/edge-tts-server/README.md",
+    "README.md",
+    "VOICE_SERVER_SETUP.md",
+    "ANDROID_APP_FEATURES.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "npm run clean && tsc -p tsconfig.json",
+    "check": "npm run build",
+    "test": "vitest run",
+    "dev": "tsx src/main.ts",
+    "start": "node dist/main.js",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "engines": {
+    "node": ">=20.10"
+  },
+  "dependencies": {
+    "@earendil-works/pi-coding-agent": "0.80.6",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/xterm": "^6.0.0",
+    "better-sqlite3": "^12.11.1",
+    "dompurify": "^3.4.12",
+    "marked": "^18.0.6",
+    "node-pty": "^1.1.0",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.5.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.0.0"
+  },
+  "overrides": {
+    "vite": "7.3.5"
+  },
+  "keywords": [
+    "pi",
+    "pi-coding-agent",
+    "coding-agent",
+    "remote",
+    "remote-control",
+    "web-ui",
+    "terminal",
+    "websocket"
+  ]
+}

package/packages/edge-tts-server/README.md

@@ -0,0 +1,68 @@
+# Native Edge TTS server for Remote Pi
+
+这是一个很薄的 Python 服务：
+
+- `edge-tts` 连接 Microsoft Edge 在线语音服务并生成 MP3。
+- `aiohttp` 提供 OpenAI-compatible `POST /v1/audio/speech` HTTP 接口。
+- 不需要 Docker、FFmpeg，也不提供语音识别。
+- 默认只监听 `127.0.0.1:5050`。
+
+## 安装和启动
+
+要求 Python 3.10 或更高版本。
+
+```bash
+cd packages/edge-tts-server
+python -m venv .venv
+```
+
+Windows PowerShell：
+
+```powershell
+.venv\Scripts\Activate.ps1
+python -m pip install -e .
+remote-pi-edge-tts
+```
+
+Linux/macOS：
+
+```bash
+source .venv/bin/activate
+python -m pip install -e .
+remote-pi-edge-tts
+```
+
+可以指定监听地址和默认音色：
+
+```bash
+remote-pi-edge-tts --host 127.0.0.1 --port 5050 --voice zh-CN-XiaoxiaoNeural
+```
+
+## 测试
+
+```bash
+curl http://127.0.0.1:5050/v1/audio/speech \
+  -H "Content-Type: application/json" \
+  -d '{"model":"edge-tts","voice":"zh-CN-XiaoxiaoNeural","input":"你好，这是 Edge TTS 测试。","response_format":"mp3"}' \
+  --output edge-tts-test.mp3
+```
+
+## 启动 Remote Pi
+
+```bash
+remote-pi \
+  --voice-base-url http://127.0.0.1:5050/v1 \
+  --voice-tts-model edge-tts \
+  --voice-tts-voice zh-CN-XiaoxiaoNeural \
+  --voice-tts-format mp3 \
+  --voice-summary-base-url https://llm.example.com/v1 \
+  --voice-summary-model your-summary-model \
+  --voice-summary-api-key-env SUMMARY_API_KEY \
+  --voice-language zh-CN
+```
+
+不要传 `--voice-stt-model`。Web UI 会提供 Agent 摘要播报，但隐藏麦克风按钮。
+
+常用中文音色包括 `zh-CN-XiaoxiaoNeural`、`zh-CN-YunxiNeural`、`zh-CN-YunyangNeural` 和 `zh-CN-YunjianNeural`。
+
+Edge TTS 使用非官方消费者服务，建议仅在本机或可信私有网络中使用。

package/packages/edge-tts-server/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=69"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "remote-pi-edge-tts-server"
+version = "0.1.0"
+description = "Small OpenAI-compatible Edge TTS server for Remote Pi"
+requires-python = ">=3.10"
+dependencies = [
+  "aiohttp>=3.9,<4",
+  "edge-tts>=7.2,<8",
+]
+
+[project.scripts]
+remote-pi-edge-tts = "remote_pi_edge_tts.__main__:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

package/packages/edge-tts-server/src/remote_pi_edge_tts/__init__.py

@@ -0,0 +1,3 @@
+"""OpenAI-compatible Edge TTS server used by Remote Pi."""
+
+__version__ = "0.1.0"

package/packages/edge-tts-server/src/remote_pi_edge_tts/__main__.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import os
+from typing import Any
+
+import edge_tts
+from aiohttp import web
+
+
+def error(message: str, status: int = 400) -> web.Response:
+    return web.json_response({"error": {"message": message}}, status=status)
+
+
+def create_app(default_voice: str, max_chars: int) -> web.Application:
+    app = web.Application(client_max_size=256 * 1024)
+    app["default_voice"] = default_voice
+    app["max_chars"] = max_chars
+
+    async def health(_: web.Request) -> web.Response:
+        return web.json_response({"status": "ok", "service": "remote-pi-edge-tts"})
+
+    async def voices(_: web.Request) -> web.Response:
+        values = await edge_tts.list_voices()
+        return web.json_response({"data": values})
+
+    async def speech(request: web.Request) -> web.StreamResponse:
+        try:
+            body: dict[str, Any] = await request.json()
+        except Exception:
+            return error("Request body must be valid JSON")
+        text = body.get("input")
+        if not isinstance(text, str) or not text.strip():
+            return error("input must be a non-empty string")
+        if len(text) > request.app["max_chars"]:
+            return error(f"input exceeds {request.app['max_chars']} characters", 413)
+        response_format = str(body.get("response_format", "mp3")).lower()
+        if response_format not in {"mp3", "mpeg"}:
+            return error("Only response_format=mp3 is supported")
+        voice = str(body.get("voice") or request.app["default_voice"])
+        rate = str(body.get("rate", "+0%"))
+        volume = str(body.get("volume", "+0%"))
+        pitch = str(body.get("pitch", "+0Hz"))
+        try:
+            communicate = edge_tts.Communicate(text.strip(), voice, rate=rate, volume=volume, pitch=pitch)
+            chunks: list[bytes] = []
+            async for chunk in communicate.stream():
+                if chunk["type"] == "audio":
+                    chunks.append(chunk["data"])
+            audio = b"".join(chunks)
+            if not audio:
+                return error("Edge TTS returned no audio", 502)
+            return web.Response(body=audio, headers={"Content-Type": "audio/mpeg", "Cache-Control": "no-store"})
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:
+            return error(f"Edge TTS failed: {exc}", 502)
+
+    app.router.add_get("/health", health)
+    app.router.add_get("/v1/voices", voices)
+    app.router.add_post("/v1/audio/speech", speech)
+    return app
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="OpenAI-compatible Edge TTS server for Remote Pi")
+    parser.add_argument("--host", default=os.environ.get("EDGE_TTS_HOST", "127.0.0.1"))
+    parser.add_argument("--port", type=int, default=int(os.environ.get("EDGE_TTS_PORT", "5050")))
+    parser.add_argument("--voice", default=os.environ.get("EDGE_TTS_VOICE", "zh-CN-XiaoxiaoNeural"))
+    parser.add_argument("--max-chars", type=int, default=int(os.environ.get("EDGE_TTS_MAX_CHARS", "5000")))
+    args = parser.parse_args()
+    web.run_app(create_app(args.voice, args.max_chars), host=args.host, port=args.port)
+
+
+if __name__ == "__main__":
+    main()