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

package/dist/acp-agent.js

@@ -20,7 +20,6 @@ export class ClaudeAcpAgent {
         this.sessions = {};
         this.client = client;
         this.toolUseCache = {};
-        this.fileContentCache = {};
         this.logger = logger ?? console;
     }
     async initialize(request) {
@@ -82,16 +81,233 @@ export class ClaudeAcpAgent {
      * Named unstable_forkSession to match SDK expectations (session/fork routes to this method).
      */
     async unstable_forkSession(params) {
-        // cwd and mcpServers are passed via _meta since they're not in the SDK type yet
-        const meta = params._meta;
-        return await this.createSession({
-            cwd: meta?.cwd ?? process.cwd(),
-            mcpServers: meta?.mcpServers ?? [],
+        // Get the session directory to track new files
+        const sessionDir = this.getSessionDirPath(params.cwd);
+        const beforeFiles = new Set(fs.existsSync(sessionDir)
+            ? fs.readdirSync(sessionDir).filter(f => f.endsWith('.jsonl'))
+            : []);
+        const result = await this.createSession({
+            cwd: params.cwd,
+            mcpServers: params.mcpServers ?? [],
             _meta: params._meta,
         }, {
             resume: params.sessionId,
             forkSession: true,
         });
+        // Wait briefly for CLI to create the session file
+        await new Promise(resolve => setTimeout(resolve, 200));
+        // Find the CLI-assigned session ID by looking for new session files
+        const cliSessionId = await this.discoverCliSessionId(sessionDir, beforeFiles, result.sessionId);
+        if (cliSessionId && cliSessionId !== result.sessionId) {
+            // Check if the CLI assigned a non-UUID session ID (e.g., "agent-xxx")
+            // If so, we need to extract the internal sessionId from the file
+            const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(cliSessionId);
+            if (!isUuid) {
+                // Read the session file to extract the internal sessionId
+                const oldFilePath = path.join(sessionDir, `${cliSessionId}.jsonl`);
+                const internalSessionId = this.extractInternalSessionId(oldFilePath);
+                if (internalSessionId) {
+                    this.logger.log(`[claude-code-acp] Fork: extracted internal sessionId ${internalSessionId} from ${cliSessionId}`);
+                    // Check if target file already exists (CLI reuses session IDs for forks from same parent)
+                    // If so, generate a new unique session ID to avoid collisions
+                    let finalSessionId = internalSessionId;
+                    let newFilePath = path.join(sessionDir, `${finalSessionId}.jsonl`);
+                    if (fs.existsSync(newFilePath)) {
+                        // Session ID collision - CLI created a fork with the same internal ID
+                        // Generate a new UUID and update the file's internal session ID
+                        finalSessionId = randomUUID();
+                        newFilePath = path.join(sessionDir, `${finalSessionId}.jsonl`);
+                        this.logger.log(`[claude-code-acp] Fork: session ID collision detected, using new ID: ${finalSessionId}`);
+                        // Update the internal session ID in the file before renaming
+                        this.updateSessionIdInFile(oldFilePath, finalSessionId);
+                    }
+                    // Rename the file to match the session ID so CLI can find it
+                    try {
+                        fs.renameSync(oldFilePath, newFilePath);
+                        this.logger.log(`[claude-code-acp] Fork: renamed ${cliSessionId}.jsonl -> ${finalSessionId}.jsonl`);
+                        // Promote sidechain to full session so it can be resumed/forked again
+                        this.promoteToFullSession(newFilePath);
+                    }
+                    catch (err) {
+                        this.logger.error(`[claude-code-acp] Failed to rename session file: ${err}`);
+                        // Continue anyway - the session might still work
+                    }
+                    // Re-register session with the final session ID
+                    const session = this.sessions[result.sessionId];
+                    this.sessions[finalSessionId] = session;
+                    delete this.sessions[result.sessionId];
+                    return { ...result, sessionId: finalSessionId };
+                }
+                // Fall through if we couldn't extract the internal ID
+                this.logger.error(`[claude-code-acp] Could not extract internal sessionId from ${oldFilePath}`);
+            }
+            // Re-register session with the CLI's session ID (if it's already a UUID or extraction failed)
+            this.logger.log(`[claude-code-acp] Fork: remapping session ${result.sessionId} -> ${cliSessionId}`);
+            this.sessions[cliSessionId] = this.sessions[result.sessionId];
+            delete this.sessions[result.sessionId];
+            return { ...result, sessionId: cliSessionId };
+        }
+        return result;
+    }
+    /**
+     * Get the directory where session files are stored for a given cwd.
+     */
+    getSessionDirPath(cwd) {
+        const realCwd = fs.realpathSync(cwd);
+        const cwdHash = realCwd.replace(/[/_]/g, "-");
+        return path.join(os.homedir(), ".claude", "projects", cwdHash);
+    }
+    /**
+     * Extract the internal sessionId from a session JSONL file.
+     * The CLI stores the actual session ID inside the file, which may differ from the filename.
+     * For forked sessions, the filename is "agent-xxx" but the internal sessionId is a UUID.
+     */
+    extractInternalSessionId(filePath) {
+        try {
+            if (!fs.existsSync(filePath)) {
+                return null;
+            }
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const firstLine = content.split('\n').find(line => line.trim().length > 0);
+            if (!firstLine) {
+                return null;
+            }
+            const parsed = JSON.parse(firstLine);
+            if (parsed.sessionId && typeof parsed.sessionId === 'string') {
+                // Verify it's a UUID format
+                const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(parsed.sessionId);
+                if (isUuid) {
+                    return parsed.sessionId;
+                }
+            }
+            return null;
+        }
+        catch (err) {
+            this.logger.error(`[claude-code-acp] Failed to extract sessionId from ${filePath}: ${err}`);
+            return null;
+        }
+    }
+    /**
+     * Promote a sidechain session to a regular session by modifying the session file.
+     * Forked sessions have "isSidechain": true which prevents them from being resumed.
+     * This method changes it to false so the session can be resumed/forked again.
+     */
+    promoteToFullSession(filePath) {
+        try {
+            if (!fs.existsSync(filePath)) {
+                return false;
+            }
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const lines = content.split('\n');
+            const modifiedLines = [];
+            for (const line of lines) {
+                if (!line.trim()) {
+                    modifiedLines.push(line);
+                    continue;
+                }
+                try {
+                    const parsed = JSON.parse(line);
+                    // Change isSidechain from true to false
+                    if (parsed.isSidechain === true) {
+                        parsed.isSidechain = false;
+                    }
+                    modifiedLines.push(JSON.stringify(parsed));
+                }
+                catch {
+                    // Keep line as-is if it can't be parsed
+                    modifiedLines.push(line);
+                }
+            }
+            fs.writeFileSync(filePath, modifiedLines.join('\n'), 'utf-8');
+            this.logger.log(`[claude-code-acp] Promoted sidechain to full session: ${filePath}`);
+            return true;
+        }
+        catch (err) {
+            this.logger.error(`[claude-code-acp] Failed to promote session: ${err}`);
+            return false;
+        }
+    }
+    /**
+     * Update the sessionId in all lines of a session JSONL file.
+     * This is used when we need to assign a new unique session ID to avoid collisions.
+     */
+    updateSessionIdInFile(filePath, newSessionId) {
+        try {
+            if (!fs.existsSync(filePath)) {
+                return false;
+            }
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const lines = content.split('\n');
+            const modifiedLines = [];
+            for (const line of lines) {
+                if (!line.trim()) {
+                    modifiedLines.push(line);
+                    continue;
+                }
+                try {
+                    const parsed = JSON.parse(line);
+                    // Update the sessionId in each line
+                    if (parsed.sessionId && typeof parsed.sessionId === 'string') {
+                        parsed.sessionId = newSessionId;
+                    }
+                    modifiedLines.push(JSON.stringify(parsed));
+                }
+                catch {
+                    // Keep line as-is if it can't be parsed
+                    modifiedLines.push(line);
+                }
+            }
+            fs.writeFileSync(filePath, modifiedLines.join('\n'), 'utf-8');
+            this.logger.log(`[claude-code-acp] Updated session ID in file: ${filePath}`);
+            return true;
+        }
+        catch (err) {
+            this.logger.error(`[claude-code-acp] Failed to update session ID in file: ${err}`);
+            return false;
+        }
+    }
+    /**
+     * Discover the CLI-assigned session ID by looking for new session files.
+     * Returns the CLI's session ID if found, or the original sessionId if not.
+     */
+    async discoverCliSessionId(sessionDir, beforeFiles, fallbackId, timeout = 2000) {
+        const start = Date.now();
+        // Pattern for CLI-assigned fork session IDs (agent-xxxxxxx)
+        const agentPattern = /^agent-[a-f0-9]+\.jsonl$/;
+        while (Date.now() - start < timeout) {
+            if (fs.existsSync(sessionDir)) {
+                const currentFiles = fs.readdirSync(sessionDir).filter(f => f.endsWith('.jsonl'));
+                // Only look for new files that match the agent-xxx pattern
+                // This prevents picking up renamed UUID files from previous forks
+                const newFiles = currentFiles.filter(f => !beforeFiles.has(f) && agentPattern.test(f));
+                if (newFiles.length === 1) {
+                    // Found exactly one new agent session file - this is our fork
+                    this.logger.log(`[claude-code-acp] Discovered fork session file: ${newFiles[0]}`);
+                    return newFiles[0].replace('.jsonl', '');
+                }
+                else if (newFiles.length > 1) {
+                    // Multiple new agent files - try to find the most recent one
+                    let newestFile = '';
+                    let newestMtime = 0;
+                    for (const file of newFiles) {
+                        const filePath = path.join(sessionDir, file);
+                        const stat = fs.statSync(filePath);
+                        if (stat.mtimeMs > newestMtime) {
+                            newestMtime = stat.mtimeMs;
+                            newestFile = file;
+                        }
+                    }
+                    if (newestFile) {
+                        this.logger.log(`[claude-code-acp] Discovered fork session file (newest of ${newFiles.length}): ${newestFile}`);
+                        return newestFile.replace('.jsonl', '');
+                    }
+                }
+            }
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        // Timeout - return fallback
+        this.logger.log(`[claude-code-acp] Could not discover CLI session ID, using fallback: ${fallbackId}`);
+        return fallbackId;
     }
     /**
      * Alias for unstable_forkSession for convenience.
@@ -191,7 +407,7 @@ export class ClaudeAcpAgent {
                     break;
                 }
                 case "stream_event": {
-                    for (const notification of streamEventToAcpNotifications(message, params.sessionId, this.toolUseCache, this.fileContentCache, this.client, this.logger)) {
+                    for (const notification of streamEventToAcpNotifications(message, params.sessionId, this.toolUseCache, this.client, this.logger)) {
                         await this.client.sessionUpdate(notification);
                     }
                     break;
@@ -233,7 +449,7 @@ export class ClaudeAcpAgent {
                         ? // Handled by stream events above
                             message.message.content.filter((item) => !["text", "thinking"].includes(item.type))
                         : message.message.content;
-                    for (const notification of toAcpNotifications(content, message.message.role, params.sessionId, this.toolUseCache, this.fileContentCache, this.client, this.logger)) {
+                    for (const notification of toAcpNotifications(content, message.message.role, params.sessionId, this.toolUseCache, this.client, this.logger)) {
                         await this.client.sessionUpdate(notification);
                     }
                     break;
@@ -256,6 +472,106 @@ export class ClaudeAcpAgent {
         this.sessions[params.sessionId].cancelled = true;
         await this.sessions[params.sessionId].query.interrupt();
     }
+    /**
+     * Handle extension methods from the client.
+     *
+     * Currently supports:
+     * - `_session/flush`: Flush a session to disk for fork-with-flush support
+     */
+    async extMethod(method, params) {
+        if (method === "_session/flush") {
+            return this.handleSessionFlush(params);
+        }
+        throw RequestError.methodNotFound(method);
+    }
+    /**
+     * Flush a session to disk by aborting its query subprocess.
+     *
+     * This is used by the fork-with-flush mechanism to ensure session data
+     * is persisted to disk before forking. When the Claude SDK subprocess
+     * exits (via abort), it writes the session data to:
+     * ~/.claude/projects/<cwd-hash>/<sessionId>.jsonl
+     *
+     * After this method completes, the session is removed from memory and
+     * must be reloaded via loadSession() to continue using it.
+     */
+    async handleSessionFlush(params) {
+        const { sessionId, persistTimeout = 5000 } = params;
+        const session = this.sessions[sessionId];
+        if (!session) {
+            return { success: false, error: `Session ${sessionId} not found` };
+        }
+        try {
+            // Step 1: Mark session as cancelled to stop processing
+            session.cancelled = true;
+            // Step 2: Interrupt any ongoing query work
+            await session.query.interrupt();
+            // Step 3: End the input stream to signal no more input
+            session.input.end();
+            // Step 4: Abort the session using the AbortController
+            // This forces the Claude SDK subprocess to exit, which triggers disk persistence
+            session.abortController.abort();
+            // Step 5: Wait for the session file to appear on disk
+            // Use stored sessionFilePath for forked sessions (where filename differs from sessionId)
+            const sessionFilePath = session.sessionFilePath ?? this.getSessionFilePath(sessionId, session.cwd);
+            this.logger.log(`[claude-code-acp] Waiting for session file at: ${sessionFilePath}`);
+            this.logger.log(`[claude-code-acp] Session cwd: ${session.cwd}`);
+            const persisted = await this.waitForSessionFile(sessionFilePath, persistTimeout);
+            if (!persisted) {
+                this.logger.error(`[claude-code-acp] Session file not found at ${sessionFilePath} after ${persistTimeout}ms`);
+                // Check if file exists at the path
+                const exists = fs.existsSync(sessionFilePath);
+                this.logger.error(`[claude-code-acp] File exists check: ${exists}`);
+                // Still remove the session from memory
+                delete this.sessions[sessionId];
+                return { success: false, error: `Session file not created within timeout` };
+            }
+            // Step 6: Remove session from our map
+            // The client will call loadSession() to reload it from disk
+            delete this.sessions[sessionId];
+            this.logger.log(`[claude-code-acp] Session ${sessionId} flushed to disk at ${sessionFilePath}`);
+            return { success: true, filePath: sessionFilePath };
+        }
+        catch (error) {
+            this.logger.error(`[claude-code-acp] Failed to flush session ${sessionId}:`, error);
+            // Clean up session on error
+            delete this.sessions[sessionId];
+            return { success: false, error: String(error) };
+        }
+    }
+    /**
+     * Get the file path where Claude Code stores session data.
+     *
+     * Claude Code stores sessions at:
+     * ~/.claude/projects/<cwd-hash>/<sessionId>.jsonl
+     *
+     * Where <cwd-hash> is the cwd with `/` replaced by `-`
+     * Note: We resolve the real path to handle macOS symlinks like /var -> /private/var
+     */
+    getSessionFilePath(sessionId, cwd) {
+        // Resolve the real path to handle macOS symlinks like /var -> /private/var
+        const realCwd = fs.realpathSync(cwd);
+        // Claude Code replaces both / and _ with - in the cwd hash
+        const cwdHash = realCwd.replace(/[/_]/g, "-");
+        return path.join(os.homedir(), ".claude", "projects", cwdHash, `${sessionId}.jsonl`);
+    }
+    /**
+     * Wait for a session file to appear on disk.
+     *
+     * @param filePath - Path to the session file
+     * @param timeout - Maximum time to wait in milliseconds
+     * @returns true if file appears, false if timeout
+     */
+    async waitForSessionFile(filePath, timeout) {
+        const start = Date.now();
+        while (Date.now() - start < timeout) {
+            if (fs.existsSync(filePath)) {
+                return true;
+            }
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        return false;
+    }
     async unstable_setSessionModel(params) {
         if (!this.sessions[params.sessionId]) {
             throw new Error("Session not found");
@@ -287,14 +603,10 @@ export class ClaudeAcpAgent {
     }
     async readTextFile(params) {
         const response = await this.client.readTextFile(params);
-        if (!params.limit && !params.line) {
-            this.fileContentCache[params.path] = response.content;
-        }
         return response;
     }
     async writeTextFile(params) {
         const response = await this.client.writeTextFile(params);
-        this.fileContentCache[params.path] = params.content;
         return response;
     }
     canUseTool(sessionId) {
@@ -322,7 +634,7 @@ export class ClaudeAcpAgent {
                     toolCall: {
                         toolCallId: toolUseID,
                         rawInput: toolInput,
-                        title: toolInfoFromToolUse({ name: toolName, input: toolInput }, this.fileContentCache, this.logger).title,
+                        title: toolInfoFromToolUse({ name: toolName, input: toolInput }).title,
                     },
                 });
                 if (signal.aborted || response.outcome?.outcome === "cancelled") {
@@ -378,7 +690,7 @@ export class ClaudeAcpAgent {
                 toolCall: {
                     toolCallId: toolUseID,
                     rawInput: toolInput,
-                    title: toolInfoFromToolUse({ name: toolName, input: toolInput }, this.fileContentCache, this.logger).title,
+                    title: toolInfoFromToolUse({ name: toolName, input: toolInput }).title,
                 },
             });
             if (signal.aborted || response.outcome?.outcome === "cancelled") {
@@ -475,7 +787,8 @@ export class ClaudeAcpAgent {
         const extraArgs = { ...userProvidedOptions?.extraArgs };
         if (creationOpts?.resume === undefined) {
             // Set our own session id if not resuming an existing session.
-            // TODO: find a way to make this work for fork
+            // Note: For forked sessions (resume + fork), Claude CLI assigns its own session ID
+            // which means chain forking (fork of a fork) is not currently supported.
             extraArgs["session-id"] = sessionId;
         }
         const options = {
@@ -543,11 +856,15 @@ export class ClaudeAcpAgent {
         if (disallowedTools.length > 0) {
             options.disallowedTools = disallowedTools;
         }
-        // Handle abort controller from meta options
-        const abortController = userProvidedOptions?.abortController;
-        if (abortController?.signal.aborted) {
+        // Create our own AbortController for session management
+        const sessionAbortController = new AbortController();
+        // Handle abort controller from meta options (user can still provide one)
+        const userAbortController = userProvidedOptions?.abortController;
+        if (userAbortController?.signal.aborted) {
             throw new Error("Cancelled");
         }
+        // Pass the abort controller to the query options
+        options.abortController = sessionAbortController;
         const q = query({
             prompt: input,
             options,
@@ -558,6 +875,8 @@ export class ClaudeAcpAgent {
             cancelled: false,
             permissionMode,
             settingsManager,
+            abortController: sessionAbortController,
+            cwd: params.cwd,
         };
         const availableCommands = await getAvailableSlashCommands(q);
         const models = await getAvailableModels(q);
@@ -750,7 +1069,7 @@ export function promptToClaude(prompt) {
  * Convert an SDKAssistantMessage (Claude) to a SessionNotification (ACP).
  * Only handles text, image, and thinking chunks for now.
  */
-export function toAcpNotifications(content, role, sessionId, toolUseCache, fileContentCache, client, logger) {
+export function toAcpNotifications(content, role, sessionId, toolUseCache, client, logger) {
     if (typeof content === "string") {
         return [
             {
@@ -857,7 +1176,7 @@ export function toAcpNotifications(content, role, sessionId, toolUseCache, fileC
                         sessionUpdate: "tool_call",
                         rawInput,
                         status: "pending",
-                        ...toolInfoFromToolUse(chunk, fileContentCache, logger),
+                        ...toolInfoFromToolUse(chunk),
                     };
                 }
                 break;
@@ -908,13 +1227,13 @@ export function toAcpNotifications(content, role, sessionId, toolUseCache, fileC
     }
     return output;
 }
-export function streamEventToAcpNotifications(message, sessionId, toolUseCache, fileContentCache, client, logger) {
+export function streamEventToAcpNotifications(message, sessionId, toolUseCache, client, logger) {
     const event = message.event;
     switch (event.type) {
         case "content_block_start":
-            return toAcpNotifications([event.content_block], "assistant", sessionId, toolUseCache, fileContentCache, client, logger);
+            return toAcpNotifications([event.content_block], "assistant", sessionId, toolUseCache, client, logger);
         case "content_block_delta":
-            return toAcpNotifications([event.delta], "assistant", sessionId, toolUseCache, fileContentCache, client, logger);
+            return toAcpNotifications([event.delta], "assistant", sessionId, toolUseCache, client, logger);
         // No content
         case "message_start":
         case "message_delta":

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

@@ -0,0 +1,338 @@
+/**
+ * Tests for fork-related helper methods in ClaudeAcpAgent.
+ *
+ * Since the methods are private, we test them by:
+ * 1. Creating a test subclass that exposes the private methods
+ * 2. Testing the file manipulation logic directly
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { ClaudeAcpAgent } from "../acp-agent.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+// Create a test subclass that exposes private methods for testing
+class TestableClaudeAcpAgent extends ClaudeAcpAgent {
+    // Expose private methods for testing
+    testExtractInternalSessionId(filePath) {
+        return this.extractInternalSessionId(filePath);
+    }
+    testPromoteToFullSession(filePath) {
+        return this.promoteToFullSession(filePath);
+    }
+    testUpdateSessionIdInFile(filePath, newSessionId) {
+        return this.updateSessionIdInFile(filePath, newSessionId);
+    }
+    testGetSessionDirPath(cwd) {
+        return this.getSessionDirPath(cwd);
+    }
+    testGetSessionFilePath(sessionId, cwd) {
+        return this.getSessionFilePath(sessionId, cwd);
+    }
+    async testDiscoverCliSessionId(sessionDir, beforeFiles, fallbackId, timeout) {
+        return this.discoverCliSessionId(sessionDir, beforeFiles, fallbackId, timeout);
+    }
+    async testWaitForSessionFile(filePath, timeout) {
+        return this.waitForSessionFile(filePath, timeout);
+    }
+}
+describe("ClaudeAcpAgent fork helpers", () => {
+    let tempDir;
+    let agent;
+    const mockLogger = {
+        log: vi.fn(),
+        error: vi.fn(),
+    };
+    // Create a minimal mock client
+    const mockClient = {
+        sessionUpdate: vi.fn(),
+        readTextFile: vi.fn(),
+        writeTextFile: vi.fn(),
+        requestPermission: vi.fn(),
+    };
+    beforeEach(async () => {
+        tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "acp-agent-fork-test-"));
+        agent = new TestableClaudeAcpAgent(mockClient, mockLogger);
+        vi.clearAllMocks();
+    });
+    afterEach(async () => {
+        await fs.promises.rm(tempDir, { recursive: true, force: true });
+    });
+    describe("extractInternalSessionId", () => {
+        it("should extract UUID sessionId from valid JSONL file", async () => {
+            const filePath = path.join(tempDir, "session.jsonl");
+            const sessionId = "12345678-1234-1234-1234-123456789abc";
+            await fs.promises.writeFile(filePath, JSON.stringify({ sessionId, type: "init" }) + "\n");
+            const result = agent.testExtractInternalSessionId(filePath);
+            expect(result).toBe(sessionId);
+        });
+        it("should return null for non-existent file", () => {
+            const result = agent.testExtractInternalSessionId(path.join(tempDir, "nonexistent.jsonl"));
+            expect(result).toBeNull();
+        });
+        it("should return null for file without sessionId", async () => {
+            const filePath = path.join(tempDir, "session.jsonl");
+            await fs.promises.writeFile(filePath, JSON.stringify({ type: "init" }) + "\n");
+            const result = agent.testExtractInternalSessionId(filePath);
+            expect(result).toBeNull();
+        });
+        it("should return null for non-UUID sessionId", async () => {
+            const filePath = path.join(tempDir, "session.jsonl");
+            await fs.promises.writeFile(filePath, JSON.stringify({ sessionId: "not-a-uuid", type: "init" }) + "\n");
+            const result = agent.testExtractInternalSessionId(filePath);
+            expect(result).toBeNull();
+        });
+        it("should handle empty file", async () => {
+            const filePath = path.join(tempDir, "session.jsonl");
+            await fs.promises.writeFile(filePath, "");
+            const result = agent.testExtractInternalSessionId(filePath);
+            expect(result).toBeNull();
+        });
+        it("should find sessionId from first non-empty line", async () => {
+            const filePath = path.join(tempDir, "session.jsonl");
+            const sessionId = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
+            await fs.promises.writeFile(filePath, "\n\n" + JSON.stringify({ sessionId, type: "init" }) + "\n");
+            const result = agent.testExtractInternalSessionId(filePath);
+            expect(result).toBe(sessionId);
+        });
+    });
+    describe("promoteToFullSession", () => {
+        it("should change isSidechain from true to false", async () => {
+            const filePath = path.join(tempDir, "session.jsonl");
+            const lines = [
+                JSON.stringify({ sessionId: "test-id", isSidechain: true }),
+                JSON.stringify({ type: "message", content: "hello" }),
+            ];
+            await fs.promises.writeFile(filePath, lines.join("\n"));
+            const result = agent.testPromoteToFullSession(filePath);
+            expect(result).toBe(true);
+            const content = await fs.promises.readFile(filePath, "utf-8");
+            const parsedLines = content.split("\n").map(line => JSON.parse(line));
+            expect(parsedLines[0].isSidechain).toBe(false);
+            expect(parsedLines[1].content).toBe("hello");
+        });
+        it("should return false for non-existent file", () => {
+            const result = agent.testPromoteToFullSession(path.join(tempDir, "nonexistent.jsonl"));
+            expect(result).toBe(false);
+        });
+        it("should preserve other fields when promoting", async () => {
+            const filePath = path.join(tempDir, "session.jsonl");
+            const original = {
+                sessionId: "test-id",
+                isSidechain: true,
+                cwd: "/some/path",
+                model: "claude-3",
+            };
+            await fs.promises.writeFile(filePath, JSON.stringify(original));
+            agent.testPromoteToFullSession(filePath);
+            const content = await fs.promises.readFile(filePath, "utf-8");
+            const parsed = JSON.parse(content);
+            expect(parsed.sessionId).toBe("test-id");
+            expect(parsed.isSidechain).toBe(false);
+            expect(parsed.cwd).toBe("/some/path");
+            expect(parsed.model).toBe("claude-3");
+        });
+        it("should handle file without isSidechain field", async () => {
+            const filePath = path.join(tempDir, "session.jsonl");
+            await fs.promises.writeFile(filePath, JSON.stringify({ sessionId: "test-id", type: "init" }));
+            const result = agent.testPromoteToFullSession(filePath);
+            expect(result).toBe(true);
+            const content = await fs.promises.readFile(filePath, "utf-8");
+            const parsed = JSON.parse(content);
+            expect(parsed.isSidechain).toBeUndefined();
+        });
+        it("should log success message", async () => {
+            const filePath = path.join(tempDir, "session.jsonl");
+            await fs.promises.writeFile(filePath, JSON.stringify({ sessionId: "test-id", isSidechain: true }));
+            agent.testPromoteToFullSession(filePath);
+            expect(mockLogger.log).toHaveBeenCalledWith(expect.stringContaining("Promoted sidechain to full session"));
+        });
+    });
+    describe("updateSessionIdInFile", () => {
+        it("should update sessionId in all lines", async () => {
+            const filePath = path.join(tempDir, "session.jsonl");
+            const oldId = "old-session-id";
+            const newId = "new-session-id";
+            const lines = [
+                JSON.stringify({ sessionId: oldId, type: "init" }),
+                JSON.stringify({ sessionId: oldId, type: "message", content: "hello" }),
+                JSON.stringify({ sessionId: oldId, type: "tool_use", name: "Read" }),
+            ];
+            await fs.promises.writeFile(filePath, lines.join("\n"));
+            const result = agent.testUpdateSessionIdInFile(filePath, newId);
+            expect(result).toBe(true);
+            const content = await fs.promises.readFile(filePath, "utf-8");
+            const parsedLines = content.split("\n").map(line => JSON.parse(line));
+            for (const line of parsedLines) {
+                expect(line.sessionId).toBe(newId);
+            }
+        });
+        it("should return false for non-existent file", () => {
+            const result = agent.testUpdateSessionIdInFile(path.join(tempDir, "nonexistent.jsonl"), "new-id");
+            expect(result).toBe(false);
+        });
+        it("should preserve lines without sessionId", async () => {
+            const filePath = path.join(tempDir, "session.jsonl");
+            const lines = [
+                JSON.stringify({ sessionId: "old-id", type: "init" }),
+                JSON.stringify({ type: "comment", text: "no sessionId here" }),
+            ];
+            await fs.promises.writeFile(filePath, lines.join("\n"));
+            agent.testUpdateSessionIdInFile(filePath, "new-id");
+            const content = await fs.promises.readFile(filePath, "utf-8");
+            const parsedLines = content.split("\n").map(line => JSON.parse(line));
+            expect(parsedLines[0].sessionId).toBe("new-id");
+            expect(parsedLines[1].sessionId).toBeUndefined();
+            expect(parsedLines[1].text).toBe("no sessionId here");
+        });
+        it("should handle empty lines gracefully", async () => {
+            const filePath = path.join(tempDir, "session.jsonl");
+            const content = JSON.stringify({ sessionId: "old-id" }) + "\n\n" + JSON.stringify({ sessionId: "old-id" });
+            await fs.promises.writeFile(filePath, content);
+            const result = agent.testUpdateSessionIdInFile(filePath, "new-id");
+            expect(result).toBe(true);
+            const newContent = await fs.promises.readFile(filePath, "utf-8");
+            const lines = newContent.split("\n");
+            expect(JSON.parse(lines[0]).sessionId).toBe("new-id");
+            expect(lines[1]).toBe(""); // Empty line preserved
+            expect(JSON.parse(lines[2]).sessionId).toBe("new-id");
+        });
+        it("should log success message", async () => {
+            const filePath = path.join(tempDir, "session.jsonl");
+            await fs.promises.writeFile(filePath, JSON.stringify({ sessionId: "old-id" }));
+            agent.testUpdateSessionIdInFile(filePath, "new-id");
+            expect(mockLogger.log).toHaveBeenCalledWith(expect.stringContaining("Updated session ID in file"));
+        });
+    });
+    describe("getSessionDirPath", () => {
+        it("should compute correct path with cwd hash", () => {
+            const result = agent.testGetSessionDirPath("/private/tmp");
+            const homeDir = os.homedir();
+            expect(result).toBe(`${homeDir}/.claude/projects/-private-tmp`);
+        });
+        it("should replace both / and _ with -", () => {
+            // Use tempDir which exists
+            const testDir = path.join(tempDir, "my_project");
+            fs.mkdirSync(testDir, { recursive: true });
+            const result = agent.testGetSessionDirPath(testDir);
+            const realPath = fs.realpathSync(testDir);
+            const expectedHash = realPath.replace(/[/_]/g, "-");
+            expect(result).toBe(`${os.homedir()}/.claude/projects/${expectedHash}`);
+        });
+        it("should resolve symlinks", () => {
+            // /var on macOS is a symlink to /private/var
+            const result = agent.testGetSessionDirPath("/var/tmp");
+            const homeDir = os.homedir();
+            // Should use the resolved path
+            expect(result).toBe(`${homeDir}/.claude/projects/-private-var-tmp`);
+        });
+    });
+    describe("getSessionFilePath", () => {
+        it("should append sessionId.jsonl to session dir", () => {
+            const result = agent.testGetSessionFilePath("my-session-id", "/private/tmp");
+            const homeDir = os.homedir();
+            expect(result).toBe(`${homeDir}/.claude/projects/-private-tmp/my-session-id.jsonl`);
+        });
+    });
+    describe("waitForSessionFile", () => {
+        it("should return true immediately if file exists", async () => {
+            const filePath = path.join(tempDir, "session.jsonl");
+            await fs.promises.writeFile(filePath, "{}");
+            const start = Date.now();
+            const result = await agent.testWaitForSessionFile(filePath, 1000);
+            const elapsed = Date.now() - start;
+            expect(result).toBe(true);
+            expect(elapsed).toBeLessThan(200);
+        });
+        it("should return true when file appears before timeout", async () => {
+            const filePath = path.join(tempDir, "session.jsonl");
+            // Create file after 200ms
+            setTimeout(async () => {
+                await fs.promises.writeFile(filePath, "{}");
+            }, 200);
+            const start = Date.now();
+            const result = await agent.testWaitForSessionFile(filePath, 2000);
+            const elapsed = Date.now() - start;
+            expect(result).toBe(true);
+            expect(elapsed).toBeGreaterThanOrEqual(200);
+            expect(elapsed).toBeLessThan(2000);
+        });
+        it("should return false when timeout expires", async () => {
+            const filePath = path.join(tempDir, "nonexistent.jsonl");
+            const start = Date.now();
+            const result = await agent.testWaitForSessionFile(filePath, 300);
+            const elapsed = Date.now() - start;
+            expect(result).toBe(false);
+            expect(elapsed).toBeGreaterThanOrEqual(300);
+            expect(elapsed).toBeLessThan(500);
+        });
+    });
+    describe("discoverCliSessionId", () => {
+        it("should find new agent-xxx file", async () => {
+            const sessionDir = path.join(tempDir, "sessions");
+            await fs.promises.mkdir(sessionDir, { recursive: true });
+            const beforeFiles = new Set();
+            // Create an agent-xxx file
+            const agentFile = "agent-abc123.jsonl";
+            await fs.promises.writeFile(path.join(sessionDir, agentFile), "{}");
+            const result = await agent.testDiscoverCliSessionId(sessionDir, beforeFiles, "fallback", 1000);
+            expect(result).toBe("agent-abc123");
+        });
+        it("should ignore non-agent files", async () => {
+            const sessionDir = path.join(tempDir, "sessions");
+            await fs.promises.mkdir(sessionDir, { recursive: true });
+            const beforeFiles = new Set();
+            // Create a UUID-named file (not agent-xxx)
+            const uuidFile = "12345678-1234-1234-1234-123456789abc.jsonl";
+            await fs.promises.writeFile(path.join(sessionDir, uuidFile), "{}");
+            const result = await agent.testDiscoverCliSessionId(sessionDir, beforeFiles, "fallback", 500);
+            expect(result).toBe("fallback");
+        });
+        it("should return fallback when no new files found", async () => {
+            const sessionDir = path.join(tempDir, "sessions");
+            await fs.promises.mkdir(sessionDir, { recursive: true });
+            const beforeFiles = new Set();
+            const result = await agent.testDiscoverCliSessionId(sessionDir, beforeFiles, "fallback-id", 300);
+            expect(result).toBe("fallback-id");
+        });
+        it("should ignore files that existed before", async () => {
+            const sessionDir = path.join(tempDir, "sessions");
+            await fs.promises.mkdir(sessionDir, { recursive: true });
+            // Create file before
+            const existingFile = "agent-existing.jsonl";
+            await fs.promises.writeFile(path.join(sessionDir, existingFile), "{}");
+            const beforeFiles = new Set([existingFile]);
+            const result = await agent.testDiscoverCliSessionId(sessionDir, beforeFiles, "fallback", 300);
+            expect(result).toBe("fallback");
+        });
+        it("should return newest file when multiple agent files appear", async () => {
+            const sessionDir = path.join(tempDir, "sessions");
+            await fs.promises.mkdir(sessionDir, { recursive: true });
+            const beforeFiles = new Set();
+            // Create first file - use hex chars to match agent-[a-f0-9]+ pattern
+            const firstPath = path.join(sessionDir, "agent-aaa111.jsonl");
+            await fs.promises.writeFile(firstPath, "{}");
+            // Wait a bit to ensure different mtime, then create second file
+            await new Promise(resolve => setTimeout(resolve, 100));
+            const secondPath = path.join(sessionDir, "agent-bbb222.jsonl");
+            await fs.promises.writeFile(secondPath, "{}");
+            // Verify files exist before calling discover
+            expect(fs.existsSync(firstPath)).toBe(true);
+            expect(fs.existsSync(secondPath)).toBe(true);
+            const result = await agent.testDiscoverCliSessionId(sessionDir, beforeFiles, "fallback", 1000);
+            expect(result).toBe("agent-bbb222");
+        });
+        it("should handle non-existent session directory initially", async () => {
+            const sessionDir = path.join(tempDir, "nonexistent-dir");
+            const beforeFiles = new Set();
+            // Start the discovery in parallel with file creation
+            const discoverPromise = agent.testDiscoverCliSessionId(sessionDir, beforeFiles, "fallback", 2000);
+            // Create directory and file after 200ms (within the 2000ms timeout)
+            // Use hex chars to match agent-[a-f0-9]+ pattern
+            await new Promise(resolve => setTimeout(resolve, 200));
+            await fs.promises.mkdir(sessionDir, { recursive: true });
+            await fs.promises.writeFile(path.join(sessionDir, "agent-ccc333.jsonl"), "{}");
+            const result = await discoverPromise;
+            expect(result).toBe("agent-ccc333");
+        });
+    });
+});

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

@@ -192,7 +192,7 @@ describe("tool conversions", () => {
                 description: "Delete README.md.rm file",
             },
         };
-        expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
             kind: "execute",
             title: "`rm README.md.rm`",
             content: [
@@ -215,7 +215,7 @@ describe("tool conversions", () => {
                 pattern: "*/**.ts",
             },
         };
-        expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
             kind: "search",
             title: "Find `*/**.ts`",
             content: [],
@@ -233,7 +233,7 @@ describe("tool conversions", () => {
                 subagent_type: "general-purpose",
             },
         };
-        expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
             kind: "think",
             title: "Handle user's work request",
             content: [
@@ -256,7 +256,7 @@ describe("tool conversions", () => {
                 path: "/Users/test/github/claude-code-acp",
             },
         };
-        expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
             kind: "search",
             title: "List the `/Users/test/github/claude-code-acp` directory's contents",
             content: [],
@@ -272,7 +272,7 @@ describe("tool conversions", () => {
                 pattern: ".*",
             },
         };
-        expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
             kind: "search",
             title: 'grep ".*"',
             content: [],
@@ -288,7 +288,7 @@ describe("tool conversions", () => {
                 content: "Hello, World!\nThis is test content.",
             },
         };
-        expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
             kind: "edit",
             title: "Write /Users/test/project/example.txt",
             content: [
@@ -312,7 +312,7 @@ describe("tool conversions", () => {
                 content: '{"version": "1.0.0"}',
             },
         };
-        expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
             kind: "edit",
             title: "Write /Users/test/project/config.json",
             content: [
@@ -335,7 +335,7 @@ describe("tool conversions", () => {
                 file_path: "/Users/test/project/readme.md",
             },
         };
-        expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
             kind: "read",
             title: "Read File",
             content: [],
@@ -351,7 +351,7 @@ describe("tool conversions", () => {
                 file_path: "/Users/test/project/data.json",
             },
         };
-        expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
             kind: "read",
             title: "Read /Users/test/project/data.json",
             content: [],
@@ -368,7 +368,7 @@ describe("tool conversions", () => {
                 limit: 100,
             },
         };
-        expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
             kind: "read",
             title: "Read /Users/test/project/large.txt (1 - 100)",
             content: [],
@@ -386,7 +386,7 @@ describe("tool conversions", () => {
                 limit: 100,
             },
         };
-        expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
             kind: "read",
             title: "Read /Users/test/project/large.txt (51 - 150)",
             content: [],
@@ -403,7 +403,7 @@ describe("tool conversions", () => {
                 offset: 200,
             },
         };
-        expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
             kind: "read",
             title: "Read /Users/test/project/large.txt (from line 201)",
             content: [],
@@ -419,7 +419,7 @@ describe("tool conversions", () => {
                 shell_id: "bash_1",
             },
         };
-        expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
             kind: "execute",
             title: `Kill Process`,
             content: [],
@@ -434,7 +434,7 @@ describe("tool conversions", () => {
                 bash_id: "bash_1",
             },
         };
-        expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+        expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
             kind: "execute",
             title: `Tail Logs`,
             content: [],
@@ -520,7 +520,7 @@ describe("tool conversions", () => {
             session_id: "d056596f-e328-41e9-badd-b07122ae5227",
             uuid: "b7c3330c-de8f-4bba-ac53-68c7f76ffeb5",
         };
-        expect(toAcpNotifications(received.message.content, received.message.role, "test", {}, {}, {}, console)).toStrictEqual([
+        expect(toAcpNotifications(received.message.content, received.message.role, "test", {}, {}, console)).toStrictEqual([
             {
                 sessionId: "test",
                 update: {
@@ -733,7 +733,7 @@ describe("permission requests", () => {
         ];
         for (const testCase of testCases) {
             // Get the tool info that would be used in requestPermission
-            const toolInfo = toolInfoFromToolUse(testCase.toolUse, {});
+            const toolInfo = toolInfoFromToolUse(testCase.toolUse);
             // Verify toolInfo has a title
             expect(toolInfo.title).toBeDefined();
             expect(toolInfo.title).toContain(testCase.expectedTitlePart);

package/dist/tools.js

@@ -1,4 +1,5 @@
-import { replaceAndCalculateLocation, SYSTEM_REMINDER } from "./mcp-server.js";
+import { SYSTEM_REMINDER } from "./mcp-server.js";
+import * as diff from "diff";
 const acpUnqualifiedToolNames = {
     read: "Read",
     edit: "Edit",
@@ -17,7 +18,7 @@ export const acpToolNames = {
     bashOutput: ACP_TOOL_NAME_PREFIX + acpUnqualifiedToolNames.bashOutput,
 };
 export const EDIT_TOOL_NAMES = [acpToolNames.edit, acpToolNames.write];
-export function toolInfoFromToolUse(toolUse, cachedFileContent, logger = console) {
+export function toolInfoFromToolUse(toolUse) {
     const name = toolUse.name;
     const input = toolUse.input;
     switch (name) {
@@ -130,27 +131,6 @@ export function toolInfoFromToolUse(toolUse, cachedFileContent, logger = console
         case acpToolNames.edit:
         case "Edit": {
             const path = input?.file_path ?? input?.file_path;
-            let oldText = input.old_string ?? null;
-            let newText = input.new_string ?? "";
-            let affectedLines = [];
-            if (path && oldText) {
-                try {
-                    const oldContent = cachedFileContent[path] || "";
-                    const newContent = replaceAndCalculateLocation(oldContent, [
-                        {
-                            oldText,
-                            newText,
-                            replaceAll: false,
-                        },
-                    ]);
-                    oldText = oldContent;
-                    newText = newContent.newContent;
-                    affectedLines = newContent.lineNumbers;
-                }
-                catch (e) {
-                    logger.error(e);
-                }
-            }
             return {
                 title: path ? `Edit \`${path}\`` : "Edit",
                 kind: "edit",
@@ -159,16 +139,12 @@ export function toolInfoFromToolUse(toolUse, cachedFileContent, logger = console
                         {
                             type: "diff",
                             path,
-                            oldText,
-                            newText,
+                            oldText: input.old_string ?? null,
+                            newText: input.new_string ?? "",
                         },
                     ]
                     : [],
-                locations: path
-                    ? affectedLines.length > 0
-                        ? affectedLines.map((line) => ({ line, path }))
-                        : [{ path }]
-                    : [],
+                locations: path ? [{ path }] : undefined,
             };
         }
         case acpToolNames.write: {
@@ -355,6 +331,13 @@ export function toolInfoFromToolUse(toolUse, cachedFileContent, logger = console
     }
 }
 export function toolUpdateFromToolResult(toolResult, toolUse) {
+    if ("is_error" in toolResult &&
+        toolResult.is_error &&
+        toolResult.content &&
+        toolResult.content.length > 0) {
+        // Only return errors
+        return toAcpContentUpdate(toolResult.content, true);
+    }
     switch (toolUse?.name) {
         case "Read":
         case acpToolNames.read:
@@ -385,19 +368,57 @@ export function toolUpdateFromToolResult(toolResult, toolUse) {
                 };
             }
             return {};
+        case acpToolNames.edit: {
+            const content = [];
+            const locations = [];
+            if (Array.isArray(toolResult.content) &&
+                toolResult.content.length > 0 &&
+                "text" in toolResult.content[0] &&
+                typeof toolResult.content[0].text === "string") {
+                const patches = diff.parsePatch(toolResult.content[0].text);
+                console.error(JSON.stringify(patches));
+                for (const { oldFileName, newFileName, hunks } of patches) {
+                    for (const { lines, newStart } of hunks) {
+                        const oldText = [];
+                        const newText = [];
+                        for (const line of lines) {
+                            if (line.startsWith("-")) {
+                                oldText.push(line.slice(1));
+                            }
+                            else if (line.startsWith("+")) {
+                                newText.push(line.slice(1));
+                            }
+                            else {
+                                oldText.push(line.slice(1));
+                                newText.push(line.slice(1));
+                            }
+                        }
+                        if (oldText.length > 0 || newText.length > 0) {
+                            locations.push({ path: newFileName || oldFileName, line: newStart });
+                            content.push({
+                                type: "diff",
+                                path: newFileName || oldFileName,
+                                oldText: oldText.join("\n") || null,
+                                newText: newText.join("\n"),
+                            });
+                        }
+                    }
+                }
+            }
+            const result = {};
+            if (content.length > 0) {
+                result.content = content;
+            }
+            if (locations.length > 0) {
+                result.locations = locations;
+            }
+            return result;
+        }
         case acpToolNames.bash:
         case "edit":
         case "Edit":
-        case acpToolNames.edit:
         case acpToolNames.write:
         case "Write": {
-            if ("is_error" in toolResult &&
-                toolResult.is_error &&
-                toolResult.content &&
-                toolResult.content.length > 0) {
-                // Only return errors
-                return toAcpContentUpdate(toolResult.content, true);
-            }
             return {};
         }
         case "ExitPlanMode": {

package/package.json

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