@indigoai-us/hq-cli 5.47.16 → 5.47.17

package/src/utils/feedback-screenshots.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+vi.mock("./vault-api.js", () => ({
+  vaultApiFetch: vi.fn(),
+}));
+
+import { vaultApiFetch } from "./vault-api.js";
+import {
+  MAX_SCREENSHOTS,
+  contentTypeForPath,
+  loadScreenshots,
+  uploadScreenshots,
+} from "./feedback-screenshots.js";
+
+let tmp: string;
+
+beforeEach(() => {
+  tmp = fs.mkdtempSync(path.join(os.tmpdir(), "shots-"));
+  vi.mocked(vaultApiFetch).mockReset();
+});
+afterEach(() => {
+  fs.rmSync(tmp, { recursive: true, force: true });
+});
+
+function writePng(name: string, bytes = Buffer.from([0x89, 0x50, 0x4e, 0x47])): string {
+  const p = path.join(tmp, name);
+  fs.writeFileSync(p, bytes);
+  return p;
+}
+
+describe("contentTypeForPath", () => {
+  it("maps known image extensions (case-insensitive)", () => {
+    expect(contentTypeForPath("a.png")).toBe("image/png");
+    expect(contentTypeForPath("a.JPG")).toBe("image/jpeg");
+    expect(contentTypeForPath("a.jpeg")).toBe("image/jpeg");
+    expect(contentTypeForPath("a.webp")).toBe("image/webp");
+    expect(contentTypeForPath("a.gif")).toBe("image/gif");
+  });
+  it("rejects unsupported extensions", () => {
+    expect(() => contentTypeForPath("a.pdf")).toThrow(/unsupported screenshot type/);
+    expect(() => contentTypeForPath("a")).toThrow(/unsupported screenshot type/);
+  });
+});
+
+describe("loadScreenshots", () => {
+  it("reads valid images with their content types", () => {
+    const a = writePng("a.png");
+    const loaded = loadScreenshots([a]);
+    expect(loaded).toHaveLength(1);
+    expect(loaded[0].contentType).toBe("image/png");
+    expect(loaded[0].bytes.byteLength).toBeGreaterThan(0);
+  });
+  it("rejects more than MAX_SCREENSHOTS", () => {
+    const paths = Array.from({ length: MAX_SCREENSHOTS + 1 }, (_, i) => writePng(`s${i}.png`));
+    expect(() => loadScreenshots(paths)).toThrow(new RegExp(`at most ${MAX_SCREENSHOTS}`));
+  });
+  it("rejects a missing file", () => {
+    expect(() => loadScreenshots([path.join(tmp, "nope.png")])).toThrow(/cannot read screenshot/);
+  });
+  it("rejects an empty file", () => {
+    expect(() => loadScreenshots([writePng("empty.png", Buffer.alloc(0))])).toThrow(/empty/);
+  });
+});
+
+describe("uploadScreenshots", () => {
+  it("returns [] without calling the API when no paths given", async () => {
+    const keys = await uploadScreenshots({ paths: [], token: "t" });
+    expect(keys).toEqual([]);
+    expect(vaultApiFetch).not.toHaveBeenCalled();
+  });
+
+  it("presigns, PUTs each image to S3, and returns the keys", async () => {
+    const a = writePng("a.png");
+    const b = writePng("b.jpg");
+    vi.mocked(vaultApiFetch).mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        screenshots: [
+          { key: "feedback-screenshots/prs_a/sub/0.png", url: "https://s3/put0", contentType: "image/png" },
+          { key: "feedback-screenshots/prs_a/sub/1.jpg", url: "https://s3/put1", contentType: "image/jpeg" },
+        ],
+      }),
+    } as unknown as Response);
+    const putCalls: Array<{ url: string; method?: string; contentType?: unknown }> = [];
+    const fetchImpl = vi.fn(async (url: string, init: { method?: string; headers?: Record<string, string> }) => {
+      putCalls.push({ url, method: init.method, contentType: init.headers?.["Content-Type"] });
+      return { ok: true, status: 200 } as Response;
+    }) as unknown as typeof fetch;
+
+    const keys = await uploadScreenshots({ paths: [a, b], token: "tok", fetchImpl });
+
+    expect(keys).toEqual([
+      "feedback-screenshots/prs_a/sub/0.png",
+      "feedback-screenshots/prs_a/sub/1.jpg",
+    ]);
+    // Presign request asked for the right content types.
+    const presignBody = vi.mocked(vaultApiFetch).mock.calls[0][0].body;
+    expect(presignBody).toEqual({ contentTypes: ["image/png", "image/jpeg"] });
+    // One PUT per image, to the presigned URL, with the right Content-Type.
+    expect(putCalls).toEqual([
+      { url: "https://s3/put0", method: "PUT", contentType: "image/png" },
+      { url: "https://s3/put1", method: "PUT", contentType: "image/jpeg" },
+    ]);
+  });
+
+  it("throws when the presign call fails", async () => {
+    const a = writePng("a.png");
+    vi.mocked(vaultApiFetch).mockResolvedValue({
+      ok: false,
+      statusText: "Bad Request",
+      json: async () => ({ error: "at most 5 screenshots are allowed" }),
+    } as unknown as Response);
+    await expect(uploadScreenshots({ paths: [a], token: "t" })).rejects.toThrow(
+      /Failed to presign screenshots: at most 5/,
+    );
+  });
+
+  it("throws when an S3 upload fails", async () => {
+    const a = writePng("a.png");
+    vi.mocked(vaultApiFetch).mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        screenshots: [{ key: "feedback-screenshots/prs_a/sub/0.png", url: "https://s3/put0", contentType: "image/png" }],
+      }),
+    } as unknown as Response);
+    const fetchImpl = vi.fn(async () => ({ ok: false, status: 403 }) as Response) as unknown as typeof fetch;
+    await expect(uploadScreenshots({ paths: [a], token: "t", fetchImpl })).rejects.toThrow(
+      /Failed to upload screenshot .*: HTTP 403/,
+    );
+  });
+});

package/src/utils/feedback-screenshots.ts

@@ -0,0 +1,124 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { vaultApiFetch } from "./vault-api.js";
+
+export const MAX_SCREENSHOTS = 5;
+// Per-image ceiling. Screenshots are PNG/JPEG captures; 10 MB is generous.
+export const MAX_SCREENSHOT_BYTES = 10 * 1024 * 1024;
+
+// Extension → content type. Must stay in sync with the server's allowed set
+// (hq-pro feedback-screenshots.ts ALLOWED_CONTENT_TYPES).
+const EXT_CONTENT_TYPE: Record<string, string> = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+};
+
+export function contentTypeForPath(filePath: string): string {
+  const ext = path.extname(filePath).toLowerCase();
+  const contentType = EXT_CONTENT_TYPE[ext];
+  if (!contentType) {
+    throw new Error(
+      `unsupported screenshot type: ${filePath} (allowed: ${Object.keys(EXT_CONTENT_TYPE).join(", ")})`,
+    );
+  }
+  return contentType;
+}
+
+export interface ScreenshotInput {
+  path: string;
+  contentType: string;
+  bytes: Buffer;
+}
+
+/** Validate + read the given screenshot paths (count, type, existence, size). */
+export function loadScreenshots(paths: string[]): ScreenshotInput[] {
+  if (paths.length > MAX_SCREENSHOTS) {
+    throw new Error(
+      `at most ${MAX_SCREENSHOTS} screenshots are allowed (got ${paths.length})`,
+    );
+  }
+  return paths.map((filePath) => {
+    const contentType = contentTypeForPath(filePath);
+    let bytes: Buffer;
+    try {
+      bytes = fs.readFileSync(filePath);
+    } catch {
+      throw new Error(`cannot read screenshot: ${filePath}`);
+    }
+    if (bytes.byteLength === 0) {
+      throw new Error(`screenshot is empty: ${filePath}`);
+    }
+    if (bytes.byteLength > MAX_SCREENSHOT_BYTES) {
+      throw new Error(
+        `screenshot too large: ${filePath} (${bytes.byteLength} bytes, max ${MAX_SCREENSHOT_BYTES})`,
+      );
+    }
+    return { path: filePath, contentType, bytes };
+  });
+}
+
+interface PresignResponse {
+  screenshots: Array<{ key: string; url: string; contentType: string }>;
+}
+
+/**
+ * Validate the screenshot paths, request presigned PUT URLs from the feedback
+ * endpoint, upload each image direct to S3, and return the object keys to
+ * attach to the feedback submission. Returns [] for no screenshots.
+ *
+ * `fetchImpl` is injectable for tests; defaults to the global fetch.
+ */
+export async function uploadScreenshots(opts: {
+  paths: string[];
+  token: string;
+  fetchImpl?: typeof fetch;
+}): Promise<string[]> {
+  if (opts.paths.length === 0) return [];
+  const inputs = loadScreenshots(opts.paths);
+
+  const res = await vaultApiFetch({
+    token: opts.token,
+    path: "/v1/feedback/screenshots/presign",
+    method: "POST",
+    body: { contentTypes: inputs.map((i) => i.contentType) },
+  });
+  if (!res.ok) {
+    const data = await res.json().catch(() => ({}));
+    const msg =
+      data &&
+      typeof data === "object" &&
+      typeof (data as { error?: unknown }).error === "string"
+        ? (data as { error: string }).error
+        : res.statusText;
+    throw new Error(`Failed to presign screenshots: ${msg}`);
+  }
+  const parsed = (await res.json()) as PresignResponse;
+  if (
+    !parsed ||
+    !Array.isArray(parsed.screenshots) ||
+    parsed.screenshots.length !== inputs.length
+  ) {
+    throw new Error("Presign response did not match the requested screenshots");
+  }
+
+  const doFetch = opts.fetchImpl ?? fetch;
+  const keys: string[] = [];
+  for (let i = 0; i < inputs.length; i++) {
+    const slot = parsed.screenshots[i]!;
+    const put = await doFetch(slot.url, {
+      method: "PUT",
+      headers: { "Content-Type": slot.contentType },
+      body: inputs[i]!.bytes,
+    });
+    if (!put.ok) {
+      throw new Error(
+        `Failed to upload screenshot ${inputs[i]!.path}: HTTP ${put.status}`,
+      );
+    }
+    keys.push(slot.key);
+  }
+  return keys;
+}

package/src/utils/feedback-versions.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+vi.mock("./manifest.js", () => ({
+  findHqRoot: vi.fn(() => "/fake/hq"),
+}));
+vi.mock("./pack-contributions.js", () => ({
+  readHqVersion: vi.fn(() => "15.0.20"),
+}));
+
+import { findHqRoot } from "./manifest.js";
+import { readHqVersion } from "./pack-contributions.js";
+import { CLI_VERSION } from "../cli-version.js";
+import {
+  collectVersions,
+  readCoreVersion,
+  readSyncVersion,
+} from "./feedback-versions.js";
+
+describe("readSyncVersion", () => {
+  let tmpHome: string;
+
+  beforeEach(() => {
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "hqsync-"));
+    fs.mkdirSync(path.join(tmpHome, ".hq"), { recursive: true });
+  });
+  afterEach(() => {
+    fs.rmSync(tmpHome, { recursive: true, force: true });
+  });
+
+  function writeMarker(contents: string): void {
+    fs.writeFileSync(path.join(tmpHome, ".hq", "sync-version.json"), contents);
+  }
+
+  it("reads the version the hq-sync app records", () => {
+    writeMarker(JSON.stringify({ version: "0.8.22-beta.1", updatedAt: "x" }));
+    expect(readSyncVersion(tmpHome)).toBe("0.8.22-beta.1");
+  });
+
+  it("returns null when the marker file is absent (hq-sync not installed)", () => {
+    expect(readSyncVersion(tmpHome)).toBeNull();
+  });
+
+  it("returns null on malformed JSON rather than throwing", () => {
+    writeMarker("{ not json");
+    expect(readSyncVersion(tmpHome)).toBeNull();
+  });
+
+  it("returns null when version is missing or not a non-empty string", () => {
+    writeMarker(JSON.stringify({ updatedAt: "x" }));
+    expect(readSyncVersion(tmpHome)).toBeNull();
+    writeMarker(JSON.stringify({ version: "" }));
+    expect(readSyncVersion(tmpHome)).toBeNull();
+    writeMarker(JSON.stringify({ version: 123 }));
+    expect(readSyncVersion(tmpHome)).toBeNull();
+  });
+});
+
+describe("readCoreVersion", () => {
+  beforeEach(() => {
+    vi.mocked(findHqRoot).mockReset().mockReturnValue("/fake/hq");
+    vi.mocked(readHqVersion).mockReset().mockReturnValue("15.0.20");
+  });
+
+  it("reads hqVersion from the resolved HQ root", () => {
+    expect(readCoreVersion()).toBe("15.0.20");
+    expect(readHqVersion).toHaveBeenCalledWith("/fake/hq");
+  });
+
+  it("returns null (never throws) when resolution fails", () => {
+    vi.mocked(findHqRoot).mockImplementation(() => {
+      throw new Error("no hq root");
+    });
+    expect(readCoreVersion()).toBeNull();
+  });
+
+  it("returns null when core.yaml has no hqVersion", () => {
+    vi.mocked(readHqVersion).mockReturnValue(null);
+    expect(readCoreVersion()).toBeNull();
+  });
+});
+
+describe("collectVersions", () => {
+  beforeEach(() => {
+    vi.mocked(findHqRoot).mockReset().mockReturnValue("/fake/hq");
+    vi.mocked(readHqVersion).mockReset().mockReturnValue("15.0.20");
+  });
+
+  it("always reports the cli version and best-effort core/sync", () => {
+    const versions = collectVersions();
+    expect(versions.cli).toBe(CLI_VERSION);
+    expect(versions.core).toBe("15.0.20");
+    // sync reads the real homedir marker, which won't exist in CI → null.
+    expect(["string", "object"]).toContain(typeof versions.sync); // string | null
+  });
+});

package/src/utils/feedback-versions.ts

@@ -0,0 +1,68 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { CLI_VERSION } from "../cli-version.js";
+import { findHqRoot } from "./manifest.js";
+import { readHqVersion } from "./pack-contributions.js";
+
+/**
+ * The three HQ component versions captured from the submitter's environment
+ * and attached to a feedback submission so triage can see exactly which
+ * versions a report came from.
+ *
+ *   - `cli`  — this hq-cli build (always known).
+ *   - `core` — the HQ scaffold version from `core/core.yaml` (`hqVersion`);
+ *               null when the command runs outside an HQ tree.
+ *   - `sync` — the installed hq-sync menubar app version, which the app
+ *               records at `~/.hq/sync-version.json` on startup; null when
+ *               hq-sync is not installed (e.g. CLI-only / CI environments).
+ */
+export interface VersionInfo {
+  cli: string;
+  core: string | null;
+  sync: string | null;
+}
+
+/**
+ * Best-effort read of the hq-core scaffold version (`core/core.yaml`
+ * `hqVersion`). Resolves the HQ root from the working directory; returns
+ * null when no HQ root / core.yaml is found rather than throwing — version
+ * capture must never break a feedback submission.
+ */
+export function readCoreVersion(): string | null {
+  try {
+    return readHqVersion(findHqRoot());
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Best-effort read of the hq-sync menubar app version. The app writes
+ * `{ version, updatedAt }` to `~/.hq/sync-version.json` on startup; the CLI
+ * reads it here. Returns null when the file is absent or malformed (hq-sync
+ * not installed, or an older build that predates the marker).
+ */
+export function readSyncVersion(homeDir: string = os.homedir()): string | null {
+  try {
+    const raw = fs.readFileSync(
+      path.join(homeDir, ".hq", "sync-version.json"),
+      "utf-8",
+    );
+    const parsed = JSON.parse(raw) as { version?: unknown };
+    return typeof parsed.version === "string" && parsed.version.length > 0
+      ? parsed.version
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Collect all three component versions, each independently best-effort. */
+export function collectVersions(): VersionInfo {
+  return {
+    cli: CLI_VERSION,
+    core: readCoreVersion(),
+    sync: readSyncVersion(),
+  };
+}