deckide 3.0.0

package/apps/server/dist/pty-daemon.js

@@ -0,0 +1,246 @@
+/**
+ * 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);
+});

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

@@ -0,0 +1,95 @@
+import crypto from 'node:crypto';
+import { Hono } from 'hono';
+import { createHttpError, handleError, readJson } from '../utils/error.js';
+import { requireWorkspace } from './workspaces.js';
+export function createDeckRouter(db, workspaces, decks) {
+    const router = new Hono();
+    const insertDeck = db.prepare('INSERT INTO decks (id, name, root, workspace_id, created_at) VALUES (?, ?, ?, ?, ?)');
+    function createDeck(name, workspaceId) {
+        const workspace = requireWorkspace(workspaces, workspaceId);
+        const deck = {
+            id: crypto.randomUUID(),
+            name: name || `${workspace.name} ${Array.from(decks.values()).filter((d) => d.workspaceId === workspaceId).length + 1}`,
+            root: workspace.path,
+            workspaceId,
+            createdAt: new Date().toISOString()
+        };
+        insertDeck.run(deck.id, deck.name, deck.root, deck.workspaceId, deck.createdAt);
+        decks.set(deck.id, deck);
+        return deck;
+    }
+    router.get('/', (c) => {
+        return c.json(Array.from(decks.values()));
+    });
+    router.post('/', async (c) => {
+        try {
+            const body = await readJson(c);
+            const workspaceId = body?.workspaceId;
+            if (!workspaceId) {
+                throw createHttpError('workspaceId is required', 400);
+            }
+            const deck = createDeck(body?.name, workspaceId);
+            return c.json(deck, 201);
+        }
+        catch (error) {
+            return handleError(c, error);
+        }
+    });
+    const updateSortOrderStmt = db.prepare('UPDATE decks SET sort_order = ? WHERE id = ?');
+    router.put('/order', async (c) => {
+        try {
+            const body = await readJson(c);
+            const deckIds = body?.deckIds;
+            if (!Array.isArray(deckIds)) {
+                throw createHttpError('deckIds array is required', 400);
+            }
+            db.exec('BEGIN TRANSACTION');
+            try {
+                deckIds.forEach((id, index) => {
+                    updateSortOrderStmt.run(index, id);
+                });
+                db.exec('COMMIT');
+            }
+            catch (err) {
+                db.exec('ROLLBACK');
+                throw err;
+            }
+            // Re-order the in-memory map to match
+            const entries = deckIds
+                .filter((id) => decks.has(id))
+                .map((id) => [id, decks.get(id)]);
+            // Add any decks not in the list at the end
+            for (const [id, deck] of decks) {
+                if (!deckIds.includes(id)) {
+                    entries.push([id, deck]);
+                }
+            }
+            decks.clear();
+            for (const [id, deck] of entries) {
+                decks.set(id, deck);
+            }
+            return c.json({ success: true });
+        }
+        catch (error) {
+            return handleError(c, error);
+        }
+    });
+    const deleteDeckStmt = db.prepare('DELETE FROM decks WHERE id = ?');
+    const deleteTerminalsByDeckStmt = db.prepare('DELETE FROM terminals WHERE deck_id = ?');
+    router.delete('/:id', (c) => {
+        try {
+            const deckId = c.req.param('id');
+            if (!decks.has(deckId)) {
+                throw createHttpError('Deck not found', 404);
+            }
+            deleteTerminalsByDeckStmt.run(deckId);
+            deleteDeckStmt.run(deckId);
+            decks.delete(deckId);
+            return c.json({ deleted: true });
+        }
+        catch (error) {
+            return handleError(c, error);
+        }
+    });
+    return router;
+}

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

@@ -0,0 +1,221 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { Hono } from 'hono';
+import { MAX_FILE_SIZE, DEFAULT_ROOT } from '../config.js';
+import { createHttpError, handleError, readJson } from '../utils/error.js';
+import { resolveSafePath, normalizeWorkspacePath } from '../utils/path.js';
+import { requireWorkspace } from './workspaces.js';
+import { sortFileEntries } from '@deck-ide/shared/utils-node';
+function mapFileEntry(entry, normalizedBase) {
+    const entryPath = normalizedBase ? `${normalizedBase}/${entry.name}` : entry.name;
+    return {
+        name: entry.name,
+        path: entryPath,
+        type: (entry.isDirectory() ? 'dir' : 'file')
+    };
+}
+export function createFileRouter(workspaces) {
+    const router = new Hono();
+    router.get('/files', async (c) => {
+        try {
+            const workspaceId = c.req.query('workspaceId');
+            if (!workspaceId) {
+                throw createHttpError('workspaceId is required', 400);
+            }
+            const workspace = requireWorkspace(workspaces, workspaceId);
+            const requestedPath = c.req.query('path') || '';
+            const target = await resolveSafePath(workspace.path, requestedPath);
+            const stats = await fs.stat(target);
+            if (!stats.isDirectory()) {
+                throw createHttpError('Path is not a directory', 400);
+            }
+            const entries = await fs.readdir(target, { withFileTypes: true });
+            const normalizedBase = requestedPath.replace(/\\/g, '/');
+            const mapped = entries.map((entry) => mapFileEntry(entry, normalizedBase));
+            const sorted = sortFileEntries(mapped);
+            return c.json(sorted);
+        }
+        catch (error) {
+            return handleError(c, error);
+        }
+    });
+    router.get('/preview', async (c) => {
+        try {
+            const rootInput = c.req.query('path') || DEFAULT_ROOT;
+            const requestedPath = c.req.query('subpath') || '';
+            const rootPath = normalizeWorkspacePath(rootInput);
+            // When workspaces exist, restrict browsing to registered workspace paths
+            if (workspaces.size > 0) {
+                const isAllowed = [...workspaces.values()].some(ws => rootPath === ws.path || rootPath.startsWith(ws.path + path.sep));
+                if (!isAllowed) {
+                    throw createHttpError('Path outside registered workspaces', 403);
+                }
+            }
+            const target = await resolveSafePath(rootPath, requestedPath);
+            const stats = await fs.stat(target);
+            if (!stats.isDirectory()) {
+                throw createHttpError('Path is not a directory', 400);
+            }
+            const entries = await fs.readdir(target, { withFileTypes: true });
+            const normalizedBase = String(requestedPath || '').replace(/\\/g, '/');
+            const mapped = entries.map((entry) => mapFileEntry(entry, normalizedBase));
+            const sorted = sortFileEntries(mapped);
+            return c.json(sorted);
+        }
+        catch (error) {
+            return handleError(c, error);
+        }
+    });
+    router.get('/file', async (c) => {
+        try {
+            const workspaceId = c.req.query('workspaceId');
+            if (!workspaceId) {
+                throw createHttpError('workspaceId is required', 400);
+            }
+            const workspace = requireWorkspace(workspaces, workspaceId);
+            const target = await resolveSafePath(workspace.path, c.req.query('path') || '');
+            const stats = await fs.stat(target);
+            if (stats.size > MAX_FILE_SIZE) {
+                throw createHttpError(`File too large (${Math.round(stats.size / 1024 / 1024)}MB). Maximum size is ${Math.round(MAX_FILE_SIZE / 1024 / 1024)}MB.`, 413);
+            }
+            const contents = await fs.readFile(target, 'utf8');
+            return c.json({ path: c.req.query('path'), contents });
+        }
+        catch (error) {
+            return handleError(c, error);
+        }
+    });
+    router.put('/file', async (c) => {
+        try {
+            const body = await readJson(c);
+            const workspaceId = body?.workspaceId;
+            if (!workspaceId) {
+                throw createHttpError('workspaceId is required', 400);
+            }
+            const workspace = requireWorkspace(workspaces, workspaceId);
+            const target = await resolveSafePath(workspace.path, body?.path || '');
+            const contents = body?.contents ?? '';
+            const contentSize = Buffer.byteLength(contents, 'utf8');
+            if (contentSize > MAX_FILE_SIZE) {
+                throw createHttpError(`Content size exceeds maximum allowed size of ${Math.round(MAX_FILE_SIZE / 1024 / 1024)}MB`, 413);
+            }
+            await fs.mkdir(path.dirname(target), { recursive: true });
+            await fs.writeFile(target, contents, 'utf8');
+            return c.json({ path: body?.path, saved: true });
+        }
+        catch (error) {
+            return handleError(c, error);
+        }
+    });
+    // Create new file
+    router.post('/file', async (c) => {
+        try {
+            const body = await readJson(c);
+            const workspaceId = body?.workspaceId;
+            if (!workspaceId) {
+                throw createHttpError('workspaceId is required', 400);
+            }
+            if (!body?.path) {
+                throw createHttpError('path is required', 400);
+            }
+            const workspace = requireWorkspace(workspaces, workspaceId);
+            const target = await resolveSafePath(workspace.path, body.path);
+            // Check if file already exists
+            try {
+                await fs.access(target);
+                throw createHttpError('File already exists', 409);
+            }
+            catch (err) {
+                if (err.code !== 'ENOENT') {
+                    throw err;
+                }
+            }
+            const contents = body?.contents ?? '';
+            await fs.mkdir(path.dirname(target), { recursive: true });
+            await fs.writeFile(target, contents, 'utf8');
+            return c.json({ path: body.path, created: true });
+        }
+        catch (error) {
+            return handleError(c, error);
+        }
+    });
+    // Delete file
+    router.delete('/file', async (c) => {
+        try {
+            const workspaceId = c.req.query('workspaceId');
+            if (!workspaceId) {
+                throw createHttpError('workspaceId is required', 400);
+            }
+            const filePath = c.req.query('path');
+            if (!filePath) {
+                throw createHttpError('path is required', 400);
+            }
+            const workspace = requireWorkspace(workspaces, workspaceId);
+            const target = await resolveSafePath(workspace.path, filePath);
+            const stats = await fs.stat(target);
+            if (stats.isDirectory()) {
+                throw createHttpError('Path is a directory, use DELETE /dir instead', 400);
+            }
+            await fs.unlink(target);
+            return c.json({ path: filePath, deleted: true });
+        }
+        catch (error) {
+            return handleError(c, error);
+        }
+    });
+    // Create directory
+    router.post('/dir', async (c) => {
+        try {
+            const body = await readJson(c);
+            const workspaceId = body?.workspaceId;
+            if (!workspaceId) {
+                throw createHttpError('workspaceId is required', 400);
+            }
+            if (!body?.path) {
+                throw createHttpError('path is required', 400);
+            }
+            const workspace = requireWorkspace(workspaces, workspaceId);
+            const target = await resolveSafePath(workspace.path, body.path);
+            // Check if already exists
+            try {
+                await fs.access(target);
+                throw createHttpError('Directory already exists', 409);
+            }
+            catch (err) {
+                if (err.code !== 'ENOENT') {
+                    throw err;
+                }
+            }
+            await fs.mkdir(target, { recursive: true });
+            return c.json({ path: body.path, created: true });
+        }
+        catch (error) {
+            return handleError(c, error);
+        }
+    });
+    // Delete directory
+    router.delete('/dir', async (c) => {
+        try {
+            const workspaceId = c.req.query('workspaceId');
+            if (!workspaceId) {
+                throw createHttpError('workspaceId is required', 400);
+            }
+            const dirPath = c.req.query('path');
+            if (!dirPath) {
+                throw createHttpError('path is required', 400);
+            }
+            const workspace = requireWorkspace(workspaces, workspaceId);
+            const target = await resolveSafePath(workspace.path, dirPath);
+            const stats = await fs.stat(target);
+            if (!stats.isDirectory()) {
+                throw createHttpError('Path is not a directory', 400);
+            }
+            await fs.rm(target, { recursive: true });
+            return c.json({ path: dirPath, deleted: true });
+        }
+        catch (error) {
+            return handleError(c, error);
+        }
+    });
+    return router;
+}