kandev 0.53.0 → 0.54.0

package/dist/service/paths.js

@@ -10,6 +10,7 @@ exports.linuxSystemUnitPath = linuxSystemUnitPath;
 exports.macosUserAgentDir = macosUserAgentDir;
 exports.macosUserPlistPath = macosUserPlistPath;
 exports.macosSystemPlistPath = macosSystemPlistPath;
+exports.homebrewShimPath = homebrewShimPath;
 exports.captureLauncher = captureLauncher;
 exports.resolveHomeDir = resolveHomeDir;
 exports.resolveLogDir = resolveLogDir;
@@ -45,6 +46,30 @@ function macosUserPlistPath() {
 function macosSystemPlistPath() {
     return node_path_1.default.join(exports.MACOS_SYSTEM_DAEMON_DIR, `${exports.LAUNCHD_LABEL}.plist`);
 }
+// Homebrew is POSIX-only, so the Cellar segment is a hardcoded "/Cellar/"
+// rather than `path.sep`-based. On a Windows CI runner `path.sep` would be
+// "\\", which would never match a POSIX Cellar path and silently break shim
+// derivation (and its tests).
+const HOMEBREW_CELLAR_SEGMENT = "/Cellar/";
+/**
+ * Derive the floating Homebrew launcher shim from a Cellar-installed cli.js path.
+ *
+ * Homebrew installs the CLI under `<prefix>/Cellar/kandev/<version>/...` and
+ * symlinks a version-independent shim at `<prefix>/bin/kandev`. That shim sets
+ * KANDEV_BUNDLE_DIR / KANDEV_VERSION itself and execs cli.js via the floating
+ * `opt/node` symlink, so it keeps working after `brew upgrade` deletes the old
+ * Cellar dir. Returns undefined when `cliEntry` isn't a Cellar layout (npm /
+ * unknown installs), so callers fall back to the version-pinned paths.
+ */
+function homebrewShimPath(cliEntry) {
+    const idx = cliEntry.indexOf(HOMEBREW_CELLAR_SEGMENT);
+    if (idx === -1)
+        return undefined;
+    const prefix = cliEntry.slice(0, idx);
+    // Homebrew layout is POSIX; use path.posix.join so the result keeps forward
+    // slashes regardless of the host the install/tests run on.
+    return node_path_1.default.posix.join(prefix, "bin", exports.SERVICE_NAME);
+}
 /**
  * Snapshot the current invocation so the service unit can faithfully reproduce it.
  *
@@ -63,7 +88,17 @@ function captureLauncher() {
         : cliEntry.includes(`${node_path_1.default.sep}node_modules${node_path_1.default.sep}`)
             ? "npm"
             : "unknown";
-    return { nodePath, cliEntry, kind, bundleDir, version };
+    // For Homebrew installs, prefer the floating bin shim so the unit survives
+    // `brew upgrade` (which deletes the versioned Cellar dir baked into nodePath
+    // /cliEntry). Only adopt it when the shim actually exists on disk; otherwise
+    // fall back to the version-pinned paths below.
+    let shimPath;
+    if (kind === "homebrew") {
+        const candidate = homebrewShimPath(cliEntry);
+        if (candidate && node_fs_1.default.existsSync(candidate))
+            shimPath = candidate;
+    }
+    return { nodePath, cliEntry, kind, bundleDir, version, shimPath };
 }
 function resolveCliEntry() {
     const argvEntry = process.argv[1];

package/dist/service/templates.js

@@ -9,12 +9,13 @@ exports.renderSystemdUnit = renderSystemdUnit;
 exports.renderLaunchdPlist = renderLaunchdPlist;
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
-// User-mode PATH includes ~/.local/bin so user-installed agent CLIs (npm user
-// prefix, pipx, fnm, etc.) are discoverable.
+// User-mode PATH includes ~/.local/bin and ~/.bun/bin so user-installed agent
+// CLIs (npm user prefix, pipx, fnm, Bun globals like oh-my-pi/omp, etc.) are
+// discoverable.
 const SYSTEMD_SYSTEM_PATH = "/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin:/home/linuxbrew/.linuxbrew/bin";
-const SYSTEMD_USER_PATH = `%h/.local/bin:${SYSTEMD_SYSTEM_PATH}`;
+const SYSTEMD_USER_PATH = `%h/.local/bin:%h/.bun/bin:${SYSTEMD_SYSTEM_PATH}`;
 const LAUNCHD_SYSTEM_PATH = "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin";
-const launchdUserPath = () => `${node_os_1.default.homedir()}/.local/bin:${LAUNCHD_SYSTEM_PATH}`;
+const launchdUserPath = () => `${node_os_1.default.homedir()}/.local/bin:${node_os_1.default.homedir()}/.bun/bin:${LAUNCHD_SYSTEM_PATH}`;
 // Prepend the launcher node's bin dir so `npm`/`npx` resolve under per-user
 // node managers (fnm, nvm, asdf, volta, mise), where node lives in a versioned
 // subdirectory not covered by the system PATH. ExecStart already points at this
@@ -51,29 +52,41 @@ function looksLikeManagedUnit(content) {
  * Render a systemd unit file for kandev.
  *
  * The unit hard-codes absolute paths so it works without a user PATH. We pass
- * `--headless` so the daemon doesn't try to open a browser. KANDEV_BUNDLE_DIR /
- * KANDEV_VERSION are surfaced only when present (Homebrew installs only) so
- * `npm i -g` installs don't get spurious env vars.
+ * `--headless` so the daemon doesn't try to open a browser.
+ *
+ * For Homebrew installs the launcher carries a resolved `shimPath` — the
+ * floating `<prefix>/bin/kandev` shim that survives `brew upgrade`. When set we
+ * exec that shim and omit KANDEV_BUNDLE_DIR / KANDEV_VERSION and the
+ * version-pinned node bin dir from PATH, because the shim supplies all three
+ * itself. Otherwise (npm / unknown installs) we fall back to the version-pinned
+ * node + cli.js and surface KANDEV_BUNDLE_DIR / KANDEV_VERSION only when present.
  */
 function renderSystemdUnit(input) {
+    const shimPath = input.launcher.shimPath;
     const basePath = input.mode === "system" ? SYSTEMD_SYSTEM_PATH : SYSTEMD_USER_PATH;
+    // For the shim, prepend its own bin dir (the Homebrew prefix's `bin`, where
+    // node/npm/npx live) so npx-based agents resolve even when the prefix isn't
+    // one of the hardcoded defaults. pathWithNodeBinDir dedupes when it already is.
+    const pathValue = pathWithNodeBinDir(basePath, shimPath ?? input.launcher.nodePath);
     const env = [
         envLine("KANDEV_HOME_DIR", input.homeDir),
         envLine("KANDEV_LOG_LEVEL", "info"),
-        envLine("PATH", pathWithNodeBinDir(basePath, input.launcher.nodePath)),
+        envLine("PATH", pathValue),
     ];
     if (input.port !== undefined) {
         env.push(envLine("KANDEV_SERVER_PORT", String(input.port)));
     }
-    if (input.launcher.bundleDir) {
+    if (!shimPath && input.launcher.bundleDir) {
         env.push(envLine("KANDEV_BUNDLE_DIR", input.launcher.bundleDir));
     }
-    if (input.launcher.version) {
+    if (!shimPath && input.launcher.version) {
         env.push(envLine("KANDEV_VERSION", input.launcher.version));
     }
     const wantedBy = input.mode === "system" ? "multi-user.target" : "default.target";
     const userLine = input.mode === "system" && input.systemUser ? `User=${input.systemUser}\n` : "";
-    const exec = `${quoteForUnit(input.launcher.nodePath)} ${quoteForUnit(input.launcher.cliEntry)} --headless`;
+    const exec = shimPath
+        ? `${quoteForUnit(shimPath)} --headless`
+        : `${quoteForUnit(input.launcher.nodePath)} ${quoteForUnit(input.launcher.cliEntry)} --headless`;
     return `${SYSTEMD_MARKER}
 [Unit]
 Description=Kandev autonomous agent platform
@@ -102,25 +115,30 @@ WantedBy=${wantedBy}
  * get a LaunchDaemon that runs at boot regardless of login.
  */
 function renderLaunchdPlist(input) {
+    const shimPath = input.launcher.shimPath;
     const basePath = input.mode === "system" ? LAUNCHD_SYSTEM_PATH : launchdUserPath();
+    // See renderSystemdUnit: prepend the shim's own bin dir so npm/npx resolve.
+    const pathValue = pathWithNodeBinDir(basePath, shimPath ?? input.launcher.nodePath);
     const envEntries = [
         ["KANDEV_HOME_DIR", input.homeDir],
         ["KANDEV_LOG_LEVEL", "info"],
-        ["PATH", pathWithNodeBinDir(basePath, input.launcher.nodePath)],
+        ["PATH", pathValue],
     ];
     if (input.port !== undefined) {
         envEntries.push(["KANDEV_SERVER_PORT", String(input.port)]);
     }
-    if (input.launcher.bundleDir) {
+    if (!shimPath && input.launcher.bundleDir) {
         envEntries.push(["KANDEV_BUNDLE_DIR", input.launcher.bundleDir]);
     }
-    if (input.launcher.version) {
+    if (!shimPath && input.launcher.version) {
         envEntries.push(["KANDEV_VERSION", input.launcher.version]);
     }
     const envXml = envEntries
         .map(([k, v]) => `      <key>${escapeXml(k)}</key>\n      <string>${escapeXml(v)}</string>`)
         .join("\n");
-    const args = [input.launcher.nodePath, input.launcher.cliEntry, "--headless"];
+    const args = shimPath
+        ? [shimPath, "--headless"]
+        : [input.launcher.nodePath, input.launcher.cliEntry, "--headless"];
     const argsXml = args.map((a) => `    <string>${escapeXml(a)}</string>`).join("\n");
     // For system-mode LaunchDaemons, run as a specific user instead of root.
     // For user agents this directive is omitted — the agent already runs as

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kandev",
-  "version": "0.53.0",
+  "version": "0.54.0",
   "private": false,
   "description": "Launcher for Kandev — manage tasks, orchestrate agents, review changes, and ship value",
   "license": "AGPL-3.0-only",
@@ -22,11 +22,11 @@
     "npm": ">=7"
   },
   "optionalDependencies": {
-    "@kdlbs/runtime-linux-x64": "0.53.0",
-    "@kdlbs/runtime-linux-arm64": "0.53.0",
-    "@kdlbs/runtime-darwin-x64": "0.53.0",
-    "@kdlbs/runtime-darwin-arm64": "0.53.0",
-    "@kdlbs/runtime-win32-x64": "0.53.0"
+    "@kdlbs/runtime-linux-x64": "0.54.0",
+    "@kdlbs/runtime-linux-arm64": "0.54.0",
+    "@kdlbs/runtime-darwin-x64": "0.54.0",
+    "@kdlbs/runtime-darwin-arm64": "0.54.0",
+    "@kdlbs/runtime-win32-x64": "0.54.0"
   },
   "dependencies": {
     "tar": "^7.5.11",