@ebowwa/coder 0.7.64 → 0.7.66

package/packages/src/interfaces/ui/terminal/bridge/types.ts

@@ -0,0 +1,226 @@
+/**
+ * TUI Bridge Types
+ * Type definitions for external control via TUI Bridge MCP
+ */
+
+import type { PermissionMode } from "../../../../types/index.js";
+
+/**
+ * Bridge event types that can be sent to external controllers
+ */
+export type BridgeEventType =
+  | "state_update"
+  | "message_added"
+  | "message_updated"
+  | "loading_changed"
+  | "model_changed"
+  | "session_changed"
+  | "command_executed"
+  | "error";
+
+/**
+ * Bridge state snapshot for external controllers
+ */
+export interface BridgeState {
+  /** Current session ID */
+  sessionId: string;
+  /** Current model */
+  model: string;
+  /** Permission mode */
+  permissionMode: PermissionMode;
+  /** Is currently processing */
+  isLoading: boolean;
+  /** Total messages count */
+  messageCount: number;
+  /** Working directory */
+  workingDirectory: string;
+  /** Tokens used */
+  tokensUsed: number;
+  /** Total cost */
+  totalCost: number;
+  /** Timestamp */
+  timestamp: number;
+}
+
+/**
+ * Bridge event payload
+ */
+export interface BridgeEvent<T = unknown> {
+  /** Event type */
+  type: BridgeEventType;
+  /** Event payload */
+  payload: T;
+  /** Timestamp */
+  timestamp: number;
+}
+
+/**
+ * Bridge event map for type-safe event handling
+ */
+export interface BridgeEventMap {
+  state_update: BridgeState;
+  message_added: { id: string; content: string; role: "user" | "assistant" | "system" };
+  message_updated: { id: string; content: string };
+  loading_changed: { isLoading: boolean };
+  model_changed: { model: string };
+  session_changed: { sessionId: string };
+  command_executed: BridgeCommand;
+  error: { message: string; code?: string };
+}
+
+/**
+ * Command that can be sent to coder via bridge
+ */
+export type BridgeCommand =
+  | { type: "send_message"; content: string }
+  | { type: "execute_command"; command: string }
+  | { type: "set_model"; model: string }
+  | { type: "clear_messages" }
+  | { type: "export_session"; format: "jsonl" | "json" | "markdown" }
+  | { type: "get_state" }
+  | { type: "get_screen" };
+
+/**
+ * Bridge command result
+ */
+export interface BridgeCommandResult<T = unknown> {
+  /** Whether command succeeded */
+  success: boolean;
+  /** Result data if any */
+  data?: T;
+  /** Error message if failed */
+  error?: string;
+}
+
+/**
+ * TUI Bridge configuration
+ */
+export interface TUIBridgeConfig {
+  /** Enable bridge mode */
+  enabled: boolean;
+  /** Unix socket path for IPC */
+  socketPath?: string;
+  /** Port for HTTP bridge */
+  httpPort?: number;
+  /** Callback for external events */
+  onEvent?: (event: BridgeEvent) => void;
+}
+
+/**
+ * Screen buffer cell for TUI parsing
+ */
+export interface ScreenCell {
+  /** Character at this position */
+  char: string;
+  /** Foreground color */
+  fg?: string;
+  /** Background color */
+  bg?: string;
+  /** Text attributes */
+  bold?: boolean;
+  italic?: boolean;
+  underline?: boolean;
+  dim?: boolean;
+  inverse?: boolean;
+}
+
+/**
+ * Screen buffer representation
+ */
+export interface ScreenBuffer {
+  /** Screen width */
+  width: number;
+  /** Screen height */
+  height: number;
+  /** 2D array of cells [row][col] */
+  cells: ScreenCell[][];
+  /** Cursor position */
+  cursor: { x: number; y: number; visible: boolean };
+  /** Timestamp */
+  timestamp: number;
+}
+
+/**
+ * Parsed screen content
+ */
+export interface ParsedScreen {
+  /** Plain text content */
+  text: string;
+  /** Screen buffer */
+  buffer: ScreenBuffer;
+  /** Detected UI elements */
+  elements: UIElement[];
+  /** Timestamp */
+  timestamp: number;
+}
+
+/**
+ * Detected UI element types
+ */
+export type UIElementType =
+  | "button"
+  | "input"
+  | "menu"
+  | "menu_item"
+  | "list"
+  | "list_item"
+  | "dialog"
+  | "text"
+  | "header"
+  | "footer";
+
+/**
+ * Detected UI element in the screen
+ */
+export interface UIElement {
+  /** Element type */
+  type: UIElementType;
+  /** Bounding box */
+  bounds: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+  /** Text content */
+  text: string;
+  /** Is focused/selected */
+  focused?: boolean;
+  /** Is clickable */
+  clickable?: boolean;
+}
+
+/**
+ * Bridge message format for IPC
+ */
+export interface BridgeMessage {
+  /** Message ID for request/response correlation */
+  id: string;
+  /** Message type */
+  type: "request" | "response" | "event";
+  /** Method name (for requests) */
+  method?: string;
+  /** Parameters (for requests) */
+  params?: unknown;
+  /** Result (for responses) */
+  result?: unknown;
+  /** Error (for error responses) */
+  error?: { code: number; message: string };
+  /** Event data (for events) */
+  event?: BridgeEvent;
+}
+
+/**
+ * Bridge methods available for external control
+ */
+export type BridgeMethod =
+  | "getState"
+  | "sendMessage"
+  | "executeCommand"
+  | "setModel"
+  | "clearMessages"
+  | "exportSession"
+  | "getScreen"
+  | "parseScreen"
+  | "subscribe"
+  | "unsubscribe";

package/packages/src/interfaces/ui/terminal/bridge/useBridge.ts

@@ -0,0 +1,210 @@
+/**
+ * useBridge Hook
+ * React hook for TUI Bridge integration
+ */
+
+import { useCallback, useEffect, useState, useRef } from "react";
+import { TUIBridge } from "./index.js";
+import type {
+  BridgeState,
+  BridgeEvent,
+  BridgeCommand,
+  BridgeCommandResult,
+  TUIBridgeConfig,
+} from "./types.js";
+
+/**
+ * Hook options
+ */
+export interface UseBridgeOptions {
+  /** Enable bridge mode */
+  enabled?: boolean;
+  /** Unix socket path */
+  socketPath?: string;
+  /** HTTP port */
+  httpPort?: number;
+  /** Event callback */
+  onEvent?: (event: BridgeEvent) => void;
+}
+
+/**
+ * Hook return type
+ */
+export interface UseBridgeReturn {
+  /** Bridge instance */
+  bridge: TUIBridge | null;
+  /** Current state */
+  state: BridgeState | null;
+  /** Is bridge enabled */
+  isEnabled: boolean;
+  /** Update state */
+  updateState: (state: Partial<BridgeState>) => void;
+  /** Execute command */
+  executeCommand: (command: BridgeCommand) => Promise<BridgeCommandResult>;
+  /** Emit event */
+  emitEvent: <T>(type: BridgeEvent<T>["type"], payload: T) => void;
+  /** Last received command */
+  lastCommand: BridgeCommand | null;
+  /** Clear last command */
+  clearLastCommand: () => void;
+}
+
+/**
+ * Hook for TUI Bridge integration
+ */
+export function useBridge(options: UseBridgeOptions = {}): UseBridgeReturn {
+  const { enabled = false, socketPath, httpPort, onEvent } = options;
+
+  const [state, setState] = useState<BridgeState | null>(null);
+  const [lastCommand, setLastCommand] = useState<BridgeCommand | null>(null);
+  const bridgeRef = useRef<TUIBridge | null>(null);
+
+  // Initialize bridge
+  useEffect(() => {
+    if (!enabled) {
+      return;
+    }
+
+    const config: TUIBridgeConfig = {
+      enabled,
+      socketPath,
+      httpPort,
+      onEvent: (event) => {
+        // Update local state on state_update events
+        if (event.type === "state_update") {
+          setState(event.payload as BridgeState);
+        }
+        // Call user callback
+        onEvent?.(event);
+      },
+    };
+
+    bridgeRef.current = TUIBridge.init(config);
+
+    return () => {
+      bridgeRef.current?.destroy();
+      bridgeRef.current = null;
+    };
+  }, [enabled, socketPath, httpPort, onEvent]);
+
+  // Listen for command events
+  useEffect(() => {
+    if (!bridgeRef.current) {
+      return;
+    }
+
+    const handleCommand = (event: BridgeEvent) => {
+      if (event.type === "command_executed") {
+        setLastCommand(event.payload as BridgeCommand);
+      }
+    };
+
+    bridgeRef.current.on("event", handleCommand);
+
+    return () => {
+      bridgeRef.current?.off("event", handleCommand);
+    };
+  }, [enabled]);
+
+  const updateState = useCallback((newState: Partial<BridgeState>) => {
+    bridgeRef.current?.updateState(newState);
+    setState((prev) => (prev ? { ...prev, ...newState } : null));
+  }, []);
+
+  const executeCommand = useCallback(async (command: BridgeCommand): Promise<BridgeCommandResult> => {
+    if (!bridgeRef.current) {
+      return { success: false, error: "Bridge not initialized" };
+    }
+    return bridgeRef.current.executeCommand(command);
+  }, []);
+
+  const emitEvent = useCallback(<T,>(type: BridgeEvent<T>["type"], payload: T) => {
+    bridgeRef.current?.emitEvent(type, payload);
+  }, []);
+
+  const clearLastCommand = useCallback(() => {
+    setLastCommand(null);
+  }, []);
+
+  return {
+    bridge: bridgeRef.current,
+    state,
+    isEnabled: enabled && bridgeRef.current !== null,
+    updateState,
+    executeCommand,
+    emitEvent,
+    lastCommand,
+    clearLastCommand,
+  };
+}
+
+/**
+ * Hook for handling bridge commands in TUI components
+ */
+export interface UseBridgeCommandHandlerOptions {
+  /** Bridge instance from useBridge */
+  bridge: TUIBridge | null;
+  /** Handler for send_message commands */
+  onSendMessage?: (content: string) => void;
+  /** Handler for execute_command commands */
+  onExecuteCommand?: (command: string) => void;
+  /** Handler for set_model commands */
+  onSetModel?: (model: string) => void;
+  /** Handler for clear_messages commands */
+  onClearMessages?: () => void;
+  /** Handler for export_session commands */
+  onExportSession?: (format: "jsonl" | "json" | "markdown") => void;
+}
+
+/**
+ * Hook for handling bridge commands
+ */
+export function useBridgeCommandHandler(options: UseBridgeCommandHandlerOptions): void {
+  const { bridge, onSendMessage, onExecuteCommand, onSetModel, onClearMessages, onExportSession } = options;
+
+  useEffect(() => {
+    if (!bridge) {
+      return;
+    }
+
+    const handleEvent = async (event: BridgeEvent) => {
+      if (event.type !== "command_executed") {
+        return;
+      }
+
+      const command = event.payload as BridgeCommand;
+
+      switch (command.type) {
+        case "send_message":
+          onSendMessage?.(command.content);
+          break;
+
+        case "execute_command":
+          onExecuteCommand?.(command.command);
+          break;
+
+        case "set_model":
+          onSetModel?.(command.model);
+          break;
+
+        case "clear_messages":
+          onClearMessages?.();
+          break;
+
+        case "export_session":
+          onExportSession?.(command.format);
+          break;
+
+        case "get_state":
+          // Already handled by bridge
+          break;
+      }
+    };
+
+    bridge.on("event", handleEvent);
+
+    return () => {
+      bridge.off("event", handleEvent);
+    };
+  }, [bridge, onSendMessage, onExecuteCommand, onSetModel, onClearMessages, onExportSession]);
+}

package/packages/src/interfaces/ui/terminal/cli/bootstrap.ts

@@ -0,0 +1,132 @@
+#!/usr/bin/env bun
+/**
+ * CLI Bootstrap - PTY Wrapper Detection
+ *
+ * This file MUST run before any other imports to handle PTY wrapping.
+ * ES modules hoist imports, so we need a separate entry point.
+ *
+ * Usage: bun bootstrap.ts [args...]
+ */
+
+import { spawn, spawnSync } from "node:child_process";
+import process from "node:process";
+
+/**
+ * Check if we need PTY wrapping and handle it
+ * Returns true if we should continue to main module, false if we're the parent waiting
+ */
+function checkPtyWrapper(): boolean {
+  const isTTY = process.stdin.isTTY;
+  const isDoppler = !!process.env.DOPPLER_TOKEN;
+  const forceInteractive = process.env.CLAUDE_FORCE_INTERACTIVE === "true";
+  const hasQuery = process.argv.includes("-q") || process.argv.includes("--query");
+  const hasVersion = process.argv.includes("--version") || process.argv.includes("-v");
+  const hasHelp = process.argv.includes("--help") || process.argv.includes("-h");
+  const alreadyWrapped = process.env.CODER_PTY_WRAPPED === "1";
+
+  // Debug output
+  if (process.env.CODER_DEBUG === "1") {
+    console.error("[bootstrap] isTTY:", isTTY);
+    console.error("[bootstrap] isDoppler:", isDoppler);
+    console.error("[bootstrap] alreadyWrapped:", alreadyWrapped);
+    console.error("[bootstrap] forceInteractive:", forceInteractive);
+  }
+
+  // Skip if we have a TTY, force interactive, have a query, version, help, or already wrapped
+  if (isTTY || forceInteractive || hasQuery || hasVersion || hasHelp || alreadyWrapped) {
+    if (process.env.CODER_DEBUG === "1") {
+      console.error("[bootstrap] Skipping wrapper - conditions met");
+    }
+    return true; // Continue to main module
+  }
+
+  // If under doppler without TTY, try to wrap with unbuffer
+  if (isDoppler) {
+    if (process.env.CODER_DEBUG === "1") {
+      console.error("[bootstrap] Attempting PTY wrap...");
+    }
+    const result = tryWrapWithUnbuffer();
+    if (process.env.CODER_DEBUG === "1") {
+      console.error("[bootstrap] Wrap result:", result.wrapped ? "success" : "failed");
+    }
+    if (result.wrapped && result.child) {
+      // Successfully wrapped - child is running
+      // Wait for child to exit, then exit parent with same code
+      const child = result.child;
+      child.on("exit", (code: number | null) => {
+        process.exit(code ?? 1);
+      });
+      child.on("error", (err: Error) => {
+        console.error("Child process error:", err.message);
+        process.exit(1);
+      });
+
+      // Keep parent alive
+      process.stdin.resume();
+      setInterval(() => {
+        /* keep alive */
+      }, 60000);
+
+      return false; // Don't continue - parent just waits
+    }
+
+    // Failed to wrap - show helpful error
+    console.error("Error: Interactive mode requires a TTY.");
+    console.error("");
+    console.error("When using 'doppler run', TTY is not passed through.");
+    console.error("");
+    console.error("Install 'expect' package for automatic PTY support:");
+    console.error("  macOS:   brew install expect");
+    console.error("  Ubuntu:  sudo apt install expect");
+    console.error("  Fedora:  sudo dnf install expect");
+    console.error("");
+    console.error("Or use one of these alternatives:");
+    console.error("  1. Single query:    doppler run -- coder -q \"your question\"");
+    console.error("  2. Export secrets:  doppler secrets download --no-file && coder");
+    console.error("  3. Force simple:    CLAUDE_FORCE_INTERACTIVE=true doppler run -- coder");
+    console.error("  4. With unbuffer:   unbuffer doppler run -- coder");
+    process.exit(1);
+  }
+
+  return true; // Continue to main module
+}
+
+/**
+ * Try to wrap execution with unbuffer to provide a PTY
+ */
+function tryWrapWithUnbuffer(): { wrapped: boolean; child?: ReturnType<typeof spawn> } {
+  try {
+    // Check if unbuffer is available
+    const checkResult = spawnSync("which", ["unbuffer"], {
+      stdio: "ignore",
+      timeout: 1000,
+    });
+
+    if (checkResult.status !== 0) {
+      return { wrapped: false };
+    }
+
+    // Re-exec ourselves with unbuffer
+    const args = [process.execPath, ...process.argv.slice(1)];
+    const child = spawn("unbuffer", args, {
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        CODER_PTY_WRAPPED: "1",
+      },
+    });
+
+    return { wrapped: true, child };
+  } catch {
+    return { wrapped: false };
+  }
+}
+
+// Run PTY check and conditionally load main module
+if (checkPtyWrapper()) {
+  // Dynamic import of main module - only after PTY check passes
+  import("./index.js").catch((err) => {
+    console.error("Failed to load main module:", err);
+    process.exit(1);
+  });
+}