@ebowwa/coder 0.7.63 → 0.7.65

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

@@ -0,0 +1,415 @@
+#!/usr/bin/env bun
+/**
+ * Coder - CLI Entry Point
+ * AI-powered terminal coding assistant
+ *
+ * This is a thin orchestrator that:
+ * 1. Parses arguments
+ * 2. Sets up session (config, MCP, hooks)
+ * 3. Initializes teammate mode if enabled
+ * 4. Dispatches to TUI or single-query mode
+ */
+
+// ============================================
+// PTY WRAPPER DETECTION (must run before any other code)
+// ============================================
+
+import { spawn, spawnSync } from "node:child_process";
+import process from "node:process";
+
+/**
+ * Check if we're running under doppler without a TTY and need a PTY wrapper
+ * This must run before any other code to properly handle the TTY requirement
+ *
+ * When successful wrapping occurs, this function NEVER returns - it exits the process
+ * when the wrapped child exits.
+ */
+function checkPtyWrapper(): void {
+  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";
+
+  // Skip if we have a TTY, force interactive, have a query, version, help, or already wrapped
+  if (isTTY || forceInteractive || hasQuery || hasVersion || hasHelp || alreadyWrapped) {
+    return;
+  }
+
+  // If under doppler without TTY, try to wrap with unbuffer
+  if (isDoppler) {
+    const result = tryWrapWithUnbuffer();
+    if (result.wrapped && result.child) {
+      // Successfully wrapped - child is running
+      // Wait for child to exit, then exit parent with same code
+      result.child.on("exit", (code: number | null) => {
+        process.exit(code ?? 1);
+      });
+      // Prevent further execution by keeping parent alive
+      // The exit handler above will terminate this process
+      setInterval(() => {
+        /* keep alive */
+      }, 10000);
+      return; // TypeScript needs this
+    }
+
+    // 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);
+  }
+}
+
+/**
+ * Try to wrap execution with unbuffer to provide a PTY
+ * @returns Object with wrapped status and child process if successful
+ */
+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 before any other code
+checkPtyWrapper();
+
+// ============================================
+// MAIN IMPORTS
+// ============================================
+
+import type { Message } from "../../../../types/index.js";
+import type { ToolDefinition, PermissionMode } from "../../../../types/index.js";
+import type { builtInTools } from "../../../../ecosystem/tools/index.js";
+import type { HookManager } from "../../../../ecosystem/hooks/index.js";
+import type { SkillManager } from "../../../../ecosystem/skills/index.js";
+import type { MCPClientImpl } from "../../../mcp/client.js";
+import type { TeammateMessage } from "../../../../types/index.js";
+import { SessionStore, printSessionsList } from "../../../../core/session-store.js";
+import { getGitStatus } from "../../../../core/git-status.js";
+import { renderStatusLine, getContextWindow, VERSION, type StatusLineOptions } from "../shared/status-line.js";
+import { InteractiveRunner } from "./interactive/index.js";
+import type { InteractiveRunnerProps } from "./interactive/types.js";
+import {
+  TeammateModeRunner,
+  setTeammateRunner,
+  isTeammateModeActive,
+} from "../../../../teammates/runner.js";
+
+// Shared modules
+import {
+  parseArgs,
+  requireApiKey,
+  setupSession,
+  buildCompleteSystemPrompt,
+  runSingleQuery,
+} from "../shared/index.js";
+
+// ============================================
+// MAIN ENTRY POINT
+// ============================================
+
+async function main(): Promise<void> {
+  const args = parseArgs();
+
+  // Handle --version flag
+  if (args.showVersion) {
+    console.log(`Coder v${VERSION}`);
+    console.log(`Model: ${args.model}`);
+    console.log(`Node: ${process.version}`);
+    console.log(`Platform: ${process.platform} ${process.arch}`);
+    process.exit(0);
+  }
+
+  // Initialize session store
+  const sessionStore = new SessionStore();
+  await sessionStore.init();
+
+  // Handle --sessions flag
+  if (args.listSessions) {
+    const sessions = await sessionStore.listSessions(20);
+    printSessionsList(sessions);
+    process.exit(0);
+  }
+
+  // Get API key
+  const apiKey = requireApiKey();
+
+  // Determine if we'll be in interactive TUI mode (no query = interactive)
+  const isInteractiveMode = !args.query;
+
+  // Setup session (config, MCP, hooks, skills)
+  const setup = await setupSession({
+    args,
+    apiKey,
+    workingDirectory: process.cwd(),
+    isTuiMode: isInteractiveMode, // Disable console logging in TUI mode
+  });
+
+  // Get git status for system prompt
+  const gitStatus = await getGitStatus(process.cwd());
+
+  // Build system prompt
+  const systemPrompt = await buildCompleteSystemPrompt(process.cwd(), {
+    systemPrompt: args.systemPrompt,
+    appendSystemPrompt: args.appendSystemPrompt,
+    teammateMode: args.teammateMode,
+    agentId: args.agentId,
+    agentName: args.agentName,
+    teamName: args.teamName,
+  });
+
+  // Handle session resume
+  let messages: Message[] = [];
+  let sessionId: string;
+
+  if (args.resumeSession) {
+    const loadedSession = await sessionStore.resumeSession(args.resumeSession);
+    if (!loadedSession) {
+      console.error(`Error: Session not found: ${args.resumeSession}`);
+      process.exit(1);
+    }
+
+    messages = loadedSession.messages;
+    sessionId = args.resumeSession;
+
+    // Update args from session metadata
+    args.model = loadedSession.metadata.model as typeof args.model;
+    args.agentName = loadedSession.metadata.agentName;
+    args.agentColor = loadedSession.metadata.agentColor;
+    args.teamName = loadedSession.metadata.teamName;
+
+    console.log(`\x1b[90mResumed session: ${args.resumeSession}\x1b[0m`);
+    console.log(`\x1b[90mModel: ${args.model} | Messages: ${messages.length}\x1b[0m\n`);
+  } else {
+    // Create new session
+    sessionId = await sessionStore.createSession({
+      model: args.model,
+      workingDirectory: process.cwd(),
+      agentName: args.agentName,
+      agentColor: args.agentColor,
+      teamName: args.teamName,
+    });
+  }
+
+  // Get initial query
+  let query = args.query;
+  const firstArg = process.argv[2];
+  if (!query && process.argv.length > 2 && firstArg && !firstArg.startsWith("-")) {
+    query = process.argv.slice(2).join(" ");
+  }
+
+  // ============================================
+  // TEAMMATE MODE INITIALIZATION
+  // ============================================
+
+  let teammateRunner: TeammateModeRunner | null = null;
+  let pendingTeammateMessages: TeammateMessage[] = [];
+
+  if (args.teammateMode && args.teamName) {
+    try {
+      teammateRunner = new TeammateModeRunner({
+        teamName: args.teamName,
+        agentId: args.agentId,
+        agentName: args.agentName,
+        agentColor: args.agentColor,
+        prompt: args.systemPrompt,
+        workingDirectory: process.cwd(),
+        onMessage: (message: TeammateMessage) => {
+          // Queue message for injection into conversation
+          pendingTeammateMessages.push(message);
+          console.log(`\x1b[90m[Teammate] Message from ${message.from}: ${message.content.slice(0, 50)}...\x1b[0m`);
+        },
+        onIdle: () => {
+          console.log(`\x1b[90m[Teammate] Now idle, waiting for tasks...\x1b[0m`);
+        },
+        pollInterval: 2000,
+      });
+
+      const teammate = await teammateRunner.start();
+
+      // Set global reference for tools to access
+      setTeammateRunner(teammateRunner);
+
+      console.log(`\x1b[90m[Teammate] Joined team "${args.teamName}" as ${teammate.name} (${teammate.teammateId})\x1b[0m`);
+    } catch (error) {
+      console.error(`\x1b[31mError starting teammate mode: ${error}\x1b[0m`);
+      teammateRunner = null;
+    }
+  }
+
+  // Cleanup handler
+  const cleanup = async () => {
+    if (teammateRunner) {
+      console.log(`\x1b[90m[Teammate] Stopping teammate mode...\x1b[0m`);
+      await teammateRunner.stop();
+      setTeammateRunner(null);
+    }
+  };
+
+  process.on("SIGINT", async () => {
+    await cleanup();
+    process.exit(0);
+  });
+
+  process.on("SIGTERM", async () => {
+    await cleanup();
+    process.exit(0);
+  });
+
+  if (!query) {
+    // Show initial status line
+    const initialStatusOptions: StatusLineOptions = {
+      permissionMode: setup.permissionMode,
+      tokensUsed: 0,
+      maxTokens: getContextWindow(args.model),
+      model: args.model,
+      isLoading: false,
+    };
+    console.log(`\x1b[90m${renderStatusLine(initialStatusOptions)}\x1b[0m`);
+    console.log(`\x1b[90mSession: ${sessionId}\x1b[0m`);
+    if (teammateRunner) {
+      console.log(`\x1b[90mTeammate Mode: Active | Team: ${args.teamName}\x1b[0m`);
+    }
+    console.log("\x1b[90mType your message, ? for help, or /help for commands.\x1b[0m\n");
+
+    // Interactive mode
+    await runInteractiveMode(
+      apiKey,
+      args,
+      systemPrompt,
+      setup.tools,
+      setup.hookManager,
+      setup.skillManager,
+      sessionStore,
+      messages,
+      sessionId,
+      setup.mcpClients,
+      setup.permissionMode,
+      teammateRunner
+    );
+  } else {
+    // Single query mode
+    await runSingleQuery({
+      apiKey,
+      args,
+      systemPrompt,
+      tools: setup.tools,
+      query,
+      sessionStore,
+      sessionId,
+      hookManager: setup.hookManager,
+      workingDirectory: process.cwd(),
+      gitStatus,
+      permissionMode: setup.permissionMode,
+    });
+  }
+}
+
+// ============================================
+// INTERACTIVE MODE
+// ============================================
+
+async function runInteractiveMode(
+  apiKey: string,
+  args: Awaited<ReturnType<typeof parseArgs>>,
+  systemPrompt: string,
+  tools: ToolDefinition[],
+  hookManager: HookManager,
+  skillManager: SkillManager,
+  sessionStore: SessionStore,
+  messages: Message[],
+  sessionId: string,
+  mcpClients: Map<string, MCPClientImpl>,
+  permissionMode: PermissionMode,
+  teammateRunner: TeammateModeRunner | null = null
+): Promise<void> {
+  // Note: PTY wrapper check already ran at module load time
+  // This check is for non-doppler environments without TTY
+  const isInteractive = process.stdin.isTTY;
+  const forceInteractive = process.env.CLAUDE_FORCE_INTERACTIVE === "true";
+
+  if (!isInteractive && !forceInteractive) {
+    console.error("Error: Interactive mode requires a TTY.");
+    console.error("");
+    console.error("Use -q for single query mode, or set CLAUDE_FORCE_INTERACTIVE=true.");
+    return;
+  }
+
+  // Create a mutable session ID holder for the interactive runner
+  let currentSessionId = sessionId;
+  const setSessionId = (newId: string) => {
+    currentSessionId = newId;
+  };
+
+  // Run the non-React interactive CLI
+  const runner = new InteractiveRunner({
+    apiKey,
+    model: args.model,
+    permissionMode,
+    maxTokens: args.maxTokens,
+    systemPrompt,
+    tools,
+    hookManager,
+    sessionStore,
+    sessionId: currentSessionId,
+    setSessionId,
+    initialMessages: messages,
+    workingDirectory: process.cwd(),
+    teammateRunner,
+    onExit: async () => {
+      // Cleanup teammate mode
+      if (teammateRunner) {
+        await teammateRunner.stop();
+        setTeammateRunner(null);
+      }
+      console.log("\n\x1b[90mGoodbye!\x1b[0m");
+    },
+  });
+
+  await runner.start();
+}
+
+// ============================================
+// RUN MAIN
+// ============================================
+
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});

package/packages/src/interfaces/ui/terminal/cli/interactive/index.ts

@@ -0,0 +1,110 @@
+/**
+ * CLI Interactive Module
+ *
+ * Non-React implementation of the interactive CLI mode.
+ * Extracts core patterns from v1 TUI without the Ink dependency.
+ *
+ * This module provides:
+ * - MessageStore: Centralized message state management
+ * - InputManager: Priority-based keyboard input handling
+ * - InteractiveRunner: Main interactive loop with agent integration
+ * - Type definitions for all components
+ *
+ * Usage:
+ * ```ts
+ * import { InteractiveRunner, MessageStoreImpl, InputManagerImpl } from "./interactive/index.js";
+ *
+ * // Create and run interactive mode
+ * const runner = new InteractiveRunner({
+ *   apiKey: process.env.API_KEY!,
+ *   model: "claude-sonnet-4-6",
+ *   // ... other props
+ * });
+ *
+ * await runner.start();
+ * ```
+ *
+ * Architecture:
+ * - MessageStore: Single source of truth for messages (non-React)
+ * - InputManager: Centralized keyboard input with priority system
+ * - InteractiveRunner: Main loop that orchestrates everything
+ *
+ * Patterns from v1 TUI:
+ * - MessageStore pattern: addMessage, addApiMessages, addSystem, clear, replace
+ * - InputContext pattern: register, focus, dispatch, blocked state
+ * - Clean separation of concerns
+ * - Well-defined TypeScript interfaces
+ */
+
+// ============================================
+// TYPES
+// ============================================
+
+export type {
+  // Message types
+  UIMessage,
+  MessageSubType,
+  MessageStore,
+
+  // Input types
+  InputManager,
+  InputHandler,
+  InputHandlerOptions,
+  NativeKeyEvent,
+
+  // Runner types
+  InteractiveRunnerProps,
+  InteractiveState,
+  SessionStore,
+  SessionInfo,
+  CommandContext,
+
+  // Context types
+  ContextInfo,
+} from "./types.js";
+
+export { InputPriority } from "./types.js";
+
+// ============================================
+// MESSAGE STORE
+// ============================================
+
+export {
+  MessageStoreImpl,
+  getMessageStore,
+  resetMessageStore,
+} from "./message-store.js";
+
+// ============================================
+// INPUT HANDLER
+// ============================================
+
+export {
+  InputManagerImpl,
+  getInputManager,
+  resetInputManager,
+  KeyEvents,
+} from "./input-handler.js";
+
+// ============================================
+// INTERACTIVE RUNNER
+// ============================================
+
+import { InteractiveRunner as _InteractiveRunner } from "./interactive-runner.js";
+
+export { _InteractiveRunner as InteractiveRunner };
+
+// ============================================
+// CONVENIENCE FUNCTIONS
+// ============================================
+
+/**
+ * Run interactive mode with the given props
+ * Convenience function that creates and starts an InteractiveRunner
+ */
+export async function runInteractiveMode(
+  props: import("./types.js").InteractiveRunnerProps
+): Promise<void> {
+  const runner = new _InteractiveRunner(props);
+  await runner.start();
+}