@roblourens/dap-cli 0.1.0 → 0.3.0

package/dist/index.js

@@ -11,7 +11,7 @@ var CliError = class extends Error {
   adapter;
   data;
   constructor(message, category, exitCode, options = {}) {
-    super(message);
+    super(message, options.cause !== void 0 ? { cause: options.cause } : void 0);
     this.name = "CliError";
     this.code = options.code ?? `${category}_error`;
     this.category = category;
@@ -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";
 
@@ -869,6 +871,10 @@ function getDapCliLogDir(env = process.env) {
   return path.join(getDapCliHome(env), "logs");
 }
 function getDapCliAdaptersDir(env = process.env) {
+  const configured = env.DAP_CLI_ADAPTERS_DIR;
+  if (configured !== void 0 && configured.trim().length > 0) {
+    return path.resolve(configured);
+  }
   return path.join(getDapCliHome(env), "adapters");
 }
 function getDapCliVenvPythonPath(env = process.env) {
@@ -897,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");
 }
@@ -978,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));
@@ -1153,8 +1165,8 @@ function isSessionErrorCode(code) {
 }
 
 // src/controller/server.ts
-import path8 from "path";
-import { randomBytes as randomBytes2 } from "crypto";
+import path17 from "path";
+import { randomBytes as randomBytes6 } from "crypto";
 
 // src/adapters/descriptor.ts
 import { z as z3 } from "zod";
@@ -1306,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();
+        }
+      });
     }
   };
 }
@@ -1342,7 +1361,7 @@ async function connectSocketAdapter(adapterId, descriptor) {
 }
 async function startServerSocketAdapter(adapterId, descriptor, logDir) {
   const port = await getFreePort(descriptor.host);
-  const args = descriptor.args.map((arg) => arg === "${port}" ? String(port) : arg);
+  const args = descriptor.args.map((arg) => arg.replaceAll("${port}", String(port)));
   const child = spawn2(descriptor.command, args, {
     cwd: descriptor.cwd,
     env: descriptor.env === void 0 ? process.env : { ...process.env, ...descriptor.env },
@@ -1383,88 +1402,1243 @@ async function startServerSocketAdapter(adapterId, descriptor, logDir) {
           logStream.end(() => resolve());
         });
       }
-    };
-  } catch (error) {
-    await terminateChild2(child);
-    await new Promise((resolve) => {
-      logStream.end(() => resolve());
+    };
+  } catch (error) {
+    await terminateChild2(child);
+    await new Promise((resolve) => {
+      logStream.end(() => resolve());
+    });
+    throw error;
+  }
+}
+async function connectWithRetry(adapterId, host, port) {
+  const deadline = Date.now() + 5e3;
+  let lastError;
+  while (Date.now() < deadline) {
+    try {
+      return await connectSocketTransport({ name: adapterId, host, port, timeoutMs: 500 });
+    } catch (error) {
+      lastError = error;
+      await delay(50);
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error("Timed out connecting DAP server adapter.");
+}
+function getFreePort(host) {
+  return new Promise((resolve, reject) => {
+    const server = net3.createServer();
+    server.once("error", reject);
+    server.listen(0, host, () => {
+      const address = server.address();
+      server.close(() => {
+        if (typeof address === "object" && address !== null) {
+          resolve(address.port);
+          return;
+        }
+        reject(new Error("Failed to allocate a local adapter server port."));
+      });
+    });
+  });
+}
+async function terminateChild2(child) {
+  if (child.exitCode !== null || child.signalCode !== null) {
+    return;
+  }
+  child.kill("SIGTERM");
+  if (await waitForExit2(child, 100)) {
+    return;
+  }
+  child.kill("SIGKILL");
+  await waitForExit2(child, 100);
+}
+function waitForExit2(child, timeoutMs) {
+  if (child.exitCode !== null || child.signalCode !== null) {
+    return Promise.resolve(true);
+  }
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      child.off("exit", onExit);
+      resolve(false);
+    }, timeoutMs);
+    const onExit = () => {
+      clearTimeout(timer);
+      resolve(true);
+    };
+    child.once("exit", onExit);
+  });
+}
+function appendStderrTail2(stderrTail, text) {
+  for (const line of text.split(/\r?\n/).filter((value) => value.length > 0)) {
+    stderrTail.push(line);
+    while (stderrTail.length > 100) {
+      stderrTail.shift();
+    }
+  }
+}
+async function delay(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/adapters/builtins/jsDebug.ts
+import { promises as fs11 } from "fs";
+import path14 from "path";
+
+// src/cli/confirm.ts
+import * as readline from "readline/promises";
+async function confirm(options) {
+  if (options.assumeYes) {
+    return true;
+  }
+  const stdin = options.stdin ?? process.stdin;
+  const stderr = options.stderr ?? process.stderr;
+  if (stdin.isTTY !== true) {
+    throw usageError("Confirmation required but stdin is not a TTY.", {
+      code: "provision_consent_required",
+      diagnostics: [
+        options.question,
+        "Re-run with `--yes` / `-y` or set `DAP_CLI_ASSUME_YES=1` to pre-consent."
+      ],
+      data: { question: options.question }
+    });
+  }
+  stderr.write(`
+${options.question}
+`);
+  for (const line of options.details ?? []) {
+    stderr.write(`  ${line}
+`);
+  }
+  stderr.write("Proceed? [y/N] ");
+  const rl = readline.createInterface({ input: stdin, output: stderr, terminal: false });
+  try {
+    const answer = (await rl.question("")).trim().toLowerCase();
+    if (answer === "y" || answer === "yes") {
+      return true;
+    }
+    throw usageError("User declined provisioning consent.", {
+      code: "provision_consent_declined",
+      diagnostics: ["Re-run with `--yes` to pre-consent."],
+      data: { question: options.question }
+    });
+  } finally {
+    rl.close();
+  }
+}
+function resolveAssumeYes(cliYes, env) {
+  if (cliYes === true) {
+    return true;
+  }
+  const value = env.DAP_CLI_ASSUME_YES;
+  return value === "1" || value === "true";
+}
+
+// src/adapters/provision/jsDebug.ts
+import path9 from "path";
+import { createHash as createHash2, randomBytes as randomBytes2 } from "crypto";
+import { promises as fs6, createReadStream as createReadStream2 } from "fs";
+
+// src/adapters/provision/atomicInstall.ts
+import path5 from "path";
+import { promises as fs2 } from "fs";
+import { randomBytes } from "crypto";
+var CACHE_UNWRITABLE_CODES = /* @__PURE__ */ new Set(["EACCES", "EROFS", "ENOSPC", "EPERM"]);
+function isCacheUnwritableError(error) {
+  if (!(error instanceof Error) || !("code" in error)) {
+    return false;
+  }
+  const code = error.code;
+  return typeof code === "string" && CACHE_UNWRITABLE_CODES.has(code);
+}
+function cacheUnwritableError(adaptersDir, errnoCode, adapterId) {
+  return usageError("Adapter cache directory is not writable.", {
+    code: "provision_cache_unwritable",
+    diagnostics: [
+      `Adapter cache: ${adaptersDir}`,
+      `Filesystem error: ${errnoCode}`,
+      "Override with `DAP_CLI_ADAPTERS_DIR=<writable-path>`."
+    ],
+    data: { adaptersDir, errnoCode, adapterId }
+  });
+}
+function stagingName(adapterId) {
+  return `.${adapterId}.tmp.${process.pid}.${randomBytes(4).toString("hex")}`;
+}
+async function verifyEntrypoints(stagingDir, entrypoints) {
+  for (const rel of entrypoints) {
+    const target = path5.join(stagingDir, rel);
+    try {
+      await fs2.stat(target);
+    } catch (cause) {
+      throw usageError("Adapter install completed but the expected entry point is missing.", {
+        code: "provision_extract_failed",
+        diagnostics: [`Missing entry point: ${rel}`, `Staging directory: ${stagingDir}`],
+        data: { entrypoint: rel, stagingDir },
+        cause
+      });
+    }
+  }
+}
+async function atomicInstall(options) {
+  const { adaptersDir, adapterId, populate, expectedEntrypoints } = options;
+  try {
+    await fs2.mkdir(adaptersDir, { recursive: true });
+  } catch (error) {
+    if (isCacheUnwritableError(error)) {
+      throw cacheUnwritableError(adaptersDir, error.code ?? "unknown", adapterId);
+    }
+    throw error;
+  }
+  const canonical = path5.join(adaptersDir, adapterId);
+  const staging = path5.join(adaptersDir, stagingName(adapterId));
+  try {
+    await fs2.mkdir(staging, { recursive: true });
+  } catch (error) {
+    if (isCacheUnwritableError(error)) {
+      throw cacheUnwritableError(adaptersDir, error.code ?? "unknown", adapterId);
+    }
+    throw error;
+  }
+  try {
+    await populate(staging);
+    await verifyEntrypoints(staging, expectedEntrypoints);
+    await fs2.rm(canonical, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+    await fs2.rename(staging, canonical);
+    return canonical;
+  } catch (error) {
+    await fs2.rm(staging, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 }).catch(() => void 0);
+    if (!(error instanceof CliError) && isCacheUnwritableError(error)) {
+      throw cacheUnwritableError(adaptersDir, error.code ?? "unknown", adapterId);
+    }
+    throw error;
+  }
+}
+
+// src/adapters/provision/http.ts
+import { createWriteStream as createWriteStream3 } from "fs";
+import { promises as fs3 } from "fs";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+import path6 from "path";
+import { fetch, ProxyAgent } from "undici";
+var LOCAL_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "::1"]);
+function pickProxyEnv(env, protocol) {
+  if (protocol === "https:") {
+    return env.HTTPS_PROXY ?? env.https_proxy;
+  }
+  return env.HTTP_PROXY ?? env.http_proxy;
+}
+function matchesNoProxy(host, noProxy) {
+  if (noProxy === void 0 || noProxy.length === 0) {
+    return false;
+  }
+  const normalized = host.toLowerCase();
+  for (const raw of noProxy.split(",")) {
+    const pattern = raw.trim().toLowerCase();
+    if (pattern.length === 0) {
+      continue;
+    }
+    if (pattern === "*") {
+      return true;
+    }
+    const stripped = pattern.startsWith(".") ? pattern.slice(1) : pattern;
+    if (normalized === stripped || normalized.endsWith(`.${stripped}`)) {
+      return true;
+    }
+  }
+  return false;
+}
+function resolveProxy(targetUrl, env) {
+  const proxyUrl = pickProxyEnv(env, targetUrl.protocol);
+  if (proxyUrl === void 0 || proxyUrl.length === 0) {
+    return { dispatcher: void 0, proxyUrl: void 0 };
+  }
+  if (matchesNoProxy(targetUrl.hostname, env.NO_PROXY ?? env.no_proxy)) {
+    return { dispatcher: void 0, proxyUrl: void 0 };
+  }
+  return { dispatcher: new ProxyAgent(proxyUrl), proxyUrl };
+}
+function isLocalHost(host) {
+  return LOCAL_HOSTS.has(host.toLowerCase());
+}
+function sanitizeUrl(raw) {
+  try {
+    const parsed = new URL(raw);
+    parsed.username = "";
+    parsed.password = "";
+    parsed.search = "";
+    parsed.hash = "";
+    return parsed.toString();
+  } catch {
+    return raw.split("?")[0]?.split("#")[0] ?? raw;
+  }
+}
+function rateLimitError(url, retryAfter) {
+  const safeUrl = sanitizeUrl(url);
+  return usageError("GitHub rate limit exceeded.", {
+    code: "provision_rate_limited",
+    diagnostics: [
+      `URL: ${safeUrl}`,
+      retryAfter !== null && retryAfter.length > 0 ? `Retry after epoch ${retryAfter}.` : "Retry-After header not provided.",
+      "Set `GITHUB_TOKEN` to raise the GitHub API rate limit."
+    ],
+    data: { url: safeUrl, status: 403, retryAfter: retryAfter ?? void 0 }
+  });
+}
+function networkError(url, status, statusText) {
+  const safeUrl = sanitizeUrl(url);
+  return usageError("Adapter download failed.", {
+    code: "provision_network_error",
+    diagnostics: [`URL: ${safeUrl}`, `HTTP ${status} ${statusText}`],
+    data: { url: safeUrl, status, statusText }
+  });
+}
+function networkCauseError(url, code, message, cause) {
+  const safeUrl = sanitizeUrl(url);
+  return usageError("Adapter download failed.", {
+    code: "provision_network_error",
+    diagnostics: [`URL: ${safeUrl}`, code !== void 0 ? `Cause: ${code}` : `Cause: ${message}`],
+    data: { url: safeUrl, causeCode: code },
+    cause
+  });
+}
+function proxyError(url, proxyUrl, code, message, cause) {
+  const safeUrl = sanitizeUrl(url);
+  const safeProxy = sanitizeUrl(proxyUrl);
+  return usageError("Adapter download failed through configured proxy.", {
+    code: "provision_proxy_error",
+    diagnostics: [
+      `URL: ${safeUrl}`,
+      `Proxy: ${safeProxy}`,
+      code !== void 0 ? `Cause: ${code}` : `Cause: ${message}`,
+      "Verify `HTTPS_PROXY` is correct or set `NO_PROXY=github.com` to bypass."
+    ],
+    data: { url: safeUrl, proxyUrl: safeProxy, causeCode: code },
+    cause
+  });
+}
+function extractCause(error) {
+  if (error instanceof Error && "cause" in error) {
+    const cause = error.cause;
+    if (cause !== void 0 && cause !== null && typeof cause === "object") {
+      const codeValue = cause.code;
+      const messageValue = cause.message;
+      const result = {};
+      if (typeof codeValue === "string") {
+        result.code = codeValue;
+      }
+      if (typeof messageValue === "string") {
+        result.message = messageValue;
+      }
+      return result;
+    }
+  }
+  return void 0;
+}
+async function downloadToFile(options) {
+  const env = options.env ?? process.env;
+  let target;
+  try {
+    target = new URL(options.url);
+  } catch {
+    throw usageError("Invalid download URL.", {
+      code: "provision_network_error",
+      diagnostics: [`URL: ${sanitizeUrl(options.url)}`, "URL could not be parsed."],
+      data: { url: sanitizeUrl(options.url) }
+    });
+  }
+  if (target.protocol !== "https:" && !(target.protocol === "http:" && isLocalHost(target.hostname))) {
+    throw usageError("Refusing non-HTTPS download URL.", {
+      code: "provision_network_error",
+      diagnostics: [`URL: ${sanitizeUrl(options.url)}`, "Downloads must use https:// (http://localhost is allowed for tests)."],
+      data: { url: sanitizeUrl(options.url) }
+    });
+  }
+  const { dispatcher, proxyUrl } = resolveProxy(target, env);
+  await fs3.mkdir(path6.dirname(options.destPath), { recursive: true });
+  let response;
+  try {
+    response = await fetch(options.url, dispatcher !== void 0 ? { dispatcher } : void 0);
+  } catch (error) {
+    const cause = extractCause(error);
+    const message = error instanceof Error ? error.message : String(error);
+    if (proxyUrl !== void 0) {
+      throw proxyError(options.url, proxyUrl, cause?.code, cause?.message ?? message, error);
+    }
+    throw networkCauseError(options.url, cause?.code, cause?.message ?? message, error);
+  }
+  if (!response.ok) {
+    if (response.status === 403 && response.headers.get("x-ratelimit-remaining") === "0") {
+      throw rateLimitError(options.url, response.headers.get("x-ratelimit-reset"));
+    }
+    throw networkError(options.url, response.status, response.statusText);
+  }
+  if (response.body === null) {
+    throw usageError("Adapter download returned an empty body.", {
+      code: "provision_network_error",
+      diagnostics: [`URL: ${sanitizeUrl(options.url)}`],
+      data: { url: sanitizeUrl(options.url) }
+    });
+  }
+  const contentLengthHeader = response.headers.get("content-length");
+  const totalBytes = contentLengthHeader !== null ? Number.parseInt(contentLengthHeader, 10) : void 0;
+  const total = Number.isFinite(totalBytes) ? totalBytes : void 0;
+  let bytesRead = 0;
+  const onProgress = options.onProgress;
+  const body = Readable.fromWeb(response.body);
+  if (onProgress !== void 0) {
+    body.on("data", (chunk) => {
+      bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
+      onProgress(bytesRead, total);
+    });
+  }
+  try {
+    await pipeline(body, createWriteStream3(options.destPath));
+  } catch (error) {
+    await fs3.rm(options.destPath, { force: true }).catch(() => void 0);
+    const message = error instanceof Error ? error.message : String(error);
+    throw usageError("Adapter download stream failed.", {
+      code: "provision_network_error",
+      diagnostics: [`URL: ${sanitizeUrl(options.url)}`, message],
+      data: { url: sanitizeUrl(options.url) },
+      cause: error
+    });
+  }
+}
+
+// src/adapters/provision/extractTarGz.ts
+import { createReadStream } from "fs";
+import * as tar from "tar";
+async function extractTarGz(archivePath, destDir, options = {}) {
+  await new Promise((resolve, reject) => {
+    const source = createReadStream(archivePath);
+    const extract = tar.x({
+      cwd: destDir,
+      strict: true,
+      strip: options.strip ?? 0
+    });
+    source.on("error", reject);
+    extract.on("error", reject);
+    extract.on("finish", resolve);
+    source.pipe(extract);
+  }).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    throw usageError("Archive extraction failed.", {
+      code: "provision_extract_failed",
+      diagnostics: [archivePath, message],
+      data: { archivePath },
+      cause: error
+    });
+  });
+}
+
+// src/adapters/provision/lock.ts
+import path7 from "path";
+import { promises as fs4 } from "fs";
+import * as lockfile from "proper-lockfile";
+var PRODUCTION_RETRY = {
+  retries: 60,
+  minTimeout: 500,
+  maxTimeout: 2e3,
+  factor: 1
+};
+var STALE_MS = 5 * 60 * 1e3;
+var CACHE_UNWRITABLE_CODES2 = /* @__PURE__ */ new Set(["EACCES", "EROFS", "ENOSPC", "EPERM"]);
+function getErrnoCode(error) {
+  if (error instanceof Error && "code" in error) {
+    const code = error.code;
+    if (typeof code === "string") {
+      return code;
+    }
+  }
+  return void 0;
+}
+function cacheUnwritableError2(adaptersDir, errnoCode, adapterId) {
+  return usageError("Adapter cache directory is not writable.", {
+    code: "provision_cache_unwritable",
+    diagnostics: [
+      `Adapter cache: ${adaptersDir}`,
+      `Filesystem error: ${errnoCode}`,
+      "Override with `DAP_CLI_ADAPTERS_DIR=<writable-path>`."
+    ],
+    data: { adaptersDir, errnoCode, adapterId }
+  });
+}
+function resolveRetry(options) {
+  if (options?.retryOverride !== void 0) {
+    return options.retryOverride;
+  }
+  const env = process.env.DAP_CLI_LOCK_RETRY_OVERRIDE;
+  if (env !== void 0 && env.length > 0) {
+    try {
+      const parsed = JSON.parse(env);
+      if (parsed !== null && typeof parsed === "object") {
+        const candidate = parsed;
+        const retries = candidate.retries;
+        const minTimeout = candidate.minTimeout;
+        const maxTimeout = candidate.maxTimeout;
+        const factor = candidate.factor;
+        if (typeof retries === "number" && typeof minTimeout === "number" && typeof maxTimeout === "number" && typeof factor === "number") {
+          return { retries, minTimeout, maxTimeout, factor };
+        }
+      }
+    } catch {
+    }
+  }
+  return PRODUCTION_RETRY;
+}
+function lockTimeoutError(adapterId, sentinel) {
+  return usageError("Timed out waiting for adapter install lock.", {
+    code: "provision_lock_timeout",
+    diagnostics: [
+      `Adapter: ${adapterId}`,
+      `Lock sentinel: ${sentinel}`,
+      `Another dap-cli process may be installing; if none, delete ${sentinel} and retry.`
+    ],
+    data: { adapterId, sentinel }
+  });
+}
+async function withAdapterLock(adaptersDir, adapterId, fn, options) {
+  try {
+    await fs4.mkdir(adaptersDir, { recursive: true });
+  } catch (error) {
+    const errnoCode = getErrnoCode(error);
+    if (errnoCode !== void 0 && CACHE_UNWRITABLE_CODES2.has(errnoCode)) {
+      throw cacheUnwritableError2(adaptersDir, errnoCode, adapterId);
+    }
+    throw error;
+  }
+  const sentinel = path7.join(adaptersDir, `.${adapterId}.lock-target`);
+  try {
+    await fs4.writeFile(sentinel, "", { flag: "a" });
+  } catch (error) {
+    const errnoCode = getErrnoCode(error);
+    if (errnoCode !== void 0 && CACHE_UNWRITABLE_CODES2.has(errnoCode)) {
+      throw cacheUnwritableError2(adaptersDir, errnoCode, adapterId);
+    }
+    throw error;
+  }
+  const retry = resolveRetry(options);
+  let release;
+  try {
+    release = await lockfile.lock(sentinel, {
+      stale: STALE_MS,
+      realpath: false,
+      retries: { ...retry }
+    });
+  } catch (error) {
+    const errnoCode = getErrnoCode(error);
+    if (errnoCode === "ELOCKED" || errnoCode === "EEXIST") {
+      throw lockTimeoutError(adapterId, sentinel);
+    }
+    if (errnoCode !== void 0 && CACHE_UNWRITABLE_CODES2.has(errnoCode)) {
+      throw cacheUnwritableError2(adaptersDir, errnoCode, adapterId);
+    }
+    throw error;
+  }
+  try {
+    return await fn();
+  } finally {
+    if (release !== void 0) {
+      await release().catch(() => void 0);
+    }
+  }
+}
+
+// src/adapters/provision/consent.ts
+import path8 from "path";
+import { promises as fs5 } from "fs";
+function markerPath(adaptersDir, adapterId, version) {
+  return path8.join(adaptersDir, adapterId, `.consent-${version}`);
+}
+async function hasConsentMarker(adaptersDir, adapterId, version) {
+  try {
+    await fs5.stat(markerPath(adaptersDir, adapterId, version));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writeConsentMarker(adaptersDir, adapterId, version) {
+  const filePath = markerPath(adaptersDir, adapterId, version);
+  await fs5.mkdir(path8.dirname(filePath), { recursive: true });
+  await fs5.writeFile(filePath, `${(/* @__PURE__ */ new Date()).toISOString()}
+`, { flag: "w" });
+}
+
+// src/adapters/provision/checksums.ts
+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"
+};
+var DELVE_CHECKSUMS = {
+  "v1.26.3": {
+    darwin_arm64: "7f28483a42f0a911f29b236aa40d24d7099f1b0ec54c56c4d439a6903d478a3d",
+    darwin_amd64: "6827a438473167a1e0805b4546e5bf2d53401530f694deb35e41c6e7b46e27c8",
+    linux_amd64: "cdd4d6b2a638d8f26468d82a76b766df594641490bea566629305d90fbccc06e",
+    linux_arm64: "5b03fd74895d676c4435bec1aade0863be1489a4be1bb5c9269c6ef389bf5d2d",
+    windows_amd64: "f9e15b8f3628e4c7bfe481011bea458df754d0e75c6ff4ab01c71294165950fd"
+  }
+};
+var CODELLDB_CHECKSUMS = {
+  "v1.12.2": {
+    darwin_arm64: "c836b81c6f2da467b5920a376a7bfc849dc4b4d81b19779dedf1c685cb4aa1a0"
+  }
+};
+
+// src/adapters/provision/jsDebug.ts
+var ADAPTER_ID = "js-debug";
+var ENTRYPOINTS = ["src/dapDebugServer.js", "src/bootloader.js"];
+var PACKAGE_BOUNDARY = '{"type":"commonjs"}\n';
+function resolveBaseUrl(env) {
+  const override = env.DAP_CLI_PROVISION_RELEASE_BASE_URL;
+  return override !== void 0 && override.length > 0 ? override : "https://github.com";
+}
+function downloadUrl(env) {
+  return `${resolveBaseUrl(env)}/microsoft/vscode-js-debug/releases/download/v${JS_DEBUG_VERSION}/js-debug-dap-v${JS_DEBUG_VERSION}.tar.gz`;
+}
+async function fileSha256(filePath) {
+  return await new Promise((resolve, reject) => {
+    const hash = createHash2("sha256");
+    const stream = createReadStream2(filePath);
+    stream.on("error", reject);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve(hash.digest("hex")));
+  });
+}
+async function entrypointsExist(installRoot) {
+  for (const rel of ENTRYPOINTS) {
+    try {
+      await fs6.access(path9.join(installRoot, rel));
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+async function provisionJsDebug(ctx) {
+  const installRoot = path9.join(ctx.adaptersDir, ADAPTER_ID);
+  const entrypoint = path9.join(installRoot, "src", "dapDebugServer.js");
+  if (await hasConsentMarker(ctx.adaptersDir, ADAPTER_ID, JS_DEBUG_VERSION) && await entrypointsExist(installRoot)) {
+    return {
+      adapterId: "js-debug",
+      version: JS_DEBUG_VERSION,
+      installRoot,
+      entrypoint,
+      fromCache: true
+    };
+  }
+  const url = downloadUrl(ctx.env);
+  const expectedSha = JS_DEBUG_CHECKSUMS[JS_DEBUG_VERSION];
+  if (expectedSha === void 0) {
+    throw usageError(`No SHA-256 checksum recorded for js-debug v${JS_DEBUG_VERSION}.`, {
+      code: "provision_checksum_mismatch",
+      diagnostics: [
+        `Adapter: js-debug ${JS_DEBUG_VERSION}`,
+        "Edit src/adapters/provision/checksums.ts and add the hash for this version.",
+        "Re-run setup or report at https://github.com/roblourens/dap-cli/issues if persistent."
+      ],
+      data: {
+        adapterId: "js-debug",
+        version: JS_DEBUG_VERSION
+      }
+    });
+  }
+  await confirm({
+    assumeYes: ctx.assumeYes,
+    question: `Install vscode-js-debug ${JS_DEBUG_VERSION} into ${installRoot} (~10MB)?`,
+    details: [`Source: ${url}`],
+    ...ctx.stdin === void 0 ? {} : { stdin: ctx.stdin },
+    ...ctx.stderr === void 0 ? {} : { stderr: ctx.stderr }
+  });
+  await withAdapterLock(ctx.adaptersDir, ADAPTER_ID, async () => {
+    if (await hasConsentMarker(ctx.adaptersDir, ADAPTER_ID, JS_DEBUG_VERSION) && await entrypointsExist(installRoot)) {
+      return;
+    }
+    await atomicInstall({
+      adaptersDir: ctx.adaptersDir,
+      adapterId: ADAPTER_ID,
+      expectedEntrypoints: ENTRYPOINTS,
+      populate: async (stagingDir) => {
+        const archivePath = path9.join(
+          ctx.adaptersDir,
+          `.${ADAPTER_ID}.archive.${process.pid}.${randomBytes2(4).toString("hex")}.tar.gz`
+        );
+        try {
+          await downloadToFile({ url, destPath: archivePath, env: ctx.env });
+          const actualSha = await fileSha256(archivePath);
+          if (actualSha !== expectedSha) {
+            throw usageError("Adapter download 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: "js-debug",
+                version: JS_DEBUG_VERSION,
+                url,
+                expectedSha,
+                actualSha
+              }
+            });
+          }
+          await extractTarGz(archivePath, stagingDir, { strip: 1 });
+          await fs6.writeFile(
+            path9.join(stagingDir, "package.json"),
+            PACKAGE_BOUNDARY,
+            "utf8"
+          );
+        } finally {
+          await fs6.rm(archivePath, { force: true }).catch(() => void 0);
+        }
+      }
+    });
+    await writeConsentMarker(ctx.adaptersDir, ADAPTER_ID, JS_DEBUG_VERSION);
+  });
+  return {
+    adapterId: "js-debug",
+    version: JS_DEBUG_VERSION,
+    installRoot,
+    entrypoint,
+    fromCache: false
+  };
+}
+
+// src/adapters/provision/debugpy.ts
+import path10 from "path";
+import { promises as fs7 } from "fs";
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+function venvPythonRel() {
+  return process.platform === "win32" ? path10.join("venv", "Scripts", "python.exe") : path10.join("venv", "bin", "python");
+}
+function venvPipRel() {
+  return process.platform === "win32" ? path10.join("venv", "Scripts", "pip.exe") : path10.join("venv", "bin", "pip");
+}
+function tail(text, max = 2048) {
+  if (text.length <= max) {
+    return text;
+  }
+  return `...${text.slice(text.length - max)}`;
+}
+async function exists(p) {
+  try {
+    await fs7.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function provisionDebugpy(ctx) {
+  const { env, assumeYes, adaptersDir, stdin, stderr } = ctx;
+  const installRoot = path10.join(adaptersDir, "debugpy");
+  const entrypoint = path10.join(installRoot, venvPythonRel());
+  if (await hasConsentMarker(adaptersDir, "debugpy", DEBUGPY_VERSION) && await exists(entrypoint)) {
+    return {
+      adapterId: "debugpy",
+      version: DEBUGPY_VERSION,
+      installRoot,
+      entrypoint,
+      fromCache: true
+    };
+  }
+  await confirm({
+    assumeYes,
+    question: `Install debugpy ${DEBUGPY_VERSION} into a venv at ${installRoot}/ (~6MB)?`,
+    details: [
+      "Requires python3 (>=3.8) on PATH.",
+      "Creates an isolated venv and pip-installs debugpy. The venv python becomes the adapter command."
+    ],
+    ...stdin === void 0 ? {} : { stdin },
+    ...stderr === void 0 ? {} : { stderr }
+  });
+  await withAdapterLock(adaptersDir, "debugpy", async () => {
+    if (await hasConsentMarker(adaptersDir, "debugpy", DEBUGPY_VERSION) && await exists(entrypoint)) {
+      return;
+    }
+    const python3 = env.DAP_CLI_PROVISION_PYTHON3 ?? "python3";
+    try {
+      await execFileAsync(python3, ["--version"]);
+    } catch (error) {
+      const message = error.stderr ?? error.message ?? "unknown error";
+      throw usageError("python3 is not available on PATH.", {
+        code: "provision_python3_missing",
+        diagnostics: [
+          "Install Python 3.8+ and ensure `python3` is on PATH.",
+          "macOS: `brew install python`",
+          "Ubuntu/Debian: `apt install python3 python3-venv`",
+          'Windows: install from python.org and check "Add to PATH".',
+          `Underlying error: ${tail(message, 512)}`
+        ],
+        data: { python3 },
+        cause: error
+      });
+    }
+    await atomicInstall({
+      adaptersDir,
+      adapterId: "debugpy",
+      expectedEntrypoints: [venvPythonRel()],
+      populate: async (stagingDir) => {
+        const venvDir = path10.join(stagingDir, "venv");
+        try {
+          await execFileAsync(python3, ["-m", "venv", venvDir]);
+        } catch (error) {
+          const stderrText = error.stderr ?? "";
+          throw usageError("Failed to create Python virtual environment.", {
+            code: "provision_python3_venv_unavailable",
+            diagnostics: [
+              "The `python3 -m venv` command failed. On Debian/Ubuntu install `python3-venv`:",
+              "  sudo apt install python3-venv",
+              "On other distros ensure the standard library `venv` and `ensurepip` modules are present.",
+              `stderr tail: ${tail(stderrText)}`
+            ],
+            data: { python3 },
+            cause: error
+          });
+        }
+        const pipPath = path10.join(stagingDir, venvPipRel());
+        try {
+          await execFileAsync(pipPath, [
+            "install",
+            "--no-warn-script-location",
+            "--disable-pip-version-check",
+            `debugpy==${DEBUGPY_VERSION}`
+          ]);
+        } catch (error) {
+          const stderrText = error.stderr ?? "";
+          throw usageError(`Failed to install debugpy==${DEBUGPY_VERSION} via pip.`, {
+            code: "provision_pip_install_failed",
+            diagnostics: [
+              "pip install failed. Common causes: no network access, restricted PyPI mirror, missing build tools.",
+              "Workaround: set `PIP_INDEX_URL` to your mirror, or pre-install debugpy into the venv and re-run.",
+              `Underlying pip command: ${pipPath} install debugpy==${DEBUGPY_VERSION}`,
+              `stderr tail: ${tail(stderrText)}`
+            ],
+            data: { pipPath, version: DEBUGPY_VERSION },
+            cause: error
+          });
+        }
+      }
+    });
+    await writeConsentMarker(adaptersDir, "debugpy", DEBUGPY_VERSION);
+  });
+  return {
+    adapterId: "debugpy",
+    version: DEBUGPY_VERSION,
+    installRoot,
+    entrypoint,
+    fromCache: false
+  };
+}
+
+// src/adapters/provision/delve.ts
+import path12 from "path";
+import { promises as fs9 } from "fs";
+import { createHash as createHash3 } from "crypto";
+import { randomBytes as randomBytes3 } from "crypto";
+
+// src/adapters/provision/extractZip.ts
+import { promises as fs8, createWriteStream as createWriteStream4 } from "fs";
+import path11 from "path";
+import yauzl from "yauzl";
+var SYMLINK_MODE = 40960;
+var UNIX_MODE_MASK = 61440;
+function isUnsafeFileName(fileName) {
+  if (path11.isAbsolute(fileName)) {
+    return true;
+  }
+  if (/^[A-Za-z]:[\\/]/.test(fileName)) {
+    return true;
+  }
+  return fileName.split(/[\\/]/).includes("..");
+}
+function isSymlinkEntry(entry) {
+  const unixMode = entry.externalFileAttributes >>> 16 & UNIX_MODE_MASK;
+  return unixMode === SYMLINK_MODE;
+}
+function unsafeEntryError(archivePath, fileName) {
+  return usageError("Archive contains unsafe entry path.", {
+    code: "provision_extract_failed",
+    diagnostics: [`Entry: ${fileName}`, `Archive: ${archivePath}`],
+    data: { archivePath, entry: fileName }
+  });
+}
+function wrapExtractError(archivePath, error) {
+  if (error instanceof CliError) {
+    return error;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return usageError("Archive extraction failed.", {
+    code: "provision_extract_failed",
+    diagnostics: [archivePath, message],
+    data: { archivePath },
+    cause: error
+  });
+}
+async function extractZip(archivePath, destDir) {
+  await fs8.mkdir(destDir, { recursive: true });
+  await new Promise((resolve, reject) => {
+    yauzl.open(archivePath, { lazyEntries: true }, (openErr, zip) => {
+      if (openErr || zip === void 0) {
+        reject(openErr ?? new Error("zip open failed"));
+        return;
+      }
+      const handleError = (err) => {
+        try {
+          zip.close();
+        } catch {
+        }
+        reject(err instanceof Error ? err : new Error(String(err)));
+      };
+      zip.on("error", handleError);
+      zip.on("end", () => {
+        resolve();
+      });
+      zip.on("entry", (entry) => {
+        if (isUnsafeFileName(entry.fileName)) {
+          handleError(unsafeEntryError(archivePath, entry.fileName));
+          return;
+        }
+        if (isSymlinkEntry(entry)) {
+          handleError(unsafeEntryError(archivePath, entry.fileName));
+          return;
+        }
+        const dest = path11.join(destDir, entry.fileName);
+        if (entry.fileName.endsWith("/")) {
+          fs8.mkdir(dest, { recursive: true }).then(() => {
+            zip.readEntry();
+          }).catch(handleError);
+          return;
+        }
+        fs8.mkdir(path11.dirname(dest), { recursive: true }).then(() => {
+          zip.openReadStream(entry, (readErr, readStream) => {
+            if (readErr || readStream === void 0) {
+              handleError(readErr ?? new Error("zip read failed"));
+              return;
+            }
+            const out = createWriteStream4(dest);
+            out.on("finish", () => {
+              zip.readEntry();
+            });
+            out.on("error", handleError);
+            readStream.on("error", handleError);
+            readStream.pipe(out);
+          });
+        }).catch(handleError);
+      });
+      zip.readEntry();
+    });
+  }).catch((error) => {
+    throw wrapExtractError(archivePath, error);
+  });
+}
+
+// src/adapters/provision/delve.ts
+var DEFAULT_RELEASE_BASE_URL = "https://github.com";
+function bareVersion() {
+  return DELVE_VERSION.startsWith("v") ? DELVE_VERSION.slice(1) : DELVE_VERSION;
+}
+function resolveDelveAsset(env) {
+  const override = env.DAP_CLI_PROVISION_DELVE_PLATFORM_OVERRIDE;
+  const key = override !== void 0 && override.length > 0 ? override : `${process.platform}_${process.arch}`;
+  const matrix = {
+    "darwin_arm64": "darwin_arm64",
+    "darwin_x64": "darwin_amd64",
+    "linux_x64": "linux_amd64",
+    "linux_arm64": "linux_arm64",
+    "win32_x64": "windows_amd64"
+  };
+  const platformKey = matrix[key];
+  if (platformKey === void 0) {
+    throw usageError(`Delve provisioning does not support platform '${key}'.`, {
+      code: "provision_arch_unsupported",
+      diagnostics: [
+        `Detected platform: ${key}`,
+        "Supported platforms: darwin_arm64, darwin_x64, linux_x64, linux_arm64, win32_x64.",
+        "Install `dlv` manually on PATH or provision a compatible binary."
+      ],
+      data: {
+        adapterId: "delve",
+        detected: key,
+        supported: ["darwin_arm64", "darwin_x64", "linux_x64", "linux_arm64", "win32_x64"]
+      }
+    });
+  }
+  const archiveKind = platformKey === "windows_amd64" ? "zip" : "tar.gz";
+  const ext = archiveKind === "zip" ? "zip" : "tar.gz";
+  const archiveName = `dlv_${bareVersion()}_${platformKey}.${ext}`;
+  const executableName = platformKey === "windows_amd64" ? "dlv.exe" : "dlv";
+  return { platformKey, archiveName, archiveKind, executableName };
+}
+async function exists2(p) {
+  try {
+    await fs9.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function computeSha256(filePath) {
+  const buffer = await fs9.readFile(filePath);
+  return createHash3("sha256").update(buffer).digest("hex");
+}
+async function provisionDelve(ctx) {
+  const { env, assumeYes, adaptersDir, stdin, stderr } = ctx;
+  const asset = resolveDelveAsset(env);
+  const installRoot = path12.join(adaptersDir, "delve");
+  const entrypoint = path12.join(installRoot, asset.executableName);
+  const expectedSha = DELVE_CHECKSUMS[DELVE_VERSION]?.[asset.platformKey];
+  if (expectedSha === void 0) {
+    throw usageError(`No pinned SHA-256 for delve ${DELVE_VERSION} on ${asset.platformKey}.`, {
+      code: "provision_checksum_mismatch",
+      diagnostics: [
+        `Adapter: delve ${DELVE_VERSION} (${asset.platformKey})`,
+        "src/adapters/provision/checksums.ts must list a checksum for every supported platform.",
+        "Re-run setup or report at https://github.com/roblourens/dap-cli/issues if persistent."
+      ],
+      data: {
+        adapterId: "delve",
+        version: DELVE_VERSION,
+        platform: asset.platformKey
+      }
+    });
+  }
+  if (await hasConsentMarker(adaptersDir, "delve", DELVE_VERSION) && await exists2(entrypoint)) {
+    return {
+      adapterId: "delve",
+      version: DELVE_VERSION,
+      installRoot,
+      entrypoint,
+      fromCache: true
+    };
+  }
+  await confirm({
+    assumeYes,
+    question: `Install delve ${DELVE_VERSION} into ${installRoot}/ (~10MB)?`,
+    details: [
+      `Downloads the official release asset ${asset.archiveName} from github.com/go-delve/delve.`,
+      "The archive SHA-256 is verified against an embedded checksum before installation."
+    ],
+    ...stdin === void 0 ? {} : { stdin },
+    ...stderr === void 0 ? {} : { stderr }
+  });
+  await withAdapterLock(adaptersDir, "delve", async () => {
+    if (await hasConsentMarker(adaptersDir, "delve", DELVE_VERSION) && await exists2(entrypoint)) {
+      return;
+    }
+    const releaseBase = env.DAP_CLI_PROVISION_RELEASE_BASE_URL ?? DEFAULT_RELEASE_BASE_URL;
+    const url = `${releaseBase}/go-delve/delve/releases/download/${DELVE_VERSION}/${asset.archiveName}`;
+    const archivePath = path12.join(
+      adaptersDir,
+      `.delve.archive.${process.pid}.${randomBytes3(4).toString("hex")}.${asset.archiveKind === "zip" ? "zip" : "tar.gz"}`
+    );
+    try {
+      await fs9.mkdir(adaptersDir, { recursive: true });
+      await downloadToFile({ url, destPath: archivePath, env });
+      const actualSha = await computeSha256(archivePath);
+      if (actualSha !== expectedSha) {
+        throw usageError("Delve 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: "delve",
+            version: DELVE_VERSION,
+            url,
+            expectedSha,
+            actualSha
+          }
+        });
+      }
+      await atomicInstall({
+        adaptersDir,
+        adapterId: "delve",
+        expectedEntrypoints: [asset.executableName],
+        populate: async (stagingDir) => {
+          if (asset.archiveKind === "zip") {
+            await extractZip(archivePath, stagingDir);
+          } else {
+            await extractTarGz(archivePath, stagingDir);
+          }
+          if (process.platform !== "win32") {
+            await fs9.chmod(path12.join(stagingDir, asset.executableName), 493);
+          }
+        }
+      });
+      await writeConsentMarker(adaptersDir, "delve", DELVE_VERSION);
+    } finally {
+      await fs9.rm(archivePath, { force: true }).catch(() => void 0);
+    }
+  });
+  return {
+    adapterId: "delve",
+    version: DELVE_VERSION,
+    installRoot,
+    entrypoint,
+    fromCache: false
+  };
+}
+
+// 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"]
+      }
     });
-    throw error;
   }
+  return {
+    platformKey: "darwin_arm64",
+    archiveName: "codelldb-darwin-arm64.vsix"
+  };
 }
-async function connectWithRetry(adapterId, host, port) {
-  const deadline = Date.now() + 5e3;
-  let lastError;
-  while (Date.now() < deadline) {
+async function isCodeLldbRuntimeReady(installRoot) {
+  for (const relativePath of REQUIRED_RUNTIME_PATHS) {
     try {
-      return await connectSocketTransport({ name: adapterId, host, port, timeoutMs: 500 });
-    } catch (error) {
-      lastError = error;
-      await delay(50);
+      await fs10.access(path13.join(installRoot, relativePath));
+    } catch {
+      return false;
     }
   }
-  throw lastError instanceof Error ? lastError : new Error("Timed out connecting DAP server adapter.");
+  return true;
 }
-function getFreePort(host) {
-  return new Promise((resolve, reject) => {
-    const server = net3.createServer();
-    server.once("error", reject);
-    server.listen(0, host, () => {
-      const address = server.address();
-      server.close(() => {
-        if (typeof address === "object" && address !== null) {
-          resolve(address.port);
-          return;
-        }
-        reject(new Error("Failed to allocate a local adapter server port."));
-      });
+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 }
     });
-  });
-}
-async function terminateChild2(child) {
-  if (child.exitCode !== null || child.signalCode !== null) {
-    return;
-  }
-  child.kill("SIGTERM");
-  if (await waitForExit2(child, 100)) {
-    return;
   }
-  child.kill("SIGKILL");
-  await waitForExit2(child, 100);
-}
-function waitForExit2(child, timeoutMs) {
-  if (child.exitCode !== null || child.signalCode !== null) {
-    return Promise.resolve(true);
+  if (await hasConsentMarker(ctx.adaptersDir, ADAPTER_ID2, CODELLDB_VERSION) && await isCodeLldbRuntimeReady(installRoot)) {
+    return { adapterId: ADAPTER_ID2, version: CODELLDB_VERSION, installRoot, entrypoint, fromCache: true };
   }
-  return new Promise((resolve) => {
-    const timer = setTimeout(() => {
-      child.off("exit", onExit);
-      resolve(false);
-    }, timeoutMs);
-    const onExit = () => {
-      clearTimeout(timer);
-      resolve(true);
-    };
-    child.once("exit", onExit);
+  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 }
   });
-}
-function appendStderrTail2(stderrTail, text) {
-  for (const line of text.split(/\r?\n/).filter((value) => value.length > 0)) {
-    stderrTail.push(line);
-    while (stderrTail.length > 100) {
-      stderrTail.shift();
+  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 };
 }
-async function delay(ms) {
-  await new Promise((resolve) => setTimeout(resolve, ms));
+
+// src/adapters/provision/index.ts
+async function provisionAdapter(id, ctx) {
+  switch (id) {
+    case "js-debug":
+      return provisionJsDebug(ctx);
+    case "debugpy":
+      return provisionDebugpy(ctx);
+    case "delve":
+      return provisionDelve(ctx);
+    case "codelldb":
+      return provisionCodeLldb(ctx);
+  }
 }
 
 // src/adapters/builtins/jsDebug.ts
-import { existsSync } from "fs";
-import path5 from "path";
-function createJsDebugDescriptor(jsDebugPath) {
-  const dapServerPath = jsDebugPath ?? resolveDefaultJsDebugPath();
+async function createJsDebugDescriptor(jsDebugPath) {
+  const dapServerPath = jsDebugPath ?? await resolveDefaultJsDebugPath();
   return {
     id: "js-debug",
     label: "JavaScript Debug Adapter (Node, Chrome, Electron)",
@@ -1488,26 +2662,35 @@ function applyJsDebugTraceDefaults(config, logDir) {
     ...record,
     trace: {
       stdio: false,
-      logFile: path5.join(logDir, `js-debug-trace-${Date.now()}.log`)
+      logFile: path14.join(logDir, `js-debug-trace-${Date.now()}.log`)
     }
   };
 }
-function resolveDefaultJsDebugPath() {
-  const candidates = [
-    path5.join(getDapCliAdaptersDir(), "js-debug", "src", "dapDebugServer.js"),
-    path5.join(process.cwd(), "node_modules", "vscode-js-debug", "src", "dapDebugServer.js")
-  ];
-  const found = candidates.find((candidate) => existsSync(candidate));
-  if (found !== void 0) {
-    return found;
+async function pathExists(candidate) {
+  try {
+    await fs11.access(candidate);
+    return true;
+  } catch {
+    return false;
   }
-  throw usageError("js-debug adapter is not installed.", {
-    code: "js_debug_not_found",
-    diagnostics: [
-      "Run npm run setup-adapters to provision js-debug, or see docs/ADAPTER-SETUP.md for advanced manual provisioning.",
-      `Checked: ${candidates.join(", ")}`
-    ]
+}
+async function resolveDefaultJsDebugPath() {
+  const env = process.env;
+  const adaptersDir = getDapCliAdaptersDir(env);
+  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;
+  }
+  if (await pathExists(repoEntrypoint)) {
+    return repoEntrypoint;
+  }
+  const result = await provisionAdapter("js-debug", {
+    env,
+    assumeYes: resolveAssumeYes(void 0, env),
+    adaptersDir
   });
+  return result.entrypoint;
 }
 
 // src/protocol/dapClient.ts
@@ -1601,14 +2784,16 @@ function parseBody(body) {
 
 // src/protocol/dapClient.ts
 var DapResponseError = class extends Error {
-  constructor(command, requestSeq, message) {
+  constructor(command, requestSeq, message, responseBody) {
     super(message);
     this.command = command;
     this.requestSeq = requestSeq;
+    this.responseBody = responseBody;
     this.name = "DapResponseError";
   }
   command;
   requestSeq;
+  responseBody;
 };
 var DapTransportClosedError = class extends Error {
   constructor(message = "DAP transport closed.") {
@@ -1629,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;
@@ -1691,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 {
@@ -1713,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") {
@@ -1736,7 +2928,7 @@ var DapClient = class {
       clearTimeout(pending.timeout);
     }
     if (!response.success) {
-      pending.reject(new DapResponseError(response.command, response.request_seq, response.message ?? `DAP request failed: ${response.command}`));
+      pending.reject(new DapResponseError(response.command, response.request_seq, response.message ?? `DAP request failed: ${response.command}`, response.body));
       return;
     }
     pending.resolve(response.body);
@@ -1818,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);
@@ -2149,14 +3344,14 @@ function getDapGeneratedCommand(command) {
 }
 
 // src/sessions/session.ts
-import { randomBytes } from "crypto";
+import { randomBytes as randomBytes5 } from "crypto";
 var REMOVABLE_LIFECYCLES = /* @__PURE__ */ new Set([
   "terminated",
   "disconnected",
   "failed"
 ]);
 function createSessionId() {
-  return `sess_${randomBytes(12).toString("base64url")}`;
+  return `sess_${randomBytes5(12).toString("base64url")}`;
 }
 function projectSessionSummary(session) {
   const summary = {
@@ -2269,9 +3464,9 @@ function createAmbiguousSessionDiagnostics(targetId, matches) {
 }
 
 // src/sessions/sessionStore.ts
-import { promises as fs2 } from "fs";
+import { promises as fs12 } from "fs";
 import { randomUUID } from "crypto";
-import path6 from "path";
+import path15 from "path";
 import { z as z5 } from "zod";
 var ownedAdapterSchema = z5.object({
   pid: z5.number().int().positive().optional(),
@@ -2313,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 = path6.join(getDapCliStateDir(env), "sessions.json");
+    this.storePath = path15.join(getDapCliStateDir(env), "sessions.json");
   }
   get path() {
     return this.storePath;
   }
   async read() {
     try {
-      const raw = await fs2.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 } : {},
@@ -2333,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 fs2.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 {
@@ -2344,12 +3539,12 @@ var SessionStore = class {
     }
   }
   async write(data) {
-    await fs2.mkdir(path6.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 fs2.writeFile(tempPath, `${JSON.stringify(validated, null, 2)}
+    await fs12.writeFile(tempPath, `${JSON.stringify(validated, null, 2)}
 `, "utf8");
-    await fs2.rename(tempPath, this.storePath);
+    await fs12.rename(tempPath, this.storePath);
   }
 };
 function isNodeError2(error) {
@@ -3082,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);
@@ -3755,12 +5000,12 @@ function sourceMatches(eventPath, requestPath) {
   if (eventPath === requestPath) {
     return true;
   }
-  const normalize = (path14) => path14.replace(/^file:\/\//, "").replace(/\\/g, "/");
+  const normalize = (path26) => path26.replace(/^file:\/\//, "").replace(/\\/g, "/");
   return normalize(eventPath) === normalize(requestPath);
 }
 
 // src/sessions/helperProcessDetection.ts
-import { execFile } from "child_process";
+import { execFile as execFile2 } from "child_process";
 var helperProcessWarningEventName = "dapCli.helperProcessWarning";
 var helperHint = "Likely attached to an adapter-spawned helper process; you probably meant `dap-cli attach`, not `dap-cli launch`.";
 function createHelperProcessDetector(options) {
@@ -3839,7 +5084,7 @@ function defaultLookupPpid(pid) {
     return Promise.resolve(void 0);
   }
   return new Promise((resolve) => {
-    execFile("ps", ["-o", "ppid=", "-p", String(pid)], { timeout: psLookupTimeoutMs }, (error, stdout) => {
+    execFile2("ps", ["-o", "ppid=", "-p", String(pid)], { timeout: psLookupTimeoutMs }, (error, stdout) => {
       if (error !== null) {
         resolve(void 0);
         return;
@@ -3860,8 +5105,8 @@ function defaultLookupPpid(pid) {
 }
 
 // src/controller/buildId.ts
-import { promises as fs3 } from "fs";
-import path7 from "path";
+import { promises as fs13 } from "fs";
+import path16 from "path";
 import { fileURLToPath } from "url";
 var cachedBuildId;
 async function computeBuildId() {
@@ -3873,14 +5118,14 @@ async function computeBuildId() {
     cachedBuildId = envOverride;
     return cachedBuildId;
   }
-  const here = path7.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 = path7.dirname(pkgPath);
+    pkgDir = path16.dirname(pkgPath);
     try {
-      const raw = await fs3.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;
@@ -3888,9 +5133,9 @@ async function computeBuildId() {
     } catch {
     }
   }
-  const distPath = path7.join(pkgDir, "dist", "index.js");
+  const distPath = path16.join(pkgDir, "dist", "index.js");
   try {
-    const stat = await fs3.stat(distPath);
+    const stat = await fs13.stat(distPath);
     cachedBuildId = `${version}:dist:${stat.mtimeMs}:${stat.size}`;
   } catch {
     cachedBuildId = `${version}:src`;
@@ -3900,12 +5145,12 @@ async function computeBuildId() {
 async function findPackageJson(startDir) {
   let dir = startDir;
   for (let depth = 0; depth < 8; depth += 1) {
-    const candidate = path7.join(dir, "package.json");
+    const candidate = path16.join(dir, "package.json");
     try {
-      await fs3.access(candidate);
+      await fs13.access(candidate);
       return candidate;
     } catch {
-      const parent = path7.dirname(dir);
+      const parent = path16.dirname(dir);
       if (parent === dir) {
         return void 0;
       }
@@ -4271,12 +5516,12 @@ var ControllerServer = class {
     }
     if (request.method === "sessions.stop") {
       const target = getOptionalStringParam(request.params, "name");
-      await this.disconnectRuntimeForTarget(target);
+      await this.disconnectRuntimeForTarget(target, { terminateDebuggee: true });
       return manager.stopSession(target);
     }
     if (request.method === "sessions.detach") {
       const target = getOptionalStringParam(request.params, "name");
-      await this.disconnectRuntimeForTarget(target);
+      await this.disconnectRuntimeForTarget(target, { terminateDebuggee: false });
       return manager.detachSession(target);
     }
     if (request.method === "sessions.close") {
@@ -4658,7 +5903,7 @@ var ControllerServer = class {
       return { sources: [] };
     }
     if (source !== void 0) {
-      const entry = map.get(path8.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 {
@@ -4683,7 +5928,7 @@ var ControllerServer = class {
     };
     const cleared = [];
     if (source !== void 0) {
-      const key = path8.resolve(source);
+      const key = path17.resolve(source);
       const entry = map.get(key);
       if (entry === void 0) {
         return { cleared: [] };
@@ -4835,7 +6080,7 @@ var ControllerServer = class {
       }
     });
   }
-  async disconnectRuntimeForTarget(target) {
+  async disconnectRuntimeForTarget(target, opts) {
     let status;
     try {
       status = this.requireSessionManager().status(target);
@@ -4849,7 +6094,9 @@ var ControllerServer = class {
     if (runtime.children !== void 0) {
       await runtime.children.dispose().catch(() => void 0);
     }
-    await runtime.lifecycle.disconnect().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);
@@ -5046,7 +6293,7 @@ function parseDapStartCompoundMemberParams(value) {
   return parsed;
 }
 function createCompoundId() {
-  return `compound_${randomBytes2(12).toString("base64url")}`;
+  return `compound_${randomBytes6(12).toString("base64url")}`;
 }
 function findFailedCompoundMemberName(error, members, startedMemberNames) {
   const failed = members.find((member) => !startedMemberNames.includes(member.memberName));
@@ -5172,7 +6419,7 @@ function toDapCliError(error, context) {
     }
     return dapError(error.message, {
       code: "dap_request_failed",
-      diagnostics: [`DAP request failed: ${error.command}. Inspect adapter diagnostics and session state.`],
+      diagnostics: createDapResponseDiagnostics(error),
       sessionId: context.sessionId,
       request: { command: error.command, seq: error.requestSeq },
       adapter: context.adapter
@@ -5204,6 +6451,33 @@ function toDapCliError(error, context) {
     diagnostics: ["The adapter failed while processing the DAP request. Check adapter stderr and log path."]
   }, context));
 }
+function createDapResponseDiagnostics(error) {
+  const diagnostics = [`DAP request failed: ${error.command}. Inspect adapter diagnostics and session state.`];
+  const responseDetail = extractDapResponseDetail(error.responseBody);
+  if (responseDetail !== void 0 && responseDetail !== error.message) {
+    diagnostics.push(`Adapter detail: ${responseDetail}`);
+  }
+  return diagnostics;
+}
+function extractDapResponseDetail(body) {
+  if (!isRecord5(body)) {
+    return void 0;
+  }
+  if (typeof body.message === "string" && body.message.trim().length > 0) {
+    return body.message.trim();
+  }
+  const error = body.error;
+  if (!isRecord5(error)) {
+    return void 0;
+  }
+  if (typeof error.format === "string" && error.format.trim().length > 0) {
+    return error.format.trim();
+  }
+  if (typeof error.message === "string" && error.message.trim().length > 0) {
+    return error.message.trim();
+  }
+  return void 0;
+}
 function toControllerErrorPayload(error) {
   const payload = {
     code: error.code,
@@ -5480,7 +6754,7 @@ async function delay2(ms) {
 }
 
 // src/cli/commands/dapAliases.ts
-import path9 from "path";
+import path18 from "path";
 
 // src/cli/commands/jsonOptions.ts
 function parseJsonOption(value) {
@@ -5608,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: path9.resolve(options.source) },
+      source: { path: path18.resolve(options.source) },
       breakpoints: lines.map((line) => compactObject({
         line,
         condition: options.condition,
@@ -5641,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 : path9.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 {
@@ -5654,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 : path9.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 {
@@ -5682,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 path14 = options.path;
+    const path26 = options.path;
     await sendAliasRequest(output, "source", compactObject({
       sourceReference: parseRequiredIntegerOption(options.sourceReference, "source-reference"),
-      source: path14 === void 0 ? void 0 : { path: path14 }
+      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) => {
@@ -5942,9 +7216,9 @@ async function buildVerificationDiagnostic(client, requestedPath, breakpointsRes
   }
   const sources = loaded.sources ?? [];
   const loadedSourcesCount = sources.length;
-  const wantBasename = path9.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(path9.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 };
   });
@@ -5986,12 +7260,12 @@ async function countChildSessions(client, parentName) {
 }
 
 // src/cli/commands/dapCore.ts
-import path13 from "path";
+import path24 from "path";
 
 // src/adapters/config.ts
-import { promises as fs4 } from "fs";
+import { promises as fs14 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
-import path10 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(),
@@ -6004,7 +7278,7 @@ var adapterConfigSchema = z6.object({
 async function loadAdapterConfig(dapCliHome) {
   const configPath = getAdapterConfigPath(dapCliHome);
   try {
-    const raw = await fs4.readFile(configPath, "utf8");
+    const raw = await fs14.readFile(configPath, "utf8");
     return parseAdapterConfig(raw);
   } catch (error) {
     if (isNodeError4(error) && error.code === "ENOENT") {
@@ -6018,7 +7292,7 @@ async function loadAdapterConfig(dapCliHome) {
 }
 function getAdapterConfigPath(dapCliHome) {
   const home = dapCliHome === void 0 ? getDapCliHome() : getDapCliHome({ ...process.env, DAP_CLI_HOME: dapCliHome });
-  return path10.join(home, "config", "adapters.json");
+  return path19.join(home, "config", "adapters.json");
 }
 function parseAdapterConfig(raw) {
   return adapterConfigSchema.parse(JSON.parse(raw));
@@ -6034,10 +7308,12 @@ function isNodeError4(error) {
 }
 
 // src/adapters/builtins/debugpy.ts
-import { existsSync as existsSync2 } from "fs";
-import { spawnSync } from "child_process";
-function createDebugpyDescriptor(pythonPath) {
-  const resolvedPythonPath = pythonPath ?? resolveDefaultDebugpyPythonPath();
+import { promises as fs15 } from "fs";
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile3);
+async function createDebugpyDescriptor(pythonPath) {
+  const resolvedPythonPath = pythonPath ?? await resolveDefaultDebugpyPythonPath();
   return {
     id: "debugpy",
     label: "Python Debug Adapter (debugpy)",
@@ -6048,26 +7324,158 @@ function createDebugpyDescriptor(pythonPath) {
     }
   };
 }
-function resolveDefaultDebugpyPythonPath() {
-  const provisionedPython = getDapCliVenvPythonPath();
-  const candidates = [provisionedPython, "python3"];
-  if (existsSync2(provisionedPython) && pythonHasDebugpy(provisionedPython)) {
-    return provisionedPython;
+async function pathExists2(p) {
+  try {
+    await fs15.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function pythonHasDebugpy(pythonPath) {
+  try {
+    await execFileAsync2(pythonPath, ["-c", "import debugpy"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveDefaultDebugpyPythonPath(env = process.env) {
+  const legacyVenvPython = getDapCliVenvPythonPath(env);
+  if (await pathExists2(legacyVenvPython) && await pythonHasDebugpy(legacyVenvPython)) {
+    return legacyVenvPython;
   }
-  if (pythonHasDebugpy("python3")) {
+  if (await pythonHasDebugpy("python3")) {
     return "python3";
   }
-  throw usageError("debugpy adapter is not installed.", {
-    code: "debugpy_not_found",
+  const adaptersDir = getDapCliAdaptersDir(env);
+  const result = await provisionAdapter("debugpy", {
+    env,
+    assumeYes: resolveAssumeYes(void 0, env),
+    adaptersDir
+  });
+  return result.entrypoint;
+}
+
+// src/adapters/builtins/delve.ts
+import { promises as fs16 } from "fs";
+import { spawnSync } from "child_process";
+import path20 from "path";
+async function createDelveDescriptor(delvePath) {
+  const resolvedDelvePath = delvePath ?? await resolveDefaultDelvePath();
+  assertSupportedProvisionedDelveToolchain(resolvedDelvePath);
+  const toolchainEnvironment = createGoToolchainEnvironment();
+  return {
+    id: "delve",
+    label: "Go Debug Adapter (Delve)",
+    transport: {
+      kind: "server",
+      command: resolvedDelvePath,
+      args: ["dap", "--listen=127.0.0.1:${port}"],
+      host: "127.0.0.1",
+      ...toolchainEnvironment === void 0 ? {} : { env: toolchainEnvironment }
+    }
+  };
+}
+function createGoToolchainEnvironment() {
+  const goToolchain = process.env.GOTOOLCHAIN;
+  return goToolchain === void 0 || goToolchain.length === 0 ? void 0 : { GOTOOLCHAIN: goToolchain };
+}
+async function pathExists3(p) {
+  try {
+    await fs16.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveDefaultDelvePath(env = process.env) {
+  if (delveIsUsable("dlv")) {
+    return "dlv";
+  }
+  const provisionedDelve = getProvisionedDelvePath(env);
+  if (await pathExists3(provisionedDelve) && delveIsUsable(provisionedDelve)) {
+    return provisionedDelve;
+  }
+  const adaptersDir = getDapCliAdaptersDir(env);
+  const result = await provisionAdapter("delve", {
+    env,
+    assumeYes: resolveAssumeYes(void 0, env),
+    adaptersDir
+  });
+  return result.entrypoint;
+}
+function getProvisionedDelvePath(env = process.env) {
+  return path20.join(getDapCliAdaptersDir(env), "delve", process.platform === "win32" ? "dlv.exe" : "dlv");
+}
+function delveIsUsable(command) {
+  const result = spawnSync(command, ["version"], { encoding: "utf8" });
+  return result.status === 0;
+}
+function assertSupportedProvisionedDelveToolchain(delvePath) {
+  const delveVersion = readCommandVersion(delvePath, ["version"], /Version:\s*v?([0-9]+\.[0-9]+\.[0-9]+)/i);
+  if (delveVersion !== "1.26.3") {
+    return;
+  }
+  const goVersion = readCommandVersion("go", ["version"], /go version go([0-9]+\.[0-9]+(?:\.[0-9]+)?)/i);
+  if (goVersion === void 0 || compareNumericVersions(goVersion, "1.24.0") >= 0) {
+    return;
+  }
+  throw usageError("Provisioned Delve is incompatible with the active Go toolchain.", {
+    code: "delve_go_version_incompatible",
     diagnostics: [
-      "Run npm run setup-adapters to provision debugpy, or see docs/ADAPTER-SETUP.md for advanced manual provisioning.",
-      `Checked: ${candidates.join(", ")}`
+      `Delve ${delveVersion} requires Go 1.24+ for debuggee builds; current \`go\` is ${goVersion}.`,
+      "Use `GOTOOLCHAIN=go1.24.0` for the dap-cli launch, or update the active Go installation.",
+      "Run `go version` in the same shell/environment used for dap-cli to confirm the effective toolchain."
     ]
   });
 }
-function pythonHasDebugpy(pythonPath) {
-  const result = spawnSync(pythonPath, ["-c", "import debugpy"], { encoding: "utf8" });
-  return result.status === 0;
+function readCommandVersion(command, args, pattern) {
+  const result = spawnSync(command, [...args], { encoding: "utf8" });
+  if (result.status !== 0) {
+    return void 0;
+  }
+  const output = `${result.stdout ?? ""}
+${result.stderr ?? ""}`;
+  return pattern.exec(output)?.[1];
+}
+function compareNumericVersions(left, right) {
+  const leftParts = left.split(".").map((part) => Number.parseInt(part, 10));
+  const rightParts = right.split(".").map((part) => Number.parseInt(part, 10));
+  const width = Math.max(leftParts.length, rightParts.length);
+  for (let index = 0; index < width; index += 1) {
+    const leftPart = leftParts[index] ?? 0;
+    const rightPart = rightParts[index] ?? 0;
+    if (leftPart !== rightPart) {
+      return leftPart - rightPart;
+    }
+  }
+  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
@@ -6086,6 +7494,16 @@ var AdapterRegistry = class {
         label: "Python Debug Adapter (debugpy)",
         create: () => createDebugpyDescriptor()
       });
+      this.builtInAdapters.set("delve", {
+        id: "delve",
+        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, {
@@ -6098,7 +7516,7 @@ var AdapterRegistry = class {
       this.customAdapters.set(descriptor.id, descriptor);
     }
   }
-  resolve(id) {
+  async resolve(id) {
     const builtInAdapter = this.builtInAdapters.get(id);
     if (builtInAdapter !== void 0) {
       return builtInAdapter.create();
@@ -6127,9 +7545,9 @@ var AdapterRegistry = class {
 };
 
 // src/config/launchConfig.ts
-import { promises as fs5 } from "fs";
+import { promises as fs17 } from "fs";
 import os from "os";
-import path11 from "path";
+import path22 from "path";
 import { parse } from "jsonc-parser";
 import { z as z7 } from "zod";
 var launchConfigTypeMap = {
@@ -6138,7 +7556,9 @@ var launchConfigTypeMap = {
   chrome: "js-debug",
   "pwa-chrome": "js-debug",
   python: "debugpy",
-  debugpy: "debugpy"
+  debugpy: "debugpy",
+  go: "delve",
+  lldb: "codelldb"
 };
 var maxLaunchJsonBytes = 256 * 1024;
 var platformKeys = /* @__PURE__ */ new Set(["osx", "mac", "linux", "windows"]);
@@ -6165,12 +7585,12 @@ function resolveLaunchConfig(sources) {
   };
 }
 function resolveLaunchConfigurationConfig(config, options) {
-  const workspaceFolder = path11.resolve(options.workspaceFolder);
+  const workspaceFolder = path22.resolve(options.workspaceFolder);
   const platform = options.platform ?? process.platform;
   const merged = applyPlatformOverlay(config, platform);
   const context = {
     workspaceFolder,
-    workspaceFolderBasename: path11.basename(workspaceFolder),
+    workspaceFolderBasename: path22.basename(workspaceFolder),
     userHome: options.userHome ?? os.homedir(),
     execPath: options.execPath ?? process.execPath,
     env: options.env ?? process.env
@@ -6185,20 +7605,20 @@ function resolveLaunchConfigurationConfig(config, options) {
   for (const key of vscodeOnlyLaunchConfigKeys) {
     delete resolved[key];
   }
-  return resolved;
+  return normalizeGoLaunchConfigProgram(resolved, workspaceFolder);
 }
 async function loadVSCodeLaunchJson(cwd) {
-  const workspaceFolder = path11.resolve(cwd);
-  const launchJsonPath = path11.join(cwd, ".vscode", "launch.json");
+  const workspaceFolder = path22.resolve(cwd);
+  const launchJsonPath = path22.join(cwd, ".vscode", "launch.json");
   try {
-    const stat = await fs5.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 fs5.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 {
@@ -6303,7 +7723,7 @@ async function applyJsDebugSourceMapDefaults(config, options) {
   if (!isJsDebugLaunchType(config.type)) {
     return config;
   }
-  const hasTsConfig = await pathExists(path11.join(options.workspaceFolder, "tsconfig.json"));
+  const hasTsConfig = await pathExists4(path22.join(options.workspaceFolder, "tsconfig.json"));
   if (!hasTsConfig) {
     return config;
   }
@@ -6313,9 +7733,9 @@ async function applyJsDebugSourceMapDefaults(config, options) {
   }
   if (mapped.outFiles === void 0) {
     mapped.outFiles = [
-      path11.join(options.workspaceFolder, "dist", "**", "*.js"),
-      path11.join(options.workspaceFolder, "out", "**", "*.js"),
-      path11.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;
@@ -6328,6 +7748,29 @@ 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" || path22.isAbsolute(config.program)) {
+    return config;
+  }
+  const cwd = typeof config.cwd === "string" ? config.cwd : workspaceFolder;
+  return {
+    ...config,
+    program: path22.resolve(cwd, config.program)
+  };
+}
 function applyPlatformOverlay(config, platform) {
   const base = {};
   for (const [key, value] of Object.entries(config)) {
@@ -6410,9 +7853,9 @@ function resolveLaunchString(value, jsonPath, context) {
     });
   });
 }
-async function pathExists(filePath) {
+async function pathExists4(filePath) {
   try {
-    await fs5.stat(filePath);
+    await fs17.stat(filePath);
     return true;
   } catch (error) {
     if (isNodeError5(error) && error.code === "ENOENT") {
@@ -6454,9 +7897,10 @@ function isNodeError5(error) {
 }
 
 // src/config/programInference.ts
-import path12 from "path";
+import path23 from "path";
 var extensionTable = {
   ".py": { adapterId: "debugpy", type: "python" },
+  ".go": { adapterId: "delve", type: "go" },
   ".js": { adapterId: "js-debug", type: "pwa-node" },
   ".mjs": { adapterId: "js-debug", type: "pwa-node" },
   ".cjs": { adapterId: "js-debug", type: "pwa-node" },
@@ -6484,7 +7928,7 @@ function inferAdapterAndType(args) {
     return { adapterId, type, inferred: { adapter: true, type: false } };
   }
   if (program !== void 0) {
-    const extension = path12.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.`, {
@@ -6500,7 +7944,7 @@ function inferAdapterAndType(args) {
 function defaultTypeForAdapter(adapterId, program) {
   if (adapterId === "js-debug") {
     if (program !== void 0) {
-      const ext = path12.extname(program).toLowerCase();
+      const ext = path23.extname(program).toLowerCase();
       if (ext === ".html" || ext === ".htm") {
         return "pwa-chrome";
       }
@@ -6510,6 +7954,12 @@ function defaultTypeForAdapter(adapterId, program) {
   if (adapterId === "debugpy") {
     return "python";
   }
+  if (adapterId === "delve") {
+    return "go";
+  }
+  if (adapterId === "codelldb") {
+    return "lldb";
+  }
   return void 0;
 }
 
@@ -6551,7 +8001,7 @@ function createNameParams(name) {
   return name === void 0 ? {} : { name };
 }
 async function startDap(output, mode, options) {
-  const workspace = path13.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;
@@ -6595,7 +8045,7 @@ async function startDap(output, mode, options) {
     ...await mapConfigForAdapter(adapterId, resolveLaunchConfig({ namedConfig: { ...adapterDefaults, ...namedConfig }, jsonOverrides, jsonConfig, flags: adapterFlags }), workspace),
     request: effectiveMode
   };
-  const descriptor = adapterId === "fake" ? createFakeDescriptor(options.script ?? (effectiveMode === "attach" ? "attach-stopped" : "stopped-on-entry"), effectiveMode) : new AdapterRegistry({ config: adapterConfig }).resolve(adapterId);
+  const descriptor = adapterId === "fake" ? createFakeDescriptor(options.script ?? (effectiveMode === "attach" ? "attach-stopped" : "stopped-on-entry"), effectiveMode) : await new AdapterRegistry({ config: adapterConfig }).resolve(adapterId);
   const client = await createControllerClient({ dapCliHome: process.env.DAP_CLI_HOME, timeoutMs: startControllerRequestTimeoutMs });
   try {
     const response = await client.request("dap.start", {
@@ -6625,7 +8075,7 @@ async function createCompoundStartMember(configuration, memberName, workspaceFol
     ...await mapConfigForAdapter(adapterId, resolveLaunchConfig({ namedConfig: { ...adapterDefaults, ...resolvedConfig }, jsonOverrides, jsonConfig, flags: adapterFlags }), workspaceFolder),
     request: memberMode
   };
-  const descriptor = adapterId === "fake" ? createFakeDescriptor(options.script ?? (memberMode === "attach" ? "attach-stopped" : "stopped-on-entry"), memberMode) : new AdapterRegistry({ config: adapterConfig }).resolve(adapterId);
+  const descriptor = adapterId === "fake" ? createFakeDescriptor(options.script ?? (memberMode === "attach" ? "attach-stopped" : "stopped-on-entry"), memberMode) : await new AdapterRegistry({ config: adapterConfig }).resolve(adapterId);
   return { memberName, mode: memberMode, descriptor, config };
 }
 function getAdapterDefaults(adapterConfig, adapterId, mode) {
@@ -6704,6 +8154,12 @@ async function mapConfigForAdapter(adapterId, config, workspaceFolder) {
   if (adapterId === "debugpy") {
     return mapDebugpyFlags(config);
   }
+  if (adapterId === "delve") {
+    return normalizeGoLaunchConfigProgram(config, workspaceFolder);
+  }
+  if (adapterId === "codelldb") {
+    return validateCodeLldbNativeConfig(config);
+  }
   return config;
 }
 function setIfDefined(target, key, value) {
@@ -6727,7 +8183,7 @@ function createFakeDescriptor(script, mode) {
     transport: {
       kind: "stdio",
       command: process.execPath,
-      args: ["--experimental-strip-types", path13.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]
     }
   };
 }
@@ -6843,6 +8299,139 @@ function createNameParams2(name) {
   return name === void 0 ? {} : { name };
 }
 
+// src/cli/commands/setupAdapters.ts
+import path25 from "path";
+import { promises as fs18 } from "fs";
+import { Option } from "commander";
+var ALL_ADAPTERS = ["js-debug", "debugpy", "delve", "codelldb"];
+var ADAPTER_VERSIONS = {
+  "js-debug": JS_DEBUG_VERSION,
+  "debugpy": DEBUGPY_VERSION,
+  "delve": DELVE_VERSION,
+  "codelldb": CODELLDB_VERSION
+};
+function expectedEntrypoint(adaptersDir, id) {
+  switch (id) {
+    case "js-debug":
+      return path25.join(adaptersDir, "js-debug", "src", "dapDebugServer.js");
+    case "debugpy":
+      return path25.join(
+        adaptersDir,
+        "debugpy",
+        process.platform === "win32" ? path25.join("venv", "Scripts", "python.exe") : path25.join("venv", "bin", "python")
+      );
+    case "delve":
+      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 fs18.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isAdapterId(value) {
+  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 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 isRuntimeReady(adaptersDir, id);
+    if (!cached) {
+      pending.push(id);
+    }
+  }
+  if (pending.length > 0 && !opts.assumeYes) {
+    const pendingDescription = pending.map((id) => `${id} ${ADAPTER_VERSIONS[id]}`).join(", ");
+    await confirm({
+      assumeYes: false,
+      question: `Install ${pending.length} adapter${pending.length === 1 ? "" : "s"} (${pendingDescription}) into ${adaptersDir}/?`,
+      ...opts.stdin === void 0 ? {} : { stdin: opts.stdin },
+      ...opts.stderr === void 0 ? {} : { stderr: opts.stderr }
+    });
+  }
+  const innerCtxBase = {
+    env: opts.env,
+    adaptersDir,
+    ...opts.stdin === void 0 ? {} : { stdin: opts.stdin },
+    ...opts.stderr === void 0 ? {} : { stderr: opts.stderr }
+  };
+  const entries = [];
+  for (const id of targets) {
+    const version = ADAPTER_VERSIONS[id];
+    try {
+      const result = await provisionAdapter(id, { ...innerCtxBase, assumeYes: true });
+      const entry = {
+        id,
+        version: result.version,
+        status: result.fromCache ? "cached" : "installed",
+        installRoot: result.installRoot
+      };
+      entries.push(entry);
+      if (opts.output !== void 0) {
+        const verb = result.fromCache ? "already cached" : "installed";
+        opts.output.warn(`${id} ${result.version}: ${verb} (${result.installRoot})`);
+      }
+    } catch (err) {
+      const cliError = err instanceof CliError ? err : null;
+      const code = cliError?.code ?? "internal_error";
+      const message = err instanceof Error ? err.message : String(err);
+      entries.push({
+        id,
+        version,
+        status: "failed",
+        error: {
+          code,
+          message,
+          diagnostics: cliError?.diagnostics ?? [message]
+        }
+      });
+      if (opts.output !== void 0) {
+        opts.output.warn(`${id} ${version}: FAILED (${code})`);
+      }
+    }
+  }
+  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, 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);
+    const result = await runSetupAdaptersAction({
+      ...adapterId === void 0 ? {} : { adapter: adapterId },
+      assumeYes,
+      env: process.env,
+      stdin: process.stdin,
+      stderr: process.stderr,
+      stdout: process.stdout,
+      output
+    });
+    const failed = result.adapters.filter((a) => a.status === "failed");
+    if (failed.length > 0) {
+      const failedNames = failed.map((a) => `${a.id} (${a.error?.code ?? "internal_error"})`).join(", ");
+      throw usageError(`Adapter setup failed for: ${failedNames}`, {
+        code: "provision_setup_failed",
+        diagnostics: failed.flatMap((a) => a.error?.diagnostics ?? []),
+        data: { adapters: result.adapters }
+      });
+    }
+    output.success(result, { command: "setup-adapters" });
+  });
+}
+
 // src/cli/program.ts
 var require2 = createRequire(import.meta.url);
 function loadPackageJson() {
@@ -6867,12 +8456,19 @@ function createProgram(options = {}) {
     resolveMode: () => resolveOutputMode({ cliHuman: getProgramHumanOption(program), isStdoutTTY: stdout.isTTY === true, env: process.env })
   });
   program[PROGRAM_OUTPUT_WRITER] = output;
-  program.name("dap-cli").description("A Debug Adapter Protocol CLI for agents. Control debug sessions from shell commands.").version(getPackageVersion(packageJson)).option("--human", "render human-readable output (default when stdout is a TTY and DAP_CLI_HUMAN is set)").option("--no-human", "render machine-readable JSON output even if DAP_CLI_HUMAN is set or stdout is a TTY").showHelpAfterError().exitOverride();
+  program.name("dap-cli").description("A Debug Adapter Protocol CLI for agents. Control debug sessions from shell commands.").version(getPackageVersion(packageJson)).option("--human", "render human-readable output (default when stdout is a TTY and DAP_CLI_HUMAN is set)").option("--no-human", "render machine-readable JSON output even if DAP_CLI_HUMAN is set or stdout is a TTY").option("-y, --yes", "pre-consent to adapter provisioning prompts (equivalent to DAP_CLI_ASSUME_YES=1)").showHelpAfterError().exitOverride();
+  program.hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    if (opts.yes === true) {
+      process.env.DAP_CLI_ASSUME_YES = "1";
+    }
+  });
   registerControllerCommands(program, output);
   registerSessionCommands(program, output);
   registerDapCoreCommands(program, output);
   registerGeneratedDapCommands(program, output);
   registerDapAliasCommands(program, output);
+  registerSetupAdaptersCommand(program, output);
   program.helpCommand(false);
   program.command("help [command...]").description("Display help for a command. Pass multiple words to drill into subcommands (e.g. `dap-cli help breakpoints set`).").action((commandPath) => {
     const segments = Array.isArray(commandPath) ? commandPath : [];