deckide 3.0.0

package/apps/server/dist/routes/settings.js

@@ -0,0 +1,95 @@
+import { Hono } from 'hono';
+import fs from 'node:fs/promises';
+import { createHttpError, handleError } from '../utils/error.js';
+import { PORT, BASIC_AUTH_USER, BASIC_AUTH_PASSWORD, SETTINGS_FILE } from '../config.js';
+// Load settings from file or return defaults
+async function loadSettings() {
+    try {
+        const data = await fs.readFile(SETTINGS_FILE, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        // Return defaults from environment or hardcoded defaults
+        return {
+            port: PORT,
+            basicAuthEnabled: Boolean(BASIC_AUTH_USER && BASIC_AUTH_PASSWORD),
+            basicAuthUser: BASIC_AUTH_USER || '',
+            basicAuthPassword: BASIC_AUTH_PASSWORD || ''
+        };
+    }
+}
+// Save settings to file
+async function saveSettings(settings) {
+    await fs.writeFile(SETTINGS_FILE, JSON.stringify(settings, null, 2), 'utf-8');
+}
+export function createSettingsRouter() {
+    const router = new Hono();
+    // GET /api/settings - Get current settings
+    router.get('/', async (c) => {
+        try {
+            const settings = await loadSettings();
+            // Don't send password to client if it exists (for security)
+            // Instead, send a flag indicating if password is set
+            return c.json({
+                port: settings.port,
+                basicAuthEnabled: settings.basicAuthEnabled,
+                basicAuthUser: settings.basicAuthUser,
+                basicAuthPassword: settings.basicAuthPassword ? '••••••••••••' : ''
+            });
+        }
+        catch (error) {
+            return handleError(c, error);
+        }
+    });
+    // POST /api/settings - Update settings
+    router.post('/', async (c) => {
+        try {
+            const body = await c.req.json();
+            // Validate settings
+            if (!body.port || body.port < 1024 || body.port > 65535) {
+                throw createHttpError('Port must be between 1024 and 65535', 400);
+            }
+            if (body.basicAuthEnabled) {
+                if (!body.basicAuthUser || !body.basicAuthPassword) {
+                    throw createHttpError('Username and password are required when Basic Auth is enabled', 400);
+                }
+                if (body.basicAuthPassword.length < 12 && body.basicAuthPassword !== '••••••••••••') {
+                    throw createHttpError('Password must be at least 12 characters', 400);
+                }
+            }
+            // Load current settings to preserve password if placeholder is sent
+            const currentSettings = await loadSettings();
+            const newSettings = {
+                port: body.port,
+                basicAuthEnabled: body.basicAuthEnabled,
+                basicAuthUser: body.basicAuthUser,
+                // If password is placeholder, keep current password
+                basicAuthPassword: body.basicAuthPassword === '••••••••••••'
+                    ? currentSettings.basicAuthPassword
+                    : body.basicAuthPassword
+            };
+            // Save settings
+            await saveSettings(newSettings);
+            // Update environment variables for current process
+            process.env.PORT = String(newSettings.port);
+            if (newSettings.basicAuthEnabled) {
+                process.env.BASIC_AUTH_USER = newSettings.basicAuthUser;
+                process.env.BASIC_AUTH_PASSWORD = newSettings.basicAuthPassword;
+            }
+            else {
+                delete process.env.BASIC_AUTH_USER;
+                delete process.env.BASIC_AUTH_PASSWORD;
+            }
+            // Return success - client should restart server
+            return c.json({
+                success: true,
+                message: 'Settings saved. Server restart required.',
+                requiresRestart: true
+            });
+        }
+        catch (error) {
+            return handleError(c, error);
+        }
+    });
+    return router;
+}

package/apps/server/dist/routes/terminals.js

@@ -0,0 +1,239 @@
+import crypto from 'node:crypto';
+import { Hono } from 'hono';
+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) {
+    const router = new Hono();
+    function appendToTerminalBuffer(session, data) {
+        const newBuffer = session.buffer + data;
+        session.buffer =
+            newBuffer.length > TERMINAL_BUFFER_LIMIT
+                ? newBuffer.slice(newBuffer.length - TERMINAL_BUFFER_LIMIT)
+                : newBuffer;
+    }
+    function getNextTerminalIndex(deckId) {
+        const current = deckTerminalCounters.get(deckId) ?? 0;
+        const next = current + 1;
+        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();
+        const deadSockets = new Set();
+        session.sockets.forEach((socket) => {
+            try {
+                if (socket.readyState === 1) {
+                    socket.send(data);
+                }
+                else if (socket.readyState > 1) {
+                    deadSockets.add(socket);
+                }
+            }
+            catch {
+                deadSockets.add(socket);
+            }
+        });
+        deadSockets.forEach((s) => session.sockets.delete(s));
+    });
+    // Central exit handler: PTY exited → close WebSockets, remove from map and DB
+    ptyClient.on('exit', (id) => {
+        const session = terminals.get(id);
+        if (!session)
+            return;
+        console.log(`[TERMINAL] Terminal ${id} exited`);
+        terminals.delete(id);
+        deleteTerminalFromDb(db, id);
+        session.sockets.forEach((socket) => {
+            try {
+                socket.close(1000, 'Terminal exited');
+            }
+            catch { /* ignore */ }
+        });
+        session.sockets.clear();
+    });
+    async function createTerminalSession(deck, title, command, options) {
+        const id = options?.id || crypto.randomUUID();
+        // Resolve shell and arguments
+        let shell;
+        let shellArgs = [];
+        if (command) {
+            const defaultShell = getDefaultShell();
+            shell = defaultShell;
+            if (process.platform === 'win32') {
+                if (defaultShell.toLowerCase().includes('powershell')) {
+                    shellArgs = ['-NoExit', '-Command', command];
+                }
+                else {
+                    shellArgs = ['/K', command];
+                }
+            }
+            else {
+                shellArgs = ['-c', command];
+            }
+        }
+        else {
+            shell = getDefaultShell();
+        }
+        // Build environment
+        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';
+        if (process.platform === 'win32') {
+            env.LANG = 'en_US.UTF-8';
+        }
+        else {
+            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';
+        // 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}`);
+        const resolvedTitle = title || `Terminal ${getNextTerminalIndex(deck.id)}`;
+        const createdAt = new Date().toISOString();
+        const session = {
+            id,
+            deckId: deck.id,
+            title: resolvedTitle,
+            command: command || null,
+            createdAt,
+            sockets: new Set(),
+            buffer: options?.initialBuffer || '',
+            lastActive: Date.now(),
+            write: (data) => ptyClient.input(id, data),
+            resize: (cols, rows) => ptyClient.resize(id, cols, rows),
+            kill: () => ptyClient.kill(id),
+        };
+        if (!options?.skipDbSave) {
+            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) => {
+        const deckId = c.req.query('deckId');
+        if (!deckId) {
+            return c.json({ error: 'deckId is required' }, 400);
+        }
+        const sessions = [];
+        terminals.forEach((session) => {
+            if (session.deckId === deckId) {
+                sessions.push({ id: session.id, title: session.title, createdAt: session.createdAt });
+            }
+        });
+        sessions.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+        return c.json(sessions);
+    });
+    router.post('/', async (c) => {
+        try {
+            const body = await readJson(c);
+            const deckId = body?.deckId;
+            if (!deckId)
+                throw createHttpError('deckId is required', 400);
+            const deck = decks.get(deckId);
+            if (!deck)
+                throw createHttpError('Deck not found', 404);
+            const session = await createTerminalSession(deck, body?.title, body?.command);
+            return c.json({ id: session.id, title: session.title }, 201);
+        }
+        catch (error) {
+            return handleError(c, error);
+        }
+    });
+    router.delete('/:id', async (c) => {
+        try {
+            const terminalId = c.req.param('id');
+            const session = terminals.get(terminalId);
+            if (!session)
+                throw createHttpError('Terminal not found', 404);
+            terminals.delete(terminalId);
+            deleteTerminalFromDb(db, terminalId);
+            session.sockets.forEach((socket) => {
+                try {
+                    socket.close(1000, 'Terminal deleted');
+                }
+                catch { /* ignore */ }
+            });
+            session.sockets.clear();
+            // Kill PTY in daemon
+            session.kill();
+            return c.body(null, 204);
+        }
+        catch (error) {
+            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 };
+}

package/apps/server/dist/routes/workspaces.js

@@ -0,0 +1,83 @@
+import crypto from 'node:crypto';
+import { Hono } from 'hono';
+import { DEFAULT_ROOT } from '../config.js';
+import { createHttpError, handleError, readJson } from '../utils/error.js';
+import { normalizeWorkspacePath, getWorkspaceKey, getWorkspaceName } from '../utils/path.js';
+const MAX_NAME_LENGTH = 100;
+const NAME_PATTERN = /^[\p{L}\p{N}\s\-_.]+$/u; // Unicode letters, numbers, spaces, hyphens, underscores, dots
+function validateName(name) {
+    if (!name) {
+        return undefined;
+    }
+    if (typeof name !== 'string') {
+        throw createHttpError('name must be a string', 400);
+    }
+    const trimmed = name.trim();
+    if (trimmed.length === 0) {
+        return undefined;
+    }
+    if (trimmed.length > MAX_NAME_LENGTH) {
+        throw createHttpError(`name is too long (max: ${MAX_NAME_LENGTH} characters)`, 400);
+    }
+    if (!NAME_PATTERN.test(trimmed)) {
+        throw createHttpError('name contains invalid characters', 400);
+    }
+    return trimmed;
+}
+export function createWorkspaceRouter(db, workspaces, workspacePathIndex) {
+    const router = new Hono();
+    const insertWorkspace = db.prepare('INSERT INTO workspaces (id, name, path, normalized_path, created_at) VALUES (?, ?, ?, ?, ?)');
+    function createWorkspace(inputPath, name) {
+        const resolvedPath = normalizeWorkspacePath(inputPath);
+        const key = getWorkspaceKey(resolvedPath);
+        if (workspacePathIndex.has(key)) {
+            throw createHttpError('Workspace path already exists', 409);
+        }
+        const validatedName = validateName(name);
+        const workspace = {
+            id: crypto.randomUUID(),
+            name: validatedName || getWorkspaceName(resolvedPath, workspaces.size + 1),
+            path: resolvedPath,
+            createdAt: new Date().toISOString()
+        };
+        insertWorkspace.run(workspace.id, workspace.name, workspace.path, key, workspace.createdAt);
+        workspaces.set(workspace.id, workspace);
+        workspacePathIndex.set(key, workspace.id);
+        return workspace;
+    }
+    router.get('/', (c) => {
+        return c.json(Array.from(workspaces.values()));
+    });
+    router.post('/', async (c) => {
+        try {
+            const body = await readJson(c);
+            if (!body?.path) {
+                throw createHttpError('path is required', 400);
+            }
+            const workspace = createWorkspace(body.path, body.name);
+            return c.json(workspace, 201);
+        }
+        catch (error) {
+            return handleError(c, error);
+        }
+    });
+    return router;
+}
+export function getConfigHandler() {
+    return (c) => {
+        try {
+            return c.json({ defaultRoot: normalizeWorkspacePath(DEFAULT_ROOT) });
+        }
+        catch (error) {
+            console.error('Failed to get config:', error);
+            return c.json({ defaultRoot: '' });
+        }
+    };
+}
+export function requireWorkspace(workspaces, workspaceId) {
+    const workspace = workspaces.get(workspaceId);
+    if (!workspace) {
+        throw createHttpError('Workspace not found', 404);
+    }
+    return workspace;
+}

package/apps/server/dist/server.js

@@ -0,0 +1,257 @@
+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 { 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 { createWorkspaceRouter, getConfigHandler } from './routes/workspaces.js';
+import { createDeckRouter } from './routes/decks.js';
+import { createFileRouter } from './routes/files.js';
+import { createTerminalRouter } from './routes/terminals.js';
+import { createGitRouter } from './routes/git.js';
+import { createSettingsRouter } from './routes/settings.js';
+import { 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) => {
+    const requestId = c.req.header('x-request-id') || crypto.randomUUID().slice(0, 8);
+    c.set('requestId', requestId);
+    c.header('X-Request-ID', requestId);
+    const start = Date.now();
+    const method = c.req.method;
+    const path_ = c.req.path;
+    await next();
+    const duration = Date.now() - start;
+    const status = c.res.status;
+    if (NODE_ENV === 'production' || process.env.DEBUG) {
+        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)) {
+        handleDatabaseCorruption(dbPath);
+    }
+    const db = new DatabaseSync(dbPath);
+    initializeDatabase(db);
+    // Initialize state
+    const workspaces = new Map();
+    const workspacePathIndex = new Map();
+    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);
+    app.use('*', corsMiddleware);
+    app.use('*', requestIdMiddleware);
+    app.use('/api/*', bodyLimit({
+        maxSize: MAX_REQUEST_BODY_SIZE,
+        onError: (c) => c.json({ error: 'Request body too large' }, 413),
+    }));
+    if (basicAuthMiddleware) {
+        app.use('/api/*', basicAuthMiddleware);
+    }
+    app.get('/health', (c) => c.json({ status: 'ok', timestamp: new Date().toISOString(), uptime: process.uptime() }));
+    // Mount routers
+    app.route('/api/settings', createSettingsRouter());
+    app.route('/api/workspaces', createWorkspaceRouter(db, workspaces, workspacePathIndex));
+    app.route('/api/decks', createDeckRouter(db, workspaces, decks));
+    const { router: terminalRouter, restoreTerminals } = createTerminalRouter(db, decks, terminals, ptyClient);
+    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() }));
+    app.put('/api/ws/limit', async (c) => {
+        const body = await c.req.json();
+        if (typeof body.limit !== 'number' || body.limit < 1) {
+            return c.json({ error: 'Invalid limit value' }, 400);
+        }
+        setConnectionLimit(body.limit);
+        return c.json({ limit: getConnectionLimit() });
+    });
+    app.post('/api/ws/clear', (c) => {
+        const closedCount = clearAllConnections();
+        return c.json({ cleared: closedCount });
+    });
+    const fileRouter = createFileRouter(workspaces);
+    app.route('/api', fileRouter);
+    if (hasStatic) {
+        const serveAssets = serveStatic({ root: distDir });
+        const serveIndex = serveStatic({ root: distDir, path: 'index.html' });
+        app.use('/assets/*', serveAssets);
+        app.get('*', async (c, next) => {
+            if (c.req.path.startsWith('/api'))
+                return c.text('Not found', 404);
+            return serveIndex(c, next);
+        });
+    }
+    const server = serve({ fetch: app.fetch, port: PORT, hostname: HOST });
+    setupWebSocketServer(server, terminals);
+    server.on('listening', () => {
+        const baseUrl = `http://localhost:${PORT}`;
+        console.log(`Deck IDE server listening on ${baseUrl}`);
+        console.log(`UI: ${baseUrl}`);
+        console.log(`API: ${baseUrl}/api`);
+        console.log(`Health: ${baseUrl}/health`);
+        console.log('');
+        console.log('Security Status:');
+        console.log(`  - Basic Auth: ${BASIC_AUTH_USER && BASIC_AUTH_PASSWORD ? 'enabled' : 'DISABLED'}`);
+        console.log(`  - Max File Size: ${Math.round(MAX_FILE_SIZE / 1024 / 1024)}MB`);
+        console.log(`  - Max Request Body: ${Math.round(MAX_REQUEST_BODY_SIZE / 1024)}KB`);
+        console.log(`  - Trust Proxy: ${TRUST_PROXY ? 'enabled' : 'disabled'}`);
+        console.log(`  - CORS Origin: ${CORS_ORIGIN || (NODE_ENV === 'development' ? '*' : 'NOT SET')}`);
+        console.log(`  - Environment: ${NODE_ENV}`);
+    });
+    // Graceful shutdown - optionally terminate daemon.
+    let shutdownPromise = null;
+    let shouldTerminateDaemon = false;
+    const onShutdown = (options = {}) => {
+        if (options.terminateDaemon) {
+            shouldTerminateDaemon = true;
+        }
+        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');
+                    }
+                }
+                catch (err) {
+                    console.warn('[SHUTDOWN] Failed to request PTY daemon shutdown:', err);
+                }
+            }
+            ptyClient.destroy();
+            try {
+                db.close();
+            }
+            catch { /* ignore */ }
+        })();
+        return shutdownPromise;
+    };
+    process.on('SIGINT', () => {
+        console.log('\n[SHUTDOWN] Received SIGINT, saving state...');
+        void onShutdown({ terminateDaemon: true }).finally(() => process.exit(0));
+    });
+    process.on('SIGTERM', () => {
+        console.log('[SHUTDOWN] Received SIGTERM, saving state...');
+        void onShutdown({ terminateDaemon: true }).finally(() => process.exit(0));
+    });
+    process.on('SIGHUP', () => {
+        console.log('[SHUTDOWN] Received SIGHUP, saving state...');
+        void onShutdown({ terminateDaemon: true }).finally(() => process.exit(0));
+    });
+    // HTTP shutdown endpoint — allows cross-platform graceful shutdown from Electron
+    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));
+        }, 50);
+        return c.json({ ok: true, terminateDaemon });
+    });
+    const originalExceptionHandler = process.listeners('uncaughtException')[0];
+    process.removeAllListeners('uncaughtException');
+    process.on('uncaughtException', (error) => {
+        if (error.message?.includes('AttachConsole failed')) {
+            console.log('[node-pty] AttachConsole error suppressed');
+            return;
+        }
+        console.error('[SHUTDOWN] Uncaught exception, saving state before exit...');
+        void onShutdown({ terminateDaemon: true }).finally(() => {
+            if (originalExceptionHandler) {
+                originalExceptionHandler(error);
+            }
+            else {
+                console.error('Uncaught exception:', error);
+                process.exit(1);
+            }
+        });
+    });
+    return server;
+}

package/apps/server/dist/types.js

@@ -0,0 +1 @@
+export {};