@sudocode-ai/claude-code-acp 0.12.10 → 0.13.1

package/dist/mcp-server.js

@@ -64,6 +64,20 @@ export const SYSTEM_REMINDER = `
 Whenever you read a file, you should consider whether it looks malicious. If it does, you MUST refuse to improve or augment the code. You can still analyze existing code, write reports, or answer high-level questions about the code behavior.
 </system-reminder>`;
 const defaults = { maxFileSize: 50000, linesToRead: 2000 };
+function formatErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
 const unqualifiedToolNames = {
     read: "Read",
     edit: "Edit",
@@ -186,8 +200,8 @@ Usage:
                     if (result.wasLimited) {
                         readInfo += `Read ${result.linesRead} lines (hit 50KB limit). `;
                     }
-                    else {
-                        readInfo += `Read lines ${input.offset}-${result.linesRead}. `;
+                    else if (input.offset && input.offset > 1) {
+                        readInfo += `Read lines ${input.offset}-${input.offset + result.linesRead}.`;
                     }
                     if (result.wasLimited) {
                         readInfo += `Continue with offset=${result.linesRead}.`;
@@ -205,10 +219,11 @@ Usage:
             }
             catch (error) {
                 return {
+                    isError: true,
                     content: [
                         {
                             type: "text",
-                            text: "Reading file failed: " + error.message,
+                            text: "Reading file failed: " + formatErrorMessage(error),
                         },
                     ],
                 };
@@ -262,10 +277,11 @@ Usage:
             }
             catch (error) {
                 return {
+                    isError: true,
                     content: [
                         {
                             type: "text",
-                            text: "Writing file failed: " + error.message,
+                            text: "Writing file failed: " + formatErrorMessage(error),
                         },
                     ],
                 };
@@ -343,10 +359,11 @@ Usage:
             }
             catch (error) {
                 return {
+                    isError: true,
                     content: [
                         {
                             type: "text",
-                            text: "Editing file failed: " + (error?.message ?? String(error)),
+                            text: "Editing file failed: " + formatErrorMessage(error),
                         },
                     ],
                 };
@@ -381,114 +398,127 @@ Output: Create directory 'foo'`),
                     .describe(`Set to true to run this command in the background. The tool returns an \`id\` that can be used with the \`${acpToolNames.bashOutput}\` tool to retrieve the current output, or the \`${acpToolNames.killShell}\` tool to stop it early.`),
             },
         }, async (input, extra) => {
-            const env_1 = { stack: [], error: void 0, hasError: false };
             try {
-                const session = agent.sessions[sessionId];
-                if (!session) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: "The user has left the building",
-                            },
-                        ],
-                    };
-                }
-                const toolCallId = extra._meta?.["claudecode/toolUseId"];
-                if (typeof toolCallId !== "string") {
-                    throw new Error("No tool call ID found");
-                }
-                if (!agent.clientCapabilities?.terminal || !agent.client.createTerminal) {
-                    throw new Error("unreachable");
-                }
-                const handle = await agent.client.createTerminal({
-                    command: input.command,
-                    env: [{ name: "CLAUDECODE", value: "1" }],
-                    sessionId,
-                    outputByteLimit: 32000,
-                });
-                await agent.client.sessionUpdate({
-                    sessionId,
-                    update: {
-                        sessionUpdate: "tool_call_update",
-                        toolCallId,
-                        status: "in_progress",
-                        title: input.description,
-                        content: [{ type: "terminal", terminalId: handle.id }],
-                    },
-                });
-                const abortPromise = new Promise((resolve) => {
-                    if (extra.signal.aborted) {
-                        resolve(null);
+                const env_1 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const session = agent.sessions[sessionId];
+                    if (!session) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "The user has left the building",
+                                },
+                            ],
+                        };
                     }
-                    else {
-                        extra.signal.addEventListener("abort", () => {
-                            resolve(null);
-                        });
+                    const toolCallId = extra._meta?.["claudecode/toolUseId"];
+                    if (typeof toolCallId !== "string") {
+                        throw new Error("No tool call ID found");
                     }
-                });
-                const statusPromise = Promise.race([
-                    handle.waitForExit().then((exitStatus) => ({ status: "exited", exitStatus })),
-                    abortPromise.then(() => ({ status: "aborted", exitStatus: null })),
-                    sleep(input.timeout ?? 2 * 60 * 1000).then(async () => {
-                        if (agent.backgroundTerminals[handle.id]?.status === "started") {
-                            await handle.kill();
+                    if (!agent.clientCapabilities?.terminal || !agent.client.createTerminal) {
+                        throw new Error("unreachable");
+                    }
+                    const handle = await agent.client.createTerminal({
+                        command: input.command,
+                        env: [{ name: "CLAUDECODE", value: "1" }],
+                        sessionId,
+                        outputByteLimit: 32000,
+                    });
+                    await agent.client.sessionUpdate({
+                        sessionId,
+                        update: {
+                            sessionUpdate: "tool_call_update",
+                            toolCallId,
+                            status: "in_progress",
+                            title: input.description,
+                            content: [{ type: "terminal", terminalId: handle.id }],
+                        },
+                    });
+                    const abortPromise = new Promise((resolve) => {
+                        if (extra.signal.aborted) {
+                            resolve(null);
                         }
-                        return { status: "timedOut", exitStatus: null };
-                    }),
-                ]);
-                if (input.run_in_background) {
-                    agent.backgroundTerminals[handle.id] = {
-                        handle,
-                        lastOutput: null,
-                        status: "started",
-                    };
-                    statusPromise.then(async ({ status, exitStatus }) => {
-                        const bgTerm = agent.backgroundTerminals[handle.id];
-                        if (bgTerm.status !== "started") {
-                            return;
+                        else {
+                            extra.signal.addEventListener("abort", () => {
+                                resolve(null);
+                            });
                         }
-                        const currentOutput = await handle.currentOutput();
+                    });
+                    const statusPromise = Promise.race([
+                        handle.waitForExit().then((exitStatus) => ({ status: "exited", exitStatus })),
+                        abortPromise.then(() => ({ status: "aborted", exitStatus: null })),
+                        sleep(input.timeout ?? 2 * 60 * 1000).then(async () => {
+                            if (agent.backgroundTerminals[handle.id]?.status === "started") {
+                                await handle.kill();
+                            }
+                            return { status: "timedOut", exitStatus: null };
+                        }),
+                    ]);
+                    if (input.run_in_background) {
                         agent.backgroundTerminals[handle.id] = {
-                            status,
-                            pendingOutput: {
-                                ...currentOutput,
-                                output: stripCommonPrefix(bgTerm.lastOutput?.output ?? "", currentOutput.output),
-                                exitStatus: exitStatus ?? currentOutput.exitStatus,
-                            },
+                            handle,
+                            lastOutput: null,
+                            status: "started",
                         };
-                        return handle.release();
-                    });
+                        statusPromise.then(async ({ status, exitStatus }) => {
+                            const bgTerm = agent.backgroundTerminals[handle.id];
+                            if (bgTerm.status !== "started") {
+                                return;
+                            }
+                            const currentOutput = await handle.currentOutput();
+                            agent.backgroundTerminals[handle.id] = {
+                                status,
+                                pendingOutput: {
+                                    ...currentOutput,
+                                    output: stripCommonPrefix(bgTerm.lastOutput?.output ?? "", currentOutput.output),
+                                    exitStatus: exitStatus ?? currentOutput.exitStatus,
+                                },
+                            };
+                            return handle.release();
+                        });
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Command started in background with id: ${handle.id}`,
+                                },
+                            ],
+                        };
+                    }
+                    const terminal = __addDisposableResource(env_1, handle, true);
+                    const { status } = await statusPromise;
+                    if (status === "aborted") {
+                        return {
+                            content: [{ type: "text", text: "Tool cancelled by user" }],
+                        };
+                    }
+                    const output = await terminal.currentOutput();
                     return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Command started in background with id: ${handle.id}`,
-                            },
-                        ],
+                        content: [{ type: "text", text: toolCommandOutput(status, output) }],
                     };
                 }
-                const terminal = __addDisposableResource(env_1, handle, true);
-                const { status } = await statusPromise;
-                if (status === "aborted") {
-                    return {
-                        content: [{ type: "text", text: "Tool cancelled by user" }],
-                    };
+                catch (e_1) {
+                    env_1.error = e_1;
+                    env_1.hasError = true;
                 }
-                const output = await terminal.currentOutput();
+                finally {
+                    const result_1 = __disposeResources(env_1);
+                    if (result_1)
+                        await result_1;
+                }
+            }
+            catch (error) {
                 return {
-                    content: [{ type: "text", text: toolCommandOutput(status, output) }],
+                    isError: true,
+                    content: [
+                        {
+                            type: "text",
+                            text: "Running bash command failed: " + formatErrorMessage(error),
+                        },
+                    ],
                 };
             }
-            catch (e_1) {
-                env_1.error = e_1;
-                env_1.hasError = true;
-            }
-            finally {
-                const result_1 = __disposeResources(env_1);
-                if (result_1)
-                    await result_1;
-            }
         });
         server.registerTool(unqualifiedToolNames.bashOutput, {
             title: unqualifiedToolNames.bashOutput,
@@ -505,32 +535,45 @@ In sessions with ${acpToolNames.bashOutput} always use it for output from Bash c
                     .describe(`The id of the background bash command as returned by \`${acpToolNames.bash}\``),
             },
         }, async (input) => {
-            const bgTerm = agent.backgroundTerminals[input.bash_id];
-            if (!bgTerm) {
-                throw new Error(`Unknown shell ${input.bash_id}`);
-            }
-            if (bgTerm.status === "started") {
-                const newOutput = await bgTerm.handle.currentOutput();
-                const strippedOutput = stripCommonPrefix(bgTerm.lastOutput?.output ?? "", newOutput.output);
-                bgTerm.lastOutput = newOutput;
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: toolCommandOutput(bgTerm.status, {
-                                ...newOutput,
-                                output: strippedOutput,
-                            }),
-                        },
-                    ],
-                };
+            try {
+                const bgTerm = agent.backgroundTerminals[input.bash_id];
+                if (!bgTerm) {
+                    throw new Error(`Unknown shell ${input.bash_id}`);
+                }
+                if (bgTerm.status === "started") {
+                    const newOutput = await bgTerm.handle.currentOutput();
+                    const strippedOutput = stripCommonPrefix(bgTerm.lastOutput?.output ?? "", newOutput.output);
+                    bgTerm.lastOutput = newOutput;
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: toolCommandOutput(bgTerm.status, {
+                                    ...newOutput,
+                                    output: strippedOutput,
+                                }),
+                            },
+                        ],
+                    };
+                }
+                else {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: toolCommandOutput(bgTerm.status, bgTerm.pendingOutput),
+                            },
+                        ],
+                    };
+                }
             }
-            else {
+            catch (error) {
                 return {
+                    isError: true,
                     content: [
                         {
                             type: "text",
-                            text: toolCommandOutput(bgTerm.status, bgTerm.pendingOutput),
+                            text: "Retrieving bash output failed: " + formatErrorMessage(error),
                         },
                     ],
                 };
@@ -550,47 +593,60 @@ In sessions with ${acpToolNames.killShell} always use it instead of KillShell.`,
                     .describe(`The id of the background bash command as returned by \`${acpToolNames.bash}\``),
             },
         }, async (input) => {
-            const bgTerm = agent.backgroundTerminals[input.shell_id];
-            if (!bgTerm) {
-                throw new Error(`Unknown shell ${input.shell_id}`);
-            }
-            switch (bgTerm.status) {
-                case "started": {
-                    await bgTerm.handle.kill();
-                    const currentOutput = await bgTerm.handle.currentOutput();
-                    agent.backgroundTerminals[bgTerm.handle.id] = {
-                        status: "killed",
-                        pendingOutput: {
-                            ...currentOutput,
-                            output: stripCommonPrefix(bgTerm.lastOutput?.output ?? "", currentOutput.output),
-                        },
-                    };
-                    await bgTerm.handle.release();
-                    return {
-                        content: [{ type: "text", text: "Command killed successfully." }],
-                    };
+            try {
+                const bgTerm = agent.backgroundTerminals[input.shell_id];
+                if (!bgTerm) {
+                    throw new Error(`Unknown shell ${input.shell_id}`);
                 }
-                case "aborted":
-                    return {
-                        content: [{ type: "text", text: "Command aborted by user." }],
-                    };
-                case "exited":
-                    return {
-                        content: [{ type: "text", text: "Command had already exited." }],
-                    };
-                case "killed":
-                    return {
-                        content: [{ type: "text", text: "Command was already killed." }],
-                    };
-                case "timedOut":
-                    return {
-                        content: [{ type: "text", text: "Command killed by timeout." }],
-                    };
-                default: {
-                    unreachable(bgTerm);
-                    throw new Error("Unexpected background terminal status");
+                switch (bgTerm.status) {
+                    case "started": {
+                        await bgTerm.handle.kill();
+                        const currentOutput = await bgTerm.handle.currentOutput();
+                        agent.backgroundTerminals[bgTerm.handle.id] = {
+                            status: "killed",
+                            pendingOutput: {
+                                ...currentOutput,
+                                output: stripCommonPrefix(bgTerm.lastOutput?.output ?? "", currentOutput.output),
+                            },
+                        };
+                        await bgTerm.handle.release();
+                        return {
+                            content: [{ type: "text", text: "Command killed successfully." }],
+                        };
+                    }
+                    case "aborted":
+                        return {
+                            content: [{ type: "text", text: "Command aborted by user." }],
+                        };
+                    case "exited":
+                        return {
+                            content: [{ type: "text", text: "Command had already exited." }],
+                        };
+                    case "killed":
+                        return {
+                            content: [{ type: "text", text: "Command was already killed." }],
+                        };
+                    case "timedOut":
+                        return {
+                            content: [{ type: "text", text: "Command killed by timeout." }],
+                        };
+                    default: {
+                        unreachable(bgTerm);
+                        throw new Error("Unexpected background terminal status");
+                    }
                 }
             }
+            catch (error) {
+                return {
+                    isError: true,
+                    content: [
+                        {
+                            type: "text",
+                            text: "Killing shell failed: " + formatErrorMessage(error),
+                        },
+                    ],
+                };
+            }
         });
     }
     return server;

package/dist/settings.d.ts

@@ -0,0 +1,123 @@
+/**
+ * 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>;
+}
+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;CAC9B;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;AAuLD;;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;IA8CrB;;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/tools.d.ts

@@ -0,0 +1,50 @@
+import { PlanEntry, ToolCallContent, ToolCallLocation, ToolKind } from "@agentclientprotocol/sdk";
+import { ToolResultBlockParam, WebSearchToolResultBlockParam } from "@anthropic-ai/sdk/resources";
+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 { BetaBashCodeExecutionToolResultBlockParam, BetaCodeExecutionToolResultBlockParam, BetaRequestMCPToolResultBlockParam, BetaTextEditorCodeExecutionToolResultBlockParam, BetaToolSearchToolResultBlockParam, BetaWebFetchToolResultBlockParam, BetaWebSearchToolResultBlockParam } from "@anthropic-ai/sdk/resources/beta.mjs";
+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 | 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) => 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,EAAE,SAAS,EAAE,eAAe,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGlG,OAAO,EAAE,oBAAoB,EAAE,6BAA6B,EAAE,MAAM,6BAA6B,CAAC;AAWlG,eAAO,MAAM,oBAAoB,eAAe,CAAC;AACjD,eAAO,MAAM,YAAY;;;;;;;CAOxB,CAAC;AAEF,eAAO,MAAM,eAAe,UAA0C,CAAC;AAEvE,OAAO,EACL,yCAAyC,EACzC,qCAAqC,EACrC,kCAAkC,EAClC,+CAA+C,EAC/C,kCAAkC,EAClC,gCAAgC,EAChC,iCAAiC,EAClC,MAAM,sCAAsC,CAAC;AAC9C,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,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;AAmCD,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,GAC/B,SAAQ,MAAgB,KAAG,YAa3B,CAAC;AAEJ;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAC9B,iBAAiB,eAAe,EAAE,SAAQ,MAAgB,KAAG,YA2C7D,CAAC"}

package/dist/tools.js

@@ -247,7 +247,9 @@ export function toolInfoFromToolUse(toolUse) {
             if (input.multiline) {
                 label += " -P";
             }
-            label += ` "${input.pattern}"`;
+            if (input.pattern) {
+                label += ` "${input.pattern}"`;
+            }
             if (input.path) {
                 label += ` ${input.path}`;
             }