@antmanler/claude-code-acp 0.12.6

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

@@ -0,0 +1,753 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+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 { query } from "@anthropic-ai/claude-agent-sdk";
+import { randomUUID } from "crypto";
+describe.skipIf(!process.env.RUN_INTEGRATION_TESTS)("ACP subprocess integration", () => {
+    let child;
+    beforeAll(async () => {
+        const valid = spawnSync("tsc", { stdio: "inherit" });
+        if (valid.status) {
+            throw new Error("failed to compile");
+        }
+        // Start the subprocess
+        child = spawn("npm", ["run", "--silent", "dev"], {
+            stdio: ["pipe", "pipe", "inherit"],
+            env: process.env,
+        });
+        child.on("error", (error) => {
+            console.error("Error starting subprocess:", error);
+        });
+        child.on("exit", (exit) => {
+            console.error("Exited with", exit);
+        });
+    });
+    afterAll(() => {
+        child.kill();
+    });
+    class TestClient {
+        constructor(agent) {
+            this.files = new Map();
+            this.receivedText = "";
+            this.agent = agent;
+            this.resolveAvailableCommands = () => { };
+            this.availableCommandsPromise = new Promise((resolve) => {
+                this.resolveAvailableCommands = resolve;
+            });
+        }
+        takeReceivedText() {
+            const text = this.receivedText;
+            this.receivedText = "";
+            return text;
+        }
+        async requestPermission(params) {
+            const optionId = params.options.find((p) => p.kind === "allow_once").optionId;
+            return { outcome: { outcome: "selected", optionId } };
+        }
+        async sessionUpdate(params) {
+            console.error("RECEIVED", JSON.stringify(params, null, 4));
+            switch (params.update.sessionUpdate) {
+                case "agent_message_chunk": {
+                    if (params.update.content.type === "text") {
+                        this.receivedText += params.update.content.text;
+                    }
+                    break;
+                }
+                case "available_commands_update":
+                    this.resolveAvailableCommands(params.update.availableCommands);
+                    break;
+                default:
+                    break;
+            }
+        }
+        async writeTextFile(params) {
+            this.files.set(params.path, params.content);
+            return {};
+        }
+        async readTextFile(params) {
+            const content = this.files.get(params.path) ?? "";
+            return {
+                content,
+            };
+        }
+    }
+    async function setupTestSession(cwd) {
+        let client;
+        const input = nodeToWebWritable(child.stdin);
+        const output = nodeToWebReadable(child.stdout);
+        const stream = ndJsonStream(input, output);
+        const connection = new ClientSideConnection((agent) => {
+            client = new TestClient(agent);
+            return client;
+        }, stream);
+        await connection.initialize({
+            protocolVersion: 1,
+            clientCapabilities: {
+                fs: {
+                    readTextFile: true,
+                    writeTextFile: true,
+                },
+            },
+        });
+        const newSessionResponse = await connection.newSession({
+            cwd,
+            mcpServers: [],
+        });
+        return { client: client, connection, newSessionResponse };
+    }
+    it("should connect to the ACP subprocess", async () => {
+        const { client, connection, newSessionResponse } = await setupTestSession("./");
+        await connection.prompt({
+            prompt: [
+                {
+                    type: "text",
+                    text: "Hello",
+                },
+            ],
+            sessionId: newSessionResponse.sessionId,
+        });
+        expect(client.takeReceivedText()).not.toEqual("");
+    }, 30000);
+    it("should include available commands", async () => {
+        const { client, connection, newSessionResponse } = await setupTestSession(__dirname);
+        const commands = await client.availableCommandsPromise;
+        expect(commands).toContainEqual({
+            name: "quick-math",
+            description: "10 * 3 = 30 (project)",
+            input: null,
+        });
+        expect(commands).toContainEqual({
+            name: "say-hello",
+            description: "Say hello (project)",
+            input: { hint: "[name]" },
+        });
+        await connection.prompt({
+            prompt: [
+                {
+                    type: "text",
+                    text: "/quick-math",
+                },
+            ],
+            sessionId: newSessionResponse.sessionId,
+        });
+        expect(client.takeReceivedText()).toContain("30");
+        await connection.prompt({
+            prompt: [
+                {
+                    type: "text",
+                    text: "/say-hello GPT-5",
+                },
+            ],
+            sessionId: newSessionResponse.sessionId,
+        });
+        expect(client.takeReceivedText()).toContain("Hello GPT-5");
+    }, 30000);
+    it("/compact works", async () => {
+        const { client, connection, newSessionResponse } = await setupTestSession(__dirname);
+        const commands = await client.availableCommandsPromise;
+        expect(commands).toContainEqual({
+            description: "Clear conversation history but keep a summary in context. Optional: /compact [instructions for summarization]",
+            input: {
+                hint: "<optional custom summarization instructions>",
+            },
+            name: "compact",
+        });
+        // Error case (no previous message)
+        await connection.prompt({
+            prompt: [{ type: "text", text: "/compact" }],
+            sessionId: newSessionResponse.sessionId,
+        });
+        expect(client.takeReceivedText()).toBe("");
+        // Send something
+        await connection.prompt({
+            prompt: [{ type: "text", text: "Hi" }],
+            sessionId: newSessionResponse.sessionId,
+        });
+        // Clear response
+        client.takeReceivedText();
+        // Test with instruction
+        await connection.prompt({
+            prompt: [
+                {
+                    type: "text",
+                    text: "/compact greeting",
+                },
+            ],
+            sessionId: newSessionResponse.sessionId,
+        });
+        expect(client.takeReceivedText()).toContain("");
+    }, 30000);
+});
+describe("tool conversions", () => {
+    it("should handle Bash nicely", () => {
+        const tool_use = {
+            type: "tool_use",
+            id: "toolu_01VtsS2mxUFwpBJZYd7BmbC9",
+            name: "Bash",
+            input: {
+                command: "rm README.md.rm",
+                description: "Delete README.md.rm file",
+            },
+        };
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
+            kind: "execute",
+            title: "`rm README.md.rm`",
+            content: [
+                {
+                    content: {
+                        text: "Delete README.md.rm file",
+                        type: "text",
+                    },
+                    type: "content",
+                },
+            ],
+        });
+    });
+    it("should handle Glob nicely", () => {
+        const tool_use = {
+            type: "tool_use",
+            id: "toolu_01VtsS2mxUFwpBJZYd7BmbC9",
+            name: "Glob",
+            input: {
+                pattern: "*/**.ts",
+            },
+        };
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
+            kind: "search",
+            title: "Find `*/**.ts`",
+            content: [],
+            locations: [],
+        });
+    });
+    it("should handle Task tool calls", () => {
+        const tool_use = {
+            type: "tool_use",
+            id: "toolu_01ANYHYDsXcDPKgxhg7us9bj",
+            name: "Task",
+            input: {
+                description: "Handle user's work request",
+                prompt: 'The user has asked me to "Create a Task to do the work!" but hasn\'t specified what specific work they want done. I need to:\n\n1. First understand what work needs to be done by examining the current state of the repository\n2. Look at the git status to see what files have been modified\n3. Check if there are any obvious tasks that need completion based on the current state\n4. If the work isn\'t clear from the context, ask the user to specify what work they want accomplished\n\nThe git status shows: "M src/tests/acp-agent.test.ts" - there\'s a modified test file that might need attention.\n\nPlease examine the repository state and determine what work needs to be done, then either complete it or ask the user for clarification on the specific task they want accomplished.',
+                subagent_type: "general-purpose",
+            },
+        };
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
+            kind: "think",
+            title: "Handle user's work request",
+            content: [
+                {
+                    content: {
+                        text: 'The user has asked me to "Create a Task to do the work!" but hasn\'t specified what specific work they want done. I need to:\n\n1. First understand what work needs to be done by examining the current state of the repository\n2. Look at the git status to see what files have been modified\n3. Check if there are any obvious tasks that need completion based on the current state\n4. If the work isn\'t clear from the context, ask the user to specify what work they want accomplished\n\nThe git status shows: "M src/tests/acp-agent.test.ts" - there\'s a modified test file that might need attention.\n\nPlease examine the repository state and determine what work needs to be done, then either complete it or ask the user for clarification on the specific task they want accomplished.',
+                        type: "text",
+                    },
+                    type: "content",
+                },
+            ],
+        });
+    });
+    it("should handle LS tool calls", () => {
+        const tool_use = {
+            type: "tool_use",
+            id: "toolu_01EEqsX7Eb9hpx87KAHVPTey",
+            name: "LS",
+            input: {
+                path: "/Users/test/github/claude-code-acp",
+            },
+        };
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
+            kind: "search",
+            title: "List the `/Users/test/github/claude-code-acp` directory's contents",
+            content: [],
+            locations: [],
+        });
+    });
+    it("should handle Grep tool calls", () => {
+        const tool_use = {
+            type: "tool_use",
+            id: "toolu_016j8oGSD3eAZ9KT62Y7Jsjb",
+            name: "Grep",
+            input: {
+                pattern: ".*",
+            },
+        };
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
+            kind: "search",
+            title: 'grep ".*"',
+            content: [],
+        });
+    });
+    it("should handle Write tool calls", () => {
+        const tool_use = {
+            type: "tool_use",
+            id: "toolu_01ABC123XYZ789",
+            name: "Write",
+            input: {
+                file_path: "/Users/test/project/example.txt",
+                content: "Hello, World!\nThis is test content.",
+            },
+        };
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
+            kind: "edit",
+            title: "Write /Users/test/project/example.txt",
+            content: [
+                {
+                    type: "diff",
+                    path: "/Users/test/project/example.txt",
+                    oldText: null,
+                    newText: "Hello, World!\nThis is test content.",
+                },
+            ],
+            locations: [{ path: "/Users/test/project/example.txt" }],
+        });
+    });
+    it("should handle mcp__acp__Write tool calls", () => {
+        const tool_use = {
+            type: "tool_use",
+            id: "toolu_01GHI789JKL456",
+            name: "mcp__acp__Write",
+            input: {
+                file_path: "/Users/test/project/config.json",
+                content: '{"version": "1.0.0"}',
+            },
+        };
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
+            kind: "edit",
+            title: "Write /Users/test/project/config.json",
+            content: [
+                {
+                    type: "diff",
+                    path: "/Users/test/project/config.json",
+                    oldText: null,
+                    newText: '{"version": "1.0.0"}',
+                },
+            ],
+            locations: [{ path: "/Users/test/project/config.json" }],
+        });
+    });
+    it("should handle Read tool calls", () => {
+        const tool_use = {
+            type: "tool_use",
+            id: "toolu_01MNO456PQR789",
+            name: "Read",
+            input: {
+                file_path: "/Users/test/project/readme.md",
+            },
+        };
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
+            kind: "read",
+            title: "Read File",
+            content: [],
+            locations: [{ path: "/Users/test/project/readme.md", line: 0 }],
+        });
+    });
+    it("should handle mcp__acp__Read tool calls", () => {
+        const tool_use = {
+            type: "tool_use",
+            id: "toolu_01YZA789BCD123",
+            name: "mcp__acp__Read",
+            input: {
+                file_path: "/Users/test/project/data.json",
+            },
+        };
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
+            kind: "read",
+            title: "Read /Users/test/project/data.json",
+            content: [],
+            locations: [{ path: "/Users/test/project/data.json", line: 0 }],
+        });
+    });
+    it("should handle mcp__acp__Read with limit", () => {
+        const tool_use = {
+            type: "tool_use",
+            id: "toolu_01EFG456HIJ789",
+            name: "mcp__acp__Read",
+            input: {
+                file_path: "/Users/test/project/large.txt",
+                limit: 100,
+            },
+        };
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
+            kind: "read",
+            title: "Read /Users/test/project/large.txt (1 - 100)",
+            content: [],
+            locations: [{ path: "/Users/test/project/large.txt", line: 0 }],
+        });
+    });
+    it("should handle mcp__acp__Read with offset and limit", () => {
+        const tool_use = {
+            type: "tool_use",
+            id: "toolu_01KLM789NOP456",
+            name: "mcp__acp__Read",
+            input: {
+                file_path: "/Users/test/project/large.txt",
+                offset: 50,
+                limit: 100,
+            },
+        };
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
+            kind: "read",
+            title: "Read /Users/test/project/large.txt (51 - 150)",
+            content: [],
+            locations: [{ path: "/Users/test/project/large.txt", line: 50 }],
+        });
+    });
+    it("should handle mcp__acp__Read with only offset", () => {
+        const tool_use = {
+            type: "tool_use",
+            id: "toolu_01QRS123TUV789",
+            name: "mcp__acp__Read",
+            input: {
+                file_path: "/Users/test/project/large.txt",
+                offset: 200,
+            },
+        };
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
+            kind: "read",
+            title: "Read /Users/test/project/large.txt (from line 201)",
+            content: [],
+            locations: [{ path: "/Users/test/project/large.txt", line: 200 }],
+        });
+    });
+    it("should handle KillBash entries", () => {
+        const tool_use = {
+            type: "tool_use",
+            id: "toolu_01PhLms5fuvmdjy2bb6dfUKT",
+            name: "KillShell",
+            input: {
+                shell_id: "bash_1",
+            },
+        };
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
+            kind: "execute",
+            title: `Kill Process`,
+            content: [],
+        });
+    });
+    it("should handle BashOutput entries", () => {
+        const tool_use = {
+            type: "tool_use",
+            id: "toolu_01SJUWPtj1QspgANgtpqGPuN",
+            name: "BashOutput",
+            input: {
+                bash_id: "bash_1",
+            },
+        };
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
+            kind: "execute",
+            title: `Tail Logs`,
+            content: [],
+        });
+    });
+    it("should handle plan entries", () => {
+        const received = {
+            type: "assistant",
+            message: {
+                id: "msg_017eNosJgww7F5qD4a8BcAcx",
+                type: "message",
+                role: "assistant",
+                container: null,
+                model: "claude-sonnet-4-20250514",
+                content: [
+                    {
+                        type: "tool_use",
+                        id: "toolu_01HaXZ4LfdchSeSR8ygt4zyq",
+                        name: "TodoWrite",
+                        input: {
+                            todos: [
+                                {
+                                    content: "Analyze existing test coverage and identify gaps",
+                                    status: "in_progress",
+                                    activeForm: "Analyzing existing test coverage",
+                                },
+                                {
+                                    content: "Add comprehensive edge case tests",
+                                    status: "pending",
+                                    activeForm: "Adding comprehensive edge case tests",
+                                },
+                                {
+                                    content: "Add performance and timing tests",
+                                    status: "pending",
+                                    activeForm: "Adding performance and timing tests",
+                                },
+                                {
+                                    content: "Add error handling and panic behavior tests",
+                                    status: "pending",
+                                    activeForm: "Adding error handling tests",
+                                },
+                                {
+                                    content: "Add concurrent access and race condition tests",
+                                    status: "pending",
+                                    activeForm: "Adding concurrent access tests",
+                                },
+                                {
+                                    content: "Add tests for Each function with various data types",
+                                    status: "pending",
+                                    activeForm: "Adding Each function tests",
+                                },
+                                {
+                                    content: "Add benchmark tests for performance measurement",
+                                    status: "pending",
+                                    activeForm: "Adding benchmark tests",
+                                },
+                                {
+                                    content: "Improve test organization and helper functions",
+                                    status: "pending",
+                                    activeForm: "Improving test organization",
+                                },
+                            ],
+                        },
+                    },
+                ],
+                stop_reason: null,
+                stop_sequence: null,
+                usage: {
+                    input_tokens: 6,
+                    cache_creation_input_tokens: 326,
+                    cache_read_input_tokens: 17265,
+                    cache_creation: {
+                        ephemeral_5m_input_tokens: 326,
+                        ephemeral_1h_input_tokens: 0,
+                    },
+                    output_tokens: 1,
+                    service_tier: "standard",
+                    server_tool_use: null,
+                },
+                context_management: null,
+            },
+            parent_tool_use_id: null,
+            session_id: "d056596f-e328-41e9-badd-b07122ae5227",
+            uuid: "b7c3330c-de8f-4bba-ac53-68c7f76ffeb5",
+        };
+        expect(toAcpNotifications(received.message.content, received.message.role, "test", {}, {}, console)).toStrictEqual([
+            {
+                sessionId: "test",
+                update: {
+                    sessionUpdate: "plan",
+                    entries: [
+                        {
+                            content: "Analyze existing test coverage and identify gaps",
+                            priority: "medium",
+                            status: "in_progress",
+                        },
+                        {
+                            content: "Add comprehensive edge case tests",
+                            priority: "medium",
+                            status: "pending",
+                        },
+                        {
+                            content: "Add performance and timing tests",
+                            priority: "medium",
+                            status: "pending",
+                        },
+                        {
+                            content: "Add error handling and panic behavior tests",
+                            priority: "medium",
+                            status: "pending",
+                        },
+                        {
+                            content: "Add concurrent access and race condition tests",
+                            priority: "medium",
+                            status: "pending",
+                        },
+                        {
+                            content: "Add tests for Each function with various data types",
+                            priority: "medium",
+                            status: "pending",
+                        },
+                        {
+                            content: "Add benchmark tests for performance measurement",
+                            priority: "medium",
+                            status: "pending",
+                        },
+                        {
+                            content: "Improve test organization and helper functions",
+                            priority: "medium",
+                            status: "pending",
+                        },
+                    ],
+                },
+            },
+        ]);
+    });
+    it("should return empty update for successful edit result", () => {
+        const toolUse = {
+            type: "tool_use",
+            id: "toolu_01MNO345",
+            name: "mcp__acp__Edit",
+            input: {
+                file_path: "/Users/test/project/test.txt",
+                old_string: "old",
+                new_string: "new",
+            },
+        };
+        const toolResult = {
+            content: [
+                {
+                    type: "text",
+                    text: "not valid json",
+                },
+            ],
+            tool_use_id: "test",
+            is_error: false,
+            type: "tool_result",
+        };
+        const update = toolUpdateFromToolResult(toolResult, toolUse);
+        // Should return empty object when parsing fails
+        expect(update).toEqual({});
+    });
+    it("should return content update for edit failure", () => {
+        const toolUse = {
+            type: "tool_use",
+            id: "toolu_01MNO345",
+            name: "mcp__acp__Edit",
+            input: {
+                file_path: "/Users/test/project/test.txt",
+                old_string: "old",
+                new_string: "new",
+            },
+        };
+        const toolResult = {
+            content: [
+                {
+                    type: "text",
+                    text: "Failed to find `old_string`",
+                },
+            ],
+            tool_use_id: "test",
+            is_error: true,
+            type: "tool_result",
+        };
+        const update = toolUpdateFromToolResult(toolResult, toolUse);
+        // Should return empty object when parsing fails
+        expect(update).toEqual({
+            content: [
+                {
+                    content: { type: "text", text: "```\nFailed to find `old_string`\n```" },
+                    type: "content",
+                },
+            ],
+        });
+    });
+});
+describe("escape markdown", () => {
+    it("should escape markdown characters", () => {
+        let text = "Hello *world*!";
+        let escaped = markdownEscape(text);
+        expect(escaped).toEqual("```\nHello *world*!\n```");
+        text = "for example:\n```markdown\nHello *world*!\n```\n";
+        escaped = markdownEscape(text);
+        expect(escaped).toEqual("````\nfor example:\n```markdown\nHello *world*!\n```\n````");
+    });
+});
+describe("prompt conversion", () => {
+    it("should not change built-in slash commands", () => {
+        const message = promptToClaude({
+            sessionId: "test",
+            prompt: [
+                {
+                    type: "text",
+                    text: "/compact args",
+                },
+            ],
+        });
+        expect(message.message.content).toEqual([
+            {
+                text: "/compact args",
+                type: "text",
+            },
+        ]);
+    });
+    it("should remove MCP prefix from MCP slash commands", () => {
+        const message = promptToClaude({
+            sessionId: "test",
+            prompt: [
+                {
+                    type: "text",
+                    text: "/mcp:server:name args",
+                },
+            ],
+        });
+        expect(message.message.content).toEqual([
+            {
+                text: "/server:name (MCP) args",
+                type: "text",
+            },
+        ]);
+    });
+});
+describe.skipIf(!process.env.RUN_INTEGRATION_TESTS)("SDK behavior", () => {
+    it("query has a 'default' model", async () => {
+        const q = query({ prompt: "hi" });
+        const models = await q.supportedModels();
+        const defaultModel = models.find((m) => m.value === "default");
+        expect(defaultModel).toBeDefined();
+    }, 10000);
+    it("custom session id", async () => {
+        const sessionId = randomUUID();
+        const q = query({
+            prompt: "hi",
+            options: {
+                systemPrompt: { type: "preset", preset: "claude_code" },
+                extraArgs: { "session-id": sessionId },
+                settingSources: ["user", "project", "local"],
+                includePartialMessages: true,
+            },
+        });
+        const { value } = await q.next();
+        expect(value).toMatchObject({ type: "system", subtype: "init", session_id: sessionId });
+    }, 10000);
+});
+describe("permission requests", () => {
+    it("should include title field in tool permission request structure", () => {
+        // Test various tool types to ensure title is correctly generated
+        const testCases = [
+            {
+                toolUse: {
+                    type: "tool_use",
+                    id: "test-1",
+                    name: "Write",
+                    input: { file_path: "/test/file.txt", content: "test" },
+                },
+                expectedTitlePart: "/test/file.txt",
+            },
+            {
+                toolUse: {
+                    type: "tool_use",
+                    id: "test-2",
+                    name: "Bash",
+                    input: { command: "ls -la", description: "List files" },
+                },
+                expectedTitlePart: "`ls -la`",
+            },
+            {
+                toolUse: {
+                    type: "tool_use",
+                    id: "test-3",
+                    name: "mcp__acp__Read",
+                    input: { file_path: "/test/data.json" },
+                },
+                expectedTitlePart: "/test/data.json",
+            },
+        ];
+        for (const testCase of testCases) {
+            // Get the tool info that would be used in requestPermission
+            const toolInfo = toolInfoFromToolUse(testCase.toolUse);
+            // Verify toolInfo has a title
+            expect(toolInfo.title).toBeDefined();
+            expect(toolInfo.title).toContain(testCase.expectedTitlePart);
+            // Verify the structure that our fix creates for requestPermission
+            const requestStructure = {
+                toolCall: {
+                    toolCallId: testCase.toolUse.id,
+                    rawInput: testCase.toolUse.input,
+                    title: toolInfo.title, // This is what commit 1785d86 adds
+                },
+            };
+            // Ensure the title field is present and populated
+            expect(requestStructure.toolCall.title).toBeDefined();
+            expect(requestStructure.toolCall.title).toContain(testCase.expectedTitlePart);
+        }
+    });
+});