@wong2kim/wmux 1.0.0

package/src/cli/commands/browser.ts

@@ -0,0 +1,128 @@
+import { sendRequest } from '../client';
+import { printResult, printError } from '../utils';
+import type { RpcResponse } from '../../shared/rpc';
+
+const BROWSER_HELP = `
+wmux browser — Scriptable Browser API
+
+USAGE
+  wmux browser <subcommand> [args]
+
+SUBCOMMANDS
+  snapshot                        Return the full page HTML (document.documentElement.outerHTML)
+  click <selector>                Click the first element matching the CSS selector
+  fill <selector> <text>          Set the value of an input matching the CSS selector
+  eval <code>                     Execute arbitrary JavaScript in the page context
+  navigate <url>                  Navigate the active browser surface to a URL
+
+EXAMPLES
+  wmux browser snapshot
+  wmux browser click "#submit-btn"
+  wmux browser fill "input[name=email]" "user@example.com"
+  wmux browser eval "document.title"
+  wmux browser navigate "https://example.com"
+`.trimStart();
+
+export async function handleBrowser(
+  args: string[],
+  jsonMode: boolean,
+): Promise<void> {
+  const sub = args[0];
+  const rest = args.slice(1);
+
+  if (!sub || sub === '--help' || sub === '-h') {
+    process.stdout.write(BROWSER_HELP);
+    process.exit(0);
+  }
+
+  let response: RpcResponse;
+
+  switch (sub) {
+    // ── browser snapshot ─────────────────────────────────────────────────────
+    case 'snapshot': {
+      response = await sendRequest('browser.snapshot', {});
+      if (jsonMode) {
+        printResult(response);
+      } else {
+        if (!response.ok) { printError(response); return; }
+        const r = response.result as { html?: string } | null;
+        process.stdout.write(r?.html ?? '');
+      }
+      break;
+    }
+
+    // ── browser click <selector> ─────────────────────────────────────────────
+    case 'click': {
+      const selector = rest[0];
+      if (!selector) {
+        console.error('Error: browser click requires <selector>');
+        process.exit(1);
+      }
+      response = await sendRequest('browser.click', { selector });
+      if (jsonMode) {
+        printResult(response);
+      } else {
+        if (!response.ok) { printError(response); return; }
+        console.log(`Clicked: ${selector}`);
+      }
+      break;
+    }
+
+    // ── browser fill <selector> <text> ───────────────────────────────────────
+    case 'fill': {
+      const selector = rest[0];
+      const text = rest.slice(1).join(' ');
+      if (!selector) {
+        console.error('Error: browser fill requires <selector> <text>');
+        process.exit(1);
+      }
+      response = await sendRequest('browser.fill', { selector, text });
+      if (jsonMode) {
+        printResult(response);
+      } else {
+        if (!response.ok) { printError(response); return; }
+        console.log(`Filled "${selector}" with "${text}"`);
+      }
+      break;
+    }
+
+    // ── browser eval <code> ──────────────────────────────────────────────────
+    case 'eval': {
+      const code = rest.join(' ');
+      if (!code) {
+        console.error('Error: browser eval requires <code>');
+        process.exit(1);
+      }
+      response = await sendRequest('browser.eval', { code });
+      if (jsonMode) {
+        printResult(response);
+      } else {
+        if (!response.ok) { printError(response); return; }
+        const r = response.result as { result?: unknown } | null;
+        console.log(JSON.stringify(r?.result, null, 2));
+      }
+      break;
+    }
+
+    // ── browser navigate <url> ───────────────────────────────────────────────
+    case 'navigate': {
+      const url = rest[0];
+      if (!url) {
+        console.error('Error: browser navigate requires <url>');
+        process.exit(1);
+      }
+      response = await sendRequest('browser.navigate', { url });
+      if (jsonMode) {
+        printResult(response);
+      } else {
+        if (!response.ok) { printError(response); return; }
+        console.log(`Navigated to: ${url}`);
+      }
+      break;
+    }
+
+    default:
+      console.error(`Unknown browser subcommand: "${sub}". Run 'wmux browser --help' for usage.`);
+      process.exit(1);
+  }
+}

package/src/cli/commands/input.ts

@@ -0,0 +1,72 @@
+import { sendRequest } from '../client';
+import { printResult, printError } from '../utils';
+import type { RpcResponse } from '../../shared/rpc';
+
+export async function handleInput(
+  cmd: string,
+  args: string[],
+  jsonMode: boolean
+): Promise<void> {
+  let response: RpcResponse;
+
+  switch (cmd) {
+    case 'send': {
+      const text = args.join(' ');
+      if (!text) {
+        console.error('Error: send requires <text>');
+        process.exit(1);
+      }
+      response = await sendRequest('input.send', { text });
+      if (jsonMode) {
+        printResult(response);
+      } else {
+        if (!response.ok) { printError(response); return; }
+        console.log('Text sent.');
+      }
+      break;
+    }
+
+    case 'send-key': {
+      const key = args[0];
+      if (!key) {
+        console.error('Error: send-key requires <keystroke>');
+        process.exit(1);
+      }
+      response = await sendRequest('input.sendKey', { key });
+      if (jsonMode) {
+        printResult(response);
+      } else {
+        if (!response.ok) { printError(response); return; }
+        console.log(`Key sent: ${key}`);
+      }
+      break;
+    }
+
+    case 'read-screen': {
+      response = await sendRequest('input.readScreen', {});
+      if (jsonMode) {
+        printResult(response);
+      } else {
+        if (!response.ok) { printError(response); return; }
+        // server returns { text: string } object or plain string
+        const result = response.result as { text?: string } | string;
+        let screen: string;
+        if (typeof result === 'object' && result !== null && 'text' in result) {
+          screen = result.text ?? '';
+        } else if (typeof result === 'string') {
+          screen = result;
+        } else {
+          console.log(JSON.stringify(result, null, 2));
+          break;
+        }
+        process.stdout.write(screen);
+        if (!screen.endsWith('\n')) process.stdout.write('\n');
+      }
+      break;
+    }
+
+    default:
+      console.error(`Unknown input command: ${cmd}`);
+      process.exit(1);
+  }
+}

package/src/cli/commands/notify.ts

@@ -0,0 +1,29 @@
+import { sendRequest } from '../client';
+import { printResult, printError, parseFlag } from '../utils';
+import type { RpcResponse } from '../../shared/rpc';
+
+export async function handleNotify(
+  args: string[],
+  jsonMode: boolean
+): Promise<void> {
+  const title = parseFlag(args, '--title');
+  const body = parseFlag(args, '--body');
+
+  if (!title) {
+    console.error('Error: notify requires --title <text>');
+    process.exit(1);
+  }
+  if (!body) {
+    console.error('Error: notify requires --body <text>');
+    process.exit(1);
+  }
+
+  const response: RpcResponse = await sendRequest('notify', { title, body });
+
+  if (jsonMode) {
+    printResult(response);
+  } else {
+    if (!response.ok) { printError(response); return; }
+    console.log(`Notification sent: "${title}"`);
+  }
+}

package/src/cli/commands/pane.ts

@@ -0,0 +1,90 @@
+import { sendRequest } from '../client';
+import { printResult, printError, parseFlag } from '../utils';
+import type { RpcResponse } from '../../shared/rpc';
+
+interface PaneInfo {
+  id: string;
+  type: 'leaf' | 'branch';
+  direction?: string;
+  activeSurfaceId?: string;
+}
+
+function formatPaneList(result: unknown): void {
+  const list = result as PaneInfo[];
+  if (!Array.isArray(list) || list.length === 0) {
+    console.log('No panes found.');
+    return;
+  }
+  const maxId = Math.max(...list.map((p) => p.id.length));
+  console.log('ID'.padEnd(maxId + 2) + 'TYPE'.padEnd(8) + 'DETAILS');
+  console.log('-'.repeat(maxId + 30));
+  for (const p of list) {
+    let details = '';
+    if (p.type === 'leaf' && p.activeSurfaceId) {
+      details = `active surface: ${p.activeSurfaceId}`;
+    } else if (p.type === 'branch' && p.direction) {
+      details = `direction: ${p.direction}`;
+    }
+    console.log(p.id.padEnd(maxId + 2) + p.type.padEnd(8) + details);
+  }
+}
+
+export async function handlePane(
+  cmd: string,
+  args: string[],
+  jsonMode: boolean
+): Promise<void> {
+  let response: RpcResponse;
+
+  switch (cmd) {
+    case 'list-panes': {
+      response = await sendRequest('pane.list', {});
+      if (jsonMode) {
+        printResult(response);
+      } else {
+        if (!response.ok) { printError(response); return; }
+        formatPaneList(response.result);
+      }
+      break;
+    }
+
+    case 'focus-pane': {
+      const id = args[0];
+      if (!id) {
+        console.error('Error: focus-pane requires <id>');
+        process.exit(1);
+      }
+      response = await sendRequest('pane.focus', { id });
+      if (jsonMode) {
+        printResult(response);
+      } else {
+        if (!response.ok) { printError(response); return; }
+        console.log(`Focused pane: ${id}`);
+      }
+      break;
+    }
+
+    case 'split': {
+      const direction = parseFlag(args, '--direction') ?? 'right';
+      if (direction !== 'right' && direction !== 'down') {
+        console.error('Error: --direction must be "right" or "down"');
+        process.exit(1);
+      }
+      // right → horizontal, down → vertical (server expects horizontal/vertical)
+      const dirMap: Record<string, string> = { right: 'horizontal', down: 'vertical' };
+      const mapped = dirMap[direction] || direction;
+      response = await sendRequest('pane.split', { direction: mapped });
+      if (jsonMode) {
+        printResult(response);
+      } else {
+        if (!response.ok) { printError(response); return; }
+        console.log(`Split pane ${direction}.`);
+      }
+      break;
+    }
+
+    default:
+      console.error(`Unknown pane command: ${cmd}`);
+      process.exit(1);
+  }
+}

package/src/cli/commands/surface.ts

@@ -0,0 +1,102 @@
+import { sendRequest } from '../client';
+import { printResult, printError } from '../utils';
+import type { RpcResponse } from '../../shared/rpc';
+
+interface SurfaceInfo {
+  id: string;
+  title: string;
+  shell: string;
+  cwd: string;
+}
+
+function formatSurfaceList(result: unknown): void {
+  const list = result as SurfaceInfo[];
+  if (!Array.isArray(list) || list.length === 0) {
+    console.log('No surfaces found.');
+    return;
+  }
+  const maxId = Math.max(...list.map((s) => s.id.length));
+  const maxTitle = Math.max(...list.map((s) => (s.title ?? '').length), 5);
+  console.log(
+    'ID'.padEnd(maxId + 2) +
+    'TITLE'.padEnd(maxTitle + 2) +
+    'SHELL'
+  );
+  console.log('-'.repeat(maxId + maxTitle + 20));
+  for (const s of list) {
+    console.log(
+      s.id.padEnd(maxId + 2) +
+      (s.title ?? '').padEnd(maxTitle + 2) +
+      (s.shell ?? '')
+    );
+  }
+}
+
+export async function handleSurface(
+  cmd: string,
+  args: string[],
+  jsonMode: boolean
+): Promise<void> {
+  let response: RpcResponse;
+
+  switch (cmd) {
+    case 'list-surfaces': {
+      response = await sendRequest('surface.list', {});
+      if (jsonMode) {
+        printResult(response);
+      } else {
+        if (!response.ok) { printError(response); return; }
+        formatSurfaceList(response.result);
+      }
+      break;
+    }
+
+    case 'new-surface': {
+      response = await sendRequest('surface.new', {});
+      if (jsonMode) {
+        printResult(response);
+      } else {
+        if (!response.ok) { printError(response); return; }
+        const s = response.result as SurfaceInfo;
+        console.log(`Created surface: ${s?.id ?? '(unknown)'}`);
+      }
+      break;
+    }
+
+    case 'focus-surface': {
+      const id = args[0];
+      if (!id) {
+        console.error('Error: focus-surface requires <id>');
+        process.exit(1);
+      }
+      response = await sendRequest('surface.focus', { id });
+      if (jsonMode) {
+        printResult(response);
+      } else {
+        if (!response.ok) { printError(response); return; }
+        console.log(`Focused surface: ${id}`);
+      }
+      break;
+    }
+
+    case 'close-surface': {
+      const id = args[0];
+      if (!id) {
+        console.error('Error: close-surface requires <id>');
+        process.exit(1);
+      }
+      response = await sendRequest('surface.close', { id });
+      if (jsonMode) {
+        printResult(response);
+      } else {
+        if (!response.ok) { printError(response); return; }
+        console.log(`Closed surface: ${id}`);
+      }
+      break;
+    }
+
+    default:
+      console.error(`Unknown surface command: ${cmd}`);
+      process.exit(1);
+  }
+}

package/src/cli/commands/system.ts

@@ -0,0 +1,95 @@
+import { sendRequest } from '../client';
+import { printResult, printError } from '../utils';
+import type { RpcResponse } from '../../shared/rpc';
+
+interface IdentifyResult {
+  app: string;
+  version: string;
+  platform: string;
+}
+
+export async function handleSystem(
+  cmd: string,
+  args: string[],
+  jsonMode: boolean
+): Promise<void> {
+  let response: RpcResponse;
+
+  switch (cmd) {
+    case 'identify': {
+      response = await sendRequest('system.identify', {});
+      if (jsonMode) {
+        printResult(response);
+      } else {
+        if (!response.ok) { printError(response); return; }
+        const info = response.result as IdentifyResult;
+        console.log(`app:      ${info?.app ?? 'wmux'}`);
+        console.log(`version:  ${info?.version ?? '1.0.0'}`);
+        console.log(`platform: ${info?.platform ?? process.platform}`);
+      }
+      break;
+    }
+
+    case 'capabilities': {
+      response = await sendRequest('system.capabilities', {});
+      if (jsonMode) {
+        printResult(response);
+      } else {
+        if (!response.ok) { printError(response); return; }
+        // server may return { methods: string[] } or string[] directly
+        const result = response.result as { methods?: string[] } | string[];
+        const methods = Array.isArray(result) ? result : (result?.methods || []);
+        if (methods.length > 0) {
+          console.log('Supported RPC methods:');
+          for (const m of methods) {
+            console.log(`  ${m}`);
+          }
+        } else {
+          console.log(JSON.stringify(response.result, null, 2));
+        }
+      }
+      break;
+    }
+
+    case 'set-status': {
+      const text = args[0];
+      if (text === undefined) {
+        console.error('Error: set-status requires <text>');
+        process.exit(1);
+      }
+      response = await sendRequest('meta.setStatus', { text });
+      if (jsonMode) {
+        printResult(response);
+      } else {
+        if (!response.ok) { printError(response); return; }
+        console.log(`Status set: "${text}"`);
+      }
+      break;
+    }
+
+    case 'set-progress': {
+      const raw = args[0];
+      if (raw === undefined) {
+        console.error('Error: set-progress requires <0-100>');
+        process.exit(1);
+      }
+      const value = Number(raw);
+      if (isNaN(value) || value < 0 || value > 100) {
+        console.error('Error: progress value must be a number between 0 and 100');
+        process.exit(1);
+      }
+      response = await sendRequest('meta.setProgress', { value });
+      if (jsonMode) {
+        printResult(response);
+      } else {
+        if (!response.ok) { printError(response); return; }
+        console.log(`Progress set: ${value}%`);
+      }
+      break;
+    }
+
+    default:
+      console.error(`Unknown system command: ${cmd}`);
+      process.exit(1);
+  }
+}

package/src/cli/commands/workspace.ts

@@ -0,0 +1,116 @@
+import { sendRequest } from '../client';
+import { printResult, printError, parseFlag } from '../utils';
+import type { RpcResponse } from '../../shared/rpc';
+
+interface WorkspaceInfo {
+  id: string;
+  name: string;
+  isActive?: boolean;
+}
+
+function formatWorkspaceList(result: unknown): void {
+  const list = result as WorkspaceInfo[];
+  if (!Array.isArray(list) || list.length === 0) {
+    console.log('No workspaces found.');
+    return;
+  }
+  const maxId = Math.max(...list.map((w) => w.id.length));
+  console.log(
+    'ID'.padEnd(maxId + 2) + 'NAME' + '    ' + 'STATUS'
+  );
+  console.log('-'.repeat(maxId + 30));
+  for (const ws of list) {
+    const active = ws.isActive ? ' (active)' : '';
+    console.log(ws.id.padEnd(maxId + 2) + ws.name + active);
+  }
+}
+
+function formatWorkspaceCurrent(result: unknown): void {
+  const ws = result as WorkspaceInfo | null;
+  if (!ws) {
+    console.log('No active workspace.');
+    return;
+  }
+  console.log(`Current workspace: ${ws.name} (${ws.id})`);
+}
+
+export async function handleWorkspace(
+  cmd: string,
+  args: string[],
+  jsonMode: boolean
+): Promise<void> {
+  let response: RpcResponse;
+
+  switch (cmd) {
+    case 'list-workspaces': {
+      response = await sendRequest('workspace.list', {});
+      if (jsonMode) {
+        printResult(response);
+      } else {
+        if (!response.ok) { printError(response); return; }
+        formatWorkspaceList(response.result);
+      }
+      break;
+    }
+
+    case 'new-workspace': {
+      const name = parseFlag(args, '--name') ?? `workspace-${Date.now()}`;
+      response = await sendRequest('workspace.new', { name });
+      if (jsonMode) {
+        printResult(response);
+      } else {
+        if (!response.ok) { printError(response); return; }
+        const ws = response.result as WorkspaceInfo;
+        console.log(`Created workspace: ${ws?.name ?? name} (${ws?.id ?? ''})`);
+      }
+      break;
+    }
+
+    case 'focus-workspace': {
+      const id = args[0];
+      if (!id) {
+        console.error('Error: focus-workspace requires <id>');
+        process.exit(1);
+      }
+      response = await sendRequest('workspace.focus', { id });
+      if (jsonMode) {
+        printResult(response);
+      } else {
+        if (!response.ok) { printError(response); return; }
+        console.log(`Focused workspace: ${id}`);
+      }
+      break;
+    }
+
+    case 'close-workspace': {
+      const id = args[0];
+      if (!id) {
+        console.error('Error: close-workspace requires <id>');
+        process.exit(1);
+      }
+      response = await sendRequest('workspace.close', { id });
+      if (jsonMode) {
+        printResult(response);
+      } else {
+        if (!response.ok) { printError(response); return; }
+        console.log(`Closed workspace: ${id}`);
+      }
+      break;
+    }
+
+    case 'current-workspace': {
+      response = await sendRequest('workspace.current', {});
+      if (jsonMode) {
+        printResult(response);
+      } else {
+        if (!response.ok) { printError(response); return; }
+        formatWorkspaceCurrent(response.result);
+      }
+      break;
+    }
+
+    default:
+      console.error(`Unknown workspace command: ${cmd}`);
+      process.exit(1);
+  }
+}