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

package/dist/utils.d.ts

@@ -0,0 +1,32 @@
+import { Readable, Writable } from "node:stream";
+import { WritableStream, ReadableStream } from "node:stream/web";
+import { Logger } from "./acp-agent.js";
+import { ClaudeCodeSettings } from "./settings.js";
+export declare class Pushable<T> implements AsyncIterable<T> {
+    private queue;
+    private resolvers;
+    private done;
+    push(item: T): void;
+    end(): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+export declare function nodeToWebWritable(nodeStream: Writable): WritableStream<Uint8Array>;
+export declare function nodeToWebReadable(nodeStream: Readable): ReadableStream<Uint8Array>;
+export declare function unreachable(value: never, logger?: Logger): void;
+export declare function sleep(time: number): Promise<void>;
+export declare function loadManagedSettings(): ClaudeCodeSettings | null;
+export declare function applyEnvironmentSettings(settings: ClaudeCodeSettings): void;
+export interface ExtractLinesResult {
+    content: string;
+    wasLimited: boolean;
+    linesRead: number;
+}
+/**
+ * Extracts lines from file content with byte limit enforcement.
+ *
+ * @param fullContent - The complete file content
+ * @param maxContentLength - Maximum number of UTF-16 Code Units to return
+ * @returns Object containing extracted content and metadata
+ */
+export declare function extractLinesWithByteLimit(fullContent: string, maxContentLength: number): ExtractLinesResult;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEjE,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACxC,OAAO,EAAE,kBAAkB,EAA0B,MAAM,eAAe,CAAC;AAG3E,qBAAa,QAAQ,CAAC,CAAC,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;IAClD,OAAO,CAAC,KAAK,CAAW;IACxB,OAAO,CAAC,SAAS,CAA8C;IAC/D,OAAO,CAAC,IAAI,CAAS;IAErB,IAAI,CAAC,IAAI,EAAE,CAAC;IASZ,GAAG;IAQH,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC;CAgB3C;AAGD,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,QAAQ,GAAG,cAAc,CAAC,UAAU,CAAC,CAclF;AAED,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,QAAQ,GAAG,cAAc,CAAC,UAAU,CAAC,CAUlF;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,GAAE,MAAgB,QAQjE;AAED,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEjD;AAED,wBAAgB,mBAAmB,IAAI,kBAAkB,GAAG,IAAI,CAM/D;AAED,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI,CAM3E;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,MAAM,GACvB,kBAAkB,CA8CpB"}

package/package.json

@@ -3,15 +3,24 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.12.10",
+  "version": "0.13.1",
   "description": "An ACP-compatible coding agent powered by the Claude Code SDK (TypeScript)",
   "main": "dist/lib.js",
+  "types": "dist/lib.d.ts",
   "bin": {
     "claude-code-acp": "./dist/index.js"
   },
   "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/lib.d.ts",
+      "import": "./dist/lib.js"
+    },
+    "./*": "./*"
+  },
   "files": [
     "dist/",
+    "!dist/tests/",
     "README.md",
     "LICENSE",
     "package.json"
@@ -25,6 +34,7 @@
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "check": "npm run lint && npm run format:check",
+    "sync-upstream": "git merge upstream/main",
     "test": "vitest",
     "test:integration": "RUN_INTEGRATION_TESTS=true vitest run",
     "test:run": "vitest run",
@@ -56,23 +66,23 @@
   "author": "Sudocode AI",
   "license": "Apache-2.0",
   "dependencies": {
-    "@agentclientprotocol/sdk": "0.12.0",
-    "@anthropic-ai/claude-agent-sdk": "0.1.70",
-    "@modelcontextprotocol/sdk": "1.25.0",
-    "diff": "8.0.2",
-    "minimatch": "^10.1.1"
+    "@agentclientprotocol/sdk": "0.13.0",
+    "@anthropic-ai/claude-agent-sdk": "0.2.7",
+    "@modelcontextprotocol/sdk": "1.25.2",
+    "diff": "8.0.3",
+    "minimatch": "10.1.1"
   },
   "devDependencies": {
     "@anthropic-ai/sdk": "0.71.2",
-    "@types/node": "25.0.2",
-    "@typescript-eslint/eslint-plugin": "8.50.0",
-    "@typescript-eslint/parser": "8.50.0",
+    "@types/node": "25.0.8",
+    "@typescript-eslint/eslint-plugin": "8.53.0",
+    "@typescript-eslint/parser": "8.53.0",
     "eslint": "9.39.2",
     "eslint-config-prettier": "10.1.8",
-    "globals": "16.5.0",
-    "prettier": "3.7.4",
+    "globals": "17.0.0",
+    "prettier": "3.8.0",
     "ts-node": "10.9.2",
     "typescript": "5.9.3",
-    "vitest": "4.0.15"
+    "vitest": "4.0.17"
   }
 }

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

@@ -1,338 +0,0 @@
-/**
- * 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");
-        });
-    });
-});