@wong2kim/wmux 1.0.0

package/dist/cli/cli/commands/surface.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSurface = handleSurface;
+const client_1 = require("../client");
+const utils_1 = require("../utils");
+function formatSurfaceList(result) {
+    const list = result;
+    if (!Array.isArray(list) || list.length === 0) {
+        console.log('No surfaces found.');
+        return;
+    }
+    const maxId = Math.max(...list.map((s) => s.id.length));
+    const maxTitle = Math.max(...list.map((s) => (s.title ?? '').length), 5);
+    console.log('ID'.padEnd(maxId + 2) +
+        'TITLE'.padEnd(maxTitle + 2) +
+        'SHELL');
+    console.log('-'.repeat(maxId + maxTitle + 20));
+    for (const s of list) {
+        console.log(s.id.padEnd(maxId + 2) +
+            (s.title ?? '').padEnd(maxTitle + 2) +
+            (s.shell ?? ''));
+    }
+}
+async function handleSurface(cmd, args, jsonMode) {
+    let response;
+    switch (cmd) {
+        case 'list-surfaces': {
+            response = await (0, client_1.sendRequest)('surface.list', {});
+            if (jsonMode) {
+                (0, utils_1.printResult)(response);
+            }
+            else {
+                if (!response.ok) {
+                    (0, utils_1.printError)(response);
+                    return;
+                }
+                formatSurfaceList(response.result);
+            }
+            break;
+        }
+        case 'new-surface': {
+            response = await (0, client_1.sendRequest)('surface.new', {});
+            if (jsonMode) {
+                (0, utils_1.printResult)(response);
+            }
+            else {
+                if (!response.ok) {
+                    (0, utils_1.printError)(response);
+                    return;
+                }
+                const s = response.result;
+                console.log(`Created surface: ${s?.id ?? '(unknown)'}`);
+            }
+            break;
+        }
+        case 'focus-surface': {
+            const id = args[0];
+            if (!id) {
+                console.error('Error: focus-surface requires <id>');
+                process.exit(1);
+            }
+            response = await (0, client_1.sendRequest)('surface.focus', { id });
+            if (jsonMode) {
+                (0, utils_1.printResult)(response);
+            }
+            else {
+                if (!response.ok) {
+                    (0, utils_1.printError)(response);
+                    return;
+                }
+                console.log(`Focused surface: ${id}`);
+            }
+            break;
+        }
+        case 'close-surface': {
+            const id = args[0];
+            if (!id) {
+                console.error('Error: close-surface requires <id>');
+                process.exit(1);
+            }
+            response = await (0, client_1.sendRequest)('surface.close', { id });
+            if (jsonMode) {
+                (0, utils_1.printResult)(response);
+            }
+            else {
+                if (!response.ok) {
+                    (0, utils_1.printError)(response);
+                    return;
+                }
+                console.log(`Closed surface: ${id}`);
+            }
+            break;
+        }
+        default:
+            console.error(`Unknown surface command: ${cmd}`);
+            process.exit(1);
+    }
+}

package/dist/cli/cli/commands/system.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSystem = handleSystem;
+const client_1 = require("../client");
+const utils_1 = require("../utils");
+async function handleSystem(cmd, args, jsonMode) {
+    let response;
+    switch (cmd) {
+        case 'identify': {
+            response = await (0, client_1.sendRequest)('system.identify', {});
+            if (jsonMode) {
+                (0, utils_1.printResult)(response);
+            }
+            else {
+                if (!response.ok) {
+                    (0, utils_1.printError)(response);
+                    return;
+                }
+                const info = response.result;
+                console.log(`app:      ${info?.app ?? 'wmux'}`);
+                console.log(`version:  ${info?.version ?? '1.0.0'}`);
+                console.log(`platform: ${info?.platform ?? process.platform}`);
+            }
+            break;
+        }
+        case 'capabilities': {
+            response = await (0, client_1.sendRequest)('system.capabilities', {});
+            if (jsonMode) {
+                (0, utils_1.printResult)(response);
+            }
+            else {
+                if (!response.ok) {
+                    (0, utils_1.printError)(response);
+                    return;
+                }
+                // server may return { methods: string[] } or string[] directly
+                const result = response.result;
+                const methods = Array.isArray(result) ? result : (result?.methods || []);
+                if (methods.length > 0) {
+                    console.log('Supported RPC methods:');
+                    for (const m of methods) {
+                        console.log(`  ${m}`);
+                    }
+                }
+                else {
+                    console.log(JSON.stringify(response.result, null, 2));
+                }
+            }
+            break;
+        }
+        case 'set-status': {
+            const text = args[0];
+            if (text === undefined) {
+                console.error('Error: set-status requires <text>');
+                process.exit(1);
+            }
+            response = await (0, client_1.sendRequest)('meta.setStatus', { text });
+            if (jsonMode) {
+                (0, utils_1.printResult)(response);
+            }
+            else {
+                if (!response.ok) {
+                    (0, utils_1.printError)(response);
+                    return;
+                }
+                console.log(`Status set: "${text}"`);
+            }
+            break;
+        }
+        case 'set-progress': {
+            const raw = args[0];
+            if (raw === undefined) {
+                console.error('Error: set-progress requires <0-100>');
+                process.exit(1);
+            }
+            const value = Number(raw);
+            if (isNaN(value) || value < 0 || value > 100) {
+                console.error('Error: progress value must be a number between 0 and 100');
+                process.exit(1);
+            }
+            response = await (0, client_1.sendRequest)('meta.setProgress', { value });
+            if (jsonMode) {
+                (0, utils_1.printResult)(response);
+            }
+            else {
+                if (!response.ok) {
+                    (0, utils_1.printError)(response);
+                    return;
+                }
+                console.log(`Progress set: ${value}%`);
+            }
+            break;
+        }
+        default:
+            console.error(`Unknown system command: ${cmd}`);
+            process.exit(1);
+    }
+}

package/dist/cli/cli/commands/workspace.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleWorkspace = handleWorkspace;
+const client_1 = require("../client");
+const utils_1 = require("../utils");
+function formatWorkspaceList(result) {
+    const list = result;
+    if (!Array.isArray(list) || list.length === 0) {
+        console.log('No workspaces found.');
+        return;
+    }
+    const maxId = Math.max(...list.map((w) => w.id.length));
+    console.log('ID'.padEnd(maxId + 2) + 'NAME' + '    ' + 'STATUS');
+    console.log('-'.repeat(maxId + 30));
+    for (const ws of list) {
+        const active = ws.isActive ? ' (active)' : '';
+        console.log(ws.id.padEnd(maxId + 2) + ws.name + active);
+    }
+}
+function formatWorkspaceCurrent(result) {
+    const ws = result;
+    if (!ws) {
+        console.log('No active workspace.');
+        return;
+    }
+    console.log(`Current workspace: ${ws.name} (${ws.id})`);
+}
+async function handleWorkspace(cmd, args, jsonMode) {
+    let response;
+    switch (cmd) {
+        case 'list-workspaces': {
+            response = await (0, client_1.sendRequest)('workspace.list', {});
+            if (jsonMode) {
+                (0, utils_1.printResult)(response);
+            }
+            else {
+                if (!response.ok) {
+                    (0, utils_1.printError)(response);
+                    return;
+                }
+                formatWorkspaceList(response.result);
+            }
+            break;
+        }
+        case 'new-workspace': {
+            const name = (0, utils_1.parseFlag)(args, '--name') ?? `workspace-${Date.now()}`;
+            response = await (0, client_1.sendRequest)('workspace.new', { name });
+            if (jsonMode) {
+                (0, utils_1.printResult)(response);
+            }
+            else {
+                if (!response.ok) {
+                    (0, utils_1.printError)(response);
+                    return;
+                }
+                const ws = response.result;
+                console.log(`Created workspace: ${ws?.name ?? name} (${ws?.id ?? ''})`);
+            }
+            break;
+        }
+        case 'focus-workspace': {
+            const id = args[0];
+            if (!id) {
+                console.error('Error: focus-workspace requires <id>');
+                process.exit(1);
+            }
+            response = await (0, client_1.sendRequest)('workspace.focus', { id });
+            if (jsonMode) {
+                (0, utils_1.printResult)(response);
+            }
+            else {
+                if (!response.ok) {
+                    (0, utils_1.printError)(response);
+                    return;
+                }
+                console.log(`Focused workspace: ${id}`);
+            }
+            break;
+        }
+        case 'close-workspace': {
+            const id = args[0];
+            if (!id) {
+                console.error('Error: close-workspace requires <id>');
+                process.exit(1);
+            }
+            response = await (0, client_1.sendRequest)('workspace.close', { id });
+            if (jsonMode) {
+                (0, utils_1.printResult)(response);
+            }
+            else {
+                if (!response.ok) {
+                    (0, utils_1.printError)(response);
+                    return;
+                }
+                console.log(`Closed workspace: ${id}`);
+            }
+            break;
+        }
+        case 'current-workspace': {
+            response = await (0, client_1.sendRequest)('workspace.current', {});
+            if (jsonMode) {
+                (0, utils_1.printResult)(response);
+            }
+            else {
+                if (!response.ok) {
+                    (0, utils_1.printError)(response);
+                    return;
+                }
+                formatWorkspaceCurrent(response.result);
+            }
+            break;
+        }
+        default:
+            console.error(`Unknown workspace command: ${cmd}`);
+            process.exit(1);
+    }
+}

package/dist/cli/cli/index.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+process.on('SIGINT', () => {
+    process.exit(130);
+});
+const utils_1 = require("./utils");
+const workspace_1 = require("./commands/workspace");
+const surface_1 = require("./commands/surface");
+const pane_1 = require("./commands/pane");
+const input_1 = require("./commands/input");
+const notify_1 = require("./commands/notify");
+const system_1 = require("./commands/system");
+const browser_1 = require("./commands/browser");
+const HELP_TEXT = `
+wmux CLI
+
+USAGE
+  wmux <command> [options]
+
+WORKSPACE COMMANDS
+  list-workspaces                   List all workspaces
+  new-workspace [--name <name>]     Create a new workspace
+  focus-workspace <id>              Focus a workspace by ID
+  close-workspace <id>              Close a workspace by ID
+  current-workspace                 Show the active workspace
+
+SURFACE COMMANDS
+  list-surfaces                     List all surfaces in the active workspace
+  new-surface                       Open a new surface (terminal tab)
+  focus-surface <id>                Focus a surface by ID
+  close-surface <id>                Close a surface by ID
+
+PANE COMMANDS
+  list-panes                        List all panes in the active workspace
+  focus-pane <id>                   Focus a pane by ID
+  split [--direction right|down]    Split the active pane (default: right)
+
+INPUT COMMANDS
+  send <text>                       Send text to the active terminal
+  send-key <keystroke>              Send a key (e.g. Enter, ctrl-c, Tab)
+  read-screen                       Read the current terminal screen content
+
+NOTIFICATION COMMANDS
+  notify --title <title> --body <body>   Show a notification in wmux
+
+SYSTEM COMMANDS
+  set-status <text>                 Set a status message on the active workspace
+  set-progress <0-100>              Set a progress value on the active workspace
+  identify                          Show wmux app info
+  capabilities                      List all supported RPC methods
+
+BROWSER COMMANDS
+  browser snapshot                  Return the full page HTML of the active browser surface
+  browser click <selector>          Click an element by CSS selector
+  browser fill <selector> <text>    Fill an input field by CSS selector
+  browser eval <code>               Execute JavaScript in the browser context
+  browser navigate <url>            Navigate the browser surface to a URL
+
+GLOBAL FLAGS
+  --json      Output raw JSON (useful for scripting)
+  --help      Show this help text
+
+EXAMPLES
+  wmux list-workspaces
+  wmux new-workspace --name dev
+  wmux send "echo hello"
+  wmux notify --title "Done" --body "Build finished"
+  wmux identify --json
+  wmux browser snapshot
+  wmux browser navigate "https://example.com"
+  wmux browser click "#login-btn"
+`.trimStart();
+const WORKSPACE_CMDS = new Set([
+    'list-workspaces',
+    'new-workspace',
+    'focus-workspace',
+    'close-workspace',
+    'current-workspace',
+]);
+const SURFACE_CMDS = new Set([
+    'list-surfaces',
+    'new-surface',
+    'focus-surface',
+    'close-surface',
+]);
+const PANE_CMDS = new Set(['list-panes', 'focus-pane', 'split']);
+const INPUT_CMDS = new Set(['send', 'send-key', 'read-screen']);
+const SYSTEM_CMDS = new Set([
+    'identify',
+    'capabilities',
+    'set-status',
+    'set-progress',
+]);
+async function main() {
+    // process.argv = ['node', 'index.js', ...userArgs]
+    const argv = process.argv.slice(2);
+    if (argv.length === 0 || (0, utils_1.hasFlag)(argv, '--help') || (0, utils_1.hasFlag)(argv, '-h')) {
+        process.stdout.write(HELP_TEXT);
+        process.exit(0);
+    }
+    const jsonMode = (0, utils_1.hasFlag)(argv, '--json');
+    // Strip global flags so commands see clean args
+    const args = argv.filter((a) => a !== '--json' && a !== '--help' && a !== '-h');
+    const cmd = args[0];
+    const rest = args.slice(1);
+    try {
+        if (WORKSPACE_CMDS.has(cmd)) {
+            await (0, workspace_1.handleWorkspace)(cmd, rest, jsonMode);
+        }
+        else if (SURFACE_CMDS.has(cmd)) {
+            await (0, surface_1.handleSurface)(cmd, rest, jsonMode);
+        }
+        else if (PANE_CMDS.has(cmd)) {
+            await (0, pane_1.handlePane)(cmd, rest, jsonMode);
+        }
+        else if (INPUT_CMDS.has(cmd)) {
+            await (0, input_1.handleInput)(cmd, rest, jsonMode);
+        }
+        else if (cmd === 'notify') {
+            await (0, notify_1.handleNotify)(rest, jsonMode);
+        }
+        else if (SYSTEM_CMDS.has(cmd)) {
+            await (0, system_1.handleSystem)(cmd, rest, jsonMode);
+        }
+        else if (cmd === 'browser') {
+            await (0, browser_1.handleBrowser)(rest, jsonMode);
+        }
+        else {
+            console.error(`Unknown command: "${cmd}". Run 'wmux --help' for usage.`);
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(message);
+        process.exit(1);
+    }
+}
+main();

package/dist/cli/cli/utils.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printResult = printResult;
+exports.printError = printError;
+exports.parseFlag = parseFlag;
+exports.hasFlag = hasFlag;
+/**
+ * Print the result field of a successful RPC response as JSON.
+ * If the response contains an error, the error is printed to stderr and
+ * the process exits with code 1.
+ */
+function printResult(response) {
+    if (!response.ok) {
+        printError(response);
+        return;
+    }
+    console.log(JSON.stringify(response.result, null, 2));
+}
+/**
+ * Print the error field of a failed RPC response to stderr and exit with 1.
+ */
+function printError(response) {
+    const msg = !response.ok ? response.error : 'Unknown error from wmux';
+    console.error(`Error: ${msg}`);
+    process.exit(1);
+}
+/**
+ * Parse a named flag value from an argv array.
+ * e.g. parseFlag(['--name', 'dev'], '--name') => 'dev'
+ * Returns undefined when the flag is not present.
+ */
+function parseFlag(args, flag) {
+    const idx = args.indexOf(flag);
+    if (idx === -1)
+        return undefined;
+    const value = args[idx + 1];
+    if (value === undefined || value.startsWith('-'))
+        return undefined;
+    return value;
+}
+/**
+ * Check whether a bare flag is present in argv.
+ * e.g. hasFlag(['--json', 'identify'], '--json') => true
+ */
+function hasFlag(args, flag) {
+    return args.includes(flag);
+}

package/dist/cli/shared/constants.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENV_KEYS = exports.PIPE_NAME = exports.IPC = void 0;
+exports.getPipeName = getPipeName;
+exports.getAuthTokenPath = getAuthTokenPath;
+// IPC Channel names
+exports.IPC = {
+    PTY_CREATE: 'pty:create',
+    PTY_WRITE: 'pty:write',
+    PTY_RESIZE: 'pty:resize',
+    PTY_DISPOSE: 'pty:dispose',
+    PTY_DATA: 'pty:data',
+    PTY_EXIT: 'pty:exit',
+    SHELL_LIST: 'shell:list',
+    SESSION_SAVE: 'session:save',
+    SESSION_LOAD: 'session:load',
+    NOTIFICATION: 'notification:new',
+    CWD_CHANGED: 'notification:cwd-changed',
+    METADATA_UPDATE: 'metadata:update',
+    METADATA_REQUEST: 'metadata:request',
+    // Phase 3: RPC bridge (Main ↔ Renderer)
+    RPC_COMMAND: 'rpc:command',
+    RPC_RESPONSE: 'rpc:response',
+    // Clipboard (main process bridge)
+    CLIPBOARD_WRITE: 'clipboard:write',
+    CLIPBOARD_READ: 'clipboard:read',
+    // Phase 4: Auto updater
+    UPDATE_CHECK: 'update:check',
+    UPDATE_AVAILABLE: 'update:available',
+    UPDATE_NOT_AVAILABLE: 'update:not-available',
+    UPDATE_ERROR: 'update:error',
+    UPDATE_DOWNLOAD: 'update:download',
+    UPDATE_INSTALL: 'update:install',
+    // Settings sync (renderer → main)
+    TOAST_ENABLED: 'settings:toast-enabled',
+};
+// Named Pipe path for wmux API
+// Fixed name so MCP clients (e.g. Claude Code) can reconnect across wmux restarts
+exports.PIPE_NAME = '\\\\.\\pipe\\wmux';
+function getPipeName() {
+    return exports.PIPE_NAME;
+}
+// Environment variable names injected into PTY sessions
+exports.ENV_KEYS = {
+    WORKSPACE_ID: 'WMUX_WORKSPACE_ID',
+    SURFACE_ID: 'WMUX_SURFACE_ID',
+    SOCKET_PATH: 'WMUX_SOCKET_PATH',
+    AUTH_TOKEN: 'WMUX_AUTH_TOKEN',
+};
+// Auth token file path — written by wmux main process, read by MCP server
+function getAuthTokenPath() {
+    const home = process.env.USERPROFILE || process.env.HOME || '';
+    return `${home}/.wmux-auth-token`;
+}

package/dist/cli/shared/rpc.js

@@ -0,0 +1,33 @@
+"use strict";
+// === JSON-RPC Protocol Types ===
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_RPC_METHODS = void 0;
+// All available methods as array (for system.capabilities)
+exports.ALL_RPC_METHODS = [
+    'workspace.list',
+    'workspace.new',
+    'workspace.focus',
+    'workspace.close',
+    'workspace.current',
+    'surface.list',
+    'surface.new',
+    'surface.focus',
+    'surface.close',
+    'pane.list',
+    'pane.focus',
+    'pane.split',
+    'input.send',
+    'input.sendKey',
+    'input.readScreen',
+    'notify',
+    'meta.setStatus',
+    'meta.setProgress',
+    'system.identify',
+    'system.capabilities',
+    'browser.open',
+    'browser.snapshot',
+    'browser.click',
+    'browser.fill',
+    'browser.eval',
+    'browser.navigate',
+];

package/dist/cli/shared/types.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateId = generateId;
+exports.sanitizePtyText = sanitizePtyText;
+exports.validateName = validateName;
+exports.validateMessage = validateMessage;
+exports.createSurface = createSurface;
+exports.createLeafPane = createLeafPane;
+exports.createWorkspace = createWorkspace;
+// === Utility: generate unique IDs ===
+function generateId(prefix) {
+    return `${prefix}-${crypto.randomUUID()}`;
+}
+// === Security: sanitize text before PTY write ===
+/**
+ * Strips control characters (\r, \n, \x00-\x1f except \t) from text
+ * that will be written to a PTY, preventing embedded command injection.
+ */
+function sanitizePtyText(text) {
+    // Remove all control chars except tab (\x09)
+    // eslint-disable-next-line no-control-regex
+    return text.replace(/[\x00-\x08\x0a-\x1f\x7f\u0080-\u009f]/g, '');
+}
+/**
+ * Validates and clamps a user-supplied name string.
+ * Returns the trimmed string if valid, or throws if invalid.
+ */
+function validateName(value, label, maxLength = 100) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new Error(`${label} must not be empty`);
+    }
+    if (trimmed.length > maxLength) {
+        throw new Error(`${label} must be ${maxLength} characters or fewer`);
+    }
+    return trimmed;
+}
+/**
+ * Validates a message body string.
+ * Returns the trimmed string if valid, or throws if invalid.
+ */
+function validateMessage(value, maxLength = 10000) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new Error('Message must not be empty');
+    }
+    if (trimmed.length > maxLength) {
+        throw new Error(`Message must be ${maxLength} characters or fewer`);
+    }
+    return trimmed;
+}
+// === Factory functions ===
+function createSurface(ptyId, shell, cwd) {
+    return {
+        id: generateId('surface'),
+        ptyId,
+        title: shell,
+        shell,
+        cwd,
+    };
+}
+function createLeafPane(surface) {
+    const surfaces = surface ? [surface] : [];
+    return {
+        id: generateId('pane'),
+        type: 'leaf',
+        surfaces,
+        activeSurfaceId: surfaces[0]?.id || '',
+    };
+}
+function createWorkspace(name) {
+    const rootPane = createLeafPane();
+    return {
+        id: generateId('ws'),
+        name,
+        rootPane,
+        activePaneId: rootPane.id,
+    };
+}