fix(nodejs): add CJS compatibility for VS Code extensions (#528)

The SDK's getBundledCliPath() used import.meta.resolve() which fails
when consumed via CJS bundlers (esbuild format:"cjs", webpack). This
breaks VS Code extensions that bundle dependencies with esbuild.

Changes:
- Replace import.meta.resolve with createRequire + resolution path
  walking (works in both ESM and CJS contexts)
- Add bundled CJS output (dist/cjs/index.cjs) via esbuild
- Add conditional exports in package.json (import + require)
- Add CJS compatibility test suite

The @github/copilot package only exposes ESM exports for ./sdk, so
require.resolve cannot resolve it directly. Instead, we walk the
module resolution paths and check for the package directory.

Fixes #528

Author: darthmolen

nodejs/esbuild-copilotsdk-nodejs.ts

@@ -4,16 +4,39 @@ import { execSync } from "child_process";
 
 const entryPoints = globSync("src/**/*.ts");
 
+// ESM build (existing)
 await esbuild.build({
     entryPoints,
     outbase: "src",
-    outdir: "dist",
+    outdir: "dist/esm",
     format: "esm",
     platform: "node",
     target: "es2022",
     sourcemap: false,
     outExtension: { ".js": ".js" },
 });
 
+// CJS build — single bundled file for consumption from CJS bundlers (esbuild
+// format:"cjs", webpack, VS Code extensions).
+// Bundled to avoid cross-file require resolution issues with .cjs extensions.
+// See: https://github.com/github/copilot-sdk/issues/528
+await esbuild.build({
+    entryPoints: ["src/index.ts"],
+    bundle: true,
+    outfile: "dist/cjs/index.cjs",
+    format: "cjs",
+    platform: "node",
+    target: "es2022",
+    sourcemap: false,
+    // Mark dependencies as external — they're resolved at runtime by the consumer
+    external: [
+        "vscode-jsonrpc",
+        "vscode-jsonrpc/*",
+        "zod",
+        "@github/copilot",
+        "@github/copilot/*",
+    ],
+});
+
 // Generate .d.ts files
 execSync("tsc", { stdio: "inherit" });

nodejs/package.json

@@ -6,12 +6,18 @@
   },
   "version": "0.1.8",
   "description": "TypeScript SDK for programmatic control of GitHub Copilot CLI via JSON-RPC",
-  "main": "./dist/index.js",
+  "main": "./dist/esm/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/cjs/index.cjs"
+      }
     }
   },
   "type": "module",

nodejs/src/client.ts

@@ -13,9 +13,10 @@
 
 import { spawn, type ChildProcess } from "node:child_process";
 import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
 import { Socket } from "node:net";
 import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { pathToFileURL } from "node:url";
 import {
     createMessageConnection,
     MessageConnection,
@@ -117,14 +118,29 @@ function getNodeExecPath(): string {
 /**
  * Gets the path to the bundled CLI from the @github/copilot package.
  * Uses index.js directly rather than npm-loader.js (which spawns the native binary).
+ *
+ * The @github/copilot package only exposes an ESM-only "./sdk" export,
+ * which breaks in CJS contexts (e.g., VS Code extensions bundled with esbuild).
+ * Instead of resolving through the package's exports, we locate the package
+ * root by walking module resolution paths and checking for its directory.
+ * See: https://github.com/github/copilot-sdk/issues/528
  */
 function getBundledCliPath(): string {
-    // Find the actual location of the @github/copilot package by resolving its sdk export
-    const sdkUrl = import.meta.resolve("@github/copilot/sdk");
-    const sdkPath = fileURLToPath(sdkUrl);
-    // sdkPath is like .../node_modules/@github/copilot/sdk/index.js
-    // Go up two levels to get the package root, then append index.js
-    return join(dirname(dirname(sdkPath)), "index.js");
+    // import.meta.url is defined in ESM; in CJS bundles (esbuild format:"cjs")
+    // it's undefined, so we fall back to __filename via pathToFileURL.
+    const require = createRequire(import.meta.url ?? pathToFileURL(__filename).href);
+    // The @github/copilot package has strict ESM-only exports, so require.resolve
+    // cannot resolve it. Instead, walk the module resolution paths to find it.
+    const searchPaths = require.resolve.paths("@github/copilot") ?? [];
+    for (const base of searchPaths) {
+        const candidate = join(base, "@github", "copilot", "index.js");
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error(
+        "Could not find @github/copilot package. Ensure it is installed."
+    );
 }
 
 export class CopilotClient {

nodejs/test/cjs-compat.test.ts

@@ -0,0 +1,66 @@
+/**
+ * CJS compatibility test
+ *
+ * Verifies that the SDK's CJS build can be loaded via require() and that
+ * getBundledCliPath() works when import.meta is unavailable (CJS context).
+ *
+ * This is the scenario that breaks for VS Code extensions bundled with
+ * esbuild format:"cjs". See: https://github.com/github/copilot-sdk/issues/528
+ */
+
+import { describe, expect, it } from "vitest";
+import { existsSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { join } from "node:path";
+
+const cjsEntryPoint = join(import.meta.dirname, "../dist/cjs/index.cjs");
+const esmEntryPoint = join(import.meta.dirname, "../dist/esm/index.js");
+
+describe("CJS compatibility (#528)", () => {
+    it("CJS dist file should exist", () => {
+        expect(existsSync(cjsEntryPoint)).toBe(true);
+    });
+
+    it("ESM dist file should exist", () => {
+        expect(existsSync(esmEntryPoint)).toBe(true);
+    });
+
+    it("CJS build should be requireable and export CopilotClient", () => {
+        // Run in a subprocess to get a genuine CJS context
+        const script = `
+            const sdk = require(${JSON.stringify(cjsEntryPoint)});
+            if (typeof sdk.CopilotClient !== 'function') {
+                process.exit(1);
+            }
+            console.log('CopilotClient exported: OK');
+        `;
+        const output = execFileSync(process.execPath, ["--eval", script], {
+            encoding: "utf-8",
+            timeout: 10000,
+        });
+        expect(output).toContain("CopilotClient exported: OK");
+    });
+
+    it("CJS CopilotClient constructor should resolve bundled CLI path", () => {
+        // Verify that new CopilotClient({ cliUrl: "8080" }) doesn't throw
+        // (constructor calls getBundledCliPath() for the default cliPath)
+        const script = `
+            const sdk = require(${JSON.stringify(cjsEntryPoint)});
+            // Use cliUrl to avoid actually spawning the CLI,
+            // but the constructor still evaluates getBundledCliPath() for cliPath default
+            try {
+                const client = new sdk.CopilotClient({ cliUrl: "8080" });
+                console.log('constructor: OK');
+            } catch (e) {
+                console.error('constructor failed:', e.message);
+                process.exit(1);
+            }
+        `;
+        const output = execFileSync(process.execPath, ["--eval", script], {
+            encoding: "utf-8",
+            timeout: 10000,
+            cwd: join(import.meta.dirname, ".."),
+        });
+        expect(output).toContain("constructor: OK");
+    });
+});