@nurix/nustack 0.23.11 → 0.23.13

package/dist/lib/agent/claudeHooks.js

@@ -9,6 +9,9 @@ function managedEntry(matcher, command, options) {
         hook.timeout = options.timeout;
     return { matcher, hooks: [hook] };
 }
+function isManagedCommand(command) {
+    return command.trimEnd().endsWith(`# ${MANAGED_MARKER}`);
+}
 function carriesMarker(entry) {
     if (entry === null || typeof entry !== "object")
         return false;
@@ -18,7 +21,7 @@ function carriesMarker(entry) {
     return hooks.some((hook) => hook !== null &&
         typeof hook === "object" &&
         typeof hook.command === "string" &&
-        hook.command.includes(MANAGED_MARKER));
+        isManagedCommand(hook.command));
 }
 function isManagedEntry(entry, matcher) {
     if (!carriesMarker(entry))

package/dist/lib/auth_grant.js

@@ -3,6 +3,7 @@ import { createHash, randomBytes } from "node:crypto";
 import { getOrCreateDeviceId } from "./device_identity.js";
 import { deleteDeviceCredential, readCredentialFailure, readDeviceCredential, writeDeviceCredential } from "./device_keychain.js";
 import { openLoopbackListener } from "./loopback.js";
+import { originMismatchError, refusedContractOrigin } from "./origin_guard.js";
 const REQUEST_TIMEOUT_MS = 10_000;
 const BOOTSTRAP_TIMEOUT_MS = 25_000;
 const LOOPBACK_TIMEOUT_MS = 10 * 60_000;
@@ -160,11 +161,14 @@ export async function readStoredCredential() {
         credential: { deviceToken: credential.device_token, studioBaseUrl: credential.studio_base_url, deviceId, userEmail: credential.user_email },
     };
 }
-export async function resolveAccessToken() {
+export async function resolveAccessToken(origin) {
     const fromEnv = envToken();
     if (fromEnv) {
         if (fromEnv.kind === "malformed")
             return { kind: "malformed_token", message: fromEnv.message };
+        const refused = refusedContractOrigin(null, origin);
+        if (refused)
+            return { kind: "origin_mismatch", error: originMismatchError(refused, null, "pat") };
         const deviceId = resolvedDeviceId ?? (await getOrCreateDeviceId());
         resolvedDeviceId = deviceId;
         return { kind: "ok", session: { accessToken: fromEnv.token, userEmail: "", deviceId } };
@@ -173,12 +177,20 @@ export async function resolveAccessToken() {
     if (!credential) {
         if (failure)
             lastDeadReason = failure;
+        const refused = refusedContractOrigin(null, origin);
+        if (refused)
+            return { kind: "origin_mismatch", error: originMismatchError(refused, null, "none") };
         return { kind: "none", reason: failure };
     }
+    const refused = refusedContractOrigin(credential.studioBaseUrl, origin);
+    if (refused)
+        return { kind: "origin_mismatch", error: originMismatchError(refused, credential.studioBaseUrl, "device") };
     return { kind: "ok", session: { accessToken: credential.deviceToken, userEmail: credential.userEmail, deviceId } };
 }
-export async function ensureAccessToken() {
-    const outcome = await resolveAccessToken();
+export async function ensureAccessToken(origin) {
+    const outcome = await resolveAccessToken(origin);
+    if (outcome.kind === "origin_mismatch")
+        throw outcome.error;
     return outcome.kind === "ok" ? { accessToken: outcome.session.accessToken, userEmail: outcome.session.userEmail } : null;
 }
 export async function forgetRefusedToken(staleToken) {

package/dist/lib/auth_recovery.js

@@ -2,6 +2,7 @@ import * as p from "@clack/prompts";
 import { deadCredentialCopy, ensureAccessToken, resolveAccessToken } from "./auth_grant.js";
 import { performDeviceLogin } from "../commands/login.js";
 import { isInteractive } from "./interactive.js";
+import { originMismatchError, refusedContractOrigin } from "./origin_guard.js";
 let lastFailure = { code: "SIGNED_OUT", message: deadCredentialCopy(null), retryable: false };
 export function lastAuthFailure() {
     return lastFailure;
@@ -12,6 +13,8 @@ function describeFailure(outcome) {
     }
     if (outcome.kind === "malformed_token")
         return { code: "TOKEN_MALFORMED", message: outcome.message, retryable: false };
+    if (outcome.kind === "origin_mismatch")
+        return { code: "ORIGIN_MISMATCH", message: outcome.error.message, retryable: false };
     return { code: "SIGNED_OUT", message: deadCredentialCopy(outcome.reason), retryable: false };
 }
 function reconnectingCopy(outcome) {
@@ -24,7 +27,7 @@ function reconnectingCopy(outcome) {
 export async function ensureAuthWithRecovery(baseUrl, json) {
     let outcome;
     try {
-        outcome = await resolveAccessToken();
+        outcome = await resolveAccessToken(baseUrl);
     }
     catch {
         lastFailure = describeFailure("unreachable");
@@ -33,13 +36,17 @@ export async function ensureAuthWithRecovery(baseUrl, json) {
     if (outcome.kind === "ok")
         return { accessToken: outcome.session.accessToken, userEmail: outcome.session.userEmail };
     lastFailure = describeFailure(outcome);
-    if (json || !isInteractive() || outcome.kind === "malformed_token")
+    if (json || !isInteractive() || outcome.kind === "malformed_token" || outcome.kind === "origin_mismatch")
         return null;
+    if (refusedContractOrigin(null, baseUrl)) {
+        lastFailure = describeFailure({ kind: "origin_mismatch", error: originMismatchError(baseUrl, null, "none") });
+        return null;
+    }
     p.log.warn(reconnectingCopy(outcome));
     const didLogin = await performDeviceLogin(baseUrl, process.cwd(), { reauthorize: true });
     if (!didLogin)
         return null;
-    return ensureAccessToken().catch(() => {
+    return ensureAccessToken(baseUrl).catch(() => {
         lastFailure = describeFailure("unreachable");
         return null;
     });

package/dist/lib/etna/manager.js

@@ -2,7 +2,17 @@ import { detectPackageManager, installPackage } from "../package_manager.js";
 import { assertSafePackageName } from "../guards.js";
 import { updateBindingEtnaProfile } from "../local_store/bindings.js";
 import { serializeProfileForBinding } from "./profile.js";
-import { mountHarness } from "../harness/mount.js";
+import { mountProjectHarness } from "../harness/mount.js";
+export function profileNamesHarness(profile) {
+    return Boolean(profile.harnessDigest || profile.versionManifestPath || profile.manifestUrl);
+}
+export function mountReportOf(outcome) {
+    return { status: outcome.status, source: outcome.source, version: outcome.version, digest: outcome.digest };
+}
+export function mountFailureReport(error) {
+    const code = error?.code;
+    return { status: "failed", code: typeof code === "string" ? code : "HARNESS_MOUNT_FAILED", message: error instanceof Error ? error.message : String(error) };
+}
 export function toolkitPackageName(profile) {
     if (!profile.name.startsWith("@"))
         return null;
@@ -16,14 +26,22 @@ export function toolkitPackageName(profile) {
 export async function installToolkit(store, bindingId, profile, cwd, deps = {}) {
     const packageName = toolkitPackageName(profile);
     let result;
-    const manifestUrl = deps.manifestUrl ?? profile.manifestUrl ?? null;
-    if (manifestUrl) {
+    if (deps.skipMount) {
+        result = { ok: true, installed: false, skipped: true, reason: "skipped_etna_mount", mount: { status: "skipped_etna_mount" } };
+    }
+    else if (profileNamesHarness(profile)) {
         try {
-            await (deps.mount ?? mountHarness)(cwd, manifestUrl);
-            result = { ok: true, installed: true, skipped: false, reason: "mounted" };
+            const outcome = await (deps.mount ?? mountProjectHarness)(cwd, {
+                projectId: deps.projectId,
+                globals: deps.globals,
+                writeContract: deps.writeContract ?? "never",
+                runtime: "claude-code",
+            });
+            result = { ok: true, installed: true, skipped: false, reason: "mounted", mount: mountReportOf(outcome) };
         }
         catch (error) {
-            result = { ok: false, installed: false, skipped: false, reason: error instanceof Error ? error.message : String(error) };
+            const mount = mountFailureReport(error);
+            result = { ok: false, installed: false, skipped: false, reason: mount.message, mount };
         }
     }
     else if (!packageName) {

package/dist/lib/etna/profile.js

@@ -1,4 +1,5 @@
 import { getProject } from "../nustack_client.js";
+import { contractFieldsFromSummary } from "../project_contract.js";
 export class ToolkitProfileUnavailableError extends Error {
     projectId;
     constructor(projectId) {
@@ -21,6 +22,11 @@ export async function fetchToolkitProfile(baseUrl, accessToken, projectId) {
         catalogVersionId: null,
         harnessVersion: project.harness?.version ?? null,
         manifestUrl: project.harness?.manifestUrl ?? null,
+        harnessTrack: project.harness?.track ?? null,
+        harnessDigest: project.harness?.digest ?? null,
+        versionManifestPath: project.harness?.versionManifestPath ?? null,
+        branchPolicy: project.branchPolicy === "trunk" || project.branchPolicy === "branch" ? project.branchPolicy : null,
+        contractFields: contractFieldsFromSummary(project),
     };
 }
 export function toolkitProfileFromManifest(manifest) {

package/dist/lib/etna/reconcile.js

@@ -22,6 +22,12 @@ export function parseRecordedToolkit(binding) {
 export function toolkitCompatibility(mounted, cloud) {
     if (!mounted || !cloud)
         return { compatible: true, blocksWrites: false, reason: null };
+    if (mounted.digest && cloud.harnessDigest) {
+        if (mounted.digest !== cloud.harnessDigest) {
+            return { compatible: false, blocksWrites: true, reason: `mounted harness digest ${mounted.digest.slice(0, 12)} differs from the expected ${cloud.harnessDigest.slice(0, 12)}` };
+        }
+        return { compatible: true, blocksWrites: false, reason: null };
+    }
     const pinned = cloud.harnessVersion ?? cloud.version;
     if (mounted.version !== pinned) {
         return { compatible: false, blocksWrites: true, reason: `mounted harness ${mounted.version} differs from the cloud pin ${pinned}` };

package/dist/lib/harness/codes.js

@@ -0,0 +1,24 @@
+export const HARNESS_CODES = {
+    HARNESS_UNAVAILABLE: "HARNESS_UNAVAILABLE",
+    HARNESS_MOUNT_FAILED: "HARNESS_MOUNT_FAILED",
+    HARNESS_DIGEST_MISMATCH: "HARNESS_DIGEST_MISMATCH",
+    HARNESS_OFFLINE_NO_CACHE: "HARNESS_OFFLINE_NO_CACHE",
+    ORIGIN_MISMATCH: "ORIGIN_MISMATCH",
+    ETNA_MOUNT_PRESENT: "ETNA_MOUNT_PRESENT",
+    INIT_NEEDS_PROJECT: "INIT_NEEDS_PROJECT",
+    INIT_NEEDS_DEVICE: "INIT_NEEDS_DEVICE",
+};
+export const TRAILER_HOOK_VALUES = ["installed", "skipped_hooks_path", "skipped_foreign_hook", "skipped_not_git"];
+export const SESSION_HOOK_VALUES = ["installed", "present", "skipped_unparsable", "skipped_etna_mount"];
+export const MOUNT_STATUS_VALUES = ["mounted", "current", "failed", "skipped_etna_mount"];
+export const MOUNT_SOURCE_VALUES = ["network", "cache", "legacy"];
+export const STATUS_SOURCE_VALUES = ["version", "legacy"];
+export const STATUS_EXIT = { IN_STEP: 0, DIFFERING: 1, UNREACHABLE: 2 };
+export class HarnessError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "HarnessError";
+        this.code = code;
+    }
+}

package/dist/lib/harness/hookCheck.js

@@ -0,0 +1,325 @@
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { openLocalStore, openLocalStoreReadOnly } from "../local_store/database.js";
+import { writeRecords } from "../records/recordsTable.js";
+import { RECORD_SCHEMA_VERSION } from "../records/door.js";
+import { idempotencyKeyOf } from "../records/naturalKey.js";
+import { recordCredentialOf } from "../records/environment.js";
+import { readProjectContract, CONTRACT_PATH } from "../project_contract.js";
+import { loadHarness } from "./vendor.js";
+import { readStoreDocumentationWaivers } from "./storeWaivers.js";
+export const HOOK_DEADLINE_MS = 3000;
+export const HOOK_DEADLINE_VARIABLE = "NUSTACK_HOOK_DEADLINE_MS";
+export const ENFORCEMENT_MAP_PATH = ".nustack/enforcement.json";
+export const HOOK_EVENTS = ["pre-tool-use", "stop"];
+export const RULE_UNAVAILABLE_GATE = "hook.rule_unavailable";
+export const DEADLINE_GATE = "hook.deadline";
+const EVENT_NAMESPACE = "3f0c9a52-6d1e-4b7a-9c2f-8e5d4a1b7c60";
+const RECORDS_STORE_VERSION = 9;
+const EDIT_TOOLS = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+export const COMMIT_RULES = new Set(["changelog", "commit-gate", "changelog-presence", "harness-checks"]);
+class CannotRun extends Error {
+}
+export function uuidV5(name, namespace = EVENT_NAMESPACE) {
+    const namespaceBytes = Buffer.from(namespace.replace(/-/g, ""), "hex");
+    const hash = createHash("sha1").update(Buffer.concat([namespaceBytes, Buffer.from(name, "utf8")])).digest();
+    const bytes = Uint8Array.prototype.slice.call(hash, 0, 16);
+    bytes[6] = (bytes[6] & 0x0f) | 0x50;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = Buffer.from(bytes).toString("hex");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function parsePayload(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new CannotRun("the hook payload on stdin is not JSON");
+    }
+    if (typeof parsed !== "object" || parsed === null)
+        throw new CannotRun("the hook payload on stdin is not an object");
+    const payload = parsed;
+    return {
+        sessionId: typeof payload.session_id === "string" ? payload.session_id : null,
+        cwd: typeof payload.cwd === "string" && payload.cwd ? payload.cwd : process.cwd(),
+        toolName: typeof payload.tool_name === "string" ? payload.tool_name : null,
+        toolInput: typeof payload.tool_input === "object" && payload.tool_input !== null ? payload.tool_input : {},
+        isStopHookActive: payload.stop_hook_active === true,
+    };
+}
+function boundRootOf(dir) {
+    let current = path.resolve(dir);
+    for (;;) {
+        if (existsSync(path.join(current, CONTRACT_PATH)))
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+function readMap(root) {
+    let text;
+    try {
+        text = readFileSync(path.join(root, ENFORCEMENT_MAP_PATH), "utf8");
+    }
+    catch {
+        throw new CannotRun(`no enforcement map at ${ENFORCEMENT_MAP_PATH}; run \`nustack harness mount\``);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new CannotRun(`${ENFORCEMENT_MAP_PATH} is not JSON`);
+    }
+    if (parsed.schemaVersion !== 1 || !Array.isArray(parsed.rules))
+        throw new CannotRun(`${ENFORCEMENT_MAP_PATH} is not a schemaVersion 1 map`);
+    return parsed.rules.filter((row) => typeof row === "object" && row !== null && typeof row.rule === "string" && (row.rung === "flag" || row.rung === "block"));
+}
+function editedPath(root, payload) {
+    const raw = payload.toolInput.file_path ?? payload.toolInput.notebook_path;
+    if (typeof raw !== "string" || raw === "")
+        return null;
+    const absolute = path.isAbsolute(raw) ? raw : path.resolve(payload.cwd, raw);
+    const relative = path.relative(root, absolute);
+    if (relative === "" || relative.startsWith("..") || path.isAbsolute(relative))
+        return null;
+    return relative.split(path.sep).join("/");
+}
+function postEditText(root, relative, payload) {
+    const onDisk = (() => {
+        try {
+            return readFileSync(path.join(root, relative), "utf8");
+        }
+        catch {
+            return null;
+        }
+    })();
+    const input = payload.toolInput;
+    const apply = (text, oldString, newString, isAll) => {
+        if (typeof oldString !== "string" || typeof newString !== "string" || oldString === "")
+            return text;
+        return isAll === true ? text.split(oldString).join(newString) : text.replace(oldString, () => newString);
+    };
+    switch (payload.toolName) {
+        case "Write":
+            return typeof input.content === "string" ? input.content : onDisk;
+        case "Edit":
+            return apply(onDisk ?? "", input.old_string, input.new_string, input.replace_all);
+        case "MultiEdit": {
+            let text = onDisk ?? "";
+            for (const edit of Array.isArray(input.edits) ? input.edits : []) {
+                if (typeof edit === "object" && edit !== null) {
+                    const step = edit;
+                    text = apply(text, step.old_string, step.new_string, step.replace_all);
+                }
+            }
+            return text;
+        }
+        default:
+            return onDisk;
+    }
+}
+function overlaidTree(base, relative, text) {
+    return {
+        read: (candidate) => (candidate === relative ? text : base.read(candidate)),
+        list: (prefix) => {
+            const listed = base.list(prefix).filter((candidate) => candidate !== relative);
+            if (text !== null && relative.startsWith(prefix))
+                listed.push(relative);
+            return listed.sort();
+        },
+    };
+}
+function branchOf(root) {
+    try {
+        return execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    }
+    catch {
+        return "";
+    }
+}
+function todayOf() {
+    return new Date().toISOString().slice(0, 10);
+}
+function findingsText(verdicts) {
+    return verdicts.map((verdict) => verdict.reason).join("\n");
+}
+function reasonOf(gate, findings) {
+    return findings.length === 0 ? gate : findings.map((finding) => `${gate}: ${finding.message}${finding.path ? ` (${finding.path})` : ""}`).join("\n");
+}
+async function writeVerdicts(root, projectId, payload, target, verdicts) {
+    if (verdicts.length === 0)
+        return null;
+    try {
+        const held = await openLocalStoreReadOnly();
+        const version = held?.version ?? RECORDS_STORE_VERSION;
+        held?.close();
+        if (version < RECORDS_STORE_VERSION)
+            return null;
+        const store = await openLocalStore();
+        try {
+            const now = Date.now();
+            const writes = verdicts.map((verdict) => {
+                const eventId = uuidV5(JSON.stringify([payload.sessionId ?? "", verdict.gate, target ?? "", verdict.reason]));
+                const naturalKey = `event:${eventId}`;
+                return {
+                    kind: "gate_event",
+                    schemaVersion: RECORD_SCHEMA_VERSION,
+                    projectId,
+                    sessionId: payload.sessionId,
+                    planAnchor: null,
+                    naturalKey,
+                    idempotencyKey: idempotencyKeyOf(projectId ?? root, "gate_event", naturalKey),
+                    payload: { eventId, gate: verdict.gate, verdict: verdict.verdict, ...(target ? { target } : {}), reason: verdict.reason.slice(0, 20_000) },
+                    createdAt: now,
+                    repositoryRoot: root,
+                    placement: "server",
+                    credential: recordCredentialOf(),
+                };
+            });
+            writeRecords(store, writes);
+        }
+        finally {
+            store.close();
+        }
+        return null;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
+function preToolUseAnswer(fields) {
+    const output = { hookEventName: "PreToolUse" };
+    if (fields.deny !== undefined) {
+        output.permissionDecision = "deny";
+        output.permissionDecisionReason = fields.deny;
+    }
+    if (fields.context !== undefined)
+        output.additionalContext = fields.context;
+    return JSON.stringify({ hookSpecificOutput: output });
+}
+function stopAnswer(fields) {
+    const output = {};
+    if (fields.block !== undefined) {
+        output.decision = "block";
+        output.reason = fields.block;
+    }
+    if (fields.message !== undefined)
+        output.systemMessage = fields.message;
+    return JSON.stringify(output);
+}
+function cannotRunAnswer(event, isProtection, reason) {
+    const line = `NuStack enforcement could not run: ${reason}`;
+    if (isProtection)
+        return { stdout: "", stderr: `${line}\n`, exitCode: 2 };
+    return { stdout: event === "pre-tool-use" ? preToolUseAnswer({ context: line }) : stopAnswer({ message: line }), stderr: "", exitCode: 0 };
+}
+export async function runHookCheck(event, isProtection, stdinText, env = process.env) {
+    const started = Date.now();
+    const lowered = Number(env[HOOK_DEADLINE_VARIABLE]);
+    const deadline = Number.isFinite(lowered) && lowered > 0 ? Math.min(lowered, HOOK_DEADLINE_MS) : HOOK_DEADLINE_MS;
+    let payload;
+    let root;
+    let rows;
+    let rules;
+    let rulesNode;
+    try {
+        payload = parsePayload(stdinText);
+        const bound = boundRootOf(payload.cwd);
+        if (!bound)
+            throw new CannotRun("this folder is not bound to a NuStack Project");
+        root = bound;
+        rows = readMap(root).filter((row) => (isProtection ? row.protection && row.rung === "block" : !(row.protection && row.rung === "block")));
+        try {
+            rules = await loadHarness("rules");
+            rulesNode = await loadHarness("rulesNode");
+        }
+        catch (error) {
+            throw new CannotRun(`the rule library did not load: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    catch (error) {
+        return cannotRunAnswer(event, isProtection, error instanceof Error ? error.message : String(error));
+    }
+    let target = null;
+    if (event === "pre-tool-use") {
+        if (payload.toolName !== null && !EDIT_TOOLS.has(payload.toolName))
+            return { stdout: "", stderr: "", exitCode: 0 };
+        target = editedPath(root, payload);
+        if (target === null)
+            return { stdout: "", stderr: "", exitCode: 0 };
+    }
+    const contract = await readProjectContract(root);
+    const verdicts = [];
+    let isPastDeadline = false;
+    try {
+        const waivers = [...rulesNode.readBookkeepingWaivers(root), ...(await readStoreDocumentationWaivers(contract.projectId))];
+        let context;
+        if (event === "pre-tool-use") {
+            const tree = rulesNode.workingTree(root);
+            const existed = tree.read(target) !== null;
+            context = {
+                head: overlaidTree(tree, target, postEditText(root, target, payload)),
+                base: tree,
+                changes: [{ path: target, status: existed ? "M" : "A" }],
+                commit: { author: "", message: "" },
+                today: todayOf(),
+                pullRequest: { headRef: branchOf(root), baseRef: "" },
+                waivers,
+            };
+        }
+        else {
+            context = { ...rulesNode.nodeRuleContext({ root, baseRef: "HEAD" }), waivers };
+        }
+        for (const row of rows) {
+            if (COMMIT_RULES.has(row.rule))
+                continue;
+            if (!rules.isRuleId(row.rule)) {
+                if (event === "stop")
+                    verdicts.push({ gate: RULE_UNAVAILABLE_GATE, verdict: "flag", findings: [], reason: `${row.rule} is not a rule this CLI serves` });
+                continue;
+            }
+            if (Date.now() - started >= deadline) {
+                isPastDeadline = true;
+                break;
+            }
+            const result = rules.runRule(row.rule, { ...context, rung: row.rung });
+            if (result.verdict === "pass")
+                continue;
+            verdicts.push({ gate: row.rule, verdict: result.verdict, findings: result.findings, reason: reasonOf(row.rule, result.findings) });
+        }
+    }
+    catch (error) {
+        return cannotRunAnswer(event, isProtection, error instanceof Error ? error.message : String(error));
+    }
+    if (isPastDeadline) {
+        for (const verdict of verdicts)
+            verdict.verdict = "flag";
+        verdicts.push({ gate: DEADLINE_GATE, verdict: "flag", findings: [], reason: `the checks did not finish within ${deadline} ms; the call was let through` });
+    }
+    const blocks = verdicts.filter((verdict) => verdict.verdict === "block");
+    const flags = verdicts.filter((verdict) => verdict.verdict === "flag");
+    const shownFlags = flags.filter((verdict) => verdict.gate !== RULE_UNAVAILABLE_GATE);
+    const writeError = await writeVerdicts(root, contract.projectId, payload, target, verdicts);
+    const writeLine = writeError ? `the gate_event record could not be written: ${writeError}` : null;
+    if (event === "pre-tool-use") {
+        if (blocks.length > 0)
+            return { stdout: preToolUseAnswer({ deny: [findingsText(blocks), writeLine].filter(Boolean).join("\n") }), stderr: "", exitCode: 0 };
+        if (flags.length > 0 || writeLine)
+            return { stdout: preToolUseAnswer({ context: [findingsText(flags), writeLine].filter(Boolean).join("\n") }), stderr: "", exitCode: 0 };
+        return { stdout: "", stderr: "", exitCode: 0 };
+    }
+    if (blocks.length > 0) {
+        const reason = [findingsText(blocks), writeLine].filter(Boolean).join("\n");
+        const shown = [reason, findingsText(shownFlags)].filter(Boolean).join("\n");
+        return { stdout: payload.isStopHookActive ? stopAnswer({ message: shown }) : stopAnswer({ block: reason }), stderr: "", exitCode: 0 };
+    }
+    if (shownFlags.length > 0 || writeLine)
+        return { stdout: stopAnswer({ message: [findingsText(shownFlags), writeLine].filter(Boolean).join("\n") }), stderr: "", exitCode: 0 };
+    return { stdout: "", stderr: "", exitCode: 0 };
+}

package/dist/lib/harness/hookEntry.js

@@ -0,0 +1,27 @@
+import { HOOK_EVENTS, runHookCheck } from "./hookCheck.js";
+function readStdin() {
+    return new Promise((resolve) => {
+        if (process.stdin.isTTY) {
+            resolve("");
+            return;
+        }
+        let text = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => (text += chunk));
+        process.stdin.on("end", () => resolve(text));
+        process.stdin.on("error", () => resolve(text));
+    });
+}
+export async function runHookMode(event, isProtection) {
+    if (!HOOK_EVENTS.includes(event)) {
+        console.error(`--hook must be one of ${HOOK_EVENTS.join(", ")}.`);
+        process.exitCode = isProtection ? 2 : 0;
+        return;
+    }
+    const answer = await runHookCheck(event, isProtection, await readStdin());
+    if (answer.stdout)
+        process.stdout.write(`${answer.stdout}\n`);
+    if (answer.stderr)
+        process.stderr.write(answer.stderr);
+    process.exitCode = answer.exitCode;
+}