@wong2kim/wmux 1.0.0 → 1.0.1

package/src/main/updater/AutoUpdater.ts

@@ -1,132 +0,0 @@
-/**
- * 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

@@ -1,71 +0,0 @@
-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

@@ -1,56 +0,0 @@
-# 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

@@ -1,153 +0,0 @@
-#!/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);
-});

package/src/mcp/wmux-client.ts

@@ -1,127 +0,0 @@
-import * as net from 'net';
-import * as fs from 'fs';
-import * as crypto from 'crypto';
-import type { RpcMethod, RpcResponse } from '../shared/rpc';
-import { getPipeName, getAuthTokenPath } from '../shared/constants';
-
-const TIMEOUT_MS = 10000;
-const RETRY_COUNT = 3;
-const RETRY_DELAY_MS = 1000;
-
-function readAuthToken(): string | undefined {
-  // 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(getAuthTokenPath(), 'utf8').trim();
-  } catch {
-    return undefined;
-  }
-}
-
-function attemptRpc(
-  pipePath: string,
-  token: string,
-  method: RpcMethod,
-  params: Record<string, unknown>,
-): Promise<unknown> {
-  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) => {
-      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();
-            if (response.ok) {
-              resolve(response.result);
-            } else {
-              reject(new Error(response.error));
-            }
-          }
-        } 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.'));
-      }
-    });
-  });
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((r) => setTimeout(r, ms));
-}
-
-export async function sendRpc(
-  method: RpcMethod,
-  params: Record<string, unknown> = {},
-): Promise<unknown> {
-  const pipePath = process.env.WMUX_SOCKET_PATH || 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 as Error).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/src/preload/index.ts

@@ -1,111 +0,0 @@
-import { contextBridge, ipcRenderer } from 'electron';
-import { IPC } from '../shared/constants';
-
-const electronAPI = {
-  pty: {
-    create: (options?: { shell?: string; cwd?: string; cols?: number; rows?: number }) =>
-      ipcRenderer.invoke(IPC.PTY_CREATE, options),
-    write: (id: string, data: string) =>
-      ipcRenderer.invoke(IPC.PTY_WRITE, id, data),
-    resize: (id: string, cols: number, rows: number) =>
-      ipcRenderer.invoke(IPC.PTY_RESIZE, id, cols, rows),
-    dispose: (id: string) =>
-      ipcRenderer.invoke(IPC.PTY_DISPOSE, id),
-    onData: (callback: (id: string, data: string) => void) => {
-      const listener = (_event: Electron.IpcRendererEvent, id: string, data: string) => callback(id, data);
-      ipcRenderer.on(IPC.PTY_DATA, listener);
-      return () => { ipcRenderer.removeListener(IPC.PTY_DATA, listener); };
-    },
-    onExit: (callback: (id: string, exitCode: number) => void) => {
-      const listener = (_event: Electron.IpcRendererEvent, id: string, exitCode: number) => callback(id, exitCode);
-      ipcRenderer.on(IPC.PTY_EXIT, listener);
-      return () => { ipcRenderer.removeListener(IPC.PTY_EXIT, listener); };
-    },
-  },
-  shell: {
-    list: () => ipcRenderer.invoke(IPC.SHELL_LIST) as Promise<{ name: string; path: string; args?: string[] }[]>,
-  },
-  session: {
-    save: (data: unknown) => ipcRenderer.invoke(IPC.SESSION_SAVE, data),
-    load: () => ipcRenderer.invoke(IPC.SESSION_LOAD),
-  },
-  settings: {
-    setToastEnabled: (enabled: boolean) => ipcRenderer.send(IPC.TOAST_ENABLED, enabled),
-  },
-  notification: {
-    onNew: (callback: (ptyId: string, data: { type: string; title: string; body: string }) => void) => {
-      const listener = (_event: Electron.IpcRendererEvent, ptyId: string, data: { type: string; title: string; body: string }) =>
-        callback(ptyId, data);
-      ipcRenderer.on(IPC.NOTIFICATION, listener);
-      return () => { ipcRenderer.removeListener(IPC.NOTIFICATION, listener); };
-    },
-    onCwdChanged: (callback: (ptyId: string, cwd: string) => void) => {
-      const listener = (_event: Electron.IpcRendererEvent, ptyId: string, cwd: string) =>
-        callback(ptyId, cwd);
-      ipcRenderer.on(IPC.CWD_CHANGED, listener);
-      return () => { ipcRenderer.removeListener(IPC.CWD_CHANGED, listener); };
-    },
-  },
-  metadata: {
-    request: (ptyId: string) =>
-      ipcRenderer.invoke(IPC.METADATA_REQUEST, ptyId),
-    onUpdate: (callback: (ptyId: string, data: { gitBranch?: string; cwd?: string; listeningPorts?: number[] }) => void) => {
-      const listener = (_event: Electron.IpcRendererEvent, ptyId: string, data: { gitBranch?: string; cwd?: string; listeningPorts?: number[] }) =>
-        callback(ptyId, data);
-      ipcRenderer.on(IPC.METADATA_UPDATE, listener);
-      return () => { ipcRenderer.removeListener(IPC.METADATA_UPDATE, listener); };
-    },
-  },
-  rpc: {
-    onCommand: (
-      callback: (requestId: string, method: string, params: Record<string, unknown>) => void,
-    ) => {
-      const listener = (
-        _event: Electron.IpcRendererEvent,
-        requestId: string,
-        method: string,
-        params: Record<string, unknown>,
-      ) => callback(requestId, method, params);
-      ipcRenderer.on(IPC.RPC_COMMAND, listener);
-      return () => { ipcRenderer.removeListener(IPC.RPC_COMMAND, listener); };
-    },
-    respond: (requestId: string, result: unknown) =>
-      ipcRenderer.send(`${IPC.RPC_RESPONSE}:${requestId}`, result),
-  },
-  updater: {
-    checkForUpdates: () =>
-      ipcRenderer.invoke(IPC.UPDATE_CHECK) as Promise<{ status: string }>,
-    installUpdate: () =>
-      ipcRenderer.invoke(IPC.UPDATE_INSTALL),
-    onUpdateAvailable: (callback: (data: { status: string; releaseName?: string }) => void) => {
-      const listener = (_event: Electron.IpcRendererEvent, data: { status: string; releaseName?: string }) =>
-        callback(data);
-      ipcRenderer.on(IPC.UPDATE_AVAILABLE, listener);
-      return () => { ipcRenderer.removeListener(IPC.UPDATE_AVAILABLE, listener); };
-    },
-    onUpdateNotAvailable: (callback: (data: { status: string }) => void) => {
-      const listener = (_event: Electron.IpcRendererEvent, data: { status: string }) =>
-        callback(data);
-      ipcRenderer.on(IPC.UPDATE_NOT_AVAILABLE, listener);
-      return () => { ipcRenderer.removeListener(IPC.UPDATE_NOT_AVAILABLE, listener); };
-    },
-    onUpdateError: (callback: (data: { status: string; message: string }) => void) => {
-      const listener = (_event: Electron.IpcRendererEvent, data: { status: string; message: string }) =>
-        callback(data);
-      ipcRenderer.on(IPC.UPDATE_ERROR, listener);
-      return () => { ipcRenderer.removeListener(IPC.UPDATE_ERROR, listener); };
-    },
-  },
-};
-
-contextBridge.exposeInMainWorld('electronAPI', electronAPI);
-
-// Expose clipboard via IPC for reliable copy/paste in terminal
-const clipboardAPI = {
-  writeText: (text: string) => ipcRenderer.invoke(IPC.CLIPBOARD_WRITE, text),
-  readText: () => ipcRenderer.invoke(IPC.CLIPBOARD_READ) as Promise<string>,
-};
-contextBridge.exposeInMainWorld('clipboardAPI', clipboardAPI);
-
-export type ElectronAPI = typeof electronAPI;
-export type ClipboardAPI = typeof clipboardAPI;