@indigoai-us/hq-cli 5.162.0 → 5.163.0

package/dist/lib/daemon/paths.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Per-host daemon files. These describe this machine's processes, so they live
+ * under ~/.hq/daemon and never under a synced HQ folder. Service logs can hold
+ * private output, so the folders are 0700 and the files 0600.
+ */
+export interface DaemonPaths {
+    root: string;
+    configPath: string;
+    statePath: string;
+    lockPath: string;
+    logsDir: string;
+    requestsDir: string;
+    supervisorLogPath: string;
+    unitLogPath: (unitId: string) => string;
+}
+export declare function daemonPaths(home?: string, env?: NodeJS.ProcessEnv): DaemonPaths;
+/** Create `dir` (and any missing parents) readable only by its owner, and tighten it if it already exists. */
+export declare function ensurePrivateDir(dir: string): void;
+/** Open a log file for appending, creating it (and its folder) owner-only. */
+export declare function openPrivateAppend(file: string): number;
+export declare function appendPrivate(file: string, text: string): void;
+//# sourceMappingURL=paths.d.ts.map

package/dist/lib/daemon/paths.js

@@ -0,0 +1,42 @@
+/**
+ * Per-host daemon files. These describe this machine's processes, so they live
+ * under ~/.hq/daemon and never under a synced HQ folder. Service logs can hold
+ * private output, so the folders are 0700 and the files 0600.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+export function daemonPaths(home = os.homedir(), env = process.env) {
+    const root = env.HQ_DAEMON_DIR?.trim() || path.join(home, ".hq", "daemon");
+    const logsDir = path.join(root, "logs");
+    return {
+        root,
+        configPath: path.join(root, "config.json"),
+        statePath: path.join(root, "state.json"),
+        lockPath: path.join(root, "daemon.pid"),
+        logsDir,
+        requestsDir: path.join(root, "requests"),
+        supervisorLogPath: path.join(logsDir, "daemon.log"),
+        unitLogPath: (unitId) => path.join(logsDir, `${unitId.replace(/[^A-Za-z0-9_.-]/g, "-")}.log`),
+    };
+}
+/** Create `dir` (and any missing parents) readable only by its owner, and tighten it if it already exists. */
+export function ensurePrivateDir(dir) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    fs.chmodSync(dir, 0o700);
+}
+/** Open a log file for appending, creating it (and its folder) owner-only. */
+export function openPrivateAppend(file) {
+    ensurePrivateDir(path.dirname(file));
+    return fs.openSync(file, "a", 0o600);
+}
+export function appendPrivate(file, text) {
+    const fd = openPrivateAppend(file);
+    try {
+        fs.writeSync(fd, text);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+//# sourceMappingURL=paths.js.map

package/dist/lib/daemon/remote-control.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The `remote-control` service host (`hq daemon service remote-control`).
+ *
+ * Like the outpost runner, `claude remote-control` runs inside a detached tmux
+ * session so Claude has a terminal. This host process starts the session and
+ * watches it; the daemon supervises the host:
+ *
+ * - the session ends -> the host exits 1 and the daemon restarts it with
+ *   backoff (replacing the runner's `while true` loop and its watchdogs);
+ * - the daemon stops the host -> the host kills the session and exits 0.
+ *
+ * The tmux server is a private socket (`-L hq-daemon`), so it never touches a
+ * user's own tmux sessions.
+ */
+import type { RunCommand } from "../service-manager/launchd.js";
+export declare const TMUX_SOCKET = "hq-daemon";
+export declare const TMUX_SESSION = "remote-control";
+export declare function remoteControlArgs(opts: {
+    name: string;
+    permissionMode?: string;
+}): string[];
+export interface RemoteControlHostDeps {
+    tmux: string;
+    claude: string;
+    hqRoot: string;
+    name: string;
+    permissionMode?: string;
+    run: RunCommand;
+    sleep: (ms: number) => Promise<void>;
+    pollMs: number;
+    signal: AbortSignal;
+    log: (line: string) => void;
+}
+export declare function runRemoteControlHost(deps: RemoteControlHostDeps): Promise<number>;
+//# sourceMappingURL=remote-control.d.ts.map

package/dist/lib/daemon/remote-control.js

@@ -0,0 +1,47 @@
+/**
+ * The `remote-control` service host (`hq daemon service remote-control`).
+ *
+ * Like the outpost runner, `claude remote-control` runs inside a detached tmux
+ * session so Claude has a terminal. This host process starts the session and
+ * watches it; the daemon supervises the host:
+ *
+ * - the session ends -> the host exits 1 and the daemon restarts it with
+ *   backoff (replacing the runner's `while true` loop and its watchdogs);
+ * - the daemon stops the host -> the host kills the session and exits 0.
+ *
+ * The tmux server is a private socket (`-L hq-daemon`), so it never touches a
+ * user's own tmux sessions.
+ */
+export const TMUX_SOCKET = "hq-daemon";
+export const TMUX_SESSION = "remote-control";
+export function remoteControlArgs(opts) {
+    const args = ["remote-control", "--name", opts.name, "--spawn=same-dir"];
+    if (opts.permissionMode)
+        args.push("--permission-mode", opts.permissionMode);
+    return args;
+}
+export async function runRemoteControlHost(deps) {
+    const tmux = (...args) => deps.run(deps.tmux, ["-L", TMUX_SOCKET, ...args]);
+    const killSession = () => tmux("kill-session", "-t", TMUX_SESSION);
+    // A session left by an earlier host (for example after a crash) is replaced.
+    killSession();
+    const started = tmux("new-session", "-d", "-s", TMUX_SESSION, "-x", "200", "-y", "50", "-c", deps.hqRoot, deps.claude, ...remoteControlArgs({ name: deps.name, permissionMode: deps.permissionMode }));
+    if (started.status !== 0) {
+        deps.log(`could not start the tmux session: ${started.stderr.trim() || `tmux exited ${started.status}`}`);
+        return 1;
+    }
+    deps.log(`claude remote-control started as "${deps.name}" in ${deps.hqRoot}`);
+    for (;;) {
+        if (deps.signal.aborted) {
+            killSession();
+            deps.log("stopped remote control");
+            return 0;
+        }
+        if (tmux("has-session", "-t", TMUX_SESSION).status !== 0) {
+            deps.log("the remote-control session ended");
+            return 1;
+        }
+        await deps.sleep(deps.pollMs);
+    }
+}
+//# sourceMappingURL=remote-control.js.map

package/dist/lib/daemon/requests.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Control requests from `hq daemon restart|trigger`, `hq bot start|stop` and the
+ * updater service to the running supervisor.
+ * Each request is one JSON file in ~/.hq/daemon/requests/; the supervisor
+ * polls the folder, applies requests oldest first, and deletes them. Files
+ * keep this working the same way on macOS, Linux and Windows.
+ */
+export type ControlRequest = {
+    action: "restart";
+    unit?: string;
+} | {
+    action: "trigger";
+    unit: string;
+} | {
+    action: "stop";
+    unit: string;
+}
+/** Restart the whole daemon, for example after the updater installed a new CLI. */
+ | {
+    action: "restart-daemon";
+};
+export declare function writeControlRequest(dir: string, request: ControlRequest, now?: () => number): string;
+export declare function takeControlRequests(dir: string): ControlRequest[];
+//# sourceMappingURL=requests.d.ts.map

package/dist/lib/daemon/requests.js

@@ -0,0 +1,63 @@
+/**
+ * Control requests from `hq daemon restart|trigger`, `hq bot start|stop` and the
+ * updater service to the running supervisor.
+ * Each request is one JSON file in ~/.hq/daemon/requests/; the supervisor
+ * polls the folder, applies requests oldest first, and deletes them. Files
+ * keep this working the same way on macOS, Linux and Windows.
+ */
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { ensurePrivateDir } from "./paths.js";
+function isControlRequest(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const v = value;
+    if (v.action === "restart")
+        return v.unit === undefined || typeof v.unit === "string";
+    if (v.action === "trigger" || v.action === "stop")
+        return typeof v.unit === "string";
+    if (v.action === "restart-daemon")
+        return true;
+    return false;
+}
+// Orders requests written by one process within the same millisecond; the
+// random part only keeps names from different processes apart.
+let sequence = 0;
+export function writeControlRequest(dir, request, now = Date.now) {
+    ensurePrivateDir(dir);
+    sequence = (sequence + 1) % 1_000_000;
+    const name = `${String(now()).padStart(15, "0")}-${String(sequence).padStart(6, "0")}-${crypto.randomBytes(4).toString("hex")}.json`;
+    const file = path.join(dir, name);
+    const tmp = `${file}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(request), { mode: 0o600 });
+    fs.renameSync(tmp, file);
+    return file;
+}
+export function takeControlRequests(dir) {
+    let names;
+    try {
+        names = fs.readdirSync(dir).filter((n) => n.endsWith(".json")).sort();
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return [];
+        throw err;
+    }
+    const requests = [];
+    for (const name of names) {
+        const file = path.join(dir, name);
+        let parsed;
+        try {
+            parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+        }
+        catch {
+            parsed = null;
+        }
+        fs.rmSync(file, { force: true });
+        if (isControlRequest(parsed))
+            requests.push(parsed);
+    }
+    return requests;
+}
+//# sourceMappingURL=requests.js.map

package/dist/lib/daemon/run.d.ts

@@ -0,0 +1,41 @@
+/**
+ * `hq daemon run` — wires the supervisor to real processes, files and signals.
+ *
+ * Each reconcile re-reads the config and re-probes the host (bots, sign-in,
+ * legacy units, the desktop app), so enabling a service, creating a bot, or
+ * signing in takes effect without restarting the daemon.
+ */
+import { type UnitPlan } from "./catalog.js";
+import { type LegacyUnit } from "./legacy.js";
+export declare const LOG_ROTATE_BYTES: number;
+/** Exit code for "restart me": non-zero so every service manager relaunches (Windows tasks only restart on failure). */
+export declare const RESTART_EXIT_CODE = 75;
+export interface RunDaemonOptions {
+    foreground?: boolean;
+    /** Started by the OS unit, which relaunches the daemon whenever it exits. */
+    managed?: boolean;
+    home?: string;
+    env?: NodeJS.ProcessEnv;
+    nodeBinary: string;
+    hqBinary: string;
+}
+export declare function resolveSyncRunnerPath(): string | null;
+export declare function listLocalBots(root?: string): string[];
+export declare function windowsTaskExists(taskName: string): boolean;
+export declare function probeLegacyUnits(platform: NodeJS.Platform, home: string): LegacyUnit[];
+/** Absolute path of `name` on PATH, or null. */
+export declare function findOnPath(name: string, env?: NodeJS.ProcessEnv): string | null;
+/** This CLI is a global package install the updater can replace (not a dev checkout or a project dependency). */
+export declare function cliSelfUpdatable(): boolean;
+/** The HQ desktop app process is running here (it runs its own sync). */
+export declare function desktopAppRunning(platform: NodeJS.Platform): boolean;
+/** Copy-and-truncate, so children appending with O_APPEND keep writing to the live file. */
+export declare function rotateLogs(logsDir: string, maxBytes?: number): number;
+/**
+ * Environment for one service process. The CLI's own update check is off:
+ * a child that updates itself exits 0 and asks to be rerun, which would leave
+ * an on-failure unit down. The daemon's updater handles CLI updates.
+ */
+export declare function unitProcessEnv(base: NodeJS.ProcessEnv, unit: UnitPlan): NodeJS.ProcessEnv;
+export declare function runDaemon(opts: RunDaemonOptions): Promise<number>;
+//# sourceMappingURL=run.d.ts.map

package/dist/lib/daemon/run.js

@@ -0,0 +1,319 @@
+/**
+ * `hq daemon run` — wires the supervisor to real processes, files and signals.
+ *
+ * Each reconcile re-reads the config and re-probes the host (bots, sign-in,
+ * legacy units, the desktop app), so enabling a service, creating a bot, or
+ * signing in takes effect without restarting the daemon.
+ */
+import { spawn, spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as os from "node:os";
+import * as path from "node:path";
+import { loadCachedTokens } from "@indigoai-us/hq-cloud";
+import { isLocalDependencyInstall, resolveRunningInstall } from "../../utils/version-gate.js";
+import { agentKitPaths } from "../agent-kit/paths.js";
+import { readBotConfig } from "../bot/config.js";
+import { botsRoot } from "../bot/paths.js";
+import { enabledServices, planUnits } from "./catalog.js";
+import { readDaemonConfig } from "./config.js";
+import { findLegacyUnits, legacyOwnerLookup } from "./legacy.js";
+import { acquireDaemonLock, releaseDaemonLock } from "./lock.js";
+import { detectMachineType } from "./machine-type.js";
+import { appendPrivate, daemonPaths, ensurePrivateDir, openPrivateAppend } from "./paths.js";
+import { takeControlRequests } from "./requests.js";
+import { STOP_ESCALATION_MS, createSupervisor } from "./supervisor.js";
+export const LOG_ROTATE_BYTES = 5 * 1024 * 1024;
+/** Exit code for "restart me": non-zero so every service manager relaunches (Windows tasks only restart on failure). */
+export const RESTART_EXIT_CODE = 75;
+const LEGACY_PROBE_TTL_MS = 60_000;
+export function resolveSyncRunnerPath() {
+    try {
+        const require = createRequire(import.meta.url);
+        const pkg = require.resolve("@indigoai-us/hq-cloud/package.json");
+        const runner = path.join(path.dirname(pkg), "dist", "bin", "sync-runner.js");
+        return fs.existsSync(runner) ? runner : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function listLocalBots(root = botsRoot()) {
+    if (!fs.existsSync(root))
+        return [];
+    return fs
+        .readdirSync(root, { withFileTypes: true })
+        .filter((d) => d.isDirectory() && readBotConfig(path.join(root, d.name)) !== null)
+        .map((d) => d.name)
+        .sort();
+}
+export function windowsTaskExists(taskName) {
+    const r = spawnSync("schtasks.exe", ["/Query", "/TN", taskName], { encoding: "utf8", windowsHide: true });
+    return r.status === 0;
+}
+export function probeLegacyUnits(platform, home) {
+    return findLegacyUnits({
+        platform,
+        home,
+        existsSync: fs.existsSync,
+        listDir: (dir) => fs.readdirSync(dir),
+        windowsTaskExists,
+    });
+}
+/** Absolute path of `name` on PATH, or null. */
+export function findOnPath(name, env = process.env) {
+    const dirs = (env.PATH ?? "").split(path.delimiter).filter(Boolean);
+    const exts = process.platform === "win32" ? (env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";") : [""];
+    for (const dir of dirs) {
+        for (const ext of exts) {
+            const candidate = path.join(dir, `${name}${ext}`);
+            try {
+                fs.accessSync(candidate, fs.constants.X_OK);
+                if (fs.statSync(candidate).isFile())
+                    return candidate;
+            }
+            catch {
+                // not here
+            }
+        }
+    }
+    return null;
+}
+/** This CLI is a global package install the updater can replace (not a dev checkout or a project dependency). */
+export function cliSelfUpdatable() {
+    const install = resolveRunningInstall();
+    if (!install.packageRoot)
+        return false;
+    const inNodeModules = install.packageRoot.split(/[\\/]/).includes("node_modules");
+    return inNodeModules && !isLocalDependencyInstall(install);
+}
+/** The HQ desktop app process is running here (it runs its own sync). */
+export function desktopAppRunning(platform) {
+    if (platform === "win32") {
+        const r = spawnSync("tasklist.exe", ["/FI", "IMAGENAME eq hq-sync-menubar.exe", "/NH"], {
+            encoding: "utf8",
+            windowsHide: true,
+        });
+        return r.status === 0 && /hq-sync-menubar\.exe/i.test(r.stdout);
+    }
+    const r = spawnSync("pgrep", ["-x", "hq-sync-menubar"], { encoding: "utf8" });
+    return r.status === 0;
+}
+function jobsReconcileScript(hqRoot) {
+    if (!hqRoot)
+        return null;
+    const script = path.join(hqRoot, "core", "scripts", "outpost-jobs-reconcile.sh");
+    return fs.existsSync(script) ? script : null;
+}
+function signedIn(env, home, log) {
+    if (fs.existsSync(agentKitPaths(home, env).machineCredsPath))
+        return true;
+    try {
+        return loadCachedTokens() !== null;
+    }
+    catch (err) {
+        log("warn", `could not read the cached HQ sign-in; treating this machine as signed out: ${err.message}`);
+        return false;
+    }
+}
+function writeJsonAtomic(file, value) {
+    ensurePrivateDir(path.dirname(file));
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}
+/** Copy-and-truncate, so children appending with O_APPEND keep writing to the live file. */
+export function rotateLogs(logsDir, maxBytes = LOG_ROTATE_BYTES) {
+    let rotated = 0;
+    let names;
+    try {
+        names = fs.readdirSync(logsDir);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return 0;
+        throw err;
+    }
+    for (const name of names) {
+        if (!name.endsWith(".log"))
+            continue;
+        const file = path.join(logsDir, name);
+        if (fs.statSync(file).size <= maxBytes)
+            continue;
+        fs.copyFileSync(file, `${file}.1`);
+        fs.truncateSync(file, 0);
+        rotated++;
+    }
+    return rotated;
+}
+function makeLogger(paths, foreground) {
+    ensurePrivateDir(paths.logsDir);
+    return (level, msg) => {
+        const line = `${new Date().toISOString()} ${level.padEnd(5)} ${msg}\n`;
+        try {
+            appendPrivate(paths.supervisorLogPath, line);
+        }
+        catch (err) {
+            process.stderr.write(`hq daemon: could not write log: ${err.message}\n`);
+        }
+        if (foreground)
+            (level === "info" ? process.stdout : process.stderr).write(line);
+    };
+}
+/**
+ * Environment for one service process. The CLI's own update check is off:
+ * a child that updates itself exits 0 and asks to be rerun, which would leave
+ * an on-failure unit down. The daemon's updater handles CLI updates.
+ */
+export function unitProcessEnv(base, unit) {
+    return { ...base, ...unit.env, HQ_DAEMON_UNIT: unit.id, HQ_NO_UPDATE_CHECK: "1" };
+}
+export async function runDaemon(opts) {
+    const env = opts.env ?? process.env;
+    const home = opts.home ?? os.homedir();
+    const platform = process.platform;
+    const paths = daemonPaths(home, env);
+    const log = makeLogger(paths, opts.foreground === true);
+    const lock = acquireDaemonLock(paths.lockPath);
+    if (!lock.ok) {
+        process.stderr.write(lock.owner ? `hq daemon is already running (pid ${lock.owner.pid}).\n` : "another hq daemon is starting up.\n");
+        return 1;
+    }
+    const initial = readDaemonConfig(paths.configPath);
+    const detected = detectMachineType(undefined, {
+        platform,
+        env,
+        home,
+        savedType: initial.machineType,
+        existsSync: fs.existsSync,
+        readFileSync: (p) => fs.readFileSync(p, "utf8"),
+    });
+    const machineType = detected.type;
+    for (const w of detected.warnings ?? [])
+        log("warn", w);
+    log("info", `starting hq daemon (pid ${process.pid}) as ${machineType} (${detected.detail})`);
+    const syncRunnerPath = resolveSyncRunnerPath();
+    if (!syncRunnerPath)
+        log("warn", "the hq-cloud sync runner was not found in this CLI install; sync is unavailable");
+    const updatable = cliSelfUpdatable();
+    const hostName = os.hostname().split(".")[0] || "hq-host";
+    let legacyCache = null;
+    const legacyUnits = () => {
+        if (!legacyCache || Date.now() - legacyCache.at > LEGACY_PROBE_TTL_MS) {
+            legacyCache = { at: Date.now(), units: probeLegacyUnits(platform, home) };
+        }
+        return legacyCache.units;
+    };
+    const plan = () => {
+        const config = readDaemonConfig(paths.configPath);
+        const legacy = legacyUnits();
+        const configured = config.hqRoot ?? env.HQ_ROOT?.trim() ?? undefined;
+        const hqRoot = configured && fs.existsSync(configured) ? configured : undefined;
+        return planUnits(enabledServices(machineType, config), {
+            machineType,
+            platform,
+            home,
+            hqRoot,
+            syncRunnerPath,
+            signedIn: signedIn(env, home, log),
+            kitConfigured: fs.existsSync(agentKitPaths(home, env).kitConfigPath),
+            desktopAppManagesSync: machineType === "desktop" &&
+                (legacy.some((u) => u.service === "sync" && !u.migratable) || desktopAppRunning(platform)),
+            bots: listLocalBots(),
+            legacyOwner: legacyOwnerLookup(legacy),
+            cliSelfUpdatable: updatable,
+            jobsReconcileScript: jobsReconcileScript(hqRoot),
+            claudePath: findOnPath("claude", env),
+            tmuxPath: findOnPath("tmux", env),
+            hostName,
+        });
+    };
+    const spawnUnit = (unit) => {
+        const command = unit.command;
+        if (!command || command.type === "internal")
+            throw new Error(`${unit.id} has no process to start`);
+        const [file, args] = command.type === "hq"
+            ? [opts.nodeBinary, [opts.hqBinary, ...command.args]]
+            : command.type === "node"
+                ? [opts.nodeBinary, [command.script, ...command.args]]
+                : [command.file, command.args];
+        const fd = openPrivateAppend(paths.unitLogPath(unit.id));
+        try {
+            const cwd = unit.env.HQ_ROOT && fs.existsSync(unit.env.HQ_ROOT) ? unit.env.HQ_ROOT : home;
+            const child = spawn(file, args, {
+                cwd,
+                env: unitProcessEnv(env, unit),
+                stdio: ["ignore", fd, fd],
+                windowsHide: true,
+            });
+            return child;
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    };
+    // Set once the shutdown path exists below; a restart request before then is dropped.
+    let restartDaemon = () => { };
+    const supervisor = createSupervisor({
+        machineType,
+        pid: process.pid,
+        plan,
+        spawn: spawnUnit,
+        runInternal: async (task) => {
+            if (task !== "rotate-logs")
+                throw new Error(`unknown internal task ${task}`);
+            const n = rotateLogs(paths.logsDir);
+            if (n > 0)
+                log("info", `rotated ${n} log file(s)`);
+            return true;
+        },
+        takeRequests: () => takeControlRequests(paths.requestsDir),
+        restartDaemon: () => restartDaemon(),
+        writeState: (state) => writeJsonAtomic(paths.statePath, state),
+        log,
+    });
+    return await new Promise((resolve) => {
+        let stopping = false;
+        const shutdown = (why, exitCode = 0) => {
+            if (stopping)
+                return;
+            stopping = true;
+            log("info", `${why}; stopping services`);
+            // The supervisor escalates to SIGKILL after STOP_ESCALATION_MS; the extra
+            // margin only covers a child that survives even that.
+            let capTimer;
+            const cap = new Promise((r) => {
+                capTimer = setTimeout(() => r("timeout"), STOP_ESCALATION_MS + 5_000);
+            });
+            void Promise.race([supervisor.stop(), cap]).then((result) => {
+                clearTimeout(capTimer);
+                if (result === "timeout")
+                    log("error", "some services did not exit after SIGKILL; releasing the lock anyway");
+                else
+                    log("info", "all services stopped");
+                releaseDaemonLock(paths.lockPath);
+                resolve(exitCode);
+            });
+        };
+        restartDaemon = () => {
+            if (!opts.managed) {
+                log("warn", "a restart was requested, but no service manager would start this daemon again; restart it yourself");
+                return;
+            }
+            shutdown("restarting onto the updated CLI", RESTART_EXIT_CODE);
+        };
+        process.on("SIGTERM", () => shutdown("received SIGTERM"));
+        process.on("SIGINT", () => shutdown("received SIGINT"));
+        if (platform !== "win32")
+            process.on("SIGHUP", () => supervisor.reconcile());
+        try {
+            supervisor.start();
+        }
+        catch (err) {
+            log("error", `supervisor failed to start: ${err.message}`);
+            releaseDaemonLock(paths.lockPath);
+            resolve(1);
+        }
+    });
+}
+//# sourceMappingURL=run.js.map