@tyvm/knowhow 0.0.158 → 0.0.160

package/tests/unit/agents/tools/loadImageAsBase64.test.ts

@@ -1,44 +0,0 @@
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import {
-  loadImageAsBase64,
-  loadImageAsBase64Definition,
-} from "../../../../src/agents/tools/loadImageAsBase64";
-import { Base64ImageProcessor } from "../../../../src/processors/Base64ImageDetector";
-import { ToolsService } from "../../../../src/services/Tools";
-
-describe("loadImageAsBase64 tool", () => {
-  it("returns an image data URL with a MIME type detected from its bytes", async () => {
-    const directory = await fs.promises.mkdtemp(path.join(os.tmpdir(), "knowhow-image-"));
-    const filePath = path.join(directory, "incorrectly-named.jpg");
-
-    try {
-      await fs.promises.writeFile(filePath, Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]));
-      const result = JSON.parse(await loadImageAsBase64(filePath));
-
-      expect(result).toMatchObject({
-        type: "image_url",
-        image_url: { detail: "auto" },
-      });
-      expect(result.image_url.url).toMatch(/^data:image\/png;base64,/);
-    } finally {
-      await fs.promises.rm(directory, { recursive: true, force: true });
-    }
-  });
-
-  it("can also be registered by the image message processor without duplication", () => {
-    const toolsService = new ToolsService();
-    toolsService.defineTools(
-      [loadImageAsBase64Definition],
-      { loadImageAsBase64 }
-    );
-
-    new Base64ImageProcessor(toolsService);
-
-    expect(
-      toolsService.getToolNames().filter((name) => name === "loadImageAsBase64")
-    ).toHaveLength(1);
-    expect(typeof toolsService.getFunction("loadImageAsBase64")).toBe("function");
-  });
-});

package/tests/unit/auth/jwtStore.test.ts

@@ -1,55 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import {
-  getJwtFileName,
-  loadJwtFromDisk,
-  storeJwtForApi,
-} from "../../../src/auth/jwtStore";
-
-describe("environment-specific JWT storage", () => {
-  const originalCwd = process.cwd();
-  let workDir: string;
-
-  beforeEach(() => {
-    workDir = fs.mkdtempSync(path.join(os.tmpdir(), "knowhow-jwt-store-"));
-    process.chdir(workDir);
-  });
-
-  afterEach(() => {
-    process.chdir(originalCwd);
-    fs.rmSync(workDir, { recursive: true, force: true });
-  });
-
-  it("uses readable names for production, development, and local APIs", () => {
-    expect(getJwtFileName("https://api.knowhow.tyvm.ai")).toBe(".jwt");
-    expect(getJwtFileName("https://api.dev.knowhow.tyvm.ai")).toBe(".jwt.dev");
-    expect(getJwtFileName("http://localhost:4000")).toBe(".jwt.local");
-  });
-
-  it("keeps tokens for each API environment independent", () => {
-    storeJwtForApi("prod-token", "https://api.knowhow.tyvm.ai");
-    storeJwtForApi("dev-token", "https://api.dev.knowhow.tyvm.ai");
-    storeJwtForApi("local-token", "http://localhost:4000");
-
-    expect(loadJwtFromDisk("https://api.knowhow.tyvm.ai")).toBe("prod-token");
-    expect(loadJwtFromDisk("https://api.dev.knowhow.tyvm.ai")).toBe("dev-token");
-    expect(loadJwtFromDisk("http://localhost:4000")).toBe("local-token");
-    expect(fs.statSync(path.join(workDir, ".knowhow", ".jwt.dev")).mode & 0o777).toBe(0o600);
-  });
-
-  it("does not send the legacy production token to another environment", () => {
-    const configDir = path.join(workDir, ".knowhow");
-    fs.mkdirSync(configDir, { recursive: true });
-    fs.writeFileSync(path.join(configDir, ".jwt"), "production-token");
-
-    expect(loadJwtFromDisk("https://api.dev.knowhow.tyvm.ai")).toBe("");
-    expect(loadJwtFromDisk("https://api.knowhow.tyvm.ai")).toBe("production-token");
-  });
-
-  it("uses a host-specific file for additional Knowhow instances", () => {
-    expect(getJwtFileName("https://api.staging.example.com:8443")).toBe(
-      ".jwt.api.staging.example.com-8443"
-    );
-  });
-});

package/tests/unit/auth/keyAuth.test.ts

@@ -1,152 +0,0 @@
-const post = jest.fn();
-const publicKeyBase64 = Buffer.alloc(32, 7).toString("base64");
-const keyPairExists = jest.fn(() => true);
-const loadKeyPair = jest.fn(() => ({ publicKeyBase64 }));
-const signMessage = jest.fn(() => "server-message-signature");
-
-jest.mock("../../../src/utils/http", () => ({
-  __esModule: true,
-  default: {
-    post,
-    isHttpError: (error: unknown) =>
-      typeof error === "object" && error !== null && "status" in error,
-  },
-}));
-
-jest.mock("../../../src/auth/keyManager", () => ({
-  getDefaultPrivateKeyPath: () => "/keys/default",
-  keyPairExists,
-  loadKeyPair,
-  signMessage,
-}));
-
-jest.mock("../../../src/auth/browserLogin", () => ({
-  getCliUserAgent: () => "test-agent",
-}));
-
-import fs from "fs";
-import os from "os";
-import path from "path";
-import {
-  authenticateWithKey,
-  exchangeAvailablePublicKeyJwt,
-  exchangePublicKeyJwt,
-  hasKeyPair,
-  registerPublicKey,
-  storeJwt,
-} from "../../../src/auth/keyAuth";
-
-describe("keyAuth", () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    keyPairExists.mockReturnValue(true);
-  });
-
-  it("signs the exact server challenge for the selected key, org, and environment", async () => {
-    post
-      .mockResolvedValueOnce({
-        data: {
-          challengeId: "challenge_1",
-          message: "exact message from server",
-          expiresAt: "2099-01-01T00:00:00.000Z",
-        },
-        status: 201,
-      })
-      .mockResolvedValueOnce({ data: { jwt: "renewed-jwt" }, status: 200 });
-
-    expect(hasKeyPair("/keys/work")).toBe(true);
-    await expect(
-      exchangePublicKeyJwt("org-1", "https://work.example", "/keys/work")
-    ).resolves.toBe("renewed-jwt");
-
-    expect(loadKeyPair).toHaveBeenCalledWith("/keys/work");
-    expect(signMessage).toHaveBeenCalledWith("exact message from server", "/keys/work");
-    expect(post.mock.calls).toEqual([
-      [
-        "https://work.example/api/public-keys/challenge",
-        { publicKey: publicKeyBase64, orgId: "org-1" },
-        { headers: { "User-Agent": "test-agent" } },
-      ],
-      [
-        "https://work.example/api/public-keys/authenticate",
-        { challengeId: "challenge_1", signature: "server-message-signature" },
-        { headers: { "User-Agent": "test-agent" } },
-      ],
-    ]);
-  });
-
-  it("uses the registered default identity when a configured identity is rejected", async () => {
-    post
-      .mockRejectedValueOnce({ status: 401 })
-      .mockResolvedValueOnce({
-        data: {
-          challengeId: "challenge_2",
-          message: "default key challenge",
-          expiresAt: "2099-01-01T00:00:00.000Z",
-        },
-        status: 201,
-      })
-      .mockResolvedValueOnce({ data: { jwt: "default-key-jwt" }, status: 200 });
-
-    await expect(
-      exchangeAvailablePublicKeyJwt("org-1", "https://work.example", "/keys/stale")
-    ).resolves.toBe("default-key-jwt");
-
-    expect(loadKeyPair.mock.calls).toEqual([
-      ["/keys/stale"],
-      ["/keys/default"],
-    ]);
-    expect(signMessage).toHaveBeenCalledWith(
-      "default key challenge",
-      "/keys/default"
-    );
-  });
-
-  it("falls back when the key is unavailable without signing a challenge", async () => {
-    post.mockRejectedValue({ status: 401 });
-
-    await expect(
-      authenticateWithKey("org-1", "https://work.example", "/keys/work")
-    ).resolves.toBe(false);
-
-    expect(post).toHaveBeenCalledTimes(2);
-    expect(signMessage).not.toHaveBeenCalled();
-  });
-
-  it("stores a refreshed JWT in the active isolated project", () => {
-    const originalCwd = process.cwd();
-    const temporaryProject = fs.mkdtempSync(path.join(os.tmpdir(), "knowhow-key-auth-"));
-    try {
-      process.chdir(temporaryProject);
-
-      storeJwt("fresh-project-jwt");
-
-      const jwtPath = path.join(temporaryProject, ".knowhow", ".jwt");
-      expect(fs.readFileSync(jwtPath, "utf8")).toBe("fresh-project-jwt");
-      expect(fs.statSync(jwtPath).mode & 0o777).toBe(0o600);
-    } finally {
-      process.chdir(originalCwd);
-      fs.rmSync(temporaryProject, { recursive: true, force: true });
-    }
-  });
-
-  it("registers only server-owned Ed25519 key fields in the selected environment", async () => {
-    post.mockResolvedValueOnce({ data: {}, status: 201 });
-
-    await registerPublicKey("browser-jwt", publicKeyBase64, "https://dev.example");
-
-    expect(post).toHaveBeenCalledWith(
-      "https://dev.example/api/public-keys/register",
-      {
-        publicKey: publicKeyBase64,
-        label: expect.any(String),
-      },
-      {
-        headers: {
-          Authorization: "Bearer browser-jwt",
-          "User-Agent": "test-agent",
-        },
-      }
-    );
-  });
-});

package/tests/unit/auth/keyManager.test.ts

@@ -1,130 +0,0 @@
-import crypto from "crypto";
-import fs from "fs";
-import os from "os";
-import path from "path";
-import {
-  ensureIdentityKeyPair,
-  generateKeyPair,
-  loadKeyPair,
-  signMessage,
-} from "../../../src/auth/keyManager";
-
-const OPENSSH_ED25519_PRIVATE_KEY = `-----BEGIN OPENSSH PRIVATE KEY-----
-b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW
-QyNTUxOQAAACD/E7YSDZcV7usL3Ej3SSvGNVuNMu1hYFOpHjQaCodvIgAAAIgKqccyCqnH
-MgAAAAtzc2gtZWQyNTUxOQAAACD/E7YSDZcV7usL3Ej3SSvGNVuNMu1hYFOpHjQaCodvIg
-AAAECC40JKj3sb9Q3KsA9wAKeLbUwazUi7cuBiDfuJHDybtf8TthINlxXu6wvcSPdJK8Y1
-W40y7WFgU6keNBoKh28iAAAABHRlc3QB
------END OPENSSH PRIVATE KEY-----
-`;
-
-const OPENSSH_ED25519_PUBLIC_KEY =
-  "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIP8TthINlxXu6wvcSPdJK8Y1W40y7WFgU6keNBoKh28i test\n";
-
-const OPENSSH_ENCRYPTED_ED25519_PRIVATE_KEY = `-----BEGIN OPENSSH PRIVATE KEY-----
-b3BlbnNzaC1rZXktdjEAAAAACmFlczI1Ni1jdHIAAAAGYmNyeXB0AAAAGAAAABAiFkZE2t
-9UBWLQLB8sAuG7AAAAGAAAAAEAAAAzAAAAC3NzaC1lZDI1NTE5AAAAID2OnkCi/hq0EH9E
-yBf1n4FXRDw16RYyDAL0pbbRWh1JAAAAkHNPoqbcZcef7FZY+dFTRTODyAMPL4gyzOxGLE
-JffXux9KUTPBrCy+xfScoAHq9JFKrspli5h5Z6PyJ7Dp2NNJPOzEaF92fv6989AETm3X3X
-2pOUvtPMJz29C1MO7hXHlReIWqF6nkaDGGcNEZMZ3xHI4ypB/lfceH6A1IjxZEa2BXJfJe
-y6h8co4T89tJdubQ==
------END OPENSSH PRIVATE KEY-----
-`;
-
-describe("keyManager", () => {
-  let directory: string;
-  let identity: string;
-
-  beforeEach(() => {
-    directory = fs.mkdtempSync(path.join(os.tmpdir(), "knowhow-key-manager-"));
-    identity = path.join(directory, "identity");
-  });
-
-  afterEach(() => {
-    fs.rmSync(directory, { recursive: true, force: true });
-  });
-
-  it("creates an Ed25519 identity with an OpenSSH-compatible public key", () => {
-    const generated = generateKeyPair(identity);
-    const publicKeyLine = fs.readFileSync(`${identity}.pub`, "utf8").trim();
-
-    expect(publicKeyLine).toMatch(/^ssh-ed25519 [A-Za-z0-9+/]+=* knowhow-cli$/);
-    expect(fs.statSync(identity).mode % 0o1000).toBe(0o600);
-    expect(loadKeyPair(identity)).toEqual(generated);
-
-    const challengeMessage = "exact server-provided challenge";
-    const signature = signMessage(challengeMessage, identity);
-    const publicKey = crypto.createPublicKey(fs.readFileSync(identity));
-    expect(
-      crypto.verify(
-        null,
-        Buffer.from(challengeMessage),
-        publicKey,
-        Buffer.from(signature, "base64")
-      )
-    ).toBe(true);
-  });
-
-  it("accepts default unencrypted OpenSSH Ed25519 private keys", () => {
-    fs.writeFileSync(identity, OPENSSH_ED25519_PRIVATE_KEY);
-    fs.writeFileSync(`${identity}.pub`, OPENSSH_ED25519_PUBLIC_KEY);
-
-    const loaded = loadKeyPair(identity);
-    expect(loaded.publicKeyBase64).toBe("/xO2Eg2XFe7rC9xI90krxjVbjTLtYWB TqR40GgqHbyI=".replace(/\s+/g, ""));
-
-    const signature = signMessage("challenge", identity);
-    const spkiPrefix = Buffer.from("302a300506032b6570032100", "hex");
-    const publicKeyDer = Buffer.concat([spkiPrefix, Buffer.from(loaded.publicKeyBase64, "base64")]);
-    const publicKey = crypto.createPublicKey({ key: publicKeyDer, format: "der", type: "spki" });
-    expect(
-      crypto.verify(
-        null,
-        Buffer.from("challenge"),
-        publicKey,
-        Buffer.from(signature, "base64")
-      )
-    ).toBe(true);
-  });
-
-  it("loads legacy raw-base64 public keys but rejects non-Ed25519 identities", () => {
-    const generated = generateKeyPair(identity);
-    fs.writeFileSync(`${identity}.pub`, generated.publicKeyBase64);
-    expect(loadKeyPair(identity).publicKeyBase64).toBe(generated.publicKeyBase64);
-
-    const rsaIdentity = path.join(directory, "rsa");
-    const rsa = crypto.generateKeyPairSync("rsa", {
-      modulusLength: 2048,
-      privateKeyEncoding: { type: "pkcs8", format: "pem" },
-      publicKeyEncoding: { type: "spki", format: "pem" },
-    });
-    fs.writeFileSync(rsaIdentity, rsa.privateKey);
-    fs.writeFileSync(`${rsaIdentity}.pub`, generated.publicKeyBase64);
-
-    expect(() => loadKeyPair(rsaIdentity)).toThrow("must be an Ed25519 private key");
-  });
-
-  it("rejects encrypted OpenSSH keys with a clear error", () => {
-    fs.writeFileSync(identity, OPENSSH_ENCRYPTED_ED25519_PRIVATE_KEY);
-    fs.writeFileSync(`${identity}.pub`, OPENSSH_ED25519_PUBLIC_KEY);
-
-    expect(() => loadKeyPair(identity)).toThrow("encrypted OpenSSH key");
-  });
-
-  it("does not overwrite a partial identity", () => {
-    fs.writeFileSync(identity, "existing key");
-    expect(() => generateKeyPair(identity)).toThrow("a key file already exists");
-    expect(fs.readFileSync(identity, "utf8")).toBe("existing key");
-  });
-
-  it("ensureIdentityKeyPair is safe for existing keys (no overwrite)", () => {
-    const generated = generateKeyPair(identity);
-    const beforePrivate = fs.readFileSync(identity, "utf8");
-    const beforePublic = fs.readFileSync(`${identity}.pub`, "utf8");
-
-    const result = ensureIdentityKeyPair(identity);
-    expect(result.created).toBe(false);
-    expect(result.keyPair).toEqual(generated);
-    expect(fs.readFileSync(identity, "utf8")).toBe(beforePrivate);
-    expect(fs.readFileSync(`${identity}.pub`, "utf8")).toBe(beforePublic);
-  });
-});

package/tests/unit/auth/registerIdentity.test.ts

@@ -1,99 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-
-const registerPublicKey = jest.fn();
-const exchangePublicKeyJwt = jest.fn();
-const storeJwt = jest.fn();
-const getOrCreatePublicKey = jest.fn();
-const getConfig = jest.fn();
-const updateConfig = jest.fn();
-
-jest.mock("../../../src/auth/keyAuth", () => ({ registerPublicKey, exchangePublicKeyJwt, storeJwt }));
-jest.mock("../../../src/auth/keyManager", () => ({ getOrCreatePublicKey }));
-jest.mock("../../../src/config", () => ({ getConfig, updateConfig }));
-
-import { decodeJwtPayload, extractOrgIdFromJwt, registerIdentity } from "../../../src/auth/registerIdentity";
-
-function makeJwt(payload: Record<string, unknown>): string {
-  return `${Buffer.from("{}").toString("base64url")}.${Buffer.from(JSON.stringify(payload)).toString("base64url")}.sig`;
-}
-
-describe("registerIdentity", () => {
-  const originalCwd = process.cwd();
-  let workDir: string;
-  const sourceJwt = makeJwt({ org: "org-test" });
-  const publicKeyBase64 = Buffer.alloc(32, 5).toString("base64");
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    jest.spyOn(console, "log").mockImplementation(() => undefined);
-    workDir = fs.mkdtempSync(path.join(os.tmpdir(), "knowhow-register-identity-"));
-    fs.mkdirSync(path.join(workDir, ".knowhow"), { recursive: true });
-    fs.writeFileSync(path.join(workDir, ".knowhow", ".jwt"), sourceJwt);
-    fs.writeFileSync(path.join(workDir, ".knowhow", ".jwt.api.example"), sourceJwt);
-    process.chdir(workDir);
-    getOrCreatePublicKey.mockReturnValue({
-      publicKeyBase64,
-      fingerprint: "SHA256:test",
-      privateKeyPath: path.join(workDir, ".knowhow", "keys", "id_ed25519"),
-    });
-    registerPublicKey.mockResolvedValue(undefined);
-    exchangePublicKeyJwt.mockResolvedValue("identity.jwt.token");
-    getConfig.mockResolvedValue({ modelProviders: [] });
-    updateConfig.mockResolvedValue(undefined);
-  });
-
-  afterEach(() => {
-    process.chdir(originalCwd);
-    fs.rmSync(workDir, { recursive: true, force: true });
-    jest.restoreAllMocks();
-  });
-
-  it("registers from the project JWT and stores the exchanged JWT", async () => {
-    await registerIdentity({ apiUrl: "https://api.example" });
-    expect(registerPublicKey).toHaveBeenCalledWith(sourceJwt, publicKeyBase64, "https://api.example");
-    expect(exchangePublicKeyJwt).toHaveBeenCalledWith("org-test", "https://api.example", undefined);
-    expect(storeJwt).toHaveBeenCalledWith("identity.jwt.token", "https://api.example");
-    expect(updateConfig).toHaveBeenCalledWith(expect.objectContaining({
-      modelProviders: [{ provider: "knowhow" }],
-      cliIdentityPath: expect.stringContaining("id_ed25519"),
-      remotes: {
-        origin: expect.objectContaining({
-          apiUrl: "https://api.example",
-          orgId: "org-test",
-        }),
-      },
-    }));
-  });
-
-  it("uses an explicitly selected identity", async () => {
-    await registerIdentity({ identityPath: "/keys/id", apiUrl: "https://api.example" });
-    expect(getOrCreatePublicKey).toHaveBeenCalledWith("/keys/id");
-    expect(exchangePublicKeyJwt).toHaveBeenCalledWith("org-test", "https://api.example", "/keys/id");
-  });
-
-  it("requires a nonempty project JWT", async () => {
-    fs.writeFileSync(path.join(workDir, ".knowhow", ".jwt"), " ");
-    await expect(registerIdentity()).rejects.toThrow("JWT file is empty");
-    expect(registerPublicKey).not.toHaveBeenCalled();
-  });
-
-  it("does not replace the JWT when registration fails", async () => {
-    registerPublicKey.mockRejectedValue(new Error("registration failed"));
-    await expect(registerIdentity()).rejects.toThrow("registration failed");
-    expect(storeJwt).not.toHaveBeenCalled();
-  });
-});
-
-describe("JWT organization extraction", () => {
-  it("decodes payload and accepts canonical org", () => {
-    expect(decodeJwtPayload(makeJwt({ org: "one" }))).toMatchObject({ org: "one" });
-    expect(extractOrgIdFromJwt(makeJwt({ org: "one" }))).toBe("one");
-  });
-
-  it("rejects malformed and organization-less JWTs", () => {
-    expect(() => decodeJwtPayload("invalid")).toThrow("Invalid JWT format");
-    expect(() => extractOrgIdFromJwt(makeJwt({ sub: "user" }))).toThrow("organization claim");
-  });
-});

package/tests/unit/chat/ToolCommandModule.test.ts

@@ -1,71 +0,0 @@
-import { ToolCommandModule } from "../../../src/chat/modules/ToolCommandModule";
-import { LazyToolsService } from "../../../src/services/LazyToolsService";
-import { ChatService } from "../../../src/chat/types";
-
-function makeHarness() {
-  const tools = new LazyToolsService();
-  tools.addTools([{
-    type: "function",
-    function: {
-      name: "hiddenEcho",
-      description: "echo",
-      parameters: { type: "object", properties: { value: { type: "string" } } },
-    },
-  }]);
-  tools.setFunction("hiddenEcho", ({ value }: { value: string }) => ({ value }));
-
-  const context: any = { plugins: [], chatHistory: [], activeAgentTaskId: "task-1" };
-  const service = {
-    getTools: () => tools,
-    getContext: () => context,
-    registerCommand: jest.fn(),
-    registerMode: jest.fn(),
-  } as unknown as ChatService;
-  const module = new ToolCommandModule();
-  return module.initialize(service).then(() => ({
-    command: module.getCommands()[0],
-    tools,
-  }));
-}
-
-describe("ToolCommandModule", () => {
-  let log: jest.SpyInstance;
-  let error: jest.SpyInstance;
-
-  beforeEach(() => {
-    log = jest.spyOn(console, "log").mockImplementation();
-    error = jest.spyOn(console, "error").mockImplementation();
-  });
-
-  afterEach(() => jest.restoreAllMocks());
-
-  test("executes compact JSON against a hidden lazy tool", async () => {
-    const { command, tools } = await makeHarness();
-    expect(tools.getToolNames()).not.toContain("hiddenEcho");
-
-    await command.handler(['{"name":"hiddenEcho","arguments":{"value":"hello world"}}']);
-
-    expect(log).toHaveBeenCalledWith('{\n  "value": "hello world"\n}');
-    expect(error).not.toHaveBeenCalled();
-  });
-
-  test("accepts an OpenAI-style tool call", async () => {
-    const { command } = await makeHarness();
-    await command.handler([
-      '{"id":"call-1","function":{"name":"hiddenEcho","arguments":{"value":"ok"}}}',
-    ]);
-    expect(log).toHaveBeenCalledWith('{\n  "value": "ok"\n}');
-  });
-
-  test("prints usage and actionable errors", async () => {
-    const { command } = await makeHarness();
-    await command.handler([]);
-    expect(log).toHaveBeenCalledWith(expect.stringContaining("Usage: /tool"));
-
-    await command.handler(["not-json"]);
-    expect(error).toHaveBeenCalledWith(expect.stringContaining("Invalid tool call JSON"));
-
-    await command.handler(['{"name":"missing","arguments":{}}']);
-    expect(error).toHaveBeenCalledWith(expect.stringContaining("Tool execution failed"));
-  });
-});

package/tests/unit/chat/historyCommandArgs.test.ts

@@ -1,37 +0,0 @@
-import { parseHistoryCommandArgs } from "../../../src/chat/modules/SessionsModule";
-
-describe("parseHistoryCommandArgs", () => {
-  it("parses an id and rollback in either order", () => {
-    expect(parseHistoryCommandArgs(["task-1", "--rollback", "2"])).toEqual({
-      id: "task-1", rollback: 2, showAll: false,
-    });
-    expect(parseHistoryCommandArgs(["--rollback", "1", "task-1"])).toEqual({
-      id: "task-1", rollback: 1, showAll: false,
-    });
-  });
-
-  it("supports interactive --all", () => {
-    expect(parseHistoryCommandArgs(["--all"])).toEqual({
-      id: undefined, rollback: 0, showAll: true,
-    });
-  });
-
-  it.each([
-    [["--rollback"]],
-    [["--rollback", "-1"]],
-    [["--rollback", "1.5"]],
-  ])(
-    "rejects invalid rollback arguments: %p",
-    (args) => {
-      expect(() => parseHistoryCommandArgs(args)).toThrow(
-        "--rollback must be a non-negative integer"
-      );
-    }
-  );
-
-  it("rejects unexpected arguments", () => {
-    expect(() => parseHistoryCommandArgs(["one", "two"])).toThrow(
-      "Unexpected argument: two"
-    );
-  });
-});