@antmanler/claude-code-acp 0.13.0 → 0.13.2

package/dist/acp-agent.js

@@ -117,6 +117,18 @@ export class ClaudeAcpAgent {
                 case "system":
                     switch (message.subtype) {
                         case "init":
+                            // Update permission mode from Claude Code's actual configuration
+                            if (this.sessions[params.sessionId]) {
+                                this.sessions[params.sessionId].permissionMode = message.permissionMode;
+                                // Notify client of the actual permission mode
+                                await this.client.sessionUpdate({
+                                    sessionId: params.sessionId,
+                                    update: {
+                                        sessionUpdate: "current_mode_update",
+                                        currentModeId: message.permissionMode,
+                                    },
+                                });
+                            }
                             break;
                         case "compact_boundary":
                         case "hook_response":
@@ -245,6 +257,14 @@ export class ClaudeAcpAgent {
                 this.sessions[params.sessionId].permissionMode = params.modeId;
                 try {
                     await this.sessions[params.sessionId].query.setPermissionMode(params.modeId);
+                    // Notify client of the mode change
+                    await this.client.sessionUpdate({
+                        sessionId: params.sessionId,
+                        update: {
+                            sessionUpdate: "current_mode_update",
+                            currentModeId: params.modeId,
+                        },
+                    });
                 }
                 catch (error) {
                     const errorMessage = error instanceof Error && error.message ? error.message : "Invalid Mode";
@@ -255,6 +275,12 @@ export class ClaudeAcpAgent {
                 throw new Error("Invalid Mode");
         }
     }
+    /**
+     * Get the current permission mode for a session
+     */
+    getCurrentPermissionMode(sessionId) {
+        return this.sessions[sessionId]?.permissionMode;
+    }
     async readTextFile(params) {
         const response = await this.client.readTextFile(params);
         return response;
@@ -470,7 +496,7 @@ export class ClaudeAcpAgent {
             // If we want bypassPermissions to be an option, we have to allow it here.
             // But it doesn't work in root mode, so we only activate it if it will work.
             allowDangerouslySkipPermissions: !IS_ROOT,
-            permissionMode,
+            // permissionMode,
             canUseTool: this.canUseTool(sessionId),
             // note: although not documented by the types, passing an absolute path
             // here works to find zed's managed node version.

package/dist/tests/acp-agent.test.js

@@ -3,7 +3,7 @@ import { spawn, spawnSync } from "child_process";
 import { ClientSideConnection, ndJsonStream, } from "@agentclientprotocol/sdk";
 import { nodeToWebWritable, nodeToWebReadable } from "../utils.js";
 import { markdownEscape, toolInfoFromToolUse, toolUpdateFromToolResult } from "../tools.js";
-import { toAcpNotifications, promptToClaude } from "../acp-agent.js";
+import { toAcpNotifications, promptToClaude, ClaudeAcpAgent } from "../acp-agent.js";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { randomUUID } from "crypto";
 describe.skipIf(!process.env.RUN_INTEGRATION_TESTS)("ACP subprocess integration", () => {
@@ -751,3 +751,157 @@ describe("permission requests", () => {
         }
     });
 });
+describe("permission mode management", () => {
+    it("should get current permission mode for existing session", () => {
+        const agent = new ClaudeAcpAgent({});
+        const sessionId = randomUUID();
+        // Manually add a session to test
+        agent.sessions[sessionId] = {
+            permissionMode: "acceptEdits",
+            query: {},
+            input: {},
+            cancelled: false,
+            settingsManager: {},
+        };
+        const mode = agent.getCurrentPermissionMode(sessionId);
+        expect(mode).toBe("acceptEdits");
+    });
+    it("should return undefined for non-existent session", () => {
+        const agent = new ClaudeAcpAgent({});
+        const nonExistentSessionId = randomUUID();
+        const mode = agent.getCurrentPermissionMode(nonExistentSessionId);
+        expect(mode).toBeUndefined();
+    });
+    it("should track all permission modes correctly", () => {
+        const agent = new ClaudeAcpAgent({});
+        const modes = ["default", "acceptEdits", "bypassPermissions", "dontAsk", "plan"];
+        modes.forEach((mode) => {
+            const sessionId = randomUUID();
+            agent.sessions[sessionId] = {
+                permissionMode: mode,
+                query: {},
+                input: {},
+                cancelled: false,
+                settingsManager: {},
+            };
+            expect(agent.getCurrentPermissionMode(sessionId)).toBe(mode);
+        });
+    });
+    it("should sync permission mode from SDK init message", async () => {
+        // Track sessionUpdate calls
+        const sessionUpdates = [];
+        const mockClient = {
+            sessionUpdate: async (params) => {
+                sessionUpdates.push(params);
+            },
+        };
+        const agent = new ClaudeAcpAgent(mockClient);
+        const sessionId = randomUUID();
+        // Manually create a session with default mode
+        agent.sessions[sessionId] = {
+            permissionMode: "default",
+            query: {},
+            input: {},
+            cancelled: false,
+            settingsManager: {},
+        };
+        // Simulate an init message with a different permission mode
+        const initMessage = {
+            type: "system",
+            subtype: "init",
+            permissionMode: "bypassPermissions",
+        };
+        // Manually trigger the logic from the prompt method (case "init")
+        if (agent.sessions[sessionId]) {
+            agent.sessions[sessionId].permissionMode = initMessage.permissionMode;
+            await agent.client.sessionUpdate({
+                sessionId: sessionId,
+                update: {
+                    sessionUpdate: "current_mode_update",
+                    currentModeId: initMessage.permissionMode,
+                },
+            });
+        }
+        // Verify the permission mode was updated
+        expect(agent.getCurrentPermissionMode(sessionId)).toBe("bypassPermissions");
+        // Verify sessionUpdate was called with correct parameters
+        expect(sessionUpdates).toHaveLength(1);
+        expect(sessionUpdates[0]).toEqual({
+            sessionId: sessionId,
+            update: {
+                sessionUpdate: "current_mode_update",
+                currentModeId: "bypassPermissions",
+            },
+        });
+    });
+    it("should notify client when permission mode changes", async () => {
+        // Track sessionUpdate calls
+        const sessionUpdates = [];
+        const mockClient = {
+            sessionUpdate: async (params) => {
+                sessionUpdates.push(params);
+            },
+        };
+        const agent = new ClaudeAcpAgent(mockClient);
+        const sessionId = randomUUID();
+        // Manually create a session
+        agent.sessions[sessionId] = {
+            permissionMode: "default",
+            query: {
+                setPermissionMode: async (_mode) => {
+                    // Mock implementation
+                },
+            },
+            input: {},
+            cancelled: false,
+            settingsManager: {},
+        };
+        // Call setSessionMode
+        await agent.setSessionMode({
+            sessionId: sessionId,
+            modeId: "acceptEdits",
+        });
+        // Verify the permission mode was updated
+        expect(agent.getCurrentPermissionMode(sessionId)).toBe("acceptEdits");
+        // Verify sessionUpdate was called
+        expect(sessionUpdates).toHaveLength(1);
+        expect(sessionUpdates[0]).toEqual({
+            sessionId: sessionId,
+            update: {
+                sessionUpdate: "current_mode_update",
+                currentModeId: "acceptEdits",
+            },
+        });
+    });
+    it("should handle setSessionMode errors without sending update", async () => {
+        const sessionUpdates = [];
+        const mockClient = {
+            sessionUpdate: async (params) => {
+                sessionUpdates.push(params);
+            },
+        };
+        const agent = new ClaudeAcpAgent(mockClient);
+        const sessionId = randomUUID();
+        // Create session with query that throws error
+        agent.sessions[sessionId] = {
+            permissionMode: "default",
+            query: {
+                setPermissionMode: async (_mode) => {
+                    throw new Error("Test error");
+                },
+            },
+            input: {},
+            cancelled: false,
+            settingsManager: {},
+        };
+        // Try to change mode - should throw
+        await expect(agent.setSessionMode({
+            sessionId: sessionId,
+            modeId: "acceptEdits",
+        })).rejects.toThrow("Test error");
+        // Verify no sessionUpdate was sent
+        expect(sessionUpdates).toHaveLength(0);
+        // Permission mode should still be updated locally (happens before SDK call)
+        expect(agent.getCurrentPermissionMode(sessionId)).toBe("acceptEdits");
+    });
+});

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.13.0",
+  "version": "0.13.2",
   "description": "An ACP-compatible coding agent powered by the Claude Code SDK (TypeScript)",
   "main": "dist/lib.js",
   "bin": {