@wong2kim/wmux 1.0.0 → 1.0.1

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

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

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

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

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

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

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

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

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

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

@@ -1,52 +0,0 @@
-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'),
-  );
-}