@indigoai-us/hq-cli 5.267.0 → 5.269.0

package/dist/lib/lanes/reviews.js

@@ -0,0 +1,395 @@
+import { randomBytes } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { assertNoSecretText } from "./text-scan.js";
+import { LanesError } from "./errors.js";
+export const LANE_REVIEWS_REL = path.join("workspace", "lanes", "reviews");
+export const LANE_REVIEW_SCHEMA_VERSION = "hq-lanes-review.v1";
+export const LANE_REVIEW_HISTORY_CAP = 50;
+const REVIEW_LOCK_WAIT_MS = 5_000;
+const REVIEW_LOCK_STALE_MS = 5 * 60_000;
+function fail(error, message, details = {}) {
+    throw new LanesError(error, message, details);
+}
+export function canonicalLaneReviewRepo(raw) {
+    const value = raw.trim();
+    const parts = value.split("/");
+    if (parts.length !== 2) {
+        return fail("review_repo_invalid", "Repository must be a safe owner/repo pair", { field: "repo" });
+    }
+    const [owner, repository] = parts;
+    if (!owner || !repository ||
+        !/^[A-Za-z0-9][A-Za-z0-9-]{0,38}$/.test(owner) ||
+        !/^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/.test(repository) ||
+        owner === "." || owner === ".." || repository === "." || repository === "..") {
+        return fail("review_repo_invalid", "Repository must be a safe owner/repo pair", { field: "repo" });
+    }
+    return `${owner.toLowerCase()}/${repository.toLowerCase()}`;
+}
+export function parseLaneReviewPr(raw) {
+    const text = String(raw).trim();
+    if (!/^\d+$/.test(text)) {
+        return fail("review_pr_invalid", "Pull request number must be a positive integer", { field: "pr" });
+    }
+    const pr = Number(text);
+    if (!Number.isSafeInteger(pr) || pr <= 0) {
+        return fail("review_pr_invalid", "Pull request number must be a positive integer", { field: "pr" });
+    }
+    return pr;
+}
+function parseHeadSha(value, field = "head") {
+    const head = value.trim();
+    if (!/^[a-fA-F0-9]{40}$/.test(head)) {
+        return fail("review_head_invalid", "Head must be a 40-character hexadecimal commit SHA", { field });
+    }
+    return head.toLowerCase();
+}
+function reviewPath(hqRoot, repo, pr) {
+    const [owner, name] = canonicalLaneReviewRepo(repo).split("/");
+    return path.join(hqRoot, LANE_REVIEWS_REL, `${owner}__${name}`, `${parseLaneReviewPr(pr)}.json`);
+}
+export function laneReviewPath(hqRoot, repo, pr) {
+    return reviewPath(hqRoot, repo, pr);
+}
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isTimestamp(value) {
+    if (typeof value !== "string")
+        return false;
+    const date = Date.parse(value);
+    return Number.isFinite(date) && new Date(date).toISOString() === value;
+}
+function isNullableText(value) {
+    return value === null || (typeof value === "string" && value.length > 0);
+}
+function storedTextIsSafe(field, value, file) {
+    try {
+        assertNoSecretText(field, value);
+    }
+    catch {
+        fail("review_record_invalid", "Review record contains unsafe text", { path: file, field });
+    }
+}
+function parseHistoryEntry(value, file) {
+    if (!isObject(value) || typeof value.repo !== "string" ||
+        !Number.isSafeInteger(value.pr) || value.pr <= 0 ||
+        typeof value.head_sha !== "string" || !/^[a-f0-9]{40}$/.test(value.head_sha) ||
+        !isNullableText(value.reviewer_lane) || !isNullableText(value.reviewer_session) ||
+        !isNullableText(value.worker_lane) || !isNullableText(value.note) ||
+        !isTimestamp(value.recorded_at)) {
+        return fail("review_record_invalid", "Review history entry has invalid fields", { path: file });
+    }
+    let repo;
+    try {
+        repo = canonicalLaneReviewRepo(value.repo);
+    }
+    catch {
+        return fail("review_record_invalid", "Review history entry has an invalid repository", { path: file });
+    }
+    if (repo !== value.repo) {
+        return fail("review_record_invalid", "Review history repository is not canonical", { path: file });
+    }
+    for (const field of ["reviewer_lane", "reviewer_session", "worker_lane", "note"]) {
+        const text = value[field];
+        if (typeof text === "string")
+            storedTextIsSafe(`review.${field}`, text, file);
+    }
+    return value;
+}
+function parseReview(value, file) {
+    if (!isObject(value) || value.schema_version !== LANE_REVIEW_SCHEMA_VERSION || !Array.isArray(value.history)) {
+        return fail("review_record_invalid", "Review record has invalid fields", { path: file });
+    }
+    const current = parseHistoryEntry(value, file);
+    if (value.history.length > LANE_REVIEW_HISTORY_CAP) {
+        return fail("review_record_invalid", "Review record history exceeds its cap", { path: file });
+    }
+    const history = value.history.map((entry) => parseHistoryEntry(entry, file));
+    return { ...current, schema_version: LANE_REVIEW_SCHEMA_VERSION, history };
+}
+export function readLaneReview(hqRoot, repo, pr) {
+    const canonicalRepo = canonicalLaneReviewRepo(repo);
+    const canonicalPr = parseLaneReviewPr(pr);
+    const file = reviewPath(hqRoot, canonicalRepo, canonicalPr);
+    let contents;
+    try {
+        contents = fs.readFileSync(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        return fail("review_record_unreadable", "Review record could not be read", { path: file });
+    }
+    let value;
+    try {
+        value = JSON.parse(contents);
+    }
+    catch {
+        return fail("review_record_invalid", "Review record is not valid JSON", { path: file });
+    }
+    const review = parseReview(value, file);
+    if (review.repo !== canonicalRepo || review.pr !== canonicalPr || reviewPath(hqRoot, review.repo, review.pr) !== file) {
+        return fail("review_record_invalid", "Review record identity does not match its path", { path: file });
+    }
+    return review;
+}
+export function listLaneReviews(hqRoot, reviewerLane) {
+    const directory = path.join(hqRoot, LANE_REVIEWS_REL);
+    let repoDirectories;
+    try {
+        repoDirectories = fs.readdirSync(directory).sort();
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { reviews: [], skipped: 0 };
+        return { reviews: [], skipped: 1 };
+    }
+    const reviews = [];
+    let skipped = 0;
+    for (const repoDirectory of repoDirectories) {
+        const match = /^([a-z0-9-]+)__([a-z0-9._-]+)$/.exec(repoDirectory);
+        if (!match || repoDirectory.startsWith(".")) {
+            skipped += 1;
+            continue;
+        }
+        const repoPath = path.join(directory, repoDirectory);
+        try {
+            const stat = fs.lstatSync(repoPath);
+            if (!stat.isDirectory() || stat.isSymbolicLink()) {
+                skipped += 1;
+                continue;
+            }
+        }
+        catch {
+            skipped += 1;
+            continue;
+        }
+        const repo = `${match[1]}/${match[2]}`;
+        let names;
+        try {
+            names = fs.readdirSync(repoPath).sort();
+        }
+        catch {
+            skipped += 1;
+            continue;
+        }
+        for (const name of names) {
+            if (/^\d+\.json\.lock$/.test(name) || /^\d+\.json\.\d+\.[a-f0-9]{12}\.tmp$/.test(name))
+                continue;
+            if (name.startsWith(".") || !/^\d+\.json$/.test(name)) {
+                skipped += 1;
+                continue;
+            }
+            const file = path.join(repoPath, name);
+            try {
+                const stat = fs.lstatSync(file);
+                if (!stat.isFile() || stat.isSymbolicLink()) {
+                    skipped += 1;
+                    continue;
+                }
+            }
+            catch {
+                skipped += 1;
+                continue;
+            }
+            let pr;
+            try {
+                pr = parseLaneReviewPr(name.slice(0, -5));
+            }
+            catch {
+                skipped += 1;
+                continue;
+            }
+            let review;
+            try {
+                review = readLaneReview(hqRoot, repo, pr);
+            }
+            catch {
+                skipped += 1;
+                continue;
+            }
+            if (!review) {
+                skipped += 1;
+                continue;
+            }
+            if (reviewerLane === undefined || review.reviewer_lane === reviewerLane)
+                reviews.push(review);
+        }
+    }
+    return {
+        reviews: reviews.sort((left, right) => right.recorded_at.localeCompare(left.recorded_at) ||
+            left.repo.localeCompare(right.repo) || left.pr - right.pr),
+        skipped,
+    };
+}
+export async function recordLaneReview(hqRoot, input) {
+    const repo = canonicalLaneReviewRepo(input.repo);
+    const pr = parseLaneReviewPr(input.pr);
+    const head_sha = parseHeadSha(input.headSha);
+    const reviewer_lane = input.reviewerLane?.trim() || null;
+    const reviewer_session = input.reviewerSession?.trim() || null;
+    const worker_lane = input.workerLane?.trim() || null;
+    const note = input.note?.trim() || null;
+    if (worker_lane && !/^[A-Za-z0-9][A-Za-z0-9._-]{0,200}$/.test(worker_lane)) {
+        return fail("review_worker_invalid", "Worker lane id has an invalid format", { field: "worker" });
+    }
+    if (reviewer_lane)
+        assertNoSecretText("reviewer_lane", reviewer_lane);
+    if (reviewer_session)
+        assertNoSecretText("reviewer_session", reviewer_session);
+    if (note)
+        assertNoSecretText("note", note);
+    if (worker_lane)
+        assertNoSecretText("worker", worker_lane);
+    const file = reviewPath(hqRoot, repo, pr);
+    return withReviewRecordLock(file, async () => {
+        const previous = readLaneReview(hqRoot, repo, pr);
+        const entry = {
+            repo,
+            pr,
+            head_sha,
+            reviewer_lane,
+            reviewer_session,
+            worker_lane,
+            note,
+            recorded_at: input.recordedAt.toISOString(),
+        };
+        const review = {
+            ...entry,
+            schema_version: LANE_REVIEW_SCHEMA_VERSION,
+            history: [...(previous?.history ?? []), ...(previous ? [currentHistoryEntry(previous)] : [])]
+                .slice(-LANE_REVIEW_HISTORY_CAP),
+        };
+        writeAtomic(file, review);
+        return review;
+    });
+}
+function reviewLockOwnerAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== "ESRCH";
+    }
+}
+function removeStaleReviewLock(lockPath) {
+    let first;
+    try {
+        first = fs.lstatSync(lockPath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return true;
+        throw error;
+    }
+    if (Date.now() - first.mtimeMs < REVIEW_LOCK_STALE_MS)
+        return false;
+    let pid;
+    try {
+        pid = Number(fs.readFileSync(lockPath, "utf8").split("\n", 1)[0]);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return true;
+        throw error;
+    }
+    if (!Number.isSafeInteger(pid) || pid <= 0 || reviewLockOwnerAlive(pid))
+        return false;
+    let second;
+    try {
+        second = fs.lstatSync(lockPath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return true;
+        throw error;
+    }
+    if (second.dev !== first.dev || second.ino !== first.ino || second.mtimeMs !== first.mtimeMs)
+        return false;
+    try {
+        fs.unlinkSync(lockPath);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return true;
+        throw error;
+    }
+}
+async function withReviewRecordLock(file, action) {
+    const lockPath = `${file}.lock`;
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    const started = Date.now();
+    let fd;
+    while (fd === undefined) {
+        try {
+            fd = fs.openSync(lockPath, "wx", 0o600);
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            if (Date.now() - started >= REVIEW_LOCK_WAIT_MS) {
+                return fail("review_record_write_busy", "This review record is being updated; retry the command", { path: file });
+            }
+            if (!removeStaleReviewLock(lockPath))
+                await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+    }
+    let ownedStat;
+    try {
+        ownedStat = fs.fstatSync(fd);
+        fs.writeSync(fd, `${process.pid}\n${Date.now()}\n`);
+        return await action();
+    }
+    finally {
+        try {
+            fs.closeSync(fd);
+        }
+        catch (error) {
+            process.stderr.write(`hq lanes review: lock close failed for ${lockPath}: ${error instanceof Error ? error.message : String(error)}\n`);
+        }
+        if (ownedStat) {
+            try {
+                const current = fs.lstatSync(lockPath);
+                if (current.dev === ownedStat.dev && current.ino === ownedStat.ino)
+                    fs.unlinkSync(lockPath);
+            }
+            catch (error) {
+                if (error.code !== "ENOENT") {
+                    process.stderr.write(`hq lanes review: lock cleanup failed for ${lockPath}: ${error instanceof Error ? error.message : String(error)}\n`);
+                }
+            }
+        }
+    }
+}
+function currentHistoryEntry(review) {
+    const { repo, pr, head_sha, reviewer_lane, reviewer_session, worker_lane, note, recorded_at } = review;
+    return { repo, pr, head_sha, reviewer_lane, reviewer_session, worker_lane, note, recorded_at };
+}
+function writeAtomic(file, review) {
+    const temporary = `${file}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+    try {
+        fs.writeFileSync(temporary, `${JSON.stringify(review, null, 2)}\n`, { encoding: "utf8", mode: 0o600, flag: "wx" });
+        fs.renameSync(temporary, file);
+        fs.chmodSync(file, 0o600);
+    }
+    catch (error) {
+        try {
+            fs.rmSync(temporary, { force: true });
+        }
+        catch (cleanupError) {
+            throw new LanesError("review_record_write_failed", "Review record could not be written and temporary cleanup failed", {
+                path: file,
+                error: error instanceof Error ? error.name : "UnknownError",
+                cleanup_error: cleanupError instanceof Error ? cleanupError.name : "UnknownError",
+            });
+        }
+        throw new LanesError("review_record_write_failed", "Review record could not be written", {
+            path: file,
+            error: error instanceof Error ? error.name : "UnknownError",
+        });
+    }
+}
+//# sourceMappingURL=reviews.js.map

package/dist/lib/lanes/watcher.js

@@ -48,6 +48,7 @@ import { resolveAdmissionHost as resolveProcessAdmissionHost } from "./admission
 import { createLaneMesh, emitLaneDecisionEvents, emitLaneProgressEvent, emitLaneTerminalStateEvent, laneStoryStatusSuppressionKey, progressEventDue, } from "./mesh-events.js";
 import { envelopeQuestionId } from "./questions.js";
 import { readLanesRegistryFlag } from "./registry-flag.js";
+import { laneCompanyUidSource, resolveLaneCompany } from "./lane-company.js";
 import { blockerFreshnessFingerprint, resolveBlockerFreshnessForLane, } from "./blocker-freshness.js";
 import { krFreshnessFingerprint, resolveKrFreshnessForLane, } from "./kr-freshness.js";
 import { MANAGER_STATUS_GATE_FLAG, managerStatusWasWritten, readStatusSnapshot, resolveManagerStatusTarget, managerStatusGateEnabledForLane, } from "./manager-status-gate.js";
@@ -647,11 +648,12 @@ async function settleManagerStatusGate(hqRoot, lane, manifestTurnId, at, deps, l
     const readFlag = deps.readManagerStatusGateFlag ?? readLanesRegistryFlag;
     let enabled = false;
     try {
-        const company = lane.company ?? lane.mesh_company ?? undefined;
+        const resolution = resolveLaneCompany(hqRoot, lane);
+        const company = resolution.company ?? undefined;
         enabled = await readFlag(MANAGER_STATUS_GATE_FLAG, {
             company,
             ...(company ? {
-                companyUidSource: lane.company ? "lane.company.uid" : "lane.mesh_company.uid",
+                companyUidSource: laneCompanyUidSource(resolution.source),
             } : {}),
         });
     }

package/package.json

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