@lucascouts/claude-agent-acp-plus 0.8.1 → 0.9.0

package/dist/permissions/normalization.js

@@ -0,0 +1,100 @@
+const MAX_UPDATES = 100;
+const MAX_RULES_PER_UPDATE = 100;
+const MAX_DIRECTORIES_PER_UPDATE = 100;
+const MAX_TOOL_NAME_LENGTH = 512;
+const MAX_RULE_CONTENT_LENGTH = 10_000;
+const MAX_DIRECTORY_LENGTH = 4_096;
+const DESTINATIONS = new Set([
+    "session",
+    "cliArg",
+    "userSettings",
+    "projectSettings",
+    "localSettings",
+]);
+const BEHAVIORS = new Set(["allow", "deny", "ask"]);
+const MODES = new Set([
+    "default",
+    "acceptEdits",
+    "bypassPermissions",
+    "plan",
+    "dontAsk",
+    "auto",
+]);
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isDestination(value) {
+    return typeof value === "string" && DESTINATIONS.has(value);
+}
+function safePlainString(value, maxLength) {
+    if (typeof value !== "string")
+        return false;
+    const normalized = value.trim();
+    return (normalized.length > 0 &&
+        value.length <= maxLength &&
+        !Array.from(normalized).some((character) => {
+            const code = character.charCodeAt(0);
+            return (code <= 0x08 ||
+                code === 0x0b ||
+                code === 0x0c ||
+                (code >= 0x0e && code <= 0x1f) ||
+                code === 0x7f);
+        }));
+}
+function isRule(value) {
+    if (!isRecord(value) || !safePlainString(value.toolName, MAX_TOOL_NAME_LENGTH)) {
+        return false;
+    }
+    return (value.ruleContent === undefined || safePlainString(value.ruleContent, MAX_RULE_CONTENT_LENGTH));
+}
+function isKnownUpdate(value) {
+    if (!isRecord(value) || !isDestination(value.destination) || typeof value.type !== "string") {
+        return false;
+    }
+    switch (value.type) {
+        case "addRules":
+        case "replaceRules":
+        case "removeRules":
+            return (Array.isArray(value.rules) &&
+                value.rules.length <= MAX_RULES_PER_UPDATE &&
+                (value.type === "replaceRules" || value.rules.length > 0) &&
+                value.rules.every(isRule) &&
+                typeof value.behavior === "string" &&
+                BEHAVIORS.has(value.behavior));
+        case "setMode":
+            return typeof value.mode === "string" && MODES.has(value.mode);
+        case "addDirectories":
+        case "removeDirectories":
+            return (Array.isArray(value.directories) &&
+                value.directories.length > 0 &&
+                value.directories.length <= MAX_DIRECTORIES_PER_UPDATE &&
+                value.directories.every((directory) => safePlainString(directory, MAX_DIRECTORY_LENGTH)));
+        default:
+            return false;
+    }
+}
+export function normalizeDurablePermissionChangeSet(suggestions, forcedAsk = false) {
+    if (forcedAsk)
+        return undefined;
+    try {
+        if (!Array.isArray(suggestions) ||
+            suggestions.length === 0 ||
+            suggestions.length > MAX_UPDATES ||
+            !suggestions.every(isKnownUpdate)) {
+            return undefined;
+        }
+        return {
+            // The ACP prompt may stay open for an arbitrary amount of time. Snapshot the
+            // provider payload so the label the user approved and the effect returned to
+            // Claude cannot diverge through later mutation of the callback argument.
+            updates: structuredClone(suggestions),
+        };
+    }
+    catch {
+        // SDK data is expected to be plain structured-cloneable input. Treat an
+        // accessor, function, proxy, or other non-wire value as an invalid bundle.
+        // Validation belongs in this boundary too because merely reading one of those
+        // values can throw before structuredClone gets a chance to reject it.
+        return undefined;
+    }
+}

package/dist/permissions/options/filesystem.d.ts

@@ -0,0 +1,9 @@
+import type { PermissionOption } from "@agentclientprotocol/sdk";
+import { type PermissionOptionContext } from "./shared.js";
+export declare function buildReadPermissionOptions(context: PermissionOptionContext): PermissionOption[];
+export declare function buildGlobPermissionOptions(context: PermissionOptionContext): PermissionOption[];
+export declare function buildGrepPermissionOptions(context: PermissionOptionContext): PermissionOption[];
+export declare function buildEditPermissionOptions(context: PermissionOptionContext): PermissionOption[];
+export declare function buildWritePermissionOptions(context: PermissionOptionContext): PermissionOption[];
+export declare function buildNotebookEditPermissionOptions(context: PermissionOptionContext): PermissionOption[];
+//# sourceMappingURL=filesystem.d.ts.map

package/dist/permissions/options/filesystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem.d.ts","sourceRoot":"","sources":["../../../src/permissions/options/filesystem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAIjE,OAAO,EAAe,KAAK,uBAAuB,EAAsB,MAAM,aAAa,CAAC;AA6J5F,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,uBAAuB,GAAG,gBAAgB,EAAE,CAE/F;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,uBAAuB,GAAG,gBAAgB,EAAE,CAE/F;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,uBAAuB,GAAG,gBAAgB,EAAE,CAE/F;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,uBAAuB,GAAG,gBAAgB,EAAE,CAE/F;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,uBAAuB,GAAG,gBAAgB,EAAE,CAEhG;AAED,wBAAgB,kCAAkC,CAChD,OAAO,EAAE,uBAAuB,GAC/B,gBAAgB,EAAE,CAEpB"}

package/dist/permissions/options/filesystem.js

@@ -0,0 +1,124 @@
+import os from "node:os";
+import path from "node:path";
+import { plainString, withOptionalUpdate } from "./shared.js";
+function isFileSessionChangeSet(changeSet, operation) {
+    return (!!changeSet &&
+        changeSet.updates.every((update) => {
+            if (update.destination !== "session")
+                return false;
+            if (update.type === "setMode") {
+                return operation === "write" && update.mode === "acceptEdits";
+            }
+            if (update.type === "addDirectories")
+                return operation === "write";
+            if (update.type !== "addRules" || update.behavior !== "allow")
+                return false;
+            return update.rules.every((rule) => operation === "read" ? rule.toolName === "Read" : rule.toolName === "Edit");
+        }));
+}
+function inputPath(context, key) {
+    return plainString(context.input[key]);
+}
+function isInside(directory, candidate) {
+    const relative = path.relative(path.resolve(directory), path.resolve(candidate));
+    return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== "..");
+}
+function hasSessionAllowRuleFor(changeSet, toolName) {
+    return !!changeSet?.updates.some((update) => update.type === "addRules" &&
+        update.destination === "session" &&
+        update.behavior === "allow" &&
+        update.rules.some((rule) => rule.toolName === toolName));
+}
+function hasBroadSessionAllowRuleFor(changeSet, toolName) {
+    return changeSet.updates.some((update) => update.type === "addRules" &&
+        update.destination === "session" &&
+        update.behavior === "allow" &&
+        update.rules.some((rule) => rule.toolName === toolName && rule.ruleContent === undefined));
+}
+function hasAcceptEditsMode(changeSet) {
+    return changeSet.updates.some((update) => update.type === "setMode" &&
+        update.destination === "session" &&
+        update.mode === "acceptEdits");
+}
+function permissionPath(ruleContent) {
+    const value = plainString(ruleContent);
+    if (!value)
+        return undefined;
+    return value.replace(/[/\\]\*\*$/, "");
+}
+function effectCoversFilePath(changeSet, filePath, operation, cwd) {
+    const directory = path.dirname(filePath);
+    const comparable = (candidate) => {
+        const resolved = path.resolve(cwd, candidate);
+        return resolved === directory || isInside(resolved, filePath);
+    };
+    const paths = changeSet.updates.flatMap((update) => {
+        if (update.type === "addDirectories")
+            return update.directories;
+        if (update.type !== "addRules" || update.behavior !== "allow")
+            return [];
+        return update.rules
+            .filter((rule) => operation === "read" ? rule.toolName === "Read" : rule.toolName === "Edit")
+            .map((rule) => permissionPath(rule.ruleContent))
+            .filter((value) => value !== undefined);
+    });
+    return paths.some(comparable);
+}
+function fileSessionLabel(context, filePath, operation) {
+    if (!isFileSessionChangeSet(context.durableChangeSet, operation))
+        return undefined;
+    const resolvedFilePath = filePath ? path.resolve(context.cwd, filePath) : undefined;
+    const isClaudePath = operation === "write" &&
+        !!resolvedFilePath &&
+        (isInside(path.join(context.cwd, ".claude"), resolvedFilePath) ||
+            isInside(path.join(os.homedir(), ".claude"), resolvedFilePath));
+    const broadRule = hasBroadSessionAllowRuleFor(context.durableChangeSet, operation === "read" ? "Read" : "Edit");
+    if (resolvedFilePath) {
+        const coversCurrentPath = effectCoversFilePath(context.durableChangeSet, resolvedFilePath, operation, context.cwd) ||
+            broadRule ||
+            (operation === "write" && !isClaudePath && hasAcceptEditsMode(context.durableChangeSet));
+        if (!coversCurrentPath)
+            return undefined;
+    }
+    else if (!broadRule &&
+        !(operation === "write" && hasAcceptEditsMode(context.durableChangeSet))) {
+        return undefined;
+    }
+    if (operation === "write" &&
+        resolvedFilePath &&
+        isClaudePath &&
+        hasSessionAllowRuleFor(context.durableChangeSet, "Edit")) {
+        return "Yes, and allow Claude to edit its own settings for this session";
+    }
+    if (!resolvedFilePath || isInside(context.cwd, resolvedFilePath)) {
+        return operation === "read"
+            ? "Yes, during this session"
+            : "Yes, allow all edits during this session";
+    }
+    const directory = path.dirname(resolvedFilePath);
+    const directoryName = path.basename(directory) || "this directory";
+    return operation === "read"
+        ? `Yes, allow reading from ${directoryName}${path.sep} during this session`
+        : `Yes, allow all edits in ${directoryName}${path.sep} during this session`;
+}
+function buildFilePermissionOptions(context, filePath, operation) {
+    return withOptionalUpdate(context.durableChangeSet, fileSessionLabel(context, filePath, operation), "Yes", "No");
+}
+export function buildReadPermissionOptions(context) {
+    return buildFilePermissionOptions(context, inputPath(context, "file_path"), "read");
+}
+export function buildGlobPermissionOptions(context) {
+    return buildFilePermissionOptions(context, inputPath(context, "path") ?? context.cwd, "read");
+}
+export function buildGrepPermissionOptions(context) {
+    return buildFilePermissionOptions(context, inputPath(context, "path") ?? context.cwd, "read");
+}
+export function buildEditPermissionOptions(context) {
+    return buildFilePermissionOptions(context, inputPath(context, "file_path"), "write");
+}
+export function buildWritePermissionOptions(context) {
+    return buildFilePermissionOptions(context, inputPath(context, "file_path"), "write");
+}
+export function buildNotebookEditPermissionOptions(context) {
+    return buildFilePermissionOptions(context, inputPath(context, "notebook_path"), "write");
+}

package/dist/permissions/options/shared.d.ts

@@ -0,0 +1,39 @@
+import type { PermissionOption } from "@agentclientprotocol/sdk";
+import type { DurablePermissionChangeSet } from "../normalization.js";
+export declare const PERMISSION_OPTION_ID: {
+    readonly allowOnce: "allow-once";
+    readonly allowWithUpdates: "allow-with-updates";
+    readonly allowSkillExact: "allow-skill-exact";
+    readonly allowSkillPrefix: "allow-skill-prefix";
+    readonly exitPlanBypass: "exit-plan-bypass";
+    readonly exitPlanAuto: "exit-plan-auto";
+    readonly exitPlanAcceptEdits: "exit-plan-accept-edits";
+    readonly exitPlanDefault: "exit-plan-default";
+    readonly exitPlanClearAuto: "exit-plan-clear-auto";
+    readonly exitPlanClearBypass: "exit-plan-clear-bypass";
+    readonly exitPlanClearAcceptEdits: "exit-plan-clear-accept-edits";
+    readonly reject: "reject";
+};
+export interface PermissionOptionContext {
+    toolName: string;
+    displayName?: string;
+    input: Record<string, unknown>;
+    cwd: string;
+    durableChangeSet?: DurablePermissionChangeSet;
+    allowPersistentOptions?: boolean;
+    availableModes?: readonly string[];
+    contextUsedPercent?: number;
+}
+export declare function allowOnce(name?: string): PermissionOption;
+export declare function allowWithUpdates(name: string): PermissionOption;
+export declare function reject(name?: string): PermissionOption;
+export declare function withOptionalUpdate(changeSet: DurablePermissionChangeSet | undefined, updateName: string | undefined, allowName?: string, rejectName?: string): PermissionOption[];
+export declare function plainString(value: unknown): string | undefined;
+export declare function exactLocalAllowRule(changeSet: DurablePermissionChangeSet | undefined, toolName: string, ruleContent?: string): boolean;
+/**
+ * An MCP "don't ask again" option is only truthful when every provider update
+ * adds an unrestricted allow rule for the tool currently being prompted.
+ */
+export declare function isMcpAllowChangeSet(changeSet: DurablePermissionChangeSet | undefined, toolName: string): boolean;
+export declare function withGeneratedUpdate(name: string, rejectName?: string): PermissionOption[];
+//# sourceMappingURL=shared.d.ts.map

package/dist/permissions/options/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/permissions/options/shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AAEtE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;CAavB,CAAC;AAEX,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,gBAAgB,CAAC,EAAE,0BAA0B,CAAC;IAC9C,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,wBAAgB,SAAS,CAAC,IAAI,SAAQ,GAAG,gBAAgB,CAExD;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,CAE/D;AAED,wBAAgB,MAAM,CAAC,IAAI,SAAO,GAAG,gBAAgB,CAEpD;AAED,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,0BAA0B,GAAG,SAAS,EACjD,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,SAAS,SAAQ,EACjB,UAAU,SAAO,GAChB,gBAAgB,EAAE,CAKpB;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAE9D;AAED,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,0BAA0B,GAAG,SAAS,EACjD,QAAQ,EAAE,MAAM,EAChB,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAkBT;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,0BAA0B,GAAG,SAAS,EACjD,QAAQ,EAAE,MAAM,GACf,OAAO,CAYT;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,SAAO,GAAG,gBAAgB,EAAE,CAEvF"}

package/dist/permissions/options/shared.js

@@ -0,0 +1,64 @@
+export const PERMISSION_OPTION_ID = {
+    allowOnce: "allow-once",
+    allowWithUpdates: "allow-with-updates",
+    allowSkillExact: "allow-skill-exact",
+    allowSkillPrefix: "allow-skill-prefix",
+    exitPlanBypass: "exit-plan-bypass",
+    exitPlanAuto: "exit-plan-auto",
+    exitPlanAcceptEdits: "exit-plan-accept-edits",
+    exitPlanDefault: "exit-plan-default",
+    exitPlanClearAuto: "exit-plan-clear-auto",
+    exitPlanClearBypass: "exit-plan-clear-bypass",
+    exitPlanClearAcceptEdits: "exit-plan-clear-accept-edits",
+    reject: "reject",
+};
+export function allowOnce(name = "Yes") {
+    return { optionId: PERMISSION_OPTION_ID.allowOnce, name, kind: "allow_once" };
+}
+export function allowWithUpdates(name) {
+    return { optionId: PERMISSION_OPTION_ID.allowWithUpdates, name, kind: "allow_always" };
+}
+export function reject(name = "No") {
+    return { optionId: PERMISSION_OPTION_ID.reject, name, kind: "reject_once" };
+}
+export function withOptionalUpdate(changeSet, updateName, allowName = "Yes", rejectName = "No") {
+    const options = [allowOnce(allowName)];
+    if (changeSet && updateName)
+        options.push(allowWithUpdates(updateName));
+    options.push(reject(rejectName));
+    return options;
+}
+export function plainString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+export function exactLocalAllowRule(changeSet, toolName, ruleContent) {
+    if (!changeSet || changeSet.updates.length !== 1)
+        return false;
+    const update = changeSet.updates[0];
+    if (update?.type !== "addRules" ||
+        update.behavior !== "allow" ||
+        update.destination !== "localSettings" ||
+        update.rules.length !== 1) {
+        return false;
+    }
+    const rule = update.rules[0];
+    return (rule?.toolName === toolName &&
+        (ruleContent === undefined
+            ? rule.ruleContent === undefined
+            : plainString(rule.ruleContent) === ruleContent));
+}
+/**
+ * An MCP "don't ask again" option is only truthful when every provider update
+ * adds an unrestricted allow rule for the tool currently being prompted.
+ */
+export function isMcpAllowChangeSet(changeSet, toolName) {
+    return (!!changeSet &&
+        changeSet.updates.length > 0 &&
+        changeSet.updates.every((update) => update.type === "addRules" &&
+            update.behavior === "allow" &&
+            update.rules.length > 0 &&
+            update.rules.every((rule) => rule.toolName === toolName && rule.ruleContent === undefined)));
+}
+export function withGeneratedUpdate(name, rejectName = "No") {
+    return [allowOnce(), allowWithUpdates(name), reject(rejectName)];
+}

package/dist/permissions/options/shell.d.ts

@@ -0,0 +1,5 @@
+import type { PermissionOption } from "@agentclientprotocol/sdk";
+import { type PermissionOptionContext } from "./shared.js";
+export declare function buildBashPermissionOptions(context: PermissionOptionContext): PermissionOption[];
+export declare function buildPowerShellPermissionOptions(context: PermissionOptionContext): PermissionOption[];
+//# sourceMappingURL=shell.d.ts.map

package/dist/permissions/options/shell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell.d.ts","sourceRoot":"","sources":["../../../src/permissions/options/shell.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAGjE,OAAO,EAAe,KAAK,uBAAuB,EAAsB,MAAM,aAAa,CAAC;AA6G5F,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,uBAAuB,GAAG,gBAAgB,EAAE,CAE/F;AAED,wBAAgB,gCAAgC,CAC9C,OAAO,EAAE,uBAAuB,GAC/B,gBAAgB,EAAE,CAEpB"}

package/dist/permissions/options/shell.js

@@ -0,0 +1,100 @@
+import path from "node:path";
+import { plainString, withOptionalUpdate } from "./shared.js";
+function permissionRulePrefix(value) {
+    return value.endsWith(":*") ? value.slice(0, -2) : value;
+}
+function displayList(values) {
+    if (values.join(", ").length > 50)
+        return "similar";
+    if (values.length === 1)
+        return values[0];
+    if (values.length === 2)
+        return `${values[0]} and ${values[1]}`;
+    return `${values.slice(0, -1).join(", ")}, and ${values.at(-1)}`;
+}
+/** Shorten paths only as much as needed to distinguish them in prompt text. */
+function displayPaths(paths) {
+    const normalizedPaths = [...new Set(paths.map((value) => path.normalize(value)))];
+    const segments = normalizedPaths.map((value) => value.split(path.sep).filter(Boolean));
+    // Compare equally deep suffixes so duplicate basenames gain the smallest
+    // useful parent prefix (for example, codex-acp/src/ vs claude-acp/src/).
+    const suffix = (index, depth) => segments[index].slice(-depth).join(path.sep) || normalizedPaths[index];
+    const names = normalizedPaths.map((value, index) => {
+        const parts = segments[index];
+        let name = path.basename(value) || value;
+        for (let depth = 1; depth <= parts.length; depth++) {
+            const candidate = suffix(index, depth);
+            if (normalizedPaths.every((_, other) => other === index || suffix(other, depth) !== candidate)) {
+                name = candidate;
+                break;
+            }
+            if (depth === parts.length)
+                name = value;
+        }
+        return name.endsWith(path.sep) ? name : `${name}${path.sep}`;
+    });
+    // Native Claude labels enumerate two paths and summarize larger sets.
+    if (names.length <= 2)
+        return displayList(names);
+    return `${names[0]}, ${names[1]} and ${names.length - 2} more`;
+}
+/** Plain-text port of Claude Code's generateShellSuggestionsLabel. */
+function shellSuggestionsLabel(toolName, changeSet) {
+    const representable = changeSet.updates.every((update) => {
+        if (update.type === "addDirectories")
+            return update.destination === "session";
+        if (update.type !== "addRules" || update.behavior !== "allow")
+            return false;
+        return update.rules.every((rule) => (rule.toolName === toolName || rule.toolName === "Read") &&
+            plainString(rule.ruleContent) !== undefined);
+    });
+    if (!representable)
+        return undefined;
+    const rules = changeSet.updates
+        .filter((update) => update.type === "addRules")
+        .flatMap((update) => update.rules);
+    const readPaths = rules
+        .filter((rule) => rule.toolName === "Read")
+        .map((rule) => rule.ruleContent?.replace(/\/\*\*$/, ""))
+        .filter((value) => !!value);
+    const commands = [
+        ...new Set(rules
+            .filter((rule) => rule.toolName === toolName && rule.ruleContent)
+            .map((rule) => permissionRulePrefix(rule.ruleContent))),
+    ];
+    const directories = changeSet.updates
+        .filter((update) => update.type === "addDirectories")
+        .flatMap((update) => update.directories);
+    const hasPaths = readPaths.length > 0 || directories.length > 0;
+    if (readPaths.length > 0 && directories.length === 0 && commands.length === 0) {
+        return `Yes, allow reading from ${displayPaths(readPaths)} from this project`;
+    }
+    if (directories.length > 0 && readPaths.length === 0 && commands.length === 0) {
+        return `Yes, and always allow access to ${displayPaths(directories)} from this project`;
+    }
+    if (commands.length > 0 && !hasPaths) {
+        return `Yes, and don't ask again for ${displayList(commands)} commands`;
+    }
+    if (hasPaths && commands.length === 0) {
+        return `Yes, and always allow access to ${displayPaths([...directories, ...readPaths])} from this project`;
+    }
+    if (hasPaths && commands.length > 0) {
+        const paths = [...directories, ...readPaths];
+        return paths.length === 1 && commands.length === 1
+            ? `Yes, and allow access to ${displayPaths(paths)} and ${displayList(commands)} commands`
+            : `Yes, and allow ${displayPaths(paths)} access and ${displayList(commands)} commands`;
+    }
+    return undefined;
+}
+function buildShellPermissionOptions(context, toolName) {
+    const name = context.durableChangeSet
+        ? shellSuggestionsLabel(toolName, context.durableChangeSet)
+        : undefined;
+    return withOptionalUpdate(context.durableChangeSet, name, "Yes", "No");
+}
+export function buildBashPermissionOptions(context) {
+    return buildShellPermissionOptions(context, "Bash");
+}
+export function buildPowerShellPermissionOptions(context) {
+    return buildShellPermissionOptions(context, "PowerShell");
+}

package/dist/permissions/options/tools.d.ts

@@ -0,0 +1,11 @@
+import type { PermissionOption } from "@agentclientprotocol/sdk";
+import { type PermissionOptionContext } from "./shared.js";
+export declare function buildWebFetchPermissionOptions(context: PermissionOptionContext): PermissionOption[];
+export declare function buildSkillPermissionOptions(context: PermissionOptionContext): PermissionOption[];
+export declare function buildEnterPlanModePermissionOptions(): PermissionOption[];
+export declare function buildExitPlanModePermissionOptions(context: PermissionOptionContext): PermissionOption[];
+export declare function buildSandboxNetworkPermissionOptions(context: PermissionOptionContext): PermissionOption[];
+export declare function buildFallbackPermissionOptions(context: PermissionOptionContext): PermissionOption[];
+export declare function isComputerUseMcpTool(toolName: string): boolean;
+export declare function buildComputerUseMcpPermissionOptions(context: PermissionOptionContext): PermissionOption[];
+//# sourceMappingURL=tools.d.ts.map

package/dist/permissions/options/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/permissions/options/tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAML,KAAK,uBAAuB,EAI7B,MAAM,aAAa,CAAC;AAErB,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,uBAAuB,GAC/B,gBAAgB,EAAE,CAapB;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,uBAAuB,GAAG,gBAAgB,EAAE,CAqBhG;AAED,wBAAgB,mCAAmC,IAAI,gBAAgB,EAAE,CAExE;AAED,wBAAgB,kCAAkC,CAChD,OAAO,EAAE,uBAAuB,GAC/B,gBAAgB,EAAE,CAyDpB;AAED,wBAAgB,oCAAoC,CAClD,OAAO,EAAE,uBAAuB,GAC/B,gBAAgB,EAAE,CAOpB;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,uBAAuB,GAC/B,gBAAgB,EAAE,CAiBpB;AAID,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED,wBAAgB,oCAAoC,CAClD,OAAO,EAAE,uBAAuB,GAC/B,gBAAgB,EAAE,CAWpB"}

package/dist/permissions/options/tools.js

@@ -0,0 +1,135 @@
+import { allowOnce, exactLocalAllowRule, isMcpAllowChangeSet, PERMISSION_OPTION_ID, plainString, reject, withGeneratedUpdate, withOptionalUpdate, } from "./shared.js";
+export function buildWebFetchPermissionOptions(context) {
+    const url = plainString(context.input.url);
+    if (url && context.allowPersistentOptions !== false) {
+        try {
+            const hostname = new URL(url).hostname;
+            if (hostname) {
+                return withGeneratedUpdate(`Yes, and don't ask again for ${hostname}`);
+            }
+        }
+        catch {
+            // Invalid input cannot produce Claude Code's domain-specific option.
+        }
+    }
+    return [allowOnce(), reject("No")];
+}
+export function buildSkillPermissionOptions(context) {
+    const skill = plainString(context.input.skill);
+    const options = [allowOnce()];
+    if (skill && context.allowPersistentOptions !== false) {
+        options.push({
+            optionId: PERMISSION_OPTION_ID.allowSkillExact,
+            name: `Yes, and don't ask again for ${skill}`,
+            kind: "allow_always",
+        });
+        const spaceIndex = skill.indexOf(" ");
+        if (spaceIndex > 0) {
+            const prefix = `${skill.slice(0, spaceIndex)}:*`;
+            options.push({
+                optionId: PERMISSION_OPTION_ID.allowSkillPrefix,
+                name: `Yes, and don't ask again for ${prefix} commands`,
+                kind: "allow_always",
+            });
+        }
+    }
+    options.push(reject("No"));
+    return options;
+}
+export function buildEnterPlanModePermissionOptions() {
+    return [allowOnce("Yes, enter plan mode"), reject("No, start implementing now")];
+}
+export function buildExitPlanModePermissionOptions(context) {
+    const modes = new Set(context.availableModes);
+    const options = [];
+    const elevatedMode = modes.has("auto")
+        ? "auto"
+        : modes.has("bypassPermissions")
+            ? "bypassPermissions"
+            : "acceptEdits";
+    if (plainString(context.input.plan)) {
+        const usage = context.contextUsedPercent === undefined ? "" : ` (${context.contextUsedPercent}% used)`;
+        if (elevatedMode === "auto") {
+            options.push({
+                optionId: PERMISSION_OPTION_ID.exitPlanClearAuto,
+                name: `Yes, clear context${usage} and use auto mode`,
+                kind: "allow_always",
+            });
+        }
+        else if (elevatedMode === "bypassPermissions") {
+            options.push({
+                optionId: PERMISSION_OPTION_ID.exitPlanClearBypass,
+                name: `Yes, clear context${usage} and bypass permissions`,
+                kind: "allow_always",
+            });
+        }
+        else {
+            options.push({
+                optionId: PERMISSION_OPTION_ID.exitPlanClearAcceptEdits,
+                name: `Yes, clear context${usage} and auto-accept edits`,
+                kind: "allow_always",
+            });
+        }
+    }
+    if (elevatedMode === "auto") {
+        options.push({
+            optionId: PERMISSION_OPTION_ID.exitPlanAuto,
+            name: "Yes, and use auto mode",
+            kind: "allow_always",
+        });
+    }
+    else if (elevatedMode === "bypassPermissions") {
+        options.push({
+            optionId: PERMISSION_OPTION_ID.exitPlanBypass,
+            name: "Yes, and bypass permissions",
+            kind: "allow_always",
+        });
+    }
+    else {
+        options.push({
+            optionId: PERMISSION_OPTION_ID.exitPlanAcceptEdits,
+            name: "Yes, auto-accept edits",
+            kind: "allow_always",
+        });
+    }
+    options.push({
+        optionId: PERMISSION_OPTION_ID.exitPlanDefault,
+        name: "Yes, manually approve edits",
+        kind: "allow_once",
+    });
+    options.push(reject("No, keep planning"));
+    return options;
+}
+export function buildSandboxNetworkPermissionOptions(context) {
+    const host = plainString(context.input.host);
+    const name = host && exactLocalAllowRule(context.durableChangeSet, context.toolName, host)
+        ? `Yes, and don't ask again for ${host}`
+        : undefined;
+    return withOptionalUpdate(context.durableChangeSet, name, "Yes", "No");
+}
+export function buildFallbackPermissionOptions(context) {
+    const toolLabel = plainString(context.displayName) ?? context.toolName;
+    if (context.toolName.startsWith("mcp__")) {
+        const changeSet = context.allowPersistentOptions !== false &&
+            isMcpAllowChangeSet(context.durableChangeSet, context.toolName)
+            ? context.durableChangeSet
+            : undefined;
+        return withOptionalUpdate(changeSet, changeSet ? `Yes, and don't ask again for ${toolLabel} commands` : undefined);
+    }
+    if (context.allowPersistentOptions !== false) {
+        return withGeneratedUpdate(`Yes, and don't ask again for ${toolLabel} commands`);
+    }
+    return [allowOnce(), reject("No")];
+}
+const COMPUTER_USE_MCP_TOOL_PREFIX = "mcp__computer-use__";
+export function isComputerUseMcpTool(toolName) {
+    return toolName.startsWith(COMPUTER_USE_MCP_TOOL_PREFIX);
+}
+export function buildComputerUseMcpPermissionOptions(context) {
+    const toolLabel = plainString(context.displayName) ?? context.toolName;
+    const changeSet = context.allowPersistentOptions !== false &&
+        isMcpAllowChangeSet(context.durableChangeSet, context.toolName)
+        ? context.durableChangeSet
+        : undefined;
+    return withOptionalUpdate(changeSet, changeSet ? `Yes, and don't ask again for ${toolLabel}` : undefined);
+}

package/dist/permissions/options.d.ts

@@ -0,0 +1,5 @@
+import type { PermissionOption } from "@agentclientprotocol/sdk";
+import type { PermissionOptionContext } from "./options/shared.js";
+export { PERMISSION_OPTION_ID } from "./options/shared.js";
+export declare function buildClaudePermissionOptions(context: PermissionOptionContext): PermissionOption[];
+//# sourceMappingURL=options.d.ts.map

package/dist/permissions/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../src/permissions/options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAUjE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAYnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAE3D,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,uBAAuB,GAAG,gBAAgB,EAAE,CAIjG"}