@wong2kim/wmux 1.0.0

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

@@ -0,0 +1,53 @@
+import type { BrowserWindow } from 'electron';
+import type { RpcRouter } from '../RpcRouter';
+import type { NotificationType } from '../../../shared/types';
+import { IPC } from '../../../shared/constants';
+import { ToastManager } from '../../notification/ToastManager';
+
+type GetWindow = () => BrowserWindow | null;
+
+const VALID_TYPES = new Set<NotificationType>(['info', 'warning', 'error', 'agent']);
+
+function isNotificationType(value: unknown): value is NotificationType {
+  return typeof value === 'string' && VALID_TYPES.has(value as NotificationType);
+}
+
+export const toastManager = new ToastManager();
+
+export function registerNotifyRpc(router: RpcRouter, getWindow: GetWindow): void {
+  /**
+   * notify — delivers a notification to the renderer UI and, when the app is
+   * not focused, also shows a Windows Toast notification.
+   *
+   * params: {
+   *   title:   string
+   *   body:    string
+   *   type?:   'info' | 'warning' | 'error' | 'agent'  (default: 'info')
+   * }
+   */
+  router.register('notify', (params) => {
+    if (typeof params['title'] !== 'string' || params['title'].length === 0) {
+      throw new Error('notify: missing required param "title"');
+    }
+    if (typeof params['body'] !== 'string') {
+      throw new Error('notify: missing required param "body"');
+    }
+
+    const title = params['title'];
+    const body = params['body'];
+    const type: NotificationType = isNotificationType(params['type'])
+      ? params['type']
+      : 'info';
+
+    const win = getWindow();
+    if (win && !win.isDestroyed()) {
+      // Push notification to the renderer notification store
+      win.webContents.send(IPC.NOTIFICATION, { title, body, type });
+    }
+
+    // Show OS-level toast (only when window is not focused)
+    toastManager.show(title, body);
+
+    return Promise.resolve({ delivered: true, type });
+  });
+}

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

@@ -0,0 +1,39 @@
+import type { BrowserWindow } from 'electron';
+import type { RpcRouter } from '../RpcRouter';
+import { sendToRenderer } from './_bridge';
+
+type GetWindow = () => BrowserWindow | null;
+
+export function registerPaneRpc(router: RpcRouter, getWindow: GetWindow): void {
+  /**
+   * pane.list — returns all panes (leaf nodes) of the current workspace
+   */
+  router.register('pane.list', (_params) =>
+    sendToRenderer(getWindow, 'pane.list'),
+  );
+
+  /**
+   * pane.focus — focuses a specific pane
+   * params: { id: string }
+   */
+  router.register('pane.focus', (params) => {
+    if (typeof params['id'] !== 'string') {
+      return Promise.reject(new Error('pane.focus: missing required param "id"'));
+    }
+    return sendToRenderer(getWindow, 'pane.focus', { id: params['id'] });
+  });
+
+  /**
+   * pane.split — splits the active pane
+   * params: { direction: 'horizontal' | 'vertical' }
+   */
+  router.register('pane.split', (params) => {
+    const direction = params['direction'];
+    if (direction !== 'horizontal' && direction !== 'vertical') {
+      return Promise.reject(
+        new Error('pane.split: "direction" must be "horizontal" or "vertical"'),
+      );
+    }
+    return sendToRenderer(getWindow, 'pane.split', { direction });
+  });
+}

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

@@ -0,0 +1,43 @@
+import type { BrowserWindow } from 'electron';
+import type { RpcRouter } from '../RpcRouter';
+import { sendToRenderer } from './_bridge';
+
+type GetWindow = () => BrowserWindow | null;
+
+export function registerSurfaceRpc(router: RpcRouter, getWindow: GetWindow): void {
+  /**
+   * surface.list — returns surfaces of the current workspace's active pane
+   */
+  router.register('surface.list', (_params) =>
+    sendToRenderer(getWindow, 'surface.list'),
+  );
+
+  /**
+   * surface.new — creates a new surface in the active pane
+   */
+  router.register('surface.new', (_params) =>
+    sendToRenderer(getWindow, 'surface.new'),
+  );
+
+  /**
+   * surface.focus — focuses a specific surface
+   * params: { id: string }
+   */
+  router.register('surface.focus', (params) => {
+    if (typeof params['id'] !== 'string') {
+      return Promise.reject(new Error('surface.focus: missing required param "id"'));
+    }
+    return sendToRenderer(getWindow, 'surface.focus', { id: params['id'] });
+  });
+
+  /**
+   * surface.close — closes a specific surface
+   * params: { id: string }
+   */
+  router.register('surface.close', (params) => {
+    if (typeof params['id'] !== 'string') {
+      return Promise.reject(new Error('surface.close: missing required param "id"'));
+    }
+    return sendToRenderer(getWindow, 'surface.close', { id: params['id'] });
+  });
+}

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

@@ -0,0 +1,36 @@
+import { app } from 'electron';
+import type { RpcRouter } from '../RpcRouter';
+import { ALL_RPC_METHODS } from '../../../shared/rpc';
+
+/**
+ * Shape returned by system.identify.
+ */
+interface SystemIdentity {
+  app: string;
+  version: string;
+  platform: NodeJS.Platform;
+  electronVersion: string;
+}
+
+export function registerSystemRpc(router: RpcRouter): void {
+  /**
+   * system.identify — returns static information about the running WinMux instance.
+   * No renderer round-trip needed; answered entirely from Main.
+   */
+  router.register('system.identify', (_params): Promise<SystemIdentity> => {
+    return Promise.resolve({
+      app: 'wmux',
+      version: app.getVersion(),
+      platform: process.platform,
+      electronVersion: process.versions.electron ?? 'unknown',
+    });
+  });
+
+  /**
+   * system.capabilities — returns the full list of registered RPC method names.
+   * Sourced from the single-source-of-truth array in shared/rpc.ts.
+   */
+  router.register('system.capabilities', (_params) => {
+    return Promise.resolve({ methods: ALL_RPC_METHODS });
+  });
+}

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

@@ -0,0 +1,52 @@
+import type { BrowserWindow } from 'electron';
+import type { RpcRouter } from '../RpcRouter';
+import { sendToRenderer } from './_bridge';
+
+type GetWindow = () => BrowserWindow | null;
+
+export function registerWorkspaceRpc(router: RpcRouter, getWindow: GetWindow): void {
+  /**
+   * workspace.list — returns all workspaces as {id, name}[]
+   */
+  router.register('workspace.list', (_params) =>
+    sendToRenderer(getWindow, 'workspace.list'),
+  );
+
+  /**
+   * workspace.new — creates a new workspace
+   * params: { name?: string }
+   */
+  router.register('workspace.new', (params) => {
+    const name = typeof params['name'] === 'string' ? params['name'] : undefined;
+    return sendToRenderer(getWindow, 'workspace.new', name !== undefined ? { name } : {});
+  });
+
+  /**
+   * workspace.focus — sets the active workspace
+   * params: { id: string }
+   */
+  router.register('workspace.focus', (params) => {
+    if (typeof params['id'] !== 'string') {
+      return Promise.reject(new Error('workspace.focus: missing required param "id"'));
+    }
+    return sendToRenderer(getWindow, 'workspace.focus', { id: params['id'] });
+  });
+
+  /**
+   * workspace.close — removes a workspace
+   * params: { id: string }
+   */
+  router.register('workspace.close', (params) => {
+    if (typeof params['id'] !== 'string') {
+      return Promise.reject(new Error('workspace.close: missing required param "id"'));
+    }
+    return sendToRenderer(getWindow, 'workspace.close', { id: params['id'] });
+  });
+
+  /**
+   * workspace.current — returns the currently active workspace {id, name}
+   */
+  router.register('workspace.current', (_params) =>
+    sendToRenderer(getWindow, 'workspace.current'),
+  );
+}

package/src/main/pty/AgentDetector.ts

@@ -0,0 +1,247 @@
+// Terminal agent status detection — monitors PTY output for known AI agent
+// prompt patterns and status indicators. This is status display only;
+// no content is captured, stored, or transmitted.
+
+export interface AgentEvent {
+  agent: string;
+  status: 'completed' | 'waiting' | 'running' | 'error';
+  message: string;
+}
+
+export interface CriticalEvent {
+  action: string;
+  riskLevel: 'review' | 'critical';
+}
+
+type AgentEventCallback = (event: AgentEvent) => void;
+type CriticalEventCallback = (event: CriticalEvent) => void;
+
+interface AgentPattern {
+  agent: string;
+  patterns: { regex: RegExp; status: AgentEvent['status']; message: string }[];
+}
+
+// ---------------------------------------------------------------------------
+// Common cross-agent terminal patterns
+// ---------------------------------------------------------------------------
+
+/** Shared completion indicators (✓ ✔ Done Complete Finished Success) */
+const COMMON_COMPLETE: AgentPattern['patterns'] = [
+  { regex: /[✓✔]\s+(.+)/,               status: 'completed', message: 'Task completed' },
+  { regex: /\b(Done|Complete(?:d)?|Finished|Success(?:ful)?)\b/, status: 'completed', message: 'Task completed' },
+];
+
+/** Shared error indicators (✗ ✘ Error Failed error:) */
+const COMMON_ERROR: AgentPattern['patterns'] = [
+  { regex: /[✗✘]\s+(.+)/,               status: 'error',     message: 'Error occurred' },
+  { regex: /\bFailed\b/,                 status: 'error',     message: 'Task failed' },
+  { regex: /\berror:\s+(.+)/i,           status: 'error',     message: 'Error occurred' },
+];
+
+/** Shared waiting indicators (? Waiting for Press y/n [Y/n]) */
+const COMMON_WAITING: AgentPattern['patterns'] = [
+  { regex: /\?\s+(.+)/,                  status: 'waiting',   message: 'Waiting for input' },
+  { regex: /Waiting for\s+(.+)/i,        status: 'waiting',   message: 'Waiting for input' },
+  { regex: /Press\s+.+\s+to\s+/i,        status: 'waiting',   message: 'Waiting for key press' },
+  { regex: /\[Y\/n\]|\(y\/n\)/i,         status: 'waiting',   message: 'Waiting for confirmation' },
+];
+
+// ---------------------------------------------------------------------------
+// Per-agent patterns
+// ---------------------------------------------------------------------------
+
+const AGENT_PATTERNS: AgentPattern[] = [
+  // ── Claude Code ────────────────────────────────────────────────────────────
+  {
+    agent: 'Claude Code',
+    patterns: [
+      { regex: /⏳\s+(.+)/,              status: 'running',   message: 'Processing...' },
+      { regex: /❌\s+(.+)/,              status: 'error',     message: 'Error occurred' },
+      { regex: /Do you want to/,         status: 'waiting',   message: 'Waiting for confirmation' },
+      ...COMMON_COMPLETE,
+      ...COMMON_ERROR,
+      ...COMMON_WAITING,
+    ],
+  },
+
+  // ── Cursor Agent ──────────────────────────────────────────────────────────
+  {
+    agent: 'Cursor Agent',
+    patterns: [
+      { regex: /Applied \d+ changes?/,   status: 'completed', message: 'Changes applied' },
+      { regex: /Thinking\.\.\./,         status: 'running',   message: 'Thinking...' },
+      ...COMMON_COMPLETE,
+      ...COMMON_ERROR,
+      ...COMMON_WAITING,
+    ],
+  },
+
+  // ── Aider ─────────────────────────────────────────────────────────────────
+  {
+    agent: 'Aider',
+    patterns: [
+      { regex: /Applied edit to/,        status: 'completed', message: 'Edit applied' },
+      { regex: /aider>/,                 status: 'waiting',   message: 'Waiting for input' },
+      ...COMMON_COMPLETE,
+      ...COMMON_ERROR,
+      ...COMMON_WAITING,
+    ],
+  },
+
+  // ── Codex CLI ─────────────────────────────────────────────────────────────
+  {
+    agent: 'Codex CLI',
+    patterns: [
+      { regex: /codex>/,                 status: 'waiting',   message: 'Waiting for input' },
+      { regex: /Codex:\s+(.+)/,          status: 'running',   message: 'Processing...' },
+      ...COMMON_COMPLETE,
+      ...COMMON_ERROR,
+      ...COMMON_WAITING,
+    ],
+  },
+
+  // ── Gemini CLI ────────────────────────────────────────────────────────────
+  {
+    agent: 'Gemini CLI',
+    patterns: [
+      { regex: /gemini>/,                status: 'waiting',   message: 'Waiting for input' },
+      { regex: /Gemini:\s+(.+)/,         status: 'running',   message: 'Processing...' },
+      ...COMMON_COMPLETE,
+      ...COMMON_ERROR,
+      ...COMMON_WAITING,
+    ],
+  },
+
+  // ── OpenCode ──────────────────────────────────────────────────────────────
+  {
+    agent: 'OpenCode',
+    patterns: [
+      { regex: /opencode>/,              status: 'waiting',   message: 'Waiting for input' },
+      ...COMMON_COMPLETE,
+      ...COMMON_ERROR,
+      ...COMMON_WAITING,
+    ],
+  },
+
+  // ── GitHub Copilot CLI ────────────────────────────────────────────────────
+  {
+    agent: 'GitHub Copilot CLI',
+    patterns: [
+      { regex: /copilot>/,               status: 'waiting',   message: 'Waiting for input' },
+      { regex: /gh copilot\s+(.+)/,      status: 'running',   message: 'Processing...' },
+      ...COMMON_COMPLETE,
+      ...COMMON_ERROR,
+      ...COMMON_WAITING,
+    ],
+  },
+];
+
+// ---------------------------------------------------------------------------
+// Critical action patterns — require approval before execution
+// ---------------------------------------------------------------------------
+
+interface CriticalPattern {
+  regex: RegExp;
+  riskLevel: 'review' | 'critical';
+  label: string;
+}
+
+const CRITICAL_PATTERNS: CriticalPattern[] = [
+  // Destructive git operations
+  { regex: /git\s+push\s+(?:.*--force|-f)\b/i,          riskLevel: 'critical', label: 'git push --force' },
+  { regex: /git\s+reset\s+--hard\b/i,                   riskLevel: 'critical', label: 'git reset --hard' },
+  { regex: /git\s+clean\s+.*-f\b/i,                     riskLevel: 'critical', label: 'git clean -f' },
+  // File system wipe
+  { regex: /\brm\s+(?:.*-r.*-f|-f.*-r|-rf|-fr)\s+/i,   riskLevel: 'critical', label: 'rm -rf' },
+  { regex: /\brmdir\s+\/[sS]\s+/,                       riskLevel: 'critical', label: 'rmdir /S' },
+  // Database destructive
+  { regex: /\bDROP\s+(?:TABLE|DATABASE|SCHEMA)\b/i,     riskLevel: 'critical', label: 'DROP TABLE/DATABASE' },
+  { regex: /\bDELETE\s+FROM\b/i,                        riskLevel: 'review',   label: 'DELETE FROM' },
+  { regex: /\bTRUNCATE\s+TABLE\b/i,                     riskLevel: 'critical', label: 'TRUNCATE TABLE' },
+  // NPM publishing
+  { regex: /\bnpm\s+publish\b/i,                        riskLevel: 'critical', label: 'npm publish' },
+  { regex: /\bnpx\s+.*--publish\b/i,                    riskLevel: 'review',   label: 'npx publish' },
+  // Cloud resource destruction
+  { regex: /\bterraform\s+destroy\b/i,                  riskLevel: 'critical', label: 'terraform destroy' },
+  { regex: /\bkubectl\s+delete\b/i,                     riskLevel: 'review',   label: 'kubectl delete' },
+  { regex: /\baws\s+.*\s+delete\b/i,                    riskLevel: 'review',   label: 'aws delete' },
+  // Disk formatting
+  { regex: /\bformat\s+[A-Za-z]:\\/i,                   riskLevel: 'critical', label: 'format disk' },
+  { regex: /\bmkfs\b/i,                                 riskLevel: 'critical', label: 'mkfs' },
+];
+
+const MAX_BUFFER = 16 * 1024; // 16 KB
+
+export class AgentDetector {
+  private callbacks: AgentEventCallback[] = [];
+  private criticalCallbacks: CriticalEventCallback[] = [];
+  private lineBuffer = '';
+  private lastEmittedKey = '';
+
+  onEvent(callback: AgentEventCallback): void {
+    this.callbacks.push(callback);
+  }
+
+  onCritical(callback: CriticalEventCallback): void {
+    this.criticalCallbacks.push(callback);
+  }
+
+  feed(data: string): void {
+    // Accumulate lines
+    this.lineBuffer += data;
+    // Prevent unbounded buffer growth
+    if (this.lineBuffer.length > MAX_BUFFER) {
+      this.lineBuffer = this.lineBuffer.slice(-MAX_BUFFER);
+    }
+    const lines = this.lineBuffer.split(/\r?\n/);
+    // Keep the last incomplete line in buffer
+    this.lineBuffer = lines.pop() || '';
+
+    for (const line of lines) {
+      this.processLine(line);
+    }
+  }
+
+  private processLine(line: string): void {
+    // Strip ANSI escape codes for pattern matching
+    const clean = line.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '').trim();
+    if (!clean) return;
+
+    // Check critical patterns first
+    for (const cp of CRITICAL_PATTERNS) {
+      if (cp.regex.test(clean)) {
+        const key = `critical:${cp.label}:${clean.slice(0, 80)}`;
+        if (key !== this.lastEmittedKey) {
+          this.lastEmittedKey = key;
+          const event: CriticalEvent = { action: cp.label, riskLevel: cp.riskLevel };
+          for (const cb of this.criticalCallbacks) {
+            cb(event);
+          }
+        }
+        return;
+      }
+    }
+
+    for (const ap of AGENT_PATTERNS) {
+      for (const p of ap.patterns) {
+        const match = clean.match(p.regex);
+        if (match) {
+          // Deduplicate: don't emit the same event twice in a row
+          const key = `${ap.agent}:${p.status}:${match[0]}`;
+          if (key === this.lastEmittedKey) return;
+          this.lastEmittedKey = key;
+
+          const event: AgentEvent = {
+            agent: ap.agent,
+            status: p.status,
+            message: match[1] || p.message,
+          };
+          for (const cb of this.callbacks) {
+            cb(event);
+          }
+          return;
+        }
+      }
+    }
+  }
+}

package/src/main/pty/OscParser.ts

@@ -0,0 +1,81 @@
+export interface OscEvent {
+  code: number;
+  data: string;
+}
+
+export type OscCallback = (event: OscEvent) => void;
+
+/**
+ * Parses OSC (Operating System Command) sequences from terminal data.
+ * Handles OSC 7 (CWD), OSC 9/99/777 (notifications).
+ */
+const MAX_BUFFER = 64 * 1024; // 64 KB
+
+export class OscParser {
+  private buffer = '';
+  private inOsc = false;
+  private callbacks: OscCallback[] = [];
+
+  onOsc(callback: OscCallback): void {
+    this.callbacks.push(callback);
+  }
+
+  /**
+   * Process terminal data, extract OSC sequences, return cleaned data.
+   */
+  process(data: string): string {
+    let result = '';
+    let i = 0;
+
+    while (i < data.length) {
+      if (this.inOsc) {
+        // Look for ST (String Terminator): BEL (\x07) or ESC \ (\x1b\x5c)
+        if (data[i] === '\x07') {
+          this.emitOsc(this.buffer);
+          this.buffer = '';
+          this.inOsc = false;
+          i++;
+        } else if (data[i] === '\x1b' && i + 1 < data.length && data[i + 1] === '\\') {
+          this.emitOsc(this.buffer);
+          this.buffer = '';
+          this.inOsc = false;
+          i += 2;
+        } else {
+          this.buffer += data[i];
+          // Prevent unbounded buffer growth
+          if (this.buffer.length > MAX_BUFFER) {
+            this.buffer = '';
+            this.inOsc = false;
+          }
+          i++;
+        }
+      } else if (data[i] === '\x1b' && i + 1 < data.length && data[i + 1] === ']') {
+        // OSC start: ESC ]
+        this.inOsc = true;
+        this.buffer = '';
+        i += 2;
+      } else {
+        result += data[i];
+        i++;
+      }
+    }
+
+    return result;
+  }
+
+  private emitOsc(raw: string): void {
+    // OSC format: code;data
+    const semicolonIdx = raw.indexOf(';');
+    if (semicolonIdx === -1) return;
+
+    const codeStr = raw.substring(0, semicolonIdx);
+    const code = parseInt(codeStr, 10);
+    if (isNaN(code)) return;
+
+    const data = raw.substring(semicolonIdx + 1);
+
+    for (const cb of this.callbacks) {
+      cb({ code, data });
+    }
+  }
+}

package/src/main/pty/PTYBridge.ts

@@ -0,0 +1,88 @@
+import { BrowserWindow } from 'electron';
+import { PTYManager } from './PTYManager';
+import { OscParser } from './OscParser';
+import { AgentDetector } from './AgentDetector';
+import { ToastManager } from '../notification/ToastManager';
+import { IPC } from '../../shared/constants';
+
+export class PTYBridge {
+  private oscParsers = new Map<string, OscParser>();
+  private agentDetectors = new Map<string, AgentDetector>();
+  private toastManager = new ToastManager();
+
+  constructor(
+    private ptyManager: PTYManager,
+    private getWindow: () => BrowserWindow | null,
+  ) {}
+
+  setupDataForwarding(ptyId: string): void {
+    const instance = this.ptyManager.get(ptyId);
+    if (!instance) return;
+
+    const oscParser = new OscParser();
+    this.oscParsers.set(ptyId, oscParser);
+
+    const agentDetector = new AgentDetector();
+    this.agentDetectors.set(ptyId, agentDetector);
+
+    // Handle OSC events
+    oscParser.onOsc((event) => {
+      const win = this.getWindow();
+      if (!win || win.isDestroyed()) return;
+
+      switch (event.code) {
+        case 7: {
+          // CWD changed — data is typically file://host/path
+          const cwd = event.data.replace(/^file:\/\/[^/]*/, '');
+          win.webContents.send(IPC.CWD_CHANGED, ptyId, cwd);
+          break;
+        }
+        case 9:   // Windows Terminal notification
+        case 99:  // iTerm2 notification
+        case 777: // rxvt-unicode notification
+          // Silently ignore — no notification, no sound
+          break;
+      }
+    });
+
+    // Handle agent detection events — status tracking only, no notification/sound
+    agentDetector.onEvent(() => {
+      // Agent status is tracked internally by AgentDetector.
+      // No notification or sound — these fire too frequently and flood the UI.
+    });
+
+    // Handle critical action events — send approval request to renderer
+    agentDetector.onCritical((criticalEvent) => {
+      const win = this.getWindow();
+      if (!win || win.isDestroyed()) return;
+
+      win.webContents.send(IPC.APPROVAL_REQUEST, ptyId, {
+        action: criticalEvent.action,
+        riskLevel: criticalEvent.riskLevel,
+      });
+    });
+
+    instance.process.onData((data: string) => {
+      const win = this.getWindow();
+      if (win && !win.isDestroyed()) {
+        // Process data through OscParser (strips OSC sequences)
+        oscParser.process(data);
+        // Feed data to AgentDetector
+        agentDetector.feed(data);
+        // Forward raw data to renderer (xterm handles OSC itself)
+        win.webContents.send(IPC.PTY_DATA, ptyId, data);
+      }
+    });
+
+    instance.process.onExit(({ exitCode }) => {
+      const win = this.getWindow();
+      if (win && !win.isDestroyed()) {
+        win.webContents.send(IPC.PTY_EXIT, ptyId, exitCode);
+      }
+      this.oscParsers.delete(ptyId);
+      this.agentDetectors.delete(ptyId);
+      // Process already exited — remove from map without calling kill()
+      this.ptyManager.remove(ptyId);
+    });
+  }
+}