@abacus-ai/cli 1.106.25007 → 2.0.0-canary.0

package/src/__e2e__/file-creation.e2e.test.tsx

@@ -0,0 +1,149 @@
+import React from "react";
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+
+import { stripAnsi } from "../lib/ansi.js";
+import { sleep } from "../lib/utils.js";
+import { renderWithProviders, waitForFrame } from "./helpers/test-helpers.js";
+
+// Mock the shell-size context to provide consistent terminal dimensions in tests
+vi.mock("../context/shell-size.js", async () => {
+  const { createContext } = await import("react");
+  const ShellSizeContext = createContext<{ width: number; height: number } | null>({
+    width: 120,
+    height: 40,
+  });
+  return {
+    ShellSizeContext,
+    ShellSizeProvider: ({ children }: { children: React.ReactNode }) => children,
+    useShellSize: () => ({ width: 120, height: 40 }),
+  };
+});
+
+import { simulateText, simulateEnter, simulateKeypress } from "./helpers/test-helpers.js";
+
+describe.sequential("File Creation Permission E2E Tests", () => {
+  beforeEach(() => {
+    vi.spyOn(process, "exit").mockImplementation(() => {
+      throw new Error("process.exit called");
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("should show file creation permission dialog with options", async () => {
+    const { App } = await import("../entrypoints/repl.js");
+    const { Timing } = await import("../lib/timing.js");
+
+    const timing = new Timing();
+
+    const { lastFrame, stdin, unmount } = renderWithProviders(React.createElement(App, { timing }));
+
+    // Wait for FULL TUI to render - look for the input prompt indicator
+    await waitForFrame(
+      lastFrame,
+      (frame) => {
+        const plain = stripAnsi(frame);
+        return plain.includes("for shortcuts") || plain.includes("shift+tab");
+      },
+      30000,
+    );
+    await sleep(100);
+
+    // Type the message using jar's stdin.write()
+    const message = "Create a helloWorld.py file";
+    simulateText(stdin, message);
+    await waitForFrame(lastFrame, (frame) => stripAnsi(frame).includes("helloWorld.py"), 5000);
+
+    simulateEnter(stdin);
+
+    // Wait for the permission dialog to appear (increase timeout for CI)
+    // The mock has a 2500ms delay before sending the tool request
+    // IMPORTANT: Only wait for '1. Yes' which is unique to the permission dialog
+    // Do NOT use 'helloWorld.py' as that matches the user's input message too early
+    await waitForFrame(
+      lastFrame,
+      (frame) => {
+        const plain = stripAnsi(frame);
+        return plain.includes("1. Yes") || plain.includes("Tab to add additional instructions");
+      },
+      60000,
+    );
+
+    let frame = stripAnsi(lastFrame() || "");
+    expect(frame).toContain("helloWorld.py");
+    expect(frame).toContain("1. Yes");
+    expect(frame).toContain("2. Yes, and enable auto-edit mode");
+    expect(frame).toContain("3. No");
+    expect(frame).toContain("Tab to add additional instructions");
+    expect(frame).toMatch(/Esc to (reject|cancel)/);
+
+    // Press Enter to accept
+    simulateEnter(stdin);
+    await sleep(100);
+
+    unmount();
+  }, 120000);
+
+  it("should allow adding instructions via Tab key", async () => {
+    const { App } = await import("../entrypoints/repl.js");
+    const { Timing } = await import("../lib/timing.js");
+
+    const timing = new Timing();
+
+    const { lastFrame, stdin, unmount } = renderWithProviders(React.createElement(App, { timing }));
+
+    // Wait for FULL TUI to render - look for the input prompt indicator
+    await waitForFrame(
+      lastFrame,
+      (frame) => {
+        const plain = stripAnsi(frame);
+        return plain.includes("for shortcuts") || plain.includes("shift+tab");
+      },
+      30000,
+    );
+    await sleep(100);
+
+    simulateText(stdin, "Create a helloWorld.py file");
+    await waitForFrame(lastFrame, (frame) => stripAnsi(frame).includes("helloWorld.py"), 5000);
+
+    simulateEnter(stdin);
+
+    // Wait for the permission dialog to appear (increase timeout for CI)
+    // The mock has a 2500ms delay before sending the tool request
+    // IMPORTANT: Only wait for permission dialog text, not 'helloWorld.py' which matches user input
+    await waitForFrame(
+      lastFrame,
+      (frame) => {
+        const plain = stripAnsi(frame);
+        return plain.includes("Tab to add additional instructions");
+      },
+      60000,
+    );
+
+    let frame = stripAnsi(lastFrame() || "");
+    expect(frame).toContain("helloWorld.py");
+    expect(frame).toContain("Tab to add additional instructions");
+
+    simulateKeypress(stdin, "\t");
+    await waitForFrame(
+      lastFrame,
+      (f) => stripAnsi(f).includes("Type here to tell AbacusAI what to do differently"),
+      5000,
+    );
+
+    frame = stripAnsi(lastFrame() || "");
+    expect(frame).toContain("Type here to tell AbacusAI what to do differently");
+
+    simulateText(stdin, "its good");
+    await waitForFrame(lastFrame, (f) => stripAnsi(f).includes("1. Yes, its good"), 5000);
+
+    frame = stripAnsi(lastFrame() || "");
+    expect(frame).toContain("1. Yes, its good");
+    expect(frame).not.toContain("Tab to add additional instructions");
+    expect(frame).toMatch(/Esc to (reject|cancel)/);
+
+    unmount();
+  }, 120000);
+});

package/src/__e2e__/helpers/test-helpers.ts

@@ -0,0 +1,450 @@
+import type { ClientLogger, HeadersProvider } from "@codellm/api";
+
+import { AbacusClient, type SSEEvent } from "@codellm/api";
+import { AuthManager } from "@codellm/auth";
+import { renderForTest } from "@codellm/jar";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import React, { type ReactElement } from "react";
+import { vi, type Mock } from "vitest";
+
+/** Maps each function property of T to Mock<fn>, keeping non-function props as-is. */
+type MockOf<T> = {
+  [K in keyof T]: T[K] extends (...args: any[]) => any ? Mock<T[K]> : T[K];
+};
+
+import type {
+  FileSystemTools,
+  ITerminalService,
+  IAbacusBrowserService,
+  ICommand,
+  ICommandResult,
+} from "../../lib/types.js";
+import type { ToolExecutionContext } from "../../tools/types.ts";
+
+import { AgentMode } from "../../components/composer/types.ts";
+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 { ShellSizeContext } from "../../context/shell-size.js";
+import { ShellTitleProvider } from "../../context/shell-title.js";
+import { AgentProvider } from "../../providers/agent.js";
+import { ApiClientProvider } from "../../providers/api-client.js";
+import { ThemeProvider } from "../../theme/index.js";
+
+// MockShellSizeProvider for tests - provides consistent terminal dimensions via the real ShellSizeContext
+function MockShellSizeProvider({ children }: React.PropsWithChildren) {
+  const value = { width: 120, height: 40 };
+  return React.createElement(ShellSizeContext.Provider, { value }, children);
+}
+
+export interface E2ETestContext {
+  lastFrame: () => string;
+  stdin: {
+    write: (data: string) => void;
+  };
+  frames: string[];
+  unmount: () => void;
+}
+
+/**
+ * Render a React element for E2E tests using jar's reconciler.
+ * Returns a context with `lastFrame()`, `frames`, `stdin.write()`, and `unmount()`.
+ */
+export function renderE2E(component: ReactElement): E2ETestContext {
+  return renderForTest(component);
+}
+
+/**
+ * Render a React element wrapped in all required test providers (QueryClient, API client,
+ * ShellSize, ShellTitle, Theme, Agent, etc.).
+ *
+ * Use this when testing components that rely on app-level contexts (e.g. App from repl.js),
+ * instead of renderE2E() which does not supply any providers.
+ *
+ * @example
+ * const { lastFrame, stdin, unmount } = renderWithProviders(
+ *   React.createElement(App, { timing })
+ * );
+ */
+export function renderWithProviders(component: ReactElement): E2ETestContext {
+  const Wrapper = createTestWrapper();
+  return renderForTest(React.createElement(Wrapper, { children: component }));
+}
+
+export function simulateKeypress(stdin: { write: (data: string) => void }, key: string) {
+  stdin.write(key);
+}
+
+export function simulateEnter(stdin: { write: (data: string) => void }) {
+  stdin.write("\r");
+}
+
+export function simulateText(stdin: { write: (data: string) => void }, text: string) {
+  for (const char of text) {
+    stdin.write(char);
+  }
+}
+
+export function simulateCtrlC(stdin: { write: (data: string) => void }) {
+  stdin.write("\x03");
+}
+
+export function simulateEscape(stdin: { write: (data: string) => void }) {
+  stdin.write("\x1b");
+}
+
+export function simulateUpArrow(stdin: { write: (data: string) => void }) {
+  stdin.write("\x1b[A");
+}
+
+export function simulateDownArrow(stdin: { write: (data: string) => void }) {
+  stdin.write("\x1b[B");
+}
+
+export function simulateRightArrow(stdin: { write: (data: string) => void }) {
+  stdin.write("\x1b[C");
+}
+
+export function simulateLeftArrow(stdin: { write: (data: string) => void }) {
+  stdin.write("\x1b[D");
+}
+
+export function waitForFrame(
+  lastFrame: () => string,
+  predicate: (frame: string) => boolean,
+  timeout = 5000,
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const startTime = Date.now();
+    const interval = setInterval(() => {
+      const frame = lastFrame();
+      if (predicate(frame)) {
+        clearInterval(interval);
+        resolve();
+      } else if (Date.now() - startTime > timeout) {
+        clearInterval(interval);
+        reject(new Error(`Timeout waiting for frame matching predicate. Last frame:\n${frame}`));
+      }
+    }, 50);
+  });
+}
+
+export function mockApiClient(): { chat: Mock; listModels: Mock } {
+  return {
+    chat: vi.fn().mockResolvedValue({
+      choices: [
+        {
+          message: {
+            content: "Mock response",
+          },
+        },
+      ],
+    }),
+    listModels: vi.fn().mockResolvedValue([{ id: "test-model", name: "Test Model" }]),
+  };
+}
+
+export function mockConfigService(): { get: Mock; set: Mock; has: Mock } {
+  return {
+    get: vi.fn().mockImplementation((key: string) => {
+      const config: Record<string, any> = {
+        apiKey: "test-api-key",
+        model: "test-model",
+      };
+      return config[key];
+    }),
+    set: vi.fn(),
+    has: vi.fn().mockReturnValue(true),
+  };
+}
+
+const mockHeadersProvider: HeadersProvider = {
+  getHeaders: vi.fn().mockResolvedValue({ APIKEY: "test-api-key" }),
+};
+
+const mockLogger: ClientLogger = {
+  error: vi.fn(),
+  debug: vi.fn(),
+  warn: vi.fn(),
+};
+
+export function createMockAbacusClient() {
+  const client = new AbacusClient(mockHeadersProvider, mockLogger);
+
+  client.getUserInfo = vi.fn().mockResolvedValue({ result: { email: "test@test.com" } });
+  client.getConversationsList = vi.fn().mockResolvedValue({ result: [] });
+  client.listExternalApplications = vi.fn().mockResolvedValue({ success: true, result: [] });
+  client.recordUserAction = vi.fn().mockResolvedValue({});
+  client.setUrl = vi.fn().mockResolvedValue(undefined);
+  client.setChatWebDomain = vi.fn().mockResolvedValue(undefined);
+  client.getChatWebDomain = vi.fn().mockResolvedValue(null);
+  client.clearDeploymentConversation = vi.fn().mockResolvedValue(null);
+  client.getCodeEdit = vi.fn().mockResolvedValue(null);
+  client.listLLMModels = vi.fn().mockResolvedValue(null);
+  client.getConstantsAutocomplete = vi.fn().mockResolvedValue(null);
+  client.getCodeAutocompleteResponse = vi.fn().mockResolvedValue(null);
+  client.getAutocompleteEditPrediction = vi.fn().mockResolvedValue(null);
+  client.resetEndpoints = vi.fn().mockResolvedValue(undefined);
+  client.getDeploymentConversation = vi
+    .fn()
+    .mockResolvedValue({ success: true, result: { history: [] } });
+  client.createCodellmDeploymentConversation = vi
+    .fn()
+    .mockResolvedValue({ success: true, result: { deploymentConversationId: "test-convo-id" } });
+
+  // Mock streamAgentMessage as an async generator that yields SSE events
+  // Use setTimeout delays to ensure React useEffect hooks have run first
+  client.streamAgentMessage = vi.fn().mockImplementation(function () {
+    async function* generate(): AsyncGenerator<SSEEvent> {
+      // Delay to ensure all React useEffect hooks have run
+      await new Promise((r) => setTimeout(r, 2000));
+
+      // First event: text segment
+      yield {
+        segment: "I will create a file helloWorld.py for you.",
+        counter: 1,
+        message_id: "test-message-id",
+      };
+
+      // Small delay to ensure proper processing
+      await new Promise((r) => setTimeout(r, 500));
+
+      // Second event: tool request
+      yield {
+        toolUseRequest: {
+          id: "tool-1",
+          type: "builtin",
+          name: "edit",
+          input: {
+            targetFile: "helloWorld.py",
+            codeEdit: 'print("Hello, World!")',
+            overwriteFile: true,
+            instructions: "Creating helloWorld.py file",
+          },
+        },
+        counter: 2,
+        message_id: "test-message-id",
+      };
+    }
+    return generate();
+  });
+
+  // Mock streamChatMessage as an async generator
+  client.streamChatMessage = vi.fn().mockImplementation(function () {
+    async function* generate(): AsyncGenerator<SSEEvent> {
+      await new Promise((r) => setTimeout(r, 2000));
+      yield {
+        segment: "I will create a file helloWorld.py for you.",
+        counter: 1,
+        message_id: "test-message-id",
+      };
+    }
+    return generate();
+  });
+
+  return client as AbacusClient & {
+    getUserInfo: Mock<typeof client.getUserInfo>;
+    getConversationsList: Mock<typeof client.getConversationsList>;
+    listExternalApplications: Mock<typeof client.listExternalApplications>;
+    recordUserAction: Mock<typeof client.recordUserAction>;
+    setUrl: Mock<typeof client.setUrl>;
+    setChatWebDomain: Mock<typeof client.setChatWebDomain>;
+    getChatWebDomain: Mock<typeof client.getChatWebDomain>;
+    clearDeploymentConversation: Mock<typeof client.clearDeploymentConversation>;
+    getCodeEdit: Mock<typeof client.getCodeEdit>;
+    listLLMModels: Mock<typeof client.listLLMModels>;
+    getConstantsAutocomplete: Mock<typeof client.getConstantsAutocomplete>;
+    getCodeAutocompleteResponse: Mock<typeof client.getCodeAutocompleteResponse>;
+    getAutocompleteEditPrediction: Mock<typeof client.getAutocompleteEditPrediction>;
+    resetEndpoints: Mock<typeof client.resetEndpoints>;
+    getDeploymentConversation: Mock<typeof client.getDeploymentConversation>;
+    createCodellmDeploymentConversation: Mock<typeof client.createCodellmDeploymentConversation>;
+    streamAgentMessage: Mock<typeof client.streamAgentMessage>;
+    streamChatMessage: Mock<typeof client.streamChatMessage>;
+  };
+}
+
+export function createMockNotificationService(): { error: ReturnType<typeof vi.fn> } {
+  return {
+    error: vi.fn(),
+  };
+}
+
+type MockToolExcecutionContext = Omit<
+  ToolExecutionContext,
+  "fileSystemTools" | "terminalService" | "abacusBrowserService" | "apiClient"
+> & {
+  fileSystemTools: ReturnType<typeof createMockFileSystemTools>;
+  terminalService: ReturnType<typeof createMockTerminalService>;
+  abacusBrowserService: ReturnType<typeof createMockBrowserService>;
+  apiClient: ReturnType<typeof createMockAbacusClient>;
+};
+
+export function createMockContext(
+  overrides?: Partial<MockToolExcecutionContext>,
+): MockToolExcecutionContext {
+  return {
+    fileSystemTools: createMockFileSystemTools(),
+    terminalService: createMockTerminalService(),
+    abacusBrowserService: createMockBrowserService(),
+    apiClient: createMockAbacusClient(),
+    mcpService: undefined,
+    extensionConnection: undefined,
+
+    abortController: new AbortController(),
+    workspacePath: "/test/workspace",
+    conversationId: "test-conversation",
+    agentMode: AgentMode.Normal,
+    toolCallId: "test-tool-call",
+    status: "pending",
+    vsCodeAppliedChanges: false,
+
+    uploadedDocs: new Set(),
+    allowEditingPaths: [],
+    terminalTimeoutMs: undefined,
+
+    addDiff: vi.fn().mockReturnValue(undefined),
+    onOutputUpdate: vi.fn().mockReturnValue(undefined),
+    ...overrides,
+  } satisfies MockToolExcecutionContext;
+}
+
+export function createMockAuthManager(): MockOf<HeadersProvider> {
+  return {
+    getHeaders: vi.fn().mockResolvedValue({ APIKEY: "test-api-key" }),
+  } satisfies HeadersProvider;
+}
+
+export function createMockFileSystemTools(): MockOf<FileSystemTools> {
+  return {
+    ls: vi.fn().mockResolvedValue(""),
+    mkdir: vi.fn().mockResolvedValue({ undo: vi.fn() }),
+    view: vi.fn().mockResolvedValue(""),
+    readRawFile: vi.fn().mockResolvedValue(""),
+    create: vi.fn().mockResolvedValue({ undo: vi.fn() }),
+    readFile: vi.fn().mockResolvedValue(""),
+    deleteFile: vi.fn().mockResolvedValue(undefined),
+    listDir: vi.fn().mockResolvedValue(""),
+    strReplace: vi.fn().mockResolvedValue({ undo: vi.fn() }),
+    grep: vi.fn().mockResolvedValue({
+      matches: [],
+      metadata: {
+        offset: 0,
+        limit: 0,
+        totalMatches: 0,
+        hasMore: false,
+      },
+    }),
+    grepFile: vi.fn().mockResolvedValue([]),
+    grepTextFile: vi.fn().mockResolvedValue([]),
+  } satisfies FileSystemTools;
+}
+
+type MockTerminalServiceOpts = {
+  executedCommand?: ICommand;
+  output?: ICommandResult[];
+};
+
+export function createMockTerminalService(
+  opts: MockTerminalServiceOpts = {},
+): MockOf<ITerminalService> {
+  return {
+    executeCommand: vi.fn().mockResolvedValue(
+      opts.executedCommand ?? {
+        result: {
+          get: vi.fn().mockResolvedValue({ stdout: "", stderr: "", exitCode: 0 }),
+        },
+      },
+    ),
+    getOutput: vi.fn().mockReturnValue(opts.output ?? []),
+    stopCommand: vi.fn().mockResolvedValue(true),
+    closeTerminal: vi.fn().mockResolvedValue(undefined),
+    dispose: vi.fn(),
+  } satisfies ITerminalService;
+}
+
+export function createMockBrowserService(): MockOf<IAbacusBrowserService> {
+  return {
+    navigateTo: vi.fn().mockResolvedValue(undefined),
+    openTab: vi.fn().mockResolvedValue(1),
+    switchActiveTab: vi.fn().mockResolvedValue(undefined),
+    closeTab: vi.fn().mockResolvedValue(undefined),
+    refreshTab: vi.fn().mockResolvedValue(undefined),
+    getTabContent: vi.fn().mockResolvedValue({
+      text: "",
+      metadata: { offset: 0, limit: 0, totalLength: 0, hasMore: false },
+    }),
+    do: vi.fn().mockResolvedValue({ content: { text: "", images: [] } }),
+    getInteractiveElements: vi.fn().mockResolvedValue(""),
+    doOnElementId: vi.fn().mockResolvedValue({ content: { text: "", images: [] } }),
+  } satisfies IAbacusBrowserService;
+}
+
+export interface TestWrapperProps {
+  children: ReactElement;
+}
+
+export function createTestWrapper(): React.FC<TestWrapperProps> {
+  const queryClient = new QueryClient({
+    defaultOptions: {
+      queries: {
+        retry: false,
+      },
+    },
+  });
+  const apiClient = createMockAbacusClient();
+  // Create a minimal AuthManager-shaped mock for test contexts
+  const mockSecureStorage = {
+    getSecret: vi.fn().mockResolvedValue(null),
+    setSecret: vi.fn().mockResolvedValue(undefined),
+    deleteSecret: vi.fn().mockResolvedValue(undefined),
+  };
+  const mockAuthManager = new AuthManager(mockSecureStorage);
+
+  return function TestWrapper({ children }: TestWrapperProps) {
+    return React.createElement(
+      ThemeProvider,
+      null,
+      React.createElement(
+        ApiClientProvider,
+        { client: apiClient, authManager: mockAuthManager },
+        React.createElement(
+          QueryClientProvider,
+          { client: queryClient },
+          React.createElement(
+            MockShellSizeProvider,
+            null,
+            React.createElement(
+              ShellTitleProvider,
+              null,
+              React.createElement(
+                NotificationProvider,
+                null,
+                React.createElement(
+                  ExtensionFileProvider,
+                  null,
+                  React.createElement(
+                    NetworkActivityProvider,
+                    null,
+                    React.createElement(
+                      AgentModeProvider,
+                      null,
+                      React.createElement(
+                        AgentProvider,
+                        {
+                          apiClient,
+                        },
+                        children,
+                      ),
+                    ),
+                  ),
+                ),
+              ),
+            ),
+          ),
+        ),
+      ),
+    );
+  };
+}

package/src/__e2e__/keyboard-navigation.e2e.test.tsx

@@ -0,0 +1,34 @@
+import React from "react";
+import { describe, it, expect } from "vitest";
+
+import { App } from "../entrypoints/repl.js";
+import { Timing } from "../lib/timing.js";
+import {
+  renderWithProviders,
+  simulateText,
+  simulateEscape,
+  waitForFrame,
+} from "./helpers/test-helpers.js";
+
+describe.concurrent("Keyboard Navigation E2E Tests", () => {
+  it("double ESC resets composer", async () => {
+    const timing = new Timing();
+
+    const { lastFrame, stdin, unmount } = renderWithProviders(React.createElement(App, { timing }));
+
+    await waitForFrame(lastFrame, (frame) => frame.length > 0, 5000);
+
+    simulateText(stdin, "Some text in composer");
+
+    const frameBeforeEsc = lastFrame();
+    expect(frameBeforeEsc.length).toBeGreaterThan(0);
+
+    simulateEscape(stdin);
+    simulateEscape(stdin);
+
+    const frameAfterEsc = lastFrame();
+    expect(frameAfterEsc.length).toBeGreaterThan(0);
+
+    unmount();
+  });
+});