@tyvm/knowhow 0.0.159 → 0.0.160

package/tests/unit/commands/misc.test.ts

@@ -1,85 +0,0 @@
-import { Command } from "commander";
-
-const login = jest.fn().mockResolvedValue(undefined);
-const registerIdentity = jest.fn().mockResolvedValue(undefined);
-const ensureIdentityKeyPair = jest.fn();
-
-jest.mock("../../../src/login", () => ({ login }));
-jest.mock("../../../src/index", () => ({
-  embed: jest.fn(),
-  upload: jest.fn(),
-  download: jest.fn(),
-  purge: jest.fn(),
-}));
-jest.mock("../../../src/auth/registerIdentity", () => ({ registerIdentity }));
-jest.mock("../../../src/auth/keyManager", () => ({ ensureIdentityKeyPair }));
-
-import { addLoginCommand } from "../../../src/commands/misc";
-
-describe("login command", () => {
-  let program: Command;
-  let logSpy: jest.SpyInstance;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    program = new Command();
-    program.exitOverride();
-    addLoginCommand(program);
-    logSpy = jest.spyOn(console, "log").mockImplementation(() => undefined);
-  });
-
-  afterEach(() => {
-    logSpy.mockRestore();
-  });
-
-  it("supports --key-gen non-interactively and exits without login", async () => {
-    ensureIdentityKeyPair.mockReturnValue({
-      created: true,
-      keyPair: {
-        fingerprint: "SHA256:test",
-        privateKeyPath: "/keys/id_ed25519",
-        publicKeyPath: "/keys/id_ed25519.pub",
-      },
-    });
-
-    await program.parseAsync(["node", "knowhow", "login", "--key-gen"]);
-
-    expect(ensureIdentityKeyPair).toHaveBeenCalledWith(undefined);
-    expect(login).not.toHaveBeenCalled();
-    expect(registerIdentity).not.toHaveBeenCalled();
-
-    const output = logSpy.mock.calls.map((call) => call.join(" ")).join("\n");
-    expect(output).toContain("Generated CLI identity keypair");
-    expect(output).toContain("/keys/id_ed25519");
-    expect(output).toContain("/keys/id_ed25519.pub");
-  });
-
-  it("does not overwrite existing key when using --key-gen", async () => {
-    ensureIdentityKeyPair.mockReturnValue({
-      created: false,
-      keyPair: {
-        fingerprint: "SHA256:existing",
-        privateKeyPath: "/keys/id_ed25519",
-        publicKeyPath: "/keys/id_ed25519.pub",
-      },
-    });
-
-    await program.parseAsync(["node", "knowhow", "login", "--key-gen", "--identity", "/keys/id_ed25519"]);
-
-    expect(ensureIdentityKeyPair).toHaveBeenCalledWith("/keys/id_ed25519");
-    expect(login).not.toHaveBeenCalled();
-    expect(registerIdentity).not.toHaveBeenCalled();
-
-    const output = logSpy.mock.calls.map((call) => call.join(" ")).join("\n");
-    expect(output).toContain("CLI identity keypair already exists");
-  });
-
-  it("rejects incompatible flag combinations with --key-gen", async () => {
-    await expect(
-      program.parseAsync(["node", "knowhow", "login", "--key-gen", "--jwt"])
-    ).rejects.toThrow("--key-gen cannot be used with --jwt or --register-identity");
-
-    expect(login).not.toHaveBeenCalled();
-    expect(registerIdentity).not.toHaveBeenCalled();
-  });
-});

package/tests/unit/commands/remote.test.ts

@@ -1,79 +0,0 @@
-import { Command } from "commander";
-
-const getConfig = jest.fn();
-const updateConfig = jest.fn();
-
-jest.mock("../../../src/config", () => ({ getConfig, updateConfig }));
-
-import { addRemoteCommand } from "../../../src/commands/remote";
-
-describe("remote command", () => {
-  let program: Command;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    jest.spyOn(console, "log").mockImplementation(() => undefined);
-    program = new Command();
-    program.exitOverride();
-    addRemoteCommand(program);
-  });
-
-  afterEach(() => jest.restoreAllMocks());
-
-  it("adds a named remote with an independent JWT path", async () => {
-    const config: any = {
-      orgIds: {
-        "http://localhost:4000": "org-local",
-      },
-    };
-    getConfig.mockResolvedValue(config);
-
-    await program.parseAsync([
-      "node",
-      "knowhow",
-      "remote",
-      "add",
-      "dev",
-      "https://api.dev.knowhow.tyvm.ai/",
-    ]);
-
-    expect(updateConfig).toHaveBeenCalledWith(config);
-    expect(config.remotes.dev).toEqual({
-      name: "dev",
-      apiUrl: "https://api.dev.knowhow.tyvm.ai",
-      jwtPath: ".knowhow/.jwt.dev",
-    });
-    expect(config.orgIds).toBeUndefined();
-    expect(config.remotes.local).toEqual({
-      name: "local",
-      apiUrl: "http://localhost:4000",
-      jwtPath: ".knowhow/.jwt.local",
-      orgId: "org-local",
-    });
-  });
-
-  it("selects a configured remote for subsequent commands", async () => {
-    const config: any = {
-      remotes: {
-        local: {
-          name: "local",
-          apiUrl: "http://localhost:4000",
-          jwtPath: ".knowhow/.jwt.local",
-          orgId: "org-local",
-        },
-      },
-    };
-    getConfig.mockResolvedValue(config);
-
-    await program.parseAsync([
-      "node",
-      "knowhow",
-      "remote",
-      "use",
-      "local",
-    ]);
-
-    expect(config.activeRemote).toBe("local");
-    expect(updateConfig).toHaveBeenCalledWith(config);
-  });
-});

package/tests/unit/commands/sandbox.test.ts

@@ -1,350 +0,0 @@
-/**
- * Unit tests for the sandbox CLI command.
- *
- * Focus: `regenerate-snapshot` and `snapshot-status` commands use the backend
- * `/regenerate` endpoint (fire-and-forget) + polling rather than a single
- * long synchronous exec request.
- */
-
-// ─── Mock http util ───────────────────────────────────────────────────────────
-// jest.mock is hoisted so we must declare the fns inside the factory,
-// then retrieve them via require after the fact.
-jest.mock("../../../src/utils/http", () => {
-  const get = jest.fn();
-  const post = jest.fn();
-  const del = jest.fn();
-  const mock = { get, post, delete: del };
-  return { default: mock, __esModule: true };
-});
-
-// Pull the mock fns after the module is mocked
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const httpMock = (require("../../../src/utils/http") as { default: { get: jest.Mock; post: jest.Mock; delete: jest.Mock } }).default;
-const mockGet = httpMock.get;
-const mockPost = httpMock.post;
-const mockDelete = httpMock.delete;
-
-// ─── Mock KnowhowClient ───────────────────────────────────────────────────────
-jest.mock("../../../src/services/KnowhowClient", () => ({
-  KNOWHOW_API_URL: "https://api.example.com",
-  loadKnowhowJwt: jest.fn().mockReturnValue("test-jwt-token"),
-}));
-
-import { Command } from "commander";
-import { addSandboxCommand } from "../../../src/commands/sandbox";
-
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-
-function makeProgram(): Command {
-  const program = new Command();
-  program.exitOverride();
-  addSandboxCommand(program);
-  return program;
-}
-
-function makeSnapshot(overrides: Record<string, unknown> = {}) {
-  return {
-    id: "snap123456789012",
-    sandboxId: "sb123456789012",
-    label: "tests-ready",
-    description: "CI snapshot",
-    status: "ready",
-    errorMsg: null,
-    statusMessage: null,
-    regenerationSandboxId: null,
-    snapshotContent: "disk_only",
-    setupScript: "npm install && npm run build",
-    ...overrides,
-  };
-}
-
-function makeSandbox(overrides: Record<string, unknown> = {}) {
-  return {
-    id: "sb123456789012",
-    name: "knowhow-web",
-    status: "running",
-    vmStatus: "running",
-    ...overrides,
-  };
-}
-
-// ─── Tests ────────────────────────────────────────────────────────────────────
-
-describe("sandbox regenerate-snapshot", () => {
-  let program: Command;
-  let consoleSpy: jest.SpyInstance;
-  let consoleErrorSpy: jest.SpyInstance;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    jest.useFakeTimers();
-    program = makeProgram();
-    consoleSpy = jest.spyOn(console, "log").mockImplementation(() => {});
-    consoleErrorSpy = jest.spyOn(console, "error").mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    jest.useRealTimers();
-    consoleSpy.mockRestore();
-    consoleErrorSpy.mockRestore();
-  });
-
-  it("calls POST /regenerate and returns immediately when --no-wait is set", async () => {
-    const snap = makeSnapshot();
-    // GET snapshot
-    mockGet.mockResolvedValueOnce({ data: snap });
-    // POST regenerate — returns immediately with regenerationSandboxId set
-    mockPost.mockResolvedValueOnce({
-      data: makeSnapshot({ regenerationSandboxId: "eph123456789012" }),
-    });
-
-    await program.parseAsync([
-      "node", "knowhow", "sandbox", "regenerate-snapshot",
-      "--sandbox-id", "sb123456789012",
-      "--snapshot-id", "snap123456789012",
-      "--no-wait",
-    ]);
-
-    expect(mockPost).toHaveBeenCalledTimes(1);
-    expect(mockPost).toHaveBeenCalledWith(
-      expect.stringContaining("/sandboxes/sb123456789012/snapshots/snap123456789012/regenerate"),
-      undefined,
-      expect.any(Object)
-    );
-    // Should NOT poll further (no additional GET calls after initial snapshot fetch)
-    expect(mockGet).toHaveBeenCalledTimes(1);
-  });
-
-  it("polls snapshot status until regenerationSandboxId clears and status is ready", async () => {
-    const snap = makeSnapshot();
-    // Initial GET for resolving snapshot
-    mockGet.mockResolvedValueOnce({ data: snap });
-    // POST /regenerate returns immediately
-    mockPost.mockResolvedValueOnce({
-      data: makeSnapshot({ regenerationSandboxId: "eph123456789012" }),
-    });
-    // First poll: still regenerating
-    mockGet.mockResolvedValueOnce({
-      data: makeSnapshot({
-        regenerationSandboxId: "eph123456789012",
-        statusMessage: "Running setupScript...",
-      }),
-    });
-    // Second poll: done
-    mockGet.mockResolvedValueOnce({
-      data: makeSnapshot({ regenerationSandboxId: null, status: "ready" }),
-    });
-
-    // Run the command but don't await yet — it will pause at the first setTimeout
-    const parsePromise = program.parseAsync([
-      "node", "knowhow", "sandbox", "regenerate-snapshot",
-      "--sandbox-id", "sb123456789012",
-      "--snapshot-id", "snap123456789012",
-      // --wait is the default (no --no-wait)
-    ]);
-
-    // Let pending promises resolve (GET + POST), then advance past each 5s poll delay
-    await Promise.resolve();
-    await Promise.resolve();
-    await Promise.resolve();
-    jest.runAllTimers();
-    await Promise.resolve();
-    await Promise.resolve();
-    jest.runAllTimers();
-    await Promise.resolve();
-    await Promise.resolve();
-    jest.runAllTimers();
-
-    await parsePromise;
-
-    // POST /regenerate called once
-    expect(mockPost).toHaveBeenCalledTimes(1);
-    // Initial GET + 2 polling GETs
-    expect(mockGet).toHaveBeenCalledTimes(3);
-
-    const logOutput = consoleSpy.mock.calls.map((c) => c.join(" ")).join("\n");
-    expect(logOutput).toContain("✅ Snapshot regeneration complete!");
-  });
-
-  it("does NOT fork a sandbox or exec a script directly (old behavior)", async () => {
-    const snap = makeSnapshot();
-    mockGet.mockResolvedValueOnce({ data: snap });
-    mockPost.mockResolvedValueOnce({
-      data: makeSnapshot({ regenerationSandboxId: "eph123456789012" }),
-    });
-    // done immediately
-    mockGet.mockResolvedValueOnce({
-      data: makeSnapshot({ regenerationSandboxId: null, status: "ready" }),
-    });
-
-    const parsePromise = program.parseAsync([
-      "node", "knowhow", "sandbox", "regenerate-snapshot",
-      "--sandbox-id", "sb123456789012",
-      "--snapshot-id", "snap123456789012",
-    ]);
-
-    await Promise.resolve();
-    await Promise.resolve();
-    await Promise.resolve();
-    jest.runAllTimers();
-    await Promise.resolve();
-    await Promise.resolve();
-
-    await parsePromise;
-
-    // Should only call POST /regenerate — not POST /fork or POST /exec
-    const postCalls = mockPost.mock.calls.map((c) => c[0] as string);
-    expect(postCalls.every((url) => url.includes("/regenerate"))).toBe(true);
-    expect(postCalls.some((url) => url.includes("/fork"))).toBe(false);
-    expect(postCalls.some((url) => url.includes("/exec"))).toBe(false);
-  });
-
-  it("shows statusMessage updates during polling", async () => {
-    const snap = makeSnapshot();
-    mockGet.mockResolvedValueOnce({ data: snap });
-    mockPost.mockResolvedValueOnce({
-      data: makeSnapshot({ regenerationSandboxId: "eph123456789012" }),
-    });
-    mockGet.mockResolvedValueOnce({
-      data: makeSnapshot({
-        regenerationSandboxId: "eph123456789012",
-        statusMessage: "Uploading 500 MB / 1.0 GB (50%)",
-      }),
-    });
-    mockGet.mockResolvedValueOnce({
-      data: makeSnapshot({ regenerationSandboxId: null, status: "ready" }),
-    });
-
-    const parsePromise = program.parseAsync([
-      "node", "knowhow", "sandbox", "regenerate-snapshot",
-      "--sandbox-id", "sb123456789012",
-      "--snapshot-id", "snap123456789012",
-    ]);
-
-    // Flush microtasks then advance timers repeatedly until done
-    for (let i = 0; i < 10; i++) {
-      await Promise.resolve();
-      jest.runAllTimers();
-    }
-
-    await parsePromise;
-
-    const logOutput = consoleSpy.mock.calls.map((c) => c.join(" ")).join("\n");
-    expect(logOutput).toContain("Uploading 500 MB / 1.0 GB (50%)");
-  }, 15000);
-
-  it("requires --sandbox-id or --sandbox-name", async () => {
-    await expect(
-      program.parseAsync([
-        "node", "knowhow", "sandbox", "regenerate-snapshot",
-        "--snapshot-id", "snap123456789012",
-      ])
-    ).rejects.toThrow(/sandbox-id|sandbox-name/i);
-  });
-
-  it("requires --snapshot-id or --snapshot-name", async () => {
-    // Use --sandbox-id directly (avoids name resolution GET) to keep test isolated
-    await expect(
-      program.parseAsync([
-        "node", "knowhow", "sandbox", "regenerate-snapshot",
-        "--sandbox-id", "sb123456789012",
-      ])
-    ).rejects.toThrow(/snapshot-id|snapshot-name/i);
-  });
-});
-
-describe("sandbox snapshot-status", () => {
-  let program: Command;
-  let consoleSpy: jest.SpyInstance;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    jest.useFakeTimers();
-    program = makeProgram();
-    consoleSpy = jest.spyOn(console, "log").mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    jest.useRealTimers();
-    consoleSpy.mockRestore();
-  });
-
-  it("prints snapshot status without waiting when --wait not set", async () => {
-    const snap = makeSnapshot({ regenerationSandboxId: "eph123456789012", status: "ready" });
-    mockGet.mockResolvedValueOnce({ data: snap });
-
-    await program.parseAsync([
-      "node", "knowhow", "sandbox", "snapshot-status",
-      "--sandbox-id", "sb123456789012",
-      "--snapshot-id", "snap123456789012",
-    ]);
-
-    const logOutput = consoleSpy.mock.calls.map((c) => c.join(" ")).join("\n");
-    expect(logOutput).toContain("regenerating");
-    expect(logOutput).toContain("eph123456789012");
-    // Should not poll further
-    expect(mockGet).toHaveBeenCalledTimes(1);
-  });
-
-  it("shows ready status when not regenerating", async () => {
-    const snap = makeSnapshot({ id: "snap123456789012", status: "ready" });
-    mockGet.mockResolvedValueOnce({ data: snap });
-
-    await program.parseAsync([
-      "node", "knowhow", "sandbox", "snapshot-status",
-      "--sandbox-id", "sb123456789012",
-      "--snapshot-id", "snap123456789012",
-    ]);
-
-    const logOutput = consoleSpy.mock.calls.map((c) => c.join(" ")).join("\n");
-    expect(logOutput).toContain("ready");
-  });
-
-  it("polls when --wait is set and regeneration is in progress", async () => {
-    const snapInProgress = makeSnapshot({ regenerationSandboxId: "eph123456789012" });
-    const snapDone = makeSnapshot({ regenerationSandboxId: null, status: "ready" });
-
-    // First GET: initial fetch (for snapshot-status command)
-    mockGet.mockResolvedValueOnce({ data: snapInProgress });
-    // Second GET: first poll iteration - still in progress
-    mockGet.mockResolvedValueOnce({ data: snapInProgress });
-    // Third GET: done
-    mockGet.mockResolvedValueOnce({ data: snapDone });
-
-    const parsePromise = program.parseAsync([
-      "node", "knowhow", "sandbox", "snapshot-status",
-      "--sandbox-id", "sb123456789012",
-      "--snapshot-id", "snap123456789012",
-      "--wait",
-    ]);
-
-    // Flush microtasks then advance timers
-    for (let i = 0; i < 10; i++) {
-      await Promise.resolve();
-      jest.runAllTimers();
-    }
-
-    await parsePromise;
-
-    const logOutput = consoleSpy.mock.calls.map((c) => c.join(" ")).join("\n");
-    expect(logOutput).toContain("Done");
-    expect(mockGet).toHaveBeenCalledTimes(3);
-  }, 15000);
-
-  it("outputs raw JSON with --json flag", async () => {
-    const snap = makeSnapshot();
-    mockGet.mockResolvedValueOnce({ data: snap });
-
-    await program.parseAsync([
-      "node", "knowhow", "sandbox", "snapshot-status",
-      "--sandbox-id", "sb123456789012",
-      "--snapshot-id", "snap123456789012",
-      "--json",
-    ]);
-
-    const logOutput = consoleSpy.mock.calls.map((c) => c.join(" ")).join("\n");
-    const parsed = JSON.parse(logOutput);
-    expect(parsed.id).toBe("snap123456789012");
-    expect(parsed.status).toBe("ready");
-  });
-});

package/tests/unit/hashes.test.ts

@@ -1,23 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { saveHashes } from "../../src/hashes";
-
-describe("saveHashes", () => {
-  it("creates the .knowhow directory in a fresh checkout", async () => {
-    const originalCwd = process.cwd();
-    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "knowhow-hashes-"));
-
-    try {
-      process.chdir(tempDir);
-      await saveHashes({ build: { input: "abc123" } });
-
-      expect(
-        JSON.parse(fs.readFileSync(".knowhow/.hashes.json", "utf8"))
-      ).toEqual({ build: { input: "abc123" } });
-    } finally {
-      process.chdir(originalCwd);
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-  });
-});

package/tests/unit/input-queue.test.ts

@@ -1,80 +0,0 @@
-/**
- * Test for InputQueueManager to verify it handles multiple concurrent ask() calls
- * without duplicating input streams
- */
-
-import { ask } from "../../src/utils";
-
-describe("InputQueueManager", () => {
-  // Note: These tests are designed to document the expected behavior
-  // Actual testing requires mocking stdin which is complex
-  
-  it("should handle single ask call", async () => {
-    // This test documents that a single ask call should work normally
-    expect(typeof ask).toBe("function");
-  });
-
-  it("should queue multiple concurrent asks", () => {
-    // When multiple ask() calls are made before any resolve:
-    // 1. Only one readline interface should be active
-    // 2. The most recent question should be displayed
-    // 3. When user presses Enter, all pending promises resolve with the same answer
-    
-    // This prevents input duplication that occurs when multiple readline
-    // interfaces listen to stdin simultaneously
-    
-    expect(true).toBe(true);
-  });
-
-  it("should update display when new question is asked while waiting", () => {
-    // When ask() is called while already waiting for input:
-    // 1. The display should clear and show the new question
-    // 2. The current typed text should be preserved
-    // 3. Cursor position should be maintained relative to the text
-    
-    expect(true).toBe(true);
-  });
-
-  it("should resolve all pending promises on Enter", () => {
-    // When Enter is pressed with multiple asks pending:
-    // 1. All promises in the queue should resolve with the same answer
-    // 2. The input stream should be cleaned up properly
-    // 3. If new asks were added during resolution, processNext() should handle them
-    
-    expect(true).toBe(true);
-  });
-
-  it("should handle autocomplete with options", () => {
-    // Tab completion should work using the options from the most recent ask call
-    expect(true).toBe(true);
-  });
-
-  it("should handle history from the most recent ask call", () => {
-    // Arrow key navigation should use history from the most recent ask call
-    expect(true).toBe(true);
-  });
-});
-
-describe("Integration: askHuman and ChatService", () => {
-  it("should not duplicate input when askHuman is called multiple times", () => {
-    // Scenario: Agent asks a question via askHuman
-    // Before user responds, agent asks another question
-    // Expected: User should see the most recent question and typing should not duplicate
-    
-    // Example flow:
-    // 1. askHuman("What is your name?")
-    // 2. Before user types, askHuman("What is your age?")
-    // 3. Display updates to show "What is your age?"
-    // 4. User types "25" and presses Enter
-    // 5. Both promises resolve with "25"
-    
-    expect(true).toBe(true);
-  });
-
-  it("should not conflict with ChatService.getInput", () => {
-    // ChatService.getInput and askHuman both use ask()
-    // They should share the same input queue and not duplicate streams
-    
-    expect(true).toBe(true);
-  });
-});