@wong2kim/wmux 1.0.0

package/src/main/metadata/MetadataCollector.ts

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

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

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

@@ -0,0 +1,46 @@
+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,
+      };
+    }
+  }
+}

package/src/main/pipe/handlers/_bridge.ts

@@ -0,0 +1,40 @@
+import { ipcMain, type BrowserWindow } from 'electron';
+import { randomUUID } from 'node:crypto';
+import { IPC } from '../../../shared/constants';
+
+type GetWindow = () => BrowserWindow | null;
+
+const TIMEOUT_MS = 5000;
+
+/**
+ * Sends a RPC command to the renderer via IPC and waits for the response.
+ * Uses a unique requestId per call so concurrent requests don't collide.
+ */
+export function sendToRenderer(
+  getWindow: GetWindow,
+  method: string,
+  params: Record<string, unknown> = {},
+): Promise<unknown> {
+  return new Promise((resolve, reject) => {
+    const win = getWindow();
+    if (!win || win.isDestroyed()) {
+      reject(new Error('BrowserWindow is not available'));
+      return;
+    }
+
+    const requestId = `rpc-${randomUUID()}`;
+    const responseChannel = `${IPC.RPC_RESPONSE}:${requestId}`;
+
+    const timer = setTimeout(() => {
+      ipcMain.removeAllListeners(responseChannel);
+      reject(new Error(`RPC timeout: ${method} (${TIMEOUT_MS}ms)`));
+    }, TIMEOUT_MS);
+
+    ipcMain.once(responseChannel, (_event, result: unknown) => {
+      clearTimeout(timer);
+      resolve(result);
+    });
+
+    win.webContents.send(IPC.RPC_COMMAND, requestId, method, params);
+  });
+}

package/src/main/pipe/handlers/browser.rpc.ts

@@ -0,0 +1,132 @@
+import type { BrowserWindow } from 'electron';
+import type { RpcRouter } from '../RpcRouter';
+import { sendToRenderer } from './_bridge';
+
+type GetWindow = () => BrowserWindow | null;
+
+/**
+ * Registers browser.* RPC handlers.
+ *
+ * All commands are delegated to the renderer process via IPC where the active
+ * browser Surface's <webview> element executes the requested operation.
+ */
+export function registerBrowserRpc(router: RpcRouter, getWindow: GetWindow): void {
+  /**
+   * browser.open
+   * Opens a new browser surface in the active pane.
+   * params: { url?: string }
+   */
+  router.register('browser.open', (params) => {
+    const url = typeof params['url'] === 'string' ? params['url'] : undefined;
+    return sendToRenderer(getWindow, 'browser.open', {
+      ...(url && { url }),
+    });
+  });
+
+  /**
+   * browser.snapshot
+   * Returns the full outer HTML of the current page as a string.
+   * params: {}
+   */
+  router.register('browser.snapshot', (params) => {
+    const surfaceId = typeof params['surfaceId'] === 'string' ? params['surfaceId'] : undefined;
+    return sendToRenderer(getWindow, 'browser.snapshot', {
+      ...(surfaceId && { surfaceId }),
+    });
+  });
+
+  /**
+   * browser.click
+   * Clicks the first element matching the given CSS selector.
+   * params: { selector: string }
+   */
+  router.register('browser.click', (params) => {
+    if (typeof params['selector'] !== 'string' || params['selector'].length === 0) {
+      throw new Error('browser.click: missing required param "selector"');
+    }
+    const surfaceId = typeof params['surfaceId'] === 'string' ? params['surfaceId'] : undefined;
+    return sendToRenderer(getWindow, 'browser.click', {
+      selector: params['selector'],
+      ...(surfaceId && { surfaceId }),
+    });
+  });
+
+  /**
+   * browser.fill
+   * Sets the value of an input element matching the given CSS selector.
+   * params: { selector: string; text: string }
+   */
+  router.register('browser.fill', (params) => {
+    if (typeof params['selector'] !== 'string' || params['selector'].length === 0) {
+      throw new Error('browser.fill: missing required param "selector"');
+    }
+    if (typeof params['text'] !== 'string') {
+      throw new Error('browser.fill: missing required param "text"');
+    }
+    const surfaceId = typeof params['surfaceId'] === 'string' ? params['surfaceId'] : undefined;
+    return sendToRenderer(getWindow, 'browser.fill', {
+      selector: params['selector'],
+      text: params['text'],
+      ...(surfaceId && { surfaceId }),
+    });
+  });
+
+  /**
+   * browser.eval
+   * Evaluates arbitrary JavaScript in the context of the current page.
+   * params: { code: string }
+   */
+  router.register('browser.eval', (params) => {
+    if (typeof params['code'] !== 'string' || params['code'].length === 0) {
+      throw new Error('browser.eval: missing required param "code"');
+    }
+    // Security: block patterns that could escape webview sandbox
+    const code = params['code'];
+    const dangerousPatterns = [
+      /\brequire\s*\(/i,
+      /\bprocess\s*\./i,
+      /\b__dirname\b/i,
+      /\b__filename\b/i,
+      /\bchild_process\b/i,
+      /\bglobal\s*\.\s*process\b/i,
+      /\belectron\b/i,
+    ];
+    for (const pat of dangerousPatterns) {
+      if (pat.test(code)) {
+        throw new Error('browser.eval: code contains blocked pattern');
+      }
+    }
+    const surfaceId = typeof params['surfaceId'] === 'string' ? params['surfaceId'] : undefined;
+    return sendToRenderer(getWindow, 'browser.eval', {
+      code,
+      ...(surfaceId && { surfaceId }),
+    });
+  });
+
+  /**
+   * browser.navigate
+   * Navigates the active browser Surface to the given URL.
+   * params: { url: string }
+   */
+  router.register('browser.navigate', (params) => {
+    if (typeof params['url'] !== 'string' || params['url'].length === 0) {
+      throw new Error('browser.navigate: missing required param "url"');
+    }
+    // Security: block dangerous URL schemes
+    const url = params['url'];
+    const normalizedUrl = url.trim().toLowerCase();
+    if (
+      normalizedUrl.startsWith('javascript:') ||
+      normalizedUrl.startsWith('data:') ||
+      normalizedUrl.startsWith('vbscript:') ||
+      normalizedUrl.startsWith('file:')
+    ) {
+      throw new Error(`browser.navigate: blocked URL scheme`);
+    }
+    const surfaceId = typeof params['surfaceId'] === 'string' ? params['surfaceId'] : undefined;
+    return sendToRenderer(getWindow, 'browser.navigate', {
+      url,
+      ...(surfaceId && { surfaceId }),
+    });
+  });
+}

package/src/main/pipe/handlers/input.rpc.ts

@@ -0,0 +1,120 @@
+import type { BrowserWindow } from 'electron';
+import type { RpcRouter } from '../RpcRouter';
+import type { PTYManager } from '../../pty/PTYManager';
+import { sendToRenderer } from './_bridge';
+
+type GetWindow = () => BrowserWindow | null;
+
+/**
+ * Key sequence mapping table for input.sendKey
+ */
+const KEY_MAP: Readonly<Record<string, string>> = {
+  enter: '\r',
+  tab: '\t',
+  'ctrl+c': '\x03',
+  'ctrl+d': '\x04',
+  'ctrl+z': '\x1a',
+  'ctrl+l': '\x0c',
+  escape: '\x1b',
+  up: '\x1b[A',
+  down: '\x1b[B',
+  right: '\x1b[C',
+  left: '\x1b[D',
+} as const;
+
+/**
+ * Resolves the active ptyId from the renderer when none is provided.
+ * Asks the renderer for the currently focused surface's ptyId.
+ */
+async function resolveActivePtyId(getWindow: GetWindow): Promise<string> {
+  const result = await sendToRenderer(getWindow, 'input.readScreen');
+  // renderer returns { ptyId: string, ... } for the active surface
+  if (
+    result !== null &&
+    typeof result === 'object' &&
+    'ptyId' in result &&
+    typeof (result as Record<string, unknown>)['ptyId'] === 'string'
+  ) {
+    return (result as Record<string, string>)['ptyId'];
+  }
+  throw new Error('input: could not resolve active ptyId from renderer');
+}
+
+export function registerInputRpc(
+  router: RpcRouter,
+  ptyManager: PTYManager,
+  getWindow: GetWindow,
+): void {
+  /**
+   * input.send — writes text to a PTY session.
+   * params: { text: string, ptyId?: string }
+   * If ptyId is omitted the renderer is queried for the active surface's ptyId.
+   */
+  router.register('input.send', async (params) => {
+    if (typeof params['text'] !== 'string') {
+      throw new Error('input.send: missing required param "text"');
+    }
+
+    const text = params['text'];
+    let ptyId: string;
+
+    if (typeof params['ptyId'] === 'string' && params['ptyId'].length > 0) {
+      ptyId = params['ptyId'];
+    } else {
+      ptyId = await resolveActivePtyId(getWindow);
+    }
+
+    const instance = ptyManager.get(ptyId);
+    if (!instance) {
+      throw new Error(`input.send: PTY not found — id="${ptyId}"`);
+    }
+
+    ptyManager.write(ptyId, text);
+    return { ok: true, ptyId };
+  });
+
+  /**
+   * input.sendKey — maps a named key to an ANSI sequence and writes it.
+   * params: { key: string, ptyId?: string }
+   * Supported keys: enter, tab, ctrl+c, ctrl+d, ctrl+z, ctrl+l,
+   *                 escape, up, down, right, left
+   */
+  router.register('input.sendKey', async (params) => {
+    if (typeof params['key'] !== 'string') {
+      throw new Error('input.sendKey: missing required param "key"');
+    }
+
+    const key = params['key'].toLowerCase();
+    const sequence = KEY_MAP[key];
+    if (sequence === undefined) {
+      throw new Error(
+        `input.sendKey: unknown key "${params['key']}". ` +
+          `Supported: ${Object.keys(KEY_MAP).join(', ')}`,
+      );
+    }
+
+    let ptyId: string;
+    if (typeof params['ptyId'] === 'string' && params['ptyId'].length > 0) {
+      ptyId = params['ptyId'];
+    } else {
+      ptyId = await resolveActivePtyId(getWindow);
+    }
+
+    const instance = ptyManager.get(ptyId);
+    if (!instance) {
+      throw new Error(`input.sendKey: PTY not found — id="${ptyId}"`);
+    }
+
+    ptyManager.write(ptyId, sequence);
+    return { ok: true, ptyId, key, sequence };
+  });
+
+  /**
+   * input.readScreen — delegates to the renderer to capture the current
+   * terminal viewport text of the active surface.
+   * Returns { ptyId: string, text: string }
+   */
+  router.register('input.readScreen', (_params) =>
+    sendToRenderer(getWindow, 'input.readScreen'),
+  );
+}

package/src/main/pipe/handlers/meta.rpc.ts

@@ -0,0 +1,59 @@
+import type { BrowserWindow } from 'electron';
+import type { RpcRouter } from '../RpcRouter';
+import { IPC } from '../../../shared/constants';
+
+type GetWindow = () => BrowserWindow | null;
+
+/**
+ * Sub-channel names embedded in the METADATA_UPDATE IPC message.
+ * The renderer's useNotificationListener (or a dedicated metadata listener)
+ * discriminates on the `kind` field.
+ */
+type MetaUpdateKind = 'status' | 'progress';
+
+interface MetaStatusPayload {
+  kind: 'status';
+  text: string;
+}
+
+interface MetaProgressPayload {
+  kind: 'progress';
+  value: number;
+}
+
+type MetaPayload = MetaStatusPayload | MetaProgressPayload;
+
+function sendMeta(getWindow: GetWindow, payload: MetaPayload): Promise<{ ok: boolean }> {
+  const win = getWindow();
+  if (!win || win.isDestroyed()) {
+    return Promise.reject(new Error('meta: BrowserWindow is not available'));
+  }
+  win.webContents.send(IPC.METADATA_UPDATE, payload);
+  return Promise.resolve({ ok: true });
+}
+
+export function registerMetaRpc(router: RpcRouter, getWindow: GetWindow): void {
+  /**
+   * meta.setStatus — sets an arbitrary status text string in the renderer.
+   * params: { text: string }
+   */
+  router.register('meta.setStatus', (params) => {
+    if (typeof params['text'] !== 'string') {
+      throw new Error('meta.setStatus: missing required param "text"');
+    }
+    return sendMeta(getWindow, { kind: 'status', text: params['text'] });
+  });
+
+  /**
+   * meta.setProgress — sets a progress value (0–100) in the renderer.
+   * params: { value: number }
+   * Values outside 0–100 are clamped.
+   */
+  router.register('meta.setProgress', (params) => {
+    if (typeof params['value'] !== 'number') {
+      throw new Error('meta.setProgress: missing required param "value" (number)');
+    }
+    const value = Math.min(100, Math.max(0, params['value']));
+    return sendMeta(getWindow, { kind: 'progress', value });
+  });
+}