deckide 3.5.41 → 3.5.43

package/dist/utils/code-server.js

@@ -0,0 +1,360 @@
+import { spawn, execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import net from 'node:net';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { dataDir } from '../config.js';
+const IDLE_TIMEOUT_MS = 20 * 60 * 1000;
+const START_TIMEOUT_MS = 30_000;
+const REAP_INTERVAL_MS = 60_000;
+// Pinned code-server version for reproducible auto-download.
+const CODE_SERVER_VERSION = process.env.DECKIDE_CODE_SERVER_VERSION || '4.125.0';
+const execFileAsync = promisify(execFile);
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function pathExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function findInPath(name) {
+    for (const dir of (process.env.PATH || '').split(path.delimiter)) {
+        if (!dir)
+            continue;
+        const candidate = path.join(dir, name);
+        if (await pathExists(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function getFreePort() {
+    return new Promise((resolve, reject) => {
+        const srv = net.createServer();
+        srv.once('error', reject);
+        srv.listen(0, '127.0.0.1', () => {
+            const addr = srv.address();
+            const port = typeof addr === 'object' && addr ? addr.port : 0;
+            srv.close(() => (port ? resolve(port) : reject(new Error('Could not get a free port'))));
+        });
+    });
+}
+/**
+ * Manages per-workspace code-server child processes — the "power editor" surface.
+ * Mirrors AgentBrowserService: spawn on demand, supervise, poll readiness, and
+ * idle-reap (auto-stop, not auto-restart). One instance per workspace id.
+ */
+export class CodeServerService {
+    workspaces;
+    instances = new Map();
+    reaper = null;
+    // Single-flight auto-download of the code-server binary.
+    downloadPromise = null;
+    downloading = false;
+    // Directory layout under ~/.deckide/code-server (set by config.dataDir).
+    root = path.join(dataDir, 'code-server');
+    constructor(workspaces) {
+        this.workspaces = workspaces;
+    }
+    // Resolve the code-server executable: explicit env → standalone install under
+    // dataDir → PATH. Returns null when not acquired.
+    async resolveBin() {
+        const configured = process.env.DECKIDE_CODE_SERVER_BIN;
+        if (configured) {
+            return (await pathExists(configured)) ? configured : null;
+        }
+        const standalone = path.join(this.root, 'bin', 'code-server');
+        if (await pathExists(standalone)) {
+            return standalone;
+        }
+        return findInPath('code-server');
+    }
+    async isAcquired() {
+        return (await this.resolveBin()) !== null;
+    }
+    // Download + install the pinned code-server build into dataDir (single-flight).
+    // Returns the resolved binary path. Auto-invoked by ensure() when not present.
+    download(onLog) {
+        if (this.downloadPromise) {
+            return this.downloadPromise;
+        }
+        this.downloading = true;
+        this.downloadPromise = this.doDownload(onLog).finally(() => {
+            this.downloading = false;
+            this.downloadPromise = null;
+        });
+        return this.downloadPromise;
+    }
+    async doDownload(onLog) {
+        const version = CODE_SERVER_VERSION;
+        const os = process.platform === 'darwin' ? 'macos' : process.platform === 'linux' ? 'linux' : null;
+        if (!os) {
+            throw new Error(`Automatic code-server download is unsupported on ${process.platform}. Install code-server manually and set DECKIDE_CODE_SERVER_BIN.`);
+        }
+        const arch = process.arch === 'arm64' ? 'arm64' : process.arch === 'x64' ? 'amd64' : null;
+        if (!arch) {
+            throw new Error(`Automatic code-server download is unsupported on architecture ${process.arch}.`);
+        }
+        const name = `code-server-${version}-${os}-${arch}`;
+        const url = `https://github.com/coder/code-server/releases/download/v${version}/${name}.tar.gz`;
+        const libDir = path.join(this.root, 'lib');
+        const tarPath = path.join(this.root, `${name}.tar.gz`);
+        await fs.mkdir(libDir, { recursive: true });
+        const log = (m) => { onLog?.(m); console.log(`[code-server] ${m}`); };
+        log(`downloading ${url}`);
+        const res = await fetch(url, { redirect: 'follow' });
+        if (!res.ok) {
+            throw new Error(`code-server download failed: HTTP ${res.status}`);
+        }
+        const bytes = Buffer.from(await res.arrayBuffer());
+        await fs.writeFile(tarPath, bytes);
+        log(`extracting ${(bytes.length / 1024 / 1024).toFixed(0)}MB`);
+        await execFileAsync('tar', ['-xzf', tarPath, '-C', libDir]);
+        await fs.rm(tarPath, { force: true });
+        const innerBin = path.join(libDir, name, 'bin', 'code-server');
+        if (!(await pathExists(innerBin))) {
+            throw new Error('code-server binary not found after extraction');
+        }
+        const binDir = path.join(this.root, 'bin');
+        await fs.mkdir(binDir, { recursive: true });
+        const link = path.join(binDir, 'code-server');
+        await fs.rm(link, { force: true });
+        await fs.symlink(innerBin, link);
+        log('installed');
+        return link;
+    }
+    // Remove the downloaded code-server install (and its per-workspace data).
+    async uninstall() {
+        await this.stopAll();
+        await fs.rm(this.root, { recursive: true, force: true });
+    }
+    async getStatus(wsId) {
+        const bin = await this.resolveBin();
+        const instance = wsId ? this.instances.get(wsId) : undefined;
+        return {
+            available: bin !== null,
+            acquired: bin !== null,
+            binPath: bin,
+            running: instance ? instance.proc.exitCode == null : false,
+            instances: this.instances.size,
+            downloading: this.downloading,
+            wsId: wsId ?? null,
+            reason: bin
+                ? undefined
+                : this.downloading
+                    ? 'code-server is downloading…'
+                    : 'code-server will be downloaded automatically on first use',
+            error: instance?.error,
+        };
+    }
+    // Ensure an instance for this workspace is running and ready; return its port.
+    async ensure(wsId) {
+        const existing = this.instances.get(wsId);
+        if (existing && existing.proc.exitCode == null) {
+            existing.lastActive = Date.now();
+            await existing.ready;
+            return existing.port;
+        }
+        if (existing) {
+            this.instances.delete(wsId);
+        }
+        const workspace = this.workspaces.get(wsId);
+        if (!workspace) {
+            throw new Error(`Unknown workspace: ${wsId}`);
+        }
+        let bin = await this.resolveBin();
+        if (!bin) {
+            // Auto-acquire on first use (single-flight ~100MB download).
+            bin = await this.download();
+        }
+        const port = await getFreePort();
+        const userDataDir = path.join(this.root, 'user', wsId);
+        const extensionsDir = path.join(this.root, 'ext');
+        await fs.mkdir(userDataDir, { recursive: true });
+        await fs.mkdir(extensionsDir, { recursive: true });
+        // Per-instance config file so the user's global ~/.config/code-server/config.yaml
+        // (which may set auth/bind-addr) can never override our flags.
+        const configPath = path.join(userDataDir, 'config.yaml');
+        await fs.writeFile(configPath, `bind-addr: 127.0.0.1:${port}\nauth: none\ncert: false\n`, 'utf8');
+        // code-server honors the PORT env var ahead of --bind-addr, so strip it
+        // (Deck IDE's own PORT would otherwise collide).
+        const childEnv = { ...process.env };
+        delete childEnv.PORT;
+        const proc = spawn(bin, [
+            '--config', configPath,
+            '--auth', 'none', // Deck IDE owns auth at the same-origin proxy.
+            '--disable-telemetry',
+            '--disable-update-check',
+            '--bind-addr', `127.0.0.1:${port}`,
+            '--user-data-dir', userDataDir,
+            '--extensions-dir', extensionsDir,
+            workspace.path,
+        ], { stdio: ['ignore', 'pipe', 'pipe'], env: childEnv });
+        let stderrTail = '';
+        proc.stderr.setEncoding('utf8');
+        proc.stderr.on('data', (chunk) => {
+            stderrTail = (stderrTail + chunk).slice(-2000);
+        });
+        proc.stdout.resume();
+        const instance = {
+            wsId,
+            proc,
+            port,
+            lastActive: Date.now(),
+            startedAt: Date.now(),
+            ready: this.waitForReady(port, proc, () => stderrTail),
+        };
+        this.instances.set(wsId, instance);
+        proc.once('exit', (code, signal) => {
+            const current = this.instances.get(wsId);
+            if (current === instance) {
+                this.instances.delete(wsId);
+            }
+            if (code !== 0 && code != null) {
+                console.error(`[code-server] ${wsId} exited (${signal ?? code}): ${stderrTail.trim()}`);
+            }
+        });
+        proc.once('error', (error) => {
+            instance.error = error.message;
+        });
+        this.ensureReaper();
+        try {
+            await instance.ready;
+        }
+        catch (error) {
+            await this.stop(wsId);
+            throw error;
+        }
+        return port;
+    }
+    async waitForReady(port, proc, tail) {
+        const deadline = Date.now() + START_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            if (proc.exitCode != null) {
+                throw new Error(`code-server exited before becoming ready: ${tail().trim()}`);
+            }
+            try {
+                const res = await fetch(`http://127.0.0.1:${port}/healthz`, {
+                    signal: AbortSignal.timeout(2000),
+                });
+                if (res.ok) {
+                    return;
+                }
+            }
+            catch {
+                // not up yet
+            }
+            await sleep(250);
+        }
+        throw new Error('Timed out waiting for code-server to become ready');
+    }
+    // Returns the running port for a ready instance (for the HTTP proxy), bumping
+    // its idle timer. Starts the instance if needed.
+    async portFor(wsId) {
+        return this.ensure(wsId);
+    }
+    touch(wsId) {
+        const instance = this.instances.get(wsId);
+        if (instance) {
+            instance.lastActive = Date.now();
+        }
+    }
+    // Proxy a WebSocket upgrade for a ready instance to its loopback port. The
+    // prefix /codeserver/:wsId has already been stripped from req.url by the caller.
+    proxyUpgrade(wsId, req, clientSocket, head) {
+        const instance = this.instances.get(wsId);
+        if (!instance || instance.proc.exitCode != null) {
+            clientSocket.destroy();
+            return;
+        }
+        instance.lastActive = Date.now();
+        const upstream = net.connect(instance.port, '127.0.0.1', () => {
+            const headerLines = [`${req.method} ${req.url} HTTP/1.1`];
+            const headers = req.headers;
+            for (const [key, value] of Object.entries(headers)) {
+                if (value === undefined)
+                    continue;
+                if (Array.isArray(value)) {
+                    for (const v of value)
+                        headerLines.push(`${key}: ${v}`);
+                }
+                else {
+                    headerLines.push(`${key}: ${value}`);
+                }
+            }
+            upstream.write(headerLines.join('\r\n') + '\r\n\r\n');
+            if (head && head.length) {
+                upstream.write(head);
+            }
+            upstream.pipe(clientSocket);
+            clientSocket.pipe(upstream);
+        });
+        const teardown = () => {
+            try {
+                upstream.destroy();
+            }
+            catch { /* ignore */ }
+            try {
+                clientSocket.destroy();
+            }
+            catch { /* ignore */ }
+        };
+        upstream.on('error', teardown);
+        clientSocket.on('error', teardown);
+    }
+    async stop(wsId) {
+        const instance = this.instances.get(wsId);
+        if (!instance)
+            return;
+        this.instances.delete(wsId);
+        const proc = instance.proc;
+        if (proc.exitCode == null && proc.signalCode == null) {
+            await new Promise((resolve) => {
+                const killTimer = setTimeout(() => {
+                    try {
+                        proc.kill('SIGKILL');
+                    }
+                    catch { /* ignore */ }
+                }, 3000);
+                killTimer.unref?.();
+                proc.once('exit', () => { clearTimeout(killTimer); resolve(); });
+                try {
+                    proc.kill('SIGTERM');
+                }
+                catch {
+                    clearTimeout(killTimer);
+                    resolve();
+                }
+            });
+        }
+    }
+    async stopAll() {
+        if (this.reaper) {
+            clearInterval(this.reaper);
+            this.reaper = null;
+        }
+        await Promise.all([...this.instances.keys()].map((wsId) => this.stop(wsId)));
+    }
+    ensureReaper() {
+        if (this.reaper)
+            return;
+        this.reaper = setInterval(() => {
+            const now = Date.now();
+            for (const [wsId, instance] of this.instances) {
+                if (now - instance.lastActive > IDLE_TIMEOUT_MS) {
+                    void this.stop(wsId);
+                }
+            }
+            if (this.instances.size === 0 && this.reaper) {
+                clearInterval(this.reaper);
+                this.reaper = null;
+            }
+        }, REAP_INTERVAL_MS);
+        this.reaper.unref?.();
+    }
+}

package/dist/websocket.js

@@ -196,8 +196,47 @@ function readBufferedRange(session, startOffset, endOffset) {
     }
     return Buffer.from(raw.subarray(alignedStart, alignedEnd));
 }
-export function setupWebSocketServer(server, terminals, browserService) {
-    const wss = new WebSocketServer({ server, maxPayload: MAX_MESSAGE_SIZE });
+export function setupWebSocketServer(server, terminals, browserService, codeServerService) {
+    // noServer mode: we own the HTTP 'upgrade' event so code-server's WebSocket can
+    // be reverse-proxied alongside the app's own sockets. Everything that isn't a
+    // /codeserver/ upgrade is handed to wss exactly as before.
+    const wss = new WebSocketServer({ noServer: true, maxPayload: MAX_MESSAGE_SIZE });
+    server.on('upgrade', (req, socket, head) => {
+        let pathname;
+        try {
+            pathname = new URL(req.url || '', `http://localhost:${PORT}`).pathname;
+        }
+        catch {
+            socket.destroy();
+            return;
+        }
+        if (codeServerService && pathname.startsWith('/codeserver/')) {
+            if (!verifyWebSocketAuth(req)) {
+                socket.destroy();
+                return;
+            }
+            const rest = pathname.slice('/codeserver/'.length);
+            const slash = rest.indexOf('/');
+            const wsId = slash === -1 ? rest : rest.slice(0, slash);
+            const prefix = `/codeserver/${wsId}`;
+            const original = req.url || '';
+            req.url = original.slice(prefix.length) || '/';
+            if (!req.url.startsWith('/')) {
+                req.url = `/${req.url}`;
+            }
+            codeServerService
+                .ensure(wsId)
+                .then(() => codeServerService.proxyUpgrade(wsId, req, socket, head))
+                .catch(() => {
+                try {
+                    socket.destroy();
+                }
+                catch { /* ignore */ }
+            });
+            return;
+        }
+        wss.handleUpgrade(req, socket, head, (ws) => wss.emit('connection', ws, req));
+    });
     const heartbeatState = new WeakMap();
     const heartbeatInterval = setInterval(() => {
         for (const socket of wss.clients) {
@@ -298,6 +337,19 @@ export function setupWebSocketServer(server, terminals, browserService) {
             browserService.attachAudioWebSocket(socket);
             return;
         }
+        if (url.pathname === '/api/browser/webrtc/ws') {
+            if (!browserService) {
+                untrackConnection(clientIP, socket);
+                socket.close(1011, 'Browser service unavailable');
+                return;
+            }
+            socket.on('close', () => {
+                heartbeatState.delete(socket);
+                untrackConnection(clientIP, socket);
+            });
+            browserService.attachWebRtcWebSocket(socket);
+            return;
+        }
         const match = url.pathname.match(/\/api\/terminals\/(.+)/);
         if (!match) {
             untrackConnection(clientIP, socket);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deckide",
-  "version": "3.5.41",
+  "version": "3.5.43",
   "description": "Deck IDE - Browser-based IDE with terminal, file explorer, and git integration",
   "type": "module",
   "bin": {
@@ -66,5 +66,8 @@
     "developer-tools"
   ],
   "author": "tako0614",
-  "license": "MIT"
+  "license": "MIT",
+  "optionalDependencies": {
+    "werift": "^0.23.0"
+  }
 }