kandev 0.58.0 → 0.60.0

package/dist/cli.js

@@ -131,6 +131,7 @@ async function main() {
             webPort,
             verbose: options.verbose,
             debug: options.debug,
+            headless: options.headless,
         });
         return;
     }

package/dist/dev.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runDev = runDev;
 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");
@@ -14,6 +13,7 @@ const health_1 = require("./health");
 const kandev_env_1 = require("./kandev-env");
 const process_1 = require("./process");
 const shared_1 = require("./shared");
+const backend_1 = require("./supervisor/backend");
 const web_1 = require("./web");
 async function runDev({ repoRoot, backendPort, webPort }) {
     const ports = await (0, shared_1.pickPorts)(backendPort, webPort);
@@ -52,16 +52,20 @@ async function runDev({ repoRoot, backendPort, webPort }) {
         node_path_1.default.join("apps", "backend"),
         "dev",
     ]);
-    const backendProc = (0, node_child_process_1.spawn)(backendCmd, backendArgs, {
+    const backend = await (0, backend_1.launchRestartableBackend)({
+        command: backendCmd,
+        args: backendArgs,
         cwd: repoRoot,
         env: backendEnv,
+        homeDir: backendEnv.KANDEV_HOME_DIR ?? (0, constants_1.devKandevHome)(repoRoot),
+        ports,
+        mode: "dev",
         stdio: "inherit",
+        supervisor,
     });
-    supervisor.children.push(backendProc);
-    (0, shared_1.attachBackendExitHandler)(backendProc, supervisor);
     const healthTimeoutMs = (0, health_1.resolveHealthTimeoutMs)(constants_1.HEALTH_TIMEOUT_MS_DEV);
     console.log("[kandev] starting backend...");
-    await (0, health_1.waitForHealth)(ports.backendUrl, backendProc, healthTimeoutMs);
+    await (0, health_1.waitForHealth)(ports.backendUrl, backend.proc, healthTimeoutMs);
     console.log(`[kandev] backend ready at ${ports.backendUrl}`);
     console.log("[kandev] starting web...");
     const webProc = (0, web_1.launchWebApp)({

package/dist/process.js

@@ -4,6 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createProcessSupervisor = createProcessSupervisor;
+exports.ignoreBrokenPipe = ignoreBrokenPipe;
+exports.__resetBrokenPipeGuard = __resetBrokenPipeGuard;
 const tree_kill_1 = __importDefault(require("tree-kill"));
 const SHUTDOWN_TIMEOUT_MS = 10000;
 function createProcessSupervisor() {
@@ -25,6 +27,12 @@ function createProcessSupervisor() {
         void shutdown(`signal ${signal}`).then(() => process.exit(0));
     };
     const attachSignalHandlers = () => {
+        // Ctrl-C sends SIGINT to the whole process group, so the parent (make/shell)
+        // exits and closes the pipe our stdout/stderr write to. Any console.log during
+        // shutdown then triggers an EPIPE 'error' event with no listener, which Node
+        // treats as fatal and crashes us before children are gracefully terminated.
+        // Swallow EPIPE so shutdown can finish.
+        ignoreBrokenPipe();
         process.on("SIGINT", onSignal);
         // SIGTERM is not available on Windows — only attach where supported
         if (process.platform !== "win32") {
@@ -33,6 +41,31 @@ function createProcessSupervisor() {
     };
     return { children, shutdown, attachSignalHandlers };
 }
+let brokenPipeGuarded = false;
+/**
+ * Install error handlers on stdout/stderr that swallow EPIPE (broken pipe).
+ * Idempotent: only attaches once per process.
+ */
+function ignoreBrokenPipe() {
+    if (brokenPipeGuarded)
+        return;
+    brokenPipeGuarded = true;
+    const onPipeError = (err) => {
+        if (err.code === "EPIPE")
+            return;
+        throw err;
+    };
+    process.stdout.on("error", onPipeError);
+    process.stderr.on("error", onPipeError);
+}
+/**
+ * Test-only: resets the broken-pipe guard so a later `ignoreBrokenPipe()` call
+ * reattaches listeners. Keeps the module guard consistent with suites that
+ * remove the listeners they installed.
+ */
+function __resetBrokenPipeGuard() {
+    brokenPipeGuarded = false;
+}
 /**
  * Terminate a process and wait for it to exit.
  * On Unix: sends SIGTERM, falls back to SIGKILL after timeout.

package/dist/run.js

@@ -7,7 +7,6 @@ exports.findCachedRelease = findCachedRelease;
 exports.cleanOldReleases = cleanOldReleases;
 exports.attachRingBuffer = attachRingBuffer;
 exports.runRelease = runRelease;
-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 bundle_1 = require("./bundle");
@@ -20,6 +19,7 @@ const ports_1 = require("./ports");
 const process_1 = require("./process");
 const runtime_1 = require("./runtime");
 const shared_1 = require("./shared");
+const backend_1 = require("./supervisor/backend");
 const web_1 = require("./web");
 /**
  * Find a cached release binary to use when GitHub is unreachable.
@@ -199,7 +199,7 @@ function attachRingBuffer(stream, maxChars = 64 * 1024) {
     });
     return () => buf;
 }
-function launchBundle(prepared) {
+async function launchBundle(prepared) {
     (0, shared_1.logStartupInfo)({
         header: `release: ${prepared.releaseTag}`,
         ports: {
@@ -213,12 +213,23 @@ function launchBundle(prepared) {
     });
     const supervisor = (0, process_1.createProcessSupervisor)();
     supervisor.attachSignalHandlers();
-    const backendProc = (0, node_child_process_1.spawn)(prepared.backendBin, [], {
+    const backend = await (0, backend_1.launchRestartableBackend)({
+        command: prepared.backendBin,
+        args: [],
         cwd: node_path_1.default.dirname(prepared.backendBin),
         env: prepared.backendEnv,
+        homeDir: (0, constants_1.resolveKandevHomeDir)(),
+        ports: {
+            backendPort: Number(prepared.backendEnv.KANDEV_SERVER_PORT),
+            webPort: prepared.webPort,
+            agentctlPort: prepared.agentctlPort,
+            backendUrl: prepared.backendUrl,
+        },
+        mode: "run",
         stdio: prepared.showOutput ? ["ignore", "inherit", "inherit"] : ["ignore", "pipe", "inherit"],
+        supervisor,
     });
-    supervisor.children.push(backendProc);
+    const backendProc = backend.proc;
     const readBuffered = prepared.showOutput ? () => "" : attachRingBuffer(backendProc.stdout);
     let dumped = false;
     const dumpBackendLogs = () => {
@@ -232,7 +243,6 @@ function launchBundle(prepared) {
         console.error(buffered.trimEnd());
         console.error("[kandev] --- end backend stdout ---");
     };
-    (0, shared_1.attachBackendExitHandler)(backendProc, supervisor);
     const webServerPath = (0, bundle_1.resolveWebServerPath)(prepared.bundleDir);
     if (!webServerPath) {
         throw new Error("Web server entry (server.js) not found in bundle");
@@ -247,7 +257,7 @@ async function runRelease({ runtimeVersion, backendPort, webPort, verbose = fals
         verbose,
         debug,
     });
-    const { supervisor, backendProc, webServerPath, dumpBackendLogs } = launchBundle(prepared);
+    const { supervisor, backendProc, webServerPath, dumpBackendLogs } = await launchBundle(prepared);
     const healthTimeoutMs = (0, health_1.resolveHealthTimeoutMs)(constants_1.HEALTH_TIMEOUT_MS_RELEASE);
     console.log("[kandev] starting backend...");
     await (0, health_1.waitForHealth)(prepared.backendUrl, backendProc, healthTimeoutMs, dumpBackendLogs);

package/dist/shared.js

@@ -202,9 +202,12 @@ function networkUrlsForPort(port, hosts) {
  * @param backendProc - The backend child process
  * @param supervisor - The process supervisor managing child processes
  */
-function attachBackendExitHandler(backendProc, supervisor) {
+function attachBackendExitHandler(backendProc, supervisor, options = {}) {
     backendProc.on("exit", (code, signal) => {
         console.error(`[kandev] backend exited (code=${code}, signal=${signal})`);
+        if (options.shouldShutdown && !options.shouldShutdown()) {
+            return;
+        }
         const exitCode = signal ? 0 : (code ?? 1);
         void supervisor.shutdown("backend exit").then(() => process.exit(exitCode));
     });

package/dist/start.js

@@ -17,7 +17,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveStandaloneServerPath = resolveStandaloneServerPath;
 exports.runStart = runStart;
-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 constants_1 = require("./constants");
@@ -25,6 +24,7 @@ const health_1 = require("./health");
 const platform_1 = require("./platform");
 const process_1 = require("./process");
 const shared_1 = require("./shared");
+const backend_1 = require("./supervisor/backend");
 const web_1 = require("./web");
 /**
  * Locates the standalone Next.js `server.js` inside `apps/web/.next/standalone/`.
@@ -83,7 +83,7 @@ function findWebServerJs(dir) {
  * @param options - Configuration for the start command
  * @throws Error if backend binary or web build is not found
  */
-async function runStart({ repoRoot, backendPort, webPort, verbose = false, debug = false, }) {
+async function runStart({ repoRoot, backendPort, webPort, verbose = false, debug = false, headless = false, }) {
     const ports = await (0, shared_1.pickPorts)(backendPort, webPort);
     const backendBin = node_path_1.default.join(repoRoot, "apps", "backend", "bin", (0, platform_1.getBinaryName)("kandev"));
     if (!node_fs_1.default.existsSync(backendBin)) {
@@ -151,16 +151,20 @@ async function runStart({ repoRoot, backendPort, webPort, verbose = false, debug
     supervisor.attachSignalHandlers();
     // Start backend: ignore stdin, show stdout only in verbose/debug mode, always show stderr
     // Stderr is always inherited to ensure error messages are visible immediately (no pipe buffering)
-    const backendProc = (0, node_child_process_1.spawn)(backendBin, [], {
+    const backend = await (0, backend_1.launchRestartableBackend)({
+        command: backendBin,
+        args: [],
         cwd: node_path_1.default.dirname(backendBin),
         env: backendEnv,
+        homeDir: (0, constants_1.resolveKandevHomeDir)(),
+        ports,
+        mode: "start",
         stdio: showOutput ? ["ignore", "inherit", "inherit"] : ["ignore", "ignore", "inherit"],
+        supervisor,
     });
-    supervisor.children.push(backendProc);
-    (0, shared_1.attachBackendExitHandler)(backendProc, supervisor);
     const healthTimeoutMs = (0, health_1.resolveHealthTimeoutMs)(constants_1.HEALTH_TIMEOUT_MS_RELEASE);
     console.log("[kandev] starting backend...");
-    await (0, health_1.waitForHealth)(ports.backendUrl, backendProc, healthTimeoutMs);
+    await (0, health_1.waitForHealth)(ports.backendUrl, backend.proc, healthTimeoutMs);
     console.log(`[kandev] backend ready at ${ports.backendUrl}`);
     // Use standalone server.js directly (not pnpm start)
     const webUrl = `http://localhost:${ports.webPort}`;
@@ -176,5 +180,9 @@ async function runStart({ repoRoot, backendPort, webPort, verbose = false, debug
     });
     await (0, health_1.waitForUrlReady)(webUrl, webProc, healthTimeoutMs);
     console.log("[kandev] open: " + ports.backendUrl);
+    if (headless) {
+        console.log(`[kandev] ready (headless) at ${ports.backendUrl}`);
+        return;
+    }
     (0, web_1.openBrowser)(ports.backendUrl);
 }

package/dist/supervisor/backend.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.launchRestartableBackend = launchRestartableBackend;
+exports.shouldUseSupervisor = shouldUseSupervisor;
+exports.withSupervisorEnv = withSupervisorEnv;
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = __importDefault(require("node:path"));
+const shared_1 = require("../shared");
+const manifest_1 = require("./manifest");
+const paths_1 = require("./paths");
+const child_1 = require("./child");
+const control_1 = require("./control");
+async function launchRestartableBackend({ command, args, cwd, env, homeDir, ports, mode, stdio, supervisor, }) {
+    if (!shouldUseSupervisor(env)) {
+        const proc = (0, node_child_process_1.spawn)(command, args, { cwd, env, stdio });
+        supervisor.children.push(proc);
+        (0, shared_1.attachBackendExitHandler)(proc, supervisor);
+        return { proc, control: null, env };
+    }
+    const supervisorEnv = withSupervisorEnv(env, homeDir);
+    const manifest = (0, manifest_1.buildLaunchManifest)({
+        backend_executable: resolveExecutable(command),
+        argv: args,
+        cwd,
+        env: supervisorEnv,
+        home_dir: homeDir,
+        port: ports.backendPort,
+        mode,
+    });
+    (0, manifest_1.writeLaunchManifest)(manifest, supervisorEnv.KANDEV_SUPERVISOR_MANIFEST);
+    const child = (0, child_1.createRestartableChild)(manifest, { stdio, extraEnv: supervisorEnv });
+    let restarting = false;
+    const attachExit = (proc) => {
+        (0, shared_1.attachBackendExitHandler)(proc, supervisor, {
+            shouldShutdown: () => !restarting,
+        });
+    };
+    const proc = child.start();
+    supervisor.children.push(proc);
+    attachExit(proc);
+    const control = await (0, control_1.startControlServer)(supervisorEnv.KANDEV_SUPERVISOR_SOCKET, async () => {
+        restarting = true;
+        try {
+            const next = await child.restart();
+            supervisor.children.push(next);
+            attachExit(next);
+        }
+        finally {
+            restarting = false;
+        }
+    });
+    return { proc, control, env: supervisorEnv };
+}
+function shouldUseSupervisor(env = process.env) {
+    return env.KANDEV_NO_SUPERVISOR !== "true";
+}
+function withSupervisorEnv(env, homeDir) {
+    (0, paths_1.prepareSupervisorDir)(homeDir);
+    return {
+        ...env,
+        KANDEV_SUPERVISOR_SOCKET: (0, paths_1.socketPath)(homeDir),
+        KANDEV_SUPERVISOR_MANIFEST: (0, paths_1.manifestPath)(homeDir),
+        KANDEV_RESTART_ADAPTER: "supervisor",
+    };
+}
+function resolveExecutable(command) {
+    if (node_path_1.default.isAbsolute(command))
+        return command;
+    const found = (0, node_child_process_1.spawnSync)(process.platform === "win32" ? "where" : "which", [command], {
+        encoding: "utf8",
+    });
+    const first = found.stdout
+        ?.split(/\r?\n/)
+        .map((line) => line.trim())
+        .find(Boolean);
+    if (!first) {
+        throw new Error(`Unable to resolve executable ${command}`);
+    }
+    return first;
+}

package/dist/supervisor/child.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRestartableChild = createRestartableChild;
+const node_child_process_1 = require("node:child_process");
+const tree_kill_1 = __importDefault(require("tree-kill"));
+const RESTART_TIMEOUT_MS = 10000;
+function createRestartableChild(manifest, options = {}) {
+    let child = null;
+    const start = () => {
+        child = (0, node_child_process_1.spawn)(manifest.backend_executable, manifest.argv, {
+            cwd: manifest.cwd,
+            env: {
+                ...process.env,
+                ...manifest.env,
+                ...options.extraEnv,
+            },
+            stdio: options.stdio ?? "inherit",
+        });
+        return child;
+    };
+    const stop = async () => {
+        if (!child?.pid || child.exitCode !== null)
+            return;
+        await terminate(child, RESTART_TIMEOUT_MS);
+    };
+    const restart = async () => {
+        await stop();
+        return start();
+    };
+    return {
+        current: () => child,
+        start,
+        restart,
+        stop,
+    };
+}
+function terminate(proc, timeoutMs) {
+    return new Promise((resolve) => {
+        const pid = proc.pid;
+        if (!pid) {
+            resolve();
+            return;
+        }
+        let done = false;
+        const finish = () => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timeout);
+            resolve();
+        };
+        const timeout = setTimeout(() => {
+            (0, tree_kill_1.default)(pid, process.platform === "win32" ? undefined : "SIGKILL", finish);
+        }, timeoutMs);
+        proc.once("exit", finish);
+        (0, tree_kill_1.default)(pid, process.platform === "win32" ? undefined : "SIGTERM", (err) => {
+            if (err)
+                finish();
+        });
+    });
+}

package/dist/supervisor/control.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startControlServer = startControlServer;
+exports.requestRestart = requestRestart;
+const node_net_1 = __importDefault(require("node:net"));
+const node_fs_1 = __importDefault(require("node:fs"));
+function startControlServer(socket, onRestart) {
+    let restartInProgress = false;
+    const scheduleRestart = () => {
+        if (restartInProgress)
+            return false;
+        restartInProgress = true;
+        setTimeout(() => {
+            void onRestart().finally(() => {
+                restartInProgress = false;
+            });
+        }, 0);
+        return true;
+    };
+    if (process.platform !== "win32" && node_fs_1.default.existsSync(socket)) {
+        node_fs_1.default.unlinkSync(socket);
+    }
+    const server = node_net_1.default.createServer((conn) => {
+        let buf = "";
+        conn.setEncoding("utf8");
+        conn.on("data", (chunk) => {
+            buf += chunk;
+            if (!buf.includes("\n"))
+                return;
+            const line = buf.slice(0, buf.indexOf("\n"));
+            void handleControlLine(line, scheduleRestart)
+                .then((resp) => {
+                conn.end(`${JSON.stringify(resp)}\n`);
+            })
+                .catch((err) => {
+                conn.end(`${JSON.stringify({
+                    accepted: false,
+                    message: err instanceof Error ? err.message : String(err),
+                })}\n`);
+            });
+        });
+    });
+    return new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(socket, () => {
+            server.off("error", reject);
+            resolve({
+                close: () => new Promise((closeResolve, closeReject) => {
+                    server.close((err) => {
+                        if (process.platform !== "win32" && node_fs_1.default.existsSync(socket)) {
+                            node_fs_1.default.unlinkSync(socket);
+                        }
+                        if (err)
+                            closeReject(err);
+                        else
+                            closeResolve();
+                    });
+                }),
+            });
+        });
+    });
+}
+function requestRestart(socket) {
+    return new Promise((resolve, reject) => {
+        const conn = node_net_1.default.createConnection(socket);
+        let buf = "";
+        conn.setEncoding("utf8");
+        conn.on("connect", () => {
+            conn.write(`${JSON.stringify({ action: "restart" })}\n`);
+        });
+        conn.on("data", (chunk) => {
+            buf += chunk;
+        });
+        conn.on("error", reject);
+        conn.on("end", () => {
+            try {
+                resolve(JSON.parse(buf.trim()));
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    });
+}
+async function handleControlLine(line, scheduleRestart) {
+    const req = JSON.parse(line);
+    if (req.action !== "restart") {
+        return { accepted: false, message: `unsupported action ${String(req.action)}` };
+    }
+    if (!scheduleRestart()) {
+        return { accepted: false, message: "Restart already in progress" };
+    }
+    return { accepted: true, message: "Restart accepted" };
+}

package/dist/supervisor/manifest.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildLaunchManifest = buildLaunchManifest;
+exports.writeLaunchManifest = writeLaunchManifest;
+exports.readLaunchManifest = readLaunchManifest;
+exports.allowedEnv = allowedEnv;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const paths_1 = require("./paths");
+const ENV_ALLOWLIST = new Set([
+    "KANDEV_HOME_DIR",
+    "KANDEV_DATABASE_PATH",
+    "KANDEV_SERVER_PORT",
+    "KANDEV_WEB_INTERNAL_URL",
+    "KANDEV_AGENT_STANDALONE_PORT",
+    "KANDEV_LOG_LEVEL",
+    "KANDEV_DEBUG_DEV_MODE",
+    "KANDEV_DEBUG_AGENT_MESSAGES",
+    "KANDEV_DEBUG_PPROF_ENABLED",
+    "KANDEV_E2E_MOCK",
+    "KANDEV_MOCK_AGENT",
+    "KANDEV_MOCK_GITHUB",
+    "KANDEV_MOCK_JIRA",
+    "KANDEV_MOCK_LINEAR",
+    "KANDEV_SUPERVISOR_SOCKET",
+    "KANDEV_SUPERVISOR_MANIFEST",
+    "KANDEV_RESTART_ADAPTER",
+]);
+function buildLaunchManifest(input) {
+    if (!node_path_1.default.isAbsolute(input.backend_executable)) {
+        throw new Error("backend_executable must be absolute");
+    }
+    if (!node_path_1.default.isAbsolute(input.cwd)) {
+        throw new Error("cwd must be absolute");
+    }
+    if (!node_path_1.default.isAbsolute(input.home_dir)) {
+        throw new Error("home_dir must be absolute");
+    }
+    return {
+        version: 1,
+        backend_executable: input.backend_executable,
+        argv: [...input.argv],
+        cwd: input.cwd,
+        env: allowedEnv(input.env),
+        home_dir: input.home_dir,
+        port: input.port,
+        mode: input.mode,
+        created_at: (input.now ?? new Date()).toISOString(),
+    };
+}
+function writeLaunchManifest(manifest, targetPath = (0, paths_1.manifestPath)(manifest.home_dir)) {
+    (0, paths_1.prepareSupervisorDir)(manifest.home_dir);
+    node_fs_1.default.writeFileSync(targetPath, `${JSON.stringify(manifest, null, 2)}\n`, { mode: 0o600 });
+    if (process.platform !== "win32") {
+        node_fs_1.default.chmodSync(targetPath, 0o600);
+    }
+    return targetPath;
+}
+function readLaunchManifest(targetPath) {
+    return JSON.parse(node_fs_1.default.readFileSync(targetPath, "utf8"));
+}
+function allowedEnv(env) {
+    const out = {};
+    for (const key of ENV_ALLOWLIST) {
+        const value = env[key];
+        if (value !== undefined) {
+            out[key] = value;
+        }
+    }
+    return out;
+}

package/dist/supervisor/paths.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supervisorDir = supervisorDir;
+exports.manifestPath = manifestPath;
+exports.socketPath = socketPath;
+exports.prepareSupervisorDir = prepareSupervisorDir;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const constants_1 = require("../constants");
+function supervisorDir(homeDir = (0, constants_1.resolveKandevHomeDir)()) {
+    return node_path_1.default.join(homeDir, "supervisor");
+}
+function manifestPath(homeDir = (0, constants_1.resolveKandevHomeDir)()) {
+    return node_path_1.default.join(supervisorDir(homeDir), "launch.json");
+}
+function socketPath(homeDir = (0, constants_1.resolveKandevHomeDir)()) {
+    if (process.platform === "win32") {
+        const safe = homeDir.replace(/[^a-zA-Z0-9_.-]/g, "-");
+        return `\\\\.\\pipe\\kandev-${safe}-supervisor`;
+    }
+    return node_path_1.default.join(supervisorDir(homeDir), "control.sock");
+}
+function prepareSupervisorDir(homeDir = (0, constants_1.resolveKandevHomeDir)()) {
+    const dir = supervisorDir(homeDir);
+    node_fs_1.default.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    if (process.platform !== "win32") {
+        node_fs_1.default.chmodSync(dir, 0o700);
+    }
+    return dir;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kandev",
-  "version": "0.58.0",
+  "version": "0.60.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.58.0",
-    "@kdlbs/runtime-linux-arm64": "0.58.0",
-    "@kdlbs/runtime-darwin-x64": "0.58.0",
-    "@kdlbs/runtime-darwin-arm64": "0.58.0",
-    "@kdlbs/runtime-win32-x64": "0.58.0"
+    "@kdlbs/runtime-linux-x64": "0.60.0",
+    "@kdlbs/runtime-linux-arm64": "0.60.0",
+    "@kdlbs/runtime-darwin-x64": "0.60.0",
+    "@kdlbs/runtime-darwin-arm64": "0.60.0",
+    "@kdlbs/runtime-win32-x64": "0.60.0"
   },
   "dependencies": {
     "tar": "^7.5.11",