@gricha/perry 0.2.5 → 0.3.0

package/dist/terminal/bun-handler.js

@@ -0,0 +1,151 @@
+import { createTerminalSession } from './handler';
+import { createHostTerminalSession } from './host-handler';
+import { isControlMessage } from './types';
+import { HOST_WORKSPACE_NAME } from '../shared/client-types';
+export class TerminalHandler {
+    connections = new Map();
+    getContainerName;
+    isHostAccessAllowed;
+    getPreferredShell;
+    constructor(options) {
+        this.getContainerName = options.getContainerName;
+        this.isHostAccessAllowed = options.isHostAccessAllowed || (() => false);
+        this.getPreferredShell = options.getPreferredShell || (() => undefined);
+    }
+    handleOpen(ws, workspaceName) {
+        const isHostMode = workspaceName === HOST_WORKSPACE_NAME;
+        if (isHostMode && !this.isHostAccessAllowed()) {
+            ws.close(4003, 'Host access is disabled');
+            return;
+        }
+        const connection = {
+            ws,
+            session: null,
+            workspaceName,
+            started: false,
+        };
+        this.connections.set(ws, connection);
+    }
+    handleMessage(ws, data) {
+        const connection = this.connections.get(ws);
+        if (!connection)
+            return;
+        if (data.startsWith('{')) {
+            try {
+                const message = JSON.parse(data);
+                if (isControlMessage(message)) {
+                    if (!connection.started) {
+                        this.startSession(connection, message.cols, message.rows);
+                    }
+                    else if (connection.session) {
+                        connection.session.resize({ cols: message.cols, rows: message.rows });
+                    }
+                    return;
+                }
+            }
+            catch {
+                // Not valid JSON control message, pass through as input
+            }
+        }
+        if (connection.session) {
+            connection.session.write(data);
+        }
+    }
+    handleClose(ws, _code, _reason) {
+        const connection = this.connections.get(ws);
+        if (connection?.session) {
+            connection.session.kill();
+        }
+        this.connections.delete(ws);
+    }
+    handleError(ws, error) {
+        console.error('WebSocket error:', error);
+        const connection = this.connections.get(ws);
+        if (connection?.session) {
+            connection.session.kill();
+        }
+        this.connections.delete(ws);
+    }
+    startSession(connection, cols, rows) {
+        if (connection.started)
+            return;
+        connection.started = true;
+        const { ws, workspaceName } = connection;
+        const isHostMode = workspaceName === HOST_WORKSPACE_NAME;
+        const preferredShell = this.getPreferredShell();
+        let session;
+        if (isHostMode) {
+            session = createHostTerminalSession({
+                size: { cols, rows },
+                shell: preferredShell,
+            });
+        }
+        else {
+            const containerName = this.getContainerName(workspaceName);
+            session = createTerminalSession({
+                containerName,
+                user: 'workspace',
+                size: { cols, rows },
+                shell: preferredShell,
+            });
+        }
+        connection.session = session;
+        session.setOnData((data) => {
+            try {
+                ws.send(data);
+            }
+            catch {
+                // WebSocket might be closed
+            }
+        });
+        session.setOnExit((code) => {
+            try {
+                ws.close(1000, `Process exited with code ${code}`);
+            }
+            catch {
+                // WebSocket might be closed
+            }
+            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);
+        }
+    }
+    getConnectionCount() {
+        return this.connections.size;
+    }
+    getConnectionsForWorkspace(workspaceName) {
+        let count = 0;
+        for (const conn of this.connections.values()) {
+            if (conn.workspaceName === workspaceName) {
+                count++;
+            }
+        }
+        return count;
+    }
+    closeConnectionsForWorkspace(workspaceName) {
+        for (const [ws, conn] of this.connections.entries()) {
+            if (conn.workspaceName === workspaceName) {
+                if (conn.session) {
+                    conn.session.kill();
+                }
+                ws.close(1001, 'Workspace stopped');
+                this.connections.delete(ws);
+            }
+        }
+    }
+    close() {
+        for (const [ws, conn] of this.connections.entries()) {
+            if (conn.session) {
+                conn.session.kill();
+            }
+            ws.close(1001, 'Server shutting down');
+        }
+        this.connections.clear();
+    }
+}

package/dist/terminal/handler.js

@@ -1,9 +1,25 @@
+import { spawnSync } from 'child_process';
 import { BaseTerminalSession } from './base-handler';
+function shellExistsInContainer(containerName, shell) {
+    const result = spawnSync('docker', ['exec', containerName, 'test', '-x', shell], {
+        timeout: 5000,
+    });
+    return result.status === 0;
+}
+function resolveShell(containerName, preferred) {
+    const fallback = '/bin/bash';
+    if (!preferred)
+        return fallback;
+    if (shellExistsInContainer(containerName, preferred))
+        return preferred;
+    return fallback;
+}
 export class TerminalSession extends BaseTerminalSession {
     containerName;
     user;
     constructor(options) {
-        super(options.shell || '/bin/bash', options.size);
+        const shell = resolveShell(options.containerName, options.shell);
+        super(shell, options.size);
         this.containerName = options.containerName;
         this.user = options.user || 'workspace';
     }

package/dist/terminal/host-handler.js

@@ -1,9 +1,27 @@
+import { accessSync, constants } from 'fs';
 import { BaseTerminalSession } from './base-handler';
 import { homedir } from 'os';
+function shellExistsOnHost(shell) {
+    try {
+        accessSync(shell, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function resolveHostShell(preferred) {
+    const fallback = '/bin/bash';
+    if (!preferred)
+        return process.env.SHELL || fallback;
+    if (shellExistsOnHost(preferred))
+        return preferred;
+    return process.env.SHELL || fallback;
+}
 export class HostTerminalSession extends BaseTerminalSession {
     workDir;
     constructor(options = {}) {
-        super(options.shell || process.env.SHELL || '/bin/bash', options.size);
+        super(resolveHostShell(options.shell), options.size);
         this.workDir = options.workDir || homedir();
     }
     getSpawnConfig() {

package/dist/terminal/websocket.js

@@ -7,10 +7,12 @@ import { HOST_WORKSPACE_NAME } from '../shared/client-types';
 export class TerminalWebSocketServer extends BaseWebSocketServer {
     getContainerName;
     isHostAccessAllowed;
+    getPreferredShell;
     constructor(options) {
         super({ isWorkspaceRunning: options.isWorkspaceRunning });
         this.getContainerName = options.getContainerName;
         this.isHostAccessAllowed = options.isHostAccessAllowed || (() => false);
+        this.getPreferredShell = options.getPreferredShell || (() => undefined);
     }
     handleConnection(ws, workspaceName) {
         const isHostMode = workspaceName === HOST_WORKSPACE_NAME;
@@ -24,9 +26,11 @@ export class TerminalWebSocketServer extends BaseWebSocketServer {
             if (started)
                 return;
             started = true;
+            const preferredShell = this.getPreferredShell();
             if (isHostMode) {
                 session = createHostTerminalSession({
                     size: { cols, rows },
+                    shell: preferredShell,
                 });
             }
             else {
@@ -35,6 +39,7 @@ export class TerminalWebSocketServer extends BaseWebSocketServer {
                     containerName,
                     user: 'workspace',
                     size: { cols, rows },
+                    shell: preferredShell,
                 });
             }
             const connection = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gricha/perry",
-  "version": "0.2.5",
+  "version": "0.3.0",
   "description": "Self-contained CLI for spinning up Docker-in-Docker development environments with SSH and proxy helpers.",
   "type": "module",
   "bin": {
@@ -18,8 +18,8 @@
     "test:web": "playwright test",
     "test:tui": "vitest run --config vitest.tui.config.js",
     "test:watch": "vitest",
-    "lint": "oxlint --deny-warnings src/",
-    "lint:fix": "oxlint --fix src/",
+    "lint": "oxlint --deny-warnings src/ mobile/src/",
+    "lint:fix": "oxlint --fix src/ mobile/src/",
     "format": "oxfmt --write src/ test/",
     "format:check": "oxfmt --check src/ test/",
     "check": "bun run lint && bun run format:check && bun x tsc --noEmit",