whale-code 6.5.6 → 6.5.7

package/dist/cli/commands/__tests__/config-cmd.test.js

@@ -0,0 +1,270 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { vol } from "memfs";
+
+// ============================================================================
+// Mocks — must be declared before imports
+// ============================================================================
+
+vi.mock("fs", async () => {
+  const memfs = await import("memfs");
+  return {
+    ...memfs.fs,
+    default: memfs.fs
+  };
+});
+vi.mock("os", () => ({
+  homedir: () => "/home/testuser"
+}));
+import { runConfigCommand } from "../config-cmd.js";
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+const SESSION_PATH = "/home/testuser/.whaletools/session.json";
+const PREFS_PATH = "/home/testuser/.whaletools/preferences.json";
+function writeConfig(data) {
+  vol.mkdirSync("/home/testuser/.whaletools", {
+    recursive: true
+  });
+  vol.writeFileSync(SESSION_PATH, JSON.stringify(data, null, 2));
+}
+function readSession() {
+  const raw = vol.readFileSync(SESSION_PATH, "utf-8");
+  return JSON.parse(raw);
+}
+
+// ============================================================================
+// Setup / Teardown
+// ============================================================================
+
+let logSpy;
+let errorSpy;
+beforeEach(() => {
+  vol.reset();
+  logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+  errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+});
+afterEach(() => {
+  logSpy.mockRestore();
+  errorSpy.mockRestore();
+});
+
+// ============================================================================
+// Show all config (no args)
+// ============================================================================
+
+describe("runConfigCommand — show all", () => {
+  it("shows 'No configuration set' when config file does not exist", async () => {
+    await runConfigCommand([], {});
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("No configuration set");
+  });
+  it("shows 'No configuration set' when config is empty object", async () => {
+    writeConfig({});
+    await runConfigCommand([], {});
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("No configuration set");
+  });
+  it("displays simple key-value pairs", async () => {
+    writeConfig({
+      store_id: "abc123",
+      email: "test@example.com"
+    });
+    await runConfigCommand([], {});
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("store_id");
+    expect(output).toContain("abc123");
+    expect(output).toContain("email");
+    expect(output).toContain("test@example.com");
+  });
+  it("displays nested object values", async () => {
+    writeConfig({
+      section: {
+        host: "localhost",
+        port: 3000
+      }
+    });
+    await runConfigCommand([], {});
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("section");
+    expect(output).toContain("host");
+    expect(output).toContain("localhost");
+  });
+  it("displays config path in header", async () => {
+    writeConfig({});
+    await runConfigCommand([], {});
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain(SESSION_PATH);
+  });
+});
+
+// ============================================================================
+// Secret masking
+// ============================================================================
+
+describe("runConfigCommand — secret masking", () => {
+  it("masks values for keys containing 'key'", async () => {
+    writeConfig({
+      api_key: "sk-abcdefghijkl1234"
+    });
+    await runConfigCommand([], {});
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("sk-a");
+    expect(output).toContain("1234");
+    expect(output).not.toContain("sk-abcdefghijkl1234");
+  });
+  it("masks values for keys containing 'token'", async () => {
+    writeConfig({
+      access_token: "eyJhbGciOiJIUzI1NiJ9"
+    });
+    await runConfigCommand([], {});
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).not.toContain("eyJhbGciOiJIUzI1NiJ9");
+    expect(output).toContain("eyJh");
+    expect(output).toContain("iJ9");
+  });
+  it("masks values for keys containing 'secret'", async () => {
+    writeConfig({
+      client_secret: "supersecretvalue123"
+    });
+    await runConfigCommand([], {});
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).not.toContain("supersecretvalue123");
+  });
+  it("shows *** for short secrets (<=8 chars)", async () => {
+    writeConfig({
+      api_key: "short"
+    });
+    await runConfigCommand([], {});
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("***");
+    expect(output).not.toContain("short");
+  });
+  it("does not mask non-secret keys", async () => {
+    writeConfig({
+      email: "user@example.com"
+    });
+    await runConfigCommand([], {});
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("user@example.com");
+  });
+});
+
+// ============================================================================
+// Read single key
+// ============================================================================
+
+describe("runConfigCommand — read single key", () => {
+  it("displays value of existing key", async () => {
+    writeConfig({
+      store_id: "abc123"
+    });
+    await runConfigCommand(["store_id"], {});
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("abc123");
+  });
+  it("shows '(not set)' for missing key", async () => {
+    writeConfig({});
+    await runConfigCommand(["nonexistent"], {});
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("(not set)");
+  });
+  it("displays object values as JSON", async () => {
+    writeConfig({
+      servers: {
+        host: "localhost",
+        port: 3000
+      }
+    });
+    await runConfigCommand(["servers"], {});
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("localhost");
+    expect(output).toContain("3000");
+  });
+  it("masks secret value when reading single key", async () => {
+    writeConfig({
+      api_key: "sk-abcdefghijkl1234"
+    });
+    await runConfigCommand(["api_key"], {});
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).not.toContain("sk-abcdefghijkl1234");
+    expect(output).toContain("sk-a");
+  });
+  it("displays numeric values as strings", async () => {
+    writeConfig({
+      port: 8080
+    });
+    await runConfigCommand(["port"], {});
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("8080");
+  });
+});
+
+// ============================================================================
+// Write single key
+// ============================================================================
+
+describe("runConfigCommand — write key", () => {
+  it("writes a new key to config", async () => {
+    await runConfigCommand(["store_id", "new-store"], {});
+    const session = readSession();
+    expect(session.store_id).toBe("new-store");
+  });
+  it("outputs confirmation after writing", async () => {
+    await runConfigCommand(["email", "test@test.com"], {});
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("email = test@test.com");
+  });
+  it("overwrites existing key", async () => {
+    writeConfig({
+      store_id: "old"
+    });
+    await runConfigCommand(["store_id", "new"], {});
+    const session = readSession();
+    expect(session.store_id).toBe("new");
+  });
+  it("preserves other keys when writing", async () => {
+    writeConfig({
+      email: "keep@me.com"
+    });
+    await runConfigCommand(["store_id", "s1"], {});
+    const session = readSession();
+    expect(session.email).toBe("keep@me.com");
+    expect(session.store_id).toBe("s1");
+  });
+  it("creates config directory if it does not exist", async () => {
+    await runConfigCommand(["store_id", "val"], {});
+    expect(vol.existsSync(SESSION_PATH)).toBe(true);
+  });
+});
+
+// ============================================================================
+// --reset flag
+// ============================================================================
+
+describe("runConfigCommand — reset", () => {
+  it("removes session file on reset", async () => {
+    writeConfig({
+      store_id: "s1",
+      email: "a@b.com"
+    });
+    await runConfigCommand([], {
+      reset: true
+    });
+    // clearConfig deletes session.json
+    expect(vol.existsSync(SESSION_PATH)).toBe(false);
+  });
+  it("outputs reset confirmation", async () => {
+    await runConfigCommand([], {
+      reset: true
+    });
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("Configuration reset to defaults");
+  });
+  it("does not throw when no config exists", async () => {
+    await expect(runConfigCommand([], {
+      reset: true
+    })).resolves.not.toThrow();
+  });
+});

package/dist/cli/commands/__tests__/doctor.test.js

@@ -0,0 +1,257 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { vol } from "memfs";
+
+// ============================================================================
+// Mocks — must be declared before imports
+// ============================================================================
+
+vi.mock("fs", async () => {
+  const memfs = await import("memfs");
+  return {
+    ...memfs.fs,
+    default: memfs.fs
+  };
+});
+vi.mock("os", () => ({
+  homedir: () => "/home/testuser"
+}));
+vi.mock("child_process", () => ({
+  execSync: vi.fn()
+}));
+
+// Mock dynamic imports used in doctor checks
+vi.mock("../../services/auth-service.js", () => ({
+  SUPABASE_URL: "https://test.supabase.co",
+  isLoggedIn: vi.fn(() => false),
+  getValidToken: vi.fn(() => null)
+}));
+vi.mock("../../services/config-store.js", () => ({
+  loadConfig: vi.fn(() => ({}))
+}));
+vi.mock("../../services/server-tools.js", () => ({
+  loadServerToolDefinitions: vi.fn(() => [])
+}));
+import { runDoctor } from "../doctor.js";
+import { execSync } from "child_process";
+import { loadConfig } from "../../services/config-store.js";
+
+// ============================================================================
+// Setup / Teardown
+// ============================================================================
+
+let logSpy;
+let originalFetch;
+beforeEach(() => {
+  vol.reset();
+  logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+  vi.mocked(execSync).mockReset();
+  vi.mocked(loadConfig).mockReset().mockReturnValue({});
+  delete process.env.ANTHROPIC_API_KEY;
+  // Mock fetch globally so checkSupabase() doesn't make real network calls
+  originalFetch = globalThis.fetch;
+  globalThis.fetch = vi.fn().mockResolvedValue({
+    ok: true,
+    status: 200
+  });
+});
+afterEach(() => {
+  logSpy.mockRestore();
+  globalThis.fetch = originalFetch;
+});
+
+// ============================================================================
+// Overall runDoctor behavior
+// ============================================================================
+
+describe("runDoctor — output structure", () => {
+  it("prints the doctor header", async () => {
+    vi.mocked(execSync).mockImplementation(() => "");
+    await runDoctor();
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("whale doctor");
+  });
+  it("runs all 8 checks", async () => {
+    vi.mocked(execSync).mockImplementation(() => "");
+    await runDoctor();
+    // At least 8 non-empty log calls for the checks
+    // Header + 8 checks + summary line + blank lines
+    expect(logSpy.mock.calls.length).toBeGreaterThanOrEqual(8);
+  });
+  it("prints check labels in the output", async () => {
+    vi.mocked(execSync).mockImplementation(() => "");
+    await runDoctor();
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("Node.js");
+    expect(output).toContain("Auth");
+    expect(output).toContain("MCP servers");
+    expect(output).toContain("Version");
+  });
+});
+
+// ============================================================================
+// Node.js version check
+// ============================================================================
+
+describe("runDoctor — Node.js check", () => {
+  it("reports ok for Node >= 20", async () => {
+    vi.mocked(execSync).mockImplementation(() => "");
+    await runDoctor();
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("Node.js");
+    expect(output).toContain(process.version);
+  });
+});
+
+// ============================================================================
+// ripgrep check
+// ============================================================================
+
+describe("runDoctor — ripgrep check", () => {
+  it("reports ok when rg is available", async () => {
+    vi.mocked(execSync).mockImplementation(cmd => {
+      if (typeof cmd === "string" && cmd.includes("rg --version")) {
+        return "ripgrep 14.1.0\n";
+      }
+      return "";
+    });
+    await runDoctor();
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("ripgrep");
+    expect(output).toContain("14.1.0");
+  });
+  it("reports warn when rg is not found and @vscode/ripgrep unavailable", async () => {
+    vi.mocked(execSync).mockImplementation(cmd => {
+      if (typeof cmd === "string" && cmd.includes("rg --version")) {
+        throw new Error("command not found");
+      }
+      return "";
+    });
+    await runDoctor();
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("ripgrep");
+  });
+});
+
+// ============================================================================
+// Supabase check
+// ============================================================================
+
+describe("runDoctor — Supabase check", () => {
+  it("reports Supabase label in output", async () => {
+    vi.mocked(execSync).mockImplementation(() => "");
+    await runDoctor();
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("Supabase");
+  });
+  it("handles Supabase fetch failure gracefully", async () => {
+    globalThis.fetch = vi.fn().mockRejectedValue(new Error("network down"));
+    vi.mocked(execSync).mockImplementation(() => "");
+    await runDoctor();
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("Supabase");
+  });
+});
+
+// ============================================================================
+// Auth check
+// ============================================================================
+
+describe("runDoctor — Auth check", () => {
+  it("reports warn when not logged in and no API key", async () => {
+    vi.mocked(execSync).mockImplementation(() => "");
+    await runDoctor();
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("Auth");
+  });
+  it("reports ok when ANTHROPIC_API_KEY env is set", async () => {
+    process.env.ANTHROPIC_API_KEY = "sk-test-key";
+    vi.mocked(execSync).mockImplementation(() => "");
+    await runDoctor();
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("Auth");
+  });
+});
+
+// ============================================================================
+// MCP servers check
+// ============================================================================
+
+describe("runDoctor — MCP servers check", () => {
+  it("reports 'none configured' when no MCP servers in config", async () => {
+    vi.mocked(loadConfig).mockReturnValue({});
+    vi.mocked(execSync).mockImplementation(() => "");
+    await runDoctor();
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("MCP servers");
+    expect(output).toContain("none configured");
+  });
+  it("reports count when MCP servers are configured", async () => {
+    vi.mocked(loadConfig).mockReturnValue({
+      mcpServers: {
+        server1: {
+          transport: "stdio",
+          command: "node"
+        },
+        server2: {
+          transport: "http",
+          url: "http://localhost:3000"
+        }
+      }
+    });
+    vi.mocked(execSync).mockImplementation(() => "");
+    await runDoctor();
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("2 configured");
+  });
+  it("reports 'none configured' when mcpServers is empty", async () => {
+    vi.mocked(loadConfig).mockReturnValue({
+      mcpServers: {}
+    });
+    vi.mocked(execSync).mockImplementation(() => "");
+    await runDoctor();
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("none configured");
+  });
+});
+
+// ============================================================================
+// Disk space check
+// ============================================================================
+
+describe("runDoctor — Disk space check", () => {
+  it("reports data dir not created when dir does not exist", async () => {
+    vi.mocked(execSync).mockImplementation(() => "");
+    await runDoctor();
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("Data dir");
+    expect(output).toContain("not created yet");
+  });
+  it("reports size when dir exists and du succeeds", async () => {
+    vol.mkdirSync("/home/testuser/.whaletools", {
+      recursive: true
+    });
+    vi.mocked(execSync).mockImplementation(cmd => {
+      if (typeof cmd === "string" && cmd.includes("du -sh")) {
+        return "4.0K\t/home/testuser/.whaletools\n";
+      }
+      return "";
+    });
+    await runDoctor();
+    const output = logSpy.mock.calls.map(c => c[0]).join("\n");
+    expect(output).toContain("Data dir");
+    expect(output).toContain("4.0K");
+  });
+});
+
+// ============================================================================
+// Summary line
+// ============================================================================
+
+describe("runDoctor — summary", () => {
+  it("prints summary after all checks", async () => {
+    vi.mocked(execSync).mockImplementation(() => "");
+    await runDoctor();
+    // Should have printed something — at least the header and some checks
+    expect(logSpy.mock.calls.length).toBeGreaterThan(0);
+  });
+});

package/dist/cli/commands/__tests__/imsg-node-bridge.test.js

@@ -0,0 +1,99 @@
+/**
+ * Tests for imsg-node-bridge — auto-provisioning and lifecycle management
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { existsSync, writeFileSync, unlinkSync } from "node:fs";
+
+// Mock dependencies before importing
+vi.mock("../../services/auth-service.js", () => ({
+  getValidToken: vi.fn()
+}));
+vi.mock("../../services/config-store.js", () => ({
+  loadConfig: vi.fn(),
+  WHALE_SERVER_URL: "https://whale-agent.fly.dev"
+}));
+vi.mock("../../../node/config.js", () => ({
+  loadConfig: vi.fn(),
+  saveConfig: vi.fn()
+}));
+vi.mock("../../../node/runtime.js", () => ({
+  NodeRuntime: vi.fn().mockImplementation(() => ({
+    start: vi.fn().mockResolvedValue(undefined),
+    stop: vi.fn().mockResolvedValue(undefined),
+    adapters: new Map()
+  }))
+}));
+vi.mock("../imsg-config.js", () => ({
+  loadImsgConfig: vi.fn().mockReturnValue({
+    default_agent: "test-agent-id",
+    conversations: {
+      "+15551234567": {
+        allowed: true,
+        system_prompt: "Be helpful"
+      },
+      "+15559999999": {
+        allowed: false
+      }
+    }
+  })
+}));
+vi.mock("../../../shared/imsg-constants.js", () => ({
+  PID_FILE: "/tmp/test-imsg-whale-daemon.pid"
+}));
+describe("imsg-node-bridge", () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+  afterEach(() => {
+    vi.restoreAllMocks();
+    // Clean up test PID file
+    try {
+      unlinkSync("/tmp/test-imsg-whale-daemon.pid");
+    } catch {/* ignore */}
+  });
+  describe("getImsgNodeStatus", () => {
+    it("returns null when no PID file exists", async () => {
+      const {
+        getImsgNodeStatus
+      } = await import("../imsg-node-bridge.js");
+      // Ensure no PID file
+      try {
+        unlinkSync("/tmp/test-imsg-whale-daemon.pid");
+      } catch {/* ignore */}
+      expect(getImsgNodeStatus()).toBeNull();
+    });
+    it("returns pid when PID file exists and process is alive", async () => {
+      const {
+        getImsgNodeStatus
+      } = await import("../imsg-node-bridge.js");
+      // Write our own PID (we know it's alive)
+      writeFileSync("/tmp/test-imsg-whale-daemon.pid", String(process.pid));
+      const status = getImsgNodeStatus();
+      expect(status).not.toBeNull();
+      expect(status.pid).toBe(process.pid);
+    });
+    it("returns null and cleans up when PID file has dead process", async () => {
+      const {
+        getImsgNodeStatus
+      } = await import("../imsg-node-bridge.js");
+      // Write a PID that almost certainly doesn't exist
+      writeFileSync("/tmp/test-imsg-whale-daemon.pid", "999999999");
+      const status = getImsgNodeStatus();
+      expect(status).toBeNull();
+      // PID file should be cleaned up
+      expect(existsSync("/tmp/test-imsg-whale-daemon.pid")).toBe(false);
+    });
+  });
+  describe("stopImsgNode", () => {
+    it("returns false when no daemon is running", async () => {
+      const {
+        stopImsgNode
+      } = await import("../imsg-node-bridge.js");
+      try {
+        unlinkSync("/tmp/test-imsg-whale-daemon.pid");
+      } catch {/* ignore */}
+      expect(stopImsgNode()).toBe(false);
+    });
+  });
+});

package/dist/cli/commands/__tests__/imsg-utils.test.js

@@ -0,0 +1,73 @@
+/**
+ * Tests for imsg-utils — standalone imsg binary queries
+ */
+
+import { describe, it, expect, vi } from "vitest";
+vi.mock("../../../shared/imsg-constants.js", () => ({
+  IMSG_BIN: "echo" // Use echo as a safe substitute
+}));
+vi.mock("node:child_process", () => ({
+  execFileSync: vi.fn().mockImplementation((cmd, args) => {
+    if (args.includes("chats")) {
+      return JSON.stringify([{
+        chat_id: 1,
+        display_name: "Test Chat",
+        is_group: false
+      }, {
+        chat_id: 2,
+        display_name: "Group Chat",
+        is_group: true
+      }]);
+    }
+    if (args.includes("list")) {
+      return JSON.stringify([{
+        text: "Hello",
+        sender: "+15551234567"
+      }]);
+    }
+    return "[]";
+  })
+}));
+describe("imsg-utils", () => {
+  describe("listChats", () => {
+    it("returns parsed chat list", async () => {
+      const {
+        listChats
+      } = await import("../imsg-utils.js");
+      const chats = listChats(10);
+      expect(chats).toHaveLength(2);
+      expect(chats[0].display_name).toBe("Test Chat");
+      expect(chats[1].is_group).toBe(true);
+    });
+    it("uses default limit of 20", async () => {
+      const {
+        listChats
+      } = await import("../imsg-utils.js");
+      const {
+        execFileSync
+      } = await import("node:child_process");
+      listChats();
+      expect(execFileSync).toHaveBeenCalledWith(expect.any(String), expect.arrayContaining(["--limit", "20"]), expect.any(Object));
+    });
+  });
+  describe("listMessages", () => {
+    it("returns parsed message list", async () => {
+      const {
+        listMessages
+      } = await import("../imsg-utils.js");
+      const msgs = listMessages(undefined, 5);
+      expect(msgs).toHaveLength(1);
+      expect(msgs[0].text).toBe("Hello");
+    });
+    it("includes chat-id when provided", async () => {
+      const {
+        listMessages
+      } = await import("../imsg-utils.js");
+      const {
+        execFileSync
+      } = await import("node:child_process");
+      listMessages(42, 10);
+      expect(execFileSync).toHaveBeenCalledWith(expect.any(String), expect.arrayContaining(["--chat-id", "42"]), expect.any(Object));
+    });
+  });
+});