@wong2kim/wmux 1.0.0

package/dist/mcp/mcp/index.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const zod_1 = require("zod");
+const wmux_client_1 = require("./wmux-client");
+const server = new mcp_js_1.McpServer({
+    name: 'wmux',
+    version: '1.0.0',
+});
+// Helper: wrap an RPC call as an MCP tool result
+async function callRpc(method, params = {}) {
+    const result = await (0, wmux_client_1.sendRpc)(method, params);
+    const text = typeof result === 'string' ? result : JSON.stringify(result, null, 2);
+    return { content: [{ type: 'text', text }] };
+}
+// Optional surfaceId schema used by browser and terminal tools
+const optionalSurfaceId = zod_1.z.string().optional().describe('Target a specific surface by ID. Omit to use the active surface.');
+// === Browser tools ===
+server.tool('browser_open', 'Open a new browser panel in the active pane. Use this when no browser surface exists yet.', {
+    url: zod_1.z.string().optional().describe('Initial URL to load (defaults to google.com)'),
+}, async ({ url }) => callRpc('browser.open', url ? { url } : {}));
+server.tool('browser_navigate', 'Navigate the wmux browser panel to a URL', {
+    url: zod_1.z.string().describe('The URL to navigate to'),
+    surfaceId: optionalSurfaceId,
+}, async ({ url, surfaceId }) => callRpc('browser.navigate', { url, ...(surfaceId && { surfaceId }) }));
+server.tool('browser_snapshot', 'Get the full HTML content of the current page in the wmux browser panel', { surfaceId: optionalSurfaceId }, async ({ surfaceId }) => callRpc('browser.snapshot', surfaceId ? { surfaceId } : {}));
+server.tool('browser_click', 'Click an element in the wmux browser panel by CSS selector', {
+    selector: zod_1.z.string().describe('CSS selector of the element to click'),
+    surfaceId: optionalSurfaceId,
+}, async ({ selector, surfaceId }) => callRpc('browser.click', { selector, ...(surfaceId && { surfaceId }) }));
+server.tool('browser_fill', 'Fill an input field in the wmux browser panel by CSS selector', {
+    selector: zod_1.z.string().describe('CSS selector of the input element'),
+    text: zod_1.z.string().describe('Text to fill into the input'),
+    surfaceId: optionalSurfaceId,
+}, async ({ selector, text, surfaceId }) => callRpc('browser.fill', { selector, text, ...(surfaceId && { surfaceId }) }));
+server.tool('browser_eval', 'Execute JavaScript in the wmux browser panel and return the result', {
+    code: zod_1.z.string().describe('JavaScript code to execute in the browser context'),
+    surfaceId: optionalSurfaceId,
+}, async ({ code, surfaceId }) => callRpc('browser.eval', { code, ...(surfaceId && { surfaceId }) }));
+// === Terminal tools ===
+server.tool('terminal_read', 'Read the current visible text from the active terminal in wmux', {}, async () => callRpc('input.readScreen'));
+server.tool('terminal_send', 'Send text to the active terminal in wmux', { text: zod_1.z.string().describe('Text to send to the terminal') }, async ({ text }) => callRpc('input.send', { text }));
+server.tool('terminal_send_key', 'Send a named key to the active terminal (enter, tab, ctrl+c, ctrl+d, ctrl+z, ctrl+l, escape, up, down, right, left)', {
+    key: zod_1.z.string().describe('Key name: enter, tab, ctrl+c, ctrl+d, ctrl+z, ctrl+l, escape, up, down, right, left'),
+}, async ({ key }) => callRpc('input.sendKey', { key }));
+// === Workspace tools ===
+server.tool('workspace_list', 'List all workspaces in wmux', {}, async () => callRpc('workspace.list'));
+server.tool('surface_list', 'List all surfaces (terminals and browsers) in the active workspace', {}, async () => callRpc('surface.list'));
+server.tool('pane_list', 'List all panes in the current workspace', {}, async () => callRpc('pane.list'));
+// === Start server ===
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((err) => {
+    console.error('wmux MCP server failed to start:', err);
+    process.exit(1);
+});

package/dist/mcp/mcp/wmux-client.js

@@ -0,0 +1,146 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendRpc = sendRpc;
+const net = __importStar(require("net"));
+const fs = __importStar(require("fs"));
+const crypto = __importStar(require("crypto"));
+const constants_1 = require("../shared/constants");
+const TIMEOUT_MS = 10000;
+const RETRY_COUNT = 3;
+const RETRY_DELAY_MS = 1000;
+function readAuthToken() {
+    // Env var takes priority (when running inside wmux terminal)
+    if (process.env.WMUX_AUTH_TOKEN)
+        return process.env.WMUX_AUTH_TOKEN;
+    // File fallback (when spawned by Claude Code as MCP server)
+    try {
+        return fs.readFileSync((0, constants_1.getAuthTokenPath)(), 'utf8').trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+function attemptRpc(pipePath, token, method, params) {
+    return new Promise((resolve, reject) => {
+        const id = crypto.randomUUID();
+        const request = JSON.stringify({ id, method, params, token }) + '\n';
+        const socket = net.connect(pipePath);
+        let buffer = '';
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                socket.destroy();
+                reject(new Error(`RPC timeout: ${method} (${TIMEOUT_MS}ms)`));
+            }
+        }, TIMEOUT_MS);
+        socket.on('connect', () => {
+            socket.write(request);
+        });
+        socket.on('data', (chunk) => {
+            buffer += chunk.toString('utf8');
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const response = JSON.parse(trimmed);
+                    if (response.id === id && !settled) {
+                        settled = true;
+                        clearTimeout(timer);
+                        socket.destroy();
+                        if (response.ok) {
+                            resolve(response.result);
+                        }
+                        else {
+                            reject(new Error(response.error));
+                        }
+                    }
+                }
+                catch {
+                    // ignore malformed lines
+                }
+            }
+        });
+        socket.on('error', (err) => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                if (err.code === 'ENOENT' || err.code === 'ECONNREFUSED') {
+                    reject(new Error('wmux is not running. Start the app first.'));
+                }
+                else {
+                    reject(new Error(`Connection error: ${err.message}`));
+                }
+            }
+        });
+        socket.on('close', () => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                reject(new Error('Connection closed before response was received.'));
+            }
+        });
+    });
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+async function sendRpc(method, params = {}) {
+    const pipePath = process.env.WMUX_SOCKET_PATH || (0, constants_1.getPipeName)();
+    for (let attempt = 0; attempt < RETRY_COUNT; attempt++) {
+        // Re-read token on every attempt (wmux may have restarted with new token)
+        const token = readAuthToken();
+        if (!token) {
+            throw new Error('wmux auth token not found. Is wmux running?');
+        }
+        try {
+            return await attemptRpc(pipePath, token, method, params);
+        }
+        catch (err) {
+            const msg = err.message;
+            const isRetryable = msg.includes('not running') || msg.includes('unauthorized');
+            if (isRetryable && attempt < RETRY_COUNT - 1) {
+                await sleep(RETRY_DELAY_MS);
+                continue;
+            }
+            throw err;
+        }
+    }
+    throw new Error('wmux is not running. Start the app first.');
+}

package/dist/mcp/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/mcp/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/mcp/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,
+    };
+}

package/forge.config.ts

@@ -0,0 +1,61 @@
+import type { ForgeConfig } from '@electron-forge/shared-types';
+import { MakerSquirrel } from '@electron-forge/maker-squirrel';
+import { MakerZIP } from '@electron-forge/maker-zip';
+import { VitePlugin } from '@electron-forge/plugin-vite';
+import { AutoUnpackNativesPlugin } from '@electron-forge/plugin-auto-unpack-natives';
+import { FusesPlugin } from '@electron-forge/plugin-fuses';
+import { FuseV1Options, FuseVersion } from '@electron/fuses';
+
+const config: ForgeConfig = {
+  packagerConfig: {
+    asar: true,
+    icon: './assets/icon',
+    extraResource: ['./dist/mcp'],
+  },
+  rebuildConfig: { disablePreGypRecuild: true },
+  hooks: {
+    // Skip native rebuild — pre-built binaries already in node_modules
+    readPackageJson: async (_config, packageJson) => {
+      packageJson.dependencies = packageJson.dependencies || {};
+      return packageJson;
+    },
+  },
+  makers: [
+    new MakerSquirrel({}),
+    new MakerZIP({}, ['darwin']),
+  ],
+  plugins: [
+    new AutoUnpackNativesPlugin({}),
+    new VitePlugin({
+      build: [
+        {
+          entry: 'src/main/index.ts',
+          config: 'vite.main.config.ts',
+          target: 'main',
+        },
+        {
+          entry: 'src/preload/preload.ts',
+          config: 'vite.preload.config.ts',
+          target: 'preload',
+        },
+      ],
+      renderer: [
+        {
+          name: 'main_window',
+          config: 'vite.renderer.config.ts',
+        },
+      ],
+    }),
+    new FusesPlugin({
+      version: FuseVersion.V1,
+      [FuseV1Options.RunAsNode]: false,
+      [FuseV1Options.EnableCookieEncryption]: true,
+      [FuseV1Options.EnableNodeOptionsEnvironmentVariable]: false,
+      [FuseV1Options.EnableNodeCliInspectArguments]: false,
+      [FuseV1Options.EnableEmbeddedAsarIntegrityValidation]: true,
+      [FuseV1Options.OnlyLoadAppFromAsar]: true,
+    }),
+  ],
+};
+
+export default config;

package/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>WinMux</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/renderer/index.tsx"></script>
+  </body>
+</html>

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "@wong2kim/wmux",
+  "productName": "wmux",
+  "version": "1.0.0",
+  "description": "AI Agent Terminal for Windows - Run Claude Code, Codex, Gemini CLI in parallel",
+  "main": ".vite/build/index.js",
+  "scripts": {
+    "start": "npm run build:mcp && electron-forge start",
+    "package": "npm run build:mcp && electron-forge package",
+    "make": "npm run build:mcp && electron-forge make",
+    "publish": "electron-forge publish",
+    "lint": "eslint --ext .ts,.tsx .",
+    "build:cli": "tsc -p tsconfig.cli.json",
+    "build:mcp": "tsc -p tsconfig.mcp.json",
+    "cli": "node dist/cli/cli/index.js",
+    "mcp": "node dist/mcp/mcp/index.js"
+  },
+  "bin": {
+    "wmux": "dist/cli/cli/index.js",
+    "wmux-mcp": "dist/mcp/mcp/index.js"
+  },
+  "keywords": ["terminal", "multiplexer", "electron", "ai", "claude", "agent", "windows", "pty", "mcp"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/openwong2kim/wmux.git"
+  },
+  "author": {
+    "name": "openwong2kim",
+    "email": "100856670+openwong2kim@users.noreply.github.com"
+  },
+  "license": "MIT",
+  "files": [
+    "dist/cli",
+    "dist/mcp",
+    "src",
+    "assets",
+    "index.html",
+    "forge.config.ts",
+    "vite.*.config.ts",
+    "tsconfig*.json",
+    "tailwind.config.js",
+    "postcss.config.js"
+  ],
+  "devDependencies": {
+    "@electron-forge/cli": "^7.11.1",
+    "@electron-forge/maker-deb": "^7.11.1",
+    "@electron-forge/maker-rpm": "^7.11.1",
+    "@electron-forge/maker-squirrel": "^7.11.1",
+    "@electron-forge/maker-zip": "^7.11.1",
+    "@electron-forge/plugin-auto-unpack-natives": "^7.11.1",
+    "@electron-forge/plugin-fuses": "^7.11.1",
+    "@electron-forge/plugin-vite": "^7.11.1",
+    "@electron/fuses": "^1.8.0",
+    "@types/electron-squirrel-startup": "^1.0.2",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@typescript-eslint/eslint-plugin": "^5.62.0",
+    "@typescript-eslint/parser": "^5.62.0",
+    "@vitejs/plugin-react": "^4.7.0",
+    "autoprefixer": "^10.4.27",
+    "electron": "41.0.3",
+    "eslint": "^8.57.1",
+    "eslint-plugin-import": "^2.32.0",
+    "postcss": "^8.5.8",
+    "tailwindcss": "^3.4.19",
+    "typescript": "^5.9.3",
+    "vite": "^5.4.21"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/addon-search": "^0.16.0",
+    "@xterm/addon-webgl": "^0.19.0",
+    "@xterm/xterm": "^6.0.0",
+    "electron-squirrel-startup": "^1.0.1",
+    "immer": "^11.1.4",
+    "node-pty": "^1.1.0",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "react-resizable-panels": "^4.7.3",
+    "zod": "^4.3.6",
+    "zustand": "^5.0.12"
+  }
+}

package/postcss.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+};

package/src/cli/client.ts

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import * as net from 'net';
+import * as crypto from 'crypto';
+import type { RpcRequest, RpcResponse, RpcMethod } from '../shared/rpc';
+
+const PIPE_NAME = process.env.WMUX_SOCKET_PATH || '\\\\.\\pipe\\wmux';
+const TIMEOUT_MS = 5000;
+
+export function sendRequest(
+  method: RpcMethod,
+  params: Record<string, unknown> = {}
+): Promise<RpcResponse> {
+  return new Promise((resolve, reject) => {
+    const id = crypto.randomUUID();
+    const token = process.env.WMUX_AUTH_TOKEN;
+    const request: RpcRequest = { id, method, params, token };
+
+    const socket = net.connect(PIPE_NAME);
+    let buffer = '';
+    let settled = false;
+
+    const timer = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        socket.destroy();
+        reject(new Error('Request timed out after 5 seconds.'));
+      }
+    }, TIMEOUT_MS);
+
+    socket.on('connect', () => {
+      socket.write(JSON.stringify(request) + '\n');
+    });
+
+    socket.on('data', (chunk: Buffer) => {
+      buffer += chunk.toString('utf8');
+      const lines = buffer.split('\n');
+      buffer = lines.pop() ?? '';
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const response = JSON.parse(trimmed) as RpcResponse;
+          if (response.id === id && !settled) {
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            resolve(response);
+          }
+        } catch {
+          // ignore malformed lines
+        }
+      }
+    });
+
+    socket.on('error', (err: NodeJS.ErrnoException) => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timer);
+        if (err.code === 'ENOENT' || err.code === 'ECONNREFUSED') {
+          reject(new Error('wmux is not running. Start the app first.'));
+        } else {
+          reject(new Error(`Connection error: ${err.message}`));
+        }
+      }
+    });
+
+    socket.on('close', () => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timer);
+        reject(new Error('Connection closed before response was received.'));
+      }
+    });
+  });
+}