assent-cli 0.0.0-stage → 0.6.0

package/dist/hook-ask.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_WAIT_SECONDS = exports.DEFAULT_WAIT_SECONDS = exports.DEFAULT_ASK_PATTERNS = void 0;
+exports.globMatches = globMatches;
+exports.wordTailMatcher = wordTailMatcher;
+exports.commandSegments = commandSegments;
+exports.canonicalWords = canonicalWords;
+exports.shellCandidates = shellCandidates;
+exports.askMatch = askMatch;
+exports.needsAssent = needsAssent;
+exports.hookAskSettings = hookAskSettings;
+exports.visible = visible;
+exports.askAssent = askAssent;
+const node_crypto_1 = require("node:crypto");
+const config_1 = require("./config");
+const exit_codes_1 = require("./exit-codes");
+const redact_1 = require("./redact");
+const shell_1 = require("./shell");
+exports.DEFAULT_ASK_PATTERNS = [
+    { tool: "Bash", target: "git push*" },
+    { tool: "Bash", target: "git reset --hard*" },
+    { tool: "Bash", target: "rm -r*" },
+    { tool: "Bash", target: "rm -fr*" },
+    { tool: "Bash", target: "*deploy*" },
+    { tool: "Bash", target: "npm publish*" },
+    { tool: "Bash", target: "terraform apply*" },
+    { tool: "Bash", target: "terraform destroy*" },
+    { tool: "Bash", target: "kubectl delete*" },
+    { tool: "Bash", target: "docker push*" },
+];
+exports.DEFAULT_WAIT_SECONDS = 120;
+exports.MAX_WAIT_SECONDS = 3600;
+const POLL_MS = 3000;
+const RULE_TARGET_MAX = 500;
+const RULE_ACTIONS = [{ id: "allow", label: "Allow", style: "primary" }, { id: "deny", label: "Block", style: "danger" }];
+const ONE_OFF_ACTIONS = [{ id: "allow", label: "Allow", style: "primary" }, { id: "block", label: "Block", style: "secondary" }];
+const SEGMENT_BREAK = /&&|\|\||\$\(|[;&|\n\r`(){}]/;
+const GIT_OPTIONS_WITH_VALUE = new Set(["-C", "-c", "--git-dir", "--work-tree", "--namespace", "--config-env", "--super-prefix"]);
+const RECURSIVE_RM_FLAG = /^(?:-[A-Za-z]*r[A-Za-z]*|--recursive)$/i;
+const DISPLAY_LIMIT = 4000;
+const HIDDEN_CHARACTERS = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f\u00ad\u061c\u180e\u200b-\u200f\u2028\u2029\u202a-\u202e\u2060-\u2064\u2066-\u2069\ufeff\ufff9-\ufffb\u{e0000}-\u{e007f}]/gu;
+const LEADING_ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=\S*\s+/;
+const LEADING_WRAPPER = /^(?:sudo|env|command|exec|nohup|time)\s+/i;
+const REGEX_SPECIAL = /[.*+?^${}()|[\]\\]/g;
+function normalise(text) {
+    return text.trim().replace(/\s+/g, " ");
+}
+function globSource(pattern) {
+    let source = "";
+    const chars = [...normalise(pattern)];
+    for (let i = 0; i < chars.length; i++) {
+        const ch = chars[i];
+        if (ch === "\\" && i + 1 < chars.length)
+            source += chars[++i].replace(REGEX_SPECIAL, "\\$&");
+        else
+            source += ch === "*" ? ".*" : ch.replace(REGEX_SPECIAL, "\\$&");
+    }
+    return source;
+}
+function globMatches(pattern, value) {
+    return new RegExp(`^${globSource(pattern)}$`, "is").test(normalise(value));
+}
+function wordTailMatcher(pattern) {
+    const source = globSource(pattern);
+    return normalise(pattern).startsWith("*") ? new RegExp(`^${source}$`, "is") : new RegExp(`(?:^| )(?:${source})$`, "is");
+}
+function bareCommand(segment) {
+    let current = segment.trim();
+    for (let previous = ""; previous !== current;) {
+        previous = current;
+        current = current.replace(LEADING_ASSIGNMENT, "").replace(LEADING_WRAPPER, "");
+    }
+    return current;
+}
+function commandSegments(command) {
+    return command.split(SEGMENT_BREAK).map(bareCommand).filter((segment) => segment.length > 0);
+}
+function baseName(word) {
+    const slash = word.lastIndexOf("/");
+    return slash >= 0 && slash < word.length - 1 ? word.slice(slash + 1) : word;
+}
+function canonicalWords(words) {
+    const recursive = words.some((w) => RECURSIVE_RM_FLAG.test(w));
+    const out = [];
+    for (let i = 0; i < words.length; i++) {
+        const word = baseName(words[i]);
+        out.push(word);
+        if (word === "git") {
+            while (i + 1 < words.length && words[i + 1].startsWith("-"))
+                i += GIT_OPTIONS_WITH_VALUE.has(words[i + 1]) ? 2 : 1;
+        }
+        if (word === "rm" && recursive)
+            out.push("-r");
+    }
+    return out;
+}
+function shellCandidates(command) {
+    const unquoted = command.replace(/["'\\]/g, "");
+    const segments = [command, unquoted].flatMap(commandSegments).map(normalise);
+    return [...segments.flatMap((segment) => [segment, canonicalWords(segment.split(" ")).join(" ")]), normalise(command), normalise(unquoted)];
+}
+function askMatch(patterns, tool, raw) {
+    const shell = (0, shell_1.isShellTool)(tool);
+    const candidates = shell ? shellCandidates(raw) : [raw];
+    for (const p of patterns) {
+        if (!globMatches(p.tool, tool))
+            continue;
+        if (p.target === undefined)
+            return raw;
+        const matcher = shell ? wordTailMatcher(p.target) : new RegExp(`^${globSource(p.target)}$`, "is");
+        const hit = candidates.find((c) => matcher.test(shell ? c : normalise(c)));
+        if (hit !== undefined)
+            return hit;
+    }
+    return null;
+}
+function needsAssent(patterns, tool, raw) {
+    return askMatch(patterns, tool, raw) !== null;
+}
+function invalid(message) {
+    throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `hook settings: ${message}`);
+}
+function parsePattern(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        invalid("each hook.ask entry must be an object like {\"tool\": \"Bash\", \"target\": \"git push*\"}");
+    const { tool, target } = value;
+    if (typeof tool !== "string" || !tool.trim())
+        invalid("each hook.ask entry needs a tool, for example \"Bash\" or \"mcp__*\"");
+    if (target !== undefined && (typeof target !== "string" || !target.trim()))
+        invalid("hook.ask target must be a non-empty pattern when given");
+    return target === undefined ? { tool } : { tool, target };
+}
+function parseWait(seconds, from) {
+    if (typeof seconds !== "number" || !Number.isInteger(seconds) || seconds < 1 || seconds > exports.MAX_WAIT_SECONDS)
+        invalid(`${from} must be a whole number of seconds from 1 to ${exports.MAX_WAIT_SECONDS}`);
+    return seconds;
+}
+function hookAskSettings(file, env) {
+    const hook = file.hook === undefined ? {} : file.hook;
+    if (hook === null || typeof hook !== "object" || Array.isArray(hook))
+        invalid("hook must be an object");
+    const { ask, waitSeconds } = hook;
+    if (ask !== undefined && !Array.isArray(ask))
+        invalid("hook.ask must be a list of {tool, target} patterns");
+    const envWait = (0, config_1.assentEnv)(env, "HOOK_WAIT_SECONDS");
+    return {
+        patterns: ask === undefined ? exports.DEFAULT_ASK_PATTERNS : ask.map(parsePattern),
+        waitSeconds: envWait !== undefined ? parseWait(Number(envWait), "ASSENT_HOOK_WAIT_SECONDS") : waitSeconds === undefined ? exports.DEFAULT_WAIT_SECONDS : parseWait(waitSeconds, "hook.waitSeconds"),
+    };
+}
+function waitLabel(seconds) {
+    return seconds % 60 === 0 ? `${seconds / 60} minute${seconds === 60 ? "" : "s"}` : `${seconds} seconds`;
+}
+function chosenAction(task) {
+    const answer = task.answer;
+    return typeof answer?.actionId === "string" ? answer.actionId : undefined;
+}
+function answerExpired(task, now) {
+    return task.answerExpiresAt !== null && Date.parse(task.answerExpiresAt) <= now;
+}
+async function quietly(work) {
+    try {
+        await work();
+    }
+    catch {
+        return;
+    }
+}
+function ruleable(call) {
+    return call.exact && call.target.replace(/[\\*]/g, "\\$&").length <= RULE_TARGET_MAX;
+}
+function visible(text) {
+    return text.replace(HIDDEN_CHARACTERS, "\ufffd");
+}
+function askDetail(call) {
+    return [
+        `Matched: ${visible((0, redact_1.redactSecrets)(call.matched))}`,
+        `Full ${(0, shell_1.isShellTool)(call.tool) ? "command" : "target"}:`,
+        visible(call.target),
+        `Summary: ${visible(call.summary)}`,
+        call.cwd ? `Working directory: ${visible((0, redact_1.redact)(call.cwd))}` : "",
+    ].filter(Boolean).join("\n");
+}
+function sameAsk(task, call, rules) {
+    if (task.created === false || task.deduped === true || task.kind !== "approve")
+        return false;
+    return !rules || (task.action === call.tool && task.target === call.target);
+}
+function withdraw(api, uuid, note) {
+    return quietly(() => api.resolve(uuid, { outcome: "withdrawn", note }));
+}
+async function waitForAnswer(api, clock, task, waitSeconds) {
+    const deadline = clock.now() + waitSeconds * 1000;
+    let current = task;
+    try {
+        while (current.status === "open") {
+            if (clock.now() >= deadline || answerExpired(current, clock.now())) {
+                await withdraw(api, current.uuid, "No answer in time, so the tool call was blocked");
+                return null;
+            }
+            await clock.sleep(Math.min(POLL_MS, deadline - clock.now()));
+            current = await api.task(current.uuid);
+        }
+    }
+    catch (err) {
+        await withdraw(api, task.uuid, "Assent could not be reached while waiting, so the tool call was blocked");
+        throw err;
+    }
+    return current;
+}
+async function askAssent(api, clock, call, waitSeconds) {
+    if ((0, redact_1.redactSecrets)(call.raw).length > DISPLAY_LIMIT)
+        return { decision: "deny", reason: "This call is too long to show in full in Assent, so it was blocked. Split it into smaller steps." };
+    const rules = ruleable(call);
+    const task = await api.ask({
+        kind: "approve",
+        title: `Allow ${call.tool}: ${visible(call.target).replace(/\s+/g, " ")}`.slice(0, 500),
+        question: "Let Claude Code make this tool call?",
+        why: `Claude Code is paused on this call and blocks it if there is no answer within ${waitLabel(waitSeconds)}.`,
+        detail: askDetail(call),
+        actions: rules ? RULE_ACTIONS : ONE_OFF_ACTIONS,
+        allowDuplicate: true,
+        ...(rules ? { action: call.tool, target: call.target } : {}),
+    }, (0, node_crypto_1.randomUUID)());
+    if (!sameAsk(task, call, rules)) {
+        if (task.created !== false)
+            await withdraw(api, task.uuid, "Assent returned a different ask, so the tool call was blocked");
+        return { decision: "deny", reason: "Assent matched this call to a different ask, so it was blocked. Ask the person before trying again." };
+    }
+    const current = await waitForAnswer(api, clock, task, waitSeconds);
+    if (current === null)
+        return { decision: "deny", reason: `No answer in Assent within ${waitLabel(waitSeconds)}, so the call was blocked. Ask the person before trying again.` };
+    const answered = current.status === "answered" || current.status === "done";
+    if (current.status === "answered")
+        await quietly(() => api.pickedUp(current.uuid));
+    if (answered && chosenAction(current) === "allow")
+        return { decision: "allow", reason: "Allowed in Assent" };
+    if (answered)
+        return { decision: "deny", reason: "Blocked in Assent. Do not retry it; ask the person what to do instead." };
+    return { decision: "deny", reason: `The Assent ask was ${current.status}, so the call was blocked` };
+}

package/dist/hook.d.ts

@@ -0,0 +1,20 @@
+import { FetchLike } from "./client";
+export type HookDecision = "allow" | "deny" | "ask";
+export interface HookDeps {
+    env: NodeJS.ProcessEnv;
+    home: string;
+    readFile(path: string): string | null;
+    readStdin(): Promise<string>;
+    stdout(line: string): void;
+    sleep(ms: number): Promise<void>;
+    now(): number;
+    fetchImpl?: FetchLike;
+}
+export declare function resolvedPath(path: string, cwd?: string): string;
+export declare function denyCheckPath(tool: string, raw: string, cwd?: string): string | null;
+export declare function hookRawTarget(tool: string, input: Record<string, unknown>, cwd?: string): string;
+export declare function hookTarget(tool: string, input: Record<string, unknown>, cwd?: string): string;
+export declare function exactTarget(tool: string, raw: string): boolean;
+export declare function hookSummary(tool: string, input: Record<string, unknown>, target: string): string;
+export declare function hookOutput(decision: HookDecision, reason: string): string;
+export declare function runHook(argv: string[], deps: HookDeps): Promise<number>;

package/dist/hook.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvedPath = resolvedPath;
+exports.denyCheckPath = denyCheckPath;
+exports.hookRawTarget = hookRawTarget;
+exports.hookTarget = hookTarget;
+exports.exactTarget = exactTarget;
+exports.hookSummary = hookSummary;
+exports.hookOutput = hookOutput;
+exports.runHook = runHook;
+const node_path_1 = require("node:path");
+const client_1 = require("./client");
+const config_1 = require("./config");
+const hook_ask_1 = require("./hook-ask");
+const redact_1 = require("./redact");
+const shell_1 = require("./shell");
+const DEFAULT_HOOK_TIMEOUT_MS = 3000;
+const TARGET_LIMIT = 4000;
+const SUMMARY_LIMIT = 200;
+const ACTION_NAME = /^[A-Za-z0-9:._/@+-]{1,120}$/;
+const PATH_TOOLS = new Set(["Edit", "Write", "Read", "MultiEdit", "NotebookEdit"]);
+const PARENT_SEGMENT = /(?:^|\/)\.\.(?:\/|$)/;
+const ASK_REQUEST_TIMEOUT_MS = 5000;
+const UNINSTALLED_MAX_WAIT_SECONDS = 45;
+const INSPECT_LIMIT = 65536;
+function field(input, ...names) {
+    for (const name of names) {
+        const value = input[name];
+        if (typeof value === "string" && value)
+            return value;
+    }
+    return undefined;
+}
+function normalisedPath(path, cwd) {
+    if (node_path_1.posix.isAbsolute(path) || !cwd || !node_path_1.posix.isAbsolute(cwd))
+        return node_path_1.posix.normalize(path);
+    return node_path_1.posix.resolve(cwd, path);
+}
+function resolvedPath(path, cwd) {
+    return PARENT_SEGMENT.test(path) ? path : normalisedPath(path, cwd);
+}
+function denyCheckPath(tool, raw, cwd) {
+    if (!PATH_TOOLS.has(tool) || !PARENT_SEGMENT.test(raw))
+        return null;
+    const normal = normalisedPath(raw, cwd);
+    return normal === raw ? null : normal;
+}
+function hookRawTarget(tool, input, cwd) {
+    const path = PATH_TOOLS.has(tool) ? field(input, "file_path", "notebook_path") : undefined;
+    const direct = tool === "Bash" ? field(input, "command")
+        : path !== undefined ? resolvedPath(path, cwd)
+            : tool === "WebFetch" ? field(input, "url")
+                : tool === "WebSearch" ? field(input, "query")
+                    : undefined;
+    return direct ?? JSON.stringify(input);
+}
+function hookTarget(tool, input, cwd) {
+    return (0, redact_1.redactSecrets)(hookRawTarget(tool, input, cwd)).slice(0, TARGET_LIMIT);
+}
+function exactPath(tool, raw) {
+    return !PATH_TOOLS.has(tool) || (node_path_1.posix.isAbsolute(raw) && !PARENT_SEGMENT.test(raw));
+}
+function exactTarget(tool, raw) {
+    return raw.length <= TARGET_LIMIT && (0, redact_1.redactSecrets)(raw) === raw && (!(0, shell_1.isShellTool)(tool) || (0, shell_1.isSimpleCommand)(raw)) && exactPath(tool, raw);
+}
+function hookSummary(tool, input, target) {
+    const described = field(input, "description");
+    return (0, redact_1.redact)(described ?? `${tool} ${target}`).slice(0, SUMMARY_LIMIT);
+}
+function hookOutput(decision, reason) {
+    return JSON.stringify({ hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: decision, permissionDecisionReason: reason } });
+}
+function hookTimeout(env) {
+    const value = Number((0, config_1.assentEnv)(env, "HOOK_TIMEOUT_MS"));
+    return Number.isInteger(value) && value > 0 ? value : DEFAULT_HOOK_TIMEOUT_MS;
+}
+function parseEvent(raw) {
+    try {
+        const event = JSON.parse(raw);
+        const tool = event?.tool_name;
+        const input = event?.tool_input;
+        if (typeof tool !== "string" || !ACTION_NAME.test(tool))
+            return null;
+        return { tool, input: input !== null && typeof input === "object" && !Array.isArray(input) ? input : {}, ...(typeof event.cwd === "string" ? { cwd: event.cwd } : {}) };
+    }
+    catch {
+        return null;
+    }
+}
+function reasonFor(decision, label, reason) {
+    if (decision === "ask")
+        return "No Assent rule covers this action";
+    const rule = `${decision === "allow" ? "Allowed" : "Blocked"} by Assent rule: ${label ?? "unnamed rule"}`;
+    return reason ? `${rule}. ${reason}` : rule;
+}
+function sources(deps) {
+    return { env: deps.env, home: deps.home, readFile: deps.readFile, exists: (path) => deps.readFile(path) !== null };
+}
+function agentApi(deps, maxTimeoutMs = Infinity) {
+    return client_1.AgentApi.fromConfig({ ...(0, config_1.loadCliConfig)(sources(deps)), timeoutMs: Math.min(hookTimeout(deps.env), maxTimeoutMs) }, deps.fetchImpl);
+}
+function maxWait(flags) {
+    const at = flags.indexOf("--max-wait");
+    if (at < 0)
+        return UNINSTALLED_MAX_WAIT_SECONDS;
+    const seconds = Number(flags[at + 1]);
+    return Number.isInteger(seconds) && seconds > 0 ? seconds : "--max-wait needs a whole number of seconds";
+}
+async function normalisedDeny(api, event) {
+    const normal = denyCheckPath(event.tool, hookRawTarget(event.tool, event.input, event.cwd), event.cwd);
+    if (normal === null)
+        return null;
+    const target = (0, redact_1.redactSecrets)(normal).slice(0, TARGET_LIMIT);
+    const result = await api.rulesCheck({ action: event.tool, target, summary: hookSummary(event.tool, event.input, target) });
+    return result.decision === "deny" ? result : null;
+}
+async function checkRules(api, event) {
+    const target = hookTarget(event.tool, event.input, event.cwd);
+    const first = await api.rulesCheck({ action: event.tool, target, summary: hookSummary(event.tool, event.input, target) });
+    const result = first.decision === "deny" ? first : (await normalisedDeny(api, event)) ?? first;
+    const decision = result.decision === "allow" || result.decision === "deny" ? result.decision : "ask";
+    if (decision === "allow" && !exactTarget(event.tool, hookRawTarget(event.tool, event.input, event.cwd)))
+        return { decision: "ask", reason: "An Assent rule allows this, but the command is chained, too long or holds a secret, so asking" };
+    return { decision, reason: reasonFor(decision, result.label, result.reason) };
+}
+function askSettings(deps) {
+    try {
+        return (0, hook_ask_1.hookAskSettings)((0, config_1.readConfigFile)(sources(deps)), deps.env);
+    }
+    catch (err) {
+        return err.message;
+    }
+}
+async function guarded(deps, event, flags) {
+    const settings = askSettings(deps);
+    if (typeof settings === "string")
+        return { decision: "deny", reason: `Assent cannot read its hook settings (${settings}), so the call was blocked` };
+    const limit = maxWait(flags);
+    if (typeof limit === "string")
+        return { decision: "deny", reason: `Assent cannot read its hook settings (${limit}), so the call was blocked` };
+    const raw = hookRawTarget(event.tool, event.input, event.cwd);
+    if ((0, shell_1.isShellTool)(event.tool) && raw.length > INSPECT_LIMIT)
+        return { decision: "deny", reason: "This command is too long for Assent to inspect, so it was blocked. Split it into smaller steps." };
+    const matched = (0, hook_ask_1.askMatch)(settings.patterns, event.tool, raw);
+    if (matched === null)
+        return checkRules(agentApi(deps), event);
+    try {
+        const api = agentApi(deps, ASK_REQUEST_TIMEOUT_MS);
+        const checked = await checkRules(api, event);
+        if (checked.decision !== "ask")
+            return checked;
+        const target = hookTarget(event.tool, event.input, event.cwd);
+        const call = { tool: event.tool, raw, target, matched, summary: hookSummary(event.tool, event.input, target), exact: exactTarget(event.tool, raw), cwd: event.cwd };
+        return await (0, hook_ask_1.askAssent)(api, deps, call, Math.min(settings.waitSeconds, limit));
+    }
+    catch (err) {
+        return { decision: "deny", reason: `Assent is unavailable (${err.message}), so the call was blocked` };
+    }
+}
+async function decide(deps, flags) {
+    const event = parseEvent(await deps.readStdin());
+    if (!event)
+        return { decision: "ask", reason: "Assent could not read this tool call, so asking" };
+    return flags.includes("--ask") ? guarded(deps, event, flags) : checkRules(agentApi(deps), event);
+}
+async function runHook(argv, deps) {
+    const [name, ...flags] = argv;
+    let outcome;
+    try {
+        outcome = name === "pre-tool-use" ? await decide(deps, flags) : { decision: "ask", reason: `Unknown Assent hook ${name ?? ""}, use hook pre-tool-use` };
+    }
+    catch (err) {
+        outcome = { decision: "ask", reason: `Assent is unavailable (${err.message}), so asking` };
+    }
+    deps.stdout(hookOutput(outcome.decision, outcome.reason));
+    return 0;
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { EXIT, CliError, exitCodeForStatus } from "./exit-codes";
+export type { ExitCode } from "./exit-codes";
+export { redact } from "./redact";
+export { assentEnv, configPath, DEFAULT_API_URL, loadCliConfig, readFileOrNull } from "./config";
+export type { CliConfig, ConfigSources } from "./config";
+export { HttpClient, AgentApi, defaultFetch } from "./client";
+export type { FetchLike, FetchInit, FetchResponse, HttpOptions, TaskView, LockResult, AskBody } from "./client";
+export { parseCommandArgs } from "./args";
+export type { OptionSpec, Parsed } from "./args";
+export { USAGE, VERSION } from "./usage";

package/dist/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = exports.USAGE = exports.parseCommandArgs = exports.defaultFetch = exports.AgentApi = exports.HttpClient = exports.readFileOrNull = exports.loadCliConfig = exports.DEFAULT_API_URL = exports.configPath = exports.assentEnv = exports.redact = exports.exitCodeForStatus = exports.CliError = exports.EXIT = void 0;
+var exit_codes_1 = require("./exit-codes");
+Object.defineProperty(exports, "EXIT", { enumerable: true, get: function () { return exit_codes_1.EXIT; } });
+Object.defineProperty(exports, "CliError", { enumerable: true, get: function () { return exit_codes_1.CliError; } });
+Object.defineProperty(exports, "exitCodeForStatus", { enumerable: true, get: function () { return exit_codes_1.exitCodeForStatus; } });
+var redact_1 = require("./redact");
+Object.defineProperty(exports, "redact", { enumerable: true, get: function () { return redact_1.redact; } });
+var config_1 = require("./config");
+Object.defineProperty(exports, "assentEnv", { enumerable: true, get: function () { return config_1.assentEnv; } });
+Object.defineProperty(exports, "configPath", { enumerable: true, get: function () { return config_1.configPath; } });
+Object.defineProperty(exports, "DEFAULT_API_URL", { enumerable: true, get: function () { return config_1.DEFAULT_API_URL; } });
+Object.defineProperty(exports, "loadCliConfig", { enumerable: true, get: function () { return config_1.loadCliConfig; } });
+Object.defineProperty(exports, "readFileOrNull", { enumerable: true, get: function () { return config_1.readFileOrNull; } });
+var client_1 = require("./client");
+Object.defineProperty(exports, "HttpClient", { enumerable: true, get: function () { return client_1.HttpClient; } });
+Object.defineProperty(exports, "AgentApi", { enumerable: true, get: function () { return client_1.AgentApi; } });
+Object.defineProperty(exports, "defaultFetch", { enumerable: true, get: function () { return client_1.defaultFetch; } });
+var args_1 = require("./args");
+Object.defineProperty(exports, "parseCommandArgs", { enumerable: true, get: function () { return args_1.parseCommandArgs; } });
+var usage_1 = require("./usage");
+Object.defineProperty(exports, "USAGE", { enumerable: true, get: function () { return usage_1.USAGE; } });
+Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return usage_1.VERSION; } });

package/dist/mcp-bridge.d.ts

@@ -0,0 +1,11 @@
+import { FetchLike } from "./client";
+export interface BridgeDeps {
+    env: NodeJS.ProcessEnv;
+    home: string;
+    readFile(path: string): string | null;
+    stdout(line: string): void;
+    stderr(line: string): void;
+    stdinLines(): AsyncIterable<string>;
+    fetchImpl?: FetchLike;
+}
+export declare function runMcpBridge(deps: BridgeDeps): Promise<number>;

package/dist/mcp-bridge.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMcpBridge = runMcpBridge;
+const client_1 = require("./client");
+const config_1 = require("./config");
+const exit_codes_1 = require("./exit-codes");
+const BRIDGE_TIMEOUT_MS = 90000;
+const API_VERSION_SUFFIX = /\/api\/v1$/;
+const PARSE_ERROR = -32700;
+const SERVER_ERROR = -32000;
+function requestId(message) {
+    if (message === null || typeof message !== "object" || Array.isArray(message) || !("id" in message))
+        return undefined;
+    const id = message.id;
+    return typeof id === "string" || typeof id === "number" ? id : null;
+}
+function rpcError(id, code, message) {
+    return JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } });
+}
+function parsed(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isRpc(body) {
+    return Array.isArray(body) || (body !== null && typeof body === "object" && "jsonrpc" in body);
+}
+function failure(status, body, text) {
+    const message = body !== null && typeof body === "object" && typeof body.message === "string" ? body.message : text.slice(0, 300);
+    return `Assent returned ${status}${message ? `: ${message}` : ""}`;
+}
+async function post(url, agentKey, line, fetchImpl) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), BRIDGE_TIMEOUT_MS);
+    try {
+        const response = await fetchImpl(url, {
+            method: "POST",
+            headers: { accept: "application/json, text/event-stream", "content-type": "application/json", "x-ordia-agent-key": agentKey },
+            body: line,
+            signal: controller.signal,
+            redirect: "error",
+        });
+        return { status: response.status, text: (await response.text()).trim() };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function forward(line, url, agentKey, deps) {
+    const message = parsed(line);
+    if (message === undefined) {
+        deps.stdout(rpcError(null, PARSE_ERROR, "Parse error"));
+        return;
+    }
+    const id = requestId(message);
+    let problem;
+    try {
+        const { status, text } = await post(url, agentKey, line, deps.fetchImpl ?? client_1.defaultFetch);
+        const body = text ? parsed(text) : undefined;
+        if (isRpc(body)) {
+            deps.stdout(JSON.stringify(body));
+            return;
+        }
+        if (status < 400 && !text)
+            return;
+        problem = status < 400 ? "Assent sent a response that is not JSON-RPC" : failure(status, body, text);
+    }
+    catch (err) {
+        problem = `Assent is unreachable at ${url}: ${err.message}`;
+    }
+    if (id === undefined)
+        deps.stderr(JSON.stringify({ error: problem }));
+    else
+        deps.stdout(rpcError(id, SERVER_ERROR, problem));
+}
+async function runMcpBridge(deps) {
+    const sources = { env: deps.env, home: deps.home, readFile: deps.readFile, exists: (path) => deps.readFile(path) !== null };
+    let config;
+    try {
+        config = (0, config_1.loadCliConfig)(sources);
+    }
+    catch (err) {
+        const { message, exitCode } = err;
+        deps.stderr(JSON.stringify({ error: message, exitCode, status: null }));
+        return exitCode;
+    }
+    const url = `${config.apiUrl.replace(API_VERSION_SUFFIX, "")}/api/v1/mcp`;
+    const pending = new Set();
+    for await (const line of deps.stdinLines()) {
+        if (!line.trim())
+            continue;
+        const job = forward(line, url, config.agentKey, deps).finally(() => pending.delete(job));
+        pending.add(job);
+    }
+    await Promise.all(pending);
+    return exit_codes_1.EXIT.ok;
+}

package/dist/redact.d.ts

@@ -0,0 +1,2 @@
+export declare function redactSecrets(text: string): string;
+export declare function redact(text: string): string;

package/dist/redact.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redactSecrets = redactSecrets;
+exports.redact = redact;
+const EMAIL_LOCAL = "[A-Za-z0-9._%+-]";
+const EMAIL_DOMAIN = "(?:[A-Za-z0-9-]{1,63}\\.){1,10}[A-Za-z]{2,63}";
+const RULES = [
+    [/-----BEGIN [A-Z ]{0,40}PRIVATE KEY-----[\s\S]{0,20000}?(?:-----END [A-Z ]{0,40}PRIVATE KEY-----|$)/g, "[key]"],
+    [/\b([a-z][a-z0-9+.-]{1,20}:\/\/)[^\s\/@:]{1,256}:[^\s\/@]{1,256}@/gi, "$1[redacted]@"],
+    [/\bBasic\s{1,64}[A-Za-z0-9+\/=]{8,}/g, "Basic [token]"],
+    [/(--(?:password|passwd|token|secret|api-key|apikey|access-token|auth-token|client-secret)(?:=|\s{1,16}))(?:"[^"\n]{0,512}"|'[^'\n]{0,512}'|[^\s"']+)/gi, "$1[redacted]"],
+    [/(?<![A-Za-z0-9_-])([A-Za-z0-9_-]{0,60}[_-](?:key|secret|token|password|passwd|pwd))(["']?\s{0,16}[:=]\s{0,16})(?:"[^"\n]{0,512}"|'[^'\n]{0,512}'|["']?[^\s"',;&]+)/gi, "$1$2[redacted]"],
+    [/(?<![A-Za-z0-9])(?:github_pat_[A-Za-z0-9_]{20,}|gh[sur]_[A-Za-z0-9]{20,}|glpat-[A-Za-z0-9_-]{20,}|xox[abprs]-[A-Za-z0-9-]{10,}|npm_[A-Za-z0-9]{36}|AIza[0-9A-Za-z_-]{35})/g, "[key]"],
+    [/(?<![A-Za-z0-9_-])eyJ(?=([A-Za-z0-9_-]{8,}))\1\.(?=([A-Za-z0-9_-]{8,}))\2\.[A-Za-z0-9_-]*/g, "[token]"],
+    [new RegExp(`(?<!${EMAIL_LOCAL})(?=(${EMAIL_LOCAL}+))\\1@${EMAIL_DOMAIN}(?:(?=(${EMAIL_LOCAL}*))\\2@${EMAIL_DOMAIN})*`, "g"), "[email]"],
+    [/Bearer\s{1,64}[A-Za-z0-9._~+\/=-]+/gi, "Bearer [token]"],
+    [/(?<![A-Za-z0-9])(password|passwd|secret|token|api_key)(["']?\s{0,16}[:=]\s{0,16})(?:"[^"\n]{0,512}"|'[^'\n]{0,512}'|["']?[^\s"',;&]+)/gi, "$1$2[redacted]"],
+    [/(?<![A-Za-z0-9])(ztk|oak|ock|lck|pps|ubk|inv|ghp|gho|vcp|svk|sva|ubrt|wfr)_[A-Za-z0-9_-]{6,}/g, "[key]"],
+    [/(?<![A-Za-z0-9])sk_(?:live|test)_[A-Za-z0-9]{8,}/g, "[key]"],
+    [/(?<![A-Za-z0-9_])sk-[A-Za-z0-9_-]{10,}/g, "[key]"],
+    [/(?<![A-Za-z0-9])FLWSECK(?:_TEST)?[-_]?[A-Za-z0-9-]{8,}/g, "[key]"],
+    [/(?<![A-Za-z0-9])(?:AKIA|ASIA)[A-Z0-9]{16}(?![A-Za-z0-9])/g, "[key]"],
+    [/(?<!\d)(?:(?:\+44|0044)[\s-]?(?:\(0\)[\s-]?)?|0)7\d{3}[\s-]?\d{3}[\s-]?\d{3}(?!\d)/g, "[phone]"],
+    [/(?<![A-Za-z0-9_])(?=([a-f0-9]{32,}))\1(?![A-Za-z0-9_])/gi, "[hash]"],
+];
+const HOME_PATH = /\/Users\/[^\/\s]+/g;
+function redactSecrets(text) {
+    return RULES.reduce((acc, [pattern, replacement]) => acc.replace(pattern, replacement), text);
+}
+function redact(text) {
+    return redactSecrets(text).replace(HOME_PATH, "~");
+}

package/dist/shell.d.ts

@@ -0,0 +1,2 @@
+export declare function isShellTool(name: string): boolean;
+export declare function isSimpleCommand(command: string): boolean;

package/dist/shell.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isShellTool = isShellTool;
+exports.isSimpleCommand = isSimpleCommand;
+const SHELL_TOOLS = /^(bash|sh|zsh|shell|powershell|exec|exec_command|run_shell_command|run_terminal_cmd)$/i;
+const SHELL_CONTROL = /[;&|`$<>()\n\r]/;
+function isShellTool(name) {
+    return SHELL_TOOLS.test(name);
+}
+function isSimpleCommand(command) {
+    return command.trim().length > 0 && !SHELL_CONTROL.test(command);
+}

package/dist/usage.d.ts

@@ -0,0 +1,5 @@
+export declare const VERSION = "0.6.0";
+export declare const COMMAND = "assent";
+export declare const LEGACY_COMMAND = "ordia";
+export declare function usage(command: string): string;
+export declare const USAGE: string;