deckide 3.4.0 → 3.5.1

package/bin/deckide.js

@@ -32,8 +32,7 @@ function getPort() {
   return loadSettings().port || 8787;
 }
 
-function isServerRunning() {
-  const port = getPort();
+function isServerRunningOnPort(port) {
   try {
     execSync(`curl -sf -o /dev/null http://localhost:${port}/health`, {
       timeout: 2000, stdio: 'ignore',
@@ -44,6 +43,58 @@ function isServerRunning() {
   }
 }
 
+function isServerRunning() {
+  return isServerRunningOnPort(getPort());
+}
+
+/** Get PID from pid file, or null if stale/missing */
+function getRunningPid() {
+  if (!fs.existsSync(pidFile)) return null;
+  try {
+    const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
+    process.kill(pid, 0); // throws if not running
+    return pid;
+  } catch {
+    try { fs.unlinkSync(pidFile); } catch {}
+    return null;
+  }
+}
+
+/** Stop server: try HTTP shutdown on common ports, then fall back to killing the PID */
+function stopServer() {
+  const port = getPort();
+  // Try HTTP shutdown on configured port
+  if (isServerRunningOnPort(port)) {
+    try {
+      execSync(`curl -sf -X POST http://localhost:${port}/api/shutdown -H "Content-Type: application/json" -d '{}'`, {
+        timeout: 5000, stdio: 'ignore',
+      });
+      try { fs.unlinkSync(pidFile); } catch {}
+      return true;
+    } catch {}
+  }
+  // Try default port 8787 if different
+  if (port !== 8787 && isServerRunningOnPort(8787)) {
+    try {
+      execSync(`curl -sf -X POST http://localhost:8787/api/shutdown -H "Content-Type: application/json" -d '{}'`, {
+        timeout: 5000, stdio: 'ignore',
+      });
+      try { fs.unlinkSync(pidFile); } catch {}
+      return true;
+    } catch {}
+  }
+  // Fall back to killing by PID
+  const pid = getRunningPid();
+  if (pid) {
+    try {
+      process.kill(pid, 'SIGTERM');
+      try { fs.unlinkSync(pidFile); } catch {}
+      return true;
+    } catch {}
+  }
+  return false;
+}
+
 // ─── CLI ────────────────────────────────────────────────────────
 
 const args = process.argv.slice(2);
@@ -68,23 +119,23 @@ Usage:
   deckide status                 Show server status
   deckide logs                   Show server logs
 
-  deckide config                 Show all settings
-  deckide config set <key> <val> Set a config value
-  deckide config get <key>       Get a config value
-  deckide config reset           Reset all settings
+  deckide port                   Show current port
+  deckide port <number>          Change port (auto-restarts)
 
   deckide auth on [user] [pass]  Enable basic auth
   deckide auth off               Disable basic auth
   deckide auth status            Show auth status
 
+  deckide config                 Show all settings
+  deckide config set <key> <val> Set a config value
+  deckide config get <key>       Get a config value
+  deckide config reset           Reset all settings
+
 Options (for start):
   -p, --port <port>              Port (default: 8787)
   --host <host>                  Host (default: 0.0.0.0)
   --no-open                      Don't open browser
   --fg                           Run in foreground
-
-Config keys:
-  port, host, cors, maxFileSize, trustProxy
 `);
   process.exit(0);
 }
@@ -131,6 +182,7 @@ if (command === 'config') {
     settings[key] = value;
     saveSettings(settings);
     console.log(`${key} = ${key === 'basicAuthPassword' ? '********' : value}`);
+    if (isServerRunning() || getRunningPid()) console.log('Run "deckide restart" to apply.');
     process.exit(0);
   }
 
@@ -144,6 +196,49 @@ if (command === 'config') {
   process.exit(1);
 }
 
+// ── deckide port ──
+if (command === 'port') {
+  const newPort = args[1];
+  const settings = loadSettings();
+  const currentPort = settings.port || 8787;
+
+  // Show current port
+  if (!newPort) {
+    console.log(`port: ${currentPort}`);
+    process.exit(0);
+  }
+
+  const parsed = parseInt(newPort, 10);
+  if (!Number.isFinite(parsed) || parsed < 1 || parsed > 65535) {
+    console.error('Error: port must be 1-65535');
+    process.exit(1);
+  }
+
+  if (parsed === currentPort) {
+    console.log(`Already using port ${parsed}`);
+    process.exit(0);
+  }
+
+  // Save new port
+  settings.port = parsed;
+  saveSettings(settings);
+  console.log(`port: ${currentPort} → ${parsed}`);
+
+  // Auto-restart if server is running
+  const wasRunning = isServerRunningOnPort(currentPort) || getRunningPid();
+  if (wasRunning) {
+    stopServer();
+    await new Promise(r => setTimeout(r, 1000));
+    // Re-exec as start (background, no open)
+    const child = spawn(process.execPath, [fileURLToPath(import.meta.url), 'start', '--no-open'], {
+      stdio: 'inherit',
+    });
+    child.on('exit', (code) => process.exit(code));
+  } else {
+    process.exit(0);
+  }
+}
+
 // ── deckide auth ──
 if (command === 'auth') {
   const sub = args[1];
@@ -211,31 +306,16 @@ if (command === 'status') {
   console.log(`  port:   ${port}`);
   console.log(`  auth:   ${settings.basicAuthEnabled ? 'enabled' : 'disabled'}`);
 
+  const pid = getRunningPid();
   if (isServerRunning()) {
     console.log(`  server: \x1b[32mrunning\x1b[0m → http://localhost:${port}`);
+    if (pid) console.log(`  pid:    ${pid}`);
+  } else if (pid) {
+    console.log(`  server: \x1b[33mprocess alive (pid ${pid}) but not responding on port ${port}\x1b[0m`);
   } else {
     console.log('  server: \x1b[31mstopped\x1b[0m');
   }
 
-  // Check PID file
-  if (fs.existsSync(pidFile)) {
-    try {
-      const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
-      process.kill(pid, 0); // Check if process exists
-      console.log(`  pid:    ${pid}`);
-    } catch {
-      // stale pid file
-    }
-  }
-
-  const daemonInfoPath = path.join(dataDir, 'pty-daemon.json');
-  if (fs.existsSync(daemonInfoPath)) {
-    try {
-      const info = JSON.parse(fs.readFileSync(daemonInfoPath, 'utf-8'));
-      console.log(`  pty:    pid ${info.pid}, port ${info.port}`);
-    } catch {}
-  }
-
   process.exit(0);
 }
 
@@ -260,19 +340,14 @@ if (command === 'logs') {
 
 // ── deckide stop ──
 if (command === 'stop') {
-  if (!isServerRunning()) {
+  const pid = getRunningPid();
+  if (!isServerRunning() && !pid) {
     console.log('Server is not running.');
     process.exit(0);
   }
-  const port = getPort();
-  try {
-    execSync(`curl -sf -X POST http://localhost:${port}/api/shutdown -H "Content-Type: application/json" -d '{"terminateDaemon":true}'`, {
-      timeout: 5000, stdio: 'ignore',
-    });
-    // Clean up pid file
-    try { fs.unlinkSync(pidFile); } catch {}
+  if (stopServer()) {
     console.log('Server stopped.');
-  } catch {
+  } else {
     console.error('Failed to stop server.');
   }
   process.exit(0);
@@ -280,15 +355,10 @@ if (command === 'stop') {
 
 // ── deckide restart ──
 if (command === 'restart') {
-  if (isServerRunning()) {
-    const port = getPort();
-    try {
-      execSync(`curl -sf -X POST http://localhost:${port}/api/shutdown -H "Content-Type: application/json" -d '{"terminateDaemon":true}'`, {
-        timeout: 5000, stdio: 'ignore',
-      });
-      try { fs.unlinkSync(pidFile); } catch {}
+  if (isServerRunning() || getRunningPid()) {
+    if (stopServer()) {
       console.log('Server stopped.');
-    } catch {}
+    }
     // Wait a moment for port to free
     await new Promise(r => setTimeout(r, 1000));
   }
@@ -332,12 +402,20 @@ const settings = loadSettings();
 const port = startOptions.port || settings.port || 8787;
 const host = startOptions.host || settings.host || '0.0.0.0';
 
-// Check if already running
-if (isServerRunning()) {
+// Check if already running on the target port
+if (isServerRunningOnPort(port)) {
   console.log(`Server is already running on http://localhost:${port}`);
   process.exit(0);
 }
 
+// Kill old server if running on a different port
+const oldPid = getRunningPid();
+if (oldPid) {
+  console.log('Stopping old server...');
+  stopServer();
+  await new Promise(r => setTimeout(r, 1000));
+}
+
 // ── Background mode (default) ──
 if (!startOptions.fg) {
   fs.mkdirSync(dataDir, { recursive: true });

package/dist/config.js

@@ -68,5 +68,3 @@ if (!Number.isFinite(MAX_FILE_SIZE) || MAX_FILE_SIZE < 1024) {
 }
 // Ensure data directory exists
 fsSync.mkdirSync(path.dirname(dbPath), { recursive: true });
-// PTY daemon info file - written by daemon on startup so server can find its port
-export const daemonInfoPath = path.join(path.dirname(dbPath), 'pty-daemon.json');

package/dist/middleware/cors.js

@@ -17,7 +17,7 @@ export const corsMiddleware = async (c, next) => {
             c.header('Access-Control-Allow-Origin', `http://localhost:${PORT}`);
         }
     }
-    c.header('Access-Control-Allow-Methods', 'GET,POST,PUT,OPTIONS');
+    c.header('Access-Control-Allow-Methods', 'GET,POST,PUT,DELETE,OPTIONS');
     c.header('Access-Control-Allow-Headers', 'Content-Type,Authorization');
     if (c.req.method === 'OPTIONS') {
         return c.body(null, 204);

package/dist/routes/terminals.js

@@ -1,12 +1,13 @@
 import crypto from 'node:crypto';
 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';
 // Track terminal index per deck for unique naming
 const deckTerminalCounters = new Map();
-export function createTerminalRouter(db, decks, terminals, ptyClient) {
+export function createTerminalRouter(db, decks, terminals) {
     const router = new Hono();
     function appendToTerminalBuffer(session, data) {
         const newBuffer = session.buffer + data;
@@ -21,13 +22,7 @@ export function createTerminalRouter(db, decks, terminals, ptyClient) {
         deckTerminalCounters.set(deckId, next);
         return next;
     }
-    // Central data handler: daemon streams output → update buffer → forward to WebSockets
-    ptyClient.on('data', (id, data) => {
-        const session = terminals.get(id);
-        if (!session)
-            return;
-        appendToTerminalBuffer(session, data);
-        session.lastActive = Date.now();
+    function broadcastToSockets(session, data) {
         const deadSockets = new Set();
         session.sockets.forEach((socket) => {
             try {
@@ -43,9 +38,8 @@ export function createTerminalRouter(db, decks, terminals, ptyClient) {
             }
         });
         deadSockets.forEach((s) => session.sockets.delete(s));
-    });
-    // Central exit handler: PTY exited → close WebSockets, remove from map and DB
-    ptyClient.on('exit', (id) => {
+    }
+    function handleTerminalExit(id) {
         const session = terminals.get(id);
         if (!session)
             return;
@@ -59,9 +53,9 @@ export function createTerminalRouter(db, decks, terminals, ptyClient) {
             catch { /* ignore */ }
         });
         session.sockets.clear();
-    });
-    async function createTerminalSession(deck, title, command, options) {
-        const id = options?.id || crypto.randomUUID();
+    }
+    function createTerminalSession(deck, title, command) {
+        const id = crypto.randomUUID();
         // Resolve shell and arguments
         let shell;
         let shellArgs = [];
@@ -101,9 +95,17 @@ export function createTerminalRouter(db, decks, terminals, ptyClient) {
         }
         env.LC_ALL = env.LC_ALL || 'en_US.UTF-8';
         env.LC_CTYPE = env.LC_CTYPE || 'en_US.UTF-8';
-        // Create PTY in the daemon
-        await ptyClient.create({ id, shell, shellArgs, cwd: deck.root, env, cols: 120, rows: 32 });
-        console.log(`[TERMINAL] Created terminal ${id} in daemon: shell=${shell}, cwd=${deck.root}`);
+        // Spawn PTY directly in this process
+        const isWindows = process.platform === 'win32';
+        const term = spawn(shell, shellArgs, {
+            cwd: deck.root,
+            cols: 120,
+            rows: 32,
+            env,
+            encoding: 'utf8',
+            ...(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 createdAt = new Date().toISOString();
         const session = {
@@ -113,18 +115,32 @@ export function createTerminalRouter(db, decks, terminals, ptyClient) {
             command: command || null,
             createdAt,
             sockets: new Set(),
-            buffer: options?.initialBuffer || '',
+            buffer: '',
             lastActive: Date.now(),
-            write: (data) => ptyClient.input(id, data),
-            resize: (cols, rows) => ptyClient.resize(id, cols, rows),
-            kill: () => ptyClient.kill(id),
+            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 */ } },
         };
-        if (!options?.skipDbSave) {
-            saveTerminal(db, id, deck.id, resolvedTitle, command || null, createdAt);
-        }
+        // Wire up PTY output → buffer + WebSocket broadcast
+        term.onData((data) => {
+            appendToTerminalBuffer(session, data);
+            session.lastActive = Date.now();
+            broadcastToSockets(session, data);
+        });
+        term.onExit(() => {
+            handleTerminalExit(id);
+        });
+        saveTerminal(db, id, deck.id, resolvedTitle, command || null, createdAt);
         terminals.set(id, session);
-        // Subscribe to live output from daemon (delta since initialBuffer)
-        ptyClient.attach(id, options?.initialBuffer?.length ?? 0);
         return session;
     }
     router.get('/', (c) => {
@@ -150,7 +166,7 @@ export function createTerminalRouter(db, decks, terminals, ptyClient) {
             const deck = decks.get(deckId);
             if (!deck)
                 throw createHttpError('Deck not found', 404);
-            const session = await createTerminalSession(deck, body?.title, body?.command);
+            const session = createTerminalSession(deck, body?.title, body?.command);
             return c.json({ id: session.id, title: session.title }, 201);
         }
         catch (error) {
@@ -172,7 +188,6 @@ export function createTerminalRouter(db, decks, terminals, ptyClient) {
                 catch { /* ignore */ }
             });
             session.sockets.clear();
-            // Kill PTY in daemon
             session.kill();
             return c.body(null, 204);
         }
@@ -180,60 +195,5 @@ export function createTerminalRouter(db, decks, terminals, ptyClient) {
             return handleError(c, error);
         }
     });
-    /**
-     * Restore terminals after a server restart.
-     * The daemon is the source of truth: only terminals alive in the daemon are restored.
-     * DB provides metadata (title, deckId, buffer) for each daemon terminal.
-     * Stale DB entries (no matching daemon terminal) are cleaned up.
-     */
-    async function restoreTerminals(persistedTerminals, daemonTerminals) {
-        const persistedById = new Map(persistedTerminals.map((t) => [t.id, t]));
-        const daemonIds = new Set(daemonTerminals.map((t) => t.id));
-        // Iterate daemon terminals — these are the only "real" ones
-        for (const daemonInfo of daemonTerminals) {
-            const persisted = persistedById.get(daemonInfo.id);
-            const deck = persisted ? decks.get(persisted.deckId) : undefined;
-            if (!persisted || !deck) {
-                // No metadata to attach this terminal to a deck — kill it
-                console.log(`[TERMINAL] Killing daemon terminal ${daemonInfo.id} (no deck metadata)`);
-                try {
-                    await ptyClient.kill(daemonInfo.id);
-                }
-                catch { /* ignore */ }
-                if (persisted)
-                    deleteTerminalFromDb(db, daemonInfo.id);
-                continue;
-            }
-            try {
-                console.log(`[TERMINAL] Re-attaching to live terminal ${persisted.id} (${persisted.title})`);
-                const session = {
-                    id: persisted.id,
-                    deckId: persisted.deckId,
-                    title: persisted.title,
-                    command: persisted.command,
-                    createdAt: persisted.createdAt,
-                    sockets: new Set(),
-                    buffer: '',
-                    lastActive: Date.now(),
-                    write: (data) => ptyClient.input(persisted.id, data),
-                    resize: (cols, rows) => ptyClient.resize(persisted.id, cols, rows),
-                    kill: () => ptyClient.kill(persisted.id),
-                };
-                terminals.set(persisted.id, session);
-                // Attach with offset 0 to get the full buffer from daemon
-                ptyClient.attach(persisted.id, 0);
-            }
-            catch (err) {
-                console.error(`[TERMINAL] Failed to restore terminal ${daemonInfo.id}:`, err);
-            }
-        }
-        // Clean up DB entries for terminals no longer alive in the daemon
-        for (const persisted of persistedTerminals) {
-            if (!daemonIds.has(persisted.id)) {
-                console.log(`[TERMINAL] Removing stale terminal ${persisted.id} from DB`);
-                deleteTerminalFromDb(db, persisted.id);
-            }
-        }
-    }
-    return { router, restoreTerminals };
+    return router;
 }

package/dist/server.js

@@ -2,17 +2,16 @@ import fsSync from 'node:fs';
 import crypto from 'node:crypto';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import childProcess from 'node:child_process';
 import { Hono } from 'hono';
 import { serve } from '@hono/node-server';
 import { serveStatic } from '@hono/node-server/serve-static';
 import { bodyLimit } from 'hono/body-limit';
 import { DatabaseSync } from 'node:sqlite';
-import { PORT, HOST, NODE_ENV, BASIC_AUTH_USER, BASIC_AUTH_PASSWORD, CORS_ORIGIN, MAX_FILE_SIZE, MAX_REQUEST_BODY_SIZE, TRUST_PROXY, TERMINAL_BUFFER_LIMIT, hasStatic, distDir, dbPath, daemonInfoPath, } from './config.js';
+import { PORT, HOST, NODE_ENV, BASIC_AUTH_USER, BASIC_AUTH_PASSWORD, CORS_ORIGIN, MAX_FILE_SIZE, MAX_REQUEST_BODY_SIZE, TRUST_PROXY, hasStatic, distDir, dbPath, } from './config.js';
 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, loadPersistedTerminals, } 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';
@@ -20,7 +19,6 @@ import { createTerminalRouter } from './routes/terminals.js';
 import { createGitRouter } from './routes/git.js';
 import { createSettingsRouter } from './routes/settings.js';
 import { setupWebSocketServer, getConnectionLimit, setConnectionLimit, getConnectionStats, clearAllConnections, } from './websocket.js';
-import { PtyClient } from './pty-client.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // Request ID and logging middleware
 const requestIdMiddleware = async (c, next) => {
@@ -37,59 +35,6 @@ const requestIdMiddleware = async (c, next) => {
         console.log(`[${requestId}] ${method} ${path_} ${status} ${duration}ms`);
     }
 };
-/** Wait for the daemon to write its info file after startup. */
-async function waitForDaemonInfo(maxWaitMs = 8000) {
-    const start = Date.now();
-    while (Date.now() - start < maxWaitMs) {
-        if (fsSync.existsSync(daemonInfoPath)) {
-            try {
-                return JSON.parse(fsSync.readFileSync(daemonInfoPath, 'utf-8'));
-            }
-            catch {
-                // File may be partially written, retry
-            }
-        }
-        await new Promise((r) => setTimeout(r, 100));
-    }
-    throw new Error('PTY daemon did not start within 8 seconds');
-}
-/** Connect to an existing daemon or spawn a new one. Returns a connected PtyClient. */
-async function ensureDaemon() {
-    const client = new PtyClient();
-    // Try connecting to an existing daemon
-    if (fsSync.existsSync(daemonInfoPath)) {
-        try {
-            const info = JSON.parse(fsSync.readFileSync(daemonInfoPath, 'utf-8'));
-            await client.connect(info.port);
-            console.log(`[SERVER] Connected to existing PTY daemon on port ${info.port} (pid ${info.pid})`);
-            return client;
-        }
-        catch {
-            console.log('[SERVER] Existing PTY daemon is gone, starting a new one...');
-            try {
-                fsSync.unlinkSync(daemonInfoPath);
-            }
-            catch { /* ignore */ }
-        }
-    }
-    // Spawn a new daemon process (detached so it survives server restarts)
-    const daemonScript = path.join(__dirname, 'pty-daemon.js');
-    const child = childProcess.spawn(process.execPath, [daemonScript], {
-        detached: true,
-        stdio: 'ignore',
-        windowsHide: true,
-        env: {
-            ...process.env,
-            DAEMON_INFO_PATH: daemonInfoPath,
-            TERMINAL_BUFFER_LIMIT: String(TERMINAL_BUFFER_LIMIT),
-        },
-    });
-    child.unref(); // Don't keep this process alive
-    const info = await waitForDaemonInfo();
-    await client.connect(info.port);
-    console.log(`[SERVER] Started PTY daemon on port ${info.port} (pid ${info.pid})`);
-    return client;
-}
 export async function createServer() {
     // Check database integrity before opening
     if (fsSync.existsSync(dbPath) && !checkDatabaseIntegrity(dbPath)) {
@@ -103,8 +48,6 @@ export async function createServer() {
     const decks = new Map();
     const terminals = new Map();
     loadPersistedState(db, workspaces, workspacePathIndex, decks);
-    // Start or reconnect to the PTY daemon
-    const ptyClient = await ensureDaemon();
     // Create Hono app
     const app = new Hono();
     app.use('*', securityHeaders);
@@ -122,17 +65,9 @@ export async function createServer() {
     app.route('/api/settings', createSettingsRouter());
     app.route('/api/workspaces', createWorkspaceRouter(db, workspaces, workspacePathIndex));
     app.route('/api/decks', createDeckRouter(db, workspaces, decks));
-    const { router: terminalRouter, restoreTerminals } = createTerminalRouter(db, decks, terminals, ptyClient);
+    const terminalRouter = createTerminalRouter(db, decks, terminals);
     app.route('/api/terminals', terminalRouter);
     app.route('/api/git', createGitRouter(workspaces));
-    // Restore terminals: daemon is the source of truth for existence, DB provides metadata
-    const daemonTerminals = await ptyClient.list();
-    const persistedTerminals = loadPersistedTerminals(db, decks);
-    if (daemonTerminals.length > 0 || persistedTerminals.length > 0) {
-        console.log(`[TERMINAL] Restoring ${daemonTerminals.length} live terminal(s) ` +
-            `(${persistedTerminals.length} DB entries)...`);
-        await restoreTerminals(persistedTerminals, daemonTerminals);
-    }
     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() }));
@@ -177,29 +112,23 @@ export async function createServer() {
         console.log(`  - CORS Origin: ${CORS_ORIGIN || (NODE_ENV === 'development' ? '*' : 'NOT SET')}`);
         console.log(`  - Environment: ${NODE_ENV}`);
     });
-    // Graceful shutdown - optionally terminate daemon.
+    // Graceful shutdown
     let shutdownPromise = null;
-    let shouldTerminateDaemon = false;
-    const onShutdown = (options = {}) => {
-        if (options.terminateDaemon) {
-            shouldTerminateDaemon = true;
-        }
-        if (shutdownPromise) {
+    const onShutdown = () => {
+        if (shutdownPromise)
             return shutdownPromise;
-        }
         shutdownPromise = (async () => {
-            if (shouldTerminateDaemon) {
-                try {
-                    const stopped = await ptyClient.shutdown();
-                    if (!stopped) {
-                        console.warn('[SHUTDOWN] PTY daemon shutdown was not acknowledged');
+            // Kill all terminals
+            terminals.forEach((session) => {
+                session.sockets.forEach((socket) => {
+                    try {
+                        socket.close(1000, 'Server shutting down');
                     }
-                }
-                catch (err) {
-                    console.warn('[SHUTDOWN] Failed to request PTY daemon shutdown:', err);
-                }
-            }
-            ptyClient.destroy();
+                    catch { /* ignore */ }
+                });
+                session.kill();
+            });
+            terminals.clear();
             try {
                 db.close();
             }
@@ -208,32 +137,24 @@ export async function createServer() {
         return shutdownPromise;
     };
     process.on('SIGINT', () => {
-        console.log('\n[SHUTDOWN] Received SIGINT, saving state...');
-        void onShutdown({ terminateDaemon: true }).finally(() => process.exit(0));
+        console.log('\n[SHUTDOWN] Received SIGINT...');
+        void onShutdown().finally(() => process.exit(0));
     });
     process.on('SIGTERM', () => {
-        console.log('[SHUTDOWN] Received SIGTERM, saving state...');
-        void onShutdown({ terminateDaemon: true }).finally(() => process.exit(0));
+        console.log('[SHUTDOWN] Received SIGTERM...');
+        void onShutdown().finally(() => process.exit(0));
     });
     process.on('SIGHUP', () => {
-        console.log('[SHUTDOWN] Received SIGHUP, saving state...');
-        void onShutdown({ terminateDaemon: true }).finally(() => process.exit(0));
+        console.log('[SHUTDOWN] Received SIGHUP...');
+        void onShutdown().finally(() => process.exit(0));
     });
-    // HTTP shutdown endpoint — allows cross-platform graceful shutdown from Electron
+    // HTTP shutdown endpoint
     app.post('/api/shutdown', async (c) => {
-        let terminateDaemon = false;
-        try {
-            const body = await c.req.json();
-            terminateDaemon = body?.terminateDaemon === true;
-        }
-        catch {
-            // Body is optional; default is false.
-        }
         setTimeout(() => {
-            console.log(`[SHUTDOWN] Shutdown requested via HTTP API${terminateDaemon ? ' (terminate daemon)' : ''}`);
-            void onShutdown({ terminateDaemon }).finally(() => process.exit(0));
+            console.log('[SHUTDOWN] Shutdown requested via HTTP API');
+            void onShutdown().finally(() => process.exit(0));
         }, 50);
-        return c.json({ ok: true, terminateDaemon });
+        return c.json({ ok: true });
     });
     const originalExceptionHandler = process.listeners('uncaughtException')[0];
     process.removeAllListeners('uncaughtException');
@@ -242,8 +163,8 @@ export async function createServer() {
             console.log('[node-pty] AttachConsole error suppressed');
             return;
         }
-        console.error('[SHUTDOWN] Uncaught exception, saving state before exit...');
-        void onShutdown({ terminateDaemon: true }).finally(() => {
+        console.error('[SHUTDOWN] Uncaught exception...');
+        void onShutdown().finally(() => {
             if (originalExceptionHandler) {
                 originalExceptionHandler(error);
             }

package/dist/utils/database.js

@@ -102,30 +102,6 @@ export function loadPersistedState(db, workspaces, workspacePathIndex, decks) {
         decks.set(deck.id, deck);
     });
 }
-// Terminal persistence functions
-export function loadPersistedTerminals(db, decks) {
-    const rows = db
-        .prepare('SELECT id, deck_id, title, command, created_at FROM terminals ORDER BY created_at ASC')
-        .all();
-    const terminals = [];
-    rows.forEach((row) => {
-        const deckId = String(row.deck_id);
-        // Only load terminals for existing decks
-        if (!decks.has(deckId)) {
-            // Clean up orphaned terminal
-            db.prepare('DELETE FROM terminals WHERE id = ?').run(String(row.id));
-            return;
-        }
-        terminals.push({
-            id: String(row.id),
-            deckId,
-            title: String(row.title),
-            command: row.command ? String(row.command) : null,
-            createdAt: String(row.created_at)
-        });
-    });
-    return terminals;
-}
 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);

package/package.json

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

package/dist/pty-client.js

@@ -1,177 +0,0 @@
-/**
- * PtyClient - IPC client for the main server to communicate with the PTY daemon.
- * Uses newline-delimited JSON over a local TCP connection.
- */
-import net from 'node:net';
-import { EventEmitter } from 'node:events';
-export class PtyClient extends EventEmitter {
-    socket = null;
-    lineBuf = '';
-    _connected = false;
-    listCallback = null;
-    shutdownCallback = null;
-    createCallbacks = new Map();
-    get connected() {
-        return this._connected;
-    }
-    connect(port) {
-        return new Promise((resolve, reject) => {
-            const socket = net.createConnection(port, '127.0.0.1');
-            socket.once('connect', () => {
-                this.socket = socket;
-                this._connected = true;
-                resolve();
-            });
-            socket.once('error', (err) => {
-                if (!this._connected) {
-                    reject(err);
-                }
-                else {
-                    this.emit('error', err);
-                }
-            });
-            socket.on('data', (chunk) => {
-                this.lineBuf += chunk.toString('utf8');
-                const lines = this.lineBuf.split('\n');
-                this.lineBuf = lines.pop();
-                for (const line of lines) {
-                    if (!line.trim())
-                        continue;
-                    try {
-                        this.handleMessage(JSON.parse(line));
-                    }
-                    catch { /* malformed message, ignore */ }
-                }
-            });
-            socket.on('close', () => {
-                this._connected = false;
-                this.socket = null;
-                if (this.shutdownCallback) {
-                    this.shutdownCallback(false);
-                    this.shutdownCallback = null;
-                }
-                this.emit('disconnect');
-            });
-        });
-    }
-    handleMessage(msg) {
-        switch (msg.type) {
-            case 'data':
-                this.emit('data', msg.id, msg.data);
-                break;
-            case 'exit':
-                this.emit('exit', msg.id, msg.code);
-                break;
-            case 'list_result': {
-                const cb = this.listCallback;
-                this.listCallback = null;
-                cb?.(msg.terminals);
-                break;
-            }
-            case 'shutdown_ack': {
-                const cb = this.shutdownCallback;
-                this.shutdownCallback = null;
-                cb?.(true);
-                break;
-            }
-            case 'created': {
-                const cb = this.createCallbacks.get(msg.id);
-                if (cb) {
-                    this.createCallbacks.delete(msg.id);
-                    cb();
-                }
-                break;
-            }
-            case 'error': {
-                if (msg.id) {
-                    const cb = this.createCallbacks.get(msg.id);
-                    if (cb) {
-                        this.createCallbacks.delete(msg.id);
-                        cb(msg.message);
-                    }
-                }
-                break;
-            }
-        }
-    }
-    send(msg) {
-        if (this.socket && !this.socket.destroyed) {
-            try {
-                this.socket.write(JSON.stringify(msg) + '\n');
-            }
-            catch { /* socket may be closing */ }
-        }
-    }
-    /** Spawn a new PTY in the daemon. Resolves when daemon confirms creation. */
-    create(params) {
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                this.createCallbacks.delete(params.id);
-                reject(new Error(`Timeout creating terminal ${params.id}`));
-            }, 10_000);
-            this.createCallbacks.set(params.id, (err) => {
-                clearTimeout(timer);
-                if (err)
-                    reject(new Error(err));
-                else
-                    resolve();
-            });
-            this.send({ type: 'create', ...params });
-        });
-    }
-    /** Send keyboard input to a terminal. */
-    input(id, data) {
-        this.send({ type: 'input', id, data });
-    }
-    /** Resize a terminal. */
-    resize(id, cols, rows) {
-        this.send({ type: 'resize', id, cols, rows });
-    }
-    /** Kill a terminal and remove it from the daemon. */
-    kill(id) {
-        this.send({ type: 'kill', id });
-    }
-    /**
-     * Subscribe to live data from a terminal.
-     * The daemon will first send any buffered output since `bufferOffset`,
-     * then stream all subsequent output.
-     */
-    attach(id, bufferOffset) {
-        this.send({ type: 'attach', id, bufferOffset });
-    }
-    /** Get a list of all terminals currently alive in the daemon. */
-    list() {
-        return new Promise((resolve) => {
-            const timer = setTimeout(() => {
-                this.listCallback = null;
-                resolve([]);
-            }, 5_000);
-            this.listCallback = (terminals) => {
-                clearTimeout(timer);
-                resolve(terminals);
-            };
-            this.send({ type: 'list' });
-        });
-    }
-    /** Ask the daemon to terminate itself and all child PTYs. */
-    shutdown(timeoutMs = 2_000) {
-        if (!this.connected) {
-            return Promise.resolve(false);
-        }
-        return new Promise((resolve) => {
-            const timer = setTimeout(() => {
-                this.shutdownCallback = null;
-                resolve(false);
-            }, timeoutMs);
-            this.shutdownCallback = (ok) => {
-                clearTimeout(timer);
-                this.shutdownCallback = null;
-                resolve(ok);
-            };
-            this.send({ type: 'shutdown' });
-        });
-    }
-    destroy() {
-        this.socket?.destroy();
-    }
-}

package/dist/pty-daemon.js

@@ -1,246 +0,0 @@
-/**
- * PTY Daemon - standalone process that manages PTY sessions.
- *
- * Spawned as a detached child by the main server so it outlives server restarts.
- * Communicates with the server over a local TCP socket using newline-delimited JSON.
- *
- * Protocol (Server → Daemon):
- *   { type:"create", id, shell, shellArgs, cwd, env, cols, rows }
- *   { type:"input",  id, data }
- *   { type:"resize", id, cols, rows }
- *   { type:"kill",   id }
- *   { type:"attach", id, bufferOffset }  -- start streaming data for this terminal
- *   { type:"list" }                       -- list active terminal IDs
- *   { type:"shutdown" }                   -- terminate daemon and all PTYs
- *
- * Protocol (Daemon → Server):
- *   { type:"created",     id }
- *   { type:"data",        id, data }      -- only for attached terminals
- *   { type:"exit",        id, code }
- *   { type:"list_result", terminals: [{id, bufferLength}] }
- *   { type:"shutdown_ack" }
- *   { type:"error",       id?, message }
- */
-import net from 'node:net';
-import fs from 'node:fs';
-import { spawn } from 'node-pty';
-const DAEMON_INFO_PATH = process.env.DAEMON_INFO_PATH;
-const BUFFER_LIMIT = Number(process.env.TERMINAL_BUFFER_LIMIT || 500000);
-if (!DAEMON_INFO_PATH) {
-    console.error('[pty-daemon] DAEMON_INFO_PATH env var is required');
-    process.exit(1);
-}
-const sessions = new Map();
-// IDs the server is currently subscribed to (receives live data for)
-const attached = new Set();
-let serverSocket = null;
-let shuttingDown = false;
-function appendBuffer(session, data) {
-    const combined = session.buffer + data;
-    session.buffer =
-        combined.length > BUFFER_LIMIT
-            ? combined.slice(combined.length - BUFFER_LIMIT)
-            : combined;
-}
-function sendToServer(msg) {
-    if (serverSocket && !serverSocket.destroyed) {
-        try {
-            serverSocket.write(JSON.stringify(msg) + '\n');
-        }
-        catch {
-            // Socket may have just closed
-        }
-    }
-}
-function handleMessage(msg) {
-    switch (msg.type) {
-        case 'create': {
-            const { id, shell, shellArgs = [], cwd, env, cols = 120, rows = 32 } = msg;
-            if (sessions.has(id)) {
-                // Already exists - just ack
-                sendToServer({ type: 'created', id });
-                return;
-            }
-            try {
-                const isWindows = process.platform === 'win32';
-                const term = spawn(shell, shellArgs, {
-                    cwd,
-                    cols,
-                    rows,
-                    env,
-                    encoding: 'utf8',
-                    ...(isWindows ? { useConpty: true } : {}),
-                });
-                const session = { id, term, buffer: '' };
-                sessions.set(id, session);
-                term.onData((data) => {
-                    appendBuffer(session, data);
-                    if (attached.has(id)) {
-                        sendToServer({ type: 'data', id, data });
-                    }
-                });
-                term.onExit(({ exitCode }) => {
-                    sessions.delete(id);
-                    attached.delete(id);
-                    sendToServer({ type: 'exit', id, code: exitCode });
-                });
-                sendToServer({ type: 'created', id });
-                console.log(`[pty-daemon] Created terminal ${id} (pid=${term.pid})`);
-            }
-            catch (err) {
-                console.error(`[pty-daemon] Failed to create terminal ${id}:`, err);
-                sendToServer({ type: 'error', id, message: String(err) });
-            }
-            break;
-        }
-        case 'input': {
-            const session = sessions.get(msg.id);
-            if (session) {
-                try {
-                    session.term.write(msg.data);
-                }
-                catch { /* terminal may be dying */ }
-            }
-            break;
-        }
-        case 'resize': {
-            const session = sessions.get(msg.id);
-            if (session) {
-                try {
-                    session.term.resize(msg.cols, msg.rows);
-                }
-                catch { /* terminal may be dying */ }
-            }
-            break;
-        }
-        case 'kill': {
-            const session = sessions.get(msg.id);
-            if (session) {
-                sessions.delete(msg.id);
-                attached.delete(msg.id);
-                try {
-                    session.term.kill();
-                }
-                catch { /* already dead */ }
-                console.log(`[pty-daemon] Killed terminal ${msg.id}`);
-            }
-            break;
-        }
-        case 'attach': {
-            const session = sessions.get(msg.id);
-            if (!session) {
-                sendToServer({ type: 'error', id: msg.id, message: 'Terminal not found' });
-                return;
-            }
-            attached.add(msg.id);
-            // Send buffered output the server hasn't seen yet
-            const offset = Number(msg.bufferOffset) || 0;
-            const delta = offset > 0 ? session.buffer.slice(offset) : session.buffer;
-            if (delta) {
-                sendToServer({ type: 'data', id: msg.id, data: delta });
-            }
-            break;
-        }
-        case 'list': {
-            const terminals = Array.from(sessions.entries()).map(([id, s]) => ({
-                id,
-                bufferLength: s.buffer.length,
-            }));
-            sendToServer({ type: 'list_result', terminals });
-            break;
-        }
-        case 'shutdown': {
-            sendToServer({ type: 'shutdown_ack' });
-            // ackを送信しきるため少し待ってから終了
-            setTimeout(() => {
-                shutdown();
-            }, 10);
-            break;
-        }
-        default:
-            console.warn(`[pty-daemon] Unknown message type: ${msg.type}`);
-    }
-}
-// TCP server - accepts one connection from the main server at a time
-const tcpServer = net.createServer((socket) => {
-    // Close previous connection if server reconnects
-    if (serverSocket && !serverSocket.destroyed) {
-        serverSocket.destroy();
-    }
-    serverSocket = socket;
-    attached.clear(); // New connection starts with no subscriptions
-    console.log('[pty-daemon] Main server connected');
-    let lineBuf = '';
-    socket.on('data', (chunk) => {
-        lineBuf += chunk.toString('utf8');
-        const lines = lineBuf.split('\n');
-        lineBuf = lines.pop();
-        for (const line of lines) {
-            if (!line.trim())
-                continue;
-            try {
-                handleMessage(JSON.parse(line));
-            }
-            catch (err) {
-                console.error('[pty-daemon] Failed to parse message:', err);
-            }
-        }
-    });
-    socket.on('close', () => {
-        if (serverSocket === socket) {
-            serverSocket = null;
-            attached.clear();
-            console.log('[pty-daemon] Main server disconnected');
-        }
-    });
-    socket.on('error', (err) => {
-        console.error('[pty-daemon] Socket error:', err.message);
-    });
-});
-tcpServer.on('error', (err) => {
-    console.error('[pty-daemon] TCP server error:', err);
-    process.exit(1);
-});
-// Listen on a random available port, then write info file for the server to find us
-tcpServer.listen(0, '127.0.0.1', () => {
-    const addr = tcpServer.address();
-    const info = { pid: process.pid, port: addr.port };
-    fs.writeFileSync(DAEMON_INFO_PATH, JSON.stringify(info));
-    console.log(`[pty-daemon] Running on port ${addr.port} (pid ${process.pid})`);
-});
-function shutdown() {
-    if (shuttingDown) {
-        return;
-    }
-    shuttingDown = true;
-    console.log('[pty-daemon] Shutting down...');
-    sessions.forEach(({ term }) => {
-        try {
-            term.kill();
-        }
-        catch { /* ignore */ }
-    });
-    sessions.clear();
-    try {
-        serverSocket?.destroy();
-    }
-    catch { /* ignore */ }
-    try {
-        tcpServer.close();
-    }
-    catch { /* ignore */ }
-    try {
-        fs.unlinkSync(DAEMON_INFO_PATH);
-    }
-    catch { /* ignore */ }
-    process.exit(0);
-}
-process.on('SIGTERM', shutdown);
-process.on('SIGINT', shutdown);
-// Keep the daemon alive even on unexpected errors
-process.on('uncaughtException', (err) => {
-    console.error('[pty-daemon] Uncaught exception (continuing):', err);
-});
-process.on('unhandledRejection', (err) => {
-    console.error('[pty-daemon] Unhandled rejection (continuing):', err);
-});