@vibecontrols/agent 2026.601.30

package/dist/postinstall-shim-fix.cjs

@@ -0,0 +1,382 @@
+#!/usr/bin/env node
+/**
+ * postinstall self-heal for @vibecontrols/agent.
+ *
+ * The `curl | bash` install path uses `bun add -g`, which symlinks
+ * ~/.bun/bin/vibe into bun's global node_modules. If that target is
+ * later wiped (manual rm, vibe nuke fallback, partial bun remove), the
+ * symlink dangles. Because ~/.bun/bin precedes nvm/npm bin in $PATH,
+ * `vibe` invocations hit ENOENT instead of falling through to a parallel
+ * `npm install -g` install.
+ *
+ * Worse: bash caches resolved binaries in its in-process hash table on
+ * first successful exec. Once cached, bash skips PATH lookup entirely
+ * for that name. So even after the dangling symlink is removed, every
+ * existing shell that previously ran `vibe` continues to try the dead
+ * path until the user runs `hash -r` or opens a new terminal.
+ *
+ * Strategy:
+ *   - Walk ~/.bun/bin/ for symlinks whose readlink target points into
+ *     ~/.bun/install/global/node_modules/@vibecontrols/.
+ *   - If target is alive, leave it (a working bun-global install).
+ *   - If target is dead AND the shim name matches one we ship (`vibe`),
+ *     REBIND it to this package's dist/cli.js — that keeps cached bash
+ *     hash entries pointed at the same path while making them work.
+ *   - Other dead vibecontrols-scoped shims get unlinked.
+ *
+ * Scoped strictly to @vibecontrols/* targets — never touches unrelated
+ * tools' shims. Best-effort throughout: any error is swallowed so a
+ * cleanup hiccup never breaks `npm install -g`.
+ */
+
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const OWNED_BIN_NAMES = new Set(["vibe"]);
+
+// Cross-package-manager hygiene: a host can have prior `vibe` shims sitting
+// in a node-version-manager bin (nvm/fnm/volta), in the npm global bin, or
+// in /usr/local/bin from an older install. When the user reinstalls via a
+// different package manager (e.g. curl|bash → bun), those older shims may
+// outrank the new one in PATH and/or be cached in the shell's hash table,
+// causing `vibe` to ENOENT against a stale path. We scan a fixed set of
+// well-known bin directories and prune any *dangling* `vibe` shim. Live
+// shims (real installs of the package) are never touched.
+function candidateExternalBins() {
+  const home = os.homedir();
+  const bins = new Set();
+  const isWin = process.platform === "win32";
+  if (isWin) {
+    if (process.env.APPDATA) bins.add(path.join(process.env.APPDATA, "npm"));
+    if (process.env.USERPROFILE) {
+      bins.add(path.join(process.env.USERPROFILE, "AppData", "Roaming", "npm"));
+      bins.add(
+        path.join(process.env.USERPROFILE, "AppData", "Local", "Volta", "bin"),
+      );
+    }
+    if (process.env.ProgramFiles)
+      bins.add(path.join(process.env.ProgramFiles, "nodejs"));
+  } else {
+    bins.add(path.join(home, ".local", "bin"));
+    bins.add("/usr/local/bin");
+    bins.add("/opt/homebrew/bin");
+    bins.add(path.join(home, ".volta", "bin"));
+    // nvm + fnm — enumerate installed node versions.
+    const nvmRoot = path.join(home, ".nvm", "versions", "node");
+    try {
+      for (const v of fs.readdirSync(nvmRoot)) {
+        bins.add(path.join(nvmRoot, v, "bin"));
+      }
+    } catch {
+      /* no nvm */
+    }
+    const fnmRoot = path.join(home, ".fnm", "node-versions");
+    try {
+      for (const v of fs.readdirSync(fnmRoot)) {
+        bins.add(path.join(fnmRoot, v, "installation", "bin"));
+      }
+    } catch {
+      /* no fnm */
+    }
+  }
+  return [...bins];
+}
+
+function pruneStaleExternalShims() {
+  const names =
+    process.platform === "win32" ? ["vibe", "vibe.cmd", "vibe.ps1"] : ["vibe"];
+  for (const dir of candidateExternalBins()) {
+    if (!fs.existsSync(dir)) continue;
+    for (const name of names) {
+      const p = path.join(dir, name);
+      let st;
+      try {
+        st = fs.lstatSync(p);
+      } catch {
+        continue;
+      }
+      // Unix: only prune symlinks (real files might be valid wrappers from
+      // another live install). Dangling symlinks are unambiguous garbage.
+      if (st.isSymbolicLink()) {
+        let target;
+        try {
+          target = fs.readlinkSync(p);
+        } catch {
+          continue;
+        }
+        const abs = path.isAbsolute(target)
+          ? target
+          : path.resolve(dir, target);
+        try {
+          fs.statSync(abs);
+          continue; // live — leave it
+        } catch {
+          /* dangling */
+        }
+        try {
+          fs.unlinkSync(p);
+          console.log(`[@vibecontrols/agent] pruned stale shim: ${p}`);
+        } catch {
+          /* best-effort */
+        }
+      }
+    }
+  }
+}
+
+// Peer deps every vibe-plugin-* package marks `--external` at build time and
+// expects to resolve from the host. Without these symlinks at the npm-global
+// root, plugins installed at `<npm-global>/@vibecontrols/<plugin>/` fail to
+// resolve `import 'elysia'` (etc.) because Node's walk-up-the-tree search
+// can't see the agent's nested copy at
+// `<npm-global>/@vibecontrols/agent/node_modules/elysia/`.
+//
+// Ones we link MUST be:
+//   - present in the agent's own node_modules after a successful npm-global
+//     install (we don't fabricate them; if missing, we skip),
+//   - widely-shared peer deps that change rarely (so a single shared copy
+//     doesn't trigger version-skew issues across plugins),
+//   - listed as peerDependencies in actual plugin packages.
+//
+// Restricting to this allowlist (rather than mirroring every dep of the
+// agent) keeps the symlink set small and predictable. Add to it only when
+// a new plugin's --external flag exposes a new gap.
+const SHARED_PEER_DEPS = ["elysia", "commander"];
+
+function main() {
+  const home = os.homedir();
+  const bunBin = path.join(home, ".bun", "bin");
+  const vibeGlobalRoot = path.join(
+    home,
+    ".bun",
+    "install",
+    "global",
+    "node_modules",
+    "@vibecontrols",
+  );
+
+  if (!fs.existsSync(bunBin)) return;
+
+  // process.cwd() during npm postinstall is the installed package root.
+  const agentRoot = process.cwd();
+  const ourCli = path.join(agentRoot, "dist", "cli.js");
+  const ourCliExists = fs.existsSync(ourCli);
+
+  // Step 0: expose the agent's nested peer deps at the npm-global root so
+  // sibling plugin packages can resolve their `import 'elysia'` etc.
+  // Walks two levels up from the agent's package dir to the root that
+  // contains all installed packages (npm-global) and symlinks the agent's
+  // own dependency copy. No-op if either source missing or target already
+  // present.
+  try {
+    const agentNodeModules = path.join(agentRoot, "node_modules");
+    const npmGlobalRoot = path.dirname(path.dirname(agentRoot));
+    if (
+      fs.existsSync(agentNodeModules) &&
+      fs.existsSync(npmGlobalRoot) &&
+      path.basename(path.dirname(agentRoot)) === "@vibecontrols"
+    ) {
+      for (const dep of SHARED_PEER_DEPS) {
+        const src = path.join(agentNodeModules, dep);
+        const dst = path.join(npmGlobalRoot, dep);
+        if (!fs.existsSync(src)) continue;
+        let dstStat = null;
+        try {
+          dstStat = fs.lstatSync(dst);
+        } catch {
+          /* missing — will create */
+        }
+        if (dstStat) {
+          // Already present (real install or our prior symlink). If it's our
+          // own stale symlink to a now-missing src, replace; otherwise leave.
+          if (dstStat.isSymbolicLink()) {
+            try {
+              const link = fs.readlinkSync(dst);
+              const linkAbs = path.isAbsolute(link)
+                ? link
+                : path.resolve(npmGlobalRoot, link);
+              if (linkAbs === src) continue; // already pointing at us
+              try {
+                fs.statSync(linkAbs);
+                continue; // points elsewhere but valid — don't clobber
+              } catch {
+                // dangling symlink — replace
+                fs.unlinkSync(dst);
+              }
+            } catch {
+              continue;
+            }
+          } else {
+            // Real install (or directory) — never clobber.
+            continue;
+          }
+        }
+        try {
+          fs.symlinkSync(src, dst);
+          console.log(
+            `[@vibecontrols/agent] linked shared peer dep ${dep} at ${dst}`,
+          );
+        } catch (err) {
+          // best-effort; symlink can fail on Windows without admin/dev mode,
+          // or on filesystems that disallow symlinks. Plugins that depend on
+          // these peer deps will still fail to load — surface the reason.
+          console.log(
+            `[@vibecontrols/agent] could not link ${dep}: ${err.message}`,
+          );
+        }
+      }
+    }
+  } catch {
+    /* never fail the install on a peer-dep linking hiccup */
+  }
+
+  let entries;
+  try {
+    entries = fs.readdirSync(bunBin);
+  } catch {
+    return;
+  }
+
+  for (const name of entries) {
+    const full = path.join(bunBin, name);
+    let st;
+    try {
+      st = fs.lstatSync(full);
+    } catch {
+      continue;
+    }
+    if (!st.isSymbolicLink()) continue;
+
+    let link;
+    try {
+      link = fs.readlinkSync(full);
+    } catch {
+      continue;
+    }
+    const target = path.isAbsolute(link) ? link : path.resolve(bunBin, link);
+    if (!target.startsWith(vibeGlobalRoot + path.sep)) continue;
+
+    let targetAlive = true;
+    try {
+      fs.statSync(target);
+    } catch {
+      targetAlive = false;
+    }
+    if (targetAlive) continue;
+
+    if (OWNED_BIN_NAMES.has(name) && ourCliExists) {
+      try {
+        fs.unlinkSync(full);
+        fs.symlinkSync(ourCli, full);
+        try {
+          fs.chmodSync(ourCli, 0o755);
+        } catch {
+          /* non-fatal */
+        }
+        console.log(
+          `[@vibecontrols/agent] rebound stale bun-shim ${full} -> ${ourCli}`,
+        );
+        continue;
+      } catch {
+        /* fall through to unlink */
+      }
+    }
+
+    try {
+      fs.unlinkSync(full);
+      console.log(`[@vibecontrols/agent] pruned dangling bun-shim: ${full}`);
+    } catch {
+      /* best-effort */
+    }
+  }
+}
+
+// Windows-only: when the agent is installed via `npm install -g`, npm derives
+// the `vibe.ps1` / `vibe.cmd` shim's interpreter from the bin's
+// `#!/usr/bin/env bun` shebang — emitting a bare `bun`. If Bun isn't on PATH at
+// invocation time the shim dies with
+// "The term 'bun.exe' is not recognized as a name of a cmdlet...". Bun is the
+// agent's runtime and the installer guarantees it under ~/.bun, so rewrite the
+// bare `bun` token in those shims to bun's absolute path. Best-effort and
+// idempotent: only acts when Bun is NOT already resolvable on PATH (a working
+// setup is left untouched) and a concrete bun.exe exists to point at.
+function patchWindowsNpmBunShims() {
+  if (process.platform !== "win32") return;
+  const home = os.homedir();
+  const bunAbs = path.join(home, ".bun", "bin", "bun.exe");
+  if (!fs.existsSync(bunAbs)) return;
+
+  // If bun already resolves on PATH the npm shim works as-is — don't touch it.
+  try {
+    const w = spawnSync("where.exe", ["bun"], { stdio: "ignore" });
+    if (w && w.status === 0) return;
+  } catch {
+    /* where.exe missing/blocked — proceed to patch defensively */
+  }
+
+  const dirs = new Set();
+  if (process.env.APPDATA) dirs.add(path.join(process.env.APPDATA, "npm"));
+  if (process.env.USERPROFILE) {
+    dirs.add(path.join(process.env.USERPROFILE, "AppData", "Roaming", "npm"));
+  }
+
+  for (const dir of dirs) {
+    // PowerShell shim: `& "bun$exe" "$basedir/.../cli.js" $args`
+    const ps1 = path.join(dir, "vibe.ps1");
+    try {
+      if (fs.existsSync(ps1)) {
+        const c = fs.readFileSync(ps1, "utf8");
+        if (c.includes('"bun$exe"')) {
+          // String split/join avoids regex-escaping the backslashes in bunAbs.
+          fs.writeFileSync(ps1, c.split('"bun$exe"').join(`"${bunAbs}"`));
+          console.log(
+            `[@vibecontrols/agent] patched ${ps1} -> ${bunAbs} (bun was not on PATH)`,
+          );
+        }
+      }
+    } catch {
+      /* best-effort */
+    }
+    // cmd.exe shim: npm emits a bare (often quoted) `bun` as the program name.
+    const cmd = path.join(dir, "vibe.cmd");
+    try {
+      if (
+        fs.existsSync(cmd) &&
+        !fs.readFileSync(cmd, "utf8").includes(bunAbs)
+      ) {
+        const c = fs.readFileSync(cmd, "utf8");
+        const patched = c.replace(/"bun"/g, `"${bunAbs}"`);
+        if (patched !== c) {
+          fs.writeFileSync(cmd, patched);
+          console.log(
+            `[@vibecontrols/agent] patched ${cmd} -> ${bunAbs} (bun was not on PATH)`,
+          );
+        }
+      }
+    } catch {
+      /* best-effort */
+    }
+  }
+}
+
+try {
+  pruneStaleExternalShims();
+} catch {
+  /* never fail the install on a cross-bin cleanup hiccup */
+}
+
+try {
+  patchWindowsNpmBunShims();
+} catch {
+  /* never fail the install on a shim-patch hiccup */
+}
+
+try {
+  main();
+} catch {
+  /* never fail the install on a cleanup hiccup */
+}

package/dist/prereqs-runner-ca4kt803.js

@@ -0,0 +1,2 @@
+// @bun
+import{d as a,e as b}from"./index-0248afsn.js";import"./index-2gsarrbn.js";import"./index-d5ysy1yn.js";import"./index-9bqd8veb.js";import"./index-0cn9bv8z.js";import"./index-jw1k4vbk.js";import"./index-yy1mm8zs.js";export{a as runPluginPrereqs,b as readPrereqState};

package/dist/preuninstall.cjs

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+/**
+ * preuninstall hook for @vibecontrols/agent.
+ *
+ * Runs before npm physically removes the package on `npm uninstall -g
+ * @vibecontrols/agent`. Cleans up everything the agent left on the host
+ * so the user gets a true uninstall — not a half-state where files,
+ * tunnels, and autostart daemons keep running with no agent to manage
+ * them.
+ *
+ * What we remove:
+ *   1. Running agent daemons   — best-effort SIGTERM by PID from the
+ *                                product-level agents.json registry.
+ *   2. Detached tunnel children — every PID recorded in any profile's
+ *                                tunnel.state.json (cloudflared/frpc
+ *                                survive `vibe stop` by design, so
+ *                                they survive uninstall too unless
+ *                                we kill them explicitly).
+ *   3. Autostart daemons       — systemd user units, launchd plists,
+ *                                Windows Task Scheduler tasks. Best-
+ *                                effort across all profiles found in
+ *                                the registry.
+ *   4. Data directory          — `~/.boff/vibecontrols/` recursive
+ *                                rm. SKIPPED when:
+ *                                  - VIBECONTROLS_PRESERVE_DATA=true
+ *                                  - npm_config_preserve_data=true
+ *                                    (set via `npm uninstall -g
+ *                                    @vibecontrols/agent --preserve-data`)
+ *
+ * Idempotent + safe: every step is wrapped in try/catch and logs to
+ * stderr. A cleanup hiccup never throws — we'd rather let the npm
+ * uninstall complete than leave the user stuck on a failed hook.
+ *
+ * CommonJS because npm invokes preuninstall hooks as plain Node scripts
+ * via `node`, not Bun. Mirror style of postinstall-shim-fix.cjs.
+ */
+
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+function log(msg) {
+  try {
+    process.stderr.write(`[@vibecontrols/agent preuninstall] ${msg}\n`);
+  } catch {
+    /* ignore */
+  }
+}
+
+function shouldPreserveData() {
+  if (process.env.VIBECONTROLS_PRESERVE_DATA === "true") return true;
+  // npm forwards --preserve-data as npm_config_preserve_data="true"
+  if (process.env.npm_config_preserve_data === "true") return true;
+  return false;
+}
+
+function getProductDir() {
+  if (process.env.VIBECONTROLS_HOME) return process.env.VIBECONTROLS_HOME;
+  return path.join(os.homedir(), ".boff", "vibecontrols");
+}
+
+function readJsonSafe(file) {
+  try {
+    if (!fs.existsSync(file)) return null;
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function killPid(pid, signal) {
+  if (!pid || typeof pid !== "number") return;
+  try {
+    process.kill(pid, signal || "SIGTERM");
+  } catch {
+    /* already dead — ignore */
+  }
+}
+
+// Step 1: stop running agent daemons (best-effort SIGTERM from registry).
+function stopAgents(productDir) {
+  try {
+    const registry = readJsonSafe(path.join(productDir, "agents.json"));
+    if (!registry) return [];
+    const list = Array.isArray(registry)
+      ? registry
+      : Array.isArray(registry.instances)
+        ? registry.instances
+        : [];
+    const names = [];
+    for (const entry of list) {
+      if (entry && typeof entry.pid === "number") {
+        killPid(entry.pid, "SIGTERM");
+        log(`SIGTERM agent ${entry.name || "?"} pid=${entry.pid}`);
+      }
+      if (entry && typeof entry.name === "string") names.push(entry.name);
+    }
+    return names;
+  } catch (err) {
+    log(`stopAgents: ${err && err.message ? err.message : err}`);
+    return [];
+  }
+}
+
+// Step 2: kill detached tunnel children recorded in any profile's
+// tunnel.state.json under <productDir>/agents/<profile>/tunnel.state.json.
+function stopTunnels(productDir) {
+  try {
+    const agentsDir = path.join(productDir, "agents");
+    if (!fs.existsSync(agentsDir)) return;
+    const profiles = fs.readdirSync(agentsDir);
+    for (const profile of profiles) {
+      const stateFile = path.join(agentsDir, profile, "tunnel.state.json");
+      const state = readJsonSafe(stateFile);
+      if (state && typeof state.pid === "number") {
+        killPid(state.pid, "SIGTERM");
+        log(`SIGTERM tunnel pid=${state.pid} (profile=${profile})`);
+      }
+    }
+  } catch (err) {
+    log(`stopTunnels: ${err && err.message ? err.message : err}`);
+  }
+}
+
+// Step 3: remove autostart daemons across all known profiles.
+//
+// The registry's profile names tell us which autostart entries the agent
+// has likely created. We attempt removal for each — if a name has no
+// installed daemon, the underlying tools no-op silently.
+function removeAutostart(productDir, profileNames) {
+  // Always include the canonical default so a clean uninstall on a host
+  // with no agents.json still strips a manually-installed default daemon.
+  const candidates = new Set(["default", ...profileNames]);
+  const platform = os.platform();
+  for (const name of candidates) {
+    try {
+      if (platform === "linux") {
+        const unit = `vibecontrols-agent-${name}.service`;
+        const unitPath = path.join(
+          os.homedir(),
+          ".config",
+          "systemd",
+          "user",
+          unit,
+        );
+        spawnSync("systemctl", ["--user", "stop", unit], { stdio: "ignore" });
+        spawnSync("systemctl", ["--user", "disable", unit], {
+          stdio: "ignore",
+        });
+        if (fs.existsSync(unitPath)) {
+          fs.unlinkSync(unitPath);
+          log(`removed systemd unit: ${unitPath}`);
+        }
+        spawnSync("systemctl", ["--user", "daemon-reload"], {
+          stdio: "ignore",
+        });
+      } else if (platform === "darwin") {
+        const label = `com.boff.vibecontrols.agent.${name}`;
+        const plistPath = path.join(
+          os.homedir(),
+          "Library",
+          "LaunchAgents",
+          `${label}.plist`,
+        );
+        spawnSync("launchctl", ["unload", plistPath], { stdio: "ignore" });
+        const uidProc = spawnSync("id", ["-u"], { encoding: "utf8" });
+        const uid = (uidProc.stdout || "").trim();
+        if (uid) {
+          spawnSync("launchctl", ["bootout", `gui/${uid}/${label}`], {
+            stdio: "ignore",
+          });
+        }
+        if (fs.existsSync(plistPath)) {
+          fs.unlinkSync(plistPath);
+          log(`removed launchd plist: ${plistPath}`);
+        }
+      } else if (platform === "win32") {
+        const taskName = `VibeControlsAgent_${name}`;
+        spawnSync("schtasks.exe", ["/End", "/TN", taskName], {
+          stdio: "ignore",
+        });
+        spawnSync("schtasks.exe", ["/Delete", "/TN", taskName, "/F"], {
+          stdio: "ignore",
+        });
+        // Best-effort cleanup of the generated XML registration file.
+        const xmlPath = path.join(productDir, `autostart-${name}.xml`);
+        if (fs.existsSync(xmlPath)) {
+          try {
+            fs.unlinkSync(xmlPath);
+          } catch {
+            /* ignore */
+          }
+        }
+      }
+    } catch (err) {
+      log(
+        `removeAutostart(${name}): ${err && err.message ? err.message : err}`,
+      );
+    }
+  }
+}
+
+// Step 4: remove the data directory (gated by --preserve-data / env var).
+function removeDataDir(productDir) {
+  if (shouldPreserveData()) {
+    log(
+      `VIBECONTROLS_PRESERVE_DATA / --preserve-data set; keeping ${productDir}`,
+    );
+    return;
+  }
+  try {
+    if (fs.existsSync(productDir)) {
+      fs.rmSync(productDir, { recursive: true, force: true });
+      log(`removed data dir: ${productDir}`);
+    }
+  } catch (err) {
+    log(`removeDataDir: ${err && err.message ? err.message : err}`);
+  }
+}
+
+function main() {
+  const productDir = getProductDir();
+  // Order matters: stop agents first so they don't auto-respawn tunnels;
+  // kill tunnels before tearing down autostart units (which on Linux/mac
+  // would re-launch the agent + tunnel chain on the next reboot if left
+  // enabled); finally rm the data dir.
+  const names = stopAgents(productDir);
+  // Give agents a brief moment to flush their shutdown handlers before
+  // we kill detached tunnel children. 250 ms is enough for SIGTERM
+  // delivery without dragging out the npm uninstall noticeably.
+  try {
+    const end = Date.now() + 250;
+    while (Date.now() < end) {
+      // Busy-wait is fine here; this script runs once per uninstall and
+      // the alternative (setTimeout + Promise) would force the script
+      // into async land for very little benefit.
+    }
+  } catch {
+    /* ignore */
+  }
+  stopTunnels(productDir);
+  removeAutostart(productDir, names);
+  removeDataDir(productDir);
+}
+
+try {
+  main();
+} catch (err) {
+  // Never fail the uninstall on a cleanup hiccup.
+  log(`unexpected: ${err && err.message ? err.message : err}`);
+}

package/dist/profile-mount-npcknw6v.js

@@ -0,0 +1,2 @@
+// @bun
+import{nb as a,ob as b,pb as c,qb as d,rb as e,sb as f}from"./index-v9fx5wab.js";import"./index-01qzsnwd.js";import"./index-d5ysy1yn.js";import"./index-04n4qgvd.js";import"./index-g2raeeh4.js";import"./index-9bqd8veb.js";import"./index-0cn9bv8z.js";import"./index-jw1k4vbk.js";import"./index-yy1mm8zs.js";export{b as unmountProfileRoutes,a as mountProfileRoutes,c as dispatchProfileRequest,f as __setMountForTests,e as __resetProfileMountsForTests,d as __listMountedProfilesForTests};

package/dist/prune-stale-shims-nkx9vq5m.js

@@ -0,0 +1,2 @@
+// @bun
+import{H as a}from"./index-mxc61yr1.js";import"./index-yy1mm8zs.js";export{a as pruneStaleBunBinShims};

package/dist/register-core-qrawzyym.js

@@ -0,0 +1,2 @@
+// @bun
+import{J as a}from"./index-3ys16efc.js";import"./index-2gsarrbn.js";import"./index-b5dhmybd.js";import"./index-e1bw1bwr.js";import"./index-g8zv1gta.js";import"./index-qfz9fy56.js";import"./index-ssjmzqcz.js";import"./index-4wgjx8bf.js";import"./index-g3ap3xpr.js";import"./index-0ckffygp.js";import"./index-rc79x8fw.js";import"./index-yrgm89r8.js";import"./index-52cp759f.js";import"./index-01qzsnwd.js";import"./index-d5ysy1yn.js";import"./index-04n4qgvd.js";import"./index-5mw3eshk.js";import"./index-z5a4yxzz.js";import"./index-ef95xr4z.js";import"./index-xjzmb1pn.js";import"./index-g2raeeh4.js";import"./index-9bqd8veb.js";import"./index-0cn9bv8z.js";import"./index-jw1k4vbk.js";import"./index-yy1mm8zs.js";export{a as registerCoreCommands};

package/dist/secondary-profile-attach-db5cr3e1.js

@@ -0,0 +1,2 @@
+// @bun
+import{x as a}from"./index-1hnw0rhc.js";import"./index-tp4y9jde.js";import"./index-4wgjx8bf.js";import"./index-g3ap3xpr.js";import"./index-0ckffygp.js";import"./index-v9fx5wab.js";import"./index-01qzsnwd.js";import"./index-d5ysy1yn.js";import"./index-04n4qgvd.js";import"./index-g2raeeh4.js";import"./index-9bqd8veb.js";import"./index-0cn9bv8z.js";import"./index-jw1k4vbk.js";import"./index-yy1mm8zs.js";export{a as attachSecondaryProfile};

package/dist/subprocess-g9sk1ep9.js

@@ -0,0 +1,2 @@
+// @bun
+import{o as a,p as b,q as c,r as d,s as e}from"./index-n7qyrdr1.js";import"./index-0ckffygp.js";import"./index-9bqd8veb.js";import"./index-0cn9bv8z.js";import"./index-jw1k4vbk.js";import"./index-yy1mm8zs.js";export{a as spawnTracked,c as listTrackedByOwner,b as listTracked,d as killTracked,e as killAllTracked};

package/dist/telemetry-tnq47dcs.js

@@ -0,0 +1,2 @@
+// @bun
+import{bb as a}from"./index-yrgm89r8.js";import"./index-52cp759f.js";import"./index-9bqd8veb.js";import"./index-0cn9bv8z.js";import"./index-jw1k4vbk.js";import"./index-yy1mm8zs.js";export{a as telemetryService};

package/dist/tree-sitter-javascript-3h25c6bs.js

@@ -0,0 +1,2 @@
+// @bun
+import"./index-yy1mm8zs.js";var l="./tree-sitter-javascript-nd0q4pe9.wasm";export{l as default};

package/dist/tree-sitter-markdown-3nemcjhe.js

@@ -0,0 +1,2 @@
+// @bun
+import"./index-yy1mm8zs.js";var F="./tree-sitter-markdown-411r6y9b.wasm";export{F as default};

package/dist/tree-sitter-markdown_inline-16ftwa53.js

@@ -0,0 +1,2 @@
+// @bun
+import"./index-yy1mm8zs.js";var E="./tree-sitter-markdown_inline-j5349f42.wasm";export{E as default};