deckide 3.5.32 → 3.5.34

package/dist/utils/browser-audio.js

@@ -0,0 +1,381 @@
+import { spawn, execFile } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { WebSocket } from 'ws';
+const execFileAsync = promisify(execFile);
+const AUDIO_CLIENT_BUFFER_LIMIT = 2 * 1024 * 1024;
+async function pathExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function findInPath(names) {
+    const pathValue = process.env.PATH || '';
+    for (const dir of pathValue.split(path.delimiter)) {
+        if (!dir)
+            continue;
+        for (const name of names) {
+            const candidate = path.join(dir, name);
+            if (await pathExists(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return null;
+}
+async function resolveExecutable(envName, names) {
+    const configured = process.env[envName];
+    if (configured) {
+        if (await pathExists(configured)) {
+            return configured;
+        }
+        throw new Error(`${envName} does not exist: ${configured}`);
+    }
+    return findInPath(names);
+}
+async function runText(command, args, timeoutMs = 2000) {
+    try {
+        const { stdout } = await execFileAsync(command, args, {
+            timeout: timeoutMs,
+            maxBuffer: 128 * 1024,
+        });
+        return stdout.trim();
+    }
+    catch {
+        return null;
+    }
+}
+async function resolvePulseSource(pactlPath) {
+    if (process.env.AGENT_BROWSER_AUDIO_SOURCE) {
+        return process.env.AGENT_BROWSER_AUDIO_SOURCE;
+    }
+    if (!pactlPath) {
+        return null;
+    }
+    const defaultSink = await runText(pactlPath, ['get-default-sink']);
+    const sourceList = await runText(pactlPath, ['list', 'short', 'sources']);
+    if (!sourceList) {
+        return defaultSink ? `${defaultSink}.monitor` : null;
+    }
+    const sources = sourceList
+        .split('\n')
+        .map((line) => line.split(/\s+/)[1])
+        .filter(Boolean);
+    if (defaultSink) {
+        const defaultMonitor = `${defaultSink}.monitor`;
+        if (sources.includes(defaultMonitor)) {
+            return defaultMonitor;
+        }
+    }
+    return sources.find((source) => source.endsWith('.monitor')) ?? null;
+}
+function isOpen(socket) {
+    return socket.readyState === WebSocket.OPEN;
+}
+export class BrowserAudioRelay {
+    clients = new Set();
+    captureProcess = null;
+    starting = null;
+    lastError;
+    ffmpegPath = null;
+    audioSource = null;
+    async getStatus() {
+        const ffmpegPath = await resolveExecutable('AGENT_BROWSER_FFMPEG', ['ffmpeg']).catch((error) => {
+            this.lastError = error instanceof Error ? error.message : String(error);
+            return null;
+        });
+        const pactlPath = await resolveExecutable('AGENT_BROWSER_PACTL', ['pactl']).catch(() => null);
+        const source = await resolvePulseSource(pactlPath);
+        let available = Boolean(ffmpegPath && source);
+        let reason;
+        if (!ffmpegPath) {
+            available = false;
+            reason = 'ffmpeg is not installed or AGENT_BROWSER_FFMPEG is not set';
+        }
+        else if (!source) {
+            available = false;
+            reason = 'PulseAudio monitor source was not found. Set AGENT_BROWSER_AUDIO_SOURCE if needed';
+        }
+        return {
+            available,
+            running: this.isRunning(),
+            clients: this.clients.size,
+            source,
+            ffmpegPath,
+            mimeType: 'audio/webm; codecs="opus"',
+            reason,
+            error: this.lastError,
+        };
+    }
+    attachWebSocket(socket) {
+        this.clients.add(socket);
+        socket.on('close', () => {
+            this.clients.delete(socket);
+            if (this.clients.size === 0) {
+                void this.stop();
+            }
+        });
+        socket.on('error', () => {
+            this.clients.delete(socket);
+            if (this.clients.size === 0) {
+                void this.stop();
+            }
+        });
+        void this.openForClient(socket);
+    }
+    async stop() {
+        const proc = this.captureProcess;
+        this.captureProcess = null;
+        if (proc && proc.exitCode == null && proc.signalCode == null) {
+            await new Promise((resolve) => {
+                const killTimer = setTimeout(() => {
+                    try {
+                        proc.kill('SIGKILL');
+                    }
+                    catch {
+                        // ignore
+                    }
+                }, 2000);
+                killTimer.unref?.();
+                proc.once('exit', () => {
+                    clearTimeout(killTimer);
+                    resolve();
+                });
+                try {
+                    proc.kill('SIGTERM');
+                }
+                catch {
+                    clearTimeout(killTimer);
+                    resolve();
+                }
+            });
+        }
+        await this.broadcastStatus();
+    }
+    async openForClient(socket) {
+        await this.sendStatus(socket);
+        try {
+            await this.start();
+            await this.sendStatus(socket);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.lastError = message;
+            this.send(socket, { type: 'audio-error', error: message });
+            await this.broadcastStatus();
+        }
+    }
+    async start() {
+        if (this.isRunning()) {
+            return;
+        }
+        if (this.starting) {
+            return this.starting;
+        }
+        this.starting = this.startCapture();
+        try {
+            await this.starting;
+        }
+        finally {
+            this.starting = null;
+        }
+    }
+    async startCapture() {
+        this.lastError = undefined;
+        this.ffmpegPath = await resolveExecutable('AGENT_BROWSER_FFMPEG', ['ffmpeg']);
+        if (!this.ffmpegPath) {
+            throw new Error('ffmpeg is required for browser audio streaming');
+        }
+        const pactlPath = await resolveExecutable('AGENT_BROWSER_PACTL', ['pactl']).catch(() => null);
+        this.audioSource = await resolvePulseSource(pactlPath);
+        if (!this.audioSource) {
+            throw new Error('PulseAudio monitor source was not found. Set AGENT_BROWSER_AUDIO_SOURCE to a monitor source');
+        }
+        const proc = spawn(this.ffmpegPath, [
+            '-hide_banner',
+            '-loglevel',
+            'warning',
+            '-nostdin',
+            '-f',
+            'pulse',
+            '-i',
+            this.audioSource,
+            '-vn',
+            '-ac',
+            '2',
+            '-ar',
+            '48000',
+            '-c:a',
+            'libopus',
+            '-b:a',
+            '96k',
+            '-application',
+            'audio',
+            '-f',
+            'webm',
+            'pipe:1',
+        ], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: process.env,
+        });
+        this.captureProcess = proc;
+        let stderrTail = '';
+        const stderrChunks = [];
+        proc.stderr.setEncoding('utf8');
+        proc.stderr.on('data', (chunk) => {
+            stderrChunks.push(chunk);
+            stderrTail = stderrChunks.join('').slice(-2000);
+        });
+        proc.stdout.on('data', (chunk) => {
+            this.broadcastAudio(chunk);
+        });
+        proc.once('exit', (code, signal) => {
+            if (this.captureProcess === proc) {
+                this.captureProcess = null;
+            }
+            if (this.clients.size > 0) {
+                this.lastError = `Audio capture exited (${signal ?? code ?? 'unknown'}): ${stderrTail.trim()}`;
+                this.broadcast({
+                    type: 'audio-error',
+                    error: this.lastError,
+                });
+                void this.broadcastStatus();
+            }
+        });
+        proc.once('error', (error) => {
+            this.lastError = error.message;
+            if (this.captureProcess === proc) {
+                this.captureProcess = null;
+            }
+            this.broadcast({ type: 'audio-error', error: error.message });
+            void this.broadcastStatus();
+        });
+        try {
+            await this.waitForFirstChunk(proc);
+        }
+        catch (error) {
+            if (this.captureProcess === proc) {
+                this.captureProcess = null;
+            }
+            try {
+                proc.kill('SIGTERM');
+            }
+            catch {
+                // ignore
+            }
+            throw error;
+        }
+        await this.broadcastStatus();
+    }
+    waitForFirstChunk(proc) {
+        return new Promise((resolve, reject) => {
+            let done = false;
+            const timer = setTimeout(() => {
+                if (done)
+                    return;
+                done = true;
+                cleanup();
+                reject(new Error('Timed out waiting for browser audio stream'));
+            }, 5000);
+            timer.unref?.();
+            const cleanup = () => {
+                clearTimeout(timer);
+                proc.stdout.off('data', onData);
+                proc.off('exit', onExit);
+                proc.off('error', onError);
+            };
+            const onData = () => {
+                if (done)
+                    return;
+                done = true;
+                cleanup();
+                resolve();
+            };
+            const onExit = (code, signal) => {
+                if (done)
+                    return;
+                done = true;
+                cleanup();
+                reject(new Error(`Audio capture exited before streaming (${signal ?? code ?? 'unknown'})`));
+            };
+            const onError = (error) => {
+                if (done)
+                    return;
+                done = true;
+                cleanup();
+                reject(error);
+            };
+            proc.stdout.once('data', onData);
+            proc.once('exit', onExit);
+            proc.once('error', onError);
+        });
+    }
+    isRunning() {
+        const proc = this.captureProcess;
+        return Boolean(proc && proc.exitCode == null && proc.signalCode == null);
+    }
+    broadcastAudio(chunk) {
+        for (const socket of this.clients) {
+            if (!isOpen(socket)) {
+                continue;
+            }
+            if (socket.bufferedAmount > AUDIO_CLIENT_BUFFER_LIMIT) {
+                try {
+                    socket.close(1009, 'Browser audio overflow');
+                }
+                catch {
+                    // ignore
+                }
+                continue;
+            }
+            try {
+                socket.send(chunk, { binary: true });
+            }
+            catch {
+                try {
+                    socket.close(1011, 'Browser audio send failed');
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+    }
+    async sendStatus(socket) {
+        this.send(socket, { type: 'audio-status', status: await this.getStatus() });
+    }
+    async broadcastStatus() {
+        const status = await this.getStatus();
+        this.broadcast({ type: 'audio-status', status });
+    }
+    broadcast(payload) {
+        const text = JSON.stringify(payload);
+        for (const socket of this.clients) {
+            this.sendRaw(socket, text);
+        }
+    }
+    send(socket, payload) {
+        this.sendRaw(socket, JSON.stringify(payload));
+    }
+    sendRaw(socket, payload) {
+        if (!isOpen(socket)) {
+            return;
+        }
+        try {
+            socket.send(payload);
+        }
+        catch {
+            try {
+                socket.close(1011, 'Browser audio control send failed');
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+}

package/dist/utils/database.js

@@ -45,16 +45,6 @@ export function initializeDatabase(db) {
       workspace_id TEXT NOT NULL,
       created_at TEXT NOT NULL
     );
-  `);
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS terminals (
-      id TEXT PRIMARY KEY,
-      deck_id TEXT NOT NULL,
-      title TEXT NOT NULL,
-      command TEXT,
-      buffer TEXT NOT NULL DEFAULT '',
-      created_at TEXT NOT NULL
-    );
   `);
     // Migration: add sort_order column to decks
     try {
@@ -65,13 +55,6 @@ export function initializeDatabase(db) {
     }
     // Create indexes for better query performance
     db.exec(`CREATE INDEX IF NOT EXISTS idx_decks_workspace_id ON decks(workspace_id);`);
-    db.exec(`CREATE INDEX IF NOT EXISTS idx_terminals_deck_id ON terminals(deck_id);`);
-}
-export function clearOrphanedTerminals(db) {
-    try {
-        db.exec('DELETE FROM terminals');
-    }
-    catch { /* table may not exist yet */ }
 }
 export function loadPersistedState(db, workspaces, workspacePathIndex, decks) {
     const workspaceRows = db
@@ -108,26 +91,3 @@ export function loadPersistedState(db, workspaces, workspacePathIndex, decks) {
         decks.set(deck.id, deck);
     });
 }
-export function saveTerminal(db, id, deckId, title, command, createdAt) {
-    const stmt = db.prepare('INSERT OR REPLACE INTO terminals (id, deck_id, title, command, buffer, created_at) VALUES (?, ?, ?, ?, ?, ?)');
-    stmt.run(id, deckId, title, command, '', createdAt);
-}
-export function updateTerminalBuffer(db, id, buffer) {
-    const stmt = db.prepare('UPDATE terminals SET buffer = ? WHERE id = ?');
-    stmt.run(buffer, id);
-}
-export function loadTerminals(db) {
-    const rows = db.prepare('SELECT id, deck_id, title, command, buffer, created_at FROM terminals ORDER BY created_at ASC').all();
-    return rows.map((row) => ({
-        id: String(row.id),
-        deckId: String(row.deck_id),
-        title: String(row.title),
-        command: row.command ? String(row.command) : null,
-        buffer: String(row.buffer ?? ''),
-        createdAt: String(row.created_at),
-    }));
-}
-export function deleteTerminal(db, id) {
-    const stmt = db.prepare('DELETE FROM terminals WHERE id = ?');
-    stmt.run(id);
-}

package/dist/utils/shell.js

@@ -1,4 +1,38 @@
+import { execSync } from 'node:child_process';
+import path from 'node:path';
 export function getDefaultShell() {
     return (process.env.SHELL ||
         (process.platform === 'win32' ? 'powershell.exe' : 'bash'));
 }
+// `locale -a` の結果はプロセス内で変わらないのでモジュールスコープでキャッシュする。
+let cachedAvailableLocales = null;
+/**
+ * システムで利用可能なロケール一覧を返す（非Windowsのみ）。
+ * `locale -a` を実行できない環境では空配列を返す。
+ */
+export function getAvailableLocales() {
+    if (process.platform === 'win32') {
+        return [];
+    }
+    if (cachedAvailableLocales !== null) {
+        return cachedAvailableLocales;
+    }
+    try {
+        const output = execSync('locale -a', { encoding: 'utf8' });
+        cachedAvailableLocales = output
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+    }
+    catch {
+        cachedAvailableLocales = [];
+    }
+    return cachedAvailableLocales;
+}
+/**
+ * シェルのベース名を小文字で返す（例: "/bin/zsh" -> "zsh", "powershell.exe" -> "powershell"）。
+ */
+export function getShellBasename(shell) {
+    const base = path.basename(shell).toLowerCase();
+    return base.replace(/\.exe$/, '');
+}

package/dist/websocket.js

@@ -143,6 +143,19 @@ function sendControl(socket, message) {
         return false;
     }
 }
+// 制御権（resizeOwner = 主クライアント）を付け替え、新旧クライアントへ
+// primary 状態を通知する。主クライアントだけが端末クエリへ応答する。
+function assignResizeOwner(session, socket) {
+    const previous = session.resizeOwner;
+    if (previous === socket) {
+        return;
+    }
+    session.resizeOwner = socket;
+    if (previous) {
+        sendControl(previous, { type: 'primary', value: false });
+    }
+    sendControl(socket, { type: 'primary', value: true });
+}
 function readBufferedRange(session, startOffset, endOffset) {
     const relativeStart = Math.max(0, startOffset - session.bufferBase);
     const relativeEnd = Math.max(relativeStart, Math.min(session.bufferLength, endOffset - session.bufferBase));
@@ -183,7 +196,7 @@ function readBufferedRange(session, startOffset, endOffset) {
     }
     return Buffer.from(raw.subarray(alignedStart, alignedEnd));
 }
-export function setupWebSocketServer(server, terminals) {
+export function setupWebSocketServer(server, terminals, browserService) {
     const wss = new WebSocketServer({ server, maxPayload: MAX_MESSAGE_SIZE });
     const heartbeatState = new WeakMap();
     const heartbeatInterval = setInterval(() => {
@@ -259,6 +272,32 @@ export function setupWebSocketServer(server, terminals) {
             return;
         }
         const url = new URL(req.url || '', `http://localhost:${PORT}`);
+        if (url.pathname === '/api/browser/ws') {
+            if (!browserService) {
+                untrackConnection(clientIP, socket);
+                socket.close(1011, 'Browser service unavailable');
+                return;
+            }
+            socket.on('close', () => {
+                heartbeatState.delete(socket);
+                untrackConnection(clientIP, socket);
+            });
+            browserService.attachWebSocket(socket);
+            return;
+        }
+        if (url.pathname === '/api/browser/audio/ws') {
+            if (!browserService) {
+                untrackConnection(clientIP, socket);
+                socket.close(1011, 'Browser service unavailable');
+                return;
+            }
+            socket.on('close', () => {
+                heartbeatState.delete(socket);
+                untrackConnection(clientIP, socket);
+            });
+            browserService.attachAudioWebSocket(socket);
+            return;
+        }
         const match = url.pathname.match(/\/api\/terminals\/(.+)/);
         if (!match) {
             untrackConnection(clientIP, socket);
@@ -321,6 +360,8 @@ export function setupWebSocketServer(server, terminals) {
             }
         }
         sendControl(socket, { type: 'ready' });
+        // この接続が現在の主クライアントかを通知（既定では先頭接続が主）。
+        sendControl(socket, { type: 'primary', value: session.resizeOwner === socket });
         socket.on('message', (data, isBinary) => {
             try {
                 const messageSize = rawDataByteLength(data);
@@ -347,14 +388,14 @@ export function setupWebSocketServer(server, terminals) {
                         control = null;
                     }
                     if (control?.type === 'claim') {
-                        session.resizeOwner = socket;
+                        assignResizeOwner(session, socket);
                         return;
                     }
                     if (control?.type === 'resize') {
                         if (session.resizeOwner && session.resizeOwner !== socket) {
                             return;
                         }
-                        session.resizeOwner = socket;
+                        assignResizeOwner(session, socket);
                         const cols = validateTerminalSize(control.cols);
                         const rows = validateTerminalSize(control.rows);
                         try {
@@ -390,6 +431,12 @@ export function setupWebSocketServer(server, terminals) {
             session.sockets.delete(socket);
             if (session.resizeOwner === socket) {
                 session.resizeOwner = null;
+                // 主クライアントが去ったら、残っている接続のいずれかを主に昇格させ、
+                // 端末クエリへ応答するクライアントが居なくならないようにする。
+                const next = session.sockets.values().next().value;
+                if (next) {
+                    assignResizeOwner(session, next);
+                }
             }
             session.lastActive = Date.now();
             heartbeatState.delete(socket);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deckide",
-  "version": "3.5.32",
+  "version": "3.5.34",
   "description": "Deck IDE - Browser-based IDE with terminal, file explorer, and git integration",
   "type": "module",
   "bin": {
@@ -22,6 +22,11 @@
   },
   "dependencies": {
     "@hono/node-server": "^1.12.2",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/addon-unicode11": "^0.9.0",
+    "@xterm/addon-web-links": "^0.12.0",
+    "@xterm/addon-webgl": "^0.19.0",
+    "@xterm/xterm": "^5.5.0",
     "hono": "^4.5.10",
     "node-pty": "^1.0.0",
     "simple-git": "^3.27.0",
@@ -39,13 +44,12 @@
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "tailwindcss": "^4.2.1",
-    "tsx": "^4.19.2",
+    "tsx": "^4.22.4",
     "typescript": "^5.6.3",
-    "vite": "^5.2.0",
-    "xterm": "^5.3.0",
-    "xterm-addon-fit": "^0.8.0",
-    "xterm-addon-unicode11": "^0.6.0",
-    "xterm-addon-web-links": "^0.9.0"
+    "vite": "^6.4.3"
+  },
+  "overrides": {
+    "dompurify": "3.4.11"
   },
   "engines": {
     "node": ">=22.5.0"