kandev 0.64.0 → 0.67.0

package/dist/service/self_update.js

@@ -1,223 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readSelfUpdateIntent = readSelfUpdateIntent;
-exports.planSelfUpdate = planSelfUpdate;
-exports.runSelfUpdateCommand = runSelfUpdateCommand;
-const node_child_process_1 = require("node:child_process");
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_os_1 = __importDefault(require("node:os"));
-const node_path_1 = __importDefault(require("node:path"));
-const paths_1 = require("./paths");
-function readSelfUpdateIntent(intentPath) {
-    return JSON.parse(node_fs_1.default.readFileSync(intentPath, "utf8"));
-}
-function planSelfUpdate(intent, opts = {}) {
-    const platform = opts.platform ?? process.platform;
-    const target = npmVersion(intent.target_version || intent.target_tag);
-    const install = intent.install;
-    const installArgs = serviceInstallArgs(install);
-    const commands = [];
-    if (install.kind === "homebrew") {
-        // `brew upgrade` installs the tap formula's current version; it can't be
-        // pinned to intent.target_version the way npm/npx can (Homebrew has no
-        // stable "install version X" without a separate versioned formula). In
-        // practice both target_version and the formula derive from the same latest
-        // GitHub release, so they match. If the formula lags, the restarted backend
-        // reports the older version and the frontend progress poll (which waits for
-        // info.version === target_version) times out gracefully rather than
-        // reporting a false success.
-        commands.push({ command: "brew", args: ["upgrade", "kandev"] });
-        // Re-run service install via the upgraded `kandev` wrapper (resolved on
-        // PATH), NOT `node <cli_entry>`. Homebrew installs into version-pinned
-        // Cellar dirs, so the recorded cli_entry still points at the OLD bundle
-        // after `brew upgrade`; worse, invoking node on it directly runs without
-        // KANDEV_BUNDLE_DIR/KANDEV_VERSION, so the install is mis-detected as
-        // kind "unknown" and the regenerated unit loses the bundle env — the
-        // restarted backend then can't find its runtime and the service stays down.
-        // The wrapper is version-stable and re-sets the bundle env. (Mirrors the
-        // manual `kandev service install` we already document for Homebrew.)
-        commands.push({ command: "kandev", args: installArgs });
-    }
-    else if (install.kind === "npm") {
-        commands.push({ command: "npm", args: npmInstallArgs(install.cli_entry, target) });
-        commands.push({ command: install.node_path, args: [install.cli_entry, ...installArgs] });
-    }
-    else if (install.kind === "npx") {
-        commands.push({ command: "npx", args: ["-y", `kandev@${target}`, ...installArgs] });
-    }
-    else {
-        throw new Error(`unsupported install kind "${install.kind}"`);
-    }
-    commands.push(restartCommand(install, platform, opts.uid));
-    return commands;
-}
-function runSelfUpdateCommand(args, runner = spawnCommand) {
-    if (!args.intent) {
-        throw new Error("kandev service self-update requires --intent <path>");
-    }
-    const intent = readSelfUpdateIntent(args.intent);
-    const commands = planSelfUpdate(intent);
-    if (args.dryRun || process.env.KANDEV_E2E_MOCK === "true") {
-        console.log(JSON.stringify({
-            dry_run: !!args.dryRun,
-            fake: process.env.KANDEV_E2E_MOCK === "true",
-            target_version: intent.target_version,
-            commands,
-        }, null, 2));
-        return;
-    }
-    const log = openSelfUpdateLog(intent);
-    try {
-        log?.line(`self-update target ${intent.target_tag} (${intent.target_version})`);
-        log?.line(`install kind=${intent.install.kind} manager=${intent.install.manager}`);
-        log?.line(`planned ${commands.length} command(s):`);
-        commands.forEach((step, i) => log?.line(`  [${i + 1}/${commands.length}] ${formatCommand(step)}`));
-        runSelfUpdateSteps(commands, runner, log);
-        log?.line("self-update completed successfully");
-    }
-    finally {
-        log?.close();
-    }
-}
-function runSelfUpdateSteps(commands, runner, log) {
-    for (const [i, step] of commands.entries()) {
-        log?.line(`\n[${i + 1}/${commands.length}] $ ${formatCommand(step)}`);
-        const res = runner(step.command, step.args);
-        teeCommandOutput(log, res);
-        if (res.error) {
-            log?.line(`! spawn error: ${res.error.message}`);
-            throw res.error;
-        }
-        if (res.status !== 0) {
-            log?.line(`! exited with code ${res.status}`);
-            throw new Error(`${formatCommand(step)} failed with code ${res.status}`);
-        }
-        log?.line("  exit 0");
-    }
-}
-function formatCommand(step) {
-    return [step.command, ...step.args].join(" ");
-}
-function serviceInstallArgs(install) {
-    const args = ["service", "install"];
-    if (install.mode === "system")
-        args.push("--system");
-    args.push("--home-dir", install.home_dir);
-    if (install.port !== undefined) {
-        args.push("--port", String(install.port));
-    }
-    return args;
-}
-function npmInstallArgs(cliEntry, target) {
-    const args = ["install", "-g"];
-    const prefix = npmPrefixFromCliEntry(cliEntry);
-    if (prefix) {
-        args.push("--prefix", prefix);
-    }
-    args.push(`kandev@${target}`);
-    return args;
-}
-function npmPrefixFromCliEntry(cliEntry) {
-    const marker = `${node_path_1.default.sep}lib${node_path_1.default.sep}node_modules${node_path_1.default.sep}kandev${node_path_1.default.sep}`;
-    const index = cliEntry.indexOf(marker);
-    if (index < 0) {
-        return undefined;
-    }
-    return index === 0 ? node_path_1.default.sep : cliEntry.slice(0, index);
-}
-function restartCommand(install, platform, uid) {
-    if (platform === "linux") {
-        return install.mode === "system"
-            ? { command: "systemctl", args: ["restart", paths_1.SERVICE_NAME] }
-            : { command: "systemctl", args: ["--user", "restart", paths_1.SERVICE_NAME] };
-    }
-    if (platform === "darwin") {
-        // Resolve the uid lazily inside the darwin branch — Linux never needs it, so
-        // os.userInfo() shouldn't run there.
-        const resolvedUid = uid ?? node_os_1.default.userInfo().uid;
-        const domain = install.mode === "system" ? "system" : `gui/${resolvedUid}`;
-        return { command: "launchctl", args: ["kickstart", "-k", `${domain}/${paths_1.LAUNCHD_LABEL}`] };
-    }
-    throw new Error(`unsupported platform "${platform}"`);
-}
-function npmVersion(versionOrTag) {
-    const stripped = versionOrTag.replace(/^v/, "");
-    return stripped || "latest";
-}
-function spawnCommand(command, args) {
-    // Capture stdout/stderr (rather than inheriting) so the self-update log can
-    // tee each step's output. The helper runs detached under launchd/systemd, so
-    // its console output would otherwise go nowhere visible — the log file is the
-    // only forensic trail when an update fails mid-flight. maxBuffer is bumped
-    // well above the 1 MiB default because `npm install -g` is chatty.
-    return (0, node_child_process_1.spawnSync)(command, args, { maxBuffer: 64 * 1024 * 1024 });
-}
-/**
- * Open a timestamped log file under the service's log dir for this self-update
- * run. The helper is spawned outside the service process (so a restart doesn't
- * kill it mid-update), which means it has no service log of its own — without
- * this file a failed update on macOS/launchd is nearly invisible. Best-effort:
- * if the log dir can't be created we return null and the update still runs.
- */
-function openSelfUpdateLog(intent) {
-    const dir = intent.install.log_dir || logDirFromHome(intent.install.home_dir);
-    if (!dir) {
-        return null;
-    }
-    try {
-        node_fs_1.default.mkdirSync(dir, { recursive: true });
-        // Self-update logs can contain install paths/env; keep the dir owner-only
-        // even if it pre-existed with looser perms.
-        node_fs_1.default.chmodSync(dir, 0o700);
-        const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-        const filePath = node_path_1.default.join(dir, `self-update-${stamp}.log`);
-        const fd = node_fs_1.default.openSync(filePath, "a");
-        const write = (chunk) => {
-            try {
-                // The `Buffer | string` union matches neither writeSync overload
-                // directly; the cast picks one — both write the runtime value correctly.
-                node_fs_1.default.writeSync(fd, chunk);
-            }
-            catch {
-                // A write failure mid-update must not abort the update itself.
-            }
-        };
-        process.stdout.write(`[kandev] self-update log: ${filePath}\n`);
-        write(`# kandev self-update ${new Date().toISOString()}\n`);
-        return {
-            path: filePath,
-            line: (message) => write(`${message}\n`),
-            raw: (chunk) => write(chunk),
-            close: () => {
-                try {
-                    node_fs_1.default.closeSync(fd);
-                }
-                catch {
-                    // already closed / never opened
-                }
-            },
-        };
-    }
-    catch {
-        return null;
-    }
-}
-function logDirFromHome(homeDir) {
-    return homeDir ? node_path_1.default.join(homeDir, "logs") : "";
-}
-// Mirror a command's captured output to both the helper log and the process's
-// own stdout/stderr, so whatever does manage to capture the helper's streams
-// (e.g. launchd's StandardOut/ErrorPath, systemd's journal) still sees it.
-function teeCommandOutput(log, res) {
-    if (res.stdout && res.stdout.length) {
-        process.stdout.write(res.stdout);
-        log?.raw(res.stdout);
-    }
-    if (res.stderr && res.stderr.length) {
-        process.stderr.write(res.stderr);
-        log?.raw(res.stderr);
-    }
-}

package/dist/service/stale_check.js

@@ -1,78 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectStaleServiceUnit = detectStaleServiceUnit;
-exports.warnIfStaleServiceUnit = warnIfStaleServiceUnit;
-const node_fs_1 = __importDefault(require("node:fs"));
-const paths_1 = require("./paths");
-const templates_1 = require("./templates");
-/**
- * Locations of the user-mode service unit we manage. We skip system-mode
- * locations because (a) they require sudo to fix anyway, (b) reading from
- * arbitrary `/etc` paths from a regular launch is noisier than worth it.
- */
-function userModeUnitPath() {
-    if (process.platform === "linux")
-        return (0, paths_1.linuxUserUnitPath)();
-    if (process.platform === "darwin")
-        return (0, paths_1.macosUserPlistPath)();
-    return null;
-}
-/**
- * Check whether an installed user-mode service unit still references the
- * current invocation's paths.
- *
- * Called once per interactive `kandev` start (skipped for `kandev service ...`
- * commands and headless service runs). The check is intentionally cheap and
- * silent on the happy path — only emits when a problem is detected — so it's
- * fine to run unconditionally.
- *
- * Returns the warning message to print, or null when there's nothing to say.
- */
-function detectStaleServiceUnit() {
-    const unitPath = userModeUnitPath();
-    if (!unitPath)
-        return null;
-    let content;
-    try {
-        content = node_fs_1.default.readFileSync(unitPath, "utf8");
-    }
-    catch {
-        return null; // no unit installed
-    }
-    if (!(0, templates_1.looksLikeManagedUnit)(content))
-        return null;
-    let launcher;
-    try {
-        launcher = (0, paths_1.captureLauncher)();
-    }
-    catch {
-        // captureLauncher throws when process.argv[1] is missing — extremely rare,
-        // but if it happens we can't tell whether the unit is stale or not.
-        return null;
-    }
-    // Stale = the unit's hard-coded paths no longer match the running binary.
-    // We match on substring rather than parsing the unit so the check works for
-    // both systemd Environment= lines and plist <string> entries.
-    const nodeFresh = content.includes(launcher.nodePath);
-    const cliFresh = content.includes(launcher.cliEntry);
-    if (nodeFresh && cliFresh)
-        return null;
-    return (`Your installed kandev service unit (${unitPath}) references paths that\n` +
-        `   no longer match this binary. This usually happens after upgrading via\n` +
-        `   npm or Homebrew. Re-run 'kandev service install' to refresh the unit.`);
-}
-/** Convenience: detect + print to stderr in one call. Safe to call from cli.ts. */
-function warnIfStaleServiceUnit() {
-    try {
-        const msg = detectStaleServiceUnit();
-        if (msg) {
-            process.stderr.write(`[kandev] notice: ${msg}\n`);
-        }
-    }
-    catch {
-        // Never let a diagnostic check break startup.
-    }
-}

package/dist/service/templates.js

@@ -1,229 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MANAGED_MARKER_TEXT = void 0;
-exports.looksLikeManagedUnit = looksLikeManagedUnit;
-exports.renderSystemdUnit = renderSystemdUnit;
-exports.renderLaunchdPlist = renderLaunchdPlist;
-const node_os_1 = __importDefault(require("node:os"));
-const node_path_1 = __importDefault(require("node:path"));
-// Service PATH includes common per-user agent install dirs so user-installed
-// CLIs (npm user prefix, pipx, fnm, Bun globals like oh-my-pi/omp, OpenCode's
-// installer, etc.) are discoverable. System-mode units still run as the
-// configured User=, so %h resolves to that user's home directory.
-const SYSTEMD_SYSTEM_PATH = "/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin:/home/linuxbrew/.linuxbrew/bin";
-const SYSTEMD_AGENT_BIN_PATH = `%h/.local/bin:%h/.bun/bin:%h/.opencode/bin`;
-const SYSTEMD_SERVICE_PATH = `${SYSTEMD_AGENT_BIN_PATH}:${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:${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
-// node, so its parent dir is exactly where the matching npm/npx live — without
-// this, npx-based ACP agents (claude, codex, opencode) fail to spawn.
-//
-// The isAbsolute guard exists because `path.dirname` on POSIX returns `'.'`
-// for a path with no `/` separator (e.g. a Windows-style `C:\…\node.exe`
-// passed through). Prepending `.` would put CWD ahead of system dirs in the
-// daemon's PATH — a privilege-escalation footgun. Production callers always
-// pass `process.execPath` (absolute on Linux/macOS), so the guard only kicks
-// in for non-POSIX or relative inputs from future callers / tests.
-function pathWithNodeBinDir(basePath, nodePath) {
-    const nodeBinDir = node_path_1.default.dirname(nodePath);
-    if (!node_path_1.default.isAbsolute(nodeBinDir))
-        return basePath;
-    const parts = basePath.split(":");
-    if (parts.includes(nodeBinDir))
-        return basePath;
-    return `${nodeBinDir}:${basePath}`;
-}
-/**
- * Marker substring baked into every unit/plist kandev writes. Used to safely
- * detect "this file is ours, overwriting is fine" vs "user has put something
- * else here, warn loudly before replacing".
- */
-exports.MANAGED_MARKER_TEXT = "managed by kandev";
-const SYSTEMD_MARKER = `# ${exports.MANAGED_MARKER_TEXT} — regenerated by \`kandev service install\``;
-const PLIST_MARKER = `<!-- ${exports.MANAGED_MARKER_TEXT} — regenerated by \`kandev service install\` -->`;
-function looksLikeManagedUnit(content) {
-    return content.includes(exports.MANAGED_MARKER_TEXT);
-}
-/**
- * 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.
- *
- * 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 = SYSTEMD_SERVICE_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", pathValue),
-    ];
-    if (input.port !== undefined) {
-        env.push(envLine("KANDEV_SERVER_PORT", String(input.port)));
-    }
-    if (!shimPath && input.launcher.bundleDir) {
-        env.push(envLine("KANDEV_BUNDLE_DIR", input.launcher.bundleDir));
-    }
-    if (!shimPath && input.launcher.version) {
-        env.push(envLine("KANDEV_VERSION", input.launcher.version));
-    }
-    if (input.serviceMetadataPath) {
-        env.push(...serviceEnvLines(input, "systemd"));
-    }
-    const wantedBy = input.mode === "system" ? "multi-user.target" : "default.target";
-    const userLine = input.mode === "system" && input.systemUser ? `User=${input.systemUser}\n` : "";
-    const exec = shimPath
-        ? `${quoteForUnit(shimPath)} --headless`
-        : `${quoteForUnit(input.launcher.nodePath)} ${quoteForUnit(input.launcher.cliEntry)} --headless`;
-    return `${SYSTEMD_MARKER}
-[Unit]
-Description=Kandev autonomous agent platform
-Documentation=https://github.com/kdlbs/kandev
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-ExecStart=${exec}
-${userLine}${env.join("\n")}
-Restart=on-failure
-RestartSec=5s
-KillMode=mixed
-TimeoutStopSec=30s
-
-[Install]
-WantedBy=${wantedBy}
-`;
-}
-/**
- * Render a launchd plist for kandev.
- *
- * launchd has no equivalent to systemd's enable-linger: a user agent only runs
- * while the user is logged in. For a Mac-as-server scenario, use --system to
- * 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", pathValue],
-    ];
-    if (input.port !== undefined) {
-        envEntries.push(["KANDEV_SERVER_PORT", String(input.port)]);
-    }
-    if (!shimPath && input.launcher.bundleDir) {
-        envEntries.push(["KANDEV_BUNDLE_DIR", input.launcher.bundleDir]);
-    }
-    if (!shimPath && input.launcher.version) {
-        envEntries.push(["KANDEV_VERSION", input.launcher.version]);
-    }
-    if (input.serviceMetadataPath) {
-        envEntries.push(...serviceEnvEntries(input, "launchd"));
-    }
-    const envXml = envEntries
-        .map(([k, v]) => `      <key>${escapeXml(k)}</key>\n      <string>${escapeXml(v)}</string>`)
-        .join("\n");
-    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
-    // the loading user.
-    const userBlock = input.mode === "system" && input.systemUser
-        ? `  <key>UserName</key>\n  <string>${escapeXml(input.systemUser)}</string>\n`
-        : "";
-    return `<?xml version="1.0" encoding="UTF-8"?>
-${PLIST_MARKER}
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>Label</key>
-  <string>com.kdlbs.kandev</string>
-  <key>ProgramArguments</key>
-  <array>
-${argsXml}
-  </array>
-  <key>EnvironmentVariables</key>
-  <dict>
-${envXml}
-  </dict>
-${userBlock}  <key>RunAtLoad</key>
-  <true/>
-  <key>KeepAlive</key>
-  <true/>
-  <key>StandardOutPath</key>
-  <string>${escapeXml(`${input.logDir}/service.out`)}</string>
-  <key>StandardErrorPath</key>
-  <string>${escapeXml(`${input.logDir}/service.err`)}</string>
-  <key>WorkingDirectory</key>
-  <string>${escapeXml(input.homeDir)}</string>
-</dict>
-</plist>
-`;
-}
-function escapeXml(value) {
-    return value
-        .replace(/&/g, "&amp;")
-        .replace(/</g, "&lt;")
-        .replace(/>/g, "&gt;")
-        .replace(/"/g, "&quot;")
-        .replace(/'/g, "&apos;");
-}
-// systemd unit "Environment=" lines can contain spaces by wrapping in double quotes.
-// ExecStart needs special handling for spaces too — paths with spaces must be
-// double-quoted per systemd.unit(5). Escape backslashes before double-quotes so
-// a literal `\` in a path is preserved instead of merging with the following
-// character into an escape sequence.
-function quoteForUnit(value) {
-    if (!/[\s"\\]/.test(value))
-        return value;
-    const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-    return `"${escaped}"`;
-}
-// Render a systemd `Environment=KEY=value` line, quoting the whole assignment
-// when the value contains whitespace, double-quote, or backslash. Without
-// quoting, systemd splits the line on the first space and treats subsequent
-// tokens as separate KEY=value pairs — which silently corrupts paths like
-// `/home/john doe/.kandev`.
-function envLine(key, value) {
-    if (!/[\s"\\]/.test(value))
-        return `Environment=${key}=${value}`;
-    const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-    return `Environment="${key}=${escaped}"`;
-}
-function serviceEnvLines(input, manager) {
-    return serviceEnvEntries(input, manager).map(([key, value]) => envLine(key, value));
-}
-function serviceEnvEntries(input, manager) {
-    if (!input.serviceMetadataPath)
-        return [];
-    return [
-        ["KANDEV_RUNNING_AS_SERVICE", "true"],
-        ["KANDEV_SERVICE_MODE", input.mode],
-        ["KANDEV_SERVICE_MANAGER", manager],
-        ["KANDEV_INSTALL_KIND", input.launcher.kind],
-        ["KANDEV_SERVICE_METADATA", input.serviceMetadataPath],
-    ];
-}