@indigoai-us/hq-cli 5.47.16 → 5.48.0

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(),
+  };
+}

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

@@ -126,11 +126,15 @@ export function mockVaultService(opts: MockVaultOptions): () => void {
     // 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 }>;
+      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: `${PRESIGN_URL_HOST}/obj?key=${encodeURIComponent(k.key)}`,
-        error: null,
       }));
       return json({
         results,