@gatebolt/cli 0.7.0 → 0.8.0

package/dist/agents/claude-code.js

@@ -11,18 +11,39 @@ const GUARD_SUB = "guard";
 const POST_TURN_SUB = "post-turn";
 const ENFORCE_STRICT = "strict";
 const ENFORCE_LENIENT = "lenient";
+const DENY_DECISION = "deny";
+export const MISSING_CLI_MESSAGE = "GateBolt: CLI not found on PATH - install it: npm i -g @gatebolt/cli";
+function missingCliDenyPayload() {
+    return JSON.stringify({
+        hookSpecificOutput: {
+            hookEventName: PRE_TOOL_USE,
+            permissionDecision: DENY_DECISION,
+            permissionDecisionReason: MISSING_CLI_MESSAGE,
+        },
+    });
+}
+function guardCommand(cli) {
+    return (`command -v ${cli} >/dev/null 2>&1 && exec ${cli} hook ${GUARD_SUB} || ` +
+        `{ [ "$GATEBOLT_ENFORCE" = ${ENFORCE_STRICT} ] && ` +
+        `{ echo "${MISSING_CLI_MESSAGE}" >&2; ` +
+        `printf '%s\\n' '${missingCliDenyPayload()}'; }; exit 0; }`);
+}
+function postTurnCommand(cli) {
+    return (`command -v ${cli} >/dev/null 2>&1 && exec ${cli} hook ${POST_TURN_SUB} || ` +
+        `echo "${MISSING_CLI_MESSAGE}" >&2`);
+}
 export function mergeSettings(existing, opts) {
     const settings = structuredClone(existing);
     const hooks = plainObject(settings.hooks, "hooks");
     settings.hooks = hooks;
     let changed = false;
     const preToolUse = arrayField(hooks[PRE_TOOL_USE], `hooks.${PRE_TOOL_USE}`);
-    if (ensureHookCommand(preToolUse, `hook ${GUARD_SUB}`, opts.command, EDIT_TOOLS_MATCHER)) {
+    if (ensureHookCommand(preToolUse, `hook ${GUARD_SUB}`, guardCommand(opts.command), EDIT_TOOLS_MATCHER)) {
         changed = true;
     }
     hooks[PRE_TOOL_USE] = preToolUse;
     const stop = arrayField(hooks[STOP], `hooks.${STOP}`);
-    if (ensureHookCommand(stop, `hook ${POST_TURN_SUB}`, opts.command)) {
+    if (ensureHookCommand(stop, `hook ${POST_TURN_SUB}`, postTurnCommand(opts.command))) {
         changed = true;
     }
     hooks[STOP] = stop;
@@ -71,11 +92,8 @@ function arrayField(value, label) {
         return value;
     throw new Error(`${SETTINGS_FILE}: "${label}" must be a JSON array.`);
 }
-// Update our command in place when it drifts, not just add-when-absent: a
-// re-run of `init` that left a stale command would silently disable the guard.
-function ensureHookCommand(entries, suffix, command, matcher) {
-    const desired = `${command} ${suffix}`;
-    const existing = findGateboltHook(entries, suffix);
+function ensureHookCommand(entries, marker, desired, matcher) {
+    const existing = findGateboltHook(entries, marker);
     if (existing) {
         if (existing.command === desired)
             return false;
@@ -86,14 +104,14 @@ function ensureHookCommand(entries, suffix, command, matcher) {
     entries.push(matcher === undefined ? { hooks: [hook] } : { matcher, hooks: [hook] });
     return true;
 }
-function findGateboltHook(entries, suffix) {
+function findGateboltHook(entries, marker) {
     for (const entry of entries) {
         if (!isRecord(entry) || !Array.isArray(entry.hooks))
             continue;
         for (const hook of entry.hooks) {
             if (isRecord(hook) &&
                 typeof hook.command === "string" &&
-                hook.command.trim().endsWith(suffix)) {
+                hook.command.includes(marker)) {
                 return hook;
             }
         }

package/dist/commands/hook.js

@@ -1,6 +1,8 @@
 import { existsSync } from "node:fs";
+import { dirname } from "node:path";
 import { formatError } from "../errors.js";
 import { hasCommits, repoContext } from "../git.js";
+import { isRecord } from "../json.js";
 import { readSession } from "../session.js";
 import { RequestError } from "../transport.js";
 import { runObserve } from "./observe.js";
@@ -21,33 +23,68 @@ task — specific repo-relative paths, not broad globs like src/** :
 The GateBolt CLI is already configured for this repository. Once it
 prints "Declared change …", retry the edit.`;
 }
-export async function runHook(argv) {
-    anchorToProjectDir();
-    drainStdin();
+export async function runHook(argv, input = {}) {
     const sub = argv[0] ?? "";
     switch (sub) {
         case "guard":
-            return runGuard();
+            return runGuard(input);
         case "post-turn":
-            return runPostTurn();
+            return runPostTurn(input);
         case "pre-push":
-            return runPrePush();
+            return runPrePush(input);
         default:
             throw new Error(`Unknown hook '${sub}'. Expected one of: guard, post-turn, pre-push.`);
     }
 }
-let stdinDrained = false;
-function drainStdin() {
-    if (stdinDrained || process.stdin.isTTY)
-        return;
-    stdinDrained = true;
-    process.stdin.on("error", () => undefined);
-    process.stdin.resume();
-}
-function anchorToProjectDir() {
-    const dir = process.env.CLAUDE_PROJECT_DIR;
-    if (dir && existsSync(dir))
+async function resolveRepo(input) {
+    const candidates = [
+        input.filePath ? dirname(input.filePath) : undefined,
+        input.cwd,
+        process.env.CLAUDE_PROJECT_DIR,
+        process.cwd(),
+    ];
+    for (const dir of candidates) {
+        if (!dir || !existsSync(dir))
+            continue;
         process.chdir(dir);
+        const repo = await hookRepoContext();
+        if (repo)
+            return repo;
+    }
+    return null;
+}
+export async function readHookPayload() {
+    const data = safeJsonParse(await readStdin());
+    if (!isRecord(data))
+        return {};
+    const toolInput = isRecord(data.tool_input) ? data.tool_input : undefined;
+    return {
+        cwd: typeof data.cwd === "string" ? data.cwd : undefined,
+        filePath: toolInput && typeof toolInput.file_path === "string"
+            ? toolInput.file_path
+            : undefined,
+    };
+}
+function safeJsonParse(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function readStdin() {
+    if (process.stdin.isTTY)
+        return Promise.resolve("");
+    return new Promise((resolve) => {
+        const chunks = [];
+        const done = () => resolve(Buffer.concat(chunks).toString("utf8"));
+        process.stdin.on("data", (chunk) => {
+            chunks.push(chunk);
+        });
+        process.stdin.on("end", done);
+        process.stdin.on("error", done);
+    });
 }
 async function hookRepoContext() {
     try {
@@ -57,10 +94,10 @@ async function hookRepoContext() {
         return null;
     }
 }
-async function runGuard() {
+async function runGuard(input) {
     if (process.env.GATEBOLT_ENFORCE !== ENFORCE_STRICT)
         return;
-    const repo = await hookRepoContext();
+    const repo = await resolveRepo(input);
     if (!repo)
         return;
     if (await readSession(repo.gitDir))
@@ -71,8 +108,8 @@ async function runGuard() {
     const cli = process.env.GATEBOLT_CLI ?? DEFAULT_CLI;
     process.stdout.write(denyPayload(declareInstructions(cli)));
 }
-async function runPostTurn() {
-    const repo = await hookRepoContext();
+async function runPostTurn(input) {
+    const repo = await resolveRepo(input);
     if (!repo)
         return;
     if (!(await readSession(repo.gitDir)))
@@ -86,8 +123,8 @@ async function runPostTurn() {
 }
 // Backstop for the interrupt case the Stop hook misses: an open, un-observed
 // declaration.
-async function runPrePush() {
-    const repo = await hookRepoContext();
+async function runPrePush(input) {
+    const repo = await resolveRepo(input);
     if (!repo)
         return;
     if (!(await readSession(repo.gitDir)))

package/dist/commands/init.js

@@ -3,7 +3,7 @@ import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
 import { delimiter, dirname, isAbsolute, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
-import { claudeCodeAdapter } from "../agents/claude-code.js";
+import { claudeCodeAdapter, MISSING_CLI_MESSAGE, } from "../agents/claude-code.js";
 import { repoIdentityFromName, resolveConnection } from "../config.js";
 import { hooksPath, isPathIgnored, isUncommitted, repoContext, } from "../git.js";
 import { isRecord } from "../json.js";
@@ -163,6 +163,10 @@ export function prePushScript(command) {
     return [
         "#!/usr/bin/env sh",
         `# ${PRE_PUSH_MARKER} — reconciles an open declaration before a push.`,
+        `if ! command -v ${command} >/dev/null 2>&1; then`,
+        `  echo "${MISSING_CLI_MESSAGE}" >&2`,
+        "  exit 0",
+        "fi",
         `exec ${command} hook ${PRE_PUSH_FILE}`,
         "",
     ].join("\n");

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { runConfigure } from "./commands/configure.js";
 import { runDeclare } from "./commands/declare.js";
-import { runHook } from "./commands/hook.js";
+import { readHookPayload, runHook } from "./commands/hook.js";
 import { runInit } from "./commands/init.js";
 import { runLink } from "./commands/link.js";
 import { runLogin } from "./commands/login.js";
@@ -43,7 +43,7 @@ async function dispatch(command, argv) {
         case "init":
             return runInit(argv);
         case "hook":
-            return runHook(argv);
+            return runHook(argv, await readHookPayload());
         default:
             process.stderr.write(`${USAGE}\nRun \`gatebolt --help\` for details.\n`);
             process.exitCode = 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gatebolt/cli",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Declare-then-observe agent client for GateBolt — records the files an AI agent intends to touch, then reconciles the actual git diff.",
   "keywords": [
     "gatebolt",