presubmit 0.1.0

package/dist/apps/server/src/terminal.js

@@ -0,0 +1,182 @@
+import * as pty from 'node-pty';
+import headless from '@xterm/headless';
+import serializer from '@xterm/addon-serialize';
+import { WebSocket } from 'ws';
+/** One server-owned PTY per terminal. Browser sockets are observers, not process owners. */
+export class SharedTerminal {
+    cwd;
+    shell;
+    onChange;
+    process;
+    screen = new headless.Terminal({
+        cols: 100,
+        rows: 30,
+        scrollback: 2000,
+        allowProposedApi: true,
+    });
+    serializer = new serializer.SerializeAddon();
+    peers = new Set();
+    sizes = new Map();
+    status = 'idle';
+    exitCode;
+    disposed = false;
+    pending = 0;
+    constructor(cwd, shell = process.env.SHELL || '/bin/sh', onChange = () => { }) {
+        this.cwd = cwd;
+        this.shell = shell;
+        this.onChange = onChange;
+        this.screen.loadAddon(this.serializer);
+    }
+    get lifecycle() {
+        return this.status;
+    }
+    get running() {
+        return !!this.process;
+    }
+    send(peer, value) {
+        if (peer.readyState !== WebSocket.OPEN)
+            return;
+        if (peer.bufferedAmount > 4 * 1024 * 1024) {
+            peer.close(1013, 'Reconnect to catch up');
+            return;
+        }
+        peer.send(JSON.stringify(value));
+    }
+    broadcast(value) {
+        for (const peer of this.peers)
+            this.send(peer, value);
+    }
+    state() {
+        return { type: 'status', status: this.status, exitCode: this.exitCode, peers: this.peers.size };
+    }
+    attach(peer) {
+        // Flush pending parser work before serializing, then subscribe without a replay/live gap.
+        this.screen.write('', () => {
+            if (this.disposed || peer.readyState !== WebSocket.OPEN)
+                return;
+            this.send(peer, {
+                type: 'snapshot',
+                data: this.serializer.serialize(),
+                cols: this.screen.cols,
+                rows: this.screen.rows,
+            });
+            this.peers.add(peer);
+            this.broadcast(this.state());
+        });
+        peer.on('message', (bytes) => {
+            if (!this.peers.has(peer))
+                return;
+            try {
+                if (bytes.toString().length > 64 * 1024)
+                    throw new Error('Terminal message too large');
+                const message = JSON.parse(bytes.toString());
+                if (message.type === 'start')
+                    this.start();
+                else if (message.type === 'input' &&
+                    typeof message.data === 'string' &&
+                    message.data.length <= 32768)
+                    this.process?.write(message.data);
+                else if (message.type === 'resize' &&
+                    Number.isInteger(message.cols) &&
+                    Number.isInteger(message.rows) &&
+                    message.cols >= 20 &&
+                    message.cols <= 300 &&
+                    message.rows >= 5 &&
+                    message.rows <= 100) {
+                    this.sizes.set(peer, { cols: message.cols, rows: message.rows });
+                    this.fitVisiblePeers();
+                }
+                else if (message.type === 'hidden') {
+                    this.sizes.delete(peer);
+                    this.fitVisiblePeers();
+                }
+                else if (message.type === 'stop')
+                    this.process?.kill();
+                else
+                    throw new Error('Invalid terminal message');
+            }
+            catch (error) {
+                this.send(peer, {
+                    type: 'error',
+                    message: error instanceof Error ? error.message : 'Terminal error',
+                });
+            }
+        });
+        peer.on('close', () => {
+            this.peers.delete(peer);
+            this.sizes.delete(peer);
+            this.fitVisiblePeers();
+            this.broadcast(this.state());
+        });
+        peer.on('error', () => this.peers.delete(peer));
+    }
+    fitVisiblePeers() {
+        this.screen.write('', () => {
+            if (this.disposed || !this.sizes.size)
+                return;
+            const sizes = [...this.sizes.values()];
+            const cols = Math.min(...sizes.map((size) => size.cols));
+            const rows = Math.min(...sizes.map((size) => size.rows));
+            if (cols === this.screen.cols && rows === this.screen.rows)
+                return;
+            this.screen.resize(cols, rows);
+            this.process?.resize(cols, rows);
+            this.broadcast({ type: 'resize', cols, rows });
+        });
+    }
+    start() {
+        if (this.process || this.disposed)
+            return;
+        this.screen.reset();
+        const child = pty.spawn(this.shell, ['-i'], {
+            cwd: this.cwd,
+            name: 'xterm-256color',
+            cols: this.screen.cols,
+            rows: this.screen.rows,
+            env: { ...process.env, TERM: 'xterm-256color' },
+        });
+        this.process = child;
+        this.status = 'running';
+        this.onChange();
+        this.exitCode = undefined;
+        this.broadcast({ type: 'snapshot', data: '', cols: this.screen.cols, rows: this.screen.rows });
+        this.broadcast(this.state());
+        child.onData((data) => {
+            if (this.disposed)
+                return;
+            this.pending += data.length;
+            if (this.pending > 256 * 1024)
+                child.pause();
+            this.screen.write(data, () => {
+                if (this.disposed)
+                    return;
+                this.pending -= data.length;
+                this.broadcast({ type: 'output', data });
+                if (this.pending < 64 * 1024 && this.process === child)
+                    child.resume();
+            });
+        });
+        child.onExit(({ exitCode }) => {
+            if (this.disposed)
+                return;
+            this.process = undefined;
+            this.status = 'exited';
+            this.onChange();
+            this.exitCode = exitCode;
+            this.screen.write('', () => {
+                if (!this.disposed)
+                    this.broadcast(this.state());
+            });
+        });
+    }
+    dispose(code = 1001, reason = 'Server stopping') {
+        this.disposed = true;
+        this.process?.kill();
+        this.process = undefined;
+        for (const peer of this.peers)
+            peer.close(code, reason);
+        this.peers.clear();
+        this.sizes.clear();
+        this.screen.dispose();
+    }
+}

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

@@ -0,0 +1,80 @@
+import { WebSocket } from 'ws';
+import { SharedTerminal } from './terminal.js';
+export class SessionTerminals {
+    cwd;
+    shell;
+    items = new Map();
+    peers = new Set();
+    nextTitle = 1;
+    constructor(cwd, shell = process.env.SHELL || '/bin/sh') {
+        this.cwd = cwd;
+        this.shell = shell;
+        this.create('main');
+    }
+    get running() {
+        return [...this.items.values()].some((item) => item.terminal.running);
+    }
+    list() {
+        return [...this.items.values()].map(({ id, title, terminal }) => ({
+            id,
+            title,
+            status: terminal.lifecycle,
+        }));
+    }
+    create(id) {
+        if (id !== 'main' && !/^[a-f0-9-]{36}$/i.test(id))
+            throw new Error('Invalid terminal ID');
+        if (this.items.has(id))
+            return this.list().find((item) => item.id === id);
+        if (this.items.size >= 16)
+            throw new Error('This session has 16 terminals. Close an existing terminal first.');
+        const title = `Terminal ${this.nextTitle++}`;
+        const terminal = new SharedTerminal(this.cwd, this.shell, () => this.broadcast());
+        this.items.set(id, { id, title, terminal });
+        this.broadcast();
+        return { id, title, status: terminal.lifecycle };
+    }
+    close(id) {
+        const item = this.items.get(id);
+        if (!item)
+            return;
+        this.items.delete(id);
+        item.terminal.dispose(1008, 'Terminal closed');
+        this.broadcast();
+    }
+    attach(id, peer) {
+        const item = this.items.get(id);
+        if (!item) {
+            peer.close(1008, 'Terminal unavailable');
+            return;
+        }
+        item.terminal.attach(peer);
+    }
+    watch(peer) {
+        this.peers.add(peer);
+        this.send(peer);
+        peer.on('close', () => this.peers.delete(peer));
+        peer.on('error', () => this.peers.delete(peer));
+    }
+    send(peer) {
+        if (peer.readyState !== WebSocket.OPEN)
+            return;
+        if (peer.bufferedAmount > 1024 * 1024) {
+            peer.close(1013, 'Reconnect');
+            return;
+        }
+        peer.send(JSON.stringify({ type: 'terminals', terminals: this.list() }));
+    }
+    broadcast() {
+        for (const peer of this.peers)
+            this.send(peer);
+    }
+    dispose() {
+        for (const peer of this.peers)
+            peer.close(1001, 'Server stopping');
+        this.peers.clear();
+        for (const item of this.items.values())
+            item.terminal.dispose();
+        this.items.clear();
+    }
+}

package/dist/apps/server/src/tool-safety.js

@@ -0,0 +1,2 @@
+// Shared with the worker so automatic execution revalidates the same policy.
+export { classifyShellCommand } from '../../../packages/agent-pi/src/shell-policy.js';

package/dist/apps/server/src/workspace-lock.js

@@ -0,0 +1,140 @@
+import { createHash } from 'node:crypto';
+import { createConnection, createServer } from 'node:net';
+import { chmod, lstat, mkdir, rmdir, unlink } from 'node:fs/promises';
+function socketPath(canonicalCwd) {
+    const hash = createHash('sha256').update(canonicalCwd).digest('hex').slice(0, 20);
+    return `/tmp/presubmit-${process.getuid?.() ?? 'user'}-${hash}.sock`;
+}
+function probe(path) {
+    return new Promise((resolve, reject) => {
+        const socket = createConnection(path);
+        let content = '';
+        socket.setTimeout(1500, () => socket.destroy(new Error('Existing workspace server did not respond.')));
+        socket.on('data', (chunk) => {
+            content += String(chunk);
+            if (content.length > 4096)
+                socket.destroy(new Error('Invalid workspace lock response.'));
+        });
+        socket.on('error', reject);
+        socket.on('end', () => {
+            try {
+                const value = JSON.parse(content);
+                resolve({
+                    pid: typeof value.pid === 'number' ? value.pid : undefined,
+                    url: typeof value.url === 'string' ? value.url : undefined,
+                });
+            }
+            catch {
+                resolve({});
+            }
+        });
+    });
+}
+async function listen(server, path) {
+    await new Promise((resolve, reject) => {
+        const onError = (error) => {
+            server.off('listening', onListen);
+            reject(error);
+        };
+        const onListen = () => {
+            server.off('error', onError);
+            resolve();
+        };
+        server.once('error', onError);
+        server.once('listening', onListen);
+        server.listen(path);
+    });
+}
+export class WorkspaceAlreadyRunningError extends Error {
+    pid;
+    url;
+    constructor(pid, url) {
+        super(`Presubmit already owns this workspace${pid ? ` (PID ${pid})` : ''}.${url ? ` Open ${url}` : ' Wait for that server to finish starting, or stop it before starting another.'}`);
+        this.pid = pid;
+        this.url = url;
+        this.name = 'WorkspaceAlreadyRunningError';
+    }
+}
+function existing(value) {
+    return new WorkspaceAlreadyRunningError(value.pid, value.url);
+}
+/** A workspace-scoped Unix socket lock is independent of the selected data directory. */
+export async function acquireWorkspaceLock(canonicalCwd) {
+    if (process.platform === 'win32')
+        throw new Error('Workspace locking currently supports macOS and Linux.');
+    const path = socketPath(canonicalCwd);
+    let url;
+    const server = createServer((socket) => {
+        socket.on('error', () => { });
+        socket.end(JSON.stringify({ pid: process.pid, url }) + '\n');
+        socket.setTimeout(1500, () => socket.destroy());
+    });
+    try {
+        await listen(server, path);
+    }
+    catch (error) {
+        if (error.code !== 'EADDRINUSE')
+            throw new Error(`Cannot acquire workspace lock at ${path}: ${error.message}`);
+        try {
+            throw existing(await probe(path));
+        }
+        catch (probeError) {
+            if (probeError.code === 'ENOTSOCK')
+                throw new Error(`Refusing to remove non-socket workspace lock: ${path}`);
+            if (probeError.code !== 'ECONNREFUSED')
+                throw probeError;
+        }
+        // Serialize stale recovery. Without this, two contenders could unlink a newly bound socket.
+        const recovery = `${path}.recovery`;
+        try {
+            await mkdir(recovery, { mode: 0o700 });
+        }
+        catch (recoveryError) {
+            if (recoveryError.code === 'EEXIST')
+                throw new Error(`Another process is recovering the workspace lock. Retry shortly. If it crashed, remove the empty recovery directory ${recovery}.`);
+            throw recoveryError;
+        }
+        try {
+            // A prior contender may have bound since our first failed probe.
+            try {
+                throw existing(await probe(path));
+            }
+            catch (probeError) {
+                if (!['ECONNREFUSED', 'ENOENT'].includes(probeError.code ?? ''))
+                    throw probeError;
+            }
+            try {
+                const info = await lstat(path);
+                if (!info.isSocket())
+                    throw new Error(`Refusing to remove non-socket workspace lock: ${path}`);
+                await unlink(path);
+            }
+            catch (statError) {
+                if (statError.code !== 'ENOENT')
+                    throw statError;
+            }
+            // Rebind while holding recovery ownership; other contenders can only probe/retry.
+            await listen(server, path);
+        }
+        finally {
+            await rmdir(recovery);
+        }
+    }
+    try {
+        await chmod(path, 0o600);
+    }
+    catch (error) {
+        await new Promise((resolve) => server.close(() => resolve()));
+        throw error;
+    }
+    let released;
+    return {
+        setUrl(value) {
+            url = value;
+        },
+        release() {
+            released ??= new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+            return released;
+        },
+    };
+}

package/dist/apps/server/src/workspace-watcher.js

@@ -0,0 +1,65 @@
+import { realpathSync } from 'node:fs';
+import { watch } from 'chokidar';
+import { diagnosticsEnabled, performanceMetrics, diagnosticGauges } from './diagnostics.js';
+export function createWorkspaceWatchers(create = watch, debounceMs = 500) {
+    const entries = new Map();
+    const updateGauges = () => {
+        diagnosticGauges.set('workspace.watchers', entries.size);
+        diagnosticGauges.set('workspace.subscribers', [...entries.values()].reduce((sum, entry) => sum + entry.subscribers.size, 0));
+    };
+    return (cwd, subscriber) => {
+        const key = realpathSync(cwd);
+        let entry = entries.get(key);
+        if (!entry) {
+            const watcher = create(key, {
+                ignoreInitial: true,
+                ignored: (path) => path
+                    .split(/[\\/]/)
+                    .some((segment) => ['node_modules', '.git', 'dist', '.cache'].includes(segment)),
+            });
+            entry = { watcher, subscribers: new Set() };
+            entries.set(key, entry);
+            const shared = entry;
+            watcher.on('all', () => {
+                if (diagnosticsEnabled)
+                    performanceMetrics.count('workspace.fileEvents');
+                // Coalesce a sustained stream as well as a short burst. Do not allocate
+                // a fresh timer for every event or postpone refresh indefinitely.
+                if (shared.timer)
+                    return;
+                shared.timer = setTimeout(() => {
+                    shared.timer = undefined;
+                    if (diagnosticsEnabled)
+                        performanceMetrics.count('workspace.changeBatches');
+                    for (const listener of shared.subscribers)
+                        listener.changed();
+                }, debounceMs);
+            });
+            watcher.on('error', (error) => {
+                for (const listener of shared.subscribers)
+                    listener.error(error);
+            });
+        }
+        entry.subscribers.add(subscriber);
+        updateGauges();
+        const shared = entry;
+        let closed;
+        return {
+            close() {
+                if (closed)
+                    return closed;
+                shared.subscribers.delete(subscriber);
+                if (!shared.subscribers.size) {
+                    entries.delete(key);
+                    clearTimeout(shared.timer);
+                    closed = shared.watcher.close();
+                }
+                else
+                    closed = Promise.resolve();
+                updateGauges();
+                return closed;
+            },
+        };
+    };
+}
+export const watchWorkspace = createWorkspaceWatchers();