@catalyst-cloud/cli 0.14.6 → 0.14.8

package/dist/owned-fetch.js

@@ -0,0 +1,182 @@
+export function ownedFetch(fetchImpl, parent, options = {}) {
+    const limit = options.maxBodyBytes;
+    if (limit !== undefined && (!Number.isSafeInteger(limit) || limit < 1))
+        throw new Error("owned_fetch_body_limit_invalid");
+    const owned = new AbortController();
+    const requests = new Set();
+    const bodies = new Set();
+    const cleanupErrors = [];
+    let settling = false;
+    const stopped = () => owned.abort(parent.reason);
+    parent.addEventListener("abort", stopped, { once: true });
+    if (parent.aborted)
+        stopped();
+    const trackedFetch = (input, init) => {
+        if (owned.signal.aborted)
+            return Promise.reject(owned.signal.reason);
+        if (settling)
+            return Promise.reject(new Error("owned_fetch_stopped"));
+        const requestSignal = input instanceof Request ? input.signal : undefined;
+        const signal = AbortSignal.any([
+            owned.signal,
+            ...(requestSignal ? [requestSignal] : []),
+            ...(init?.signal ? [init.signal] : []),
+        ]);
+        if (signal.aborted)
+            return Promise.reject(signal.reason);
+        const network = new AbortController();
+        const stopHeaders = () => network.abort(signal.reason);
+        signal.addEventListener("abort", stopHeaders, { once: true });
+        const pending = (async () => {
+            let response;
+            try {
+                response = await fetchImpl(input, {
+                    ...init,
+                    signal: network.signal,
+                    redirect: "error",
+                });
+            }
+            finally {
+                signal.removeEventListener("abort", stopHeaders);
+            }
+            if (!response.body) {
+                if (signal.aborted)
+                    throw signal.reason;
+                return response;
+            }
+            const reader = response.body.getReader();
+            let bodyController;
+            let terminal = false;
+            let consumed = 0;
+            let completed = false;
+            let enteredRead;
+            let firstCancel;
+            let complete;
+            const joined = new Promise((resolve) => {
+                complete = resolve;
+            });
+            bodies.add(joined);
+            const finish = () => {
+                if (completed)
+                    return;
+                completed = true;
+                signal.removeEventListener("abort", aborted);
+                try {
+                    reader.releaseLock();
+                }
+                catch (error) {
+                    cleanupErrors.push(error);
+                }
+                complete();
+            };
+            const cancel = (reason) => {
+                if (firstCancel)
+                    return firstCancel;
+                if (completed)
+                    return Promise.resolve();
+                terminal = true;
+                // Retain this FIRST promise: a second cancel can resolve before underlying IO acknowledges it.
+                firstCancel = reader.cancel(reason);
+                // Close/error the owned reader FIRST. Aborting native fetch first can instead error its
+                // upstream stream and turn an otherwise acknowledged cancellation into a rejection.
+                network.abort(reason);
+                const read = enteredRead;
+                void Promise.allSettled([firstCancel, ...(read ? [read] : [])]).then((results) => {
+                    const cancellation = results[0];
+                    if (cancellation?.status === "rejected")
+                        cleanupErrors.push(cancellation.reason);
+                    finish();
+                });
+                return firstCancel;
+            };
+            const aborted = () => {
+                if (completed)
+                    return;
+                terminal = true;
+                // An abort is an error, never successful EOF that could publish a truncated page.
+                try {
+                    bodyController?.error(signal.reason);
+                }
+                catch {
+                    /* already terminal */
+                }
+                void cancel(signal.reason).catch(() => { });
+            };
+            const body = new ReadableStream({
+                start(controller) {
+                    bodyController = controller;
+                    signal.addEventListener("abort", aborted, { once: true });
+                    if (signal.aborted)
+                        aborted();
+                },
+                async pull(controller) {
+                    if (terminal)
+                        return;
+                    const read = reader.read();
+                    enteredRead = read;
+                    try {
+                        const result = await read;
+                        if (terminal || signal.aborted)
+                            return;
+                        if (result.done) {
+                            terminal = true;
+                            controller.close();
+                            finish();
+                        }
+                        else {
+                            if (limit !== undefined &&
+                                result.value.byteLength > limit - consumed)
+                                throw new Error("owned_fetch_body_limit");
+                            consumed += result.value.byteLength;
+                            controller.enqueue(result.value);
+                        }
+                    }
+                    catch (error) {
+                        if (!terminal) {
+                            terminal = true;
+                            controller.error(error);
+                            void cancel(error).catch(() => { });
+                        }
+                    }
+                    finally {
+                        if (enteredRead === read)
+                            enteredRead = undefined;
+                    }
+                },
+                cancel(reason) {
+                    return cancel(reason);
+                },
+            });
+            if (signal.aborted) {
+                aborted();
+                await joined;
+                throw signal.reason;
+            }
+            return new Response(body, {
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+            });
+        })();
+        requests.add(pending);
+        void pending.then(() => requests.delete(pending), () => requests.delete(pending));
+        return pending;
+    };
+    return {
+        fetch: trackedFetch,
+        abort(reason) {
+            owned.abort(reason);
+        },
+        async settle() {
+            settling = true;
+            owned.abort(new Error("owned_fetch_settling"));
+            // A fetch that ignores its signal stays owned. Its eventual body is cancelled before return.
+            // This join does not pretend a deadline proves that non-cooperative IO has stopped.
+            await Promise.allSettled([...requests]);
+            await Promise.all([...bodies]);
+            parent.removeEventListener("abort", stopped);
+            if (cleanupErrors.length > 0)
+                throw new AggregateError(cleanupErrors, "owned_fetch_cleanup_failed");
+        },
+    };
+}

package/dist/pagination.js

@@ -12,6 +12,8 @@
 import { CliError } from "./errors.js";
 export const NEXT_CURSOR_HEADER = "x-mirror-next-cursor";
 export const TOTAL_HEADER = "x-mirror-total";
+/** CTC-4556 — the `/issues` params that narrowed the page, comma-separated; absent on older mirrors. */
+export const SCOPE_HEADER = "x-mirror-scope";
 /** The server clamps every page to this regardless of the requested `limit` (MAX_VIEW_LIMIT). */
 export const SERVER_PAGE_CAP = 500;
 /** 100 pages × 500 rows = 50,000. Reaching it is a refusal, not an ending. */
@@ -29,6 +31,12 @@ export function rowsOf(body) {
     }
     return [];
 }
+function readScope(headers) {
+    const raw = headers.get(SCOPE_HEADER);
+    if (raw === null)
+        return null;
+    return raw.split(",").map((p) => p.trim()).filter(Boolean);
+}
 function readTotal(headers) {
     const raw = headers.get(TOTAL_HEADER);
     if (raw === null)
@@ -43,6 +51,7 @@ export async function fetchPage(api, path, query) {
         rows: rowsOf(res.body),
         nextCursor: next === null || next === "" ? null : next,
         total: readTotal(res.headers),
+        scope: readScope(res.headers),
     };
 }
 export async function fetchAllPages(api, path, query) {
@@ -50,13 +59,16 @@ export async function fetchAllPages(api, path, query) {
     const seen = new Set();
     let after;
     let total = null;
+    let scope = null;
     for (let pages = 1; pages <= MAX_PAGES; pages++) {
         const page = await fetchPage(api, path, { ...query, limit: SERVER_PAGE_CAP, after });
         rows.push(...page.rows);
         if (page.total !== null)
             total = page.total;
+        // A param counts as applied only if every page says so.
+        scope = pages === 1 ? page.scope : scope && page.scope && scope.filter((p) => page.scope?.includes(p));
         if (page.nextCursor === null)
-            return { rows, total, pages };
+            return { rows, total, pages, scope };
         // ⛔ A cursor that does not advance is an infinite loop, not a long read.
         if (seen.has(page.nextCursor)) {
             throw new CliError(`GET ${path} repeated a page cursor after ${rows.length} rows — the cloud is not advancing the keyset, so --all cannot finish`, "pagination-stalled", 1);

package/dist/query.js

@@ -1,12 +1,12 @@
 // query.ts — `query issues|issue|pulls|pull|projects|cycles|search|changes`: the replica when it is
-// fresh, else the API, with the source named on stderr every time. Output shape is the read-model
+// explicitly selected, otherwise the API, with the source named on stderr every time. Output shape is the read-model
 // view either way. `pull`, `cycles`, `search` and `changes` are API-only (the SDK wraps no view for
 // them and the read-model package is not a declared dependency of this bundle).
-import { flagBool, flagInt, flagString, positionals } from "./args.js";
-import { requireConfig, replicaDbPath } from "./config.js";
+import { flagBool, flagInt, flagString, positionals, } from "./args.js";
+import { requireConfig, replicaDbPath, } from "./config.js";
 import { CliError, UsageError } from "./errors.js";
 import { apiClient } from "./transport.js";
-import { fetchAllPages, fetchPage, rowsOf, truncationNotice } from "./pagination.js";
+import { fetchAllPages, fetchPage, rowsOf, truncationNotice, } from "./pagination.js";
 import { engineFor, replicaStatus } from "./replica.js";
 import { loadSdk } from "./sdk.js";
 export { rowsOf };
@@ -20,9 +20,10 @@ export async function cmdQuery(args, ctx, deps = {}) {
         throw new UsageError("query needs a subcommand: issues | issue <id> | pulls | pull <id> | projects | cycles | search <terms> | changes --since <n>");
     const cfg = requireConfig(ctx);
     const filters = {
-        team: flagString(args, "team"),
-        project: flagString(args, "project"),
-        state: flagString(args, "state"),
+        // CTC-4556 — trimmed here, so the value sent and the value compared are the one the mirror reads.
+        team: trimmedFlag(args, "team"),
+        project: trimmedFlag(args, "project"),
+        state: trimmedFlag(args, "state"),
         limit: flagInt(args, "limit", 50),
         all: flagBool(args, "all"),
     };
@@ -38,7 +39,9 @@ export async function cmdQuery(args, ctx, deps = {}) {
     if (filters.all && flagString(args, "limit") !== undefined) {
         ctx.stderr("--all reads the whole scope, so --limit is ignored");
     }
-    const status = replicaStatus(ctx, cfg);
+    const status = forced === "replica" && REPLICA_CAPABLE.has(sub)
+        ? replicaStatus(ctx, cfg)
+        : null;
     let source;
     let why;
     if (!REPLICA_CAPABLE.has(sub)) {
@@ -53,19 +56,17 @@ export async function cmdQuery(args, ctx, deps = {}) {
         source = "api";
         why = "--all follows the cloud's pages";
     }
-    else if (status.verdict === "fresh") {
-        source = "replica";
-        why = `cursor ${status.cursor}`;
-    }
     else {
         source = "api";
-        why = `replica ${status.verdict}`;
+        why = "cloud reads by default";
     }
     ctx.stderr(source === "replica" ? `source: replica (${why})` : `source: api (${why})`);
     let result;
     if (source === "replica") {
-        if (status.verdict === "absent" || status.verdict === "not-configured") {
-            throw new UsageError(`--source replica but the replica is ${status.verdict}`);
+        if (!status ||
+            status.verdict === "absent" ||
+            status.verdict === "not-configured") {
+            throw new UsageError(`--source replica but the replica is ${status?.verdict ?? "unavailable"}`);
         }
         result = await fromReplica(ctx, cfg, sub, rest, filters, deps);
     }
@@ -82,8 +83,15 @@ export async function cmdQuery(args, ctx, deps = {}) {
 async function fromReplica(ctx, cfg, sub, rest, f, deps) {
     const sdk = await loadSdk();
     const dbPath = replicaDbPath(cfg, ctx.home, ctx.env);
-    const engine = await engineFor(sdk, dbPath, ctx, { ...deps.engineDeps, readonly: true });
-    const replica = await sdk.CatalystReplica.openReadOnly({ dbPath, engine, log: () => { } });
+    const engine = await engineFor(sdk, dbPath, ctx, {
+        ...deps.engineDeps,
+        readonly: true,
+    });
+    const replica = await sdk.CatalystReplica.openReadOnly({
+        dbPath,
+        engine,
+        log: () => { },
+    });
     try {
         switch (sub) {
             case "issues": {
@@ -95,7 +103,9 @@ async function fromReplica(ctx, cfg, sub, rest, f, deps) {
             case "pulls":
                 return replica.pulls({ limit: f.limit });
             case "projects":
-                return applyFilters(replica.projects({ limit: Math.max(f.limit, 200) }), { limit: f.limit, state: f.state }).slice(0, f.limit);
+                return applyFilters(replica.projects({
+                    limit: Math.max(f.limit, 200),
+                }), { limit: f.limit, state: f.state }).slice(0, f.limit);
             default:
                 throw new UsageError(`${sub} is not readable from the replica`);
         }
@@ -106,14 +116,25 @@ async function fromReplica(ctx, cfg, sub, rest, f, deps) {
 }
 async function fromApi(ctx, cfg, sub, rest, f, args) {
     const api = apiClient(cfg, ctx);
-    const common = { team: f.team, project: f.project, state: f.state, limit: f.limit };
+    // CTC-4556 — the mirror narrows `/issues` by `team_key` and `state_name`; `team` and a state name
+    // in `state` narrow nothing there.
+    const issueScope = {
+        team_key: f.team,
+        project: f.project,
+        state_name: f.state,
+    };
     switch (sub) {
         case "issues": {
             if (f.all) {
-                const { rows } = await fetchAllPages(api, "/api/v1/issues", { team: f.team, project: f.project, state: f.state });
+                const { rows, scope } = await fetchAllPages(api, "/api/v1/issues", issueScope);
+                requireIssueScope(scope, f);
                 return applyFilters(rows, f); // no .slice — --all means the whole scope
             }
-            const page = await fetchPage(api, "/api/v1/issues", common);
+            const page = await fetchPage(api, "/api/v1/issues", {
+                ...issueScope,
+                limit: f.limit,
+            });
+            requireIssueScope(page.scope, f);
             const rows = applyFilters(page.rows, f).slice(0, f.limit);
             const notice = truncationNotice(page);
             if (notice)
@@ -131,7 +152,10 @@ async function fromApi(ctx, cfg, sub, rest, f, args) {
                 const { rows } = await fetchAllPages(api, "/api/v1/pulls", { ticket });
                 return rows;
             }
-            const page = await fetchPage(api, "/api/v1/pulls", { limit: f.limit, ticket });
+            const page = await fetchPage(api, "/api/v1/pulls", {
+                limit: f.limit,
+                ticket,
+            });
             const rows = page.rows.slice(0, f.limit);
             const notice = truncationNotice(page);
             if (notice)
@@ -144,18 +168,24 @@ async function fromApi(ctx, cfg, sub, rest, f, args) {
             return res.status === 404 ? null : res.body;
         }
         case "projects": {
-            const res = await api.getJson("/api/v1/projects", { query: { limit: f.limit } });
+            const res = await api.getJson("/api/v1/projects", {
+                query: { limit: f.limit },
+            });
             return rowsOf(res.body).slice(0, f.limit);
         }
         case "cycles": {
-            const res = await api.getJson("/api/v1/cycles", { query: { team: f.team, limit: f.limit } });
+            const res = await api.getJson("/api/v1/cycles", {
+                query: { team: f.team, limit: f.limit },
+            });
             return rowsOf(res.body);
         }
         case "search": {
             const q = rest.join(" ").trim();
             if (!q)
                 throw new UsageError("search needs terms: query search <terms>");
-            const res = await api.getJson("/api/v1/search", { query: { q, limit: f.limit } });
+            const res = await api.getJson("/api/v1/search", {
+                query: { q, limit: f.limit },
+            });
             return searchRows(res.body);
         }
         case "changes": {
@@ -191,7 +221,11 @@ async function readChanges(api, since, limit) {
     });
     const head = res.headers.get(HEAD_SEQ_HEADER);
     if (res.status !== 409) {
-        return { since: Number(resolved), head: head === null ? null : Number(head), changes: res.body };
+        return {
+            since: Number(resolved),
+            head: head === null ? null : Number(head),
+            changes: res.body,
+        };
     }
     const where = head === null ? "" : ` The feed's live cursor is ${head}.`;
     throw new CliError(`cursor ${resolved} is not usable: it is either past the feed's head or no longer in the change log, which keeps only recent changes.${where} Re-run with \`--since head\` to start from now, or with a cursor the feed still holds.`, "changefeed-resync", 1, 409);
@@ -199,7 +233,10 @@ async function readChanges(api, since, limit) {
 /** The live head, read off any `/changes` response's own header — a 409 carries it too, which is
  *  what makes this work on a tenant whose log has rotated past every cursor the caller could guess. */
 async function headCursor(api) {
-    const probe = await api.getNdjson("/api/v1/changes", { query: { since: "0", limit: 1 }, accept: [409] });
+    const probe = await api.getNdjson("/api/v1/changes", {
+        query: { since: "0", limit: 1 },
+        accept: [409],
+    });
     const raw = probe.headers.get(HEAD_SEQ_HEADER);
     const head = raw === null ? Number.NaN : Number(raw);
     if (!Number.isFinite(head)) {
@@ -213,13 +250,39 @@ function needArg(rest, usage) {
         throw new UsageError(`query ${usage}`);
     return v;
 }
+/** CTC-4556 — refuse a page the cloud did not narrow by a filter the user asked for. Filtering it
+ *  here would print the matches among the newest rows and call that the answer. */
+function requireIssueScope(scope, f) {
+    const asked = [
+        ["--team", "team_key", f.team],
+        ["--state", "state_name", f.state],
+        ["--project", "project", f.project],
+    ];
+    for (const [flag, param, value] of asked) {
+        if (!value || scope?.includes(param))
+            continue;
+        throw new CliError(`the cloud did not apply ${flag} (${scope === null ? "it sent no x-mirror-scope header" : `it applied: ${scope.join(", ") || "nothing"}`}), so the page is not that scope; nothing printed. Read it with --source replica, or drop ${flag}`, "filter-not-applied", 1);
+    }
+}
+function trimmedFlag(args, name) {
+    const value = flagString(args, name)?.trim();
+    return value === "" ? undefined : value;
+}
+/** The mirror's comparison for team keys and state names: trimmed and lowercased, nothing more.
+ *  "In Progress" and "In_Progress" stay different names. */
+const sameName = (a, b) => String(a ?? "").trim().toLowerCase() === b.trim().toLowerCase();
 export function applyFilters(rows, f) {
     return rows.filter((r) => {
-        if (f.team && !(String(r.identifier ?? "").toUpperCase().startsWith(`${f.team.toUpperCase()}-`) || r.team_id === f.team || r.team_key === f.team))
+        if (f.team &&
+            !(String(r.identifier ?? "")
+                .toUpperCase()
+                .startsWith(`${f.team.toUpperCase()}-`) ||
+                r.team_id === f.team ||
+                sameName(r.team_key, f.team)))
             return false;
         if (f.project && r.project_id !== f.project)
             return false;
-        if (f.state && String(r.state ?? "").toLowerCase() !== f.state.toLowerCase())
+        if (f.state && !sameName(r.state, f.state))
             return false;
         return true;
     });
@@ -227,7 +290,12 @@ export function applyFilters(rows, f) {
 /** The hub answers search in four groups (`issues`, `pulls`, `projects`, `initiatives`, the read
  *  model's SearchView). `rowsOf` returns only the first array it finds, so it dropped every match that
  *  was not a ticket. Every group comes back here, flattened, each row tagged with its `kind`. */
-const SEARCH_GROUPS = [["issues", "issue"], ["pulls", "pull"], ["projects", "project"], ["initiatives", "initiative"]];
+const SEARCH_GROUPS = [
+    ["issues", "issue"],
+    ["pulls", "pull"],
+    ["projects", "project"],
+    ["initiatives", "initiative"],
+];
 export function searchRows(body) {
     if (Array.isArray(body))
         return body;
@@ -235,7 +303,12 @@ export function searchRows(body) {
         return [];
     const b = body;
     if (SEARCH_GROUPS.some(([group]) => Array.isArray(b[group]))) {
-        return SEARCH_GROUPS.flatMap(([group, kind]) => Array.isArray(b[group]) ? b[group].map((row) => ({ kind, ...row })) : []);
+        return SEARCH_GROUPS.flatMap(([group, kind]) => Array.isArray(b[group])
+            ? b[group].map((row) => ({
+                kind,
+                ...row,
+            }))
+            : []);
     }
     return rowsOf(body);
 }