deckide 3.3.1 → 3.5.0

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/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/routes/workspaces.js

@@ -61,6 +61,24 @@ export function createWorkspaceRouter(db, workspaces, workspacePathIndex) {
             return handleError(c, error);
         }
     });
+    const deleteWorkspace = db.prepare('DELETE FROM workspaces WHERE id = ?');
+    router.delete('/:id', (c) => {
+        try {
+            const id = c.req.param('id');
+            const workspace = workspaces.get(id);
+            if (!workspace) {
+                throw createHttpError('Workspace not found', 404);
+            }
+            const key = getWorkspaceKey(workspace.path);
+            deleteWorkspace.run(id);
+            workspaces.delete(id);
+            workspacePathIndex.delete(key);
+            return c.json({ deleted: true });
+        }
+        catch (error) {
+            return handleError(c, error);
+        }
+    });
     return router;
 }
 export function getConfigHandler() {