viberoom 0.3.0 → 0.4.0

package/vendor/acp/claude-agent-acp/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/vendor/acp/claude-agent-acp/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/vendor/acp/claude-agent-acp/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/vendor/acp/claude-agent-acp/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/vendor/acp/claude-agent-acp/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/vendor/acp/claude-agent-acp/dist/permissions/options.js

@@ -0,0 +1,60 @@
+import { buildEditPermissionOptions, buildGlobPermissionOptions, buildGrepPermissionOptions, buildNotebookEditPermissionOptions, buildReadPermissionOptions, buildWritePermissionOptions, } from "./options/filesystem.js";
+import { buildBashPermissionOptions, buildPowerShellPermissionOptions } from "./options/shell.js";
+import { buildComputerUseMcpPermissionOptions, buildEnterPlanModePermissionOptions, buildExitPlanModePermissionOptions, buildFallbackPermissionOptions, buildSandboxNetworkPermissionOptions, buildSkillPermissionOptions, buildWebFetchPermissionOptions, isComputerUseMcpTool, } from "./options/tools.js";
+export { PERMISSION_OPTION_ID } from "./options/shared.js";
+export function buildClaudePermissionOptions(context) {
+    return buildUnsortedClaudePermissionOptions(context).sort((left, right) => permissionOptionOrder(left) - permissionOptionOrder(right));
+}
+function buildUnsortedClaudePermissionOptions(context) {
+    if (isComputerUseMcpTool(context.toolName)) {
+        return buildComputerUseMcpPermissionOptions(context);
+    }
+    switch (context.toolName) {
+        case "AskUserQuestion":
+            throw new Error("AskUserQuestion must be handled by ACP elicitation, not permission options");
+        case "Bash":
+            return buildBashPermissionOptions(context);
+        case "PowerShell":
+            return buildPowerShellPermissionOptions(context);
+        case "Read":
+            return buildReadPermissionOptions(context);
+        case "Glob":
+            return buildGlobPermissionOptions(context);
+        case "Grep":
+            return buildGrepPermissionOptions(context);
+        case "Edit":
+            return buildEditPermissionOptions(context);
+        case "Write":
+            return buildWritePermissionOptions(context);
+        case "NotebookEdit":
+            return buildNotebookEditPermissionOptions(context);
+        case "WebFetch":
+            return buildWebFetchPermissionOptions(context);
+        case "Skill":
+            return buildSkillPermissionOptions(context);
+        case "EnterPlanMode":
+            return buildEnterPlanModePermissionOptions();
+        case "ExitPlanMode":
+            return buildExitPlanModePermissionOptions(context);
+        case "SandboxNetworkAccess":
+            return buildSandboxNetworkPermissionOptions(context);
+        case "WebSearch":
+        case "Agent":
+        case "Task":
+        default:
+            return buildFallbackPermissionOptions(context);
+    }
+}
+function permissionOptionOrder(option) {
+    switch (option.kind) {
+        case "allow_once":
+            return 0;
+        case "allow_always":
+            return 1;
+        case "reject_once":
+        case "reject_always":
+            return 3;
+        default:
+            return 2;
+    }
+}

package/vendor/acp/claude-agent-acp/dist/permissions/presentation.js

@@ -0,0 +1,83 @@
+import { toolInfoFromToolUse } from "../tools.js";
+function humanText(value, maxLength, singleLine = false) {
+    if (typeof value !== "string")
+        return undefined;
+    const withoutControls = Array.from(value)
+        .filter((character) => {
+        const code = character.charCodeAt(0);
+        return !(code <= 0x08 ||
+            code === 0x0b ||
+            code === 0x0c ||
+            (code >= 0x0e && code <= 0x1f) ||
+            code === 0x7f);
+    })
+        .join("");
+    const normalized = singleLine
+        ? withoutControls.replace(/\s+/gu, " ").trim()
+        : withoutControls.trim();
+    return normalized && normalized.length <= maxLength ? normalized : undefined;
+}
+function compactText(value) {
+    return humanText(value, 160, true);
+}
+function withBlockedPath(locations, blockedPath) {
+    const path = humanText(blockedPath, 4_096, true);
+    if (!path)
+        return locations;
+    const result = [...(locations ?? [])];
+    if (!result.some((location) => location.path === path))
+        result.push({ path });
+    return result;
+}
+export function buildClaudePermissionPresentation(value) {
+    const info = toolInfoFromToolUse({ id: value.toolUseID, name: value.toolName, input: value.input }, value.supportsTerminalOutput ?? false, value.cwd);
+    const host = value.toolName === "SandboxNetworkAccess" ? compactText(value.input.host) : undefined;
+    const isComputerUse = value.toolName.startsWith("mcp__computer-use__");
+    const subjectTitle = host ?? (isComputerUse ? compactText(value.displayName) : undefined);
+    const subjectContent = (host || isComputerUse) && info.content.length === 0
+        ? [
+            {
+                type: "content",
+                content: {
+                    type: "text",
+                    text: `\`\`\`json\n${JSON.stringify(value.input, null, 2)}\n\`\`\``,
+                },
+            },
+        ]
+        : info.content;
+    // Reuse the exact standard tool-call heading as the permission heading so
+    // the approval never maintains a second, divergent name for the operation.
+    // decisionReason is temporarily exposed as the permission description so
+    // its actual SDK values can be inspected; it remains diagnostic policy text.
+    const shellTitle = value.toolName === "Bash" || value.toolName === "PowerShell"
+        ? (compactText(value.input.description) ?? value.toolName)
+        : undefined;
+    const toolCallTitle = shellTitle ?? subjectTitle ?? info.title;
+    const permissionTitle = value.toolName === "ExitPlanMode" ? "Ready to code?" : toolCallTitle;
+    const title = humanText(permissionTitle, 4_000, true) ?? "Use tool?";
+    const decisionReason = humanText(value.decisionReason, 4_000);
+    const description = decisionReason ? `Reason: ${decisionReason}` : undefined;
+    return {
+        toolCall: {
+            toolCallId: value.toolUseID,
+            name: value.toolName,
+            status: "pending",
+            rawInput: value.input,
+            ...info,
+            title: toolCallTitle,
+            content: subjectContent,
+            locations: withBlockedPath(info.locations, value.blockedPath),
+        },
+        ...(title
+            ? {
+                _meta: {
+                    permission: {
+                        version: 1,
+                        title,
+                        ...(description ? { description } : {}),
+                    },
+                },
+            }
+            : {}),
+    };
+}