debug-that 0.4.0 → 0.5.0

package/dist/main.js

@@ -1,6 +1,21 @@
 #!/usr/bin/env bun
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __export = (target, all) => {
   for (var name in all)
@@ -16827,6 +16842,196 @@ var init_session = __esm(() => {
   };
 });
 
+// src/dap/adapters/java/adapter-sources.tar.gz
+var require_adapter_sources_tar = __commonJS((exports, module) => {
+  module.exports = "./adapter-sources.tar-cnge9g7b.gz";
+});
+
+// src/dap/adapters/java.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { delimiter, join as join2 } from "path";
+var {$ } = globalThis.Bun;
+function getJavaAdapterDir() {
+  return join2(getManagedAdaptersDir(), "java");
+}
+function isJavaAdapterInstalled() {
+  const dir = getJavaAdapterDir();
+  const depsDir = join2(dir, "deps");
+  if (!existsSync2(join2(dir, "classes", "com", "debugthat", "adapter", "Main.class"))) {
+    return false;
+  }
+  return JAVA_DEP_NAMES.every((jar) => existsSync2(join2(depsDir, jar)));
+}
+function getJavaAdapterClasspath() {
+  const dir = getJavaAdapterDir();
+  const depsDir = join2(dir, "deps");
+  const classesDir = join2(dir, "classes");
+  const jars = JAVA_DEP_NAMES.map((jar) => join2(depsDir, jar));
+  return [classesDir, ...jars].join(delimiter);
+}
+async function extractAdapterSources(installDir) {
+  const devPackageDir = join2(import.meta.dir, "java", "com", "debugthat", "adapter");
+  if (existsSync2(devPackageDir)) {
+    return Array.from(new Bun.Glob("*.java").scanSync(devPackageDir)).map((f) => join2(devPackageDir, f));
+  }
+  const { default: tarballPath } = await Promise.resolve().then(() => __toESM(require_adapter_sources_tar(), 1));
+  const resolved = tarballPath.startsWith("/") ? tarballPath : join2(import.meta.dir, tarballPath);
+  const srcDir = join2(installDir, "src");
+  mkdirSync2(srcDir, { recursive: true });
+  await $`tar xzf ${resolved} -C ${srcDir}`;
+  const packageDir = join2(srcDir, "com", "debugthat", "adapter");
+  return Array.from(new Bun.Glob("*.java").scanSync(packageDir)).map((f) => join2(packageDir, f));
+}
+var MAVEN_CENTRAL = "https://repo1.maven.org/maven2", JAVA_DEPS, JAVA_DEP_NAMES, javaInstaller;
+var init_java = __esm(() => {
+  init_session2();
+  JAVA_DEPS = {
+    "com.microsoft.java.debug.core-0.53.0.jar": "com/microsoft/java/com.microsoft.java.debug.core/0.53.0/com.microsoft.java.debug.core-0.53.0.jar",
+    "commons-lang3-3.14.0.jar": "org/apache/commons/commons-lang3/3.14.0/commons-lang3-3.14.0.jar",
+    "gson-2.10.1.jar": "com/google/code/gson/gson/2.10.1/gson-2.10.1.jar",
+    "rxjava-2.2.21.jar": "io/reactivex/rxjava2/rxjava/2.2.21/rxjava-2.2.21.jar",
+    "reactive-streams-1.0.4.jar": "org/reactivestreams/reactive-streams/1.0.4/reactive-streams-1.0.4.jar",
+    "commons-io-2.15.1.jar": "commons-io/commons-io/2.15.1/commons-io-2.15.1.jar"
+  };
+  JAVA_DEP_NAMES = Object.keys(JAVA_DEPS);
+  javaInstaller = {
+    name: "java (java-debug.core)",
+    isInstalled: isJavaAdapterInstalled,
+    async install(log) {
+      const javaVersionResult = await $`java -version`.quiet().nothrow();
+      const stderr = javaVersionResult.stderr.toString().trim();
+      const versionMatch = stderr.match(/version "(\d+)/);
+      const version2 = versionMatch?.[1] ? parseInt(versionMatch[1], 10) : 0;
+      if (version2 < 11) {
+        throw new Error(`Java 11+ required (found: ${stderr.split(`
+`)[0]?.trim() ?? "none"})`);
+      }
+      const dir = getJavaAdapterDir();
+      const depsDir = join2(dir, "deps");
+      mkdirSync2(depsDir, { recursive: true });
+      for (const [jarName, mavenPath] of Object.entries(JAVA_DEPS)) {
+        const jarPath = join2(depsDir, jarName);
+        if (!existsSync2(jarPath)) {
+          log(`  Downloading ${jarName}...`);
+          const response = await fetch(`${MAVEN_CENTRAL}/${mavenPath}`, {
+            redirect: "follow"
+          });
+          if (!response.ok) {
+            throw new Error(`Failed to download ${jarName}: HTTP ${response.status}`);
+          }
+          await Bun.write(jarPath, response);
+        }
+      }
+      log("  Compiling adapter...");
+      const cp = JAVA_DEP_NAMES.map((jar) => join2(depsDir, jar)).join(delimiter);
+      const classesDir = join2(dir, "classes");
+      mkdirSync2(classesDir, { recursive: true });
+      const sourceFiles = await extractAdapterSources(dir);
+      await $`javac -d ${classesDir} -cp ${cp} -source 11 -target 11 ${sourceFiles}`;
+      log("  Adapter compiled.");
+    }
+  };
+});
+
+// src/dap/adapters/lldb.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3 } from "fs";
+import { join as join3 } from "path";
+var {$: $2 } = globalThis.Bun;
+function getLlvmDownloadUrl(version2, os, arch) {
+  const platforms = {
+    darwin: {
+      arm64: `LLVM-${version2}-macOS-ARM64.tar.xz`,
+      x64: `LLVM-${version2}-macOS-X64.tar.xz`
+    },
+    linux: {
+      x64: `LLVM-${version2}-Linux-X64.tar.xz`,
+      arm64: `LLVM-${version2}-Linux-AArch64.tar.xz`
+    }
+  };
+  const filename = platforms[os]?.[arch];
+  if (!filename)
+    return null;
+  return `https://github.com/llvm/llvm-project/releases/download/llvmorg-${version2}/${filename}`;
+}
+function getTargetPath() {
+  return join3(getManagedAdaptersDir(), "lldb-dap");
+}
+var LLVM_VERSION = "19.1.7", lldbInstaller;
+var init_lldb = __esm(() => {
+  init_session2();
+  lldbInstaller = {
+    name: "lldb-dap",
+    isInstalled() {
+      return existsSync3(getTargetPath());
+    },
+    async install(log) {
+      const os = process.platform;
+      const arch = process.arch;
+      const url2 = getLlvmDownloadUrl(LLVM_VERSION, os, arch);
+      if (!url2) {
+        throw new Error(`Unsupported platform: ${os}-${arch}
+  Supported: darwin-arm64, darwin-x64, linux-x64, linux-arm64`);
+      }
+      const adaptersDir = getManagedAdaptersDir();
+      const targetPath = getTargetPath();
+      log(`Downloading LLVM ${LLVM_VERSION} for ${os}-${arch}...`);
+      const response = await fetch(url2, { redirect: "follow" });
+      if (!response.ok) {
+        throw new Error(`Download failed: HTTP ${response.status}
+  -> Check your internet connection or try again later`);
+      }
+      const tarball = await response.arrayBuffer();
+      log(`Downloaded ${(tarball.byteLength / 1024 / 1024).toFixed(1)} MB`);
+      mkdirSync3(adaptersDir, { recursive: true });
+      const tmpTar = join3(adaptersDir, "llvm-download.tar.xz");
+      await Bun.write(tmpTar, tarball);
+      try {
+        log("Extracting lldb-dap...");
+        const files = (await $2`tar -tf ${tmpTar}`.text()).split(`
+`);
+        const lldbDapEntry = files.find((f) => f.endsWith("/bin/lldb-dap") || f === "bin/lldb-dap");
+        if (!lldbDapEntry) {
+          throw new Error(`Could not find lldb-dap in the LLVM archive (${files.length} entries)
+  -> Try installing manually: brew install llvm`);
+        }
+        const stripComponents = String(lldbDapEntry.split("/").length - 1);
+        await $2`tar -xf ${tmpTar} -C ${adaptersDir} --strip-components ${stripComponents} ${lldbDapEntry}`;
+        const liblldbEntries = files.filter((f) => f.includes("liblldb") && (f.endsWith(".so") || f.endsWith(".dylib")));
+        for (const libEntry of liblldbEntries) {
+          const libStrip = String(libEntry.split("/").length - 1);
+          await $2`tar -xf ${tmpTar} -C ${adaptersDir} --strip-components ${libStrip} ${libEntry}`.quiet();
+        }
+      } finally {
+        await $2`rm -f ${tmpTar}`.quiet();
+      }
+      await $2`chmod +x ${targetPath}`;
+      if (!existsSync3(targetPath)) {
+        throw new Error(`lldb-dap not found after extraction
+  -> Try installing manually: brew install llvm`);
+      }
+      log(`Installed lldb-dap to ${targetPath}`);
+    }
+  };
+});
+
+// src/dap/adapters/index.ts
+function getAdapterInstaller(name) {
+  return ADAPTERS[name];
+}
+function listAdapterNames() {
+  return Object.keys(ADAPTERS);
+}
+var ADAPTERS;
+var init_adapters2 = __esm(() => {
+  init_java();
+  init_lldb();
+  init_java();
+  ADAPTERS = {
+    lldb: lldbInstaller,
+    java: javaInstaller
+  };
+});
+
 // src/dap/client.ts
 class DapClient {
   proc;
@@ -17024,49 +17229,102 @@ class DapClient {
 var init_client2 = () => {};
 
 // src/dap/session.ts
-import { existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
 function getManagedAdaptersDir() {
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "/tmp";
-  return join2(home, ".debug-that", "adapters");
-}
-function resolveAdapterCommand(runtime) {
-  switch (runtime) {
-    case "lldb":
-    case "lldb-dap": {
-      const managedPath = join2(getManagedAdaptersDir(), "lldb-dap");
-      if (existsSync2(managedPath)) {
+  return join4(home, ".debug-that", "adapters");
+}
+function getRuntimeConfig(runtime) {
+  return RUNTIME_CONFIGS[runtime] ?? {
+    resolveCommand: () => [runtime],
+    buildLaunchArgs: DEFAULT_LAUNCH
+  };
+}
+var DEFAULT_LAUNCH = (program, programArgs, cwd) => ({
+  program,
+  args: programArgs,
+  cwd
+}), lldbConfig, debugpyConfig, javaConfig, RUNTIME_CONFIGS, DapSession;
+var init_session2 = __esm(() => {
+  init_base_session();
+  init_adapters2();
+  init_client2();
+  lldbConfig = {
+    resolveCommand() {
+      const managedPath = join4(getManagedAdaptersDir(), "lldb-dap");
+      if (existsSync4(managedPath))
         return [managedPath];
-      }
-      const whichResult = Bun.spawnSync(["which", "lldb-dap"]);
-      if (whichResult.exitCode === 0) {
+      if (Bun.which("lldb-dap"))
         return ["lldb-dap"];
-      }
       const brewPath = "/opt/homebrew/opt/llvm/bin/lldb-dap";
-      if (existsSync2(brewPath)) {
+      if (existsSync4(brewPath))
         return [brewPath];
-      }
       return ["lldb-dap"];
-    }
-    case "codelldb":
-      return ["codelldb", "--port", "0"];
-    case "python":
-    case "debugpy": {
-      const py3 = Bun.spawnSync(["which", "python3"]);
-      const pyBin = py3.exitCode === 0 ? "python3" : "python";
+    },
+    buildLaunchArgs: DEFAULT_LAUNCH
+  };
+  debugpyConfig = {
+    resolveCommand() {
+      const pyBin = Bun.which("python3") ? "python3" : "python";
       return [pyBin, "-m", "debugpy.adapter"];
+    },
+    buildLaunchArgs: (program, programArgs, cwd) => ({
+      program,
+      args: programArgs,
+      cwd,
+      console: "internalConsole",
+      justMyCode: false
+    })
+  };
+  javaConfig = {
+    resolveCommand() {
+      if (!isJavaAdapterInstalled()) {
+        throw new Error("Java debug adapter not installed. Run `dbg install java` first.");
+      }
+      const cp = getJavaAdapterClasspath();
+      return ["java", "-cp", cp, "com.debugthat.adapter.Main"];
+    },
+    buildLaunchArgs(program, programArgs, _cwd) {
+      const basename = program.split("/").pop() ?? program;
+      const mainClass = basename.replace(/\.(java|class)$/, "");
+      const programDir = program.includes("/") ? program.substring(0, program.lastIndexOf("/")) : _cwd;
+      return {
+        mainClass,
+        classPaths: [programDir],
+        cwd: programDir,
+        sourcePaths: [programDir],
+        stopOnEntry: true,
+        ...programArgs.length > 0 ? { args: programArgs.join(" ") } : {}
+      };
+    },
+    parseAttachTarget(target) {
+      const colonIdx = target.lastIndexOf(":");
+      if (colonIdx > 0) {
+        return {
+          hostName: target.substring(0, colonIdx),
+          port: parseInt(target.substring(colonIdx + 1), 10)
+        };
+      }
+      const port = parseInt(target, 10);
+      return { hostName: "localhost", port: Number.isNaN(port) ? 5005 : port };
     }
-    default:
-      return [runtime];
-  }
-}
-var DapSession;
-var init_session2 = __esm(() => {
-  init_base_session();
-  init_client2();
+  };
+  RUNTIME_CONFIGS = {
+    lldb: lldbConfig,
+    "lldb-dap": lldbConfig,
+    codelldb: {
+      resolveCommand: () => ["codelldb", "--port", "0"],
+      buildLaunchArgs: DEFAULT_LAUNCH
+    },
+    python: debugpyConfig,
+    debugpy: debugpyConfig,
+    java: javaConfig
+  };
   DapSession = class DapSession extends BaseSession {
     dap = null;
     _runtime;
+    _isAttached = false;
     _threadId = 1;
     _stackFrames = [];
     adapterCapabilities = {};
@@ -17109,17 +17367,16 @@ var init_session2 = __esm(() => {
       if (this.state !== "idle") {
         throw new Error("Session already has an active debug target");
       }
-      const adapterCmd = resolveAdapterCommand(this._runtime);
+      const config2 = getRuntimeConfig(this._runtime);
+      const adapterCmd = config2.resolveCommand();
       this.dap = DapClient.spawn(adapterCmd);
       this.setupEventHandlers();
       await this.initializeAdapter();
-      const program = options.program ?? command[0];
+      const program = options.program ?? command[0] ?? "";
       const programArgs = options.args ?? command.slice(1);
       const launchArgs = {
-        program,
-        args: programArgs,
         stopOnEntry: options.brk ?? true,
-        cwd: process.cwd()
+        ...config2.buildLaunchArgs(program, programArgs, process.cwd())
       };
       if (this._remaps.length > 0) {
         launchArgs.sourceMap = this._remaps.map(([from, to]) => [from, to]);
@@ -17127,10 +17384,6 @@ var init_session2 = __esm(() => {
       if (this._symbolPaths.length > 0) {
         launchArgs.preRunCommands = this._symbolPaths.map((p) => `add-dsym ${p}`);
       }
-      if (this._runtime === "python" || this._runtime === "debugpy") {
-        launchArgs.console = "internalConsole";
-        launchArgs.justMyCode = false;
-      }
       const launchPromise = this.dap.send("launch", launchArgs);
       await this.waitForInitialized();
       await this.dap.send("configurationDone");
@@ -17160,12 +17413,19 @@ ${detail}` : "Target exited without stopping (stopOnEntry had no effect)";
       if (this.state !== "idle") {
         throw new Error("Session already has an active debug target");
       }
-      const adapterCmd = resolveAdapterCommand(this._runtime);
+      this._isAttached = true;
+      const config2 = getRuntimeConfig(this._runtime);
+      const adapterCmd = config2.resolveCommand();
       this.dap = DapClient.spawn(adapterCmd);
       this.setupEventHandlers();
       await this.initializeAdapter();
-      const pid = parseInt(target, 10);
-      const attachArgs = Number.isNaN(pid) ? { program: target, waitFor: true } : { pid };
+      let attachArgs;
+      if (config2.parseAttachTarget) {
+        attachArgs = config2.parseAttachTarget(target);
+      } else {
+        const pid = parseInt(target, 10);
+        attachArgs = Number.isNaN(pid) ? { program: target, waitFor: true } : { pid };
+      }
       const attachPromise = this.dap.send("attach", attachArgs);
       await this.waitForInitialized();
       await this.dap.send("configurationDone");
@@ -17190,13 +17450,14 @@ ${detail}` : "Target exited without stopping (stopOnEntry had no effect)";
     async stop() {
       if (this.dap) {
         try {
-          await this.dap.send("disconnect", { terminateDebuggee: true });
+          await this.dap.send("disconnect", { terminateDebuggee: !this._isAttached });
         } catch {}
         this.dap.disconnect();
         this.dap = null;
       }
       this.resetState();
       this._stackFrames = [];
+      this._isAttached = false;
       this.breakpoints.clear();
       this.allBreakpoints = [];
       this.functionBreakpoints = [];
@@ -17930,7 +18191,7 @@ var DAP_RUNTIMES;
 var init_factory = __esm(() => {
   init_session();
   init_session2();
-  DAP_RUNTIMES = new Set(["lldb", "lldb-dap", "codelldb", "python", "debugpy"]);
+  DAP_RUNTIMES = new Set(["lldb", "lldb-dap", "codelldb", "python", "debugpy", "java"]);
 });
 
 // src/daemon/eval-suggestions.ts
@@ -17979,7 +18240,7 @@ function extractLines(buffer) {
 }
 
 // src/daemon/server.ts
-import { existsSync as existsSync3, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync5, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
 
 class DaemonServer {
   session;
@@ -18002,14 +18263,14 @@ class DaemonServer {
   }
   async start() {
     ensureSocketDir();
-    if (existsSync3(this.lockPath)) {
+    if (existsSync5(this.lockPath)) {
       const existingPid = parseInt(await Bun.file(this.lockPath).text(), 10);
       if (!Number.isNaN(existingPid) && isProcessRunning(existingPid)) {
         throw new Error(`Daemon already running for session "${this.session}" (pid ${existingPid})`);
       }
       unlinkSync(this.lockPath);
     }
-    if (existsSync3(this.socketPath)) {
+    if (existsSync5(this.socketPath)) {
       unlinkSync(this.socketPath);
     }
     writeFileSync3(this.lockPath, String(process.pid));
@@ -18135,10 +18396,10 @@ class DaemonServer {
       this.listener.stop(true);
       this.listener = null;
     }
-    if (existsSync3(this.socketPath)) {
+    if (existsSync5(this.socketPath)) {
       unlinkSync(this.socketPath);
     }
-    if (existsSync3(this.lockPath)) {
+    if (existsSync5(this.lockPath)) {
       unlinkSync(this.lockPath);
     }
   }
@@ -20883,7 +21144,7 @@ var init_command = __esm(() => {
 });
 
 // src/daemon/client.ts
-import { existsSync as existsSync4, readdirSync, readFileSync, unlinkSync as unlinkSync2 } from "fs";
+import { existsSync as existsSync6, readdirSync, readFileSync, unlinkSync as unlinkSync2 } from "fs";
 
 class DaemonClient {
   session;
@@ -20963,11 +21224,11 @@ class DaemonClient {
   }
   static isRunning(session2) {
     const socketPath = getSocketPath(session2);
-    if (!existsSync4(socketPath)) {
+    if (!existsSync6(socketPath)) {
       return false;
     }
     const lockPath = getLockPath(session2);
-    if (!existsSync4(lockPath)) {
+    if (!existsSync6(lockPath)) {
       return false;
     }
     try {
@@ -20983,14 +21244,14 @@ class DaemonClient {
   static cleanStaleFiles(session2) {
     const socketPath = getSocketPath(session2);
     const lockPath = getLockPath(session2);
-    if (existsSync4(socketPath))
+    if (existsSync6(socketPath))
       unlinkSync2(socketPath);
-    if (existsSync4(lockPath))
+    if (existsSync6(lockPath))
       unlinkSync2(lockPath);
   }
   static async isAlive(session2) {
     const socketPath = getSocketPath(session2);
-    if (!existsSync4(socketPath)) {
+    if (!existsSync6(socketPath)) {
       return false;
     }
     try {
@@ -21003,7 +21264,7 @@ class DaemonClient {
   }
   static listSessions() {
     const dir = getSocketDir();
-    if (!existsSync4(dir)) {
+    if (!existsSync6(dir)) {
       return [];
     }
     const files = readdirSync(dir);
@@ -21032,7 +21293,7 @@ var init_client3 = __esm(() => {
 });
 
 // src/daemon/spawn.ts
-import { closeSync, existsSync as existsSync5, openSync, readFileSync as readFileSync2 } from "fs";
+import { closeSync, existsSync as existsSync7, openSync, readFileSync as readFileSync2 } from "fs";
 async function spawnDaemon(session2, options = {}) {
   const socketPath = getSocketPath(session2);
   const spawnArgs = [];
@@ -21059,7 +21320,7 @@ async function spawnDaemon(session2, options = {}) {
   proc.unref();
   const deadline = Date.now() + SPAWN_TIMEOUT_MS;
   while (Date.now() < deadline) {
-    if (existsSync5(socketPath)) {
+    if (existsSync7(socketPath)) {
       return;
     }
     await Bun.sleep(SPAWN_POLL_INTERVAL_MS);
@@ -21171,6 +21432,10 @@ var init_detect_runtime = __esm(() => {
       pattern: /^(uvicorn|gunicorn|flask|django-admin|pytest|mypy)$/,
       entry: { runtime: "debugpy", stripInterpreter: false }
     },
+    {
+      pattern: /^(mvn|mvnw|gradle|gradlew|mvnDebug)$/,
+      entry: { runtime: "java", stripInterpreter: false }
+    },
     { pattern: /^(rails|rake|rspec|irb)$/, entry: { runtime: "ruby", stripInterpreter: false } },
     { pattern: /^(iex|mix)$/, entry: { runtime: "elixir", stripInterpreter: false } }
   ];
@@ -23473,36 +23738,11 @@ var init_symbols = __esm(() => {
 });
 
 // src/commands/install.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync2 } from "fs";
-import { join as join3 } from "path";
-function getPlatformArch() {
-  const os = process.platform;
-  const arch = process.arch;
-  return { os, arch };
-}
-function getLlvmDownloadUrl(version2, os, arch) {
-  if (os === "darwin") {
-    if (arch === "arm64") {
-      return `https://github.com/llvm/llvm-project/releases/download/llvmorg-${version2}/LLVM-${version2}-macOS-ARM64.tar.xz`;
-    }
-    if (arch === "x64") {
-      return `https://github.com/llvm/llvm-project/releases/download/llvmorg-${version2}/LLVM-${version2}-macOS-X64.tar.xz`;
-    }
-  }
-  if (os === "linux") {
-    if (arch === "x64") {
-      return `https://github.com/llvm/llvm-project/releases/download/llvmorg-${version2}/LLVM-${version2}-Linux-X64.tar.xz`;
-    }
-    if (arch === "arm64") {
-      return `https://github.com/llvm/llvm-project/releases/download/llvmorg-${version2}/LLVM-${version2}-Linux-AArch64.tar.xz`;
-    }
-  }
-  return null;
-}
-var LLVM_VERSION = "19.1.7";
+import { existsSync as existsSync8 } from "fs";
 var init_install = __esm(() => {
   init_zod();
   init_command();
+  init_adapters2();
   init_session2();
   defineCommand({
     name: "install",
@@ -23516,10 +23756,11 @@ var init_install = __esm(() => {
     }),
     handler: async (ctx) => {
       const adapter = ctx.positional || undefined;
+      const supported = listAdapterNames();
       if (ctx.flags.list) {
         const dir = getManagedAdaptersDir();
         console.log(`Managed adapters directory: ${dir}`);
-        if (!existsSync6(dir)) {
+        if (!existsSync8(dir)) {
           console.log("  (empty \u2014 no adapters installed)");
           return 0;
         }
@@ -23535,92 +23776,30 @@ var init_install = __esm(() => {
       }
       if (!adapter) {
         console.error("Usage: dbg install <adapter>");
-        console.error("  Supported adapters: lldb");
+        console.error(`  Supported adapters: ${supported.join(", ")}`);
         console.error("  Options: --list (show installed adapters)");
         return 1;
       }
-      if (adapter !== "lldb") {
+      const installer = getAdapterInstaller(adapter);
+      if (!installer) {
         console.error(`Unknown adapter: ${adapter}`);
-        console.error("  Supported adapters: lldb");
-        return 1;
-      }
-      const { os, arch } = getPlatformArch();
-      const url3 = getLlvmDownloadUrl(LLVM_VERSION, os, arch);
-      if (!url3) {
-        console.error(`Unsupported platform: ${os}-${arch}`);
-        console.error("  Supported: darwin-arm64, darwin-x64, linux-x64, linux-arm64");
+        console.error(`  Supported adapters: ${supported.join(", ")}`);
         return 1;
       }
-      const adaptersDir = getManagedAdaptersDir();
-      const targetPath = join3(adaptersDir, "lldb-dap");
-      if (existsSync6(targetPath)) {
-        console.log(`lldb-dap already installed at ${targetPath}`);
-        console.log(`  To reinstall, remove it first: rm ${targetPath}`);
+      if (installer.isInstalled()) {
+        console.log(`${installer.name} is already installed.`);
+        console.log("  To reinstall, remove ~/.debug-that/adapters/ entry first.");
         return 0;
       }
-      console.log(`Downloading LLVM ${LLVM_VERSION} for ${os}-${arch}...`);
-      console.log(`  From: ${url3}`);
-      const response = await fetch(url3, { redirect: "follow" });
-      if (!response.ok) {
-        console.error(`Download failed: HTTP ${response.status}`);
-        console.error("  -> Check your internet connection or try again later");
-        return 1;
-      }
-      const tarball = await response.arrayBuffer();
-      console.log(`Downloaded ${(tarball.byteLength / 1024 / 1024).toFixed(1)} MB`);
-      mkdirSync2(adaptersDir, { recursive: true });
-      const tmpTar = join3(adaptersDir, "llvm-download.tar.xz");
-      await Bun.write(tmpTar, tarball);
-      console.log("Extracting lldb-dap...");
-      const listResult = Bun.spawnSync(["tar", "-tf", tmpTar], {
-        stdout: "pipe"
-      });
-      const files = listResult.stdout.toString().split(`
-`);
-      const lldbDapEntry = files.find((f) => f.endsWith("/bin/lldb-dap") || f === "bin/lldb-dap");
-      if (!lldbDapEntry) {
-        Bun.spawnSync(["rm", tmpTar]);
-        console.error("Could not find lldb-dap in the LLVM archive");
-        console.error(`  Archive entries searched: ${files.length}`);
-        console.error("  -> Try installing manually: brew install llvm");
-        return 1;
-      }
-      const extractResult = Bun.spawnSync([
-        "tar",
-        "-xf",
-        tmpTar,
-        "-C",
-        adaptersDir,
-        "--strip-components",
-        String(lldbDapEntry.split("/").length - 1),
-        lldbDapEntry
-      ], { stdout: "pipe", stderr: "pipe" });
-      Bun.spawnSync(["rm", tmpTar]);
-      if (extractResult.exitCode !== 0) {
-        console.error(`Extraction failed: ${extractResult.stderr.toString()}`);
-        return 1;
-      }
-      const liblldbEntries = files.filter((f) => f.includes("liblldb") && (f.endsWith(".so") || f.endsWith(".dylib")));
-      for (const libEntry of liblldbEntries) {
-        Bun.spawnSync([
-          "tar",
-          "-xf",
-          tmpTar,
-          "-C",
-          adaptersDir,
-          "--strip-components",
-          String(libEntry.split("/").length - 1),
-          libEntry
-        ], { stdout: "pipe", stderr: "pipe" });
-      }
-      Bun.spawnSync(["chmod", "+x", targetPath]);
-      if (existsSync6(targetPath)) {
-        console.log(`Installed lldb-dap to ${targetPath}`);
+      try {
+        console.log(`Installing ${installer.name}...`);
+        await installer.install((msg) => console.log(msg));
+        console.log(`${installer.name} installed successfully.`);
         return 0;
+      } catch (e) {
+        console.error(`Installation failed: ${e.message}`);
+        return 1;
       }
-      console.error("Installation failed \u2014 lldb-dap not found after extraction");
-      console.error("  -> Try installing manually: brew install llvm");
-      return 1;
     }
   });
 });
@@ -23742,7 +23921,7 @@ var init_logs = __esm(() => {
 // src/commands/logs.ts
 import {
   closeSync as closeSync2,
-  existsSync as existsSync7,
+  existsSync as existsSync9,
   openSync as openSync2,
   readFileSync as readFileSync3,
   readSync,
@@ -23822,7 +24001,7 @@ var init_logs2 = __esm(() => {
       const isDaemon = ctx.flags.daemon || false;
       const logPath = isDaemon ? getDaemonLogPath(session2) : getLogPath(session2);
       if (ctx.flags.clear) {
-        if (existsSync7(logPath)) {
+        if (existsSync9(logPath)) {
           writeFileSync4(logPath, "");
           console.log(`${isDaemon ? "Daemon log" : "Log"} cleared`);
         } else {
@@ -23830,7 +24009,7 @@ var init_logs2 = __esm(() => {
         }
         return 0;
       }
-      if (!existsSync7(logPath)) {
+      if (!existsSync9(logPath)) {
         console.error(`No ${isDaemon ? "daemon " : ""}log file for session "${session2}"`);
         console.error("  -> Try: dbg launch --brk node app.js");
         return 1;
@@ -24168,7 +24347,7 @@ var init_help = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "debug-that",
-    version: "0.4.0",
+    version: "0.5.0",
     description: "Universal Debugger CLI for AI Agents",
     license: "MIT",
     author: "Theodo Group",
@@ -24200,7 +24379,7 @@ var require_package = __commonJS((exports, module) => {
     ],
     scripts: {
       dev: "bun run src/main.ts",
-      build: "bun build src/main.ts --outdir dist --target=bun",
+      build: "bun run build.ts",
       test: "bun test tests/unit/ && bun test --concurrent tests/integration/",
       lint: "biome check .",
       format: "biome check --write .",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "debug-that",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Universal Debugger CLI for AI Agents",
   "license": "MIT",
   "author": "Theodo Group",
@@ -32,7 +32,7 @@
   ],
   "scripts": {
     "dev": "bun run src/main.ts",
-    "build": "bun build src/main.ts --outdir dist --target=bun",
+    "build": "bun run build.ts",
     "test": "bun test tests/unit/ && bun test --concurrent tests/integration/",
     "lint": "biome check .",
     "format": "biome check --write .",
@@ -54,4 +54,4 @@
     "zod": "^4.0.0"
   },
   "module": "index.ts"
-}
+}