mob-coordinator 0.2.1

package/dist/server/server/ws-server.js

@@ -0,0 +1,197 @@
+import { WebSocketServer, WebSocket } from 'ws';
+import { validateLaunchPayload } from './util/sanitize.js';
+import { createLogger } from './util/logger.js';
+const log = createLogger('ws');
+export function createWsServer(server, instanceManager, ptyManager) {
+    const wss = new WebSocketServer({ server, path: '/mob-ws' });
+    let clientCount = 0;
+    log.info('WebSocket server created on path /mob-ws');
+    function broadcast(msg) {
+        const data = JSON.stringify(msg);
+        let sent = 0;
+        for (const client of wss.clients) {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(data);
+                sent++;
+            }
+        }
+        if (msg.type !== 'terminal:output') {
+            log.info(`Broadcast ${msg.type} to ${sent} client(s)`);
+        }
+    }
+    // Forward instance events to all clients
+    instanceManager.on('update', (info) => {
+        log.info(`Instance update: ${info.id} (${info.name}) state=${info.state}`);
+        broadcast({ type: 'instance:update', payload: info });
+    });
+    instanceManager.on('remove', (id) => {
+        log.info(`Instance removed: ${id}`);
+        broadcast({ type: 'instance:remove', payload: { instanceId: id } });
+    });
+    // Forward PTY data to subscribed clients
+    ptyManager.on('data', (instanceId, data) => {
+        const subs = instanceManager.subscribers.get(instanceId);
+        if (subs) {
+            const msg = JSON.stringify({
+                type: 'terminal:output',
+                payload: { instanceId, data },
+            });
+            for (const client of subs) {
+                if (client.readyState === WebSocket.OPEN) {
+                    client.send(msg);
+                }
+            }
+        }
+    });
+    instanceManager.on('pty:exit', (instanceId, exitCode) => {
+        log.info(`PTY exit: ${instanceId} code=${exitCode}`);
+        const subs = instanceManager.subscribers.get(instanceId);
+        if (subs) {
+            const msg = JSON.stringify({
+                type: 'terminal:exit',
+                payload: { instanceId, exitCode },
+            });
+            for (const client of subs) {
+                if (client.readyState === WebSocket.OPEN) {
+                    client.send(msg);
+                }
+            }
+        }
+    });
+    wss.on('connection', (ws, req) => {
+        clientCount++;
+        const clientId = clientCount;
+        log.info(`Client #${clientId} connected from ${req.socket.remoteAddress}`);
+        // Send current snapshot
+        const snapshot = instanceManager.getAll();
+        log.info(`Sending snapshot to #${clientId}: ${snapshot.length} instance(s)`);
+        ws.send(JSON.stringify({
+            type: 'snapshot',
+            payload: { instances: snapshot },
+        }));
+        ws.on('message', (raw) => {
+            let msg;
+            try {
+                msg = JSON.parse(raw.toString());
+            }
+            catch {
+                log.error(`Client #${clientId}: invalid JSON`);
+                ws.send(JSON.stringify({ type: 'error', payload: { message: 'Invalid JSON' } }));
+                return;
+            }
+            log.info(`Client #${clientId} → ${msg.type}`, msg.type === 'terminal:input' ? '(input data)' : ('payload' in msg ? msg.payload : ''));
+            switch (msg.type) {
+                case 'sync':
+                    ws.send(JSON.stringify({
+                        type: 'snapshot',
+                        payload: { instances: instanceManager.getAll() },
+                    }));
+                    break;
+                case 'launch': {
+                    const validation = validateLaunchPayload(msg.payload);
+                    if (!validation.valid) {
+                        log.warn(`Client #${clientId} launch rejected: ${validation.error}`);
+                        ws.send(JSON.stringify({
+                            type: 'error',
+                            payload: { message: validation.error },
+                        }));
+                        break;
+                    }
+                    log.info(`Client #${clientId} launching: cwd=${validation.data.cwd} name=${validation.data.name || '(auto)'}`);
+                    const info = instanceManager.launch(validation.data);
+                    log.info(`Launched instance ${info.id} (${info.name})`);
+                    // Auto-subscribe the launching client
+                    const subs = instanceManager.subscribers.get(info.id);
+                    if (subs)
+                        subs.add(ws);
+                    // Tell the launching client to select this instance
+                    ws.send(JSON.stringify({
+                        type: 'instance:select',
+                        payload: { instanceId: info.id },
+                    }));
+                    break;
+                }
+                case 'kill':
+                    log.info(`Client #${clientId} killing instance ${msg.payload.instanceId}`);
+                    instanceManager.kill(msg.payload.instanceId);
+                    break;
+                case 'resume': {
+                    log.info(`Client #${clientId} resuming instance ${msg.payload.instanceId}`);
+                    const resumed = instanceManager.resume(msg.payload.instanceId);
+                    if (resumed) {
+                        log.info(`Resumed as new instance ${resumed.id}`);
+                        const subs = instanceManager.subscribers.get(resumed.id);
+                        if (subs)
+                            subs.add(ws);
+                        ws.send(JSON.stringify({
+                            type: 'instance:select',
+                            payload: { instanceId: resumed.id },
+                        }));
+                    }
+                    else {
+                        ws.send(JSON.stringify({
+                            type: 'error',
+                            payload: { message: 'Cannot resume instance', context: msg.payload.instanceId },
+                        }));
+                    }
+                    break;
+                }
+                case 'dismiss':
+                    log.info(`Client #${clientId} dismissing instance ${msg.payload.instanceId}`);
+                    instanceManager.dismiss(msg.payload.instanceId);
+                    break;
+                case 'terminal:subscribe': {
+                    const { instanceId } = msg.payload;
+                    log.info(`Client #${clientId} subscribing to ${instanceId}`);
+                    // Only allow subscribing to existing instances
+                    if (!instanceManager.get(instanceId)) {
+                        log.warn(`Client #${clientId} tried to subscribe to non-existent instance ${instanceId}`);
+                        break;
+                    }
+                    let subs = instanceManager.subscribers.get(instanceId);
+                    if (!subs) {
+                        subs = new Set();
+                        instanceManager.subscribers.set(instanceId, subs);
+                    }
+                    subs.add(ws);
+                    // Send scrollback history
+                    const scrollback = instanceManager.getScrollback(instanceId);
+                    if (scrollback) {
+                        ws.send(JSON.stringify({
+                            type: 'terminal:scrollback',
+                            payload: { instanceId, data: scrollback },
+                        }));
+                    }
+                    break;
+                }
+                case 'terminal:unsubscribe': {
+                    const { instanceId } = msg.payload;
+                    instanceManager.subscribers.get(instanceId)?.delete(ws);
+                    break;
+                }
+                case 'terminal:input':
+                    ptyManager.write(msg.payload.instanceId, msg.payload.data);
+                    break;
+                case 'terminal:resize':
+                    ptyManager.resize(msg.payload.instanceId, msg.payload.cols, msg.payload.rows);
+                    break;
+                default:
+                    log.warn(`Client #${clientId}: unknown message type`);
+                    ws.send(JSON.stringify({
+                        type: 'error',
+                        payload: { message: `Unknown message type` },
+                    }));
+            }
+        });
+        ws.on('close', (code, reason) => {
+            log.info(`Client #${clientId} disconnected (code=${code})`);
+            for (const subs of instanceManager.subscribers.values()) {
+                subs.delete(ws);
+            }
+        });
+        ws.on('error', (err) => {
+            log.error(`Client #${clientId} error:`, err.message);
+        });
+    });
+    return wss;
+}

package/dist/server/shared/constants.js

@@ -0,0 +1,8 @@
+export const DEFAULT_PORT = 4040;
+export const STALE_THRESHOLD_MS = 30_000;
+export const WS_RECONNECT_BASE_MS = 1000;
+export const WS_RECONNECT_MAX_MS = 10_000;
+export const SCROLLBACK_MAX_BYTES = 512 * 1024;
+export const SCROLLBACK_FLUSH_MS = 2_000;
+export const SESSION_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+export const HOOK_SILENCE_THRESHOLD_MS = 15_000;

package/dist/server/shared/protocol.js

@@ -0,0 +1 @@
+export {};

package/dist/server/shared/settings.js

@@ -0,0 +1,54 @@
+export const DEFAULT_SETTINGS = {
+    shortcuts: {
+        launchDialog: 'Alt+KeyN',
+        toggleSidebar: 'Alt+KeyB',
+        cycleInstanceDown: 'Alt+ArrowDown',
+        cycleInstanceUp: 'Alt+ArrowUp',
+        jumpToInstance1: 'Mod+Digit1',
+        jumpToInstance2: 'Mod+Digit2',
+        jumpToInstance3: 'Mod+Digit3',
+        jumpToInstance4: 'Mod+Digit4',
+        jumpToInstance5: 'Mod+Digit5',
+        jumpToInstance6: 'Mod+Digit6',
+        jumpToInstance7: 'Mod+Digit7',
+        jumpToInstance8: 'Mod+Digit8',
+        jumpToInstance9: 'Mod+Digit9',
+        resumeInstance: 'Alt+KeyR',
+    },
+    launch: {
+        cwd: '',
+        model: '',
+        permissionMode: '',
+        autoName: true,
+    },
+    terminal: {
+        fontSize: 14,
+        cursorStyle: 'block',
+        scrollbackLines: 5000,
+    },
+    general: {
+        sidebarCollapsed: false,
+        maxCachedTerminals: 20,
+        staleThresholdSecs: 30,
+        notifications: true,
+    },
+    jira: {
+        baseUrl: '',
+        email: '',
+        apiToken: '',
+    },
+};
+/** Deep merge a partial settings object with defaults, ensuring all keys exist. */
+export function mergeWithDefaults(partial) {
+    const result = structuredClone(DEFAULT_SETTINGS);
+    for (const section of Object.keys(DEFAULT_SETTINGS)) {
+        if (partial[section] && typeof partial[section] === 'object') {
+            for (const key of Object.keys(DEFAULT_SETTINGS[section])) {
+                if (key in partial[section]) {
+                    result[section][key] = partial[section][key];
+                }
+            }
+        }
+    }
+    return result;
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "mob-coordinator",
+  "version": "0.2.1",
+  "description": "Local web dashboard for coordinating multiple Claude Code CLI sessions",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nickelbob/mob.git"
+  },
+  "keywords": ["claude", "claude-code", "ai", "terminal", "dashboard", "cli"],
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "mob": "./bin/mob.js"
+  },
+  "scripts": {
+    "dev": "concurrently \"tsx src/server/index.ts\" \"vite\"",
+    "build": "vite build && tsc -p tsconfig.node.json",
+    "start": "node dist/server/index.js",
+    "install-hooks": "tsx scripts/install-hooks.ts",
+    "uninstall-hooks": "tsx scripts/uninstall-hooks.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src/",
+    "format": "prettier --write 'src/**/*.{ts,svelte}'",
+    "format:check": "prettier --check 'src/**/*.{ts,svelte}'",
+    "setup": "node scripts/postinstall.cjs",
+    "predev": "node scripts/postinstall.cjs",
+    "prebuild": "node scripts/postinstall.cjs",
+    "postinstall": "node scripts/postinstall.cjs",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "scripts/postinstall.cjs",
+    "package.json",
+    "README.md"
+  ],
+  "dependencies": {
+    "@lydell/node-pty": "^1.0.0",
+    "chokidar": "^4.0.0",
+    "cors": "^2.8.5",
+    "express": "^4.21.0",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@sveltejs/vite-plugin-svelte": "^4.0.0",
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.5.0",
+    "concurrently": "^9.0.0",
+    "eslint": "^10.1.0",
+    "eslint-plugin-svelte": "^3.16.0",
+    "prettier": "^3.8.1",
+    "svelte": "^5.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.6.0",
+    "typescript-eslint": "^8.57.2",
+    "vite": "^5.0.0",
+    "vitest": "^4.1.2",
+    "xterm": "^5.3.0",
+    "xterm-addon-fit": "^0.8.0"
+  }
+}

package/scripts/postinstall.cjs

@@ -0,0 +1,68 @@
+// Checks for missing platform-specific native dependencies and installs them.
+// npm has a known bug (https://github.com/npm/cli/issues/4828) where optional
+// native binaries sometimes fail to install. This script runs after `npm install`
+// to detect and fix that.
+
+const { execSync } = require('child_process');
+const path = require('path');
+
+const toInstall = [];
+
+// Check @lydell/node-pty native binary
+const ptyPlatformPkg = `@lydell/node-pty-${process.platform}-${process.arch}`;
+try {
+  require.resolve(`${ptyPlatformPkg}/conpty.node`);
+} catch {
+  try {
+    // Get the version that @lydell/node-pty expects
+    const ptyPkg = require('@lydell/node-pty/package.json');
+    const version = ptyPkg.optionalDependencies?.[ptyPlatformPkg];
+    if (version) {
+      toInstall.push(`${ptyPlatformPkg}@${version}`);
+    }
+  } catch {
+    // @lydell/node-pty itself not installed yet, skip
+  }
+}
+
+// Check rollup native binary
+try {
+  require.resolve('rollup/dist/native.js');
+  // If it resolves, try actually loading it to see if the native module works
+  require('rollup/dist/native.js');
+} catch (e) {
+  if (e.message && e.message.includes('rollup')) {
+    try {
+      const rollupPkg = require('rollup/package.json');
+      const optDeps = rollupPkg.optionalDependencies || {};
+      // Find the matching native package for this platform+arch
+      // On Windows, prefer msvc over gnu
+      const candidates = Object.keys(optDeps).filter(k =>
+        k.startsWith('@rollup/rollup-') &&
+        k.includes(process.platform) &&
+        k.includes(process.arch)
+      );
+      const match = candidates.find(k => k.includes('msvc')) || candidates[0];
+      if (match) {
+        toInstall.push(`${match}@${optDeps[match]}`);
+      }
+    } catch {
+      // rollup itself not installed yet, skip
+    }
+  }
+}
+
+if (toInstall.length > 0) {
+  console.log(`\nInstalling missing native dependencies: ${toInstall.join(', ')}`);
+  try {
+    execSync(`npm install --no-save ${toInstall.join(' ')}`, {
+      stdio: 'inherit',
+      env: { ...process.env, npm_config_ignore_scripts: 'true' },
+    });
+    console.log('Native dependencies installed successfully.\n');
+  } catch (err) {
+    console.error('\nFailed to auto-install native dependencies.');
+    console.error('Try manually: npm install ' + toInstall.join(' '));
+    console.error('');
+  }
+}