@wong2kim/wmux 1.0.0

package/src/main/pty/PTYManager.ts

@@ -0,0 +1,104 @@
+import * as pty from 'node-pty';
+import os from 'node:os';
+import { getPipeName, ENV_KEYS } from '../../shared/constants';
+
+export interface PTYInstance {
+  id: string;
+  process: pty.IPty;
+  shell: string;
+}
+
+export class PTYManager {
+  private instances = new Map<string, PTYInstance>();
+  private nextId = 0;
+  private _authToken: string | undefined;
+
+  setAuthToken(token: string): void {
+    this._authToken = token;
+  }
+
+  create(options?: {
+    shell?: string;
+    cwd?: string;
+    cols?: number;
+    rows?: number;
+    workspaceId?: string;
+    surfaceId?: string;
+    authToken?: string;
+  }): PTYInstance {
+    const id = `pty-${++this.nextId}`;
+    const shell = options?.shell || this.getDefaultShell();
+    const cwd = options?.cwd || os.homedir();
+
+    // Filter out ELECTRON_ variables to prevent leaking internal state to child processes
+    const env: Record<string, string> = {};
+    for (const [key, value] of Object.entries(globalThis.process.env)) {
+      if (value === undefined) continue;
+      if (key.startsWith('ELECTRON_')) continue;
+      env[key] = value;
+    }
+    env[ENV_KEYS.SOCKET_PATH] = getPipeName();
+    if (options?.workspaceId) env[ENV_KEYS.WORKSPACE_ID] = options.workspaceId;
+    if (options?.surfaceId) env[ENV_KEYS.SURFACE_ID] = options.surfaceId;
+    const authToken = options?.authToken || this._authToken;
+    if (authToken) env[ENV_KEYS.AUTH_TOKEN] = authToken;
+
+    const process = pty.spawn(shell, [], {
+      name: 'xterm-256color',
+      cols: options?.cols || 80,
+      rows: options?.rows || 24,
+      cwd,
+      env,
+      useConpty: true,
+    });
+
+    const instance: PTYInstance = { id, process, shell };
+    this.instances.set(id, instance);
+    return instance;
+  }
+
+  write(id: string, data: string): void {
+    const instance = this.instances.get(id);
+    if (instance) {
+      instance.process.write(data);
+    }
+  }
+
+  resize(id: string, cols: number, rows: number): void {
+    const instance = this.instances.get(id);
+    if (instance) {
+      instance.process.resize(cols, rows);
+    }
+  }
+
+  dispose(id: string): void {
+    const instance = this.instances.get(id);
+    if (instance) {
+      try { instance.process.kill(); } catch { /* already dead */ }
+      this.instances.delete(id);
+    }
+  }
+
+  /** Remove an entry from the map without killing — use when the process has already exited. */
+  remove(id: string): void {
+    this.instances.delete(id);
+  }
+
+  get(id: string): PTYInstance | undefined {
+    return this.instances.get(id);
+  }
+
+  disposeAll(): void {
+    for (const [id] of this.instances) {
+      this.dispose(id);
+    }
+  }
+
+  private getDefaultShell(): string {
+    if (process.platform === 'win32') {
+      // PowerShell 우선 (cd로 드라이브 전환 자동 지원)
+      return 'powershell.exe';
+    }
+    return process.env.SHELL || '/bin/bash';
+  }
+}

package/src/main/pty/ShellDetector.ts

@@ -0,0 +1,63 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export interface ShellInfo {
+  name: string;
+  path: string;
+  args?: string[];
+}
+
+export class ShellDetector {
+  detect(): ShellInfo[] {
+    const shells: ShellInfo[] = [];
+
+    // PowerShell 7+ (pwsh)
+    const pwshPaths = [
+      'C:\\Program Files\\PowerShell\\7\\pwsh.exe',
+      path.join(process.env.LOCALAPPDATA || '', 'Microsoft\\WindowsApps\\pwsh.exe'),
+    ];
+    for (const p of pwshPaths) {
+      if (fs.existsSync(p)) {
+        shells.push({ name: 'PowerShell 7', path: p });
+        break;
+      }
+    }
+
+    // Windows PowerShell 5.1
+    const ps5 = path.join(process.env.SystemRoot || 'C:\\Windows', 'System32\\WindowsPowerShell\\v1.0\\powershell.exe');
+    if (fs.existsSync(ps5)) {
+      shells.push({ name: 'Windows PowerShell', path: ps5 });
+    }
+
+    // Git Bash
+    const gitBashPaths = [
+      'C:\\Program Files\\Git\\bin\\bash.exe',
+      'C:\\Program Files (x86)\\Git\\bin\\bash.exe',
+    ];
+    for (const p of gitBashPaths) {
+      if (fs.existsSync(p)) {
+        shells.push({ name: 'Git Bash', path: p, args: ['--login', '-i'] });
+        break;
+      }
+    }
+
+    // WSL
+    const wslPath = path.join(process.env.SystemRoot || 'C:\\Windows', 'System32\\wsl.exe');
+    if (fs.existsSync(wslPath)) {
+      shells.push({ name: 'WSL', path: wslPath });
+    }
+
+    // cmd.exe
+    const cmd = process.env.COMSPEC || path.join(process.env.SystemRoot || 'C:\\Windows', 'System32\\cmd.exe');
+    if (fs.existsSync(cmd)) {
+      shells.push({ name: 'Command Prompt', path: cmd });
+    }
+
+    return shells;
+  }
+
+  getDefault(): string {
+    const shells = this.detect();
+    return shells.length > 0 ? shells[0].path : 'powershell.exe';
+  }
+}

package/src/main/session/SessionManager.ts

@@ -0,0 +1,53 @@
+import { app } from 'electron';
+import fs from 'node:fs';
+import path from 'node:path';
+import type { SessionData } from '../../shared/types';
+
+export class SessionManager {
+  private filePath: string;
+
+  constructor() {
+    this.filePath = path.join(app.getPath('userData'), 'session.json');
+  }
+
+  save(data: SessionData): void {
+    try {
+      const dir = path.dirname(this.filePath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(this.filePath, JSON.stringify(data, null, 2), 'utf-8');
+    } catch (err) {
+      console.error('Failed to save session:', err);
+    }
+  }
+
+  load(): SessionData | null {
+    try {
+      if (!fs.existsSync(this.filePath)) return null;
+      const raw = fs.readFileSync(this.filePath, 'utf-8');
+
+      // Guard against prototype pollution via JSON reviver
+      const parsed: unknown = JSON.parse(raw, (key, value) => {
+        if (key === '__proto__' || key === 'constructor' || key === 'prototype') return undefined;
+        return value;
+      });
+
+      // Basic schema validation
+      if (
+        typeof parsed !== 'object' ||
+        parsed === null ||
+        !Array.isArray((parsed as Record<string, unknown>)['workspaces']) ||
+        typeof (parsed as Record<string, unknown>)['activeWorkspaceId'] !== 'string'
+      ) {
+        console.warn('[SessionManager] Session file failed schema validation — discarding.');
+        return null;
+      }
+
+      return parsed as SessionData;
+    } catch (err) {
+      console.error('Failed to load session:', err);
+      return null;
+    }
+  }
+}

package/src/main/updater/AutoUpdater.ts

@@ -0,0 +1,132 @@
+/**
+ * AutoUpdater
+ *
+ * Electron 내장 autoUpdater API 기반 자동 업데이트 시스템.
+ *
+ * 실제 배포 환경에서는:
+ *   1. electron-forge squirrel maker로 빌드
+ *   2. GitHub Releases (또는 S3)에 업데이트 파일 업로드
+ *   3. FEED_URL을 업데이트 서버 주소로 변경
+ *
+ * 개발 환경에서는 autoUpdater가 지원되지 않으므로 모두 no-op 처리.
+ */
+
+import { autoUpdater, type BrowserWindow, ipcMain } from 'electron';
+import { IPC } from '../../shared/constants';
+
+// GitHub Releases 또는 별도 업데이트 서버 URL
+// 예: https://update.winmux.app/update/win32/${version}
+const FEED_URL = '';
+
+// 업데이트 자동 확인 간격 (30분)
+const CHECK_INTERVAL_MS = 30 * 60 * 1000;
+
+export class AutoUpdater {
+  private checkTimer: ReturnType<typeof setInterval> | null = null;
+  private getWindow: () => BrowserWindow | null;
+  private isChecking = false;
+
+  constructor(getWindow: () => BrowserWindow | null) {
+    this.getWindow = getWindow;
+  }
+
+  start(): void {
+    if (!FEED_URL || process.env.NODE_ENV === 'development') {
+      // 업데이트 서버가 설정되지 않았거나 개발 모드 — 초기화 스킵
+      this.registerIpcHandlers();
+      return;
+    }
+
+    try {
+      autoUpdater.setFeedURL({ url: FEED_URL });
+      this.setupAutoUpdaterEvents();
+      this.registerIpcHandlers();
+
+      // 앱 시작 후 15초 뒤 첫 번째 확인 (시작 부하 방지)
+      setTimeout(() => this.check(), 15_000);
+
+      // 이후 주기적 확인
+      this.checkTimer = setInterval(() => this.check(), CHECK_INTERVAL_MS);
+    } catch (err) {
+      console.warn('[AutoUpdater] Failed to initialize:', err);
+    }
+  }
+
+  stop(): void {
+    if (this.checkTimer !== null) {
+      clearInterval(this.checkTimer);
+      this.checkTimer = null;
+    }
+    // IPC 핸들러 정리
+    ipcMain.removeHandler(IPC.UPDATE_CHECK);
+    ipcMain.removeHandler(IPC.UPDATE_INSTALL);
+  }
+
+  private check(): void {
+    if (this.isChecking) return;
+    try {
+      this.isChecking = true;
+      autoUpdater.checkForUpdates();
+    } catch (err) {
+      console.warn('[AutoUpdater] checkForUpdates error:', err);
+      this.isChecking = false;
+    }
+  }
+
+  private setupAutoUpdaterEvents(): void {
+    autoUpdater.on('checking-for-update', () => {
+      this.sendToRenderer(IPC.UPDATE_CHECK, { status: 'checking' });
+    });
+
+    autoUpdater.on('update-available', () => {
+      this.isChecking = false;
+      this.sendToRenderer(IPC.UPDATE_AVAILABLE, { status: 'available' });
+    });
+
+    autoUpdater.on('update-not-available', () => {
+      this.isChecking = false;
+      this.sendToRenderer(IPC.UPDATE_NOT_AVAILABLE, { status: 'not-available' });
+    });
+
+    autoUpdater.on('error', (err: Error) => {
+      this.isChecking = false;
+      console.warn('[AutoUpdater] error:', err.message);
+      this.sendToRenderer(IPC.UPDATE_ERROR, { status: 'error', message: err.message });
+    });
+
+    autoUpdater.on('update-downloaded', (_event, releaseNotes, releaseName) => {
+      this.sendToRenderer(IPC.UPDATE_AVAILABLE, {
+        status: 'downloaded',
+        releaseName,
+        releaseNotes,
+      });
+    });
+  }
+
+  private registerIpcHandlers(): void {
+    // Renderer가 수동으로 업데이트 확인 요청
+    ipcMain.handle(IPC.UPDATE_CHECK, () => {
+      if (!FEED_URL || process.env.NODE_ENV === 'development') {
+        return { status: 'not-available' };
+      }
+      this.check();
+      return { status: 'checking' };
+    });
+
+    // Renderer가 "지금 설치" 요청 → 앱 재시작 후 업데이트 적용
+    ipcMain.handle(IPC.UPDATE_INSTALL, () => {
+      try {
+        autoUpdater.quitAndInstall();
+      } catch (err) {
+        console.warn('[AutoUpdater] quitAndInstall error:', err);
+      }
+    });
+  }
+
+  private sendToRenderer(channel: string, data: Record<string, unknown>): void {
+    const win = this.getWindow();
+    if (win && !win.isDestroyed()) {
+      win.webContents.send(channel, data);
+    }
+  }
+}

package/src/main/window/createWindow.ts

@@ -0,0 +1,71 @@
+import { BrowserWindow } from 'electron';
+import path from 'node:path';
+
+export function createWindow(): BrowserWindow {
+  const mainWindow = new BrowserWindow({
+    width: 1280,
+    height: 800,
+    minWidth: 800,
+    minHeight: 600,
+    title: 'wmux',
+    icon: path.join(__dirname, '../../assets/icon.ico'),
+    backgroundColor: '#1e1e2e',
+    webPreferences: {
+      preload: path.join(__dirname, 'preload.js'),
+      contextIsolation: true,
+      nodeIntegration: false,
+      webviewTag: true,
+    },
+  });
+
+  if (MAIN_WINDOW_VITE_DEV_SERVER_URL) {
+    mainWindow.loadURL(MAIN_WINDOW_VITE_DEV_SERVER_URL);
+  } else {
+    mainWindow.loadFile(
+      path.join(__dirname, `../renderer/${MAIN_WINDOW_VITE_NAME}/index.html`),
+    );
+  }
+
+  // CSP header — production only (dev needs full access for Vite HMR)
+  if (!MAIN_WINDOW_VITE_DEV_SERVER_URL) {
+    mainWindow.webContents.session.webRequest.onHeadersReceived((details, callback) => {
+      callback({
+        responseHeaders: {
+          ...details.responseHeaders,
+          'Content-Security-Policy': [
+            "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; connect-src 'self'",
+          ],
+        },
+      });
+    });
+  }
+
+  // Harden webview security: strip preload, enforce contextIsolation
+  mainWindow.webContents.on('will-attach-webview', (_event, webPreferences) => {
+    delete webPreferences.preload;
+    delete (webPreferences as Record<string, unknown>)['preloadURL'];
+    webPreferences.nodeIntegration = false;
+    webPreferences.contextIsolation = true;
+    webPreferences.sandbox = true;
+    // Ensure web security (same-origin policy) is not accidentally disabled
+    (webPreferences as Record<string, unknown>)['webSecurity'] = true;
+  });
+
+  // Block webview navigations to dangerous URL schemes
+  mainWindow.webContents.on('will-navigate', (event, url) => {
+    const normalized = url.trim().toLowerCase();
+    if (
+      normalized.startsWith('javascript:') ||
+      normalized.startsWith('vbscript:') ||
+      normalized.startsWith('data:')
+    ) {
+      event.preventDefault();
+    }
+  });
+
+  if (process.env.NODE_ENV === 'development') {
+    mainWindow.webContents.openDevTools();
+  }
+
+  return mainWindow;
+}

package/src/mcp/README.md

@@ -0,0 +1,56 @@
+# wmux MCP Server
+
+MCP server that lets Claude Code control wmux's browser and terminal.
+Supports multi-agent use — each agent can target its own browser via `surfaceId`.
+
+## Setup
+
+1. Build the MCP server:
+   ```bash
+   npm run build:mcp
+   ```
+
+2. Add to your project's `.mcp.json`:
+   ```json
+   {
+     "mcpServers": {
+       "wmux": {
+         "command": "node",
+         "args": ["<path-to-wmux>/dist/mcp/mcp/index.js"]
+       }
+     }
+   }
+   ```
+
+   `WMUX_SOCKET_PATH` and `WMUX_AUTH_TOKEN` are automatically set in wmux
+   terminal sessions. When running Claude Code inside wmux, no extra env
+   config is needed.
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `browser_navigate` | Navigate browser to URL |
+| `browser_snapshot` | Get page HTML |
+| `browser_click` | Click element by CSS selector |
+| `browser_fill` | Fill input by CSS selector |
+| `browser_eval` | Execute JS in browser |
+| `terminal_read` | Read terminal screen |
+| `terminal_send` | Send text to terminal |
+| `terminal_send_key` | Send key (enter, ctrl+c, etc.) |
+| `workspace_list` | List workspaces |
+| `surface_list` | List surfaces (terminals + browsers) |
+| `pane_list` | List panes |
+
+## Multi-Agent Usage
+
+All browser tools accept an optional `surfaceId` parameter. Use `surface_list`
+to discover available surfaces, then pass the browser surface's ID:
+
+```
+1. Call surface_list → find your browser surface ID
+2. Call browser_navigate with surfaceId="<your-browser-id>"
+3. Call browser_snapshot with surfaceId="<your-browser-id>"
+```
+
+When `surfaceId` is omitted, the currently active browser surface is used.

package/src/mcp/index.ts

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { sendRpc } from './wmux-client';
+import type { RpcMethod } from '../shared/rpc';
+
+const server = new McpServer({
+  name: 'wmux',
+  version: '1.0.0',
+});
+
+// Helper: wrap an RPC call as an MCP tool result
+async function callRpc(
+  method: RpcMethod,
+  params: Record<string, unknown> = {},
+): Promise<{ content: { type: 'text'; text: string }[] }> {
+  const result = await 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 = 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: 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: 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: 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: z.string().describe('CSS selector of the input element'),
+    text: 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: 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: 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: 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(): Promise<void> {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((err) => {
+  console.error('wmux MCP server failed to start:', err);
+  process.exit(1);
+});