@abacus-ai/cli 2.0.0-canary.1 → 2.0.0-canary.11

package/src/entrypoints/print-mode.ts

@@ -1,312 +0,0 @@
-import { AgentMode, AgentSession, AutoAcceptProvider, PromptHistory } from "@codellm/agent";
-import { AbacusClient } from "@codellm/api";
-import { AuthManager } from "@codellm/auth";
-import { product } from "@codellm/product";
-
-import type { AgentArgs } from "../args.js";
-
-import { logger } from "../services/logger.js";
-import { onExit } from "../terminal/exit.js";
-
-async function createApiClient(): Promise<{ apiClient: AbacusClient; authManager: AuthManager }> {
-  const authManager = await AuthManager.create();
-  const cliLogger = {
-    error: (message: string | Error, ...args: unknown[]) => logger.error(message, ...args),
-    debug: (...message: unknown[]) => logger.debug(...message),
-    warn: (message: string, ...args: unknown[]) => logger.warn(message, ...args),
-  };
-  return { apiClient: new AbacusClient(authManager, cliLogger), authManager };
-}
-
-/**
- * Enhanced instructions for high quality / deep-agent mode.
- */
-const HIGH_QUALITY_INSTRUCTIONS = `
-IMPORTANT INSTRUCTIONS: Your task is to follow the <task_description> EXACTLY and verify the solution within the FIXED TIME LIMIT.
-A few things to keep in mind (Add Relevant ONES BELOW AS TODOS):
-1. You are in a docker container without user interaction and fixed time limit. Assume HIGHEST permissions are available to the user.
-2. Check running servers in the docker container e.g. with \`ps aux | grep python\` and \`docker ps -a\`
-3. If the task requires a server to run in the background, use \`nohup\` to start it so that tests can access it.
-4. Check the installed packages with \`pip list\`. Use already installed packages unless explicity mentioned to install new ones in the task_description.
-5. Extract ALL filenames and IMPORTANT KEYWORDS mentioned in the task description.
-6. Extract EVERY specific constraint (versions, paths, file locations, values) and list them as checkable assertions
-7. Check all files and folders in the current directory with \`find . -type f \\( -name "*.py" -o -name "*.pyx" -o -name "*.pxd" -o -name "*.txt" \\) | head -20\`
-8. When file names are not specified in the task description, use generic names like app.py etc.
-9. Do NOT do manual conflict resolution when merging files.
-10. When working with .ppm files, Do NOT use \`head -20\` or similar commands with .ppm files
-11. For counting tokens, check both deepseek_solution and deepseek_reasoning and tokenize both separately when asked about deepseek
-12. *CRITICAL*: Write a test script to validate ALL THE CONSTRAINTS, ALL THE POSSIBLE CASES AND SCENARIOS AND REQUIREMENTS for the task and MAKE SURE THEY PASS before declaring COMPLETION. IF ANY FAIL, DEBUG AND FIX AND DO NOT STOP UNTIL ALL TESTS PASS. ** VERY CRITICAL **: Your test scripts must invoke tools/binaries EXACTLY as specified in the task requirements
-13. Follow task instructions precisely, especially file paths and naming conventions specified.
-14. When creating the tar archive, ensure that when it's later extracted, the files will be found at the exact same absolute paths they currently exist at in the filesystem. The archive structure must preserve the full directory hierarchy for validation.
-15. BEFORE claiming completion:
-     - STOP and re-read the FULL ORIGINAL task description
-     - For EACH constraint you listed in step 3:
-       a. Run a command to CHECK it
-       b. Record the actual result
-       c. Compare to expected result
-     - Create a validation table:
-       | Requirement | Expected | Actual | Pass/Fail |
-     - If ANY constraint fails: web_search for correct examples before proceeding AND FIX IT. Do not declare success.
-Follow TASK instructions EXACTLY. Do NOT take shortcuts that bypass task requirements. Add "Re-read ALL requirements from task description and CONFIRM they are met" 2 times to the list of todos.`;
-
-/** Write a JSON line to stdout (stream-json format). */
-function emitJson(obj: Record<string, unknown>): void {
-  process.stdout.write(JSON.stringify(obj) + "\n");
-}
-
-/**
- * Authenticate for print mode: env vars first, then stored credentials.
- */
-async function handleAuth(authManager: AuthManager, apiClient: AbacusClient): Promise<void> {
-  // Env-based auth (ephemeral) or stored credentials are both valid
-  if (authManager.isAuthenticated()) return;
-
-  try {
-    const userInfo = await apiClient.getUserInfo();
-    if (userInfo?.result?.email) return;
-  } catch {
-    // not authenticated
-  }
-
-  console.error(
-    `Error: Not authenticated. Please set ${product.envPrefix}API_KEY environment variable.`,
-  );
-  console.error("You can obtain your API key by visiting: https://abacus.ai/app/abacusai-cli");
-  console.error(
-    `\nUsage: ${product.envPrefix}API_KEY=your_key_here abacusai --print "your prompt"`,
-  );
-  process.exit(1);
-}
-
-/**
- * Fuzzy model name matching.
- */
-function findBestMatchingModel(
-  models: { name?: string; llmName: string }[],
-  requested: string,
-): string | null {
-  const getFuzzyScore = (modelName: string): number => {
-    const name = modelName.toLowerCase();
-    if (name === requested) return 1000;
-    if (name.startsWith(requested)) return 900;
-    let score = 0;
-    let lastIndex = -1;
-    for (const char of requested) {
-      const index = name.indexOf(char, lastIndex + 1);
-      if (index === -1) return 0;
-      score += 100 - (index - lastIndex);
-      lastIndex = index;
-    }
-    score += Math.max(0, 50 - name.length);
-    return score;
-  };
-  let bestMatch: string | null = null;
-  let bestScore = 0;
-  for (const model of models) {
-    const score = Math.max(getFuzzyScore(model.name ?? ""), getFuzzyScore(model.llmName));
-    if (score > bestScore) {
-      bestScore = score;
-      bestMatch = model.llmName;
-    }
-  }
-  return bestScore >= 100 ? bestMatch : null;
-}
-
-async function selectModel(apiClient: AbacusClient, requestedModel?: string): Promise<string> {
-  const modelsResponse = await apiClient.listLLMModels();
-  const models = modelsResponse?.result ?? [];
-
-  if (!models.length) {
-    console.error("Error: No models available. Check your API key and connection.");
-    process.exit(1);
-  }
-
-  if (!requestedModel) return models[0].llmName;
-
-  const match = findBestMatchingModel(models, requestedModel.toLowerCase());
-  if (!match) {
-    console.error(
-      `Warning: Model "${requestedModel}" not found. Using default: ${models[0].llmName}`,
-    );
-    return models[0].llmName;
-  }
-  return match;
-}
-
-/**
- * Resolve the startup conversation ID from --resume / --continue flags.
- */
-async function resolveConversationId(
-  agentArgs: AgentArgs | undefined,
-  apiClient: AbacusClient,
-): Promise<string | undefined> {
-  if (agentArgs?.resume) return agentArgs.resume;
-  if (agentArgs?.continue) {
-    try {
-      const result = await apiClient.getConversationsList("CODE_LLM_AGENT");
-      const conversations = result?.result ?? [];
-      const latest = conversations.sort((a, b) => {
-        const aTime = a.lastEventCreatedAt ? new Date(a.lastEventCreatedAt).getTime() : 0;
-        const bTime = b.lastEventCreatedAt ? new Date(b.lastEventCreatedAt).getTime() : 0;
-        return bTime - aTime;
-      })[0];
-      return latest?.deploymentConversationId;
-    } catch {
-      // fall through — start a new conversation
-    }
-  }
-  return agentArgs?.conversationId;
-}
-
-/**
- * Print mode: run headlessly, stream events per output format, always Yolo.
- */
-export async function runPrintMode({ agentArgs }: { agentArgs?: AgentArgs }): Promise<void> {
-  const { apiClient, authManager } = await createApiClient();
-
-  await handleAuth(authManager, apiClient);
-
-  // Configure custom base URL if provided
-  const baseUrl = process.env[`${product.envPrefix}BASE_URL`];
-  if (baseUrl) {
-    try {
-      new URL(baseUrl);
-    } catch {
-      console.error(`Invalid ${product.envPrefix}BASE_URL: ${baseUrl}`);
-      process.exit(1);
-    }
-    apiClient.setUrl(baseUrl);
-    apiClient.resetEndpoints();
-    await apiClient.getApiEndpoint();
-  }
-
-  const cwd = process.cwd();
-  const outputFormat = agentArgs?.["output-format"] ?? "text";
-  const model = await selectModel(apiClient, agentArgs?.model);
-
-  const session = new AgentSession({
-    allowedDirectories: [cwd],
-    primaryWorkspace: cwd,
-    apiClient,
-    mode: AgentMode.Yolo,
-    model,
-    permissionProvider: new AutoAcceptProvider(),
-    isPrintMode: true,
-    enablePromptRewrite: false,
-    supportsThoughtStreaming: true,
-  });
-
-  // Register graceful Ctrl+C handler
-  onExit(
-    async () => {
-      session.stop();
-      await new Promise((r) => setTimeout(r, 200));
-    },
-    { wait: 1000 },
-  );
-
-  // Resolve startup conversation from --resume / --continue flags
-  const startupConversationId = await resolveConversationId(agentArgs, apiClient);
-  if (startupConversationId) {
-    await session.loadConversation(startupConversationId);
-  }
-
-  let userMessage = agentArgs?.prompt ?? "";
-  if (process.env.DEEPAGENT_HIGH_QUALITY === "true") {
-    userMessage = `${HIGH_QUALITY_INSTRUCTIONS}\nThis is the task description: <task_description>${userMessage}</task_description>`;
-  }
-
-  // Print startup header to stderr (not stdout, to keep stdout clean for piping)
-  const convLabel = startupConversationId
-    ? `conversation: ${startupConversationId}`
-    : "conversation: new";
-  process.stderr.write(`model: ${model} | cwd: ${cwd} | ${convLabel}\n`);
-
-  // Record in prompt history
-  const promptHistory = new PromptHistory("cli-print");
-  await promptHistory.load();
-  promptHistory.append(userMessage);
-
-  // Accumulate text and thinking for grouped output
-  let accumulatedText = "";
-  let accumulatedThinking = "";
-
-  // Stream agent events
-  for await (const event of session.send(userMessage)) {
-    switch (event.type) {
-      case "text_delta":
-        accumulatedText += event.content;
-        break;
-
-      case "thinking_delta":
-        accumulatedThinking += event.content;
-        break;
-
-      case "tool_requested": {
-        const toolName = event.tool.name;
-        const toolId = event.tool.id;
-        if (outputFormat === "stream-json") {
-          emitJson({ type: "tool_call", name: toolName, id: toolId, input: event.tool.input });
-        } else {
-          const inputSummary = Object.entries(event.tool.input ?? {})
-            .slice(0, 2)
-            .map(([k, v]) => `${k}=${JSON.stringify(v).slice(0, 60)}`)
-            .join(", ");
-          process.stderr.write(`  ⏺ ${toolName}(${inputSummary})\n`);
-        }
-        break;
-      }
-
-      case "tool_execution_complete": {
-        if (outputFormat === "stream-json") {
-          const resultText =
-            typeof event.result?.content === "string" ? event.result.content.slice(0, 200) : "";
-          emitJson({ type: "tool_result", id: event.tool.id, result: resultText });
-        }
-        break;
-      }
-
-      case "notification":
-        if (outputFormat === "stream-json") {
-          emitJson({
-            type: "notification",
-            severity: event.severity,
-            message: event.message,
-            ...(event.actions ? { actions: event.actions } : {}),
-          });
-        } else if (event.severity === "error" || event.severity === "warning") {
-          process.stderr.write(`[${event.severity}] ${event.message}\n`);
-        }
-        break;
-
-      case "error":
-        if (outputFormat === "stream-json") {
-          emitJson({ type: "error", message: event.error.message });
-        } else {
-          process.stderr.write(`Error: ${event.error.message}\n`);
-        }
-        break;
-
-      default:
-        break;
-    }
-  }
-
-  // Output final result based on format
-  if (outputFormat === "stream-json") {
-    if (accumulatedThinking) {
-      emitJson({ type: "thinking", content: accumulatedThinking });
-    }
-    if (accumulatedText) {
-      emitJson({ type: "text", content: accumulatedText });
-    }
-    emitJson({ type: "result", success: true });
-  } else {
-    if (accumulatedText) {
-      process.stdout.write(accumulatedText);
-      process.stdout.write("\n");
-    }
-  }
-
-  process.exit(0);
-}

package/src/entrypoints/repl.tsx

@@ -1,389 +0,0 @@
-import type { AbacusClient } from "@codellm/api";
-
-import { AuthManager } from "@codellm/auth";
-import { View, render, useInput } from "@codellm/jar";
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import {
-  Activity,
-  useEffect,
-  useState,
-  useDeferredValue,
-  useMemo,
-  useCallback,
-  useRef,
-} from "react";
-
-import type { AgentArgs } from "../args.js";
-import type { HistorySegment } from "../lib/types.js";
-
-import { Composer, type ComposerHandle } from "../components/composer/index.js";
-import { AgentMode } from "../components/composer/types.js";
-import { ExitMessage } from "../components/exit-message.js";
-import { ExpandedView } from "../components/expanded-view.js";
-import { Header } from "../components/header.js";
-import { Segment } from "../components/segments.js";
-import { StatusIndicator } from "../components/status-indicator.js";
-import { GROUPABLE_TOOLS, ToolGroupSummary } from "../components/tool-group-summary.js";
-import { ToolPermissionUI } from "../components/tool-permissions/tool-permission-ui.js";
-import { PendingToolCallIdContext } from "../components/tools/shared/index.js";
-import { AgentModeProvider } from "../context/agent-mode.js";
-import { ExtensionFileProvider } from "../context/extension-file.js";
-import { NetworkActivityProvider } from "../context/network-activity.js";
-import { NotificationProvider } from "../context/notification.js";
-import { ShellSizeProvider } from "../context/shell-size.js";
-import { ShellTitleProvider, useShellTitle } from "../context/shell-title.js";
-import { useAgent } from "../hooks/use-agent.js";
-import { useApiClient } from "../hooks/use-api-client.js";
-import { useInterruptManager } from "../hooks/use-interrupt-manager.js";
-import { ANSI } from "../lib/ansi.js";
-import { Timing } from "../lib/timing.js";
-import { AgentProvider, AgentStatus } from "../providers/agent.js";
-import { ApiClientProvider } from "../providers/api-client.js";
-import { onExit, gracefulExit } from "../terminal/exit.js";
-import { ThemeProvider } from "../theme/index.js";
-
-/** Group consecutive "groupable" tool call segments together for compact rendering. */
-type RenderItem =
-  | { kind: "segment"; segment: HistorySegment }
-  | { kind: "tool-group"; id: string; segments: HistorySegment[] };
-
-function isToolSeg(seg: HistorySegment): boolean {
-  return seg.type === "code_llm_tool_call" || seg.type === "code_llm_agent_tool_request";
-}
-
-function hasToolError(seg: HistorySegment): boolean {
-  const result = seg.toolUseResult as { rejected?: boolean; content?: string } | undefined;
-  return !!(result?.rejected || result?.content?.startsWith("Error:"));
-}
-
-function groupSegments(segments: HistorySegment[]): RenderItem[] {
-  const items: RenderItem[] = [];
-  let i = 0;
-  while (i < segments.length) {
-    const seg = segments[i];
-
-    // Thinking segments render inline (visible while active + 2s after completion)
-    if (seg.type === "thinking") {
-      items.push({ kind: "segment", segment: seg });
-      i++;
-      continue;
-    }
-
-    if (isToolSeg(seg) && GROUPABLE_TOOLS.has(getToolName(seg))) {
-      // Collect all consecutive groupable tool calls, treating thinking as transparent gaps
-      // Break the group at any completed tool that returned an error
-      const group: HistorySegment[] = [seg];
-      let j = i + 1;
-      while (j < segments.length) {
-        const next = segments[j];
-        if (next.type === "thinking") {
-          // Thinking between tool calls is transparent — skip without breaking the group
-          j++;
-          continue;
-        }
-        // If the last tool in the group errored, start a new group from here
-        if (hasToolError(group[group.length - 1]!)) {
-          break;
-        }
-        if (isToolSeg(next) && GROUPABLE_TOOLS.has(getToolName(next))) {
-          group.push(next);
-          j++;
-        } else {
-          break;
-        }
-      }
-      if (group.length === 1) {
-        items.push({ kind: "segment", segment: group[0] });
-      } else {
-        items.push({ kind: "tool-group", id: group[0].id, segments: group });
-      }
-      i = j;
-      continue;
-    }
-
-    items.push({ kind: "segment", segment: seg });
-    i++;
-  }
-  return items;
-}
-
-function getToolName(seg: HistorySegment): string {
-  const req = seg.toolUseRequest;
-  if (!req) return "";
-  if (Array.isArray(req)) return (req[0] as { name?: string })?.name ?? "";
-  return (req as { name?: string }).name ?? "";
-}
-
-/** Derive the most recent thinking timing from segments for the status indicator. */
-function getThinkingTiming(segments: HistorySegment[]): {
-  thinkingStartTime: number | null;
-  thinkingEndTime: number | null;
-} {
-  // Find the last thinking segment
-  for (let i = segments.length - 1; i >= 0; i--) {
-    const seg = segments[i];
-    if (seg.type === "thinking") {
-      return {
-        thinkingStartTime: seg.thinkingStartTime ?? null,
-        thinkingEndTime: seg.thinkingEndTime ?? null,
-      };
-    }
-  }
-  return { thinkingStartTime: null, thinkingEndTime: null };
-}
-
-export function App({ timing }: { timing: Timing }) {
-  const { setTitle } = useShellTitle();
-
-  const {
-    segments: rawSegments,
-    agentStatus,
-    pendingToolPermission,
-    conversationTitle,
-    conversationId,
-    addNotification,
-    stop,
-    rejectPendingPermission,
-    removeFirstFromQueue,
-    clearQueue,
-    retryState,
-    networkOnline,
-  } = useAgent();
-
-  const composerRef = useRef<ComposerHandle>(null);
-
-  const { authExpired, clearAuthExpired } = useApiClient();
-
-  // Show a notification segment when session expires
-  useEffect(() => {
-    if (authExpired) {
-      addNotification("Session expired — use /login to authenticate again.", "error");
-      clearAuthExpired();
-    }
-  }, [authExpired, addNotification, clearAuthExpired]);
-
-  // Expanded view: snapshot taken at moment of Ctrl+O
-  const [expandedSnapshot, setExpandedSnapshot] = useState<HistorySegment[] | null>(null);
-
-  const toggleExpand = useCallback(() => {
-    setExpandedSnapshot((prev) => {
-      if (prev !== null) return null; // close
-      // Snapshot: exclude transient/spinny
-      return rawSegments.filter((s) => !s.temp && !s.isSpinny);
-    });
-  }, [rawSegments]);
-
-  // Global Ctrl+O handler — only active when NOT in expanded mode.
-  // When expanded, ExpandedView's own useInput handles the key.
-  // Both handlers firing would cause a toggle → re-open race.
-  useInput(
-    (input, key) => {
-      if ((key.ctrl || key.super) && input === "o") {
-        toggleExpand();
-      }
-    },
-    { isActive: expandedSnapshot === null },
-  );
-
-  const { lastItem, prevItems } = useMemo(() => {
-    const filtered = rawSegments.filter((s) => !s.temp && !s.isSpinny);
-    const items = groupSegments(filtered);
-    return {
-      lastItem: items.at(-1) ?? null,
-      prevItems: items.slice(0, -1),
-    };
-  }, [rawSegments]);
-
-  const deferredPrevItems = useDeferredValue(prevItems);
-
-  // Thinking timing for status indicator
-  const { thinkingStartTime, thinkingEndTime } = useMemo(
-    () => getThinkingTiming(rawSegments),
-    [rawSegments],
-  );
-
-  const isWaitingForPermission =
-    agentStatus === AgentStatus.WaitingForToolPermission && pendingToolPermission !== null;
-
-  const [exiting, setExiting] = useState(false);
-  const [exitDuration, setExitDuration] = useState("0");
-  const [exitCredits, setExitCredits] = useState(0);
-
-  useEffect(() => {
-    if (conversationTitle) {
-      setTitle(`${conversationTitle} • Abacus.AI CLI`);
-    } else {
-      setTitle("Abacus.AI CLI");
-    }
-  }, [conversationTitle, setTitle]);
-
-  useEffect(() => {
-    const unsubscribe = onExit(
-      async () => {
-        const duration = timing.getFormattedDuration();
-
-        setExitCredits(0);
-        setExitDuration(duration);
-        setExiting(true);
-
-        await new Promise<void>((resolve) => setTimeout(resolve, 100));
-      },
-      { wait: 2000, streams: [process.stdout, process.stderr] },
-    );
-
-    return unsubscribe;
-  }, [timing]);
-
-  const hints = useInterruptManager({
-    agentStatus,
-    hasPendingPermission: pendingToolPermission !== null,
-    composerHasText: () => composerRef.current?.hasText() ?? false,
-    hasQueuedMessages: () => composerRef.current?.hasQueue() ?? false,
-    stopAgent: stop,
-    rejectPermission: rejectPendingPermission,
-    saveAndClearComposer: () => composerRef.current?.saveAndClear(),
-    clearComposer: () => composerRef.current?.clear(),
-    dequeueOne: removeFirstFromQueue,
-    clearQueue,
-    exitApp: () => gracefulExit(0),
-  });
-
-  const shouldShowStatusIndicator =
-    (agentStatus !== AgentStatus.Idle && agentStatus !== AgentStatus.WaitingForToolPermission) ||
-    retryState !== null ||
-    !networkOnline;
-
-  const pendingToolCallId = pendingToolPermission?.request.tool.id ?? null;
-
-  // Expanded mode: show static snapshot instead of normal UI
-  if (expandedSnapshot !== null) {
-    return <ExpandedView snapshot={expandedSnapshot} onClose={() => setExpandedSnapshot(null)} />;
-  }
-
-  return (
-    <>
-      <View flexDirection="column" gap={1} paddingBottom={1} width="95%">
-        <Header />
-        <PendingToolCallIdContext.Provider value={pendingToolCallId}>
-          {deferredPrevItems.map((item) =>
-            item.kind === "segment" ? (
-              <Segment key={item.segment.id} segment={item.segment} />
-            ) : (
-              <ToolGroupSummary key={item.id} segments={item.segments} />
-            ),
-          )}
-          {lastItem &&
-            (lastItem.kind === "segment" ? (
-              <Segment key={lastItem.segment.id} segment={lastItem.segment} />
-            ) : (
-              <ToolGroupSummary key={lastItem.id} segments={lastItem.segments} />
-            ))}
-        </PendingToolCallIdContext.Provider>
-        {shouldShowStatusIndicator && (
-          <StatusIndicator
-            status={agentStatus}
-            thinkingStartTime={thinkingStartTime}
-            thinkingEndTime={thinkingEndTime}
-            retryState={retryState}
-            networkOnline={networkOnline}
-          />
-        )}
-      </View>
-
-      {exiting ? (
-        <ExitMessage
-          duration={exitDuration}
-          credits={exitCredits}
-          conversationId={conversationId}
-        />
-      ) : (
-        <>
-          {isWaitingForPermission && <ToolPermissionUI pendingTool={pendingToolPermission} />}
-          <Activity mode={isWaitingForPermission ? "hidden" : "visible"}>
-            <Composer hints={hints} composerRef={composerRef} />
-          </Activity>
-        </>
-      )}
-    </>
-  );
-}
-
-export interface ReplConfig {
-  apiClient: AbacusClient;
-  authManager: AuthManager;
-  agentArgs?: AgentArgs;
-}
-
-export async function runRepl({ apiClient, authManager, agentArgs }: ReplConfig) {
-  const queryClient = new QueryClient();
-  const timing = new Timing();
-
-  let initialAgentMode: AgentMode | undefined;
-  if (agentArgs?.["dangerously-skip-permissions"]) {
-    initialAgentMode = AgentMode.Yolo;
-  } else if (agentArgs?.["auto-accept-edits"]) {
-    initialAgentMode = AgentMode.AcceptEdits;
-  } else if (agentArgs?.["plan-mode"]) {
-    initialAgentMode = AgentMode.PlanMode;
-  }
-
-  const stdout = process.stdout;
-  const write = (s: string) => {
-    if (stdout && stdout.writable) {
-      stdout.write(s);
-    }
-  };
-  const hideCursor = () => write(ANSI.HIDE_CURSOR);
-  const showCursor = () => write(ANSI.SHOW_CURSOR);
-
-  hideCursor();
-  const app = render(
-    <ThemeProvider>
-      <ApiClientProvider client={apiClient} authManager={authManager}>
-        <QueryClientProvider client={queryClient}>
-          <ShellSizeProvider>
-            <ShellTitleProvider>
-              <NotificationProvider>
-                <ExtensionFileProvider>
-                  <AgentModeProvider initialMode={initialAgentMode}>
-                    <NetworkActivityProvider>
-                      <AgentProvider apiClient={apiClient} agentArgs={agentArgs}>
-                        <App timing={timing} />
-                      </AgentProvider>
-                    </NetworkActivityProvider>
-                  </AgentModeProvider>
-                </ExtensionFileProvider>
-              </NotificationProvider>
-            </ShellTitleProvider>
-          </ShellSizeProvider>
-        </QueryClientProvider>
-      </ApiClientProvider>
-    </ThemeProvider>,
-    {
-      exitOnCtrlC: false,
-      suspendable: true,
-      onSuspended: () => {
-        process.stderr.write("\nAbacus.AI has been suspended. Run `fg` to bring Abacus back.\n");
-      },
-    },
-  );
-
-  let cleanedUp = false;
-  const cleanup = () => {
-    if (cleanedUp) return;
-    cleanedUp = true;
-    showCursor();
-  };
-
-  const handleProcessExit = () => {
-    if (!cleanedUp) {
-      cleanedUp = true;
-      app.cleanupTerminal();
-    }
-  };
-  process.once("exit", handleProcessExit);
-
-  await app.waitUntilExit();
-  process.off("exit", handleProcessExit);
-  cleanup();
-}