@indigoai-us/hq-cli 5.108.26 → 5.109.1

package/dist/utils/access-outcomes.js

@@ -0,0 +1,53 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+export function accessOutcomesPath(hqRoot) {
+    return path.join(hqRoot, ".hq", "access-outcomes.jsonl");
+}
+/**
+ * Append one JSONL line. Best-effort by contract: callers are expected to
+ * catch and downgrade any failure, since telemetry must never change an
+ * `hq access` outcome or exit code.
+ */
+export function recordAccessOutcome(hqRoot, rec) {
+    const file = accessOutcomesPath(hqRoot);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const line = JSON.stringify({ outcome: rec.outcome, company: rec.company, ts: rec.ts });
+    fs.appendFileSync(file, `${line}\n`, "utf-8");
+}
+/**
+ * Read the ledger. A missing file is the empty ledger; malformed lines are
+ * skipped so one bad append never hides the rest of the history.
+ */
+export function readAccessOutcomes(hqRoot) {
+    const file = accessOutcomesPath(hqRoot);
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf-8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return [];
+        throw err;
+    }
+    const out = [];
+    for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed &&
+                typeof parsed === "object" &&
+                typeof parsed.outcome === "string" &&
+                typeof parsed.company === "string" &&
+                typeof parsed.ts === "string") {
+                out.push(parsed);
+            }
+        }
+        catch {
+            // malformed line: skip
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=access-outcomes.js.map

package/dist/utils/access-requests.d.ts

@@ -0,0 +1,28 @@
+export declare const ACCESS_REQUEST_DEDUPE_MS: number;
+export interface AccessRequestRecord {
+    requester: string;
+    prefix: string;
+    company: string;
+    grantor: string;
+    sentAt: string;
+    eventId?: string;
+}
+export declare function accessRequestsPath(hqRoot: string): string;
+/**
+ * Read the ledger. A missing file is the empty ledger; any other failure
+ * (unreadable, corrupt JSON, non-array shape) is rethrown with the ledger path
+ * so a corrupt file is never silently replaced by the next write.
+ */
+export declare function readAccessRequests(hqRoot: string): AccessRequestRecord[];
+export declare function recordAccessRequest(hqRoot: string, rec: AccessRequestRecord): void;
+export declare function findRecentAccessRequest(hqRoot: string, args: {
+    requester: string;
+    prefix: string;
+    /** Company slug — `prefix` is company-relative, so it is only unique per company. */
+    company: string;
+    grantor: string;
+    now: number;
+    windowMs?: number;
+}): AccessRequestRecord | null;
+export declare function formatTimeAgo(iso: string, nowMs: number): string;
+//# sourceMappingURL=access-requests.d.ts.map

package/dist/utils/access-requests.js

@@ -0,0 +1,98 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+export const ACCESS_REQUEST_DEDUPE_MS = 24 * 60 * 60 * 1000;
+export function accessRequestsPath(hqRoot) {
+    return path.join(hqRoot, ".hq", "access-requests.json");
+}
+/**
+ * Read the ledger. A missing file is the empty ledger; any other failure
+ * (unreadable, corrupt JSON, non-array shape) is rethrown with the ledger path
+ * so a corrupt file is never silently replaced by the next write.
+ */
+export function readAccessRequests(hqRoot) {
+    const file = accessRequestsPath(hqRoot);
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf-8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return [];
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Cannot read access-request ledger at ${file}: ${message}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Corrupt access-request ledger at ${file}: ${message}. Repair or remove the file; it was not overwritten.`);
+    }
+    if (!Array.isArray(parsed)) {
+        throw new Error(`Corrupt access-request ledger at ${file}: expected a JSON array. Repair or remove the file; it was not overwritten.`);
+    }
+    return parsed;
+}
+export function recordAccessRequest(hqRoot, rec) {
+    // Read first: a corrupt ledger throws here, before anything is written.
+    const existing = readAccessRequests(hqRoot);
+    existing.push(rec);
+    const file = accessRequestsPath(hqRoot);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    // Atomic replace: write a sibling tmp file, then rename over the ledger so a
+    // crash mid-write can never leave a truncated file behind.
+    const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+    try {
+        fs.writeFileSync(tmp, JSON.stringify(existing, null, 2), "utf-8");
+        fs.renameSync(tmp, file);
+    }
+    finally {
+        // A failed rename must not strand the tmp file next to the ledger.
+        if (fs.existsSync(tmp))
+            fs.unlinkSync(tmp);
+    }
+}
+export function findRecentAccessRequest(hqRoot, args) {
+    const windowMs = args.windowMs ?? ACCESS_REQUEST_DEDUPE_MS;
+    const rows = readAccessRequests(hqRoot);
+    let latest = null;
+    for (const row of rows) {
+        if (row.requester !== args.requester ||
+            row.prefix !== args.prefix ||
+            row.company !== args.company ||
+            row.grantor !== args.grantor) {
+            continue;
+        }
+        const t = Date.parse(row.sentAt);
+        if (!Number.isFinite(t))
+            continue;
+        if (args.now - t > windowMs)
+            continue;
+        if (!latest || Date.parse(latest.sentAt) < t)
+            latest = row;
+    }
+    return latest;
+}
+export function formatTimeAgo(iso, nowMs) {
+    const t = Date.parse(iso);
+    if (!Number.isFinite(t))
+        return "just now";
+    const delta = Math.max(0, nowMs - t);
+    const minute = 60 * 1000;
+    const hour = 60 * minute;
+    const day = 24 * hour;
+    if (delta < minute)
+        return "just now";
+    if (delta < hour) {
+        const n = Math.floor(delta / minute);
+        return `${n} minute${n === 1 ? "" : "s"} ago`;
+    }
+    if (delta < day) {
+        const n = Math.floor(delta / hour);
+        return `${n} hour${n === 1 ? "" : "s"} ago`;
+    }
+    const n = Math.floor(delta / day);
+    return `${n} day${n === 1 ? "" : "s"} ago`;
+}
+//# sourceMappingURL=access-requests.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.108.26",
+  "version": "5.109.1",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {