skillrepo 4.5.1 → 4.6.0

package/src/test/e2e/mock-server.mjs

@@ -80,6 +80,31 @@ export function createMockServer(initialPayload, options = {}) {
   /** @type {{ status: number, body: any } | null} */
   let forcedError = null;
 
+  // Library-request inspection. Tests use these to distinguish a true
+  // 304 wire exchange (`If-None-Match` sent, server replied 304) from
+  // a request that produced "up to date" output via some other path.
+  // PR #1575's placement-presence fix made this distinction
+  // load-bearing — see the assertion at the call sites in
+  // update-list-contract.integration.test.mjs.
+  /** @type {string | null} */
+  let lastLibraryIfNoneMatch = null;
+  /** @type {string | null} */
+  let lastLibrarySince = null;
+  let libraryRequestCount = 0;
+  // #1832 — `?manifest=1` capture for the GET /api/v1/library route so
+  // tests can assert `skillrepo list` made the non-recording manifest read.
+  /** @type {string | null} */
+  let lastLibraryManifest = null;
+
+  // #1832 — POST /api/v1/library/sync-receipts inspection + response slot.
+  // `lastReceipt` holds the most recent JSON-parsed receipt body;
+  // `receiptResponse` overrides the default 200 so tests can simulate
+  // failures (the CLI treats a failed receipt as a non-fatal warning).
+  let lastReceipt = null;
+  let receiptRequestCount = 0;
+  /** @type {{ status: number, body: any } | null} */
+  let receiptResponse = null;
+
   // PR3a mutable slots for POST/DELETE library routes
   //
   // Each entry is `{ status: number, body: any }` describing the
@@ -262,6 +287,41 @@ export function createMockServer(initialPayload, options = {}) {
       return;
     }
 
+    // ── #1832: POST /api/v1/library/sync-receipts (confirmed-write) ─
+    //
+    // The CLI posts this after `runSync` writes skills to disk. Default
+    // 200 echoes a `recorded` count; tests can override via
+    // setReceiptResponse to exercise the non-fatal-warning path.
+    if (
+      url.pathname === "/api/v1/library/sync-receipts" &&
+      req.method === "POST"
+    ) {
+      if (!checkAuth(req, res)) return;
+      let body;
+      try {
+        body = rawBody.length > 0 ? JSON.parse(rawBody) : {};
+      } catch {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({ error: "Body must be JSON", code: "bad_request" }),
+        );
+        return;
+      }
+      lastReceipt = body;
+      receiptRequestCount++;
+      if (receiptResponse) {
+        res.writeHead(receiptResponse.status, {
+          "Content-Type": "application/json",
+        });
+        res.end(JSON.stringify(receiptResponse.body ?? {}));
+        return;
+      }
+      const recorded = Array.isArray(body?.skills) ? body.skills.length : 0;
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ recorded }));
+      return;
+    }
+
     // ── #1452: POST /api/v1/library (multipart file-push) ──────────
     //
     // Accepts multipart/form-data and returns a synthesized
@@ -486,18 +546,58 @@ export function createMockServer(initialPayload, options = {}) {
         return;
       }
 
-      // ETag short-circuit
+      // ETag short-circuit. Capture the inbound If-None-Match and
+      // `since` into inspectable slots BEFORE deciding 304-vs-200 so
+      // tests can assert on what the client actually sent — not just
+      // whether the response was 304. PR #1575's placement-presence
+      // fix makes the wire-level distinction load-bearing.
       const ifNoneMatch = req.headers["if-none-match"];
+      const sinceParam = url.searchParams.get("since");
+      lastLibraryIfNoneMatch = ifNoneMatch ?? null;
+      lastLibrarySince = sinceParam ?? null;
+      lastLibraryManifest = url.searchParams.get("manifest");
+      libraryRequestCount++;
       if (libraryEtag && ifNoneMatch === libraryEtag) {
         res.writeHead(304, { ETag: libraryEtag });
         res.end();
         return;
       }
 
+      // Mirror the production server's `since` filter — only return
+      // skills updated AFTER the `since` timestamp. Pre-PR #1575 the
+      // mock returned every skill regardless of `since`, which hid a
+      // real production bug: dropping the ETag without ALSO dropping
+      // `since` made the server respond with an empty delta, leaving
+      // newly-detected vendor placements empty forever. Mirroring the
+      // filter here means any future regression of that class fails
+      // at test time. See src/lib/queries/library.ts in the server
+      // for the production behavior (`gt(skills.updatedAt, since)`).
+      let respondedSkills = libraryResponse.skills ?? [];
+      if (sinceParam && Array.isArray(respondedSkills)) {
+        const sinceDate = new Date(sinceParam);
+        if (!Number.isNaN(sinceDate.getTime())) {
+          respondedSkills = respondedSkills.filter((s) => {
+            // updatedAt is a string ISO timestamp in the fixture skills.
+            // Missing/invalid → treat as "older than since" → exclude
+            // (matches the production semantic of "not modified in
+            // the window").
+            if (typeof s.updatedAt !== "string") return false;
+            const updated = new Date(s.updatedAt);
+            if (Number.isNaN(updated.getTime())) return false;
+            return updated.getTime() > sinceDate.getTime();
+          });
+        }
+      }
+
+      const filteredResponse = {
+        ...libraryResponse,
+        skills: respondedSkills,
+      };
+
       const headers = { "Content-Type": "application/json" };
       if (libraryEtag) headers.ETag = libraryEtag;
       res.writeHead(200, headers);
-      res.end(JSON.stringify(libraryResponse));
+      res.end(JSON.stringify(filteredResponse));
       return;
     }
 
@@ -586,6 +686,89 @@ export function createMockServer(initialPayload, options = {}) {
       libraryEtag = etag;
     },
 
+    /**
+     * Inspect the inbound `If-None-Match` header from the LAST request
+     * to GET /api/v1/library. Returns the literal header string, or
+     * `null` if the request didn't send one (full-fetch path). Used
+     * by tests asserting that the placement-presence check correctly
+     * dropped or sent the ETag header. See PR #1575's coverage gap
+     * 2 — without this accessor, the "304 fires" tests could pass on
+     * an implementation that broke the wire-level optimization while
+     * preserving the user-facing "up to date" output.
+     */
+    getLastLibraryIfNoneMatch() {
+      return lastLibraryIfNoneMatch;
+    },
+
+    /** Count of GET /api/v1/library requests since server start or reset. */
+    getLibraryRequestCount() {
+      return libraryRequestCount;
+    },
+
+    /**
+     * Inspect the inbound `?since=` query param from the LAST request
+     * to GET /api/v1/library. Returns the literal string or `null` if
+     * not present. The placement-presence fix must drop BOTH the
+     * If-None-Match header AND the `since` query param when placements
+     * are incomplete — otherwise the server returns an empty delta
+     * and missing placements stay empty. Tests use this to assert the
+     * fix at the wire level.
+     */
+    getLastLibrarySince() {
+      return lastLibrarySince;
+    },
+
+    /** Reset the inspection slots — useful between phases of a multi-step test. */
+    resetLibraryInspection() {
+      lastLibraryIfNoneMatch = null;
+      lastLibrarySince = null;
+      lastLibraryManifest = null;
+      libraryRequestCount = 0;
+    },
+
+    /**
+     * Inspect the inbound `?manifest=` query param from the LAST request
+     * to GET /api/v1/library. `"1"` means the client made the
+     * non-recording manifest read (#1832, `skillrepo list`); `null`
+     * means a normal recording sync.
+     */
+    getLastLibraryManifest() {
+      return lastLibraryManifest;
+    },
+
+    // ── #1832: sync-receipt slots ─────────────────────────────────
+
+    /**
+     * Return the most recent POST /api/v1/library/sync-receipts body
+     * (JSON-parsed), or null if none received. Tests assert on
+     * `.skills` (the confirmed-write list) and `.syncedAt`.
+     */
+    getLastReceipt() {
+      return lastReceipt;
+    },
+
+    /** Count of sync-receipt POSTs since server start or reset. */
+    getReceiptRequestCount() {
+      return receiptRequestCount;
+    },
+
+    /**
+     * Override the sync-receipt response to simulate a failure (e.g.
+     * `{ status: 500, body: { error: "boom" } }`). The CLI treats a
+     * failed receipt as a non-fatal warning, so tests use this to
+     * assert the sync still succeeds. Pass null to restore the 200.
+     */
+    setReceiptResponse(override) {
+      receiptResponse = override;
+    },
+
+    /** Reset sync-receipt inspection slots. */
+    resetReceipts() {
+      lastReceipt = null;
+      receiptRequestCount = 0;
+      receiptResponse = null;
+    },
+
     /** Register a single-skill response keyed by `owner/name`. */
     setSkillResponse(owner, name, skill) {
       skillResponses.set(`${owner}/${name}`, skill);