deckide 3.5.8 → 3.5.10

package/dist/routes/terminals.js

@@ -4,7 +4,7 @@ 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 { saveTerminal, deleteTerminal as deleteTerminalFromDb, updateTerminalBuffer, loadTerminals } from '../utils/database.js';
 // Track terminal index per deck for unique naming
 const deckTerminalCounters = new Map();
 export function createTerminalRouter(db, decks, terminals) {
@@ -143,6 +143,106 @@ export function createTerminalRouter(db, decks, terminals) {
         terminals.set(id, session);
         return session;
     }
+    // Restore persisted terminals from database (re-spawn PTY processes)
+    function restoreTerminals() {
+        const saved = loadTerminals(db);
+        for (const row of saved) {
+            if (!decks.has(row.deckId)) {
+                // Deck no longer exists, clean up
+                deleteTerminalFromDb(db, row.id);
+                continue;
+            }
+            const deck = decks.get(row.deckId);
+            let shell;
+            let shellArgs = [];
+            if (row.command) {
+                shell = getDefaultShell();
+                if (process.platform === 'win32') {
+                    if (shell.toLowerCase().includes('powershell')) {
+                        shellArgs = ['-NoExit', '-Command', row.command];
+                    }
+                    else {
+                        shellArgs = ['/K', row.command];
+                    }
+                }
+                else {
+                    shellArgs = ['-c', row.command];
+                }
+            }
+            else {
+                shell = getDefaultShell();
+            }
+            const env = {};
+            for (const [key, value] of Object.entries(process.env)) {
+                if (value !== undefined)
+                    env[key] = value;
+            }
+            env.TERM = env.TERM || 'xterm-256color';
+            env.COLORTERM = 'truecolor';
+            env.TERM_PROGRAM = 'xterm.js';
+            env.TERM_PROGRAM_VERSION = '5.0.0';
+            env.LANG = env.LANG || 'en_US.UTF-8';
+            env.LC_ALL = env.LC_ALL || 'en_US.UTF-8';
+            env.LC_CTYPE = env.LC_CTYPE || 'en_US.UTF-8';
+            try {
+                const isWindows = process.platform === 'win32';
+                const term = spawn(shell, shellArgs, {
+                    cwd: deck.root,
+                    cols: 120,
+                    rows: 32,
+                    env,
+                    encoding: 'utf8',
+                    ...(isWindows ? { useConpty: true } : {}),
+                });
+                const session = {
+                    id: row.id,
+                    deckId: row.deckId,
+                    title: row.title,
+                    command: row.command,
+                    createdAt: row.createdAt,
+                    sockets: new Set(),
+                    buffer: row.buffer,
+                    lastActive: Date.now(),
+                    write: (data) => { try {
+                        term.write(data);
+                    }
+                    catch { /* terminal may be dying */ } },
+                    resize: (cols, rows) => { try {
+                        term.resize(cols, rows);
+                    }
+                    catch { /* terminal may be dying */ } },
+                    kill: () => { try {
+                        term.kill();
+                    }
+                    catch { /* already dead */ } },
+                };
+                term.onData((data) => {
+                    appendToTerminalBuffer(session, data);
+                    session.lastActive = Date.now();
+                    broadcastToSockets(session, data);
+                });
+                term.onExit(() => {
+                    handleTerminalExit(row.id);
+                });
+                terminals.set(row.id, session);
+                console.log(`[TERMINAL] Restored terminal ${row.id}: shell=${shell}, cwd=${deck.root}, pid=${term.pid}`);
+            }
+            catch (error) {
+                console.error(`[TERMINAL] Failed to restore terminal ${row.id}:`, error);
+                deleteTerminalFromDb(db, row.id);
+            }
+        }
+    }
+    restoreTerminals();
+    // Periodically save terminal buffers to database
+    const bufferSaveInterval = setInterval(() => {
+        terminals.forEach((session) => {
+            try {
+                updateTerminalBuffer(db, session.id, session.buffer);
+            }
+            catch { /* ignore */ }
+        });
+    }, 10_000); // Every 10 seconds
     router.get('/', (c) => {
         const deckId = c.req.query('deckId');
         if (!deckId) {

package/dist/server.js

@@ -11,7 +11,7 @@ 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, } from './utils/database.js';
+import { checkDatabaseIntegrity, handleDatabaseCorruption, initializeDatabase, loadPersistedState, updateTerminalBuffer, } from './utils/database.js';
 import { createWorkspaceRouter, getConfigHandler } from './routes/workspaces.js';
 import { createDeckRouter } from './routes/decks.js';
 import { createFileRouter } from './routes/files.js';
@@ -118,8 +118,12 @@ export async function createServer() {
         if (shutdownPromise)
             return shutdownPromise;
         shutdownPromise = (async () => {
-            // Kill all terminals
+            // Save terminal buffers and kill all terminals
             terminals.forEach((session) => {
+                try {
+                    updateTerminalBuffer(db, session.id, session.buffer);
+                }
+                catch { /* ignore */ }
                 session.sockets.forEach((socket) => {
                     try {
                         socket.close(1000, 'Server shutting down');

package/dist/utils/database.js

@@ -103,8 +103,23 @@ export function loadPersistedState(db, workspaces, workspacePathIndex, decks) {
     });
 }
 export function saveTerminal(db, id, deckId, title, command, createdAt) {
-    const stmt = db.prepare('INSERT OR REPLACE INTO terminals (id, deck_id, title, command, created_at) VALUES (?, ?, ?, ?, ?)');
-    stmt.run(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 = ?');

package/dist/websocket.js

@@ -1,6 +1,6 @@
 import crypto from 'node:crypto';
 import { WebSocketServer } from 'ws';
-import { PORT, TRUST_PROXY, CORS_ORIGIN } from './config.js';
+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;
@@ -99,8 +99,10 @@ export function setupWebSocketServer(server, terminals) {
         const socketId = crypto.randomUUID();
         const clientIP = getClientIP(req);
         // 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');
         const origin = req.headers['origin'];
-        if (origin && CORS_ORIGIN !== '*' && !WS_ALLOWED_ORIGINS.has(origin)) {
+        if (origin && !skipOriginCheck && !WS_ALLOWED_ORIGINS.has(origin)) {
             logSecurityEvent('WS_INVALID_ORIGIN', { ip: clientIP, origin });
             socket.close(1008, 'Invalid origin');
             return;

package/package.json

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