acp-extension-claude 0.13.1

package/dist/tests/typescript-declarations.test.js

@@ -0,0 +1,473 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { spawnSync } from "child_process";
+describe.skipIf(!process.env.RUN_INTEGRATION_TESTS)("TypeScript declaration files integration", () => {
+    let tempDir;
+    let tarballPath;
+    const projectRoot = path.resolve(__dirname, "../..");
+    // Base configuration templates
+    const basePackageJson = {
+        name: "ts-declaration-test",
+        version: "1.0.0",
+        type: "module",
+        dependencies: {},
+        devDependencies: {
+            typescript: "5.9.3",
+            "@types/node": "25.0.3",
+        },
+    };
+    const baseTsConfig = {
+        compilerOptions: {
+            target: "ES2020",
+            module: "NodeNext",
+            moduleResolution: "NodeNext",
+            lib: ["ES2020"],
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true, // Skip checking dependency internals, focus on our types
+            noEmit: true,
+            declaration: false,
+        },
+        include: ["*.ts"],
+    };
+    // Build and pack the package once for all tests
+    beforeAll(async () => {
+        // Step 1: Clean dist folder to ensure fresh build
+        const distPath = path.join(projectRoot, "dist");
+        await fs.promises.rm(distPath, { recursive: true, force: true });
+        console.log("Cleaned dist folder");
+        console.log("Building package...");
+        // Step 2: Build the package
+        const buildResult = spawnSync("npm", ["run", "build"], {
+            cwd: projectRoot,
+            stdio: "pipe",
+            encoding: "utf-8",
+        });
+        if (buildResult.status !== 0) {
+            throw new Error(`Build failed: ${buildResult.stderr || buildResult.stdout}`);
+        }
+        console.log("Packing package...");
+        // Step 3: Pack to create tarball
+        const packResult = spawnSync("npm", ["pack", "--pack-destination", os.tmpdir()], {
+            cwd: projectRoot,
+            stdio: "pipe",
+            encoding: "utf-8",
+        });
+        if (packResult.status !== 0) {
+            throw new Error(`Pack failed: ${packResult.stderr || packResult.stdout}`);
+        }
+        // Get the tarball filename from stdout (npm pack outputs the filename)
+        const tarballName = packResult.stdout.trim().split("\n").pop();
+        if (!tarballName) {
+            throw new Error("Failed to get tarball name from npm pack output");
+        }
+        tarballPath = path.join(os.tmpdir(), tarballName);
+        console.log(`Tarball created at: ${tarballPath}`);
+    }, 60000); // 60 second timeout for build
+    // Clean up the tarball after all tests
+    afterAll(async () => {
+        if (tarballPath && fs.existsSync(tarballPath)) {
+            await fs.promises.unlink(tarballPath);
+            console.log("Cleaned up tarball");
+        }
+    });
+    // Create fresh temp directory for each test
+    beforeEach(async () => {
+        tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "ts-declaration-test-"));
+    });
+    // Clean up temp directory after each test
+    afterEach(async () => {
+        if (tempDir) {
+            await fs.promises.rm(tempDir, { recursive: true, force: true });
+        }
+    });
+    // Helper function to set up a test TypeScript project
+    async function setupTestProject(packageJson = basePackageJson, tsconfig = baseTsConfig) {
+        // Write package.json
+        await fs.promises.writeFile(path.join(tempDir, "package.json"), JSON.stringify(packageJson, null, 2));
+        // Write tsconfig.json
+        await fs.promises.writeFile(path.join(tempDir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2));
+        // Install all dependencies (TypeScript, @types/node, and the tarball)
+        console.log(`Installing dependencies in ${tempDir}...`);
+        const installResult = spawnSync("npm", ["install", tarballPath], {
+            cwd: tempDir,
+            stdio: "pipe",
+            encoding: "utf-8",
+            timeout: 60000, // 60 second timeout
+        });
+        if (installResult.status !== 0) {
+            throw new Error(`npm install failed: ${installResult.stderr || installResult.stdout}`);
+        }
+    }
+    // Helper function to run TypeScript type checking
+    function runTypeCheck(srcDir = tempDir) {
+        const result = spawnSync("npx", ["tsc", "--noEmit"], {
+            cwd: srcDir,
+            stdio: "pipe",
+            encoding: "utf-8",
+            timeout: 30000, // 30 second timeout
+        });
+        return {
+            success: result.status === 0,
+            output: result.stdout + result.stderr,
+        };
+    }
+    // Helper function to write a test TypeScript file
+    async function writeTestFile(filename, content) {
+        await fs.promises.writeFile(path.join(tempDir, filename), content);
+    }
+    // Test 1: Main exports import verification
+    it("should successfully type-check main exports", async () => {
+        await setupTestProject();
+        await writeTestFile("test-main-exports.ts", `
+import {
+  ClaudeAcpAgent,
+  runAcp,
+  toAcpNotifications,
+  streamEventToAcpNotifications,
+  SettingsManager,
+  createMcpServer,
+  loadManagedSettings,
+  applyEnvironmentSettings,
+  nodeToWebReadable,
+  nodeToWebWritable,
+  Pushable,
+  unreachable,
+  toolInfoFromToolUse,
+  planEntries,
+  toolUpdateFromToolResult,
+  createPreToolUseHook,
+  toolNames,
+} from "@zed-industries/claude-code-acp";
+
+// Type-only imports
+import type {
+  ToolUpdateMeta,
+  NewSessionMeta,
+  ClaudeCodeSettings,
+  PermissionSettings,
+  PermissionDecision,
+  PermissionCheckResult,
+  SettingsManagerOptions,
+  ClaudePlanEntry,
+} from "@zed-industries/claude-code-acp";
+
+// Verify exports exist and have expected types
+const _runAcp: typeof runAcp = runAcp;
+const _createMcpServer: typeof createMcpServer = createMcpServer;
+const _toolNames: typeof toolNames = toolNames;
+`);
+        const result = runTypeCheck();
+        if (!result.success) {
+            console.error("TypeScript errors:", result.output);
+        }
+        expect(result.success).toBe(true);
+    }, 120000);
+    // Test 2: Deep imports verification (backwards compatibility)
+    it("should successfully type-check deep imports", async () => {
+        await setupTestProject();
+        await writeTestFile("test-deep-imports.ts", `
+// Deep import from dist/tools.js
+import {
+  acpToolNames,
+  EDIT_TOOL_NAMES,
+  ACP_TOOL_NAME_PREFIX,
+  toolInfoFromToolUse,
+  planEntries,
+} from "@zed-industries/claude-code-acp/dist/tools.js";
+
+// Deep import from dist/settings.js
+import {
+  SettingsManager,
+  getManagedSettingsPath,
+} from "@zed-industries/claude-code-acp/dist/settings.js";
+
+// Deep import from dist/utils.js
+import {
+  Pushable,
+  nodeToWebReadable,
+  nodeToWebWritable,
+  loadManagedSettings,
+} from "@zed-industries/claude-code-acp/dist/utils.js";
+
+// Verify types work
+const prefix: string = ACP_TOOL_NAME_PREFIX;
+const editTools: readonly string[] = EDIT_TOOL_NAMES;
+`);
+        const result = runTypeCheck();
+        if (!result.success) {
+            console.error("TypeScript errors:", result.output);
+        }
+        expect(result.success).toBe(true);
+    }, 120000);
+    // Test 3: SettingsManager type shape verification
+    it("should verify SettingsManager has correct type shape", async () => {
+        await setupTestProject();
+        await writeTestFile("test-settings-manager.ts", `
+import {
+  SettingsManager,
+  ClaudeCodeSettings,
+  PermissionCheckResult,
+  SettingsManagerOptions
+} from "@zed-industries/claude-code-acp";
+
+// Test constructor signature
+const options: SettingsManagerOptions = {
+  onChange: () => {},
+  logger: { log: console.log, error: console.error },
+};
+declare const cwd: string;
+const manager = new SettingsManager(cwd, options);
+
+// Test method signatures
+async function testMethods() {
+  // initialize returns Promise<void>
+  await manager.initialize();
+
+  // checkPermission returns PermissionCheckResult
+  const result: PermissionCheckResult = manager.checkPermission(
+    "mcp__acp__Read",
+    { file_path: "/some/path" }
+  );
+
+  // Verify decision type
+  const decision: "allow" | "deny" | "ask" = result.decision;
+  const rule: string | undefined = result.rule;
+  const source: "allow" | "deny" | "ask" | undefined = result.source;
+
+  // getSettings returns ClaudeCodeSettings
+  const settings: ClaudeCodeSettings = manager.getSettings();
+
+  // getCwd returns string
+  const currentCwd: string = manager.getCwd();
+
+  // setCwd returns Promise<void>
+  await manager.setCwd("/new/path");
+
+  // dispose returns void
+  manager.dispose();
+}
+`);
+        const result = runTypeCheck();
+        if (!result.success) {
+            console.error("TypeScript errors:", result.output);
+        }
+        expect(result.success).toBe(true);
+    }, 120000);
+    // Test 4: ClaudeAcpAgent instantiation and type verification
+    it("should verify ClaudeAcpAgent has correct type shape", async () => {
+        await setupTestProject();
+        await writeTestFile("test-claude-acp-agent.ts", `
+import { ClaudeAcpAgent } from "@zed-industries/claude-code-acp";
+import type { AgentSideConnection } from "@agentclientprotocol/sdk";
+
+// ClaudeAcpAgent should be a class that can be instantiated
+declare const mockConnection: AgentSideConnection;
+declare const mockLogger: { log: (...args: any[]) => void; error: (...args: any[]) => void };
+
+// Test constructor - accepts AgentSideConnection and optional logger
+const agent = new ClaudeAcpAgent(mockConnection, mockLogger);
+
+// Verify it has sessions property
+const sessions: Record<string, any> = agent.sessions;
+
+// Verify it has client property
+const client: AgentSideConnection = agent.client;
+
+// Verify it has logger property
+const logger = agent.logger;
+`);
+        const result = runTypeCheck();
+        if (!result.success) {
+            console.error("TypeScript errors:", result.output);
+        }
+        expect(result.success).toBe(true);
+    }, 120000);
+    // Test 5: Type-only exports work correctly
+    it("should verify type-only exports are usable", async () => {
+        await setupTestProject();
+        await writeTestFile("test-type-exports.ts", `
+import type {
+  ClaudeCodeSettings,
+  PermissionSettings,
+  PermissionDecision,
+  PermissionCheckResult,
+  SettingsManagerOptions,
+  ClaudePlanEntry,
+  ToolUpdateMeta,
+  NewSessionMeta,
+} from "@zed-industries/claude-code-acp";
+
+// Test ClaudeCodeSettings shape
+const settings: ClaudeCodeSettings = {
+  permissions: {
+    allow: ["Read"],
+    deny: ["Read(./.env)"],
+    ask: ["Bash"],
+    additionalDirectories: ["/extra"],
+    defaultMode: "default",
+  },
+  env: {
+    API_KEY: "secret",
+  },
+};
+
+// Test PermissionSettings shape
+const perms: PermissionSettings = {
+  allow: ["Read"],
+  deny: ["Write"],
+};
+
+// Test PermissionDecision
+const decisions: PermissionDecision[] = ["allow", "deny", "ask"];
+
+// Test ClaudePlanEntry shape
+const planEntry: ClaudePlanEntry = {
+  content: "Do something",
+  status: "pending",
+  activeForm: "Doing something",
+};
+
+// Test valid status values
+const validStatuses: ClaudePlanEntry["status"][] = [
+  "pending",
+  "in_progress",
+  "completed",
+];
+
+// Test ToolUpdateMeta shape
+const toolMeta: ToolUpdateMeta = {
+  claudeCode: {
+    toolName: "Read",
+    toolResponse: { success: true },
+  },
+};
+
+// Test NewSessionMeta shape
+const sessionMeta: NewSessionMeta = {
+  claudeCode: {
+    options: {},
+  },
+};
+`);
+        const result = runTypeCheck();
+        if (!result.success) {
+            console.error("TypeScript errors:", result.output);
+        }
+        expect(result.success).toBe(true);
+    }, 120000);
+    // Test 6: Function signatures verification
+    it("should verify function signatures are correct", async () => {
+        await setupTestProject();
+        await writeTestFile("test-function-signatures.ts", `
+import {
+  runAcp,
+  createMcpServer,
+  toolInfoFromToolUse,
+  planEntries,
+  createPreToolUseHook,
+  loadManagedSettings,
+  applyEnvironmentSettings,
+  SettingsManager,
+} from "@zed-industries/claude-code-acp";
+
+import type { ClaudeCodeSettings } from "@zed-industries/claude-code-acp";
+
+// runAcp should be a function with no parameters that returns void
+const runAcpType: () => void = runAcp;
+
+// toolInfoFromToolUse should accept any and return object with title and kind
+const info = toolInfoFromToolUse({ name: "Read", input: {} });
+const title: string = info.title;
+const kind: string = info.kind;
+
+// planEntries should accept todos array and return array
+const entries = planEntries({
+  todos: [
+    { content: "test", status: "pending", activeForm: "testing" }
+  ]
+});
+// entries should be an array
+const entriesArray: any[] = entries;
+
+// createPreToolUseHook should accept SettingsManager and optional logger
+declare const settingsManager: SettingsManager;
+const hook = createPreToolUseHook(settingsManager, console);
+
+// loadManagedSettings should return ClaudeCodeSettings | null
+const managedSettings: ClaudeCodeSettings | null = loadManagedSettings();
+
+// applyEnvironmentSettings should accept ClaudeCodeSettings and return void
+const applyResult: void = applyEnvironmentSettings({ permissions: {} });
+`);
+        const result = runTypeCheck();
+        if (!result.success) {
+            console.error("TypeScript errors:", result.output);
+        }
+        expect(result.success).toBe(true);
+    }, 120000);
+    // Test 7: Pushable generic class verification
+    it("should verify Pushable class works correctly", async () => {
+        await setupTestProject();
+        await writeTestFile("test-pushable.ts", `
+import { Pushable } from "@zed-industries/claude-code-acp";
+
+// Pushable should be a generic class
+const pushable = new Pushable<string>();
+
+// Should have push method
+pushable.push("test");
+
+// Should have end method
+pushable.end();
+
+// Should implement AsyncIterable
+async function consume() {
+  for await (const item of pushable) {
+    const str: string = item;
+  }
+}
+
+// Generic type parameter should work
+const numPushable = new Pushable<number>();
+numPushable.push(42);
+
+interface MyType { id: number; name: string; }
+const customPushable = new Pushable<MyType>();
+customPushable.push({ id: 1, name: "test" });
+`);
+        const result = runTypeCheck();
+        if (!result.success) {
+            console.error("TypeScript errors:", result.output);
+        }
+        expect(result.success).toBe(true);
+    }, 120000);
+    // Test 8: Verify incorrect types fail
+    it("should fail type-check with incorrect types", async () => {
+        await setupTestProject();
+        await writeTestFile("test-invalid-types.ts", `
+import { SettingsManager, ClaudeCodeSettings } from "@zed-industries/claude-code-acp";
+
+// This should fail - SettingsManager constructor requires string cwd
+// @ts-expect-error - Testing that wrong argument type fails
+const badManager = new SettingsManager(123);
+
+// This should fail - ClaudeCodeSettings permissions must be an object
+const badSettings: ClaudeCodeSettings = {
+  // @ts-expect-error - Testing that wrong type fails
+  permissions: "not-an-object",
+};
+`);
+        // This test should PASS because we expect tsc to catch these errors
+        // with @ts-expect-error directives
+        const result = runTypeCheck();
+        if (!result.success) {
+            // If it fails, it means @ts-expect-error didn't catch the error
+            // which could mean the types are too permissive
+            console.error("TypeScript errors (expected @ts-expect-error to catch):", result.output);
+        }
+        expect(result.success).toBe(true);
+    }, 120000);
+});

package/dist/tools.d.ts

@@ -0,0 +1,50 @@
+import { PlanEntry, ToolCallContent, ToolCallLocation, ToolKind } from "@agentclientprotocol/sdk";
+import { ToolResultBlockParam, WebSearchToolResultBlockParam } from "@anthropic-ai/sdk/resources";
+export declare const ACP_TOOL_NAME_PREFIX = "mcp__acp__";
+export declare const acpToolNames: {
+    read: string;
+    edit: string;
+    write: string;
+    bash: string;
+    killShell: string;
+    bashOutput: string;
+};
+export declare const EDIT_TOOL_NAMES: string[];
+import { BetaBashCodeExecutionToolResultBlockParam, BetaCodeExecutionToolResultBlockParam, BetaRequestMCPToolResultBlockParam, BetaTextEditorCodeExecutionToolResultBlockParam, BetaToolSearchToolResultBlockParam, BetaWebFetchToolResultBlockParam, BetaWebSearchToolResultBlockParam } from "@anthropic-ai/sdk/resources/beta.mjs";
+import { HookCallback } from "@anthropic-ai/claude-agent-sdk";
+import { Logger } from "./acp-agent.js";
+import { SettingsManager } from "./settings.js";
+interface ToolInfo {
+    title: string;
+    kind: ToolKind;
+    content: ToolCallContent[];
+    locations?: ToolCallLocation[];
+}
+interface ToolUpdate {
+    title?: string;
+    content?: ToolCallContent[];
+    locations?: ToolCallLocation[];
+}
+export declare function toolInfoFromToolUse(toolUse: any): ToolInfo;
+export declare function toolUpdateFromToolResult(toolResult: ToolResultBlockParam | BetaWebSearchToolResultBlockParam | BetaWebFetchToolResultBlockParam | WebSearchToolResultBlockParam | BetaCodeExecutionToolResultBlockParam | BetaBashCodeExecutionToolResultBlockParam | BetaTextEditorCodeExecutionToolResultBlockParam | BetaRequestMCPToolResultBlockParam | BetaToolSearchToolResultBlockParam, toolUse: any | undefined): ToolUpdate;
+export type ClaudePlanEntry = {
+    content: string;
+    status: "pending" | "in_progress" | "completed";
+    activeForm: string;
+};
+export declare function planEntries(input: {
+    todos: ClaudePlanEntry[];
+}): PlanEntry[];
+export declare function markdownEscape(text: string): string;
+export declare const registerHookCallback: (toolUseID: string, { onPostToolUseHook, }: {
+    onPostToolUseHook?: (toolUseID: string, toolInput: unknown, toolResponse: unknown) => Promise<void>;
+}) => void;
+export declare const createPostToolUseHook: (logger?: Logger) => HookCallback;
+/**
+ * Creates a PreToolUse hook that checks permissions using the SettingsManager.
+ * This runs before the SDK's built-in permission rules, allowing us to enforce
+ * our own permission settings for ACP-prefixed tools.
+ */
+export declare const createPreToolUseHook: (settingsManager: SettingsManager, logger?: Logger) => HookCallback;
+export {};
+//# sourceMappingURL=tools.d.ts.map

package/dist/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGlG,OAAO,EAAE,oBAAoB,EAAE,6BAA6B,EAAE,MAAM,6BAA6B,CAAC;AAWlG,eAAO,MAAM,oBAAoB,eAAe,CAAC;AACjD,eAAO,MAAM,YAAY;;;;;;;CAOxB,CAAC;AAEF,eAAO,MAAM,eAAe,UAA0C,CAAC;AAEvE,OAAO,EACL,yCAAyC,EACzC,qCAAqC,EACrC,kCAAkC,EAClC,+CAA+C,EAC/C,kCAAkC,EAClC,gCAAgC,EAChC,iCAAiC,EAClC,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAC9D,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAEhD,UAAU,QAAQ;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC;CAChC;AAED,UAAU,UAAU;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,eAAe,EAAE,CAAC;IAC5B,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC;CAChC;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,GAAG,GAAG,QAAQ,CA+V1D;AAED,wBAAgB,wBAAwB,CACtC,UAAU,EACN,oBAAoB,GACpB,iCAAiC,GACjC,gCAAgC,GAChC,6BAA6B,GAC7B,qCAAqC,GACrC,yCAAyC,GACzC,+CAA+C,GAC/C,kCAAkC,GAClC,kCAAkC,EACtC,OAAO,EAAE,GAAG,GAAG,SAAS,GACvB,UAAU,CA4HZ;AAmCD,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,SAAS,GAAG,aAAa,GAAG,WAAW,CAAC;IAChD,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,wBAAgB,WAAW,CAAC,KAAK,EAAE;IAAE,KAAK,EAAE,eAAe,EAAE,CAAA;CAAE,GAAG,SAAS,EAAE,CAM5E;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQnD;AAcD,eAAO,MAAM,oBAAoB,GAC/B,WAAW,MAAM,EACjB,wBAEG;IACD,iBAAiB,CAAC,EAAE,CAClB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,OAAO,EAClB,YAAY,EAAE,OAAO,KAClB,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB,SAKF,CAAC;AAGF,eAAO,MAAM,qBAAqB,GAC/B,SAAQ,MAAgB,KAAG,YAa3B,CAAC;AAEJ;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAC9B,iBAAiB,eAAe,EAAE,SAAQ,MAAgB,KAAG,YA2C7D,CAAC"}