@ebowwa/coder 0.7.64 → 0.7.65

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

@@ -6,19 +6,130 @@
  * This is a thin orchestrator that:
  * 1. Parses arguments
  * 2. Sets up session (config, MCP, hooks)
- * 3. Dispatches to TUI or single-query mode
+ * 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 { runInteractiveTUI } from "../tui/index.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 {
@@ -59,11 +170,15 @@ async function main(): Promise<void> {
   // 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
@@ -119,6 +234,64 @@ async function main(): Promise<void> {
     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 = {
@@ -130,6 +303,9 @@ async function main(): Promise<void> {
     };
     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
@@ -144,7 +320,8 @@ async function main(): Promise<void> {
       messages,
       sessionId,
       setup.mcpClients,
-      setup.permissionMode
+      setup.permissionMode,
+      teammateRunner
     );
   } else {
     // Single query mode
@@ -159,6 +336,7 @@ async function main(): Promise<void> {
       hookManager: setup.hookManager,
       workingDirectory: process.cwd(),
       gitStatus,
+      permissionMode: setup.permissionMode,
     });
   }
 }
@@ -178,28 +356,29 @@ async function runInteractiveMode(
   messages: Message[],
   sessionId: string,
   mcpClients: Map<string, MCPClientImpl>,
-  permissionMode: PermissionMode
+  permissionMode: PermissionMode,
+  teammateRunner: TeammateModeRunner | null = null
 ): Promise<void> {
-  // Check if stdin is a TTY (interactive terminal)
+  // Note: PTY wrapper check already ran at module load time
+  // This check is for non-doppler environments without TTY
   const isInteractive = process.stdin.isTTY;
-
-  // Allow force-interactive mode for testing
   const forceInteractive = process.env.CLAUDE_FORCE_INTERACTIVE === "true";
 
   if (!isInteractive && !forceInteractive) {
-    console.error("Error: Interactive mode requires a TTY. Use -q for single query mode.");
-    console.error("       Or set CLAUDE_FORCE_INTERACTIVE=true for testing.");
+    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 TUI
+  // Create a mutable session ID holder for the interactive runner
   let currentSessionId = sessionId;
   const setSessionId = (newId: string) => {
     currentSessionId = newId;
   };
 
-  // Run the Ink-based React TUI
-  await runInteractiveTUI({
+  // Run the non-React interactive CLI
+  const runner = new InteractiveRunner({
     apiKey,
     model: args.model,
     permissionMode,
@@ -212,10 +391,18 @@ async function runInteractiveMode(
     setSessionId,
     initialMessages: messages,
     workingDirectory: process.cwd(),
-    onExit: () => {
+    teammateRunner,
+    onExit: async () => {
+      // Cleanup teammate mode
+      if (teammateRunner) {
+        await teammateRunner.stop();
+        setTeammateRunner(null);
+      }
       console.log("\n\x1b[90mGoodbye!\x1b[0m");
     },
   });
+
+  await runner.start();
 }
 
 // ============================================

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();
+}