deckide 3.5.32 → 3.5.34

package/dist/routes/terminals.js

@@ -3,12 +3,82 @@ import { Hono } from 'hono';
 import { spawn } from 'node-pty';
 import { TERMINAL_BUFFER_LIMIT } from '../config.js';
 import { createHttpError, handleError, readJson } from '../utils/error.js';
-import { getDefaultShell } from '../utils/shell.js';
-import { saveTerminal, deleteTerminal as deleteTerminalFromDb } from '../utils/database.js';
+import { getDefaultShell, getAvailableLocales, getShellBasename } from '../utils/shell.js';
 import { alignToUtf8Start, skipPartialEscapeSequence } from '../utils/utf8.js';
 const DEFAULT_TERMINAL_TITLE = 'ターミナル';
 const MAX_SOCKET_BUFFERED_AMOUNT = 1024 * 1024;
-export function createTerminalRouter(db, decks, terminals) {
+// 初期端末サイズ（リクエストで指定がない場合のデフォルト）。
+const DEFAULT_TERMINAL_COLS = 120;
+const DEFAULT_TERMINAL_ROWS = 32;
+// WebSocket の resize と同じ範囲でバリデーションする。
+const MIN_TERMINAL_SIZE = 1;
+const MAX_TERMINAL_SIZE = 500;
+// ログインシェルとして扱う POSIX シェルのベース名。
+const POSIX_LOGIN_SHELLS = new Set(['bash', 'zsh', 'sh', 'fish', 'csh', 'tcsh']);
+function isUtf8Locale(value) {
+    if (!value)
+        return false;
+    return /\.(utf-?8)$/i.test(value);
+}
+/**
+ * リクエストボディの cols/rows を整数化し 1..500 の範囲に収める。
+ * 数値でない場合は fallback を返す。
+ */
+function normalizeTerminalSize(value, fallback) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return fallback;
+    }
+    const intValue = Math.floor(value);
+    if (intValue < MIN_TERMINAL_SIZE)
+        return MIN_TERMINAL_SIZE;
+    if (intValue > MAX_TERMINAL_SIZE)
+        return MAX_TERMINAL_SIZE;
+    return intValue;
+}
+/**
+ * 継承した環境に有効な UTF-8 ロケールが無い場合のフォールバックを選ぶ。
+ * システムに存在しないロケールは決して設定しない。
+ * 優先順位: 継承 LANG と同じ言語の UTF-8 → "C.UTF-8" → "C.utf8" → 最初の "*.UTF-8"/"*.utf8"。
+ * 該当が無ければ null を返す（何も設定しない）。
+ */
+function pickFallbackUtf8Locale(inheritedLang) {
+    const available = getAvailableLocales();
+    if (available.length === 0) {
+        return null;
+    }
+    const utf8Locales = available.filter((loc) => isUtf8Locale(loc));
+    if (utf8Locales.length === 0) {
+        return null;
+    }
+    // 継承 LANG の言語部分（例: "ja_JP.eucJP" -> "ja_JP" / "ja"）に一致する UTF-8 ロケール。
+    if (inheritedLang) {
+        const langBase = inheritedLang.split('.')[0];
+        if (langBase) {
+            const exact = utf8Locales.find((loc) => loc.split('.')[0] === langBase);
+            if (exact)
+                return exact;
+            const lang = langBase.split('_')[0];
+            if (lang) {
+                const byLang = utf8Locales.find((loc) => loc.split(/[._]/)[0] === lang);
+                if (byLang)
+                    return byLang;
+            }
+        }
+    }
+    const cUtf8 = utf8Locales.find((loc) => loc === 'C.UTF-8');
+    if (cUtf8)
+        return cUtf8;
+    const cUtf8Lower = utf8Locales.find((loc) => loc === 'C.utf8');
+    if (cUtf8Lower)
+        return cUtf8Lower;
+    return utf8Locales[0];
+}
+// PTY flow-control thresholds (per terminal session).
+const FLOW_HIGH_WATER = 512 * 1024; // pause the PTY above this backlog
+const FLOW_LOW_WATER = 64 * 1024; // resume once drained below this
+const FLOW_CHECK_INTERVAL_MS = 100; // how often to poll for drain while paused
+const FLOW_MAX_PAUSE_MS = 10_000; // evict a stuck consumer after this long
+export function createTerminalRouter(decks, terminals) {
     const router = new Hono();
     function toBuffer(data) {
         return Buffer.isBuffer(data) ? data : Buffer.from(data, 'utf8');
@@ -124,11 +194,11 @@ export function createTerminalRouter(db, decks, terminals) {
                 deadSockets.add(socket);
             }
         });
+        // resizeOwner（主クライアント）の付け替え・昇格は WebSocket の close
+        // ハンドラに一元化する。ここで resizeOwner を null にすると、主ソケットが
+        // 切断されたときの「残りクライアントへの昇格」が動かなくなるため触らない。
         deadSockets.forEach((s) => {
             session.sockets.delete(s);
-            if (session.resizeOwner === s) {
-                session.resizeOwner = null;
-            }
         });
     }
     function handleTerminalExit(id) {
@@ -137,7 +207,6 @@ export function createTerminalRouter(db, decks, terminals) {
             return;
         console.log(`[TERMINAL] Terminal ${id} exited`);
         terminals.delete(id);
-        deleteTerminalFromDb(db, id);
         session.sockets.forEach((socket) => {
             try {
                 socket.close(1000, 'Terminal exited');
@@ -147,7 +216,7 @@ export function createTerminalRouter(db, decks, terminals) {
         session.sockets.clear();
         session.resizeOwner = null;
     }
-    function createTerminalSession(deck, title, command) {
+    function createTerminalSession(deck, title, command, cols = DEFAULT_TERMINAL_COLS, rows = DEFAULT_TERMINAL_ROWS) {
         const id = crypto.randomUUID();
         // Resolve shell and arguments
         let shell;
@@ -169,6 +238,14 @@ export function createTerminalRouter(db, decks, terminals) {
         }
         else {
             shell = getDefaultShell();
+            // macOS のターミナルアプリはログインシェル（-l）で起動し
+            // ~/.zprofile / ~/.bash_profile から PATH を読み込む。これに合わせる。
+            // 一方 Linux の端末は通常「非ログインの対話シェル」で ~/.bashrc を読むため、
+            // -l を付けると ~/.bash_profile を持たないユーザーが alias/関数を失う回帰になる。
+            // そのため -l は darwin のみに限定する。
+            if (process.platform === 'darwin' && POSIX_LOGIN_SHELLS.has(getShellBasename(shell))) {
+                shellArgs = ['-l'];
+            }
         }
         // Build environment
         const env = {};
@@ -179,21 +256,32 @@ export function createTerminalRouter(db, decks, terminals) {
         env.TERM = env.TERM || 'xterm-256color';
         env.COLORTERM = 'truecolor';
         env.TERM_PROGRAM = 'xterm.js';
-        env.TERM_PROGRAM_VERSION = '5.0.0';
+        env.TERM_PROGRAM_VERSION = '5.5.0';
         if (process.platform === 'win32') {
+            // Windows は従来どおり（locale -a 検出は行わない）。
             env.LANG = 'en_US.UTF-8';
         }
         else {
-            env.LANG = env.LANG || 'en_US.UTF-8';
+            // LC_ALL は設定しない（ユーザーの実ロケールを上書きしない）。
+            // 継承した環境に有効な UTF-8 ロケールが無いときだけフォールバックを設定する。
+            const hasInheritedUtf8 = isUtf8Locale(env.LC_ALL) ||
+                isUtf8Locale(env.LANG) ||
+                isUtf8Locale(env.LC_CTYPE);
+            if (!hasInheritedUtf8) {
+                const fallback = pickFallbackUtf8Locale(env.LANG);
+                if (fallback) {
+                    // 実在するロケールのみを設定する（存在しないロケールは設定しない）。
+                    env.LANG = env.LANG || fallback;
+                    env.LC_CTYPE = env.LC_CTYPE || fallback;
+                }
+            }
         }
-        env.LC_ALL = env.LC_ALL || 'en_US.UTF-8';
-        env.LC_CTYPE = env.LC_CTYPE || 'en_US.UTF-8';
         // Spawn PTY directly in this process
         const isWindows = process.platform === 'win32';
         const term = spawn(shell, shellArgs, {
             cwd: deck.root,
-            cols: 120,
-            rows: 32,
+            cols,
+            rows,
             env,
             encoding: null,
             ...(isWindows ? { useConpty: true } : {}),
@@ -229,16 +317,90 @@ export function createTerminalRouter(db, decks, terminals) {
             }
             catch { /* already dead */ } },
         };
+        // ── Flow control ────────────────────────────────────────────────────
+        // Instead of closing a slow client when its send buffer fills (which then
+        // reconnects and re-replays, looking like the terminal "freezes" or jumps
+        // during heavy output), pause the PTY when the slowest consumer falls
+        // behind and resume once it drains.  A stuck consumer is evicted after a
+        // grace period so it can't deadlock the terminal for everyone else.
+        let ptyPaused = false;
+        let resumeTimer = null;
+        let pausedAt = 0;
+        const maxBufferedAmount = () => {
+            let max = 0;
+            session.sockets.forEach((socket) => {
+                if (socket.readyState === 1 && socket.bufferedAmount > max) {
+                    max = socket.bufferedAmount;
+                }
+            });
+            return max;
+        };
+        const evictLaggards = (threshold) => {
+            session.sockets.forEach((socket) => {
+                if (socket.readyState === 1 && socket.bufferedAmount > threshold) {
+                    // close() で readyState は即 CLOSING になり、maxBufferedAmount の
+                    // 集計（OPEN のみ）から外れる。socket の削除と resizeOwner の昇格は
+                    // WebSocket の close ハンドラに任せる（主クライアント昇格のため）。
+                    try {
+                        socket.close(1009, 'Terminal output overflow');
+                    }
+                    catch { /* ignore */ }
+                }
+            });
+        };
+        const resumePty = () => {
+            if (resumeTimer) {
+                clearInterval(resumeTimer);
+                resumeTimer = null;
+            }
+            if (!ptyPaused)
+                return;
+            ptyPaused = false;
+            try {
+                term.resume();
+            }
+            catch { /* terminal may be dying */ }
+        };
+        const pausePty = () => {
+            if (ptyPaused)
+                return;
+            ptyPaused = true;
+            pausedAt = Date.now();
+            try {
+                term.pause();
+            }
+            catch { /* terminal may be dying */ }
+            resumeTimer = setInterval(() => {
+                if (maxBufferedAmount() < FLOW_LOW_WATER) {
+                    resumePty();
+                    return;
+                }
+                if (Date.now() - pausedAt > FLOW_MAX_PAUSE_MS) {
+                    // A consumer is stuck — drop it rather than freeze everyone.
+                    evictLaggards(FLOW_LOW_WATER);
+                    if (maxBufferedAmount() < FLOW_LOW_WATER) {
+                        resumePty();
+                    }
+                    else {
+                        pausedAt = Date.now();
+                    }
+                }
+            }, FLOW_CHECK_INTERVAL_MS);
+            resumeTimer.unref?.();
+        };
         // Wire up PTY output → buffer + WebSocket broadcast
         term.on('data', (data) => {
             appendToTerminalBuffer(session, data);
             session.lastActive = Date.now();
             broadcastToSockets(session, data);
+            if (!ptyPaused && maxBufferedAmount() > FLOW_HIGH_WATER) {
+                pausePty();
+            }
         });
         term.onExit(() => {
+            resumePty();
             handleTerminalExit(id);
         });
-        saveTerminal(db, id, deck.id, resolvedTitle, command || null, createdAt);
         terminals.set(id, session);
         return session;
     }
@@ -265,7 +427,9 @@ export function createTerminalRouter(db, decks, terminals) {
             const deck = decks.get(deckId);
             if (!deck)
                 throw createHttpError('Deck not found', 404);
-            const session = createTerminalSession(deck, body?.title, body?.command);
+            const cols = normalizeTerminalSize(body?.cols, DEFAULT_TERMINAL_COLS);
+            const rows = normalizeTerminalSize(body?.rows, DEFAULT_TERMINAL_ROWS);
+            const session = createTerminalSession(deck, body?.title, body?.command, cols, rows);
             return c.json({ id: session.id, title: session.title }, 201);
         }
         catch (error) {
@@ -279,7 +443,6 @@ export function createTerminalRouter(db, decks, terminals) {
             if (!session)
                 throw createHttpError('Terminal not found', 404);
             terminals.delete(terminalId);
-            deleteTerminalFromDb(db, terminalId);
             session.sockets.forEach((socket) => {
                 try {
                     socket.close(1000, 'Terminal deleted');

package/dist/server.js

@@ -11,13 +11,16 @@ import { PORT, HOST, NODE_ENV, BASIC_AUTH_USER, BASIC_AUTH_PASSWORD, CORS_ORIGIN
 import { securityHeaders } from './middleware/security.js';
 import { corsMiddleware } from './middleware/cors.js';
 import { basicAuthMiddleware, generateWsToken, isBasicAuthEnabled } from './middleware/auth.js';
-import { checkDatabaseIntegrity, handleDatabaseCorruption, initializeDatabase, loadPersistedState, clearOrphanedTerminals, } from './utils/database.js';
+import { checkDatabaseIntegrity, handleDatabaseCorruption, initializeDatabase, loadPersistedState, } from './utils/database.js';
 import { createWorkspaceRouter, getConfigHandler } from './routes/workspaces.js';
 import { createDeckRouter } from './routes/decks.js';
 import { createFileRouter } from './routes/files.js';
 import { createTerminalRouter } from './routes/terminals.js';
 import { createGitRouter } from './routes/git.js';
 import { createSettingsRouter } from './routes/settings.js';
+import { createMcpRouter } from './routes/mcp.js';
+import { createBrowserRouter } from './routes/browser.js';
+import { AgentBrowserService } from './utils/agent-browser.js';
 import { setupWebSocketServer, getConnectionLimit, setConnectionLimit, getConnectionStats, clearAllConnections, } from './websocket.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // Request ID and logging middleware
@@ -42,12 +45,12 @@ export async function createServer() {
     }
     const db = new DatabaseSync(dbPath);
     initializeDatabase(db);
-    clearOrphanedTerminals(db);
     // Initialize state
     const workspaces = new Map();
     const workspacePathIndex = new Map();
     const decks = new Map();
     const terminals = new Map();
+    const browserService = new AgentBrowserService();
     loadPersistedState(db, workspaces, workspacePathIndex, decks);
     // Create Hono app
     const app = new Hono();
@@ -58,17 +61,27 @@ export async function createServer() {
         maxSize: MAX_REQUEST_BODY_SIZE,
         onError: (c) => c.json({ error: 'Request body too large' }, 413),
     }));
+    app.use('/mcp', bodyLimit({
+        maxSize: MAX_REQUEST_BODY_SIZE,
+        onError: (c) => c.json({ error: 'Request body too large' }, 413),
+    }));
+    app.use('/oauth/*', bodyLimit({
+        maxSize: MAX_REQUEST_BODY_SIZE,
+        onError: (c) => c.json({ error: 'Request body too large' }, 413),
+    }));
     if (basicAuthMiddleware) {
         app.use('/api/*', basicAuthMiddleware);
+        app.use('/oauth/authorize', basicAuthMiddleware);
     }
     app.get('/health', (c) => c.json({ status: 'ok', timestamp: new Date().toISOString(), uptime: process.uptime() }));
     // Mount routers
     app.route('/api/settings', createSettingsRouter());
     app.route('/api/workspaces', createWorkspaceRouter(db, workspaces, workspacePathIndex));
     app.route('/api/decks', createDeckRouter(db, workspaces, decks, terminals));
-    const terminalRouter = createTerminalRouter(db, decks, terminals);
+    const terminalRouter = createTerminalRouter(decks, terminals);
     app.route('/api/terminals', terminalRouter);
     app.route('/api/git', createGitRouter(workspaces));
+    app.route('/api/browser', createBrowserRouter(browserService));
     app.get('/api/config', getConfigHandler());
     app.get('/api/ws-token', (c) => c.json({ token: generateWsToken(), authEnabled: isBasicAuthEnabled() }));
     app.get('/api/ws/stats', (c) => c.json({ limit: getConnectionLimit(), connections: getConnectionStats() }));
@@ -86,6 +99,10 @@ export async function createServer() {
     });
     const fileRouter = createFileRouter(workspaces);
     app.route('/api', fileRouter);
+    app.route('/', createMcpRouter({
+        apiFetch: (request) => Promise.resolve(app.fetch(request)),
+        terminals,
+    }));
     if (hasStatic) {
         const serveAssets = serveStatic({ root: distDir });
         const serveIndex = serveStatic({ root: distDir, path: 'index.html' });
@@ -97,18 +114,20 @@ export async function createServer() {
         });
     }
     const server = serve({ fetch: app.fetch, port: PORT, hostname: HOST });
-    setupWebSocketServer(server, terminals);
+    setupWebSocketServer(server, terminals, browserService);
     server.on('listening', () => {
         const baseUrl = `http://localhost:${PORT}`;
         console.log(`Deck IDE server listening on ${baseUrl}`);
         console.log(`UI: ${baseUrl}`);
         console.log(`API: ${baseUrl}/api`);
+        console.log(`MCP: ${baseUrl}/mcp`);
         console.log(`Health: ${baseUrl}/health`);
         console.log('');
         console.log('Security Status:');
         console.log(`  - Basic Auth: ${BASIC_AUTH_USER && BASIC_AUTH_PASSWORD ? 'enabled' : 'DISABLED'}`);
         console.log(`  - Max File Size: ${Math.round(MAX_FILE_SIZE / 1024 / 1024)}MB`);
         console.log(`  - Max Request Body: ${Math.round(MAX_REQUEST_BODY_SIZE / 1024)}KB`);
+        console.log('  - MCP OAuth: enabled');
         console.log(`  - Trust Proxy: ${TRUST_PROXY ? 'enabled' : 'disabled'}`);
         console.log(`  - CORS Origin: ${CORS_ORIGIN || (NODE_ENV === 'development' ? '*' : 'NOT SET')}`);
         console.log(`  - Environment: ${NODE_ENV}`);
@@ -130,6 +149,7 @@ export async function createServer() {
                 session.kill();
             });
             terminals.clear();
+            await browserService.stop();
             try {
                 db.close();
             }