@roblourens/dap-cli 0.2.0 → 0.3.0

package/dist/index.js

@@ -846,8 +846,10 @@ function breakpointBindingGuidance(options = {}) {
 }
 
 // src/controller/ipc.ts
+import { createHash } from "crypto";
 import { promises as fs } from "fs";
 import net from "net";
+import { tmpdir } from "os";
 import path2 from "path";
 import { z as z2 } from "zod";
 
@@ -901,6 +903,7 @@ var controllerDiscoverySchema = z2.object({
   startedAt: z2.string().min(1),
   lastHeartbeatAt: z2.string().min(1)
 });
+var maximumPortableUnixSocketPathLength = 100;
 function resolveControllerDiscoveryPath(options = {}) {
   return path2.join(resolveStateDir(options), "controller.json");
 }
@@ -982,7 +985,12 @@ function createControllerEndpoint(stateDir, platform) {
   if (platform === "win32") {
     return { kind: "ipc", path: `\\\\.\\pipe\\dap-cli-${Buffer.from(stateDir).toString("hex").slice(0, 24)}` };
   }
-  return { kind: "ipc", path: path2.join(stateDir, "controller.sock") };
+  const endpointPath = path2.join(stateDir, "controller.sock");
+  if (Buffer.byteLength(endpointPath, "utf8") <= maximumPortableUnixSocketPathLength) {
+    return { kind: "ipc", path: endpointPath };
+  }
+  const stateHash = createHash("sha256").update(stateDir).digest("hex").slice(0, 24);
+  return { kind: "ipc", path: path2.join(tmpdir(), `dap-cli-${stateHash}.sock`) };
 }
 function resolveStateDir(options) {
   return getDapCliStateDir(createEnv(options));
@@ -1157,8 +1165,8 @@ function isSessionErrorCode(code) {
 }
 
 // src/controller/server.ts
-import path16 from "path";
-import { randomBytes as randomBytes5 } from "crypto";
+import path17 from "path";
+import { randomBytes as randomBytes6 } from "crypto";
 
 // src/adapters/descriptor.ts
 import { z as z3 } from "zod";
@@ -1310,9 +1318,16 @@ function createSocketTransport(options) {
     readable: options.socket,
     writable: options.socket,
     close() {
-      options.socket.end();
-      options.socket.destroy();
-      return Promise.resolve();
+      if (options.socket.closed) {
+        return Promise.resolve();
+      }
+      return new Promise((resolve) => {
+        options.socket.once("close", resolve);
+        if (!options.socket.destroyed) {
+          options.socket.end();
+          options.socket.destroy();
+        }
+      });
     }
   };
 }
@@ -1465,8 +1480,8 @@ async function delay(ms) {
 }
 
 // src/adapters/builtins/jsDebug.ts
-import { promises as fs10 } from "fs";
-import path13 from "path";
+import { promises as fs11 } from "fs";
+import path14 from "path";
 
 // src/cli/confirm.ts
 import * as readline from "readline/promises";
@@ -1519,7 +1534,7 @@ function resolveAssumeYes(cliYes, env) {
 
 // src/adapters/provision/jsDebug.ts
 import path9 from "path";
-import { createHash, randomBytes as randomBytes2 } from "crypto";
+import { createHash as createHash2, randomBytes as randomBytes2 } from "crypto";
 import { promises as fs6, createReadStream as createReadStream2 } from "fs";
 
 // src/adapters/provision/atomicInstall.ts
@@ -1954,6 +1969,7 @@ async function writeConsentMarker(adaptersDir, adapterId, version) {
 var JS_DEBUG_VERSION = "1.117.0";
 var DEBUGPY_VERSION = "1.8.20";
 var DELVE_VERSION = "v1.26.3";
+var CODELLDB_VERSION = "v1.12.2";
 var JS_DEBUG_CHECKSUMS = {
   "1.117.0": "ad8d04ede9d4b75cc290fd5438a65047a06f786d04f604b6112485b36f090772"
 };
@@ -1966,6 +1982,11 @@ var DELVE_CHECKSUMS = {
     windows_amd64: "f9e15b8f3628e4c7bfe481011bea458df754d0e75c6ff4ab01c71294165950fd"
   }
 };
+var CODELLDB_CHECKSUMS = {
+  "v1.12.2": {
+    darwin_arm64: "c836b81c6f2da467b5920a376a7bfc849dc4b4d81b19779dedf1c685cb4aa1a0"
+  }
+};
 
 // src/adapters/provision/jsDebug.ts
 var ADAPTER_ID = "js-debug";
@@ -1980,7 +2001,7 @@ function downloadUrl(env) {
 }
 async function fileSha256(filePath) {
   return await new Promise((resolve, reject) => {
-    const hash = createHash("sha256");
+    const hash = createHash2("sha256");
     const stream = createReadStream2(filePath);
     stream.on("error", reject);
     stream.on("data", (chunk) => hash.update(chunk));
@@ -2219,7 +2240,7 @@ async function provisionDebugpy(ctx) {
 // src/adapters/provision/delve.ts
 import path12 from "path";
 import { promises as fs9 } from "fs";
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { randomBytes as randomBytes3 } from "crypto";
 
 // src/adapters/provision/extractZip.ts
@@ -2365,7 +2386,7 @@ async function exists2(p) {
 }
 async function computeSha256(filePath) {
   const buffer = await fs9.readFile(filePath);
-  return createHash2("sha256").update(buffer).digest("hex");
+  return createHash3("sha256").update(buffer).digest("hex");
 }
 async function provisionDelve(ctx) {
   const { env, assumeYes, adaptersDir, stdin, stderr } = ctx;
@@ -2468,6 +2489,139 @@ async function provisionDelve(ctx) {
   };
 }
 
+// src/adapters/provision/codelldb.ts
+import path13 from "path";
+import { promises as fs10 } from "fs";
+import { createHash as createHash4, randomBytes as randomBytes4 } from "crypto";
+var ADAPTER_ID2 = "codelldb";
+var DEFAULT_RELEASE_BASE_URL2 = "https://github.com";
+var ENTRYPOINT = "extension/adapter/codelldb";
+var REQUIRED_RUNTIME_PATHS = [
+  ENTRYPOINT,
+  "extension/adapter/scripts/codelldb/__init__.py",
+  "extension/lldb/bin/lldb",
+  "extension/lldb/bin/lldb-argdumper",
+  "extension/lldb/bin/lldb-server",
+  "extension/lldb/lib/liblldb.dylib",
+  "extension/lldb/lib/libpython312.dylib",
+  "extension/lldb/lib/python3.12/os.py",
+  "extension/lang_support/rust.py",
+  "extension/package.json"
+];
+var EXECUTABLE_PATHS = [
+  ENTRYPOINT,
+  "extension/lldb/bin/lldb",
+  "extension/lldb/bin/lldb-argdumper",
+  "extension/lldb/bin/lldb-server"
+];
+function resolveCodeLldbAsset(env) {
+  const override = env.DAP_CLI_PROVISION_CODELLDB_PLATFORM_OVERRIDE;
+  const detected = override !== void 0 && override.length > 0 ? override : `${process.platform}_${process.arch}`;
+  if (detected !== "darwin_arm64") {
+    throw usageError(`CodeLLDB provisioning does not support platform '${detected}'.`, {
+      code: "provision_arch_unsupported",
+      diagnostics: [
+        `Detected platform: ${detected}`,
+        "Supported platforms: darwin_arm64.",
+        "Only the official CodeLLDB darwin-arm64 artifact has passed verification."
+      ],
+      data: {
+        adapterId: ADAPTER_ID2,
+        detected,
+        supported: ["darwin_arm64"]
+      }
+    });
+  }
+  return {
+    platformKey: "darwin_arm64",
+    archiveName: "codelldb-darwin-arm64.vsix"
+  };
+}
+async function isCodeLldbRuntimeReady(installRoot) {
+  for (const relativePath of REQUIRED_RUNTIME_PATHS) {
+    try {
+      await fs10.access(path13.join(installRoot, relativePath));
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+async function computeSha2562(filePath) {
+  const buffer = await fs10.readFile(filePath);
+  return createHash4("sha256").update(buffer).digest("hex");
+}
+async function provisionCodeLldb(ctx) {
+  const asset = resolveCodeLldbAsset(ctx.env);
+  const installRoot = path13.join(ctx.adaptersDir, ADAPTER_ID2);
+  const entrypoint = path13.join(installRoot, ENTRYPOINT);
+  const expectedSha = CODELLDB_CHECKSUMS[CODELLDB_VERSION]?.[asset.platformKey];
+  if (expectedSha === void 0) {
+    throw usageError(`No pinned SHA-256 for CodeLLDB ${CODELLDB_VERSION} on ${asset.platformKey}.`, {
+      code: "provision_checksum_mismatch",
+      diagnostics: [
+        `Adapter: ${ADAPTER_ID2} ${CODELLDB_VERSION} (${asset.platformKey})`,
+        "src/adapters/provision/checksums.ts must list a verified checksum for every supported platform.",
+        "Re-run setup or report at https://github.com/roblourens/dap-cli/issues if persistent."
+      ],
+      data: { adapterId: ADAPTER_ID2, version: CODELLDB_VERSION, platform: asset.platformKey }
+    });
+  }
+  if (await hasConsentMarker(ctx.adaptersDir, ADAPTER_ID2, CODELLDB_VERSION) && await isCodeLldbRuntimeReady(installRoot)) {
+    return { adapterId: ADAPTER_ID2, version: CODELLDB_VERSION, installRoot, entrypoint, fromCache: true };
+  }
+  await confirm({
+    assumeYes: ctx.assumeYes,
+    question: `Install CodeLLDB ${CODELLDB_VERSION} into ${installRoot}/ (~44MB download)?`,
+    details: [
+      `Downloads the official release asset ${asset.archiveName} from github.com/vadimcn/codelldb.`,
+      "The full VSIX runtime tree is cached locally after SHA-256 verification."
+    ],
+    ...ctx.stdin === void 0 ? {} : { stdin: ctx.stdin },
+    ...ctx.stderr === void 0 ? {} : { stderr: ctx.stderr }
+  });
+  await withAdapterLock(ctx.adaptersDir, ADAPTER_ID2, async () => {
+    if (await hasConsentMarker(ctx.adaptersDir, ADAPTER_ID2, CODELLDB_VERSION) && await isCodeLldbRuntimeReady(installRoot)) {
+      return;
+    }
+    const releaseBase = ctx.env.DAP_CLI_PROVISION_RELEASE_BASE_URL ?? DEFAULT_RELEASE_BASE_URL2;
+    const url = `${releaseBase}/vadimcn/codelldb/releases/download/${CODELLDB_VERSION}/${asset.archiveName}`;
+    const archivePath = path13.join(ctx.adaptersDir, `.${ADAPTER_ID2}.archive.${process.pid}.${randomBytes4(4).toString("hex")}.vsix`);
+    try {
+      await fs10.mkdir(ctx.adaptersDir, { recursive: true });
+      await downloadToFile({ url, destPath: archivePath, env: ctx.env });
+      const actualSha = await computeSha2562(archivePath);
+      if (actualSha !== expectedSha) {
+        throw usageError("CodeLLDB archive failed SHA-256 verification.", {
+          code: "provision_checksum_mismatch",
+          diagnostics: [
+            `URL: ${url}`,
+            `Expected: ${expectedSha}`,
+            `Actual:   ${actualSha}`,
+            "Re-run setup or report at https://github.com/roblourens/dap-cli/issues if persistent."
+          ],
+          data: { adapterId: ADAPTER_ID2, version: CODELLDB_VERSION, url, expectedSha, actualSha }
+        });
+      }
+      await atomicInstall({
+        adaptersDir: ctx.adaptersDir,
+        adapterId: ADAPTER_ID2,
+        expectedEntrypoints: REQUIRED_RUNTIME_PATHS,
+        populate: async (stagingDir) => {
+          await extractZip(archivePath, stagingDir);
+          for (const executablePath of EXECUTABLE_PATHS) {
+            await fs10.chmod(path13.join(stagingDir, executablePath), 493);
+          }
+        }
+      });
+      await writeConsentMarker(ctx.adaptersDir, ADAPTER_ID2, CODELLDB_VERSION);
+    } finally {
+      await fs10.rm(archivePath, { force: true }).catch(() => void 0);
+    }
+  });
+  return { adapterId: ADAPTER_ID2, version: CODELLDB_VERSION, installRoot, entrypoint, fromCache: false };
+}
+
 // src/adapters/provision/index.ts
 async function provisionAdapter(id, ctx) {
   switch (id) {
@@ -2477,6 +2631,8 @@ async function provisionAdapter(id, ctx) {
       return provisionDebugpy(ctx);
     case "delve":
       return provisionDelve(ctx);
+    case "codelldb":
+      return provisionCodeLldb(ctx);
   }
 }
 
@@ -2506,13 +2662,13 @@ function applyJsDebugTraceDefaults(config, logDir) {
     ...record,
     trace: {
       stdio: false,
-      logFile: path13.join(logDir, `js-debug-trace-${Date.now()}.log`)
+      logFile: path14.join(logDir, `js-debug-trace-${Date.now()}.log`)
     }
   };
 }
 async function pathExists(candidate) {
   try {
-    await fs10.access(candidate);
+    await fs11.access(candidate);
     return true;
   } catch {
     return false;
@@ -2521,8 +2677,8 @@ async function pathExists(candidate) {
 async function resolveDefaultJsDebugPath() {
   const env = process.env;
   const adaptersDir = getDapCliAdaptersDir(env);
-  const provisionedEntrypoint = path13.join(adaptersDir, "js-debug", "src", "dapDebugServer.js");
-  const repoEntrypoint = path13.join(process.cwd(), "node_modules", "vscode-js-debug", "src", "dapDebugServer.js");
+  const provisionedEntrypoint = path14.join(adaptersDir, "js-debug", "src", "dapDebugServer.js");
+  const repoEntrypoint = path14.join(process.cwd(), "node_modules", "vscode-js-debug", "src", "dapDebugServer.js");
   if (await pathExists(provisionedEntrypoint)) {
     return provisionedEntrypoint;
   }
@@ -2658,6 +2814,9 @@ var DapClient = class {
     transport.readable.on("close", this.handleClosed);
     transport.readable.on("end", this.handleClosed);
     transport.readable.on("error", this.handleTransportError);
+    if (!Object.is(transport.writable, transport.readable)) {
+      transport.writable.on("error", this.handleTransportError);
+    }
   }
   transport;
   options;
@@ -2720,9 +2879,12 @@ var DapClient = class {
   }
   async close() {
     this.handleClosed();
-    this.detachTransportHandlers();
-    await this.terminateChildProcesses();
-    await this.transport.close();
+    try {
+      await this.terminateChildProcesses();
+      await this.transport.close();
+    } finally {
+      this.detachTransportHandlers();
+    }
   }
   handleData = (chunk) => {
     try {
@@ -2742,7 +2904,8 @@ var DapClient = class {
     this.rejectPending(new DapTransportClosedError());
   };
   handleTransportError = (error) => {
-    this.rejectPending(error);
+    this.closed = true;
+    this.rejectPending(error instanceof DapTransportClosedError ? error : new DapTransportClosedError(error.message));
   };
   handleMessage(message) {
     if (message.type === "event") {
@@ -2847,6 +3010,9 @@ var DapClient = class {
     this.transport.readable.removeListener("close", this.handleClosed);
     this.transport.readable.removeListener("end", this.handleClosed);
     this.transport.readable.removeListener("error", this.handleTransportError);
+    if (!Object.is(this.transport.writable, this.transport.readable)) {
+      this.transport.writable.removeListener("error", this.handleTransportError);
+    }
   }
   handleRunInTerminal(argumentsValue) {
     const parsed = runInTerminalArgumentsSchema.safeParse(argumentsValue);
@@ -3178,14 +3344,14 @@ function getDapGeneratedCommand(command) {
 }
 
 // src/sessions/session.ts
-import { randomBytes as randomBytes4 } from "crypto";
+import { randomBytes as randomBytes5 } from "crypto";
 var REMOVABLE_LIFECYCLES = /* @__PURE__ */ new Set([
   "terminated",
   "disconnected",
   "failed"
 ]);
 function createSessionId() {
-  return `sess_${randomBytes4(12).toString("base64url")}`;
+  return `sess_${randomBytes5(12).toString("base64url")}`;
 }
 function projectSessionSummary(session) {
   const summary = {
@@ -3298,9 +3464,9 @@ function createAmbiguousSessionDiagnostics(targetId, matches) {
 }
 
 // src/sessions/sessionStore.ts
-import { promises as fs11 } from "fs";
+import { promises as fs12 } from "fs";
 import { randomUUID } from "crypto";
-import path14 from "path";
+import path15 from "path";
 import { z as z5 } from "zod";
 var ownedAdapterSchema = z5.object({
   pid: z5.number().int().positive().optional(),
@@ -3342,14 +3508,14 @@ var SessionStore = class {
   storePath;
   constructor(options = {}) {
     const env = options.dapCliHome === void 0 ? process.env : { ...process.env, DAP_CLI_HOME: options.dapCliHome };
-    this.storePath = path14.join(getDapCliStateDir(env), "sessions.json");
+    this.storePath = path15.join(getDapCliStateDir(env), "sessions.json");
   }
   get path() {
     return this.storePath;
   }
   async read() {
     try {
-      const raw = await fs11.readFile(this.storePath, "utf8");
+      const raw = await fs12.readFile(this.storePath, "utf8");
       const parsed = sessionStoreSchema.parse(JSON.parse(raw));
       return {
         ...parsed.activeSessionId !== void 0 ? { activeSessionId: parsed.activeSessionId } : {},
@@ -3362,7 +3528,7 @@ var SessionStore = class {
       if (error instanceof SyntaxError || error instanceof z5.ZodError) {
         const backupPath = `${this.storePath}.corrupt.${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.bak`;
         try {
-          await fs11.rename(this.storePath, backupPath);
+          await fs12.rename(this.storePath, backupPath);
           process.stderr.write(`dap-cli: sessions.json was unparseable; moved to ${backupPath} and continuing with empty state.
 `);
         } catch {
@@ -3373,12 +3539,12 @@ var SessionStore = class {
     }
   }
   async write(data) {
-    await fs11.mkdir(path14.dirname(this.storePath), { recursive: true });
+    await fs12.mkdir(path15.dirname(this.storePath), { recursive: true });
     const validated = sessionStoreSchema.parse(data);
     const tempPath = `${this.storePath}.${process.pid}.${randomUUID()}.tmp`;
-    await fs11.writeFile(tempPath, `${JSON.stringify(validated, null, 2)}
+    await fs12.writeFile(tempPath, `${JSON.stringify(validated, null, 2)}
 `, "utf8");
-    await fs11.rename(tempPath, this.storePath);
+    await fs12.rename(tempPath, this.storePath);
   }
 };
 function isNodeError2(error) {
@@ -4111,22 +4277,72 @@ var ChildSessionCoordinator = class {
     try {
       await this.options.sessionManager.updateLifecycle(childId, command === "launch" ? "launching" : "attaching").catch(() => void 0);
       const requestPromise = client.request(command, config);
-      requestPromise.catch(() => void 0);
+      let launchAttachOutcome = "pending";
+      requestPromise.then(
+        () => {
+          launchAttachOutcome = "fulfilled";
+        },
+        (error) => {
+          launchAttachOutcome = { error };
+        }
+      );
       await runtime.initializedPromise;
       for (const breakpointArgs of this.pendingSetBreakpoints) {
         await client.request("setBreakpoints", breakpointArgs);
       }
       await client.request("configurationDone");
-      await requestPromise;
+      await Promise.resolve();
+      const getLaunchAttachOutcome = () => launchAttachOutcome;
+      const outcomeAfterConfiguration = getLaunchAttachOutcome();
+      if (typeof outcomeAfterConfiguration === "object") {
+        throw outcomeAfterConfiguration.error;
+      }
       await this.options.sessionManager.updateLifecycle(childId, "running").catch(() => void 0);
       if (!runtime.readySeen) {
         runtime.readySeen = true;
         runtime.resolveReady();
       }
+      if (outcomeAfterConfiguration === "pending") {
+        this.observeTrailingLaunchAttachResponse(childId, command, requestPromise);
+      }
     } catch (error) {
       await this.markChildFailed(childId, error);
     }
   }
+  /**
+   * Observe a launch/attach response that arrives — or times out — AFTER the
+   * child has already been marked `running` off the back of `configurationDone`.
+   *
+   * A trailing rejection no longer fails the child: the session is configured
+   * and usable, and gating readiness on this response wedged js-debug page
+   * sessions (see {@link runChildLifecycle}). Instead it is surfaced as a
+   * non-fatal `output` warning on the parent so the condition stays debuggable
+   * from the agent side. Transport-closed rejections during normal teardown are
+   * ignored — they are not an attach anomaly.
+   */
+  observeTrailingLaunchAttachResponse(childId, command, requestPromise) {
+    void requestPromise.then(
+      () => void 0,
+      (error) => {
+        if (error instanceof DapTransportClosedError) {
+          return;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        const synthetic = {
+          seq: 0,
+          type: "event",
+          event: "output",
+          body: {
+            category: "stderr",
+            output: `child session ${childId} ${command} response not received: ${message}
+`,
+            child_session_id: childId
+          }
+        };
+        this.options.parentEventCache.append(this.options.parentSessionId, synthetic);
+      }
+    );
+  }
   async markChildFailed(childId, error) {
     await this.options.sessionManager.updateLifecycle(childId, "failed").catch(() => void 0);
     const runtime = this.children.get(childId);
@@ -4784,7 +5000,7 @@ function sourceMatches(eventPath, requestPath) {
   if (eventPath === requestPath) {
     return true;
   }
-  const normalize = (path24) => path24.replace(/^file:\/\//, "").replace(/\\/g, "/");
+  const normalize = (path26) => path26.replace(/^file:\/\//, "").replace(/\\/g, "/");
   return normalize(eventPath) === normalize(requestPath);
 }
 
@@ -4889,8 +5105,8 @@ function defaultLookupPpid(pid) {
 }
 
 // src/controller/buildId.ts
-import { promises as fs12 } from "fs";
-import path15 from "path";
+import { promises as fs13 } from "fs";
+import path16 from "path";
 import { fileURLToPath } from "url";
 var cachedBuildId;
 async function computeBuildId() {
@@ -4902,14 +5118,14 @@ async function computeBuildId() {
     cachedBuildId = envOverride;
     return cachedBuildId;
   }
-  const here = path15.dirname(fileURLToPath(import.meta.url));
+  const here = path16.dirname(fileURLToPath(import.meta.url));
   const pkgPath = await findPackageJson(here);
   let version = "0.0.0";
   let pkgDir = here;
   if (pkgPath !== void 0) {
-    pkgDir = path15.dirname(pkgPath);
+    pkgDir = path16.dirname(pkgPath);
     try {
-      const raw = await fs12.readFile(pkgPath, "utf8");
+      const raw = await fs13.readFile(pkgPath, "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed.version === "string" && parsed.version.length > 0) {
         version = parsed.version;
@@ -4917,9 +5133,9 @@ async function computeBuildId() {
     } catch {
     }
   }
-  const distPath = path15.join(pkgDir, "dist", "index.js");
+  const distPath = path16.join(pkgDir, "dist", "index.js");
   try {
-    const stat = await fs12.stat(distPath);
+    const stat = await fs13.stat(distPath);
     cachedBuildId = `${version}:dist:${stat.mtimeMs}:${stat.size}`;
   } catch {
     cachedBuildId = `${version}:src`;
@@ -4929,12 +5145,12 @@ async function computeBuildId() {
 async function findPackageJson(startDir) {
   let dir = startDir;
   for (let depth = 0; depth < 8; depth += 1) {
-    const candidate = path15.join(dir, "package.json");
+    const candidate = path16.join(dir, "package.json");
     try {
-      await fs12.access(candidate);
+      await fs13.access(candidate);
       return candidate;
     } catch {
-      const parent = path15.dirname(dir);
+      const parent = path16.dirname(dir);
       if (parent === dir) {
         return void 0;
       }
@@ -5687,7 +5903,7 @@ var ControllerServer = class {
       return { sources: [] };
     }
     if (source !== void 0) {
-      const entry = map.get(path16.resolve(source));
+      const entry = map.get(path17.resolve(source));
       return entry === void 0 ? { sources: [] } : { sources: [{ source: entry.source, breakpoints: entry.response, requested: entry.requested }] };
     }
     return {
@@ -5712,7 +5928,7 @@ var ControllerServer = class {
     };
     const cleared = [];
     if (source !== void 0) {
-      const key = path16.resolve(source);
+      const key = path17.resolve(source);
       const entry = map.get(key);
       if (entry === void 0) {
         return { cleared: [] };
@@ -5878,7 +6094,9 @@ var ControllerServer = class {
     if (runtime.children !== void 0) {
       await runtime.children.dispose().catch(() => void 0);
     }
-    await runtime.lifecycle.disconnect({ terminateDebuggee: opts.terminateDebuggee }).catch(() => void 0);
+    const disconnect = runtime.lifecycle.disconnect({ terminateDebuggee: opts.terminateDebuggee });
+    disconnect.catch(() => void 0);
+    await this.waitForDisconnect(disconnect, controllerDisconnectTimeoutMs);
     await runtime.client.close().catch(() => void 0);
     await runtime.adapter.close().catch(() => void 0);
     this.runtimes.delete(status.id);
@@ -6075,7 +6293,7 @@ function parseDapStartCompoundMemberParams(value) {
   return parsed;
 }
 function createCompoundId() {
-  return `compound_${randomBytes5(12).toString("base64url")}`;
+  return `compound_${randomBytes6(12).toString("base64url")}`;
 }
 function findFailedCompoundMemberName(error, members, startedMemberNames) {
   const failed = members.find((member) => !startedMemberNames.includes(member.memberName));
@@ -6536,7 +6754,7 @@ async function delay2(ms) {
 }
 
 // src/cli/commands/dapAliases.ts
-import path17 from "path";
+import path18 from "path";
 
 // src/cli/commands/jsonOptions.ts
 function parseJsonOption(value) {
@@ -6664,7 +6882,7 @@ function registerDapAliasCommands(program, output) {
   breakpoints.command("set").requiredOption("--source <path>", "source path").requiredOption("--line <number...>", "breakpoint line").option("--name <name>", "session name or id").option("--condition <expr>", "breakpoint condition").option("--hit-condition <expr>", "breakpoint hit condition").option("--log-message <text>", "breakpoint log message").description("Set breakpoints at source file line numbers").action(async (options) => {
     const lines = parseIntegerValues(options.line, "line");
     const args = {
-      source: { path: path17.resolve(options.source) },
+      source: { path: path18.resolve(options.source) },
       breakpoints: lines.map((line) => compactObject({
         line,
         condition: options.condition,
@@ -6697,7 +6915,7 @@ function registerDapAliasCommands(program, output) {
   breakpoints.command("list").option("--source <path>", "filter to a single source path").option("--name <name>", "session name or id").description("List breakpoints currently tracked for a session (per source, with verified state)").action(async (options) => {
     const params = compactObject({
       name: options.name,
-      source: options.source === void 0 ? void 0 : path17.resolve(options.source)
+      source: options.source === void 0 ? void 0 : path18.resolve(options.source)
     });
     const client = await createControllerClient({ dapCliHome: process.env.DAP_CLI_HOME });
     try {
@@ -6710,7 +6928,7 @@ function registerDapAliasCommands(program, output) {
   breakpoints.command("clear").option("--source <path>", "clear only the named source (otherwise: clear all tracked sources)").option("--name <name>", "session name or id").description("Clear breakpoints in a source (DAP setBreakpoints empty-list semantics)").action(async (options) => {
     const params = compactObject({
       name: options.name,
-      source: options.source === void 0 ? void 0 : path17.resolve(options.source)
+      source: options.source === void 0 ? void 0 : path18.resolve(options.source)
     });
     const client = await createControllerClient({ dapCliHome: process.env.DAP_CLI_HOME });
     try {
@@ -6738,10 +6956,10 @@ function registerDapAliasCommands(program, output) {
     await sendAliasRequest(output, "variables", { variablesReference: parseRequiredIntegerOption(options.variablesReference, "variables-reference") }, options.name, "variables");
   });
   program.command("source").helpGroup("Paused-state inspection").requiredOption("--source-reference <number>", "source reference").option("--path <path>", "source path").option("--name <name>", "session name or id").description("Return source content").action(async (options) => {
-    const path24 = options.path;
+    const path26 = options.path;
     await sendAliasRequest(output, "source", compactObject({
       sourceReference: parseRequiredIntegerOption(options.sourceReference, "source-reference"),
-      source: path24 === void 0 ? void 0 : { path: path24 }
+      source: path26 === void 0 ? void 0 : { path: path26 }
     }), options.name, "source");
   });
   program.command("evaluate").helpGroup("Paused-state inspection").requiredOption("--expression <expr>", "expression").option("--frame-id <number>", "frame id (auto-resolved to topmost paused frame when omitted)").option("--context <context>", "evaluation context").option("--name <name>", "session name or id").description("Evaluate an expression (auto-uses topmost frame of most-recently-stopped thread when paused)").action(async (options) => {
@@ -6998,9 +7216,9 @@ async function buildVerificationDiagnostic(client, requestedPath, breakpointsRes
   }
   const sources = loaded.sources ?? [];
   const loadedSourcesCount = sources.length;
-  const wantBasename = path17.basename(requestedPath);
+  const wantBasename = path18.basename(requestedPath);
   const cmp = process.platform === "win32" ? (a, b) => a.toLowerCase() === b.toLowerCase() : (a, b) => a === b;
-  const matchingLoadedSources = sources.filter((s) => typeof s.path === "string" && (cmp(s.path, requestedPath) || cmp(path17.basename(s.path), wantBasename))).map((s) => {
+  const matchingLoadedSources = sources.filter((s) => typeof s.path === "string" && (cmp(s.path, requestedPath) || cmp(path18.basename(s.path), wantBasename))).map((s) => {
     const sourcePath = s.path;
     return typeof s.name === "string" ? { path: sourcePath, name: s.name } : { path: sourcePath };
   });
@@ -7042,12 +7260,12 @@ async function countChildSessions(client, parentName) {
 }
 
 // src/cli/commands/dapCore.ts
-import path22 from "path";
+import path24 from "path";
 
 // src/adapters/config.ts
-import { promises as fs13 } from "fs";
+import { promises as fs14 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
-import path18 from "path";
+import path19 from "path";
 import { z as z6 } from "zod";
 var configuredAdapterDescriptorSchema = adapterDescriptorSchema.and(z6.object({
   launchDefaults: z6.record(z6.string(), z6.unknown()).optional(),
@@ -7060,7 +7278,7 @@ var adapterConfigSchema = z6.object({
 async function loadAdapterConfig(dapCliHome) {
   const configPath = getAdapterConfigPath(dapCliHome);
   try {
-    const raw = await fs13.readFile(configPath, "utf8");
+    const raw = await fs14.readFile(configPath, "utf8");
     return parseAdapterConfig(raw);
   } catch (error) {
     if (isNodeError4(error) && error.code === "ENOENT") {
@@ -7074,7 +7292,7 @@ async function loadAdapterConfig(dapCliHome) {
 }
 function getAdapterConfigPath(dapCliHome) {
   const home = dapCliHome === void 0 ? getDapCliHome() : getDapCliHome({ ...process.env, DAP_CLI_HOME: dapCliHome });
-  return path18.join(home, "config", "adapters.json");
+  return path19.join(home, "config", "adapters.json");
 }
 function parseAdapterConfig(raw) {
   return adapterConfigSchema.parse(JSON.parse(raw));
@@ -7090,7 +7308,7 @@ function isNodeError4(error) {
 }
 
 // src/adapters/builtins/debugpy.ts
-import { promises as fs14 } from "fs";
+import { promises as fs15 } from "fs";
 import { execFile as execFile3 } from "child_process";
 import { promisify as promisify2 } from "util";
 var execFileAsync2 = promisify2(execFile3);
@@ -7108,7 +7326,7 @@ async function createDebugpyDescriptor(pythonPath) {
 }
 async function pathExists2(p) {
   try {
-    await fs14.access(p);
+    await fs15.access(p);
     return true;
   } catch {
     return false;
@@ -7140,9 +7358,9 @@ async function resolveDefaultDebugpyPythonPath(env = process.env) {
 }
 
 // src/adapters/builtins/delve.ts
-import { promises as fs15 } from "fs";
+import { promises as fs16 } from "fs";
 import { spawnSync } from "child_process";
-import path19 from "path";
+import path20 from "path";
 async function createDelveDescriptor(delvePath) {
   const resolvedDelvePath = delvePath ?? await resolveDefaultDelvePath();
   assertSupportedProvisionedDelveToolchain(resolvedDelvePath);
@@ -7165,7 +7383,7 @@ function createGoToolchainEnvironment() {
 }
 async function pathExists3(p) {
   try {
-    await fs15.access(p);
+    await fs16.access(p);
     return true;
   } catch {
     return false;
@@ -7188,7 +7406,7 @@ async function resolveDefaultDelvePath(env = process.env) {
   return result.entrypoint;
 }
 function getProvisionedDelvePath(env = process.env) {
-  return path19.join(getDapCliAdaptersDir(env), "delve", process.platform === "win32" ? "dlv.exe" : "dlv");
+  return path20.join(getDapCliAdaptersDir(env), "delve", process.platform === "win32" ? "dlv.exe" : "dlv");
 }
 function delveIsUsable(command) {
   const result = spawnSync(command, ["version"], { encoding: "utf8" });
@@ -7235,6 +7453,31 @@ function compareNumericVersions(left, right) {
   return 0;
 }
 
+// src/adapters/builtins/codelldb.ts
+import path21 from "path";
+async function createCodeLldbDescriptor(codelldbPath) {
+  const entrypoint = codelldbPath ?? await resolveDefaultCodeLldbPath();
+  const libLldbPath = path21.join(path21.dirname(entrypoint), "..", "lldb", "lib", "liblldb.dylib");
+  return {
+    id: "codelldb",
+    label: "Rust Debug Adapter (CodeLLDB)",
+    transport: {
+      kind: "server",
+      command: entrypoint,
+      args: ["--liblldb", libLldbPath, "--port", "${port}"],
+      host: "127.0.0.1"
+    }
+  };
+}
+async function resolveDefaultCodeLldbPath(env = process.env) {
+  const result = await provisionAdapter("codelldb", {
+    env,
+    assumeYes: resolveAssumeYes(void 0, env),
+    adaptersDir: getDapCliAdaptersDir(env)
+  });
+  return result.entrypoint;
+}
+
 // src/adapters/registry.ts
 var AdapterRegistry = class {
   builtInAdapters = /* @__PURE__ */ new Map();
@@ -7256,6 +7499,11 @@ var AdapterRegistry = class {
         label: "Go Debug Adapter (Delve)",
         create: () => createDelveDescriptor()
       });
+      this.builtInAdapters.set("codelldb", {
+        id: "codelldb",
+        label: "Rust Debug Adapter (CodeLLDB)",
+        create: () => createCodeLldbDescriptor()
+      });
     }
     for (const descriptor of options.builtInAdapters ?? []) {
       this.builtInAdapters.set(descriptor.id, {
@@ -7297,9 +7545,9 @@ var AdapterRegistry = class {
 };
 
 // src/config/launchConfig.ts
-import { promises as fs16 } from "fs";
+import { promises as fs17 } from "fs";
 import os from "os";
-import path20 from "path";
+import path22 from "path";
 import { parse } from "jsonc-parser";
 import { z as z7 } from "zod";
 var launchConfigTypeMap = {
@@ -7309,7 +7557,8 @@ var launchConfigTypeMap = {
   "pwa-chrome": "js-debug",
   python: "debugpy",
   debugpy: "debugpy",
-  go: "delve"
+  go: "delve",
+  lldb: "codelldb"
 };
 var maxLaunchJsonBytes = 256 * 1024;
 var platformKeys = /* @__PURE__ */ new Set(["osx", "mac", "linux", "windows"]);
@@ -7336,12 +7585,12 @@ function resolveLaunchConfig(sources) {
   };
 }
 function resolveLaunchConfigurationConfig(config, options) {
-  const workspaceFolder = path20.resolve(options.workspaceFolder);
+  const workspaceFolder = path22.resolve(options.workspaceFolder);
   const platform = options.platform ?? process.platform;
   const merged = applyPlatformOverlay(config, platform);
   const context = {
     workspaceFolder,
-    workspaceFolderBasename: path20.basename(workspaceFolder),
+    workspaceFolderBasename: path22.basename(workspaceFolder),
     userHome: options.userHome ?? os.homedir(),
     execPath: options.execPath ?? process.execPath,
     env: options.env ?? process.env
@@ -7359,17 +7608,17 @@ function resolveLaunchConfigurationConfig(config, options) {
   return normalizeGoLaunchConfigProgram(resolved, workspaceFolder);
 }
 async function loadVSCodeLaunchJson(cwd) {
-  const workspaceFolder = path20.resolve(cwd);
-  const launchJsonPath = path20.join(cwd, ".vscode", "launch.json");
+  const workspaceFolder = path22.resolve(cwd);
+  const launchJsonPath = path22.join(cwd, ".vscode", "launch.json");
   try {
-    const stat = await fs16.stat(launchJsonPath);
+    const stat = await fs17.stat(launchJsonPath);
     if (stat.size > maxLaunchJsonBytes) {
       throw usageError("Invalid launch.json.", {
         code: "invalid_launch_json",
         diagnostics: [".vscode/launch.json is larger than 256KB."]
       });
     }
-    const raw = await fs16.readFile(launchJsonPath, "utf8");
+    const raw = await fs17.readFile(launchJsonPath, "utf8");
     const normalized = raw.charCodeAt(0) === 65279 ? raw.slice(1) : raw;
     const parsed = launchJsonSchema.parse(parseJsonc(normalized));
     return {
@@ -7474,7 +7723,7 @@ async function applyJsDebugSourceMapDefaults(config, options) {
   if (!isJsDebugLaunchType(config.type)) {
     return config;
   }
-  const hasTsConfig = await pathExists4(path20.join(options.workspaceFolder, "tsconfig.json"));
+  const hasTsConfig = await pathExists4(path22.join(options.workspaceFolder, "tsconfig.json"));
   if (!hasTsConfig) {
     return config;
   }
@@ -7484,9 +7733,9 @@ async function applyJsDebugSourceMapDefaults(config, options) {
   }
   if (mapped.outFiles === void 0) {
     mapped.outFiles = [
-      path20.join(options.workspaceFolder, "dist", "**", "*.js"),
-      path20.join(options.workspaceFolder, "out", "**", "*.js"),
-      path20.join(options.workspaceFolder, "build", "**", "*.js")
+      path22.join(options.workspaceFolder, "dist", "**", "*.js"),
+      path22.join(options.workspaceFolder, "out", "**", "*.js"),
+      path22.join(options.workspaceFolder, "build", "**", "*.js")
     ];
   }
   return mapped;
@@ -7499,14 +7748,27 @@ function mapDebugpyFlags(flags) {
   }
   return mapped;
 }
+function validateCodeLldbNativeConfig(config) {
+  if (Object.prototype.hasOwnProperty.call(config, "cargo")) {
+    throw usageError("CodeLLDB Cargo launch configurations are not supported by dap-cli.", {
+      code: "codelldb_cargo_config_unsupported",
+      diagnostics: [
+        "The `cargo` property is resolved by the VS Code CodeLLDB extension and cannot be forwarded to the standalone adapter.",
+        "Build an explicitly built Rust binary and pass its executable path with `program`."
+      ],
+      data: { adapterId: "codelldb", unsupportedField: "cargo", requiredField: "program" }
+    });
+  }
+  return config;
+}
 function normalizeGoLaunchConfigProgram(config, workspaceFolder) {
-  if (config.type !== "go" || config.request === "attach" || typeof config.program !== "string" || path20.isAbsolute(config.program)) {
+  if (config.type !== "go" || config.request === "attach" || typeof config.program !== "string" || path22.isAbsolute(config.program)) {
     return config;
   }
   const cwd = typeof config.cwd === "string" ? config.cwd : workspaceFolder;
   return {
     ...config,
-    program: path20.resolve(cwd, config.program)
+    program: path22.resolve(cwd, config.program)
   };
 }
 function applyPlatformOverlay(config, platform) {
@@ -7593,7 +7855,7 @@ function resolveLaunchString(value, jsonPath, context) {
 }
 async function pathExists4(filePath) {
   try {
-    await fs16.stat(filePath);
+    await fs17.stat(filePath);
     return true;
   } catch (error) {
     if (isNodeError5(error) && error.code === "ENOENT") {
@@ -7635,7 +7897,7 @@ function isNodeError5(error) {
 }
 
 // src/config/programInference.ts
-import path21 from "path";
+import path23 from "path";
 var extensionTable = {
   ".py": { adapterId: "debugpy", type: "python" },
   ".go": { adapterId: "delve", type: "go" },
@@ -7666,7 +7928,7 @@ function inferAdapterAndType(args) {
     return { adapterId, type, inferred: { adapter: true, type: false } };
   }
   if (program !== void 0) {
-    const extension = path21.extname(program).toLowerCase();
+    const extension = path23.extname(program).toLowerCase();
     const match = extensionTable[extension];
     if (match === void 0) {
       throw usageError(`Cannot infer adapter from program extension '${extension}'. Pass --adapter or --type explicitly.`, {
@@ -7682,7 +7944,7 @@ function inferAdapterAndType(args) {
 function defaultTypeForAdapter(adapterId, program) {
   if (adapterId === "js-debug") {
     if (program !== void 0) {
-      const ext = path21.extname(program).toLowerCase();
+      const ext = path23.extname(program).toLowerCase();
       if (ext === ".html" || ext === ".htm") {
         return "pwa-chrome";
       }
@@ -7695,6 +7957,9 @@ function defaultTypeForAdapter(adapterId, program) {
   if (adapterId === "delve") {
     return "go";
   }
+  if (adapterId === "codelldb") {
+    return "lldb";
+  }
   return void 0;
 }
 
@@ -7736,7 +8001,7 @@ function createNameParams(name) {
   return name === void 0 ? {} : { name };
 }
 async function startDap(output, mode, options) {
-  const workspace = path22.resolve(options.workspace ?? process.cwd());
+  const workspace = path24.resolve(options.workspace ?? process.cwd());
   if (options.listConfigs === true) {
     output.success(listLaunchConfigEntries(await loadVSCodeLaunchJson(workspace)), { command: "launch configs" });
     return;
@@ -7892,6 +8157,9 @@ async function mapConfigForAdapter(adapterId, config, workspaceFolder) {
   if (adapterId === "delve") {
     return normalizeGoLaunchConfigProgram(config, workspaceFolder);
   }
+  if (adapterId === "codelldb") {
+    return validateCodeLldbNativeConfig(config);
+  }
   return config;
 }
 function setIfDefined(target, key, value) {
@@ -7915,7 +8183,7 @@ function createFakeDescriptor(script, mode) {
     transport: {
       kind: "stdio",
       command: process.execPath,
-      args: ["--experimental-strip-types", path22.join(process.cwd(), "tests", "fixtures", "fake-adapter-entry.ts"), "--script", script, "--mode", mode]
+      args: ["--experimental-strip-types", path24.join(process.cwd(), "tests", "fixtures", "fake-adapter-entry.ts"), "--script", script, "--mode", mode]
     }
   };
 }
@@ -8032,48 +8300,54 @@ function createNameParams2(name) {
 }
 
 // src/cli/commands/setupAdapters.ts
-import path23 from "path";
-import { promises as fs17 } from "fs";
+import path25 from "path";
+import { promises as fs18 } from "fs";
 import { Option } from "commander";
-var ALL_ADAPTERS = ["js-debug", "debugpy", "delve"];
+var ALL_ADAPTERS = ["js-debug", "debugpy", "delve", "codelldb"];
 var ADAPTER_VERSIONS = {
   "js-debug": JS_DEBUG_VERSION,
   "debugpy": DEBUGPY_VERSION,
-  "delve": DELVE_VERSION
+  "delve": DELVE_VERSION,
+  "codelldb": CODELLDB_VERSION
 };
 function expectedEntrypoint(adaptersDir, id) {
   switch (id) {
     case "js-debug":
-      return path23.join(adaptersDir, "js-debug", "src", "dapDebugServer.js");
+      return path25.join(adaptersDir, "js-debug", "src", "dapDebugServer.js");
     case "debugpy":
-      return path23.join(
+      return path25.join(
         adaptersDir,
         "debugpy",
-        process.platform === "win32" ? path23.join("venv", "Scripts", "python.exe") : path23.join("venv", "bin", "python")
+        process.platform === "win32" ? path25.join("venv", "Scripts", "python.exe") : path25.join("venv", "bin", "python")
       );
     case "delve":
-      return path23.join(adaptersDir, "delve", process.platform === "win32" ? "dlv.exe" : "dlv");
+      return path25.join(adaptersDir, "delve", process.platform === "win32" ? "dlv.exe" : "dlv");
+    case "codelldb":
+      return path25.join(adaptersDir, "codelldb", "extension", "adapter", "codelldb");
   }
 }
 async function pathExists5(p) {
   try {
-    await fs17.access(p);
+    await fs18.access(p);
     return true;
   } catch {
     return false;
   }
 }
 function isAdapterId(value) {
-  return value === "js-debug" || value === "debugpy" || value === "delve";
+  return value === "js-debug" || value === "debugpy" || value === "delve" || value === "codelldb";
+}
+async function isRuntimeReady(adaptersDir, id) {
+  return id === "codelldb" ? isCodeLldbRuntimeReady(path25.join(adaptersDir, id)) : pathExists5(expectedEntrypoint(adaptersDir, id));
 }
 async function runSetupAdaptersAction(opts) {
   const targets = opts.adapter !== void 0 ? [opts.adapter] : ALL_ADAPTERS;
   const adaptersDir = getDapCliAdaptersDir(opts.env);
-  await fs17.mkdir(adaptersDir, { recursive: true });
+  await fs18.mkdir(adaptersDir, { recursive: true });
   const pending = [];
   for (const id of targets) {
     const version = ADAPTER_VERSIONS[id];
-    const cached = await hasConsentMarker(adaptersDir, id, version) && await pathExists5(expectedEntrypoint(adaptersDir, id));
+    const cached = await hasConsentMarker(adaptersDir, id, version) && await isRuntimeReady(adaptersDir, id);
     if (!cached) {
       pending.push(id);
     }
@@ -8131,8 +8405,8 @@ async function runSetupAdaptersAction(opts) {
   return { adapters: entries };
 }
 function registerSetupAdaptersCommand(program, output) {
-  program.command("setup-adapters").helpGroup("Adapters").description("Install or update built-in debug adapters (js-debug, debugpy, delve) into ~/.dap-cli/adapters/").addOption(
-    new Option("--adapter <id>", "install only the named adapter").choices(["js-debug", "debugpy", "delve"])
+  program.command("setup-adapters").helpGroup("Adapters").description("Install or update built-in debug adapters (js-debug, debugpy, delve, codelldb) into ~/.dap-cli/adapters/").addOption(
+    new Option("--adapter <id>", "install only the named adapter").choices(["js-debug", "debugpy", "delve", "codelldb"])
   ).action(async (cmdOpts) => {
     const adapterId = cmdOpts.adapter !== void 0 && isAdapterId(cmdOpts.adapter) ? cmdOpts.adapter : void 0;
     const assumeYes = resolveAssumeYes(void 0, process.env);