@wong2kim/wmux 1.0.0 → 1.0.1

package/src/main/ipc/handlers/metadata.handler.ts

@@ -1,56 +0,0 @@
-import { ipcMain, BrowserWindow } from 'electron';
-import { IPC } from '../../../shared/constants';
-import { MetadataCollector } from '../../metadata/MetadataCollector';
-import { PTYManager } from '../../pty/PTYManager';
-
-const collector = new MetadataCollector();
-
-// Track CWD per ptyId (updated via OSC 7 or polling)
-const cwdMap = new Map<string, string>();
-
-export function registerMetadataHandlers(
-  ptyManager: PTYManager,
-  getWindow: () => BrowserWindow | null,
-): () => void {
-  // Handle metadata request from renderer
-  ipcMain.handle(IPC.METADATA_REQUEST, async (_event, ptyId: string) => {
-    const cwd = cwdMap.get(ptyId);
-    return collector.collect(cwd);
-  });
-
-  // Listen for CWD changes from PTYBridge (via OscParser)
-  ipcMain.on(IPC.CWD_CHANGED, (_event, ptyId: string, cwd: string) => {
-    cwdMap.set(ptyId, cwd);
-  });
-
-  // Periodic metadata polling (every 5 seconds)
-  const pollingInterval = setInterval(async () => {
-    const win = getWindow();
-    if (!win || win.isDestroyed()) return;
-
-    for (const [ptyId] of cwdMap) {
-      const instance = ptyManager.get(ptyId);
-      if (!instance) {
-        cwdMap.delete(ptyId);
-        continue;
-      }
-
-      const cwd = cwdMap.get(ptyId);
-      if (cwd) {
-        const metadata = await collector.collect(cwd);
-        win.webContents.send(IPC.METADATA_UPDATE, ptyId, metadata);
-      }
-    }
-  }, 5000);
-
-  // cleanup 함수 반환 — 앱 종료 시 호출
-  return () => {
-    clearInterval(pollingInterval);
-    ipcMain.removeHandler(IPC.METADATA_REQUEST);
-    ipcMain.removeAllListeners(IPC.CWD_CHANGED);
-  };
-}
-
-export function updateCwd(ptyId: string, cwd: string): void {
-  cwdMap.set(ptyId, cwd);
-}

package/src/main/ipc/handlers/pty.handler.ts

@@ -1,69 +0,0 @@
-import { ipcMain } from 'electron';
-import fs from 'node:fs';
-import path from 'node:path';
-import { PTYManager } from '../../pty/PTYManager';
-import { PTYBridge } from '../../pty/PTYBridge';
-import { IPC } from '../../../shared/constants';
-
-/**
- * Allowed shell basenames (case-insensitive on Windows).
- * Only these executables may be spawned via IPC.
- */
-const ALLOWED_SHELLS = new Set([
-  'powershell.exe',
-  'pwsh.exe',
-  'cmd.exe',
-  'bash.exe',
-  'wsl.exe',
-  'git-bash.exe',
-  'sh.exe',
-]);
-
-function isAllowedShell(shell: string): boolean {
-  const basename = path.basename(shell).toLowerCase();
-  return ALLOWED_SHELLS.has(basename);
-}
-
-export function registerPTYHandlers(ptyManager: PTYManager, ptyBridge: PTYBridge): void {
-  ipcMain.handle(IPC.PTY_CREATE, (_event, options?: { shell?: string; cwd?: string; cols?: number; rows?: number }) => {
-    if (options?.shell !== undefined && !isAllowedShell(options.shell)) {
-      throw new Error(`PTY_CREATE: shell not allowed: ${options.shell}`);
-    }
-
-    // Validate workDir to block UNC paths and non-existent directories
-    let safeCwd: string | undefined;
-    if (options?.cwd) {
-      const resolved = path.resolve(options.cwd);
-      // Block UNC paths (e.g. \\server\share)
-      if (!resolved.startsWith('\\\\') && fs.existsSync(resolved)) {
-        const stat = fs.statSync(resolved);
-        if (stat.isDirectory()) {
-          safeCwd = resolved;
-        }
-      }
-    }
-
-    const instance = ptyManager.create(safeCwd !== undefined ? { ...options, cwd: safeCwd } : { ...options, cwd: undefined });
-    ptyBridge.setupDataForwarding(instance.id);
-    return { id: instance.id, shell: instance.shell };
-  });
-
-  ipcMain.handle(IPC.PTY_WRITE, (_event, id: string, data: string) => {
-    // 세션 복원 시 이전 ptyId가 남아있을 수 있음 — 조용히 무시
-    if (!ptyManager.get(id)) return;
-    if (typeof data !== 'string') return;
-    if (data.length > 100_000) return; // prevent mega-writes
-    ptyManager.write(id, data);
-  });
-
-  ipcMain.handle(IPC.PTY_RESIZE, (_event, id: string, cols: number, rows: number) => {
-    if (!Number.isInteger(cols) || cols <= 0 || !Number.isInteger(rows) || rows <= 0) {
-      throw new Error(`PTY_RESIZE: cols and rows must be positive integers (got cols=${cols}, rows=${rows})`);
-    }
-    ptyManager.resize(id, cols, rows);
-  });
-
-  ipcMain.handle(IPC.PTY_DISPOSE, (_event, id: string) => {
-    ptyManager.dispose(id);
-  });
-}

package/src/main/ipc/handlers/session.handler.ts

@@ -1,17 +0,0 @@
-import { ipcMain } from 'electron';
-import { IPC } from '../../../shared/constants';
-import { SessionManager } from '../../session/SessionManager';
-import type { SessionData } from '../../../shared/types';
-
-const sessionManager = new SessionManager();
-
-export function registerSessionHandlers(): void {
-  ipcMain.handle(IPC.SESSION_SAVE, (_event, data: SessionData) => {
-    sessionManager.save(data);
-    return { success: true };
-  });
-
-  ipcMain.handle(IPC.SESSION_LOAD, () => {
-    return sessionManager.load();
-  });
-}

package/src/main/ipc/handlers/shell.handler.ts

@@ -1,11 +0,0 @@
-import { ipcMain } from 'electron';
-import { ShellDetector } from '../../pty/ShellDetector';
-import { IPC } from '../../../shared/constants';
-
-export function registerShellHandlers(): void {
-  const detector = new ShellDetector();
-
-  ipcMain.handle(IPC.SHELL_LIST, () => {
-    return detector.detect();
-  });
-}

package/src/main/ipc/registerHandlers.ts

@@ -1,31 +0,0 @@
-import { ipcMain, type BrowserWindow } from 'electron';
-import { PTYManager } from '../pty/PTYManager';
-import { PTYBridge } from '../pty/PTYBridge';
-import { registerPTYHandlers } from './handlers/pty.handler';
-import { registerSessionHandlers } from './handlers/session.handler';
-import { registerShellHandlers } from './handlers/shell.handler';
-import { registerMetadataHandlers } from './handlers/metadata.handler';
-import { registerClipboardHandlers } from './handlers/clipboard.handler';
-import { IPC } from '../../shared/constants';
-import { toastManager } from '../pipe/handlers/notify.rpc';
-
-export function registerAllHandlers(
-  ptyManager: PTYManager,
-  ptyBridge: PTYBridge,
-  getWindow: () => BrowserWindow | null,
-): () => void {
-  registerPTYHandlers(ptyManager, ptyBridge);
-  registerSessionHandlers();
-  registerShellHandlers();
-  const cleanupMetadata = registerMetadataHandlers(ptyManager, getWindow);
-  registerClipboardHandlers();
-
-  // Sync toast setting from renderer
-  ipcMain.on(IPC.TOAST_ENABLED, (_event, enabled: boolean) => {
-    toastManager.enabled = enabled;
-  });
-
-  return () => {
-    cleanupMetadata();
-  };
-}

package/src/main/mcp/McpRegistrar.ts

@@ -1,156 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { app } from 'electron';
-import { getAuthTokenPath } from '../../shared/constants';
-
-/**
- * Registers/unregisters the wmux MCP server in Claude Code's config files
- * and writes the auth token to a well-known file so the MCP server can read it.
- *
- * The MCP server uses:
- *   - Fixed pipe path: \\.\pipe\wmux  (from shared/constants)
- *   - Auth token file: ~/.wmux-auth-token (written here, read by MCP)
- *
- * Config files written:
- *   1. ~/.claude/settings.json   (global settings — mcpServers key)
- *   2. ~/.claude/.mcp.json       (user-level MCP config)
- */
-export class McpRegistrar {
-  private readonly settingsPath: string;
-  private readonly mcpJsonPath: string;
-  private readonly authTokenPath: string;
-  private registered = false;
-
-  constructor() {
-    const home = app.getPath('home');
-    this.settingsPath = path.join(home, '.claude', 'settings.json');
-    this.mcpJsonPath = path.join(home, '.claude', '.mcp.json');
-    this.authTokenPath = getAuthTokenPath();
-  }
-
-  /**
-   * Write auth token to file and register MCP server in Claude Code configs.
-   * Must be called after PipeServer.start().
-   */
-  register(authToken: string): void {
-    try {
-      // Write auth token to file so MCP server can read it
-      fs.writeFileSync(this.authTokenPath, authToken, { encoding: 'utf8', mode: 0o600 });
-      console.log(`[McpRegistrar] Auth token written to ${this.authTokenPath}`);
-
-      const mcpScript = this.getMcpScriptPath();
-      if (!mcpScript) {
-        console.warn('[McpRegistrar] Could not determine MCP script path — skipping registration.');
-        return;
-      }
-
-      // Use absolute node path to avoid PATH resolution issues
-      const mcpEntry = {
-        command: process.execPath,
-        args: [mcpScript],
-      };
-
-      this.registerInSettings(mcpEntry);
-      this.registerInMcpJson(mcpEntry);
-
-      this.registered = true;
-      console.log(`[McpRegistrar] Registered wmux MCP → ${mcpScript}`);
-    } catch (err) {
-      console.error('[McpRegistrar] Failed to register:', err);
-    }
-  }
-
-  /**
-   * Remove wmux MCP server entry and auth token file.
-   */
-  unregister(): void {
-    // Always clean up auth token file
-    try {
-      if (fs.existsSync(this.authTokenPath)) {
-        fs.unlinkSync(this.authTokenPath);
-      }
-    } catch { /* ignore */ }
-
-    if (!this.registered) return;
-
-    try {
-      this.unregisterFromSettings();
-      this.unregisterFromMcpJson();
-      console.log('[McpRegistrar] Unregistered wmux MCP.');
-    } catch (err) {
-      console.error('[McpRegistrar] Failed to unregister:', err);
-    }
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private registerInSettings(mcpEntry: Record<string, any>): void {
-    const settings = this.readJson(this.settingsPath);
-    if (!settings.mcpServers) settings.mcpServers = {};
-    settings.mcpServers['wmux'] = mcpEntry;
-    this.writeJson(this.settingsPath, settings);
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private registerInMcpJson(mcpEntry: Record<string, any>): void {
-    const mcpConfig = this.readJson(this.mcpJsonPath);
-    if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
-    mcpConfig.mcpServers['wmux'] = mcpEntry;
-    this.writeJson(this.mcpJsonPath, mcpConfig);
-  }
-
-  private unregisterFromSettings(): void {
-    const settings = this.readJson(this.settingsPath);
-    if (settings.mcpServers?.['wmux']) {
-      delete settings.mcpServers['wmux'];
-      if (Object.keys(settings.mcpServers).length === 0) delete settings.mcpServers;
-      this.writeJson(this.settingsPath, settings);
-    }
-  }
-
-  private unregisterFromMcpJson(): void {
-    const mcpConfig = this.readJson(this.mcpJsonPath);
-    if (mcpConfig.mcpServers?.['wmux']) {
-      delete mcpConfig.mcpServers['wmux'];
-      if (Object.keys(mcpConfig.mcpServers).length === 0) delete mcpConfig.mcpServers;
-      if (Object.keys(mcpConfig).length === 0) {
-        try { fs.unlinkSync(this.mcpJsonPath); } catch { /* ignore */ }
-      } else {
-        this.writeJson(this.mcpJsonPath, mcpConfig);
-      }
-    }
-  }
-
-  private getMcpScriptPath(): string | null {
-    if (app.isPackaged) {
-      const resourcePath = path.join(process.resourcesPath, 'mcp', 'mcp', 'index.js');
-      if (fs.existsSync(resourcePath)) return resourcePath;
-      return null;
-    }
-
-    const appPath = app.getAppPath();
-    const devPath = path.join(appPath, 'dist', 'mcp', 'mcp', 'index.js');
-    if (fs.existsSync(devPath)) return devPath;
-
-    return null;
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private readJson(filePath: string): Record<string, any> {
-    try {
-      if (fs.existsSync(filePath)) {
-        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-      }
-    } catch { /* corrupted — start fresh */ }
-
-    const dir = path.dirname(filePath);
-    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-    return {};
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private writeJson(filePath: string, data: Record<string, any>): void {
-    const dir = path.dirname(filePath);
-    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf8');
-  }
-}

package/src/main/metadata/MetadataCollector.ts

@@ -1,58 +0,0 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-
-const execFileAsync = promisify(execFile);
-
-export class MetadataCollector {
-  async getGitBranch(cwd: string): Promise<string | undefined> {
-    try {
-      const { stdout } = await execFileAsync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
-        cwd,
-        timeout: 3000,
-      });
-      const branch = stdout.trim();
-      return branch || undefined;
-    } catch {
-      return undefined;
-    }
-  }
-
-  async getListeningPorts(pid?: number): Promise<number[]> {
-    if (pid !== undefined && !(Number.isInteger(pid) && pid > 0)) {
-      return [];
-    }
-    try {
-      // Use PowerShell to get listening TCP connections
-      const script = pid
-        ? `Get-NetTCPConnection -State Listen -OwningProcess ${pid} -ErrorAction SilentlyContinue | Select-Object -ExpandProperty LocalPort`
-        : `Get-NetTCPConnection -State Listen -ErrorAction SilentlyContinue | Where-Object { $_.OwningProcess -ne 0 -and $_.OwningProcess -ne 4 } | Select-Object -ExpandProperty LocalPort | Sort-Object -Unique | Select-Object -First 20`;
-
-      const { stdout } = await execFileAsync('powershell.exe', ['-NoProfile', '-Command', script], {
-        timeout: 5000,
-      });
-
-      const ports = stdout
-        .trim()
-        .split(/\r?\n/)
-        .map((s) => parseInt(s.trim(), 10))
-        .filter((p) => !isNaN(p) && p > 0);
-
-      return [...new Set(ports)].sort((a, b) => a - b);
-    } catch {
-      return [];
-    }
-  }
-
-  async collect(cwd?: string): Promise<{ gitBranch?: string; cwd?: string; listeningPorts?: number[] }> {
-    const [gitBranch, listeningPorts] = await Promise.all([
-      cwd ? this.getGitBranch(cwd) : Promise.resolve(undefined),
-      this.getListeningPorts(),
-    ]);
-
-    return {
-      gitBranch,
-      cwd,
-      listeningPorts: listeningPorts.length > 0 ? listeningPorts : undefined,
-    };
-  }
-}

package/src/main/notification/ToastManager.ts

@@ -1,32 +0,0 @@
-import { Notification, BrowserWindow } from 'electron';
-
-export class ToastManager {
-  enabled = true;
-
-  show(title: string, body: string): void {
-    if (!this.enabled) return;
-
-    // Only show toast when app is not focused
-    const focusedWindow = BrowserWindow.getFocusedWindow();
-    if (focusedWindow) return;
-
-    if (!Notification.isSupported()) return;
-
-    const notification = new Notification({
-      title,
-      body,
-      silent: false,
-    });
-
-    notification.on('click', () => {
-      // Bring app to front when toast is clicked
-      const win = BrowserWindow.getAllWindows()[0];
-      if (win) {
-        if (win.isMinimized()) win.restore();
-        win.focus();
-      }
-    });
-
-    notification.show();
-  }
-}

package/src/main/pipe/PipeServer.ts

@@ -1,190 +0,0 @@
-import * as net from 'net';
-import * as crypto from 'crypto';
-import { getPipeName } from '../../shared/constants';
-import type { RpcRequest } from '../../shared/rpc';
-import { RpcRouter } from './RpcRouter';
-
-const MAX_LINE_BUFFER = 1024 * 1024; // 1 MB — prevent OOM from malicious clients
-
-export class PipeServer {
-  private server: net.Server | null = null;
-  private readonly router: RpcRouter;
-  private readonly connectedSockets = new Set<net.Socket>();
-  private readonly authToken: string;
-  private readonly rateLimits = new Map<net.Socket, { count: number; resetAt: number }>();
-
-  constructor(router: RpcRouter) {
-    this.router = router;
-    this.authToken = crypto.randomUUID();
-  }
-
-  getAuthToken(): string {
-    return this.authToken;
-  }
-
-  start(): void {
-    if (this.server) {
-      return;
-    }
-
-    this.server = net.createServer((socket) => {
-      this.connectedSockets.add(socket);
-      socket.on('close', () => {
-        this.connectedSockets.delete(socket);
-        this.rateLimits.delete(socket);
-      });
-      this.handleConnection(socket);
-    });
-
-    this.server.on('error', (err: NodeJS.ErrnoException) => {
-      if (err.code === 'EADDRINUSE') {
-        console.warn('[PipeServer] EADDRINUSE — retrying in 1s...');
-        setTimeout(() => {
-          if (this.server) {
-            this.server.close();
-            this.server.listen(getPipeName());
-          }
-        }, 1000);
-      } else {
-        console.error('[PipeServer] Server error:', err);
-      }
-    });
-
-    const pipeName = getPipeName();
-    this.server.listen(pipeName, () => {
-      console.log(`[PipeServer] Listening on ${pipeName}`);
-    });
-  }
-
-  stop(): void {
-    if (!this.server) {
-      return;
-    }
-
-    // Destroy all connected sockets
-    for (const socket of this.connectedSockets) {
-      socket.destroy();
-    }
-    this.connectedSockets.clear();
-
-    this.server.close((err) => {
-      if (err) {
-        console.error('[PipeServer] Error closing server:', err);
-      } else {
-        console.log('[PipeServer] Server closed.');
-      }
-    });
-
-    this.server = null;
-  }
-
-  private handleConnection(socket: net.Socket): void {
-    console.log('[PipeServer] Client connected.');
-
-    let buffer = '';
-
-    socket.setEncoding('utf8');
-
-    socket.on('data', (chunk: string) => {
-      buffer += chunk;
-
-      // Security: prevent OOM from clients that never send newlines
-      if (buffer.length > MAX_LINE_BUFFER) {
-        console.warn('[PipeServer] Client exceeded max buffer size — disconnecting.');
-        socket.destroy();
-        return;
-      }
-
-      const lines = buffer.split('\n');
-      // 마지막 요소는 아직 완성되지 않은 부분 — 다음 청크를 기다림
-      buffer = lines.pop() ?? '';
-
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed) {
-          continue;
-        }
-        this.processLine(socket, trimmed);
-      }
-    });
-
-    socket.on('end', () => {
-      // 연결 종료 시 남은 버퍼 처리
-      const trimmed = buffer.trim();
-      if (trimmed) {
-        this.processLine(socket, trimmed);
-      }
-      buffer = '';
-      console.log('[PipeServer] Client disconnected.');
-    });
-
-    socket.on('error', (err) => {
-      console.error('[PipeServer] Socket error:', err);
-      socket.destroy();
-    });
-  }
-
-  private processLine(socket: net.Socket, line: string): void {
-    let request: RpcRequest;
-
-    try {
-      request = JSON.parse(line) as RpcRequest;
-    } catch {
-      const errorResponse = JSON.stringify({
-        id: null,
-        ok: false,
-        error: 'Invalid JSON',
-      });
-      socket.write(errorResponse + '\n');
-      return;
-    }
-
-    // Rate limiting: max 50 requests per second per socket
-    const now = Date.now();
-    let limit = this.rateLimits.get(socket);
-    if (!limit || now > limit.resetAt) {
-      limit = { count: 0, resetAt: now + 1000 };
-      this.rateLimits.set(socket, limit);
-    }
-    limit.count++;
-    if (limit.count > 50) {
-      const rateLimitResponse = JSON.stringify({
-        id: request.id,
-        ok: false,
-        error: 'rate limited',
-      });
-      socket.write(rateLimitResponse + '\n');
-      return;
-    }
-
-    // Authenticate: every request must carry a valid token
-    if (request.token !== this.authToken) {
-      const unauthorizedResponse = JSON.stringify({
-        id: request.id,
-        ok: false,
-        error: 'unauthorized',
-      });
-      socket.write(unauthorizedResponse + '\n');
-      return;
-    }
-
-    this.router
-      .dispatch(request)
-      .then((response) => {
-        if (!socket.destroyed) {
-          socket.write(JSON.stringify(response) + '\n');
-        }
-      })
-      .catch((err: unknown) => {
-        console.error('[PipeServer] Dispatch error:', err);
-        if (!socket.destroyed) {
-          const errorResponse = JSON.stringify({
-            id: request.id,
-            ok: false,
-            error: 'Internal server error',
-          });
-          socket.write(errorResponse + '\n');
-        }
-      });
-  }
-}

package/src/main/pipe/RpcRouter.ts

@@ -1,46 +0,0 @@
-import type { RpcMethod, RpcRequest, RpcResponse } from '../../shared/rpc';
-
-type RpcHandler = (params: Record<string, unknown>) => Promise<unknown>;
-
-export class RpcRouter {
-  private readonly handlers = new Map<RpcMethod, RpcHandler>();
-
-  register(method: RpcMethod, handler: RpcHandler): void {
-    this.handlers.set(method, handler);
-  }
-
-  async dispatch(request: RpcRequest): Promise<RpcResponse> {
-    if (!request || typeof request.id !== 'string' || typeof request.method !== 'string') {
-      return { id: (request as RpcRequest)?.id || '', ok: false, error: 'Invalid RPC request: missing id or method' };
-    }
-    if (request.params !== undefined && (typeof request.params !== 'object' || request.params === null)) {
-      return { id: request.id, ok: false, error: 'Invalid RPC request: params must be an object' };
-    }
-
-    const handler = this.handlers.get(request.method);
-
-    if (!handler) {
-      return {
-        id: request.id,
-        ok: false,
-        error: `Unknown method: ${request.method}`,
-      };
-    }
-
-    try {
-      const result = await handler(request.params);
-      return {
-        id: request.id,
-        ok: true,
-        result,
-      };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return {
-        id: request.id,
-        ok: false,
-        error: message,
-      };
-    }
-  }
-}