whale-code 6.5.10 → 6.6.0

package/dist/cli/services/__tests__/auth-service.test.js

@@ -1,242 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-// ============================================================================
-// Mocks
-// ============================================================================
-
-const mockSignInWithPassword = vi.fn();
-const mockSignUp = vi.fn();
-const mockRefreshSession = vi.fn();
-const mockFrom = vi.fn();
-vi.mock("@supabase/supabase-js", () => ({
-  createClient: vi.fn(() => ({
-    auth: {
-      signInWithPassword: mockSignInWithPassword,
-      signUp: mockSignUp,
-      refreshSession: mockRefreshSession
-    },
-    from: mockFrom
-  }))
-}));
-const mockLoadConfig = vi.fn(() => ({}));
-const mockSaveConfig = vi.fn();
-const mockClearConfig = vi.fn();
-const mockUpdateConfig = vi.fn();
-vi.mock("../config-store.js", () => ({
-  loadConfig: (...args) => mockLoadConfig(...args),
-  saveConfig: (...args) => mockSaveConfig(...args),
-  clearConfig: (...args) => mockClearConfig(...args),
-  updateConfig: (...args) => mockUpdateConfig(...args)
-}));
-import { signIn, signUp, refreshSession } from "../auth-service.js";
-
-// ============================================================================
-// Setup
-// ============================================================================
-
-beforeEach(() => {
-  vi.clearAllMocks();
-  mockLoadConfig.mockReturnValue({});
-});
-
-// ============================================================================
-// signIn
-// ============================================================================
-
-describe("signIn", () => {
-  it("returns success with session data", async () => {
-    mockSignInWithPassword.mockResolvedValue({
-      data: {
-        session: {
-          access_token: "at",
-          refresh_token: "rt",
-          expires_at: 9999999999
-        },
-        user: {
-          id: "u1",
-          email: "test@test.com",
-          user_metadata: {}
-        }
-      },
-      error: null
-    });
-    const emptyResult = {
-      data: [],
-      error: null
-    };
-    mockFrom.mockReturnValue({
-      select: vi.fn().mockReturnValue({
-        limit: vi.fn().mockResolvedValue(emptyResult),
-        eq: vi.fn().mockReturnValue({
-          ...emptyResult,
-          then: cb => Promise.resolve(emptyResult).then(cb),
-          in: vi.fn().mockResolvedValue(emptyResult)
-        }),
-        in: vi.fn().mockResolvedValue(emptyResult)
-      })
-    });
-    const result = await signIn("test@test.com", "password123");
-    expect(result.success).toBe(true);
-    expect(result.config?.access_token).toBe("at");
-    expect(result.config?.email).toBe("test@test.com");
-    expect(mockSaveConfig).toHaveBeenCalled();
-  });
-  it("returns error on auth failure", async () => {
-    mockSignInWithPassword.mockResolvedValue({
-      data: {
-        session: null,
-        user: null
-      },
-      error: {
-        message: "Invalid credentials"
-      }
-    });
-    const result = await signIn("bad@test.com", "wrong");
-    expect(result.success).toBe(false);
-    expect(result.error).toBe("Invalid credentials");
-  });
-  it("returns error when no session returned", async () => {
-    mockSignInWithPassword.mockResolvedValue({
-      data: {
-        session: null,
-        user: {
-          id: "u1",
-          email: "test@test.com"
-        }
-      },
-      error: null
-    });
-    const result = await signIn("test@test.com", "pass");
-    expect(result.success).toBe(false);
-    expect(result.error).toContain("No session");
-  });
-  it("extracts store from JWT user_metadata", async () => {
-    mockSignInWithPassword.mockResolvedValue({
-      data: {
-        session: {
-          access_token: "at",
-          refresh_token: "rt",
-          expires_at: 9999
-        },
-        user: {
-          id: "u1",
-          email: "test@test.com",
-          user_metadata: {
-            vendor_id: "store-1",
-            store_name: "My Store"
-          }
-        }
-      },
-      error: null
-    });
-    const result = await signIn("test@test.com", "pass");
-    expect(result.success).toBe(true);
-    expect(result.config?.store_id).toBe("store-1");
-    expect(result.config?.store_name).toBe("My Store");
-  });
-});
-
-// ============================================================================
-// signUp
-// ============================================================================
-
-describe("signUp", () => {
-  it("returns success with session on immediate confirmation", async () => {
-    mockSignUp.mockResolvedValue({
-      data: {
-        session: {
-          access_token: "at",
-          refresh_token: "rt",
-          expires_at: 9999
-        },
-        user: {
-          id: "u1",
-          email: "new@test.com"
-        }
-      },
-      error: null
-    });
-    const result = await signUp("new@test.com", "password");
-    expect(result.success).toBe(true);
-    expect(result.config?.access_token).toBe("at");
-    expect(mockSaveConfig).toHaveBeenCalled();
-  });
-  it("returns success with email confirmation message when no session", async () => {
-    mockSignUp.mockResolvedValue({
-      data: {
-        session: null,
-        user: {
-          id: "u1",
-          email: "new@test.com"
-        }
-      },
-      error: null
-    });
-    const result = await signUp("new@test.com", "password");
-    expect(result.success).toBe(true);
-    expect(result.error).toContain("email");
-  });
-  it("returns error on signup failure", async () => {
-    mockSignUp.mockResolvedValue({
-      data: {
-        session: null,
-        user: null
-      },
-      error: {
-        message: "Email already taken"
-      }
-    });
-    const result = await signUp("existing@test.com", "pass");
-    expect(result.success).toBe(false);
-    expect(result.error).toBe("Email already taken");
-  });
-});
-
-// ============================================================================
-// refreshSession
-// ============================================================================
-
-describe("refreshSession", () => {
-  it("returns error when not logged in", async () => {
-    mockLoadConfig.mockReturnValue({});
-    const result = await refreshSession();
-    expect(result.success).toBe(false);
-    expect(result.error).toContain("Not logged in");
-  });
-  it("refreshes tokens successfully", async () => {
-    mockLoadConfig.mockReturnValue({
-      refresh_token: "old_rt",
-      email: "test@test.com"
-    });
-    mockRefreshSession.mockResolvedValue({
-      data: {
-        session: {
-          access_token: "new_at",
-          refresh_token: "new_rt",
-          expires_at: 9999
-        }
-      },
-      error: null
-    });
-    const result = await refreshSession();
-    expect(result.success).toBe(true);
-    expect(result.config?.access_token).toBe("new_at");
-    expect(result.config?.refresh_token).toBe("new_rt");
-  });
-  it("clears config on refresh failure", async () => {
-    mockLoadConfig.mockReturnValue({
-      refresh_token: "old_rt"
-    });
-    mockRefreshSession.mockResolvedValue({
-      data: {
-        session: null
-      },
-      error: {
-        message: "Token expired"
-      }
-    });
-    const result = await refreshSession();
-    expect(result.success).toBe(false);
-    expect(mockClearConfig).toHaveBeenCalled();
-  });
-});

package/dist/cli/services/__tests__/background-processes.test.js

@@ -1,282 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-
-// ============================================================================
-// Mocks
-// ============================================================================
-const mockOn = vi.fn();
-const mockKill = vi.fn();
-const mockStdoutOn = vi.fn();
-const mockStderrOn = vi.fn();
-const mockChildProcess = {
-  pid: 12345,
-  stdout: {
-    on: mockStdoutOn
-  },
-  stderr: {
-    on: mockStderrOn
-  },
-  on: mockOn,
-  kill: mockKill
-};
-const mockSpawn = vi.fn().mockReturnValue(mockChildProcess);
-vi.mock("child_process", () => ({
-  spawn: (...args) => mockSpawn(...args),
-  ChildProcess: class {}
-}));
-vi.mock("fs", () => ({
-  readFileSync: vi.fn().mockReturnValue("file contents"),
-  existsSync: vi.fn().mockReturnValue(true)
-}));
-import { spawnBackground, readProcessOutput, killProcess, listProcesses, registerBackgroundAgent, getAgentStatus, markAgentDone, readAgentOutput, listBackgroundAgents, stopBackgroundAgent, BACKGROUND_TOOL_DEFINITIONS } from "../background-processes.js";
-
-// ============================================================================
-// spawnBackground
-// ============================================================================
-describe("spawnBackground", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.useFakeTimers({
-      shouldAdvanceTime: true
-    });
-    // Reset mock callbacks
-    mockOn.mockReset();
-    mockStdoutOn.mockReset();
-    mockStderrOn.mockReset();
-    mockKill.mockReset();
-    mockSpawn.mockReturnValue({
-      pid: 12345,
-      stdout: {
-        on: mockStdoutOn
-      },
-      stderr: {
-        on: mockStderrOn
-      },
-      on: mockOn,
-      kill: mockKill
-    });
-  });
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-  it("spawns a shell process with correct args", async () => {
-    const promise = spawnBackground("echo hello");
-    await vi.advanceTimersByTimeAsync(2000);
-    const result = await promise;
-    expect(mockSpawn).toHaveBeenCalledWith("echo hello", [], expect.objectContaining({
-      shell: true,
-      stdio: ["ignore", "pipe", "pipe"]
-    }));
-    expect(result.id).toMatch(/^shell-/);
-    expect(result.status).toBe("running");
-  });
-  it("uses provided cwd", async () => {
-    const promise = spawnBackground("ls", {
-      cwd: "/tmp"
-    });
-    await vi.advanceTimersByTimeAsync(2000);
-    await promise;
-    expect(mockSpawn).toHaveBeenCalledWith("ls", [], expect.objectContaining({
-      cwd: "/tmp"
-    }));
-  });
-  it("returns running status for active process", async () => {
-    const promise = spawnBackground("sleep 10");
-    await vi.advanceTimersByTimeAsync(2000);
-    const result = await promise;
-    expect(result.status).toBe("running");
-    expect(result.message).toContain("Background process running");
-  });
-  it("returns failed status when spawn throws", async () => {
-    mockSpawn.mockImplementationOnce(() => {
-      throw new Error("spawn fail");
-    });
-    const promise = spawnBackground("bad-cmd");
-    await vi.advanceTimersByTimeAsync(2000);
-    const result = await promise;
-    expect(result.status).toBe("failed");
-    expect(result.message).toContain("Failed to spawn");
-  });
-});
-
-// ============================================================================
-// readProcessOutput
-// ============================================================================
-describe("readProcessOutput", () => {
-  it("returns error for unknown process id", () => {
-    const result = readProcessOutput("nonexistent-id-xyz");
-    expect("error" in result).toBe(true);
-    if ("error" in result) {
-      expect(result.error).toContain("Process not found");
-    }
-  });
-  it("returns process output for a known process", async () => {
-    vi.useFakeTimers({
-      shouldAdvanceTime: true
-    });
-    mockSpawn.mockReturnValue({
-      pid: 999,
-      stdout: {
-        on: mockStdoutOn
-      },
-      stderr: {
-        on: mockStderrOn
-      },
-      on: mockOn,
-      kill: mockKill
-    });
-    const promise = spawnBackground("echo test");
-    // Simulate stdout data before the validation wait completes
-    const stdoutCb = mockStdoutOn.mock.calls[0]?.[1];
-    if (stdoutCb) stdoutCb(Buffer.from("hello output\n"));
-    await vi.advanceTimersByTimeAsync(2000);
-    const spawned = await promise;
-
-    // Read output
-    const output = readProcessOutput(spawned.id);
-    expect("error" in output).toBe(false);
-    if (!("error" in output)) {
-      expect(output.id).toBe(spawned.id);
-      expect(output.status).toBe("running");
-    }
-    vi.useRealTimers();
-  });
-});
-
-// ============================================================================
-// killProcess
-// ============================================================================
-describe("killProcess", () => {
-  it("returns failure for unknown process", () => {
-    const result = killProcess("nonexistent-kill-id");
-    expect(result.success).toBe(false);
-    expect(result.message).toContain("Process not found");
-  });
-});
-
-// ============================================================================
-// listProcesses
-// ============================================================================
-describe("listProcesses", () => {
-  it("returns an array", () => {
-    const list = listProcesses();
-    expect(Array.isArray(list)).toBe(true);
-  });
-  it("list entries have expected shape", () => {
-    const list = listProcesses();
-    for (const p of list) {
-      expect(p).toHaveProperty("id");
-      expect(p).toHaveProperty("command");
-      expect(p).toHaveProperty("status");
-      expect(p).toHaveProperty("runtime");
-      expect(p).toHaveProperty("outputLines");
-      expect(p).toHaveProperty("errorLines");
-    }
-  });
-});
-
-// ============================================================================
-// Background Agent Tracking
-// ============================================================================
-describe("registerBackgroundAgent", () => {
-  it("registers an agent", () => {
-    registerBackgroundAgent("agent-1", "code", "/tmp/agent-1.log");
-    const status = getAgentStatus("agent-1");
-    expect(status).not.toBeNull();
-    expect(status.id).toBe("agent-1");
-    expect(status.type).toBe("code");
-    expect(status.status).toBe("running");
-  });
-});
-describe("getAgentStatus", () => {
-  it("returns null for unknown agent", () => {
-    expect(getAgentStatus("unknown-agent")).toBeNull();
-  });
-  it("returns agent info after registration", () => {
-    registerBackgroundAgent("agent-2", "review", "/tmp/agent-2.log");
-    const status = getAgentStatus("agent-2");
-    expect(status).toMatchObject({
-      id: "agent-2",
-      type: "review",
-      status: "running"
-    });
-  });
-});
-describe("markAgentDone", () => {
-  it("marks agent as completed", () => {
-    registerBackgroundAgent("agent-3", "test", "/tmp/agent-3.log");
-    markAgentDone("agent-3", true);
-    expect(getAgentStatus("agent-3").status).toBe("completed");
-  });
-  it("marks agent as failed", () => {
-    registerBackgroundAgent("agent-4", "test", "/tmp/agent-4.log");
-    markAgentDone("agent-4", false);
-    expect(getAgentStatus("agent-4").status).toBe("failed");
-  });
-  it("does nothing for unknown agent", () => {
-    expect(() => markAgentDone("nope", true)).not.toThrow();
-  });
-});
-describe("readAgentOutput", () => {
-  it("returns null for unknown agent", () => {
-    expect(readAgentOutput("unknown")).toBeNull();
-  });
-  it("reads output file for a registered agent", () => {
-    registerBackgroundAgent("agent-5", "code", "/tmp/agent-5.log");
-    const output = readAgentOutput("agent-5");
-    expect(output).not.toBeNull();
-    expect(output.status).toBe("running");
-    expect(output.output).toBe("file contents");
-  });
-});
-describe("listBackgroundAgents", () => {
-  it("returns an array of registered agents", () => {
-    const agents = listBackgroundAgents();
-    expect(Array.isArray(agents)).toBe(true);
-    // We have at least the agents registered in earlier tests
-    expect(agents.length).toBeGreaterThanOrEqual(1);
-  });
-});
-describe("stopBackgroundAgent", () => {
-  it("returns failure for unknown agent", () => {
-    const result = stopBackgroundAgent("nope");
-    expect(result.success).toBe(false);
-    expect(result.message).toContain("Agent not found");
-  });
-  it("marks a running agent as failed", () => {
-    registerBackgroundAgent("agent-6", "stop-test", "/tmp/agent-6.log");
-    const result = stopBackgroundAgent("agent-6");
-    expect(result.success).toBe(true);
-    expect(getAgentStatus("agent-6").status).toBe("failed");
-  });
-  it("fails to stop an already completed agent", () => {
-    registerBackgroundAgent("agent-7", "done-test", "/tmp/agent-7.log");
-    markAgentDone("agent-7", true);
-    const result = stopBackgroundAgent("agent-7");
-    expect(result.success).toBe(false);
-    expect(result.message).toContain("already completed");
-  });
-});
-
-// ============================================================================
-// BACKGROUND_TOOL_DEFINITIONS
-// ============================================================================
-describe("BACKGROUND_TOOL_DEFINITIONS", () => {
-  it("exports an array of tool definitions", () => {
-    expect(Array.isArray(BACKGROUND_TOOL_DEFINITIONS)).toBe(true);
-    expect(BACKGROUND_TOOL_DEFINITIONS.length).toBe(3);
-  });
-  it("includes bash_output tool", () => {
-    const tool = BACKGROUND_TOOL_DEFINITIONS.find(t => t.name === "bash_output");
-    expect(tool).toBeDefined();
-    expect(tool.input_schema.properties).toHaveProperty("bash_id");
-  });
-  it("includes kill_shell tool", () => {
-    const tool = BACKGROUND_TOOL_DEFINITIONS.find(t => t.name === "kill_shell");
-    expect(tool).toBeDefined();
-    expect(tool.input_schema.properties).toHaveProperty("shell_id");
-  });
-  it("includes list_shells tool", () => {
-    const tool = BACKGROUND_TOOL_DEFINITIONS.find(t => t.name === "list_shells");
-    expect(tool).toBeDefined();
-  });
-});

package/dist/cli/services/__tests__/claude-md-loader.test.js

@@ -1,134 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { vol } from "memfs";
-
-// ============================================================================
-// Mocks
-// ============================================================================
-
-vi.mock("fs", async () => {
-  const memfs = await import("memfs");
-  return {
-    ...memfs.fs,
-    default: memfs.fs
-  };
-});
-
-// Must import after mock declarations
-import { loadClaudeMd, reloadClaudeMd, resetClaudeMdCache } from "../claude-md-loader.js";
-
-// ============================================================================
-// Setup
-// ============================================================================
-
-beforeEach(() => {
-  vol.reset();
-  resetClaudeMdCache();
-});
-
-// ============================================================================
-// loadClaudeMd
-// ============================================================================
-
-describe("loadClaudeMd", () => {
-  it("returns null when no CLAUDE.md exists anywhere", () => {
-    vol.fromJSON({
-      "/tmp/project/file.ts": "code"
-    });
-    // process.cwd() won't be in memfs necessarily; mock cwd to a path in memfs
-    const cwdSpy = vi.spyOn(process, "cwd").mockReturnValue("/tmp/project");
-    expect(loadClaudeMd()).toBeNull();
-    cwdSpy.mockRestore();
-  });
-  it("finds CLAUDE.md in cwd", () => {
-    vol.fromJSON({
-      "/tmp/project/CLAUDE.md": "# Project rules\nDo X not Y",
-      "/tmp/project/src/index.ts": "code"
-    });
-    const cwdSpy = vi.spyOn(process, "cwd").mockReturnValue("/tmp/project");
-    const result = loadClaudeMd();
-    expect(result).not.toBeNull();
-    expect(result.content).toContain("Project rules");
-    expect(result.path).toBe("/tmp/project/CLAUDE.md");
-    cwdSpy.mockRestore();
-  });
-  it("finds CLAUDE.md in .claude subdirectory", () => {
-    vol.fromJSON({
-      "/tmp/project/.claude/CLAUDE.md": "Rules here"
-    });
-    const cwdSpy = vi.spyOn(process, "cwd").mockReturnValue("/tmp/project");
-    const result = loadClaudeMd();
-    expect(result).not.toBeNull();
-    expect(result.content).toBe("Rules here");
-    expect(result.path).toContain(".claude/CLAUDE.md");
-    cwdSpy.mockRestore();
-  });
-  it("walks up to parent directories", () => {
-    vol.fromJSON({
-      "/tmp/CLAUDE.md": "Root rules",
-      "/tmp/project/src/file.ts": "code"
-    });
-    const cwdSpy = vi.spyOn(process, "cwd").mockReturnValue("/tmp/project/src");
-    const result = loadClaudeMd();
-    expect(result).not.toBeNull();
-    expect(result.content).toBe("Root rules");
-    cwdSpy.mockRestore();
-  });
-  it("caches result on subsequent calls", () => {
-    vol.fromJSON({
-      "/tmp/project/CLAUDE.md": "Cached content"
-    });
-    const cwdSpy = vi.spyOn(process, "cwd").mockReturnValue("/tmp/project");
-    const first = loadClaudeMd();
-    // Remove the file — should still return cached
-    vol.unlinkSync("/tmp/project/CLAUDE.md");
-    const second = loadClaudeMd();
-    expect(second).toEqual(first);
-    cwdSpy.mockRestore();
-  });
-  it("skips empty CLAUDE.md files", () => {
-    vol.fromJSON({
-      "/tmp/project/CLAUDE.md": "   \n  "
-    });
-    const cwdSpy = vi.spyOn(process, "cwd").mockReturnValue("/tmp/project");
-    const result = loadClaudeMd();
-    expect(result).toBeNull();
-    cwdSpy.mockRestore();
-  });
-});
-
-// ============================================================================
-// reloadClaudeMd
-// ============================================================================
-
-describe("reloadClaudeMd", () => {
-  it("clears cache and reloads from disk", () => {
-    vol.fromJSON({
-      "/tmp/project/CLAUDE.md": "V1 content"
-    });
-    const cwdSpy = vi.spyOn(process, "cwd").mockReturnValue("/tmp/project");
-    loadClaudeMd(); // cache V1
-    vol.writeFileSync("/tmp/project/CLAUDE.md", "V2 content");
-    const result = reloadClaudeMd();
-    expect(result.content).toBe("V2 content");
-    cwdSpy.mockRestore();
-  });
-});
-
-// ============================================================================
-// resetClaudeMdCache
-// ============================================================================
-
-describe("resetClaudeMdCache", () => {
-  it("clears cache so next load reads from disk", () => {
-    vol.fromJSON({
-      "/tmp/project/CLAUDE.md": "Original"
-    });
-    const cwdSpy = vi.spyOn(process, "cwd").mockReturnValue("/tmp/project");
-    loadClaudeMd();
-    resetClaudeMdCache();
-    vol.writeFileSync("/tmp/project/CLAUDE.md", "Updated");
-    const result = loadClaudeMd();
-    expect(result.content).toBe("Updated");
-    cwdSpy.mockRestore();
-  });
-});