auto-mode 0.10.0 → 0.12.0

package/dist/cli.js

@@ -1,11 +1,13 @@
 #!/usr/bin/env node
-import { g as string, h as strictObject, l as DEFAULT_DENIAL_BUDGET, m as number, n as parseActionRequest, r as classifyAction, s as loadPolicy, t as renderVerdict, u as loadConfig } from "./render-verdict-1xtCI2is.js";
-import { appendFile, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { D as string, E as strictObject, T as number, _ as splitCommandWords, a as resolveSessionScopePath, b as DEFAULT_SCOPE_SOURCES, c as loadCheckoutRemotes, g as splitShellCommand, h as toRepositorySlug, i as resolveStateDir, l as findCheckout, m as loadPolicy, n as parseActionRequest, o as loadSessionScope, p as loadRepositoryContext, r as classifyAction, s as EMPTY_SESSION_SCOPE, t as renderVerdict, x as loadConfig, y as DEFAULT_DENIAL_BUDGET } from "./render-verdict-FhSKxlO9.js";
+import { appendFile, mkdir, open, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, normalize } from "node:path";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { spawn } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import { text } from "node:stream/consumers";
 import { parseArgs } from "node:util";
+import { setTimeout } from "node:timers/promises";
 //#region src/budget/build-retry-key.ts
 const DESCRIPTIVE_FIELDS = { Bash: [
 	"description",
@@ -117,13 +119,6 @@ function formatDenialsLeft(left) {
 	return "This is the last denial before auto-mode asks the user. Stop now, without finishing the rest of the task, and tell the user what consent you need to continue.";
 }
 //#endregion
-//#region src/state/resolve-state-dir.ts
-function resolveStateDir() {
-	const stateHome = process.env["XDG_STATE_HOME"];
-	const base = stateHome === void 0 || stateHome === "" ? join(homedir(), ".local", "state") : stateHome;
-	return join(base, "auto-mode");
-}
-//#endregion
 //#region src/budget/resolve-denial-state-path.ts
 function resolveDenialStatePath(request) {
 	const agentID = request.decisionContext?.agentID ?? "";
@@ -185,12 +180,303 @@ function toHash(value) {
 	return createHash("sha256").update(value).digest("hex").slice(0, 16);
 }
 //#endregion
+//#region src/request/parse-scope-record-request.ts
+const recordSchema = strictObject({
+	sessionID: string().min(1),
+	cwd: string().min(1),
+	startedAt: number().int().positive(),
+	command: string().min(1),
+	resultText: string()
+});
+function parseScopeRecordRequest(body) {
+	const parsed = recordSchema.safeParse(body);
+	return parsed.success ? parsed.data : null;
+}
+//#endregion
+//#region src/scope/read-pull-request.ts
+const LOOKUP_TIMEOUT_MS = 5e3;
+function readPullRequest(repository, number) {
+	const args = [
+		"pr",
+		"view",
+		String(number),
+		"--repo",
+		repository,
+		"--json",
+		"headRefName,createdAt"
+	];
+	return new Promise((resolve) => {
+		const child = spawn("gh", [
+			...args,
+			"--jq",
+			"[.headRefName, .createdAt] | @tsv"
+		], {
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			],
+			timeout: LOOKUP_TIMEOUT_MS
+		});
+		let output = "";
+		child.stdout.setEncoding("utf8");
+		child.stdout.on("data", (chunk) => {
+			output += chunk;
+		});
+		child.on("error", () => {
+			resolve(null);
+		});
+		child.on("close", (code) => {
+			const [head = "", created = ""] = output.trim().split("	");
+			const createdAt = Date.parse(created);
+			resolve(code === 0 && head !== "" && !Number.isNaN(createdAt) ? {
+				head,
+				createdAt
+			} : null);
+		});
+	});
+}
+//#endregion
+//#region src/scope/collect-pull-request-addresses.ts
+function collectPullRequestAddresses(text) {
+	const addresses = /* @__PURE__ */ new Map();
+	for (const match of text.matchAll(PULL_REQUEST_URL)) {
+		const repository = toRepositorySlug(`https://${match.groups?.["repository"] ?? ""}`);
+		const number = Number(match.groups?.["number"]);
+		if (repository !== null) addresses.set(`${repository}#${String(number)}`, {
+			repository,
+			number
+		});
+	}
+	return [...addresses.values()];
+}
+const PULL_REQUEST_URL = /https:\/\/(?<repository>[^/\s]+\/[^/\s]+\/[^/\s]+)\/pull\/(?<number>[1-9]\d*)\b/gu;
+//#endregion
+//#region src/scope/collect-scope-events.ts
+function collectScopeEvents(command, cwd, home) {
+	const events = [];
+	const hasPipe = /(?<!\|)\|(?!\|)/u.test(command);
+	let directory = cwd;
+	for (const segment of splitShellCommand(command).segments) {
+		const [name, ...args] = splitCommandWords(segment.text);
+		if (name === "cd") directory = hasPipe ? null : resolvePath(directory, args[0] ?? home, home);
+		else if (name === "git" && directory !== null) events.push(...collectGitEvents(args, directory, home));
+		else if (name === "gh" && directory !== null && args[0] === "pr" && args[1] === "create") events.push({
+			kind: "pull-request",
+			directory,
+			head: findOptionValue(args, ["--head", "-H"])
+		});
+	}
+	return events;
+}
+const BRANCH_CREATE_OPTIONS = /* @__PURE__ */ new Set([
+	"-b",
+	"-B",
+	"-c",
+	"-C",
+	"--create",
+	"--force-create"
+]);
+const BRANCH_OTHER_OPTIONS = /^-(?:d|D|m|M|c|C|l|a|r|v|vv|u)$|^--(?:delete|move|copy|list|all|remotes|verbose|show-current|contains|no-contains|merged|no-merged|points-at|format|sort|set-upstream-to|unset-upstream|edit-description)/u;
+function collectGitEvents(args, cwd, home) {
+	let directory = cwd;
+	let index = 0;
+	while (index < args.length && args[index]?.startsWith("-") === true) {
+		if (args[index] === "-C") directory = resolvePath(directory, args[index + 1] ?? "", home);
+		index += args[index] === "-C" || args[index] === "-c" ? 2 : 1;
+	}
+	const subcommand = args[index];
+	const rest = args.slice(index + 1);
+	if (directory === null) return [];
+	if (subcommand === "worktree" && rest[0] === "add") {
+		const path = findWorktreePath(rest.slice(1));
+		const resolved = path === null ? null : resolvePath(directory, path, home);
+		return resolved === null ? [] : [{
+			kind: "worktree",
+			path: resolved
+		}];
+	}
+	if (subcommand === "checkout" || subcommand === "switch") {
+		const name = findOptionValue(rest, [...BRANCH_CREATE_OPTIONS]);
+		return name === null ? [] : [{
+			kind: "branch",
+			name,
+			directory
+		}];
+	}
+	if (subcommand === "branch" && !rest.some((word) => BRANCH_OTHER_OPTIONS.test(word))) {
+		const name = rest.find((word) => !word.startsWith("-"));
+		return name === void 0 || isUnresolved(name) ? [] : [{
+			kind: "branch",
+			name,
+			directory
+		}];
+	}
+	return [];
+}
+const WORKTREE_VALUE_OPTIONS = /* @__PURE__ */ new Set([
+	"-b",
+	"-B",
+	"--reason"
+]);
+function findWorktreePath(args) {
+	for (let index = 0; index < args.length; index += 1) {
+		const word = args[index] ?? "";
+		if (WORKTREE_VALUE_OPTIONS.has(word)) index += 1;
+		else if (!word.startsWith("-")) return word;
+	}
+	return null;
+}
+function findOptionValue(args, options) {
+	const index = args.findIndex((word) => options.includes(word));
+	const value = index === -1 ? void 0 : args[index + 1];
+	return value === void 0 || isUnresolved(value) ? null : value;
+}
+function isUnresolved(word) {
+	return /[$`]/u.test(word);
+}
+function resolvePath(directory, path, home) {
+	const expanded = path.replace(/^(?:~|\$HOME|\$\{HOME\})(?=\/|$)/u, home);
+	if (isUnresolved(expanded) || expanded.startsWith("~") || expanded === "") return null;
+	if (!isAbsolute(expanded) && directory === null) return null;
+	const absolute = isAbsolute(expanded) || directory === null ? expanded : join(directory, expanded);
+	return normalize(absolute).replace(/(?<=.)\/$/u, "");
+}
+//#endregion
+//#region src/scope/merge-session-scope.ts
+function mergeSessionScope(all) {
+	const branches = /* @__PURE__ */ new Map();
+	const pullRequests = /* @__PURE__ */ new Map();
+	for (const branch of all.flatMap((scope) => scope.branches)) branches.set(`${branch.commonDir}\0${branch.name}`, branch);
+	for (const pull of all.flatMap((scope) => scope.pullRequests)) pullRequests.set(`${pull.repository}#${String(pull.number)}`, pull);
+	return {
+		worktrees: [...new Set(all.flatMap((scope) => scope.worktrees))],
+		branches: [...branches.values()],
+		pullRequests: [...pullRequests.values()]
+	};
+}
+//#endregion
+//#region src/scope/read-branch-created-at.ts
+async function readBranchCreatedAt(commonDir, branch) {
+	if (!/^[\w./-]+$/u.test(branch) || branch.split("/").includes("..")) return null;
+	const [first = ""] = (await readFile(join(commonDir, "logs", "refs", "heads", branch), "utf8").catch(() => "")).split("\n");
+	const seconds = /^0+ [\da-f]+ .* (?<time>\d+) [+-]\d{4}\t/u.exec(first)?.groups?.["time"];
+	return seconds === void 0 ? null : Number(seconds) * 1e3;
+}
+//#endregion
+//#region src/scope/write-session-scope.ts
+async function writeSessionScope(path, added) {
+	await mkdir(dirname(path), {
+		recursive: true,
+		mode: 448
+	});
+	const lock = `${path}.lock`;
+	await claimLock(lock);
+	try {
+		const merged = mergeSessionScope([await loadSessionScope(path), added]);
+		const staged = `${path}.${randomUUID()}.tmp`;
+		await writeFile(staged, `${JSON.stringify(merged)}\n`, { mode: 384 });
+		await rename(staged, path);
+	} finally {
+		await rm(lock, { force: true });
+	}
+}
+const STALE_LOCK_MS = 1e4;
+const LOCK_WAIT_MS = 3e3;
+const LOCK_POLL_MS = 10;
+async function claimLock(lock) {
+	const deadline = Date.now() + LOCK_WAIT_MS;
+	for (;;) {
+		try {
+			await (await open(lock, "wx", 384)).close();
+			return;
+		} catch (error) {
+			if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
+		}
+		const held = await stat(lock).catch(() => null);
+		if (held !== null && Date.now() - held.mtimeMs > STALE_LOCK_MS) await rm(lock, { force: true });
+		else if (Date.now() > deadline) throw new Error("session scope lock unavailable");
+		else await setTimeout(LOCK_POLL_MS);
+	}
+}
+//#endregion
+//#region src/scope/update-session-scope.ts
+const MAX_CALL_AGE_MS = 9e5;
+async function updateSessionScope(request, options) {
+	const age = options.now - request.startedAt;
+	if (age < -6e4 || age > MAX_CALL_AGE_MS) return EMPTY_SESSION_SCOPE;
+	const events = collectScopeEvents(request.command, request.cwd, options.home);
+	const scope = mergeSessionScope(await Promise.all(events.map((event) => tryVerifyScopeEvent(event, request, options))));
+	if (scope.worktrees.length + scope.branches.length + scope.pullRequests.length > 0) await writeSessionScope(resolveSessionScopePath(options.stateDir, request.sessionID), scope);
+	return scope;
+}
+async function tryVerifyScopeEvent(event, request, options) {
+	try {
+		return await verifyScopeEvent(event, request, options);
+	} catch {
+		return EMPTY_SESSION_SCOPE;
+	}
+}
+const FORGE_CLOCK_SKEW_MS = 6e4;
+const FILE_CLOCK_SLACK_MS = 50;
+async function verifyScopeEvent(event, request, options) {
+	if (event.kind === "worktree") {
+		const link = await stat(join(event.path, ".git"));
+		const checkout = await findCheckout(event.path);
+		if (!link.isFile() || link.mtimeMs < request.startedAt - FILE_CLOCK_SLACK_MS || checkout?.worktree !== event.path) return EMPTY_SESSION_SCOPE;
+		const branch = (await loadRepositoryContext(event.path))?.branch ?? null;
+		if (branch === null) return {
+			...EMPTY_SESSION_SCOPE,
+			worktrees: [event.path]
+		};
+		const isNew = await isBranchCreatedSince(checkout.commonDir, branch, request.startedAt);
+		return {
+			...EMPTY_SESSION_SCOPE,
+			worktrees: [event.path],
+			branches: isNew ? [{
+				name: branch,
+				commonDir: checkout.commonDir
+			}] : []
+		};
+	}
+	const checkout = await findCheckout(event.directory);
+	if (checkout === null) return EMPTY_SESSION_SCOPE;
+	if (event.kind === "branch") return await isBranchCreatedSince(checkout.commonDir, event.name, request.startedAt) ? {
+		...EMPTY_SESSION_SCOPE,
+		branches: [{
+			name: event.name,
+			commonDir: checkout.commonDir
+		}]
+	} : EMPTY_SESSION_SCOPE;
+	const remotes = await loadCheckoutRemotes(checkout.commonDir);
+	const repositories = new Set(remotes.map((remote) => toRepositorySlug(remote.url)));
+	const addresses = collectPullRequestAddresses(request.resultText).filter((address) => repositories.has(address.repository));
+	const pulls = await Promise.all(addresses.map(async (address) => {
+		const pull = await options.readPullRequest(address.repository, address.number);
+		return pull !== null && pull.createdAt >= request.startedAt - FORGE_CLOCK_SKEW_MS ? [{
+			...address,
+			head: pull.head
+		}] : [];
+	}));
+	return {
+		...EMPTY_SESSION_SCOPE,
+		pullRequests: pulls.flat()
+	};
+}
+async function isBranchCreatedSince(commonDir, branch, since) {
+	const createdAt = await readBranchCreatedAt(commonDir, branch);
+	if (createdAt === null || createdAt < Math.floor(since / 1e3) * 1e3) return false;
+	const ref = await stat(join(commonDir, "refs", "heads", branch)).catch(() => null);
+	return ref !== null && ref.mtimeMs >= since - FILE_CLOCK_SLACK_MS;
+}
+//#endregion
 //#region src/cli.ts
 const USAGE = `auto-mode — a permission classifier for the auto-mode Claude Code mod
 
 Usage:
   auto-mode run              Read an action request on stdin, write a verdict on stdout
   auto-mode print-prompt     Print the system prompt the classifier receives
+  auto-mode record           Read a finished Bash call on stdin, add what it created to the session's scope
 
 Options:
   --classifier <path>   Use this framework file instead of the shipped one
@@ -294,6 +580,29 @@ async function run(explain, localOnly, jevOnly, deadline) {
 		process.off("SIGINT", stopEvaluation);
 	}
 }
+async function runRecord() {
+	const raw = await readStdin();
+	let body;
+	try {
+		body = JSON.parse(raw);
+	} catch {
+		return 0;
+	}
+	const request = parseScopeRecordRequest(body);
+	if (request === null) return 0;
+	try {
+		const config = await loadConfig();
+		if (Object.values(config.scopeSources ?? DEFAULT_SCOPE_SOURCES).some((source) => source.kind === "session")) await updateSessionScope(request, {
+			now: Date.now(),
+			stateDir: resolveStateDir(),
+			home: homedir(),
+			readPullRequest
+		});
+	} catch {
+		process.stderr.write("auto-mode: session scope unavailable\n");
+	}
+	return 0;
+}
 async function tryWriteDenialState(path, state) {
 	try {
 		await writeDenialState(path, state);
@@ -339,6 +648,7 @@ async function main(argv) {
 		process.stderr.write("auto-mode: configuration unreadable; no verdict\n");
 		return 0;
 	}
+	if (command === "record") return runRecord();
 	if (command === "print-prompt") {
 		const config = await loadConfig();
 		printWarnings(config.warnings);

package/dist/get-edit-fields-BtAvHIsq.js

@@ -0,0 +1,20 @@
+//#region src/bypass/get-edit-fields.ts
+const EDIT_FIELDS = {
+	Edit: {
+		path: "file_path",
+		content: "new_string"
+	},
+	Write: {
+		path: "file_path",
+		content: "content"
+	},
+	NotebookEdit: {
+		path: "notebook_path",
+		content: "new_source"
+	}
+};
+function getEditFields(toolName) {
+	return EDIT_FIELDS[toolName] ?? null;
+}
+//#endregion
+export { getEditFields as t };

package/dist/index.d.ts

@@ -115,7 +115,7 @@ interface DecisionDiagnostics {
 }
 //#endregion
 //#region src/classify-action.d.ts
-type DecidingStage = 'local' | 'containment' | 'jev' | 'messages' | 'retry';
+type DecidingStage = 'local' | 'containment' | 'bypass' | 'jev' | 'messages' | 'retry';
 interface ActionOutcome {
   readonly verdict: Verdict | null;
   readonly decidingStage: DecidingStage;

package/dist/index.js

@@ -1,2 +1,2 @@
-import { a as classifyWithModel, c as DEFAULT_CONFIG, d as resolveApiKey, f as resolveConfigPath, i as classifyLocally, n as parseActionRequest, o as parseModelVerdict, p as PRESETS, r as classifyAction, s as loadPolicy, t as renderVerdict, u as loadConfig } from "./render-verdict-1xtCI2is.js";
+import { C as resolveConfigPath, S as resolveApiKey, d as classifyWithModel, f as parseModelVerdict, m as loadPolicy, n as parseActionRequest, r as classifyAction, t as renderVerdict, u as classifyLocally, v as DEFAULT_CONFIG, w as PRESETS, x as loadConfig } from "./render-verdict-FhSKxlO9.js";
 export { DEFAULT_CONFIG, PRESETS, classifyAction, classifyLocally, classifyWithModel, loadConfig, loadPolicy, parseActionRequest, parseModelVerdict, renderVerdict, resolveApiKey, resolveConfigPath };