@poolzin/pool-bot 2026.3.27 → 2026.3.28

package/dist/daemon/launchd.js

@@ -1,319 +0,0 @@
-import { execFile } from "node:child_process";
-import fs from "node:fs/promises";
-import path from "node:path";
-import { promisify } from "node:util";
-import { colorize, isRich, theme } from "../terminal/theme.js";
-import { formatGatewayServiceDescription, GATEWAY_LAUNCH_AGENT_LABEL, LEGACY_GATEWAY_LAUNCH_AGENT_LABELS, resolveGatewayLaunchAgentLabel, } from "./constants.js";
-import { buildLaunchAgentPlist as buildLaunchAgentPlistImpl, readLaunchAgentProgramArgumentsFromFile, } from "./launchd-plist.js";
-import { parseKeyValueOutput } from "./runtime-parse.js";
-import { resolveGatewayStateDir, resolveHomeDir } from "./paths.js";
-const execFileAsync = promisify(execFile);
-const toPosixPath = (value) => value.replace(/\\/g, "/");
-const formatLine = (label, value) => {
-    const rich = isRich();
-    return `${colorize(rich, theme.muted, `${label}:`)} ${colorize(rich, theme.command, value)}`;
-};
-function resolveLaunchAgentLabel(args) {
-    const envLabel = args?.env?.POOLBOT_LAUNCHD_LABEL?.trim() || args?.env?.CLAWDBOT_LAUNCHD_LABEL?.trim();
-    if (envLabel)
-        return envLabel;
-    return resolveGatewayLaunchAgentLabel(args?.env?.POOLBOT_PROFILE ?? args?.env?.CLAWDBOT_PROFILE);
-}
-function resolveLaunchAgentPlistPathForLabel(env, label) {
-    const home = toPosixPath(resolveHomeDir(env));
-    return path.posix.join(home, "Library", "LaunchAgents", `${label}.plist`);
-}
-export function resolveLaunchAgentPlistPath(env) {
-    const label = resolveLaunchAgentLabel({ env });
-    return resolveLaunchAgentPlistPathForLabel(env, label);
-}
-export function resolveGatewayLogPaths(env) {
-    const stateDir = resolveGatewayStateDir(env);
-    const logDir = path.join(stateDir, "logs");
-    const prefix = env.POOLBOT_LOG_PREFIX?.trim() || env.CLAWDBOT_LOG_PREFIX?.trim() || "gateway";
-    return {
-        logDir,
-        stdoutPath: path.join(logDir, `${prefix}.log`),
-        stderrPath: path.join(logDir, `${prefix}.err.log`),
-    };
-}
-export async function readLaunchAgentProgramArguments(env) {
-    const plistPath = resolveLaunchAgentPlistPath(env);
-    return readLaunchAgentProgramArgumentsFromFile(plistPath);
-}
-export function buildLaunchAgentPlist({ label = GATEWAY_LAUNCH_AGENT_LABEL, comment, programArguments, workingDirectory, stdoutPath, stderrPath, environment, }) {
-    return buildLaunchAgentPlistImpl({
-        label,
-        comment,
-        programArguments,
-        workingDirectory,
-        stdoutPath,
-        stderrPath,
-        environment,
-    });
-}
-async function execLaunchctl(args) {
-    try {
-        const { stdout, stderr } = await execFileAsync("launchctl", args, {
-            encoding: "utf8",
-            shell: process.platform === "win32",
-        });
-        return {
-            stdout: String(stdout ?? ""),
-            stderr: String(stderr ?? ""),
-            code: 0,
-        };
-    }
-    catch (error) {
-        const e = error;
-        return {
-            stdout: typeof e.stdout === "string" ? e.stdout : "",
-            stderr: typeof e.stderr === "string" ? e.stderr : typeof e.message === "string" ? e.message : "",
-            code: typeof e.code === "number" ? e.code : 1,
-        };
-    }
-}
-function resolveGuiDomain() {
-    if (typeof process.getuid !== "function")
-        return "gui/501";
-    return `gui/${process.getuid()}`;
-}
-export function parseLaunchctlPrint(output) {
-    const entries = parseKeyValueOutput(output, "=");
-    const info = {};
-    const state = entries.state;
-    if (state)
-        info.state = state;
-    const pidValue = entries.pid;
-    if (pidValue) {
-        const pid = Number.parseInt(pidValue, 10);
-        if (Number.isFinite(pid))
-            info.pid = pid;
-    }
-    const exitStatusValue = entries["last exit status"];
-    if (exitStatusValue) {
-        const status = Number.parseInt(exitStatusValue, 10);
-        if (Number.isFinite(status))
-            info.lastExitStatus = status;
-    }
-    const exitReason = entries["last exit reason"];
-    if (exitReason)
-        info.lastExitReason = exitReason;
-    return info;
-}
-export async function isLaunchAgentLoaded(args) {
-    const domain = resolveGuiDomain();
-    const label = resolveLaunchAgentLabel({ env: args.env });
-    const res = await execLaunchctl(["print", `${domain}/${label}`]);
-    return res.code === 0;
-}
-export async function isLaunchAgentListed(args) {
-    const label = resolveLaunchAgentLabel({ env: args.env });
-    const res = await execLaunchctl(["list"]);
-    if (res.code !== 0)
-        return false;
-    return res.stdout.split(/\r?\n/).some((line) => line.trim().split(/\s+/).at(-1) === label);
-}
-export async function launchAgentPlistExists(env) {
-    try {
-        const plistPath = resolveLaunchAgentPlistPath(env);
-        await fs.access(plistPath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export async function readLaunchAgentRuntime(env) {
-    const domain = resolveGuiDomain();
-    const label = resolveLaunchAgentLabel({ env });
-    const res = await execLaunchctl(["print", `${domain}/${label}`]);
-    if (res.code !== 0) {
-        return {
-            status: "unknown",
-            detail: (res.stderr || res.stdout).trim() || undefined,
-            missingUnit: true,
-        };
-    }
-    const parsed = parseLaunchctlPrint(res.stdout || res.stderr || "");
-    const plistExists = await launchAgentPlistExists(env);
-    const state = parsed.state?.toLowerCase();
-    const status = state === "running" || parsed.pid ? "running" : state ? "stopped" : "unknown";
-    return {
-        status,
-        state: parsed.state,
-        pid: parsed.pid,
-        lastExitStatus: parsed.lastExitStatus,
-        lastExitReason: parsed.lastExitReason,
-        cachedLabel: !plistExists,
-    };
-}
-export async function repairLaunchAgentBootstrap(args) {
-    const env = args.env ?? process.env;
-    const domain = resolveGuiDomain();
-    const label = resolveLaunchAgentLabel({ env });
-    const plistPath = resolveLaunchAgentPlistPath(env);
-    const boot = await execLaunchctl(["bootstrap", domain, plistPath]);
-    if (boot.code !== 0) {
-        return { ok: false, detail: (boot.stderr || boot.stdout).trim() || undefined };
-    }
-    const kick = await execLaunchctl(["kickstart", "-k", `${domain}/${label}`]);
-    if (kick.code !== 0) {
-        return { ok: false, detail: (kick.stderr || kick.stdout).trim() || undefined };
-    }
-    return { ok: true };
-}
-export async function findLegacyLaunchAgents(env) {
-    const domain = resolveGuiDomain();
-    const results = [];
-    for (const label of LEGACY_GATEWAY_LAUNCH_AGENT_LABELS) {
-        const plistPath = resolveLaunchAgentPlistPathForLabel(env, label);
-        const res = await execLaunchctl(["print", `${domain}/${label}`]);
-        const loaded = res.code === 0;
-        let exists = false;
-        try {
-            await fs.access(plistPath);
-            exists = true;
-        }
-        catch {
-            // ignore
-        }
-        if (loaded || exists) {
-            results.push({ label, plistPath, loaded, exists });
-        }
-    }
-    return results;
-}
-export async function uninstallLegacyLaunchAgents({ env, stdout, }) {
-    const domain = resolveGuiDomain();
-    const agents = await findLegacyLaunchAgents(env);
-    if (agents.length === 0)
-        return agents;
-    const home = resolveHomeDir(env);
-    const trashDir = path.join(home, ".Trash");
-    try {
-        await fs.mkdir(trashDir, { recursive: true });
-    }
-    catch {
-        // ignore
-    }
-    for (const agent of agents) {
-        await execLaunchctl(["bootout", domain, agent.plistPath]);
-        await execLaunchctl(["unload", agent.plistPath]);
-        try {
-            await fs.access(agent.plistPath);
-        }
-        catch {
-            continue;
-        }
-        const dest = path.join(trashDir, `${agent.label}.plist`);
-        try {
-            await fs.rename(agent.plistPath, dest);
-            stdout.write(`${formatLine("Moved legacy LaunchAgent to Trash", dest)}\n`);
-        }
-        catch {
-            stdout.write(`Legacy LaunchAgent remains at ${agent.plistPath} (could not move)\n`);
-        }
-    }
-    return agents;
-}
-export async function uninstallLaunchAgent({ env, stdout, }) {
-    const domain = resolveGuiDomain();
-    const label = resolveLaunchAgentLabel({ env });
-    const plistPath = resolveLaunchAgentPlistPath(env);
-    await execLaunchctl(["bootout", domain, plistPath]);
-    await execLaunchctl(["unload", plistPath]);
-    try {
-        await fs.access(plistPath);
-    }
-    catch {
-        stdout.write(`LaunchAgent not found at ${plistPath}\n`);
-        return;
-    }
-    const home = resolveHomeDir(env);
-    const trashDir = path.join(home, ".Trash");
-    const dest = path.join(trashDir, `${label}.plist`);
-    try {
-        await fs.mkdir(trashDir, { recursive: true });
-        await fs.rename(plistPath, dest);
-        stdout.write(`${formatLine("Moved LaunchAgent to Trash", dest)}\n`);
-    }
-    catch {
-        stdout.write(`LaunchAgent remains at ${plistPath} (could not move)\n`);
-    }
-}
-function isLaunchctlNotLoaded(res) {
-    const detail = `${res.stderr || res.stdout}`.toLowerCase();
-    return (detail.includes("no such process") ||
-        detail.includes("could not find service") ||
-        detail.includes("not found"));
-}
-export async function stopLaunchAgent({ stdout, env, }) {
-    const domain = resolveGuiDomain();
-    const label = resolveLaunchAgentLabel({ env });
-    const res = await execLaunchctl(["bootout", `${domain}/${label}`]);
-    if (res.code !== 0 && !isLaunchctlNotLoaded(res)) {
-        throw new Error(`launchctl bootout failed: ${res.stderr || res.stdout}`.trim());
-    }
-    stdout.write(`${formatLine("Stopped LaunchAgent", `${domain}/${label}`)}\n`);
-}
-export async function installLaunchAgent({ env, stdout, programArguments, workingDirectory, environment, description, }) {
-    const { logDir, stdoutPath, stderrPath } = resolveGatewayLogPaths(env);
-    await fs.mkdir(logDir, { recursive: true });
-    const domain = resolveGuiDomain();
-    const label = resolveLaunchAgentLabel({ env });
-    for (const legacyLabel of LEGACY_GATEWAY_LAUNCH_AGENT_LABELS) {
-        const legacyPlistPath = resolveLaunchAgentPlistPathForLabel(env, legacyLabel);
-        await execLaunchctl(["bootout", domain, legacyPlistPath]);
-        await execLaunchctl(["unload", legacyPlistPath]);
-        try {
-            await fs.unlink(legacyPlistPath);
-        }
-        catch {
-            // ignore
-        }
-    }
-    const plistPath = resolveLaunchAgentPlistPathForLabel(env, label);
-    await fs.mkdir(path.dirname(plistPath), { recursive: true });
-    const serviceDescription = description ??
-        formatGatewayServiceDescription({
-            profile: env.POOLBOT_PROFILE ?? env.CLAWDBOT_PROFILE,
-            version: environment?.POOLBOT_SERVICE_VERSION ??
-                environment?.CLAWDBOT_SERVICE_VERSION ??
-                env.POOLBOT_SERVICE_VERSION ??
-                env.CLAWDBOT_SERVICE_VERSION,
-        });
-    const plist = buildLaunchAgentPlist({
-        label,
-        comment: serviceDescription,
-        programArguments,
-        workingDirectory,
-        stdoutPath,
-        stderrPath,
-        environment,
-    });
-    await fs.writeFile(plistPath, plist, "utf8");
-    await execLaunchctl(["bootout", domain, plistPath]);
-    await execLaunchctl(["unload", plistPath]);
-    // launchd can persist "disabled" state even after bootout + plist removal; clear it before bootstrap.
-    await execLaunchctl(["enable", `${domain}/${label}`]);
-    const boot = await execLaunchctl(["bootstrap", domain, plistPath]);
-    if (boot.code !== 0) {
-        throw new Error(`launchctl bootstrap failed: ${boot.stderr || boot.stdout}`.trim());
-    }
-    await execLaunchctl(["kickstart", "-k", `${domain}/${label}`]);
-    // Ensure we don't end up writing to a clack spinner line (wizards show progress without a newline).
-    stdout.write("\n");
-    stdout.write(`${formatLine("Installed LaunchAgent", plistPath)}\n`);
-    stdout.write(`${formatLine("Logs", stdoutPath)}\n`);
-    return { plistPath };
-}
-export async function restartLaunchAgent({ stdout, env, }) {
-    const domain = resolveGuiDomain();
-    const label = resolveLaunchAgentLabel({ env });
-    const res = await execLaunchctl(["kickstart", "-k", `${domain}/${label}`]);
-    if (res.code !== 0) {
-        throw new Error(`launchctl kickstart failed: ${res.stderr || res.stdout}`.trim());
-    }
-    stdout.write(`${formatLine("Restarted LaunchAgent", `${domain}/${label}`)}\n`);
-}

package/dist/daemon/legacy.js

@@ -1,44 +0,0 @@
-import { findLegacyLaunchAgents, uninstallLegacyLaunchAgents } from "./launchd.js";
-import { findLegacySystemdUnits, uninstallLegacySystemdUnits } from "./systemd.js";
-function formatLegacyLaunchAgents(agents) {
-    return agents.map((agent) => ({
-        platform: "darwin",
-        label: agent.label,
-        detail: [
-            agent.loaded ? "loaded" : "not loaded",
-            agent.exists ? `plist: ${agent.plistPath}` : "plist missing",
-        ].join(", "),
-    }));
-}
-function formatLegacySystemdUnits(units) {
-    return units.map((unit) => ({
-        platform: "linux",
-        label: `${unit.name}.service`,
-        detail: [
-            unit.enabled ? "enabled" : "disabled",
-            unit.exists ? `unit: ${unit.unitPath}` : "unit missing",
-        ].join(", "),
-    }));
-}
-export async function findLegacyGatewayServices(env) {
-    if (process.platform === "darwin") {
-        const agents = await findLegacyLaunchAgents(env);
-        return formatLegacyLaunchAgents(agents);
-    }
-    if (process.platform === "linux") {
-        const units = await findLegacySystemdUnits(env);
-        return formatLegacySystemdUnits(units);
-    }
-    return [];
-}
-export async function uninstallLegacyGatewayServices({ env, stdout, }) {
-    if (process.platform === "darwin") {
-        const agents = await uninstallLegacyLaunchAgents({ env, stdout });
-        return formatLegacyLaunchAgents(agents);
-    }
-    if (process.platform === "linux") {
-        const units = await uninstallLegacySystemdUnits({ env, stdout });
-        return formatLegacySystemdUnits(units);
-    }
-    return [];
-}

package/dist/daemon/node-service.js

@@ -1,67 +0,0 @@
-import { resolveGatewayService } from "./service.js";
-import { NODE_SERVICE_KIND, NODE_SERVICE_MARKER, NODE_WINDOWS_TASK_SCRIPT_NAME, resolveNodeLaunchAgentLabel, resolveNodeSystemdServiceName, resolveNodeWindowsTaskName, } from "./constants.js";
-function withNodeServiceEnv(env) {
-    return {
-        ...env,
-        POOLBOT_LAUNCHD_LABEL: resolveNodeLaunchAgentLabel(),
-        POOLBOT_SYSTEMD_UNIT: resolveNodeSystemdServiceName(),
-        POOLBOT_WINDOWS_TASK_NAME: resolveNodeWindowsTaskName(),
-        POOLBOT_TASK_SCRIPT_NAME: NODE_WINDOWS_TASK_SCRIPT_NAME,
-        POOLBOT_LOG_PREFIX: "node",
-        POOLBOT_SERVICE_MARKER: NODE_SERVICE_MARKER,
-        POOLBOT_SERVICE_KIND: NODE_SERVICE_KIND,
-        CLAWDBOT_LAUNCHD_LABEL: resolveNodeLaunchAgentLabel(),
-        CLAWDBOT_SYSTEMD_UNIT: resolveNodeSystemdServiceName(),
-        CLAWDBOT_WINDOWS_TASK_NAME: resolveNodeWindowsTaskName(),
-        CLAWDBOT_TASK_SCRIPT_NAME: NODE_WINDOWS_TASK_SCRIPT_NAME,
-        CLAWDBOT_LOG_PREFIX: "node",
-        CLAWDBOT_SERVICE_MARKER: NODE_SERVICE_MARKER,
-        CLAWDBOT_SERVICE_KIND: NODE_SERVICE_KIND,
-    };
-}
-function withNodeInstallEnv(args) {
-    return {
-        ...args,
-        env: withNodeServiceEnv(args.env),
-        environment: {
-            ...args.environment,
-            POOLBOT_LAUNCHD_LABEL: resolveNodeLaunchAgentLabel(),
-            POOLBOT_SYSTEMD_UNIT: resolveNodeSystemdServiceName(),
-            POOLBOT_WINDOWS_TASK_NAME: resolveNodeWindowsTaskName(),
-            POOLBOT_TASK_SCRIPT_NAME: NODE_WINDOWS_TASK_SCRIPT_NAME,
-            POOLBOT_LOG_PREFIX: "node",
-            POOLBOT_SERVICE_MARKER: NODE_SERVICE_MARKER,
-            POOLBOT_SERVICE_KIND: NODE_SERVICE_KIND,
-            CLAWDBOT_LAUNCHD_LABEL: resolveNodeLaunchAgentLabel(),
-            CLAWDBOT_SYSTEMD_UNIT: resolveNodeSystemdServiceName(),
-            CLAWDBOT_WINDOWS_TASK_NAME: resolveNodeWindowsTaskName(),
-            CLAWDBOT_TASK_SCRIPT_NAME: NODE_WINDOWS_TASK_SCRIPT_NAME,
-            CLAWDBOT_LOG_PREFIX: "node",
-            CLAWDBOT_SERVICE_MARKER: NODE_SERVICE_MARKER,
-            CLAWDBOT_SERVICE_KIND: NODE_SERVICE_KIND,
-        },
-    };
-}
-export function resolveNodeService() {
-    const base = resolveGatewayService();
-    return {
-        ...base,
-        install: async (args) => {
-            return base.install(withNodeInstallEnv(args));
-        },
-        uninstall: async (args) => {
-            return base.uninstall({ ...args, env: withNodeServiceEnv(args.env) });
-        },
-        stop: async (args) => {
-            return base.stop({ ...args, env: withNodeServiceEnv(args.env ?? {}) });
-        },
-        restart: async (args) => {
-            return base.restart({ ...args, env: withNodeServiceEnv(args.env ?? {}) });
-        },
-        isLoaded: async (args) => {
-            return base.isLoaded({ env: withNodeServiceEnv(args.env ?? {}) });
-        },
-        readCommand: (env) => base.readCommand(withNodeServiceEnv(env)),
-        readRuntime: (env) => base.readRuntime(withNodeServiceEnv(env)),
-    };
-}

package/dist/daemon/output.js

@@ -1,6 +0,0 @@
-import { colorize, isRich, theme } from "../terminal/theme.js";
-export const toPosixPath = (value) => value.replace(/\\/g, "/");
-export function formatLine(label, value) {
-    const rich = isRich();
-    return `${colorize(rich, theme.muted, `${label}:`)} ${colorize(rich, theme.command, value)}`;
-}

package/dist/daemon/paths.js

@@ -1,35 +0,0 @@
-import path from "node:path";
-import { resolveGatewayProfileSuffix } from "./constants.js";
-const windowsAbsolutePath = /^[a-zA-Z]:[\\/]/;
-const windowsUncPath = /^\\\\/;
-export function resolveHomeDir(env) {
-    const home = env.HOME?.trim() || env.USERPROFILE?.trim();
-    if (!home)
-        throw new Error("Missing HOME");
-    return home;
-}
-export function resolveUserPathWithHome(input, home) {
-    const trimmed = input.trim();
-    if (!trimmed)
-        return trimmed;
-    if (trimmed.startsWith("~")) {
-        if (!home)
-            throw new Error("Missing HOME");
-        const expanded = trimmed.replace(/^~(?=$|[\\/])/, home);
-        return path.resolve(expanded);
-    }
-    if (windowsAbsolutePath.test(trimmed) || windowsUncPath.test(trimmed)) {
-        return trimmed;
-    }
-    return path.resolve(trimmed);
-}
-export function resolveGatewayStateDir(env) {
-    const override = env.POOLBOT_STATE_DIR?.trim() || env.CLAWDBOT_STATE_DIR?.trim();
-    if (override) {
-        const home = override.startsWith("~") ? resolveHomeDir(env) : undefined;
-        return resolveUserPathWithHome(override, home);
-    }
-    const home = resolveHomeDir(env);
-    const suffix = resolveGatewayProfileSuffix(env.POOLBOT_PROFILE ?? env.CLAWDBOT_PROFILE);
-    return path.join(home, `.poolbot${suffix}`);
-}

package/dist/daemon/program-args.js

@@ -1,220 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-function isNodeRuntime(execPath) {
-    const base = path.basename(execPath).toLowerCase();
-    return base === "node" || base === "node.exe";
-}
-function isBunRuntime(execPath) {
-    const base = path.basename(execPath).toLowerCase();
-    return base === "bun" || base === "bun.exe";
-}
-async function resolveCliEntrypointPathForService() {
-    const argv1 = process.argv[1];
-    if (!argv1)
-        throw new Error("Unable to resolve CLI entrypoint path");
-    const normalized = path.resolve(argv1);
-    const resolvedPath = await resolveRealpathSafe(normalized);
-    const looksLikeDist = /[/\\]dist[/\\].+\.(cjs|js|mjs)$/.test(resolvedPath);
-    if (looksLikeDist) {
-        await fs.access(resolvedPath);
-        // Prefer the original (possibly symlinked) path over the resolved realpath.
-        // This keeps LaunchAgent/systemd paths stable across package version updates,
-        // since symlinks like node_modules/poolbot -> .pnpm/poolbot@X.Y.Z/...
-        // are automatically updated by pnpm, while the resolved path contains
-        // version-specific directories that break after updates.
-        const normalizedLooksLikeDist = /[/\\]dist[/\\].+\.(cjs|js|mjs)$/.test(normalized);
-        if (normalizedLooksLikeDist && normalized !== resolvedPath) {
-            try {
-                await fs.access(normalized);
-                return normalized;
-            }
-            catch {
-                // Fall through to return resolvedPath
-            }
-        }
-        return resolvedPath;
-    }
-    const distCandidates = buildDistCandidates(resolvedPath, normalized);
-    for (const candidate of distCandidates) {
-        try {
-            await fs.access(candidate);
-            return candidate;
-        }
-        catch {
-            // keep going
-        }
-    }
-    throw new Error(`Cannot find built CLI at ${distCandidates.join(" or ")}. Run "pnpm build" first, or use dev mode.`);
-}
-async function resolveRealpathSafe(inputPath) {
-    try {
-        return await fs.realpath(inputPath);
-    }
-    catch {
-        return inputPath;
-    }
-}
-function buildDistCandidates(...inputs) {
-    const candidates = [];
-    const seen = new Set();
-    for (const inputPath of inputs) {
-        if (!inputPath)
-            continue;
-        const baseDir = path.dirname(inputPath);
-        appendDistCandidates(candidates, seen, path.resolve(baseDir, ".."));
-        appendDistCandidates(candidates, seen, baseDir);
-        appendNodeModulesBinCandidates(candidates, seen, inputPath);
-    }
-    return candidates;
-}
-function appendDistCandidates(candidates, seen, baseDir) {
-    const distDir = path.resolve(baseDir, "dist");
-    const distEntries = [
-        path.join(distDir, "index.js"),
-        path.join(distDir, "index.mjs"),
-        path.join(distDir, "entry.js"),
-        path.join(distDir, "entry.mjs"),
-    ];
-    for (const entry of distEntries) {
-        if (seen.has(entry))
-            continue;
-        seen.add(entry);
-        candidates.push(entry);
-    }
-}
-function appendNodeModulesBinCandidates(candidates, seen, inputPath) {
-    const parts = inputPath.split(path.sep);
-    const binIndex = parts.lastIndexOf(".bin");
-    if (binIndex <= 0)
-        return;
-    if (parts[binIndex - 1] !== "node_modules")
-        return;
-    const binName = path.basename(inputPath);
-    const nodeModulesDir = parts.slice(0, binIndex).join(path.sep);
-    const packageRoot = path.join(nodeModulesDir, binName);
-    appendDistCandidates(candidates, seen, packageRoot);
-}
-function resolveRepoRootForDev() {
-    const argv1 = process.argv[1];
-    if (!argv1)
-        throw new Error("Unable to resolve repo root");
-    const normalized = path.resolve(argv1);
-    const parts = normalized.split(path.sep);
-    const srcIndex = parts.lastIndexOf("src");
-    if (srcIndex === -1) {
-        throw new Error("Dev mode requires running from repo (src/index.ts)");
-    }
-    return parts.slice(0, srcIndex).join(path.sep);
-}
-async function resolveBunPath() {
-    const bunPath = await resolveBinaryPath("bun");
-    return bunPath;
-}
-async function resolveNodePath() {
-    const nodePath = await resolveBinaryPath("node");
-    return nodePath;
-}
-async function resolveBinaryPath(binary) {
-    const { execSync } = await import("node:child_process");
-    const cmd = process.platform === "win32" ? "where" : "which";
-    try {
-        const output = execSync(`${cmd} ${binary}`, { encoding: "utf8" }).trim();
-        const resolved = output.split(/\r?\n/)[0]?.trim();
-        if (!resolved)
-            throw new Error("empty");
-        await fs.access(resolved);
-        return resolved;
-    }
-    catch {
-        if (binary === "bun") {
-            throw new Error("Bun not found in PATH. Install bun: https://bun.sh");
-        }
-        throw new Error("Node not found in PATH. Install Node 22+.");
-    }
-}
-async function resolveCliProgramArguments(params) {
-    const execPath = process.execPath;
-    const runtime = params.runtime ?? "auto";
-    if (runtime === "node") {
-        const nodePath = params.nodePath ?? (isNodeRuntime(execPath) ? execPath : await resolveNodePath());
-        const cliEntrypointPath = await resolveCliEntrypointPathForService();
-        return {
-            programArguments: [nodePath, cliEntrypointPath, ...params.args],
-        };
-    }
-    if (runtime === "bun") {
-        if (params.dev) {
-            const repoRoot = resolveRepoRootForDev();
-            const devCliPath = path.join(repoRoot, "src", "index.ts");
-            await fs.access(devCliPath);
-            const bunPath = isBunRuntime(execPath) ? execPath : await resolveBunPath();
-            return {
-                programArguments: [bunPath, devCliPath, ...params.args],
-                workingDirectory: repoRoot,
-            };
-        }
-        const bunPath = isBunRuntime(execPath) ? execPath : await resolveBunPath();
-        const cliEntrypointPath = await resolveCliEntrypointPathForService();
-        return {
-            programArguments: [bunPath, cliEntrypointPath, ...params.args],
-        };
-    }
-    if (!params.dev) {
-        try {
-            const cliEntrypointPath = await resolveCliEntrypointPathForService();
-            return {
-                programArguments: [execPath, cliEntrypointPath, ...params.args],
-            };
-        }
-        catch (error) {
-            // If running under bun or another runtime that can execute TS directly
-            if (!isNodeRuntime(execPath)) {
-                return { programArguments: [execPath, ...params.args] };
-            }
-            throw error;
-        }
-    }
-    // Dev mode: use bun to run TypeScript directly
-    const repoRoot = resolveRepoRootForDev();
-    const devCliPath = path.join(repoRoot, "src", "index.ts");
-    await fs.access(devCliPath);
-    // If already running under bun, use current execPath
-    if (isBunRuntime(execPath)) {
-        return {
-            programArguments: [execPath, devCliPath, ...params.args],
-            workingDirectory: repoRoot,
-        };
-    }
-    // Otherwise resolve bun from PATH
-    const bunPath = await resolveBunPath();
-    return {
-        programArguments: [bunPath, devCliPath, ...params.args],
-        workingDirectory: repoRoot,
-    };
-}
-export async function resolveGatewayProgramArguments(params) {
-    const gatewayArgs = ["gateway", "--port", String(params.port)];
-    return resolveCliProgramArguments({
-        args: gatewayArgs,
-        dev: params.dev,
-        runtime: params.runtime,
-        nodePath: params.nodePath,
-    });
-}
-export async function resolveNodeProgramArguments(params) {
-    const args = ["node", "run", "--host", params.host, "--port", String(params.port)];
-    if (params.tls || params.tlsFingerprint)
-        args.push("--tls");
-    if (params.tlsFingerprint)
-        args.push("--tls-fingerprint", params.tlsFingerprint);
-    if (params.nodeId)
-        args.push("--node-id", params.nodeId);
-    if (params.displayName)
-        args.push("--display-name", params.displayName);
-    return resolveCliProgramArguments({
-        args,
-        dev: params.dev,
-        runtime: params.runtime,
-        nodePath: params.nodePath,
-    });
-}