@indigoai-us/hq-cli 5.77.14 → 5.79.0

package/test/helpers/vault-service-mock.ts

@@ -1,295 +0,0 @@
-/**
- * vault-service-mock.ts — vault-service test double.
- *
- * Two collaborating pieces:
- *   1. A `globalThis.fetch` stub for the vault-service JSON API (membership,
- *      entity lookup, STS vend, files list/presign).
- *   2. A real ephemeral localhost HTTP server that serves the presigned-object
- *      GETs. As of hq-cloud >=6.14.x, `PresignObjectIO` fetches presigned URLs
- *      through Node's core HTTP client (`nodePresignedGet`), NOT
- *      `globalThis.fetch`, to bypass the runtime-bundled undici parser — so a
- *      fetch stub alone never intercepts them and the request escapes to real
- *      DNS (`ENOTFOUND`). A real (loopback) server is transport-agnostic: it
- *      works for both the fetch and node-http code paths, and future ones.
- *
- * `mockVaultService` is async (it awaits the server's `listen`) and returns a
- * restore function for `afterEach` that both un-installs the fetch stub and
- * closes the server.
- *
- * Handled JSON endpoints (URL path suffixes):
- *   GET  .../membership/me                  returns { memberships: [...] }
- *   GET  .../entity/by-slug/{type}/{slug}   returns { entity: {...} }
- *   GET  .../entity/{uid}                   returns { entity: {...} }   (direct UID lookup)
- *   GET  .../v1/files/list                  returns { objects, cursor, truncated }
- *   POST .../v1/files/presign               returns { results, expiresAt } (URLs point at the local server)
- *   POST .../sts/vend                       returns { credentials, expiresAt }
- */
-
-import http from "node:http";
-import type { AddressInfo } from "node:net";
-import type { Membership, EntityInfo } from "@indigoai-us/hq-cloud";
-
-export interface MockEntity {
-  /** Entity UID (e.g. "cmp_indigo_001") */
-  uid: string;
-  /** Human-readable stable slug (e.g. "indigo", "personal") */
-  slug: string;
-  /** S3 bucket name for this entity */
-  bucketName: string;
-  /** AWS region; defaults to "us-east-1" */
-  region?: string;
-  /** Entity role in this membership; defaults to "owner" */
-  role?: "owner" | "admin" | "member" | "guest";
-}
-
-export interface MockStsCredentials {
-  accessKeyId: string;
-  secretAccessKey: string;
-  sessionToken: string;
-}
-
-/** A file served over the presigned-URL transport (HQ-59 company reads). */
-export interface MockVaultFile {
-  /** Object key (e.g. "sources/meetings/abc.md") */
-  key: string;
-  /** Full file content as UTF-8 string */
-  content: string;
-  /** Optional override; defaults to 2026-01-01T00:00:00Z */
-  lastModified?: Date;
-}
-
-export interface MockVaultOptions {
-  entities: MockEntity[];
-  /** STS credentials returned for every POST /entities/{uid}/sts; defaults to test creds */
-  stsCredentials?: MockStsCredentials;
-  /**
-   * Files served over the presigned-URL transport (`GET /v1/files/list`,
-   * `POST /v1/files/presign`, then a GET against the minted URL). Supplied so
-   * company (cmp_) reads — which route through presign as of HQ-59 — resolve
-   * without touching real S3. Absent → those endpoints return empty/404.
-   */
-  files?: MockVaultFile[];
-}
-
-const DEFAULT_FILE_DATE = new Date("2026-01-01T00:00:00Z");
-
-const DEFAULT_STS: MockStsCredentials = {
-  accessKeyId: "ASIAMOCK000000000001",
-  secretAccessKey: "mockSecretAccessKey",
-  sessionToken: "mockSessionToken",
-};
-
-/**
- * Start a loopback HTTP server that serves presigned-object GETs from the
- * in-memory `files`. Each minted presign URL is `${origin}/obj?key=<key>`;
- * the handler resolves the file (200 + body) or 404s (→ NoSuchKey in the
- * reader). Returns the server + its `http://127.0.0.1:<port>` origin.
- */
-async function startPresignedFileServer(
-  files: MockVaultFile[],
-): Promise<{ server: http.Server; origin: string }> {
-  const server = http.createServer((req, res) => {
-    const requestUrl = new URL(req.url ?? "/", "http://127.0.0.1");
-    const key = requestUrl.searchParams.get("key") ?? "";
-    const file = files.find((f) => f.key === key);
-    if (!file) {
-      res.statusCode = 404;
-      res.setHeader("content-length", "0");
-      res.end();
-      return;
-    }
-    const body = Buffer.from(file.content, "utf-8");
-    res.writeHead(200, {
-      "content-type": "text/markdown",
-      "content-length": String(body.byteLength),
-      "last-modified": (file.lastModified ?? DEFAULT_FILE_DATE).toUTCString(),
-      etag: '"mock-etag"',
-    });
-    res.end(body);
-  });
-  await new Promise<void>((resolve) => {
-    server.listen(0, "127.0.0.1", resolve);
-  });
-  // Don't keep the event loop (or vitest) alive on this listener.
-  server.unref();
-  const { port } = server.address() as AddressInfo;
-  return { server, origin: `http://127.0.0.1:${port}` };
-}
-
-/**
- * Installs the vault-service test double (fetch stub + presigned-file server).
- *
- * @returns A restore function — call it in afterEach to un-install the stub and
- *   close the server.
- */
-export async function mockVaultService(
-  opts: MockVaultOptions,
-): Promise<() => void> {
-  const { entities, stsCredentials = DEFAULT_STS, files = [] } = opts;
-  const originalFetch = globalThis.fetch as typeof fetch | undefined;
-
-  const { server, origin: presignOrigin } = await startPresignedFileServer(files);
-
-  globalThis.fetch = async (
-    input: RequestInfo | URL,
-    init?: RequestInit,
-  ): Promise<Response> => {
-    const url =
-      typeof input === "string"
-        ? input
-        : input instanceof URL
-          ? input.toString()
-          : (input as Request).url;
-    const method =
-      (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
-
-    // ── Presigned-URL transport (HQ-59 company reads) ──────────────────────
-    // Production fetches presigned URLs over node http (served by the loopback
-    // server above), but keep a fetch branch too so any fetch-based transport
-    // resolves identically without escaping to the network.
-    if (url.startsWith(`${presignOrigin}/`)) {
-      const key = new URL(url).searchParams.get("key") ?? "";
-      const file = files.find((f) => f.key === key);
-      if (!file) return new Response("", { status: 404 });
-      return new Response(file.content, {
-        status: 200,
-        headers: {
-          "Content-Type": "text/markdown",
-          "Content-Length": String(Buffer.byteLength(file.content, "utf-8")),
-          "Last-Modified": (file.lastModified ?? DEFAULT_FILE_DATE).toUTCString(),
-          ETag: '"mock-etag"',
-        },
-      });
-    }
-
-    // GET /v1/files/list?company=<uid>&prefix=<p>&cursor=<c>  (VaultClient.listFiles)
-    if (method === "GET" && /\/v1\/files\/list(\?|$)/.test(url)) {
-      const prefix = new URL(url).searchParams.get("prefix") ?? "";
-      const objects = files
-        .filter((f) => f.key.startsWith(prefix))
-        .map((f) => ({
-          key: f.key,
-          size: Buffer.byteLength(f.content, "utf-8"),
-          lastModified: (f.lastModified ?? DEFAULT_FILE_DATE).toISOString(),
-          etag: "mock-etag",
-          permission: "read",
-        }));
-      return json({ objects, cursor: null, truncated: false });
-    }
-
-    // POST /v1/files/presign  (VaultClient.presign) — mint a per-key URL that
-    // the loopback server (and the GET branch above) resolves. Unknown keys
-    // still get a URL → that GET 404s, which the reader normalizes to
-    // NoSuchKey (the not-found path).
-    if (method === "POST" && /\/v1\/files\/presign$/.test(url)) {
-      const body = init?.body ? JSON.parse(init.body.toString()) : {};
-      const keys = (body.keys ?? []) as Array<{ key: string; op?: string }>;
-      // Echo the requested op and omit `error` on success. hq-cloud >=6.11.x
-      // validates each presign result with a strict schema (op ∈ get|put|delete;
-      // error must be a string when present), so the older `error: null` +
-      // missing-op shape no longer passes.
-      const results = keys.map((k) => ({
-        key: k.key,
-        op: k.op ?? "get",
-        url: `${presignOrigin}/obj?key=${encodeURIComponent(k.key)}`,
-      }));
-      return json({
-        results,
-        expiresAt: new Date(Date.now() + 3600 * 1000).toISOString(),
-      });
-    }
-
-    // GET /membership/me
-    if (method === "GET" && /\/membership\/me(\?.*)?$/.test(url)) {
-      const memberships: Partial<Membership>[] = entities.map((e) => ({
-        membershipKey: `mbr_${e.uid}`,
-        personUid: "prs_test_person_001",
-        companyUid: e.uid,
-        role: e.role ?? "owner",
-        status: "active",
-        invitedBy: "system",
-        invitedAt: "2026-01-01T00:00:00Z",
-        createdAt: "2026-01-01T00:00:00Z",
-        updatedAt: "2026-01-01T00:00:00Z",
-      }));
-      return json({ memberships });
-    }
-
-    // GET /entity/by-slug/{type}/{slug}
-    const bySlugMatch = /\/entity\/by-slug\/[^/]+\/([^/?]+)/.exec(url);
-    if (method === "GET" && bySlugMatch) {
-      const slug = decodeURIComponent(bySlugMatch[1]);
-      const entity = entities.find((e) => e.slug === slug);
-      if (!entity) {
-        return json({ error: "Not found" }, 404);
-      }
-      const info: Partial<EntityInfo> = {
-        uid: entity.uid,
-        slug: entity.slug,
-        type: "company",
-        name: entity.slug,
-        bucketName: entity.bucketName,
-        status: "active",
-      };
-      return json({ entity: info });
-    }
-
-    // GET /entity/{uid} (direct UID lookup — used by entity-resolver)
-    const entityUidMatch = /\/entity\/([^/?]+)$/.exec(url);
-    if (method === "GET" && entityUidMatch) {
-      const uid = decodeURIComponent(entityUidMatch[1]);
-      const entity = entities.find((e) => e.uid === uid);
-      if (!entity) {
-        return json({ error: `Entity '${uid}' not found` }, 404);
-      }
-      const info: Partial<EntityInfo> = {
-        uid: entity.uid,
-        slug: entity.slug,
-        type: "company",
-        name: entity.slug,
-        bucketName: entity.bucketName,
-        status: "active",
-      };
-      return json({ entity: info });
-    }
-
-    // POST /sts/vend  (canonical vault-service endpoint as of hq-cloud 5.21.0;
-    // the previously mocked POST /entities/{uid}/sts was the made-up path
-    // from 5.20.0 that never existed server-side.)
-    if (method === "POST" && url.endsWith("/sts/vend")) {
-      const body = init?.body ? JSON.parse(init.body.toString()) : {};
-      const uid = body.companyUid as string | undefined;
-      const entity = uid ? entities.find((e) => e.uid === uid) : undefined;
-      if (!entity) {
-        return json({ error: `Entity '${uid ?? "(missing companyUid)"}' not found` }, 404);
-      }
-      return json({
-        credentials: stsCredentials,
-        expiresAt: new Date(Date.now() + 3600 * 1000).toISOString(),
-      });
-    }
-
-    // Unhandled — pass through if original fetch exists, else 500
-    if (originalFetch) {
-      return originalFetch(input, init);
-    }
-    return json({ error: `mockVaultService: unhandled request ${method} ${url}` }, 500);
-  };
-
-  return () => {
-    if (originalFetch) {
-      globalThis.fetch = originalFetch;
-    } else {
-      delete (globalThis as Record<string, unknown>).fetch;
-    }
-    server.closeAllConnections?.();
-    server.close();
-  };
-}
-
-function json(body: unknown, status = 200): Response {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: { "Content-Type": "application/json" },
-  });
-}

package/test/sources-signals/smoke.test.ts

@@ -1,228 +0,0 @@
-/**
- * smoke.test.ts — Phase 0 infrastructure smoke test (US-001).
- *
- * Validates that:
- *   1. The fixture files exist and have the expected frontmatter shape.
- *   2. mockS3WithEntries lists and retrieves entries with full round-trip fidelity.
- *   3. mockVaultService intercepts /membership/me, /entity/{uid}, and /sts/vend correctly.
- *   4. runCli(['hq', '--help']) exits 0 (basic wiring check).
- *
- * Note: assertions about 'sources'/'signals' appearing in `hq --help` are
- * intentionally absent here — those land when US-006/US-007 register the
- * commands and add them to buildProgram() in cli-runner.ts.
- */
-
-import { readFileSync } from "fs";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-import { afterEach, describe, expect, it } from "vitest";
-import { GetObjectCommand, ListObjectsV2Command } from "@aws-sdk/client-s3";
-import { mockS3WithEntries } from "../helpers/s3-list-mock.js";
-import { mockVaultService } from "../helpers/vault-service-mock.js";
-import { runCli } from "../helpers/cli-runner.js";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-const FIXTURES = join(__dirname, "../fixtures");
-const SOURCE_PATH = join(FIXTURES, "sources/meetings/sample.md");
-const SIGNAL_ACTION_PATH = join(FIXTURES, "signals/action_item/sample.md");
-const SIGNAL_SUMMARY_PATH = join(FIXTURES, "signals/summary/sample.md");
-
-// ---------------------------------------------------------------------------
-// Fixture shape tests
-// ---------------------------------------------------------------------------
-
-describe("fixtures — file shape", () => {
-  it("source fixture has expected frontmatter fields", () => {
-    const content = readFileSync(SOURCE_PATH, "utf-8");
-    expect(content).toContain("source_id:");
-    expect(content).toContain("channel: meeting");
-    expect(content).toContain("participants:");
-    expect(content).toContain("created_at:");
-  });
-
-  it("action_item signal fixture has required signal fields", () => {
-    const content = readFileSync(SIGNAL_ACTION_PATH, "utf-8");
-    expect(content).toContain("signal_id:");
-    expect(content).toContain("signal_type: action_item");
-    expect(content).toContain("source_ref:");
-    expect(content).toContain("citations:");
-    expect(content).toContain("entity_refs:");
-  });
-
-  it("summary signal fixture has required signal fields", () => {
-    const content = readFileSync(SIGNAL_SUMMARY_PATH, "utf-8");
-    expect(content).toContain("signal_type: summary");
-    expect(content).toContain("source_ref:");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// S3 mock round-trip tests
-// ---------------------------------------------------------------------------
-
-describe("mockS3WithEntries — listing", () => {
-  it("lists all entries when no prefix filter is applied", async () => {
-    const sourceContent = readFileSync(SOURCE_PATH, "utf-8");
-    const signalContent = readFileSync(SIGNAL_ACTION_PATH, "utf-8");
-
-    const client = mockS3WithEntries({
-      entries: [
-        { key: "sources/meetings/abc.md", content: sourceContent },
-        { key: "signals/action_item/xyz.md", content: signalContent },
-      ],
-    });
-
-    const result = await client.send(
-      new ListObjectsV2Command({ Bucket: "mock-bucket" }),
-    ) as { Contents: Array<{ Key: string; Size: number }> };
-
-    expect(result.Contents).toHaveLength(2);
-    const keys = result.Contents.map((c) => c.Key);
-    expect(keys).toContain("sources/meetings/abc.md");
-    expect(keys).toContain("signals/action_item/xyz.md");
-  });
-
-  it("filters by prefix — returns only matching entries", async () => {
-    const sourceContent = readFileSync(SOURCE_PATH, "utf-8");
-    const signalContent = readFileSync(SIGNAL_ACTION_PATH, "utf-8");
-
-    const client = mockS3WithEntries({
-      entries: [
-        { key: "sources/meetings/abc.md", content: sourceContent },
-        { key: "signals/action_item/xyz.md", content: signalContent },
-      ],
-    });
-
-    const sourceList = await client.send(
-      new ListObjectsV2Command({ Bucket: "mock-bucket", Prefix: "sources/meetings/" }),
-    ) as { Contents: Array<{ Key: string }> };
-
-    expect(sourceList.Contents).toHaveLength(1);
-    expect(sourceList.Contents[0].Key).toBe("sources/meetings/abc.md");
-
-    const signalList = await client.send(
-      new ListObjectsV2Command({ Bucket: "mock-bucket", Prefix: "signals/action_item/" }),
-    ) as { Contents: Array<{ Key: string }> };
-
-    expect(signalList.Contents).toHaveLength(1);
-    expect(signalList.Contents[0].Key).toBe("signals/action_item/xyz.md");
-  });
-});
-
-describe("mockS3WithEntries — get round-trip", () => {
-  it("retrieves source content and preserves exact bytes", async () => {
-    const sourceContent = readFileSync(SOURCE_PATH, "utf-8");
-
-    const client = mockS3WithEntries({
-      entries: [{ key: "sources/meetings/abc.md", content: sourceContent }],
-    });
-
-    const result = await client.send(
-      new GetObjectCommand({ Bucket: "mock-bucket", Key: "sources/meetings/abc.md" }),
-    ) as { Body: AsyncIterable<Uint8Array> };
-
-    const chunks: Buffer[] = [];
-    for await (const chunk of result.Body) {
-      chunks.push(Buffer.from(chunk));
-    }
-    const retrieved = Buffer.concat(chunks).toString("utf-8");
-
-    expect(retrieved).toBe(sourceContent);
-    // Spot-check frontmatter field survives round-trip
-    expect(retrieved).toContain("source_id: abc-meeting-001");
-  });
-
-  it("retrieves signal content and preserves exact bytes", async () => {
-    const signalContent = readFileSync(SIGNAL_ACTION_PATH, "utf-8");
-
-    const client = mockS3WithEntries({
-      entries: [{ key: "signals/action_item/xyz.md", content: signalContent }],
-    });
-
-    const result = await client.send(
-      new GetObjectCommand({ Bucket: "mock-bucket", Key: "signals/action_item/xyz.md" }),
-    ) as { Body: AsyncIterable<Uint8Array> };
-
-    const chunks: Buffer[] = [];
-    for await (const chunk of result.Body) {
-      chunks.push(Buffer.from(chunk));
-    }
-    const retrieved = Buffer.concat(chunks).toString("utf-8");
-
-    expect(retrieved).toBe(signalContent);
-    expect(retrieved).toContain("signal_type: action_item");
-  });
-
-  it("throws NoSuchKey for missing entry", async () => {
-    const client = mockS3WithEntries({ entries: [] });
-
-    await expect(
-      client.send(new GetObjectCommand({ Bucket: "mock-bucket", Key: "does/not/exist.md" })),
-    ).rejects.toMatchObject({ name: "NoSuchKey" });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Vault-service mock tests
-// ---------------------------------------------------------------------------
-
-describe("mockVaultService — membership endpoint", () => {
-  let restore: (() => void) | undefined;
-
-  afterEach(() => {
-    restore?.();
-    restore = undefined;
-  });
-
-  it("GET /membership/me returns memberships for all configured entities", async () => {
-    restore = await mockVaultService({
-      entities: [
-        { uid: "cmp_indigo_001", slug: "indigo", bucketName: "hq-indigo-bucket" },
-        { uid: "prs_personal_001", slug: "personal", bucketName: "hq-personal-bucket" },
-      ],
-    });
-
-    const res = await fetch("https://vault-api.example.com/membership/me");
-    const body = (await res.json()) as { memberships: Array<{ companyUid: string }> };
-
-    expect(res.status).toBe(200);
-    expect(body.memberships).toHaveLength(2);
-    const uids = body.memberships.map((m) => m.companyUid);
-    expect(uids).toContain("cmp_indigo_001");
-    expect(uids).toContain("prs_personal_001");
-  });
-
-  it("POST /sts/vend returns credentials", async () => {
-    restore = await mockVaultService({
-      entities: [{ uid: "cmp_indigo_001", slug: "indigo", bucketName: "hq-indigo-bucket" }],
-    });
-
-    const res = await fetch("https://vault-api.example.com/sts/vend", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ companyUid: "cmp_indigo_001" }),
-    });
-    const body = (await res.json()) as {
-      credentials: { accessKeyId: string };
-      expiresAt: string;
-    };
-
-    expect(res.status).toBe(200);
-    expect(body.credentials.accessKeyId).toBe("ASIAMOCK000000000001");
-    expect(typeof body.expiresAt).toBe("string");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// CLI runner
-// ---------------------------------------------------------------------------
-
-describe("runCli — basic wiring", () => {
-  it("runCli(['hq', '--help']) exits 0 and emits non-empty stdout", async () => {
-    const result = await runCli(["hq", "--help"]);
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout.length).toBeGreaterThan(0);
-    expect(result.stdout).toContain("hq");
-  });
-});

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "lib": ["ES2022"],
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "resolveJsonModule": true,
-    "outDir": "dist",
-    "rootDir": "src"
-  },
-  "include": ["src"],
-  "exclude": ["src/**/*.test.ts"]
-}

package/vitest.config.ts

@@ -1,11 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    include: [
-      "src/**/*.test.ts",
-      "test/sources-signals/**/*.test.ts",
-      "test/commands/**/*.test.ts",
-    ],
-  },
-});

package/vitest.e2e.config.ts

@@ -1,7 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    include: ["e2e/**/*.test.ts"],
-  },
-});