@gricha/perry 0.0.1

package/dist/terminal/handler.js

@@ -0,0 +1,86 @@
+export class TerminalSession {
+    process = null;
+    terminal = null;
+    containerName;
+    user;
+    shell;
+    size;
+    onData = null;
+    onExit = null;
+    constructor(options) {
+        this.containerName = options.containerName;
+        this.user = options.user || 'workspace';
+        this.shell = options.shell || '/bin/bash';
+        this.size = options.size || { cols: 80, rows: 24 };
+    }
+    start() {
+        if (this.process) {
+            throw new Error('Terminal session already started');
+        }
+        const args = [
+            'exec',
+            '-it',
+            '-u',
+            this.user,
+            '-e',
+            `TERM=xterm-256color`,
+            this.containerName,
+            this.shell,
+            '-l',
+        ];
+        this.process = Bun.spawn(['docker', ...args], {
+            terminal: {
+                cols: this.size.cols,
+                rows: this.size.rows,
+                data: (_terminal, chunk) => {
+                    if (this.onData) {
+                        this.onData(Buffer.from(chunk));
+                    }
+                },
+            },
+        });
+        this.terminal = this.process.terminal;
+        this.process.exited.then((code) => {
+            this.process = null;
+            this.terminal = null;
+            if (this.onExit) {
+                this.onExit(code);
+            }
+        });
+    }
+    write(data) {
+        if (!this.terminal) {
+            return;
+        }
+        this.terminal.write(data.toString());
+    }
+    resize(size) {
+        this.size = size;
+        console.log('[terminal] Resize request:', size.cols, 'x', size.rows);
+        if (!this.terminal) {
+            console.log('[terminal] No terminal yet, storing size for later');
+            return;
+        }
+        this.terminal.resize(size.cols, size.rows);
+        console.log('[terminal] Resized terminal to', size.cols, 'x', size.rows);
+    }
+    setOnData(callback) {
+        this.onData = callback;
+    }
+    setOnExit(callback) {
+        this.onExit = callback;
+    }
+    kill() {
+        if (this.process) {
+            this.process.kill();
+            this.process = null;
+            this.terminal = null;
+        }
+    }
+    isRunning() {
+        return this.process !== null;
+    }
+}
+export function createTerminalSession(options) {
+    return new TerminalSession(options);
+}

package/dist/terminal/host-handler.js

@@ -0,0 +1,76 @@
+import { homedir } from 'os';
+export class HostTerminalSession {
+    process = null;
+    terminal = null;
+    shell;
+    size;
+    workDir;
+    onData = null;
+    onExit = null;
+    constructor(options = {}) {
+        this.shell = options.shell || process.env.SHELL || '/bin/bash';
+        this.size = options.size || { cols: 80, rows: 24 };
+        this.workDir = options.workDir || homedir();
+    }
+    start() {
+        if (this.process) {
+            throw new Error('Terminal session already started');
+        }
+        this.process = Bun.spawn([this.shell, '-l'], {
+            cwd: this.workDir,
+            env: {
+                ...process.env,
+                TERM: 'xterm-256color',
+            },
+            terminal: {
+                cols: this.size.cols,
+                rows: this.size.rows,
+                data: (_terminal, chunk) => {
+                    if (this.onData) {
+                        this.onData(Buffer.from(chunk));
+                    }
+                },
+            },
+        });
+        this.terminal = this.process.terminal;
+        this.process.exited.then((code) => {
+            this.process = null;
+            this.terminal = null;
+            if (this.onExit) {
+                this.onExit(code);
+            }
+        });
+    }
+    write(data) {
+        if (!this.terminal) {
+            return;
+        }
+        this.terminal.write(data.toString());
+    }
+    resize(size) {
+        this.size = size;
+        if (!this.terminal) {
+            return;
+        }
+        this.terminal.resize(size.cols, size.rows);
+    }
+    setOnData(callback) {
+        this.onData = callback;
+    }
+    setOnExit(callback) {
+        this.onExit = callback;
+    }
+    kill() {
+        if (this.process) {
+            this.process.kill();
+            this.process = null;
+            this.terminal = null;
+        }
+    }
+    isRunning() {
+        return this.process !== null;
+    }
+}
+export function createHostTerminalSession(options) {
+    return new HostTerminalSession(options);
+}

package/dist/terminal/index.js

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './handler';
+export * from './websocket';

package/dist/terminal/types.js

@@ -0,0 +1,8 @@
+export function isControlMessage(data) {
+    return (typeof data === 'object' &&
+        data !== null &&
+        'type' in data &&
+        data.type === 'resize' &&
+        typeof data.cols === 'number' &&
+        typeof data.rows === 'number');
+}

package/dist/terminal/websocket.js

@@ -0,0 +1,115 @@
+import { WebSocket } from 'ws';
+import { BaseWebSocketServer } from '../shared/base-websocket';
+import { createTerminalSession } from './handler';
+import { createHostTerminalSession } from './host-handler';
+import { isControlMessage } from './types';
+import { HOST_WORKSPACE_NAME } from '../shared/types';
+export class TerminalWebSocketServer extends BaseWebSocketServer {
+    getContainerName;
+    isHostAccessAllowed;
+    constructor(options) {
+        super({ isWorkspaceRunning: options.isWorkspaceRunning });
+        this.getContainerName = options.getContainerName;
+        this.isHostAccessAllowed = options.isHostAccessAllowed || (() => false);
+    }
+    handleConnection(ws, workspaceName) {
+        const isHostMode = workspaceName === HOST_WORKSPACE_NAME;
+        if (isHostMode && !this.isHostAccessAllowed()) {
+            ws.close(4003, 'Host access is disabled');
+            return;
+        }
+        let session = null;
+        let started = false;
+        const startSession = (cols, rows) => {
+            if (started)
+                return;
+            started = true;
+            if (isHostMode) {
+                session = createHostTerminalSession({
+                    size: { cols, rows },
+                });
+            }
+            else {
+                const containerName = this.getContainerName(workspaceName);
+                session = createTerminalSession({
+                    containerName,
+                    user: 'workspace',
+                    size: { cols, rows },
+                });
+            }
+            const connection = {
+                ws,
+                session,
+                workspaceName,
+            };
+            this.connections.set(ws, connection);
+            session.setOnData((data) => {
+                if (ws.readyState === WebSocket.OPEN) {
+                    ws.send(data);
+                }
+            });
+            session.setOnExit((code) => {
+                if (ws.readyState === WebSocket.OPEN) {
+                    ws.close(1000, `Process exited with code ${code}`);
+                }
+                this.connections.delete(ws);
+            });
+            try {
+                session.start();
+            }
+            catch (err) {
+                console.error('Failed to start terminal session:', err);
+                ws.close(1011, 'Failed to start terminal');
+                this.connections.delete(ws);
+            }
+        };
+        ws.on('message', (data) => {
+            const str = typeof data === 'string' ? data : data.toString();
+            if (str.startsWith('{')) {
+                try {
+                    const message = JSON.parse(str);
+                    if (isControlMessage(message)) {
+                        if (!started) {
+                            startSession(message.cols, message.rows);
+                        }
+                        else if (session) {
+                            session.resize({ cols: message.cols, rows: message.rows });
+                        }
+                        return;
+                    }
+                }
+                catch {
+                    // Not valid JSON control message, pass through as input
+                }
+            }
+            if (session) {
+                session.write(data);
+            }
+        });
+        ws.on('close', () => {
+            if (session) {
+                session.kill();
+            }
+            this.connections.delete(ws);
+        });
+        ws.on('error', (err) => {
+            console.error('WebSocket error:', err);
+            if (session) {
+                session.kill();
+            }
+            this.connections.delete(ws);
+        });
+    }
+    cleanupConnection(connection) {
+        connection.session.kill();
+    }
+    getConnectionsForWorkspace(workspaceName) {
+        let count = 0;
+        for (const conn of this.connections.values()) {
+            if (conn.workspaceName === workspaceName) {
+                count++;
+            }
+        }
+        return count;
+    }
+}

package/dist/workspace/index.js

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './state';
+export * from './manager';