kandev 0.52.0 → 0.54.0

package/dist/backup.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isProductionDb = isProductionDb;
+exports.backupProductionDb = backupProductionDb;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+// Prefix for dev-prod-db automatic snapshots. Distinct from the backend's
+// "kandev-*" auto-snapshots and "manual-*" user snapshots so the families
+// don't interfere with each other's retention policies.
+const BACKUP_PREFIX = "dev-prod-db-";
+const BACKUP_SUFFIX = ".db";
+const MAX_BACKUPS = 5;
+/**
+ * Returns true if the given dbPath points to a non-dev database that should
+ * be backed up before running dev mode. Dev-isolated databases live under
+ * <repo>/.kandev-dev/ and are considered disposable.
+ */
+function isProductionDb(dbPath) {
+    const normalized = node_path_1.default.normalize(dbPath);
+    const segments = normalized.split(node_path_1.default.sep).filter(Boolean);
+    return !segments.includes(".kandev-dev");
+}
+/**
+ * Backs up the database at dbPath to <data-dir>/backups/ before dev mode
+ * runs against it. Keeps only the newest MAX_BACKUPS snapshots.
+ *
+ * Returns the path of the created backup, or null if the DB didn't exist
+ * or no backup was needed.
+ *
+ * The optional `homeDir` parameter is exposed for tests so they can redirect
+ * the backup location without mocking os.homedir(). The optional `now`
+ * parameter lets tests pass an explicit timestamp so back-to-back calls in
+ * the same millisecond produce distinct filenames + mtimes without sleeping.
+ */
+function backupProductionDb(dbPath, homeDir, now) {
+    if (!node_fs_1.default.existsSync(dbPath)) {
+        return null;
+    }
+    const root = homeDir ?? node_os_1.default.homedir();
+    // Backups are always placed under ~/.kandev/data/backups/ (or the
+    // caller-supplied homeDir in tests), even when dbPath points elsewhere.
+    // This matches the dev-prod-db default flow; custom KANDEV_DATABASE_PATH
+    // values are advanced usage where the user is responsible for backup location.
+    const dataDir = node_path_1.default.join(root, ".kandev", "data");
+    const backupDir = node_path_1.default.join(dataDir, "backups");
+    node_fs_1.default.mkdirSync(backupDir, { recursive: true });
+    const stamp = now ?? new Date();
+    const ts = stamp.toISOString().replace(/[:.]/g, "");
+    const name = `${BACKUP_PREFIX}${ts}${BACKUP_SUFFIX}`;
+    const dest = node_path_1.default.join(backupDir, name);
+    node_fs_1.default.copyFileSync(dbPath, dest);
+    // Stamp both atime + mtime so pruning (which sorts by mtime) is deterministic.
+    node_fs_1.default.utimesSync(dest, stamp, stamp);
+    pruneBackups(backupDir, MAX_BACKUPS);
+    return dest;
+}
+/**
+ * Keeps only the `keep` newest dev-prod-db backup files in `dir`, deleting
+ * older ones. Non-matching files are left untouched.
+ */
+function pruneBackups(dir, keep) {
+    let entries;
+    try {
+        entries = node_fs_1.default.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    const files = entries
+        .filter((e) => e.isFile() && e.name.startsWith(BACKUP_PREFIX) && e.name.endsWith(BACKUP_SUFFIX))
+        .map((e) => {
+        const fullPath = node_path_1.default.join(dir, e.name);
+        try {
+            const stat = node_fs_1.default.statSync(fullPath);
+            return { path: fullPath, mtime: stat.mtime };
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((f) => f !== null);
+    if (files.length <= keep) {
+        return;
+    }
+    files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    for (const f of files.slice(keep)) {
+        try {
+            node_fs_1.default.unlinkSync(f.path);
+        }
+        catch {
+            // Non-critical: don't fail the launch if one old backup can't be removed.
+        }
+    }
+}

package/dist/dev.js

@@ -8,6 +8,7 @@ exports.resolveDevBackendEnv = resolveDevBackendEnv;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
+const backup_1 = require("./backup");
 const constants_1 = require("./constants");
 const health_1 = require("./health");
 const kandev_env_1 = require("./kandev-env");
@@ -17,6 +18,22 @@ const web_1 = require("./web");
 async function runDev({ repoRoot, backendPort, webPort }) {
     const ports = await (0, shared_1.pickPorts)(backendPort, webPort);
     const { dbPath, extra } = resolveDevBackendEnv(repoRoot);
+    if ((0, backup_1.isProductionDb)(dbPath)) {
+        try {
+            const backupPath = (0, backup_1.backupProductionDb)(dbPath);
+            if (backupPath) {
+                const name = node_path_1.default.basename(backupPath);
+                console.log(`[kandev] backed up production db → ${name}`);
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            // Abort rather than continue: the backup exists precisely to protect the
+            // production db before dev mode touches it. Proceeding on failure would
+            // remove the safety guarantee that justified introducing this guard.
+            throw new Error(`failed to back up production db (${message}); aborting dev startup`);
+        }
+    }
     const backendEnv = (0, shared_1.buildBackendEnv)({ ports, extra });
     const webEnv = (0, shared_1.buildWebEnv)({ ports, debug: true });
     const logLevel = process.env.KANDEV_LOGGING_LEVEL?.trim() || process.env.KANDEV_LOG_LEVEL?.trim() || "info";

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.52.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.52.0",
-    "@kdlbs/runtime-linux-arm64": "0.52.0",
-    "@kdlbs/runtime-darwin-x64": "0.52.0",
-    "@kdlbs/runtime-darwin-arm64": "0.52.0",
-    "@kdlbs/runtime-win32-x64": "0.52.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",