@boxes-dev/dvb-runtime 1.0.297 → 1.0.299

package/dist/devbox/daemonClient.js

@@ -1,677 +0,0 @@
-import http from "node:http";
-import path from "node:path";
-import { spawn, spawnSync } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import fs from "node:fs";
-import { access } from "node:fs/promises";
-import { injectActiveTraceContextHeaders, parseUpgradeRequiredResponseBody, readCurrentPackageVersion, resolveDevboxDir, resolveSocketInfo, } from "@boxes-dev/core";
-import { getControlPlaneUrl, getConvexUrl } from "./controlPlane.js";
-import { logger } from "./logger.js";
-export const DAEMON_TIMEOUT_MS = {
-    health: 300,
-    quick: 500,
-    registry: 5000,
-};
-const AUTH_RELOGIN_HINT = "Run `dvb setup` in a TTY to sign in again.";
-const readNonEmptyString = (value) => {
-    if (typeof value !== "string")
-        return null;
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : null;
-};
-const extractDaemonErrorPayload = (body) => {
-    if (!body || typeof body !== "object") {
-        return {};
-    }
-    return body;
-};
-const shouldAttachReloginHint = (message) => {
-    const normalized = message.toLowerCase();
-    return (normalized.includes("control plane") &&
-        normalized.includes("auth") &&
-        !normalized.includes("dvb setup"));
-};
-export const formatDaemonResponseError = (response) => {
-    const payload = extractDaemonErrorPayload(response.body);
-    const errorCode = readNonEmptyString(payload.error);
-    const detail = readNonEmptyString(payload.message) ?? readNonEmptyString(payload.detail);
-    if (errorCode === "control_plane_auth_invalid" ||
-        errorCode === "control_plane_auth_missing") {
-        const detailWithHint = detail && !detail.includes("dvb setup")
-            ? `${detail} ${AUTH_RELOGIN_HINT}`
-            : (detail ?? AUTH_RELOGIN_HINT);
-        return detailWithHint;
-    }
-    if (detail) {
-        return shouldAttachReloginHint(detail)
-            ? `${detail} ${AUTH_RELOGIN_HINT}`
-            : detail;
-    }
-    if (errorCode) {
-        return `dvbd error (${response.status}): ${errorCode}`;
-    }
-    const rawBody = readNonEmptyString(response.rawBody);
-    if (rawBody) {
-        return `dvbd error (${response.status}): ${rawBody.slice(0, 220)}`;
-    }
-    return `dvbd error: ${response.status}`;
-};
-export const throwDaemonResponseError = (response) => {
-    const upgradeRequired = parseUpgradeRequiredResponseBody(typeof response.rawBody === "string"
-        ? response.rawBody
-        : JSON.stringify(response.body ?? {}), {
-        source: "daemon",
-        statusCode: response.status,
-    });
-    if (upgradeRequired) {
-        throw upgradeRequired;
-    }
-    throw new Error(formatDaemonResponseError(response));
-};
-class DaemonConnectionError extends Error {
-    code;
-    socketPath;
-    constructor(socketPath, cause) {
-        super(cause.message);
-        this.name = "DaemonConnectionError";
-        this.code = cause.code;
-        this.socketPath = socketPath;
-        this.cause = cause;
-    }
-}
-const isConnectionError = (error) => {
-    if (!(error instanceof Error))
-        return false;
-    const code = error.code;
-    return (code === "ENOENT" ||
-        code === "ECONNREFUSED" ||
-        code === "EPIPE" ||
-        code === "ENOTFOUND" ||
-        code === "EINVAL" ||
-        code === "ENAMETOOLONG");
-};
-export const isDaemonConnectionError = isConnectionError;
-const unixSocketPathLimit = () => {
-    return process.platform === "linux" ? 107 : 103;
-};
-const isSocketPathTooLong = (socketPath) => {
-    return Buffer.byteLength(socketPath, "utf8") > unixSocketPathLimit();
-};
-let expectedDaemonVersionCache = null;
-const daemonFeaturesCache = new Map();
-const ensureDaemonRunningInFlight = new Map();
-const ACTIVE_DAEMON_RECOVERY_TIMEOUT_MS = 20_000;
-const readExpectedDaemonVersion = () => {
-    if (expectedDaemonVersionCache)
-        return expectedDaemonVersionCache;
-    expectedDaemonVersionCache = readCurrentPackageVersion() ?? "unknown";
-    return expectedDaemonVersionCache;
-};
-const DAEMON_PID_EXIT_GRACE_MS = 1_500;
-const DAEMON_FORCE_KILL_TIMEOUT_MS = 1_000;
-const DAEMON_POLL_INTERVAL_MS = 100;
-const sleep = async (ms) => await new Promise((resolve) => setTimeout(resolve, ms));
-const isProcessAlive = (pid) => {
-    if (!Number.isInteger(pid) || pid <= 0)
-        return false;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        const code = error?.code;
-        return code === "EPERM";
-    }
-};
-const waitForPidExit = async (pid, timeoutMs) => {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        if (!isProcessAlive(pid))
-            return true;
-        await sleep(DAEMON_POLL_INTERVAL_MS);
-    }
-    return !isProcessAlive(pid);
-};
-const hasSocketPath = async (socketPath) => {
-    try {
-        await access(socketPath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-};
-const signalPid = (pid, signal) => {
-    try {
-        process.kill(pid, signal);
-        return true;
-    }
-    catch (error) {
-        const code = error?.code;
-        if (code === "ESRCH") {
-            return false;
-        }
-        throw error;
-    }
-};
-const normalizeVersion = (value) => {
-    if (typeof value !== "string")
-        return null;
-    const trimmed = value.trim();
-    if (!trimmed)
-        return null;
-    if (trimmed === "unknown")
-        return null;
-    return trimmed;
-};
-const parseIsoTimestampMs = (value) => {
-    if (typeof value !== "string") {
-        return null;
-    }
-    const parsed = Date.parse(value);
-    return Number.isFinite(parsed) ? parsed : null;
-};
-const shouldRestartDaemonForRuntimeMismatch = (args) => {
-    const versionMismatch = Boolean(args.expectedVersion &&
-        args.actualVersion &&
-        args.actualVersion !== args.expectedVersion);
-    const scriptChangedSinceStart = Boolean(args.expectedScriptMtimeMs &&
-        args.startedAtMs &&
-        args.expectedScriptMtimeMs > args.startedAtMs + 250);
-    return {
-        versionMismatch,
-        scriptChangedSinceStart,
-        shouldRestart: versionMismatch || scriptChangedSinceStart,
-    };
-};
-const terminateDaemonPid = async (socketPath, pid, reason) => {
-    const termSent = signalPid(pid, "SIGTERM");
-    if (!termSent) {
-        return;
-    }
-    const exitedGracefully = await waitForPidExit(pid, DAEMON_PID_EXIT_GRACE_MS);
-    if (exitedGracefully) {
-        return;
-    }
-    logger.warn("daemon_force_kill", {
-        socketPath,
-        pid,
-        reason,
-    });
-    const killSent = signalPid(pid, "SIGKILL");
-    if (!killSent) {
-        return;
-    }
-    const exitedAfterKill = await waitForPidExit(pid, DAEMON_FORCE_KILL_TIMEOUT_MS);
-    if (exitedAfterKill) {
-        return;
-    }
-    throw new Error(`dvbd pid ${pid} did not exit after SIGKILL`);
-};
-const terminateDaemonPids = async (socketPath, pids, reason) => {
-    for (const pid of pids) {
-        await terminateDaemonPid(socketPath, pid, reason);
-    }
-};
-export const requestJson = async (socketPath, method, requestPath, timeoutMs, body) => {
-    const requestId = randomUUID();
-    logger.info("daemon_request", {
-        requestId,
-        method,
-        path: requestPath,
-    });
-    return new Promise((resolve, reject) => {
-        const payload = body ? JSON.stringify(body) : null;
-        const headers = injectActiveTraceContextHeaders({
-            "x-request-id": requestId,
-            ...(payload
-                ? {
-                    "content-type": "application/json",
-                    "content-length": Buffer.byteLength(payload).toString(),
-                }
-                : {}),
-        });
-        const req = http.request({
-            method,
-            socketPath,
-            path: requestPath,
-            headers,
-        }, (res) => {
-            const chunks = [];
-            res.on("data", (chunk) => {
-                chunks.push(Buffer.from(chunk));
-            });
-            res.on("end", () => {
-                const payload = Buffer.concat(chunks).toString("utf8");
-                let parsedBody = {};
-                let parseError;
-                if (payload) {
-                    try {
-                        parsedBody = JSON.parse(payload);
-                    }
-                    catch (error) {
-                        parseError =
-                            error instanceof Error ? error.message : "invalid_json";
-                        logger.warn("daemon_response_invalid_json", {
-                            requestId,
-                            method,
-                            path: requestPath,
-                            status: res.statusCode,
-                            error: parseError,
-                        });
-                    }
-                }
-                logger.info("daemon_response", {
-                    requestId,
-                    method,
-                    path: requestPath,
-                    status: res.statusCode,
-                });
-                resolve({
-                    status: res.statusCode ?? 0,
-                    body: parsedBody,
-                    ...(payload ? { rawBody: payload } : {}),
-                    ...(parseError ? { parseError } : {}),
-                });
-            });
-        });
-        req.on("error", (error) => {
-            if (isConnectionError(error)) {
-                reject(new DaemonConnectionError(socketPath, error));
-                return;
-            }
-            reject(error);
-        });
-        req.setTimeout(timeoutMs, () => {
-            req.destroy(new Error("request_timeout"));
-        });
-        if (payload) {
-            req.write(payload);
-        }
-        req.end();
-    });
-};
-export const requireDaemonFeatures = async (socketPath, required) => {
-    if (!required.length)
-        return;
-    let available = daemonFeaturesCache.get(socketPath);
-    if (!available) {
-        const response = await requestJson(socketPath, "GET", "/version", DAEMON_TIMEOUT_MS.quick);
-        if (response.status !== 200) {
-            throw new Error("dvbd does not support this command. Restart the daemon and try again.");
-        }
-        const features = Array.isArray(response.body.features)
-            ? response.body.features
-            : [];
-        available = new Set(features);
-        daemonFeaturesCache.set(socketPath, available);
-    }
-    const missing = required.filter((feature) => !available.has(feature));
-    if (missing.length) {
-        throw new Error(`dvbd is missing required capabilities (${missing.join(", ")}). Restart the daemon and try again.`);
-    }
-};
-const resolveDaemonCommand = () => {
-    if (process.env.DEVBOXD_BIN_PATH) {
-        return {
-            command: process.execPath,
-            args: [process.env.DEVBOXD_BIN_PATH],
-            source: "env",
-        };
-    }
-    if (process.argv[1]) {
-        return {
-            command: process.execPath,
-            args: [process.argv[1], "--daemon"],
-            source: "self",
-        };
-    }
-    return {
-        command: process.execPath,
-        args: ["--daemon"],
-        source: "self",
-    };
-};
-const resolveExpectedDaemonScriptPath = () => {
-    const command = resolveDaemonCommand();
-    const scriptPath = command.args[0]?.trim() ?? "";
-    if (!scriptPath || scriptPath === "--daemon") {
-        return null;
-    }
-    return scriptPath;
-};
-const readExpectedDaemonScriptMtimeMs = () => {
-    const scriptPath = resolveExpectedDaemonScriptPath();
-    if (!scriptPath) {
-        return null;
-    }
-    try {
-        return fs.statSync(scriptPath).mtimeMs;
-    }
-    catch {
-        return null;
-    }
-};
-const spawnDaemon = (socketPath) => {
-    const command = resolveDaemonCommand();
-    const controlPlaneUrl = getControlPlaneUrl();
-    const convexUrl = getConvexUrl();
-    const runtimeDir = path.dirname(socketPath);
-    const logPath = path.join(runtimeDir, "dvbd.log");
-    let logFd = null;
-    try {
-        // Keep daemon startup logs somewhere users can inspect when health checks fail.
-        logFd = fs.openSync(logPath, "a");
-    }
-    catch {
-        logFd = null;
-    }
-    logger.info("daemon_spawn", {
-        socketPath,
-        command: command.command,
-        args: command.args,
-        source: command.source,
-        ...(logFd !== null ? { logPath } : {}),
-    });
-    const child = spawn(command.command, command.args, {
-        env: {
-            ...process.env,
-            DEVBOX_SOCKET_PATH: socketPath,
-            ...(controlPlaneUrl ? { DEVBOX_CONTROL_PLANE_URL: controlPlaneUrl } : {}),
-            ...(convexUrl ? { DEVBOX_CONVEX_URL: convexUrl } : {}),
-        },
-        stdio: logFd !== null ? ["ignore", logFd, logFd] : "ignore",
-        detached: true,
-    });
-    if (logFd !== null) {
-        try {
-            fs.closeSync(logFd);
-        }
-        catch {
-            // ignore
-        }
-    }
-    child.unref();
-};
-const waitForHealth = async (socketPath, timeoutMs) => {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        try {
-            const response = await requestJson(socketPath, "GET", "/health", DAEMON_TIMEOUT_MS.quick);
-            if (response.status === 200 && response.body.ok)
-                return response.body;
-        }
-        catch {
-            // retry until timeout
-        }
-        await new Promise((resolve) => setTimeout(resolve, 150));
-    }
-    throw new Error("dvbd did not become healthy in time");
-};
-const listAlternateSocketPaths = (primary) => {
-    const candidates = new Set();
-    const envWithoutSocket = { ...process.env };
-    delete envWithoutSocket.DEVBOX_SOCKET_PATH;
-    const fallback = resolveSocketInfo(envWithoutSocket).socketPath;
-    candidates.add(fallback);
-    const homeDir = process.env.HOME?.trim();
-    if (homeDir) {
-        candidates.add(path.join(resolveDevboxDir(homeDir), "run", "devboxd.sock"));
-    }
-    candidates.delete(primary);
-    return [...candidates].filter((socketPath) => {
-        if (!isSocketPathTooLong(socketPath))
-            return true;
-        logger.warn("daemon_duplicate_check_skipped", {
-            socketPath,
-            reason: "socket_path_too_long",
-        });
-        return false;
-    });
-};
-const pruneDuplicateDaemons = async (primary) => {
-    const candidates = listAlternateSocketPaths(primary);
-    for (const socketPath of candidates) {
-        try {
-            const health = await requestJson(socketPath, "GET", "/health", DAEMON_TIMEOUT_MS.health);
-            if (health.status === 200 && health.body.ok) {
-                logger.warn("daemon_duplicate_detected", {
-                    socketPath,
-                    pid: health.body.pid,
-                });
-                await stopDaemon(socketPath);
-            }
-        }
-        catch (error) {
-            if (!isConnectionError(error)) {
-                logger.warn("daemon_duplicate_check_failed", {
-                    socketPath,
-                    error: String(error),
-                });
-            }
-        }
-    }
-};
-const listDaemonPidsForSocket = (socketPath) => {
-    const ps = spawnSync("ps", ["eww", "-Ao", "pid=,command="], {
-        encoding: "utf8",
-    });
-    if (ps.status !== 0 || typeof ps.stdout !== "string") {
-        return [];
-    }
-    const expectedSocketEnv = `DEVBOX_SOCKET_PATH=${socketPath}`;
-    const pids = new Set();
-    for (const rawLine of ps.stdout.split(/\r?\n/)) {
-        const line = rawLine.trim();
-        if (!line)
-            continue;
-        if (!line.includes(" --daemon"))
-            continue;
-        if (!line.includes("dvb.cjs") && !line.includes("dvbd.cjs"))
-            continue;
-        if (!line.includes(expectedSocketEnv))
-            continue;
-        const firstSpace = line.indexOf(" ");
-        if (firstSpace <= 0)
-            continue;
-        const pid = Number.parseInt(line.slice(0, firstSpace).trim(), 10);
-        if (!Number.isFinite(pid) || pid <= 0 || pid === process.pid)
-            continue;
-        pids.add(pid);
-    }
-    return [...pids];
-};
-const pruneSameSocketDaemons = async (socketPath, keepPid) => {
-    const pids = listDaemonPidsForSocket(socketPath);
-    for (const pid of pids) {
-        if (pid === keepPid)
-            continue;
-        logger.warn("daemon_duplicate_same_socket_detected", {
-            socketPath,
-            keepPid,
-            duplicatePid: pid,
-        });
-        try {
-            await terminateDaemonPid(socketPath, pid, "duplicate_same_socket");
-        }
-        catch (error) {
-            const code = error?.code;
-            if (code !== "ESRCH") {
-                logger.warn("daemon_duplicate_same_socket_stop_failed", {
-                    socketPath,
-                    duplicatePid: pid,
-                    error: String(error),
-                });
-            }
-        }
-    }
-};
-const maybeRestartDaemonForVersionMismatch = async (socketPath, health) => {
-    const expected = normalizeVersion(readExpectedDaemonVersion());
-    const expectedScriptMtimeMs = readExpectedDaemonScriptMtimeMs();
-    const startedAtMs = parseIsoTimestampMs(health.startedAt);
-    if (!expected && !expectedScriptMtimeMs)
-        return health;
-    const versionResponse = await requestJson(socketPath, "GET", "/version", DAEMON_TIMEOUT_MS.quick);
-    if (versionResponse.status !== 200)
-        return health;
-    const actual = normalizeVersion(versionResponse.body.version);
-    const mismatch = shouldRestartDaemonForRuntimeMismatch({
-        expectedVersion: expected,
-        actualVersion: actual,
-        expectedScriptMtimeMs,
-        startedAtMs,
-    });
-    if (!mismatch.shouldRestart)
-        return health;
-    logger.warn(mismatch.versionMismatch
-        ? "daemon_version_mismatch"
-        : "daemon_script_stale", {
-        socketPath,
-        pid: health.pid,
-        expected,
-        actual,
-        ...(expectedScriptMtimeMs
-            ? { expectedScriptMtimeMs: Math.trunc(expectedScriptMtimeMs) }
-            : {}),
-        ...(startedAtMs ? { startedAtMs: Math.trunc(startedAtMs) } : {}),
-    });
-    try {
-        await stopDaemon(socketPath);
-    }
-    catch (error) {
-        logger.warn("daemon_restart_failed", {
-            socketPath,
-            pid: health.pid,
-            error: String(error),
-        });
-        return health;
-    }
-    spawnDaemon(socketPath);
-    return await waitForHealth(socketPath, 5000);
-};
-const readHealthyDaemon = async (socketPath, timeoutMs) => {
-    try {
-        const response = await requestJson(socketPath, "GET", "/health", timeoutMs);
-        if (response.status === 200 && response.body.ok) {
-            return response.body;
-        }
-    }
-    catch (error) {
-        if (!isConnectionError(error))
-            throw error;
-    }
-    return null;
-};
-export const ensureDaemonRunning = async (socketPath) => {
-    const inFlight = ensureDaemonRunningInFlight.get(socketPath);
-    if (inFlight) {
-        return await inFlight;
-    }
-    const ensure = (async () => {
-        daemonFeaturesCache.delete(socketPath);
-        const active = await readHealthyDaemon(socketPath, DAEMON_TIMEOUT_MS.health);
-        if (active) {
-            await pruneDuplicateDaemons(socketPath);
-            const health = await maybeRestartDaemonForVersionMismatch(socketPath, active);
-            await pruneSameSocketDaemons(socketPath, health.pid);
-            return health;
-        }
-        await pruneDuplicateDaemons(socketPath);
-        const existingDaemonPids = listDaemonPidsForSocket(socketPath);
-        const socketExists = await hasSocketPath(socketPath);
-        if (existingDaemonPids.length > 0 && !socketExists) {
-            logger.warn("daemon_orphan_detected", {
-                socketPath,
-                pids: existingDaemonPids,
-            });
-            await terminateDaemonPids(socketPath, existingDaemonPids, "missing_socket");
-            spawnDaemon(socketPath);
-            const health = await waitForHealth(socketPath, 5000);
-            await pruneSameSocketDaemons(socketPath, health.pid);
-            return health;
-        }
-        const recoverTimeoutMs = existingDaemonPids.length > 0 ? ACTIVE_DAEMON_RECOVERY_TIMEOUT_MS : 1200;
-        // If the daemon process still exists, prefer waiting for it to finish
-        // in-flight work rather than replacing it on the same socket.
-        try {
-            const recovered = await waitForHealth(socketPath, recoverTimeoutMs);
-            const health = await maybeRestartDaemonForVersionMismatch(socketPath, recovered);
-            await pruneSameSocketDaemons(socketPath, health.pid);
-            return health;
-        }
-        catch {
-            // Fall through to daemon spawn when the existing socket truly is unhealthy.
-        }
-        if (existingDaemonPids.length > 0) {
-            logger.warn("daemon_unhealthy_reaping_before_restart", {
-                socketPath,
-                pids: existingDaemonPids,
-            });
-            await terminateDaemonPids(socketPath, existingDaemonPids, "unhealthy_after_recovery_timeout");
-        }
-        spawnDaemon(socketPath);
-        const health = await waitForHealth(socketPath, 5000);
-        await pruneSameSocketDaemons(socketPath, health.pid);
-        return health;
-    })();
-    ensureDaemonRunningInFlight.set(socketPath, ensure);
-    try {
-        return await ensure;
-    }
-    finally {
-        if (ensureDaemonRunningInFlight.get(socketPath) === ensure) {
-            ensureDaemonRunningInFlight.delete(socketPath);
-        }
-    }
-};
-// Best-effort: if dvbd is already running, ensure it's the same version as the
-// currently installed CLI package. This avoids a common footgun where upgrading
-// `dvb` leaves a long-running older dvbd process in place.
-//
-// Intentionally does not spawn the daemon if it's not running; callers that
-// need dvbd should use `ensureDaemonRunning`.
-export const ensureDaemonUpToDateIfRunning = async (socketPath) => {
-    daemonFeaturesCache.delete(socketPath);
-    const active = await readHealthyDaemon(socketPath, DAEMON_TIMEOUT_MS.health);
-    if (active) {
-        await pruneDuplicateDaemons(socketPath);
-        const health = await maybeRestartDaemonForVersionMismatch(socketPath, active);
-        await pruneSameSocketDaemons(socketPath, health.pid);
-        return health;
-    }
-    return null;
-};
-export const __testOnly = {
-    shouldRestartDaemonForRuntimeMismatch,
-};
-export const stopDaemon = async (socketPath) => {
-    daemonFeaturesCache.delete(socketPath);
-    try {
-        const health = await requestJson(socketPath, "GET", "/health", DAEMON_TIMEOUT_MS.health);
-        if (health.status === 200 && health.body.ok) {
-            await terminateDaemonPid(socketPath, health.body.pid, "stop_daemon");
-            return true;
-        }
-    }
-    catch (error) {
-        if (!isConnectionError(error))
-            throw error;
-    }
-    const existingDaemonPids = listDaemonPidsForSocket(socketPath);
-    if (existingDaemonPids.length === 0) {
-        return false;
-    }
-    logger.warn("daemon_orphan_detected", {
-        socketPath,
-        pids: existingDaemonPids,
-    });
-    await terminateDaemonPids(socketPath, existingDaemonPids, "stop_daemon_orphan");
-    if (await hasSocketPath(socketPath)) {
-        logger.warn("daemon_socket_still_present_after_stop", {
-            socketPath,
-        });
-    }
-    return true;
-};
-//# sourceMappingURL=daemonClient.js.map