@ape-egg/claude-code-acp 0.0.0-stage → 0.16.2

package/dist/settings.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Permission rule format examples:
+ * - "Read" - matches all Read tool calls
+ * - "Read(./.env)" - matches specific path
+ * - "Read(./.env.*)" - glob pattern
+ * - "Read(./secrets/**)" - recursive glob
+ * - "Bash(npm run lint)" - exact command prefix
+ * - "Bash(npm run:*)" - command prefix with wildcard
+ *
+ * Docs: https://code.claude.com/docs/en/iam#tool-specific-permission-rules
+ */
+export interface PermissionSettings {
+    allow?: string[];
+    deny?: string[];
+    ask?: string[];
+    additionalDirectories?: string[];
+    defaultMode?: string;
+}
+export interface ClaudeCodeSettings {
+    permissions?: PermissionSettings;
+    env?: Record<string, string>;
+    model?: string;
+}
+export type PermissionDecision = "allow" | "deny" | "ask";
+export interface PermissionCheckResult {
+    decision: PermissionDecision;
+    rule?: string;
+    source?: "allow" | "deny" | "ask";
+}
+/**
+ * Gets the enterprise settings path based on the current platform
+ */
+export declare function getManagedSettingsPath(): string;
+export interface SettingsManagerOptions {
+    onChange?: () => void;
+    logger?: {
+        log: (...args: any[]) => void;
+        error: (...args: any[]) => void;
+    };
+}
+/**
+ * Manages Claude Code settings from multiple sources with proper precedence.
+ *
+ * Settings are loaded from (in order of increasing precedence):
+ * 1. User settings (~/.claude/settings.json)
+ * 2. Project settings (<cwd>/.claude/settings.json)
+ * 3. Local project settings (<cwd>/.claude/settings.local.json)
+ * 4. Enterprise managed settings (platform-specific path)
+ *
+ * The manager watches all settings files for changes and automatically reloads.
+ */
+export declare class SettingsManager {
+    private cwd;
+    private userSettings;
+    private projectSettings;
+    private localSettings;
+    private enterpriseSettings;
+    private mergedSettings;
+    private watchers;
+    private onChange?;
+    private logger;
+    private initialized;
+    private debounceTimer;
+    constructor(cwd: string, options?: SettingsManagerOptions);
+    /**
+     * Initialize the settings manager by loading all settings and setting up file watchers
+     */
+    initialize(): Promise<void>;
+    /**
+     * Returns the path to the user settings file
+     */
+    private getUserSettingsPath;
+    /**
+     * Returns the path to the project settings file
+     */
+    private getProjectSettingsPath;
+    /**
+     * Returns the path to the local project settings file
+     */
+    private getLocalSettingsPath;
+    /**
+     * Loads settings from all sources
+     */
+    private loadAllSettings;
+    /**
+     * Merges all settings sources with proper precedence.
+     * For permissions, rules from all sources are combined.
+     * Deny rules always take precedence during permission checks.
+     */
+    private mergeSettings;
+    /**
+     * Sets up file watchers for all settings files
+     */
+    private setupWatchers;
+    /**
+     * Handles settings file changes with debouncing to avoid rapid reloads
+     */
+    private handleSettingsChange;
+    /**
+     * Checks if a tool invocation is allowed based on the loaded settings.
+     *
+     * @param toolName - The tool name (can be ACP-prefixed like mcp__acp__Read or plain like Read)
+     * @param toolInput - The tool input object
+     * @returns The permission decision and matching rule info
+     */
+    checkPermission(toolName: string, toolInput: unknown): PermissionCheckResult;
+    /**
+     * Returns the current merged settings
+     */
+    getSettings(): ClaudeCodeSettings;
+    /**
+     * Returns the current working directory
+     */
+    getCwd(): string;
+    /**
+     * Updates the working directory and reloads project-specific settings
+     */
+    setCwd(cwd: string): Promise<void>;
+    /**
+     * Disposes of file watchers and cleans up resources
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=settings.d.ts.map

package/dist/settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../src/settings.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,kBAAkB;IACjC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;IACf,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC;IACjC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,kBAAkB;IACjC,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC;AAE1D,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC;CACnC;AAwLD;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,CAW/C;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,MAAM,CAAC,EAAE;QAAE,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;QAAC,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAA;KAAE,CAAC;CAC7E;AAED;;;;;;;;;;GAUG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,YAAY,CAA0B;IAC9C,OAAO,CAAC,eAAe,CAA0B;IACjD,OAAO,CAAC,aAAa,CAA0B;IAC/C,OAAO,CAAC,kBAAkB,CAA0B;IACpD,OAAO,CAAC,cAAc,CAA0B;IAChD,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,QAAQ,CAAC,CAAa;IAC9B,OAAO,CAAC,MAAM,CAAqE;IACnF,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,aAAa,CAA8C;gBAEvD,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,sBAAsB;IAMzD;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAUjC;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAI3B;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAI9B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAI5B;;OAEG;YACW,eAAe;IAgB7B;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAkDrB;;OAEG;IACH,OAAO,CAAC,aAAa;IAkCrB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAgB5B;;;;;;OAMG;IACH,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,GAAG,qBAAqB;IAuC5E;;OAEG;IACH,WAAW,IAAI,kBAAkB;IAIjC;;OAEG;IACH,MAAM,IAAI,MAAM;IAIhB;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAWxC;;OAEG;IACH,OAAO,IAAI,IAAI;CAYhB"}

package/dist/settings.js

@@ -0,0 +1,426 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { minimatch } from "minimatch";
+import { ACP_TOOL_NAME_PREFIX, acpToolNames } from "./tools.js";
+import { CLAUDE_CONFIG_DIR } from "./acp-agent.js";
+/**
+ * Shell operators that can be used for command chaining/injection
+ * These should cause a prefix match to fail to prevent bypasses like:
+ * - "safe-cmd && malicious-cmd"
+ * - "safe-cmd; malicious-cmd"
+ * - "safe-cmd | malicious-cmd"
+ * - "safe-cmd || malicious-cmd"
+ * - "$(malicious-cmd)"
+ * - "`malicious-cmd`"
+ */
+const SHELL_OPERATORS = ["&&", "||", ";", "|", "$(", "`", "\n"];
+/**
+ * Checks if a string contains shell operators that could allow command chaining
+ */
+function containsShellOperator(str) {
+    return SHELL_OPERATORS.some((op) => str.includes(op));
+}
+/*
+ * Tools that modify files. Per Claude Code docs:
+ * "Edit rules apply to all built-in tools that edit files."
+ * This means an Edit(...) rule should match Write, MultiEdit, etc.
+ */
+const FILE_EDITING_TOOLS = [acpToolNames.edit, acpToolNames.write];
+/**
+ * Tools that read files. Per Claude Code docs:
+ * "Claude will make a best-effort attempt to apply Read rules to all built-in tools
+ * that read files like Grep and Glob."
+ * This means a Read(...) rule should match Grep, Glob, etc.
+ */
+const FILE_READING_TOOLS = [acpToolNames.read];
+/**
+ * Functions to extract the relevant argument from tool input for permission matching
+ */
+const TOOL_ARG_ACCESSORS = {
+    mcp__acp__Read: (input) => input?.file_path,
+    mcp__acp__Edit: (input) => input?.file_path,
+    mcp__acp__Write: (input) => input?.file_path,
+    mcp__acp__Bash: (input) => input?.command,
+};
+/**
+ * Parses a permission rule string into its components
+ * Examples:
+ *   "Read" -> { toolName: "Read" }
+ *   "Read(./.env)" -> { toolName: "Read", argument: "./.env" }
+ *   "Bash(npm run:*)" -> { toolName: "Bash", argument: "npm run", isWildcard: true }
+ */
+function parseRule(rule) {
+    const match = rule.match(/^(\w+)(?:\((.+)\))?$/);
+    if (!match) {
+        return { toolName: rule };
+    }
+    const [, toolName, argument] = match;
+    if (argument && argument.endsWith(":*")) {
+        return {
+            toolName,
+            argument: argument.slice(0, -2),
+            isWildcard: true,
+        };
+    }
+    return { toolName, argument };
+}
+/**
+ * Normalizes a path for comparison:
+ * - Expands ~ to home directory
+ * - Resolves relative paths against cwd
+ * - Normalizes path separators
+ */
+function normalizePath(filePath, cwd) {
+    if (filePath.startsWith("~/")) {
+        filePath = path.join(os.homedir(), filePath.slice(2));
+    }
+    else if (filePath.startsWith("./")) {
+        filePath = path.join(cwd, filePath.slice(2));
+    }
+    else if (!path.isAbsolute(filePath)) {
+        filePath = path.join(cwd, filePath);
+    }
+    // Convert backslashes to forward slashes for minimatch compatibility on Windows
+    return path.normalize(filePath).replace(/\\/g, "/");
+}
+/**
+ * Checks if a file path matches a glob pattern
+ */
+function matchesGlob(pattern, filePath, cwd) {
+    const normalizedPattern = normalizePath(pattern, cwd);
+    const normalizedPath = normalizePath(filePath, cwd);
+    return minimatch(normalizedPath, normalizedPattern, {
+        dot: true,
+        matchBase: false,
+        nocase: process.platform === "win32",
+    });
+}
+/**
+ * Checks if a tool invocation matches a parsed permission rule
+ */
+function matchesRule(rule, toolName, toolInput, cwd) {
+    // Per Claude Code docs:
+    // - "Edit rules apply to all built-in tools that edit files."
+    // - "Claude will make a best-effort attempt to apply Read rules to all built-in tools
+    //    that read files like Grep, Glob, and LS."
+    const ruleAppliesToTool = (rule.toolName === "Bash" && toolName === acpToolNames.bash) ||
+        (rule.toolName === "Edit" && FILE_EDITING_TOOLS.includes(toolName)) ||
+        (rule.toolName === "Read" && FILE_READING_TOOLS.includes(toolName));
+    if (!ruleAppliesToTool) {
+        return false;
+    }
+    if (!rule.argument) {
+        return true;
+    }
+    const argAccessor = TOOL_ARG_ACCESSORS[toolName];
+    if (!argAccessor) {
+        return true;
+    }
+    const actualArg = argAccessor(toolInput);
+    if (!actualArg) {
+        return false;
+    }
+    if (toolName === acpToolNames.bash) {
+        // Per Claude Code docs: https://code.claude.com/docs/en/iam#tool-specific-permission-rules
+        // - Bash(npm run build) matches the EXACT command "npm run build"
+        // - Bash(npm run test:*) matches commands STARTING WITH "npm run test"
+        // The :* suffix enables prefix matching, without it the match is exact
+        //
+        // Also from docs: "Claude Code is aware of shell operators (like &&) so a prefix match
+        // rule like Bash(safe-cmd:*) won't give it permission to run the command safe-cmd && other-cmd"
+        if (rule.isWildcard) {
+            if (!actualArg.startsWith(rule.argument)) {
+                return false;
+            }
+            // Check that the matched prefix isn't followed by shell operators that could
+            // allow command chaining/injection
+            const remainder = actualArg.slice(rule.argument.length);
+            if (containsShellOperator(remainder)) {
+                return false;
+            }
+            return true;
+        }
+        return actualArg === rule.argument;
+    }
+    // For file-based tools (Read, Edit, Write), use glob matching
+    return matchesGlob(rule.argument, actualArg, cwd);
+}
+/**
+ * Reads and parses a JSON settings file, returning an empty object if not found or invalid
+ */
+async function loadSettingsFile(filePath) {
+    if (!filePath) {
+        return {};
+    }
+    try {
+        const content = await fs.promises.readFile(filePath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Gets the enterprise settings path based on the current platform
+ */
+export function getManagedSettingsPath() {
+    switch (process.platform) {
+        case "darwin":
+            return "/Library/Application Support/ClaudeCode/managed-settings.json";
+        case "linux":
+            return "/etc/claude-code/managed-settings.json";
+        case "win32":
+            return "C:\\Program Files\\ClaudeCode\\managed-settings.json";
+        default:
+            return "/etc/claude-code/managed-settings.json";
+    }
+}
+/**
+ * Manages Claude Code settings from multiple sources with proper precedence.
+ *
+ * Settings are loaded from (in order of increasing precedence):
+ * 1. User settings (~/.claude/settings.json)
+ * 2. Project settings (<cwd>/.claude/settings.json)
+ * 3. Local project settings (<cwd>/.claude/settings.local.json)
+ * 4. Enterprise managed settings (platform-specific path)
+ *
+ * The manager watches all settings files for changes and automatically reloads.
+ */
+export class SettingsManager {
+    constructor(cwd, options) {
+        this.userSettings = {};
+        this.projectSettings = {};
+        this.localSettings = {};
+        this.enterpriseSettings = {};
+        this.mergedSettings = {};
+        this.watchers = [];
+        this.initialized = false;
+        this.debounceTimer = null;
+        this.cwd = cwd;
+        this.onChange = options?.onChange;
+        this.logger = options?.logger ?? console;
+    }
+    /**
+     * Initialize the settings manager by loading all settings and setting up file watchers
+     */
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        await this.loadAllSettings();
+        this.setupWatchers();
+        this.initialized = true;
+    }
+    /**
+     * Returns the path to the user settings file
+     */
+    getUserSettingsPath() {
+        return path.join(CLAUDE_CONFIG_DIR, "settings.json");
+    }
+    /**
+     * Returns the path to the project settings file
+     */
+    getProjectSettingsPath() {
+        return path.join(this.cwd, ".claude", "settings.json");
+    }
+    /**
+     * Returns the path to the local project settings file
+     */
+    getLocalSettingsPath() {
+        return path.join(this.cwd, ".claude", "settings.local.json");
+    }
+    /**
+     * Loads settings from all sources
+     */
+    async loadAllSettings() {
+        const [userSettings, projectSettings, localSettings, enterpriseSettings] = await Promise.all([
+            loadSettingsFile(this.getUserSettingsPath()),
+            loadSettingsFile(this.getProjectSettingsPath()),
+            loadSettingsFile(this.getLocalSettingsPath()),
+            loadSettingsFile(getManagedSettingsPath()),
+        ]);
+        this.userSettings = userSettings;
+        this.projectSettings = projectSettings;
+        this.localSettings = localSettings;
+        this.enterpriseSettings = enterpriseSettings;
+        this.mergeSettings();
+    }
+    /**
+     * Merges all settings sources with proper precedence.
+     * For permissions, rules from all sources are combined.
+     * Deny rules always take precedence during permission checks.
+     */
+    mergeSettings() {
+        const allSettings = [
+            this.userSettings,
+            this.projectSettings,
+            this.localSettings,
+            this.enterpriseSettings,
+        ];
+        const merged = {
+            permissions: {
+                allow: [],
+                deny: [],
+                ask: [],
+            },
+        };
+        for (const settings of allSettings) {
+            if (settings.permissions) {
+                if (settings.permissions.allow) {
+                    merged.permissions.allow.push(...settings.permissions.allow);
+                }
+                if (settings.permissions.deny) {
+                    merged.permissions.deny.push(...settings.permissions.deny);
+                }
+                if (settings.permissions.ask) {
+                    merged.permissions.ask.push(...settings.permissions.ask);
+                }
+                if (settings.permissions.additionalDirectories) {
+                    merged.permissions.additionalDirectories = [
+                        ...(merged.permissions.additionalDirectories || []),
+                        ...settings.permissions.additionalDirectories,
+                    ];
+                }
+                if (settings.permissions.defaultMode) {
+                    merged.permissions.defaultMode = settings.permissions.defaultMode;
+                }
+            }
+            if (settings.env) {
+                merged.env = { ...merged.env, ...settings.env };
+            }
+            if (settings.model) {
+                merged.model = settings.model;
+            }
+        }
+        this.mergedSettings = merged;
+    }
+    /**
+     * Sets up file watchers for all settings files
+     */
+    setupWatchers() {
+        const paths = [
+            this.getUserSettingsPath(),
+            this.getProjectSettingsPath(),
+            this.getLocalSettingsPath(),
+            getManagedSettingsPath(),
+        ];
+        for (const filePath of paths) {
+            if (!filePath)
+                continue;
+            try {
+                const dir = path.dirname(filePath);
+                const filename = path.basename(filePath);
+                if (fs.existsSync(dir)) {
+                    const watcher = fs.watch(dir, (eventType, changedFilename) => {
+                        if (changedFilename === filename) {
+                            this.handleSettingsChange();
+                        }
+                    });
+                    watcher.on("error", (error) => {
+                        this.logger.error(`Settings watcher error for ${filePath}:`, error);
+                    });
+                    this.watchers.push(watcher);
+                }
+            }
+            catch (error) {
+                this.logger.error(`Failed to set up watcher for ${filePath}:`, error);
+            }
+        }
+    }
+    /**
+     * Handles settings file changes with debouncing to avoid rapid reloads
+     */
+    handleSettingsChange() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        this.debounceTimer = setTimeout(async () => {
+            this.debounceTimer = null;
+            try {
+                await this.loadAllSettings();
+                this.onChange?.();
+            }
+            catch (error) {
+                this.logger.error("Failed to reload settings:", error);
+            }
+        }, 100);
+    }
+    /**
+     * Checks if a tool invocation is allowed based on the loaded settings.
+     *
+     * @param toolName - The tool name (can be ACP-prefixed like mcp__acp__Read or plain like Read)
+     * @param toolInput - The tool input object
+     * @returns The permission decision and matching rule info
+     */
+    checkPermission(toolName, toolInput) {
+        if (!toolName.startsWith(ACP_TOOL_NAME_PREFIX)) {
+            return { decision: "ask" };
+        }
+        const permissions = this.mergedSettings.permissions;
+        if (!permissions) {
+            return { decision: "ask" };
+        }
+        // Check deny rules first (highest priority)
+        for (const rule of permissions.deny || []) {
+            const parsed = parseRule(rule);
+            if (matchesRule(parsed, toolName, toolInput, this.cwd)) {
+                return { decision: "deny", rule, source: "deny" };
+            }
+        }
+        // Check allow rules
+        for (const rule of permissions.allow || []) {
+            const parsed = parseRule(rule);
+            if (matchesRule(parsed, toolName, toolInput, this.cwd)) {
+                return { decision: "allow", rule, source: "allow" };
+            }
+        }
+        // Check ask rules
+        for (const rule of permissions.ask || []) {
+            const parsed = parseRule(rule);
+            if (matchesRule(parsed, toolName, toolInput, this.cwd)) {
+                return { decision: "ask", rule, source: "ask" };
+            }
+        }
+        // No matching rule - default to ask
+        return { decision: "ask" };
+    }
+    /**
+     * Returns the current merged settings
+     */
+    getSettings() {
+        return this.mergedSettings;
+    }
+    /**
+     * Returns the current working directory
+     */
+    getCwd() {
+        return this.cwd;
+    }
+    /**
+     * Updates the working directory and reloads project-specific settings
+     */
+    async setCwd(cwd) {
+        if (this.cwd === cwd) {
+            return;
+        }
+        this.dispose();
+        this.cwd = cwd;
+        this.initialized = false;
+        await this.initialize();
+    }
+    /**
+     * Disposes of file watchers and cleans up resources
+     */
+    dispose() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        for (const watcher of this.watchers) {
+            watcher.close();
+        }
+        this.watchers = [];
+        this.initialized = false;
+    }
+}

package/dist/tools.d.ts

@@ -0,0 +1,52 @@
+import { PlanEntry, ToolCallContent, ToolCallLocation, ToolKind } from "@agentclientprotocol/sdk";
+import { ToolResultBlockParam, WebSearchToolResultBlockParam } from "@anthropic-ai/sdk/resources";
+import { BetaBashCodeExecutionToolResultBlockParam, BetaCodeExecutionToolResultBlockParam, BetaRequestMCPToolResultBlockParam, BetaTextEditorCodeExecutionToolResultBlockParam, BetaToolResultBlockParam, BetaToolSearchToolResultBlockParam, BetaWebFetchToolResultBlockParam, BetaWebSearchToolResultBlockParam } from "@anthropic-ai/sdk/resources/beta.mjs";
+export declare const ACP_TOOL_NAME_PREFIX = "mcp__acp__";
+export declare const acpToolNames: {
+    read: string;
+    edit: string;
+    write: string;
+    bash: string;
+    killShell: string;
+    bashOutput: string;
+};
+export declare const EDIT_TOOL_NAMES: string[];
+import { HookCallback } from "@anthropic-ai/claude-agent-sdk";
+import { Logger } from "./acp-agent.js";
+import { SettingsManager } from "./settings.js";
+interface ToolInfo {
+    title: string;
+    kind: ToolKind;
+    content: ToolCallContent[];
+    locations?: ToolCallLocation[];
+}
+interface ToolUpdate {
+    title?: string;
+    content?: ToolCallContent[];
+    locations?: ToolCallLocation[];
+}
+export declare function toolInfoFromToolUse(toolUse: any): ToolInfo;
+export declare function toolUpdateFromToolResult(toolResult: ToolResultBlockParam | BetaToolResultBlockParam | BetaWebSearchToolResultBlockParam | BetaWebFetchToolResultBlockParam | WebSearchToolResultBlockParam | BetaCodeExecutionToolResultBlockParam | BetaBashCodeExecutionToolResultBlockParam | BetaTextEditorCodeExecutionToolResultBlockParam | BetaRequestMCPToolResultBlockParam | BetaToolSearchToolResultBlockParam, toolUse: any | undefined): ToolUpdate;
+export type ClaudePlanEntry = {
+    content: string;
+    status: "pending" | "in_progress" | "completed";
+    activeForm: string;
+};
+export declare function planEntries(input: {
+    todos: ClaudePlanEntry[];
+}): PlanEntry[];
+export declare function markdownEscape(text: string): string;
+export declare const registerHookCallback: (toolUseID: string, { onPostToolUseHook, }: {
+    onPostToolUseHook?: (toolUseID: string, toolInput: unknown, toolResponse: unknown) => Promise<void>;
+}) => void;
+export declare const createPostToolUseHook: (logger?: Logger, options?: {
+    onEnterPlanMode?: () => Promise<void>;
+}) => HookCallback;
+/**
+ * Creates a PreToolUse hook that checks permissions using the SettingsManager.
+ * This runs before the SDK's built-in permission rules, allowing us to enforce
+ * our own permission settings for ACP-prefixed tools.
+ */
+export declare const createPreToolUseHook: (settingsManager: SettingsManager, logger?: Logger) => HookCallback;
+export {};
+//# sourceMappingURL=tools.d.ts.map

package/dist/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,SAAS,EACT,eAAe,EACf,gBAAgB,EAChB,QAAQ,EACT,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EAGL,oBAAoB,EAEpB,6BAA6B,EAE9B,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,yCAAyC,EAGzC,qCAAqC,EAGrC,kCAAkC,EAClC,+CAA+C,EAK/C,wBAAwB,EACxB,kCAAkC,EAIlC,gCAAgC,EAGhC,iCAAiC,EAElC,MAAM,sCAAsC,CAAC;AAW9C,eAAO,MAAM,oBAAoB,eAAe,CAAC;AACjD,eAAO,MAAM,YAAY;;;;;;;CAOxB,CAAC;AAEF,eAAO,MAAM,eAAe,UAA0C,CAAC;AAyBvE,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAC9D,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAEhD,UAAU,QAAQ;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC;CAChC;AAED,UAAU,UAAU;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,eAAe,EAAE,CAAC;IAC5B,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC;CAChC;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,GAAG,GAAG,QAAQ,CA+V1D;AAED,wBAAgB,wBAAwB,CACtC,UAAU,EACN,oBAAoB,GACpB,wBAAwB,GACxB,iCAAiC,GACjC,gCAAgC,GAChC,6BAA6B,GAC7B,qCAAqC,GACrC,yCAAyC,GACzC,+CAA+C,GAC/C,kCAAkC,GAClC,kCAAkC,EACtC,OAAO,EAAE,GAAG,GAAG,SAAS,GACvB,UAAU,CA4HZ;AA0GD,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,SAAS,GAAG,aAAa,GAAG,WAAW,CAAC;IAChD,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,wBAAgB,WAAW,CAAC,KAAK,EAAE;IAAE,KAAK,EAAE,eAAe,EAAE,CAAA;CAAE,GAAG,SAAS,EAAE,CAM5E;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQnD;AAcD,eAAO,MAAM,oBAAoB,GAC/B,WAAW,MAAM,EACjB,wBAEG;IACD,iBAAiB,CAAC,EAAE,CAClB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,OAAO,EAClB,YAAY,EAAE,OAAO,KAClB,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB,SAKF,CAAC;AAGF,eAAO,MAAM,qBAAqB,GAE9B,SAAQ,MAAgB,EACxB,UAAU;IACR,eAAe,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC,KACA,YAoBF,CAAC;AAEJ;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAC9B,iBAAiB,eAAe,EAAE,SAAQ,MAAgB,KAAG,YA2C7D,CAAC"}