@indigoai-us/hq-cli 5.77.13 → 5.78.0

package/src/commands/files-delete.test.ts

@@ -1,484 +0,0 @@
-/**
- * Unit tests for `hq files delete <prefix>` (files.ts).
- *
- * Coverage (mirrors the server-side regression list from the caller's side):
- *   - --dry-run previews the key set and deletes nothing;
- *   - a real delete previews the EXACT count, then deletes only after confirm;
- *   - --yes bypasses the confirmation prompt;
- *   - a declined confirmation deletes nothing;
- *   - the root/empty prefix is rejected CLIENT-side before any network call;
- *   - a 403 from the server is surfaced as a clear "not authorized" message;
- *   - the request body shape is exactly { company, prefix, dryRun }.
- *
- * Mirrors files.test.ts: globalThis.fetch + process.exit are spied; the
- * `__EXIT__:<code>` throw mimics how Commander aborts on a failure path.
- */
-
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  it,
-  vi,
-  type MockInstance,
-} from "vitest";
-
-vi.mock("open", () => ({ default: vi.fn(() => Promise.resolve({ pid: 0 })) }));
-
-vi.mock("../utils/cognito-session.js", async (importOriginal) => {
-  const original = (await importOriginal()) as Record<string, unknown>;
-  return {
-    ...original,
-    ensureCognitoToken: vi.fn(async () => "test-token"),
-  };
-});
-
-import { Command } from "commander";
-import {
-  registerFilesCommand,
-  runFilesDelete,
-  stripRedundantCompanyScope,
-  FilesDeleteHttpError,
-  formatFilesDeleteError,
-  type FilesDeleteResponse,
-} from "./files.js";
-
-function jsonResponse(status: number, body: unknown): Response {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: { "Content-Type": "application/json" },
-  });
-}
-
-/** A membership response so getCompanyUid resolves a single active company. */
-function membershipResponse(): Response {
-  return jsonResponse(200, {
-    memberships: [
-      { membershipKey: "k1", companyUid: "cmp_acme", role: "member", status: "active" },
-    ],
-  });
-}
-
-function deleteResponse(overrides: Partial<FilesDeleteResponse>): Response {
-  return jsonResponse(200, {
-    prefix: "reports/*",
-    mode: "prefix",
-    dryRun: false,
-    matched: 0,
-    deleted: 0,
-    skipped: 0,
-    tombstoned: 0,
-    keys: [],
-    keysTruncated: false,
-    ...overrides,
-  });
-}
-
-let fetchSpy: MockInstance<typeof fetch>;
-let exitSpy: MockInstance<typeof process.exit>;
-let logSpy: MockInstance<typeof console.log>;
-let errSpy: MockInstance<typeof console.error>;
-
-beforeEach(() => {
-  fetchSpy = vi.spyOn(globalThis, "fetch");
-  exitSpy = vi.spyOn(process, "exit").mockImplementation(((code?: number) => {
-    throw new Error(`__EXIT__:${code ?? 0}`);
-  }) as never);
-  logSpy = vi.spyOn(console, "log").mockImplementation(() => undefined);
-  errSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-function buildProgram(): Command {
-  const program = new Command();
-  program.exitOverride();
-  registerFilesCommand(program);
-  return program;
-}
-
-function deleteCalls() {
-  return fetchSpy.mock.calls.filter((c) => String(c[0]).includes("/v1/files/delete"));
-}
-
-function deleteCallBodies(): Array<{ company: string; prefix: string; dryRun: boolean }> {
-  return deleteCalls().map((c) => JSON.parse((c[1]?.body as string) ?? "{}"));
-}
-
-function printed(): string {
-  return logSpy.mock.calls.map((c) => String(c[0])).join("\n");
-}
-function printedErr(): string {
-  return errSpy.mock.calls.map((c) => String(c[0])).join("\n");
-}
-
-describe("hq files delete — --dry-run", () => {
-  it("previews the key set, sends only a dryRun:true request, deletes nothing", async () => {
-    fetchSpy.mockResolvedValueOnce(membershipResponse());
-    fetchSpy.mockResolvedValueOnce(
-      deleteResponse({
-        dryRun: true,
-        matched: 2,
-        keys: ["reports/a.md", "reports/b.md"],
-      }),
-    );
-
-    const program = buildProgram();
-    await program.parseAsync(["files", "delete", "reports/", "--dry-run"], { from: "user" });
-
-    const bodies = deleteCallBodies();
-    expect(bodies).toHaveLength(1);
-    expect(bodies[0]).toEqual({ company: "cmp_acme", prefix: "reports/*", dryRun: true });
-    expect(printed()).toContain("[dry-run]");
-    expect(printed()).toContain("reports/a.md");
-    expect(exitSpy).not.toHaveBeenCalled();
-  });
-});
-
-describe("hq files delete — real delete with --yes", () => {
-  it("previews then deletes (dryRun:true then dryRun:false), no confirm needed", async () => {
-    fetchSpy.mockResolvedValueOnce(membershipResponse());
-    fetchSpy.mockResolvedValueOnce(
-      deleteResponse({ dryRun: true, matched: 2, keys: ["reports/a.md", "reports/b.md"] }),
-    );
-    fetchSpy.mockResolvedValueOnce(
-      deleteResponse({ matched: 2, deleted: 2, tombstoned: 2, keys: ["reports/a.md", "reports/b.md"] }),
-    );
-
-    const program = buildProgram();
-    await program.parseAsync(["files", "delete", "reports/*", "--yes"], { from: "user" });
-
-    const bodies = deleteCallBodies();
-    expect(bodies).toHaveLength(2);
-    expect(bodies[0].dryRun).toBe(true); // preview first
-    expect(bodies[1].dryRun).toBe(false); // then the real delete
-    expect(printed()).toContain("Deleted 2");
-    expect(exitSpy).not.toHaveBeenCalled();
-  });
-});
-
-describe("hq files delete — confirmation gating", () => {
-  it("a declined confirmation deletes nothing (no dryRun:false request)", async () => {
-    fetchSpy.mockResolvedValueOnce(membershipResponse());
-    fetchSpy.mockResolvedValueOnce(
-      deleteResponse({ dryRun: true, matched: 3, keys: ["x/a", "x/b", "x/c"] }),
-    );
-
-    await runFilesDelete(
-      { prefix: "x/*", dryRun: false, yes: false, companySlug: undefined },
-      { confirm: async () => false },
-    );
-
-    const bodies = deleteCallBodies();
-    expect(bodies).toHaveLength(1); // only the preview
-    expect(bodies[0].dryRun).toBe(true);
-    expect(printed()).toContain("Aborted");
-  });
-
-  it("an accepted confirmation proceeds with the delete", async () => {
-    fetchSpy.mockResolvedValueOnce(membershipResponse());
-    fetchSpy.mockResolvedValueOnce(
-      deleteResponse({ dryRun: true, matched: 1, keys: ["x/a"] }),
-    );
-    fetchSpy.mockResolvedValueOnce(
-      deleteResponse({ matched: 1, deleted: 1, tombstoned: 1, keys: ["x/a"] }),
-    );
-
-    await runFilesDelete(
-      { prefix: "x/*", dryRun: false, yes: false, companySlug: undefined },
-      { confirm: async () => true },
-    );
-
-    const bodies = deleteCallBodies();
-    expect(bodies).toHaveLength(2);
-    expect(bodies[1].dryRun).toBe(false);
-    expect(printed()).toContain("Deleted 1");
-  });
-
-  it("reports skipped keys (peer files the caller can't delete) in the preview", async () => {
-    fetchSpy.mockResolvedValueOnce(membershipResponse());
-    fetchSpy.mockResolvedValueOnce(
-      deleteResponse({ dryRun: true, matched: 1, skipped: 2, keys: ["x/mine.md"] }),
-    );
-
-    await runFilesDelete(
-      { prefix: "x/*", dryRun: false, yes: false, companySlug: undefined },
-      { confirm: async () => false },
-    );
-
-    expect(printed()).toContain("2 more under this prefix you can't delete");
-  });
-});
-
-describe("hq files delete — nothing to delete", () => {
-  it("prints a no-op message and makes no second request", async () => {
-    fetchSpy.mockResolvedValueOnce(membershipResponse());
-    fetchSpy.mockResolvedValueOnce(deleteResponse({ dryRun: true, matched: 0, keys: [] }));
-
-    let confirmCalled = false;
-    await runFilesDelete(
-      { prefix: "empty/*", dryRun: false, yes: false, companySlug: undefined },
-      { confirm: async () => { confirmCalled = true; return true; } },
-    );
-
-    expect(deleteCallBodies()).toHaveLength(1);
-    expect(confirmCalled).toBe(false);
-    expect(printed()).toContain("Nothing to delete");
-  });
-});
-
-describe("hq files delete — root/empty prefix rejected client-side", () => {
-  for (const prefix of ["", "*", "/", "/*"]) {
-    it(`rejects ${JSON.stringify(prefix)} before any network call`, async () => {
-      const program = buildProgram();
-      await expect(
-        program.parseAsync(["files", "delete", prefix], { from: "user" }),
-      ).rejects.toThrow(/__EXIT__:1/);
-      expect(fetchSpy).not.toHaveBeenCalled();
-      expect(printedErr()).toContain("Refusing to delete the vault root");
-    });
-  }
-});
-
-// HQ-8F: a caller who pastes an HQ *local* tree path (`companies/<slug>/…`)
-// over-prefixes the bucket-relative vault key; the server rejects it with a 400
-// (INVALID_PREFIX_COMPANIES_SCOPED), the source of the recurring warning. The
-// CLI now strips the redundant scope BEFORE sending, so the local-looking path
-// is gracefully normalized to bucket-relative.
-describe("stripRedundantCompanyScope (HQ-8F, pure)", () => {
-  it("strips a leading companies/<slug>/ to the bucket-relative remainder", () => {
-    expect(stripRedundantCompanyScope("companies/acme/projects/foo")).toEqual({
-      prefix: "projects/foo",
-      strippedSlug: "acme",
-    });
-    expect(stripRedundantCompanyScope("companies/acme/projects/foo/*")).toEqual({
-      prefix: "projects/foo/*",
-      strippedSlug: "acme",
-    });
-  });
-
-  it("returns an EMPTY remainder for the company-root spellings (→ root-reject)", () => {
-    expect(stripRedundantCompanyScope("companies/acme")).toEqual({
-      prefix: "",
-      strippedSlug: "acme",
-    });
-    expect(stripRedundantCompanyScope("companies/acme/")).toEqual({
-      prefix: "",
-      strippedSlug: "acme",
-    });
-  });
-
-  it("leaves an already bucket-relative prefix untouched (null)", () => {
-    expect(stripRedundantCompanyScope("projects/foo/*")).toBeNull();
-    expect(stripRedundantCompanyScope("reports/q3/")).toBeNull();
-    // A non-scope path that merely starts with the word "companies" is NOT a
-    // scope prefix and must be left alone.
-    expect(stripRedundantCompanyScope("companiesreport/x")).toBeNull();
-  });
-});
-
-describe("hq files delete — HQ-8F company-scope normalization", () => {
-  it("strips companies/<slug>/ and sends the BUCKET-RELATIVE prefix (no 400)", async () => {
-    fetchSpy.mockResolvedValueOnce(membershipResponse());
-    fetchSpy.mockResolvedValueOnce(
-      deleteResponse({ dryRun: true, matched: 1, keys: ["projects/foo/a.md"] }),
-    );
-    fetchSpy.mockResolvedValueOnce(
-      deleteResponse({ matched: 1, deleted: 1, tombstoned: 1, keys: ["projects/foo/a.md"] }),
-    );
-
-    await runFilesDelete(
-      {
-        // Trailing slash → also exercises the `/` → `/*` glob normalization.
-        prefix: "companies/acme/projects/foo/",
-        dryRun: false,
-        yes: true,
-        companySlug: undefined,
-      },
-      { confirm: async () => true },
-    );
-
-    const bodies = deleteCallBodies();
-    // Both the preview and the delete carry the stripped, bucket-relative prefix.
-    expect(bodies.map((b) => b.prefix)).toEqual(["projects/foo/*", "projects/foo/*"]);
-    expect(printedErr()).toContain("stripped redundant 'companies/acme/'");
-  });
-
-  it("a bare companies/<slug> strips to empty → root-reject, no network call", async () => {
-    const program = buildProgram();
-    await expect(
-      program.parseAsync(["files", "delete", "companies/acme", "--yes"], {
-        from: "user",
-      }),
-    ).rejects.toThrow(/__EXIT__:1/);
-    expect(fetchSpy).not.toHaveBeenCalled();
-    expect(printedErr()).toContain("Refusing to delete the vault root");
-  });
-});
-
-// HQ-CA: the EXACT-KEY sibling of HQ-8F. When the over-prefixed path has no
-// trailing slash and no wildcard (a literal key like
-// `companies/<slug>/notes/foo.md`), the server takes the exact-key branch where
-// `validateObjectKey` — not `validatePrefix` — rejects it with a 400 ("Invalid
-// key: … do not prefix with 'companies/<slug>/'."). The same client-side strip
-// runs UPSTREAM of the server's exact-vs-glob split, so it normalizes the exact
-// key to bucket-relative and the 400 is never emitted. This locks that path,
-// which #117 only exercised via the trailing-slash (glob) spelling.
-describe("hq files delete — HQ-CA exact-key company-scope normalization", () => {
-  it("strips companies/<slug>/ from an EXACT key and sends the bucket-relative key (no glob, no 400)", async () => {
-    fetchSpy.mockResolvedValueOnce(membershipResponse());
-    fetchSpy.mockResolvedValueOnce(
-      deleteResponse({
-        dryRun: true,
-        mode: "exact",
-        prefix: "notes/foo.md",
-        matched: 1,
-        keys: ["notes/foo.md"],
-      }),
-    );
-    fetchSpy.mockResolvedValueOnce(
-      deleteResponse({
-        mode: "exact",
-        prefix: "notes/foo.md",
-        matched: 1,
-        deleted: 1,
-        tombstoned: 1,
-        keys: ["notes/foo.md"],
-      }),
-    );
-
-    await runFilesDelete(
-      {
-        // No trailing slash, no wildcard → server takes the EXACT-key branch.
-        prefix: "companies/acme/notes/foo.md",
-        dryRun: false,
-        yes: true,
-        companySlug: undefined,
-      },
-      { confirm: async () => true },
-    );
-
-    const bodies = deleteCallBodies();
-    // Preview + delete both carry the stripped, bucket-relative EXACT key —
-    // never the `companies/acme/...` over-prefix that 400s, and never glob-ified
-    // into a prefix delete.
-    expect(bodies.map((b) => b.prefix)).toEqual(["notes/foo.md", "notes/foo.md"]);
-    for (const b of bodies) {
-      expect(b.prefix.startsWith("companies/")).toBe(false);
-      expect(b.prefix).not.toContain("*");
-    }
-    expect(printedErr()).toContain("stripped redundant 'companies/acme/'");
-  });
-});
-
-describe("hq files delete — server error mapping", () => {
-  it("403 surfaces a clear not-authorized message and exits 1", async () => {
-    fetchSpy.mockResolvedValueOnce(membershipResponse());
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse(403, { error: "forbidden", code: "FILES_DELETE_FORBIDDEN" }),
-    );
-
-    const program = buildProgram();
-    await expect(
-      program.parseAsync(["files", "delete", "reports/*"], { from: "user" }),
-    ).rejects.toThrow(/__EXIT__:1/);
-
-    expect(printedErr()).toContain("Not authorized to delete 'reports/*'");
-    // Only the preview call happened; no delete was issued.
-    expect(deleteCallBodies()).toHaveLength(1);
-  });
-
-  it("formatFilesDeleteError maps statuses to copy", () => {
-    expect(formatFilesDeleteError(new FilesDeleteHttpError(401, "x"), "p")).toMatch(/hq login/);
-    expect(formatFilesDeleteError(new FilesDeleteHttpError(403, "x"), "p/*")).toMatch(/Not authorized to delete 'p\/\*'/);
-    expect(formatFilesDeleteError(new FilesDeleteHttpError(400, "bad"), "p")).toMatch(/Invalid request: bad/);
-    expect(formatFilesDeleteError(new FilesDeleteHttpError(500, "boom"), "p")).toMatch(/Server error: boom/);
-  });
-});
-
-describe("hq files delete — --personal (personal vault scope)", () => {
-  // Body parser tolerant of both scope shapes (company vs personal).
-  function bodies(): Array<Record<string, unknown>> {
-    return deleteCalls().map((c) => JSON.parse((c[1]?.body as string) ?? "{}"));
-  }
-
-  it("--dry-run sends { personal: true } with NO company membership lookup", async () => {
-    // First (and only) fetch is the delete preview — getCompanyUid is skipped.
-    fetchSpy.mockResolvedValueOnce(
-      deleteResponse({
-        dryRun: true,
-        matched: 2,
-        keys: ["installer/a.txt", "installer/b.txt"],
-      }),
-    );
-
-    const program = buildProgram();
-    await program.parseAsync(
-      ["files", "delete", "installer/", "--personal", "--dry-run"],
-      { from: "user" },
-    );
-
-    const b = bodies();
-    expect(b).toHaveLength(1);
-    expect(b[0]).toEqual({ personal: true, prefix: "installer/*", dryRun: true });
-    expect(b[0]).not.toHaveProperty("company");
-    expect(printed()).toContain("[dry-run]");
-    expect(exitSpy).not.toHaveBeenCalled();
-  });
-
-  it("real delete with --yes previews then deletes, both bodies personal-scoped", async () => {
-    fetchSpy.mockResolvedValueOnce(
-      deleteResponse({ dryRun: true, matched: 2, keys: ["installer/a.txt", "installer/b.txt"] }),
-    );
-    fetchSpy.mockResolvedValueOnce(
-      deleteResponse({ dryRun: false, matched: 2, deleted: 2, tombstoned: 2 }),
-    );
-
-    const program = buildProgram();
-    await program.parseAsync(
-      ["files", "delete", "installer/*", "--personal", "--yes"],
-      { from: "user" },
-    );
-
-    const b = bodies();
-    expect(b).toHaveLength(2);
-    expect(b[0]).toEqual({ personal: true, prefix: "installer/*", dryRun: true });
-    expect(b[1]).toEqual({ personal: true, prefix: "installer/*", dryRun: false });
-    expect(printed()).toContain("Deleted 2 objects");
-  });
-
-  it("confirmation copy says 'your personal vault' (not the shared-vault wording)", async () => {
-    fetchSpy.mockResolvedValueOnce(
-      deleteResponse({ dryRun: true, matched: 1, keys: ["installer/a.txt"] }),
-    );
-    let prompt = "";
-    await runFilesDelete(
-      { prefix: "installer/*", dryRun: false, yes: false, personal: true, companySlug: undefined },
-      {
-        confirm: async (m) => {
-          prompt = m;
-          return false;
-        },
-      },
-    );
-    expect(prompt).toContain("your personal vault");
-    expect(prompt).not.toContain("shared vault");
-    // Declined → no real delete (only the preview fetch happened).
-    expect(bodies()).toHaveLength(1);
-  });
-
-  it("rejects --personal combined with --company before any network call", async () => {
-    const program = buildProgram();
-    await expect(
-      program.parseAsync(
-        ["files", "--company", "acme", "delete", "installer/*", "--personal"],
-        { from: "user" },
-      ),
-    ).rejects.toThrow(/__EXIT__:1/);
-    expect(printedErr()).toContain("Pass either --personal or --company");
-    expect(deleteCalls()).toHaveLength(0);
-  });
-});