deckide 3.5.15 → 3.5.17

package/dist/routes/decks.js

@@ -2,7 +2,7 @@ import crypto from 'node:crypto';
 import { Hono } from 'hono';
 import { createHttpError, handleError, readJson } from '../utils/error.js';
 import { requireWorkspace } from './workspaces.js';
-export function createDeckRouter(db, workspaces, decks) {
+export function createDeckRouter(db, workspaces, decks, terminals) {
     const router = new Hono();
     const insertDeck = db.prepare('INSERT INTO decks (id, name, root, workspace_id, created_at) VALUES (?, ?, ?, ?, ?)');
     function createDeck(name, workspaceId) {
@@ -76,12 +76,33 @@ export function createDeckRouter(db, workspaces, decks) {
     });
     const deleteDeckStmt = db.prepare('DELETE FROM decks WHERE id = ?');
     const deleteTerminalsByDeckStmt = db.prepare('DELETE FROM terminals WHERE deck_id = ?');
+    function closeDeckTerminalSockets(sockets, reason) {
+        sockets.forEach((socket) => {
+            try {
+                socket.close(1000, reason);
+            }
+            catch { /* ignore */ }
+        });
+        sockets.clear();
+    }
     router.delete('/:id', (c) => {
         try {
             const deckId = c.req.param('id');
             if (!decks.has(deckId)) {
                 throw createHttpError('Deck not found', 404);
             }
+            const deckTerminalIds = Array.from(terminals.values())
+                .filter((session) => session.deckId === deckId)
+                .map((session) => session.id);
+            deckTerminalIds.forEach((terminalId) => {
+                const session = terminals.get(terminalId);
+                if (!session)
+                    return;
+                terminals.delete(terminalId);
+                session.resizeOwner = null;
+                closeDeckTerminalSockets(session.sockets, 'Deck deleted');
+                session.kill();
+            });
             deleteTerminalsByDeckStmt.run(deckId);
             deleteDeckStmt.run(deckId);
             decks.delete(deckId);

package/dist/routes/terminals.js

@@ -5,43 +5,99 @@ 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';
-// Track terminal index per deck for unique naming
-const deckTerminalCounters = new Map();
+const DEFAULT_TERMINAL_TITLE = 'ターミナル';
+const MAX_SOCKET_BUFFERED_AMOUNT = 1024 * 1024;
 export function createTerminalRouter(db, decks, terminals) {
     const router = new Hono();
+    function toBuffer(data) {
+        return Buffer.isBuffer(data) ? data : Buffer.from(data, 'utf8');
+    }
     function appendToTerminalBuffer(session, data) {
-        const newBuffer = session.buffer + data;
-        if (newBuffer.length > TERMINAL_BUFFER_LIMIT) {
-            const excess = newBuffer.length - TERMINAL_BUFFER_LIMIT;
-            session.buffer = newBuffer.slice(excess);
-            session.bufferBase += excess;
+        const chunk = toBuffer(data);
+        if (chunk.length === 0) {
+            return;
         }
-        else {
-            session.buffer = newBuffer;
+        if (chunk.length >= TERMINAL_BUFFER_LIMIT) {
+            const retainedChunk = Buffer.from(chunk.subarray(chunk.length - TERMINAL_BUFFER_LIMIT));
+            session.bufferBase += session.bufferLength + (chunk.length - TERMINAL_BUFFER_LIMIT);
+            session.bufferChunks = [retainedChunk];
+            session.bufferLength = retainedChunk.length;
+            return;
+        }
+        session.bufferChunks.push(Buffer.from(chunk));
+        session.bufferLength += chunk.length;
+        while (session.bufferLength > TERMINAL_BUFFER_LIMIT && session.bufferChunks.length > 0) {
+            const overflow = session.bufferLength - TERMINAL_BUFFER_LIMIT;
+            const firstChunk = session.bufferChunks[0];
+            if (firstChunk.length <= overflow) {
+                session.bufferChunks.shift();
+                session.bufferBase += firstChunk.length;
+                session.bufferLength -= firstChunk.length;
+                continue;
+            }
+            session.bufferChunks[0] = Buffer.from(firstChunk.subarray(overflow));
+            session.bufferBase += overflow;
+            session.bufferLength -= overflow;
         }
     }
-    function getNextTerminalIndex(deckId) {
-        const current = deckTerminalCounters.get(deckId) ?? 0;
-        const next = current + 1;
-        deckTerminalCounters.set(deckId, next);
-        return next;
+    function getUniqueTerminalTitle(deckId, requestedTitle) {
+        const trimmedTitle = requestedTitle?.trim();
+        const baseTitle = trimmedTitle && trimmedTitle.length > 0 ? trimmedTitle : null;
+        const existingTitles = new Set(Array.from(terminals.values())
+            .filter((session) => session.deckId === deckId)
+            .map((session) => session.title));
+        if (!baseTitle) {
+            let index = 1;
+            while (existingTitles.has(`${DEFAULT_TERMINAL_TITLE} ${index}`)) {
+                index++;
+            }
+            return `${DEFAULT_TERMINAL_TITLE} ${index}`;
+        }
+        if (!existingTitles.has(baseTitle)) {
+            return baseTitle;
+        }
+        let suffix = 2;
+        while (existingTitles.has(`${baseTitle} ${suffix}`)) {
+            suffix++;
+        }
+        return `${baseTitle} ${suffix}`;
     }
     function broadcastToSockets(session, data) {
+        const payload = toBuffer(data);
         const deadSockets = new Set();
         session.sockets.forEach((socket) => {
             try {
-                if (socket.readyState === 1) {
-                    socket.send(data);
+                if (socket.readyState !== 1) {
+                    deadSockets.add(socket);
+                    return;
                 }
-                else if (socket.readyState > 1) {
+                if (socket.bufferedAmount > MAX_SOCKET_BUFFERED_AMOUNT) {
+                    try {
+                        socket.close(1009, 'Terminal output overflow');
+                    }
+                    catch { /* ignore */ }
                     deadSockets.add(socket);
+                    return;
                 }
+                socket.send(payload, { binary: true }, (error) => {
+                    if (error) {
+                        try {
+                            socket.close(1011, 'Terminal stream error');
+                        }
+                        catch { /* ignore */ }
+                    }
+                });
             }
             catch {
                 deadSockets.add(socket);
             }
         });
-        deadSockets.forEach((s) => session.sockets.delete(s));
+        deadSockets.forEach((s) => {
+            session.sockets.delete(s);
+            if (session.resizeOwner === s) {
+                session.resizeOwner = null;
+            }
+        });
     }
     function handleTerminalExit(id) {
         const session = terminals.get(id);
@@ -57,6 +113,7 @@ export function createTerminalRouter(db, decks, terminals) {
             catch { /* ignore */ }
         });
         session.sockets.clear();
+        session.resizeOwner = null;
     }
     function createTerminalSession(deck, title, command) {
         const id = crypto.randomUUID();
@@ -106,11 +163,11 @@ export function createTerminalRouter(db, decks, terminals) {
             cols: 120,
             rows: 32,
             env,
-            encoding: 'utf8',
+            encoding: null,
             ...(isWindows ? { useConpty: true } : {}),
         });
         console.log(`[TERMINAL] Created terminal ${id}: shell=${shell}, cwd=${deck.root}, pid=${term.pid}`);
-        const resolvedTitle = title || `Terminal ${getNextTerminalIndex(deck.id)}`;
+        const resolvedTitle = getUniqueTerminalTitle(deck.id, title);
         const createdAt = new Date().toISOString();
         const session = {
             id,
@@ -119,13 +176,18 @@ export function createTerminalRouter(db, decks, terminals) {
             command: command || null,
             createdAt,
             sockets: new Set(),
-            buffer: '',
+            resizeOwner: null,
+            bufferChunks: [],
+            bufferLength: 0,
             bufferBase: 0,
             lastActive: Date.now(),
-            write: (data) => { try {
-                term.write(data);
-            }
-            catch { /* terminal may be dying */ } },
+            write: (data) => {
+                const payload = Buffer.isBuffer(data) ? data : Buffer.from(data);
+                try {
+                    term.write(payload);
+                }
+                catch { /* terminal may be dying */ }
+            },
             resize: (cols, rows) => { try {
                 term.resize(cols, rows);
             }
@@ -136,7 +198,7 @@ export function createTerminalRouter(db, decks, terminals) {
             catch { /* already dead */ } },
         };
         // Wire up PTY output → buffer + WebSocket broadcast
-        term.onData((data) => {
+        term.on('data', (data) => {
             appendToTerminalBuffer(session, data);
             session.lastActive = Date.now();
             broadcastToSockets(session, data);
@@ -193,6 +255,7 @@ export function createTerminalRouter(db, decks, terminals) {
                 catch { /* ignore */ }
             });
             session.sockets.clear();
+            session.resizeOwner = null;
             session.kill();
             return c.body(null, 204);
         }

package/dist/server.js

@@ -65,7 +65,7 @@ export async function createServer() {
     // Mount routers
     app.route('/api/settings', createSettingsRouter());
     app.route('/api/workspaces', createWorkspaceRouter(db, workspaces, workspacePathIndex));
-    app.route('/api/decks', createDeckRouter(db, workspaces, decks));
+    app.route('/api/decks', createDeckRouter(db, workspaces, decks, terminals));
     const terminalRouter = createTerminalRouter(db, decks, terminals);
     app.route('/api/terminals', terminalRouter);
     app.route('/api/git', createGitRouter(workspaces));

package/dist/websocket.js

@@ -1,11 +1,13 @@
 import crypto from 'node:crypto';
-import { WebSocketServer } from 'ws';
+import { WebSocketServer, WebSocket } from 'ws';
 import { PORT, TRUST_PROXY, CORS_ORIGIN, NODE_ENV } from './config.js';
 import { logSecurityEvent } from './middleware/security.js';
 import { verifyWebSocketAuth } from './middleware/auth.js';
 const MIN_TERMINAL_SIZE = 1;
 const MAX_TERMINAL_SIZE = 500;
 const MAX_MESSAGE_SIZE = 64 * 1024; // 64KB max message size
+const MAX_SOCKET_BUFFERED_AMOUNT = 1024 * 1024;
+const HEARTBEAT_INTERVAL_MS = 30_000;
 // Configurable connection limit per IP (default: 1000)
 let maxConnectionsPerIP = 1000;
 // Track connections per IP
@@ -75,6 +77,8 @@ function untrackConnection(ip, socket) {
     }
 }
 function validateTerminalSize(value) {
+    if (value == null)
+        return MIN_TERMINAL_SIZE;
     const intValue = Math.floor(value);
     if (!Number.isFinite(intValue) || intValue < MIN_TERMINAL_SIZE) {
         return MIN_TERMINAL_SIZE;
@@ -84,8 +88,113 @@ function validateTerminalSize(value) {
     }
     return intValue;
 }
+function rawDataByteLength(data) {
+    if (typeof data === 'string') {
+        return Buffer.byteLength(data, 'utf8');
+    }
+    if (Array.isArray(data)) {
+        return data.reduce((total, chunk) => total + chunk.length, 0);
+    }
+    if (data instanceof ArrayBuffer) {
+        return data.byteLength;
+    }
+    return data.length;
+}
+function rawDataToBuffer(data) {
+    if (typeof data === 'string') {
+        return Buffer.from(data, 'utf8');
+    }
+    if (Array.isArray(data)) {
+        return Buffer.concat(data);
+    }
+    if (data instanceof ArrayBuffer) {
+        return Buffer.from(data);
+    }
+    // data is Buffer
+    return Buffer.isBuffer(data) ? data : Buffer.from(data);
+}
+function canSendToSocket(socket) {
+    if (socket.readyState !== WebSocket.OPEN) {
+        return false;
+    }
+    if (socket.bufferedAmount > MAX_SOCKET_BUFFERED_AMOUNT) {
+        try {
+            socket.close(1009, 'Terminal output overflow');
+        }
+        catch { /* ignore */ }
+        return false;
+    }
+    return true;
+}
+function sendControl(socket, message) {
+    if (!canSendToSocket(socket)) {
+        return false;
+    }
+    try {
+        socket.send(JSON.stringify(message));
+        return true;
+    }
+    catch {
+        try {
+            socket.close(1011, 'Terminal control send failed');
+        }
+        catch { /* ignore */ }
+        return false;
+    }
+}
+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));
+    const totalLength = relativeEnd - relativeStart;
+    if (totalLength <= 0 || session.bufferChunks.length === 0) {
+        return Buffer.alloc(0);
+    }
+    if (session.bufferChunks.length === 1) {
+        return session.bufferChunks[0].subarray(relativeStart, relativeEnd);
+    }
+    const slices = [];
+    let traversed = 0;
+    for (const chunk of session.bufferChunks) {
+        const chunkStart = traversed;
+        const chunkEnd = traversed + chunk.length;
+        traversed = chunkEnd;
+        if (chunkEnd <= relativeStart) {
+            continue;
+        }
+        if (chunkStart >= relativeEnd) {
+            break;
+        }
+        const startInChunk = Math.max(0, relativeStart - chunkStart);
+        const endInChunk = Math.min(chunk.length, relativeEnd - chunkStart);
+        slices.push(chunk.subarray(startInChunk, endInChunk));
+    }
+    return slices.length === 1 ? slices[0] : Buffer.concat(slices, totalLength);
+}
 export function setupWebSocketServer(server, terminals) {
-    const wss = new WebSocketServer({ server });
+    const wss = new WebSocketServer({ server, maxPayload: MAX_MESSAGE_SIZE });
+    const heartbeatState = new WeakMap();
+    const heartbeatInterval = setInterval(() => {
+        for (const socket of wss.clients) {
+            if (heartbeatState.get(socket) === false) {
+                try {
+                    socket.terminate();
+                }
+                catch { /* ignore */ }
+                continue;
+            }
+            heartbeatState.set(socket, false);
+            try {
+                socket.ping();
+            }
+            catch {
+                try {
+                    socket.terminate();
+                }
+                catch { /* ignore */ }
+            }
+        }
+    }, HEARTBEAT_INTERVAL_MS);
+    heartbeatInterval.unref?.();
     const WS_ALLOWED_ORIGINS = new Set([
         `http://localhost:${PORT}`,
     ]);
@@ -101,6 +210,7 @@ export function setupWebSocketServer(server, terminals) {
     wss.on('connection', (socket, req) => {
         const socketId = crypto.randomUUID();
         const clientIP = getClientIP(req);
+        heartbeatState.set(socket, true);
         // Validate Origin header to prevent Cross-Site WebSocket Hijacking
         // Skip check if CORS_ORIGIN is '*' or unset in development mode
         const skipOriginCheck = CORS_ORIGIN === '*' || (!CORS_ORIGIN && NODE_ENV !== 'production');
@@ -120,6 +230,9 @@ export function setupWebSocketServer(server, terminals) {
                 // Socket might already be closed
             }
         });
+        socket.on('pong', () => {
+            heartbeatState.set(socket, true);
+        });
         // Check connection limit per IP
         if (!trackConnection(clientIP, socket)) {
             logSecurityEvent('WS_CONNECTION_LIMIT_EXCEEDED', { ip: clientIP });
@@ -146,67 +259,111 @@ export function setupWebSocketServer(server, terminals) {
             socket.close(1000, 'Terminal not found');
             return;
         }
+        const hadNoSockets = session.sockets.size === 0;
         session.sockets.add(socket);
+        if (hadNoSockets && !session.resizeOwner) {
+            session.resizeOwner = socket;
+        }
         session.lastActive = Date.now();
         // Send buffer content if available
-        // bufferOffset: absolute character count the client already received
-        // bufferBase: absolute position of buffer[0] (chars dropped from start)
+        // bufferOffset: absolute byte count the client already processed
+        // bufferBase: absolute byte position of buffer[0] (bytes dropped from start)
         const offsetParam = url.searchParams.get('bufferOffset');
         const clientOffset = offsetParam ? Math.max(0, parseInt(offsetParam, 10) || 0) : 0;
-        if (session.buffer) {
+        const bufferStart = session.bufferBase;
+        const bufferEnd = session.bufferBase + session.bufferLength;
+        let replayStartOffset = clientOffset;
+        let resetTerminal = false;
+        if (clientOffset <= bufferStart) {
+            replayStartOffset = bufferStart;
+            resetTerminal = session.bufferLength > 0;
+        }
+        else if (clientOffset >= bufferEnd) {
+            replayStartOffset = bufferEnd;
+        }
+        if (!sendControl(socket, { type: 'sync', offsetBase: replayStartOffset, reset: resetTerminal })) {
+            return;
+        }
+        if (session.bufferLength > 0) {
             try {
-                const bufferStart = session.bufferBase;
-                const bufferEnd = session.bufferBase + session.buffer.length;
-                let bufferToSend;
+                let bufferToSend = Buffer.alloc(0);
                 if (clientOffset <= bufferStart) {
                     // Client's last position is before (or at) what we have — send everything
-                    bufferToSend = session.buffer;
+                    bufferToSend = readBufferedRange(session, bufferStart, bufferEnd);
                 }
                 else if (clientOffset >= bufferEnd) {
                     // Client is fully up to date
-                    bufferToSend = '';
+                    bufferToSend = Buffer.alloc(0);
                 }
                 else {
                     // Send only the delta
-                    bufferToSend = session.buffer.slice(clientOffset - bufferStart);
+                    bufferToSend = readBufferedRange(session, clientOffset, bufferEnd);
                 }
-                if (bufferToSend) {
-                    socket.send(bufferToSend);
+                if (bufferToSend.length > 0 && canSendToSocket(socket)) {
+                    socket.send(bufferToSend, { binary: true });
                 }
             }
             catch (error) {
                 console.error(`Failed to send buffer to socket ${socketId}:`, error);
             }
         }
-        socket.on('message', (data) => {
+        sendControl(socket, { type: 'ready' });
+        socket.on('message', (data, isBinary) => {
             try {
-                // Convert to string
-                const message = data.toString('utf8');
-                // Check message size
-                const messageSize = Buffer.byteLength(message, 'utf8');
+                const messageSize = rawDataByteLength(data);
                 if (messageSize > MAX_MESSAGE_SIZE) {
                     logSecurityEvent('WS_MESSAGE_TOO_LARGE', { ip: clientIP, size: messageSize });
-                    socket.send('\r\n\x1b[31mMessage too large. Maximum size is 64KB.\x1b[0m\r\n');
+                    socket.close(1009, 'Message too large');
                     return;
                 }
                 session.lastActive = Date.now();
-                // Check for resize message
-                if (message.startsWith('\u0000resize:')) {
-                    const payload = message.slice('\u0000resize:'.length);
-                    const [colsRaw, rowsRaw] = payload.split(',');
-                    const cols = validateTerminalSize(Number(colsRaw));
-                    const rows = validateTerminalSize(Number(rowsRaw));
+                // Text frames carry JSON control messages (claim, resize).
+                // Note: the ws library delivers text frames as Buffer by default,
+                // so we use the isBinary flag rather than typeof === 'string'.
+                if (!isBinary) {
+                    const text = typeof data === 'string'
+                        ? data
+                        : Array.isArray(data)
+                            ? Buffer.concat(data).toString('utf8')
+                            : Buffer.from(data).toString('utf8');
+                    let control = null;
                     try {
-                        session.resize(cols, rows);
+                        control = JSON.parse(text);
+                    }
+                    catch {
+                        control = null;
                     }
-                    catch (resizeError) {
-                        console.error(`Failed to resize terminal ${id}:`, resizeError);
+                    if (control?.type === 'claim') {
+                        session.resizeOwner = socket;
+                        return;
+                    }
+                    if (control?.type === 'resize') {
+                        if (session.resizeOwner && session.resizeOwner !== socket) {
+                            return;
+                        }
+                        session.resizeOwner = socket;
+                        const cols = validateTerminalSize(control.cols);
+                        const rows = validateTerminalSize(control.rows);
+                        try {
+                            session.resize(cols, rows);
+                        }
+                        catch (resizeError) {
+                            console.error(`Failed to resize terminal ${id}:`, resizeError);
+                        }
+                        return;
+                    }
+                    // Unknown text frame — still forward to terminal for compatibility
+                    try {
+                        session.write(Buffer.from(text, 'utf8'));
+                    }
+                    catch (writeError) {
+                        console.error(`Failed to write text input to terminal ${id}:`, writeError);
                     }
                     return;
                 }
+                // Binary frames carry terminal input (keystrokes, paste, etc.)
                 try {
-                    // Write user input to terminal
-                    session.write(message);
+                    session.write(rawDataToBuffer(data));
                 }
                 catch (writeError) {
                     console.error(`Failed to write to terminal ${id}:`, writeError);
@@ -218,12 +375,19 @@ export function setupWebSocketServer(server, terminals) {
         });
         socket.on('close', () => {
             session.sockets.delete(socket);
+            if (session.resizeOwner === socket) {
+                session.resizeOwner = null;
+            }
             session.lastActive = Date.now();
+            heartbeatState.delete(socket);
             untrackConnection(clientIP, socket);
         });
     });
     wss.on('error', (error) => {
         console.error('WebSocket server error:', error);
     });
+    wss.on('close', () => {
+        clearInterval(heartbeatInterval);
+    });
     return wss;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deckide",
-  "version": "3.5.15",
+  "version": "3.5.17",
   "description": "Deck IDE - Browser-based IDE with terminal, file explorer, and git integration",
   "type": "module",
   "bin": {