@indigoai-us/hq-cli 5.265.0 → 5.266.0

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [5.266.0] — 2026-09-28
+
+### Added
+
+- `hq daemon run --host desktop` lets the HQ desktop app run the daemon as its
+  own child process. The daemon then runs sync even though the app is open, and
+  records the app as its host in `state.json`. Older per-service installers
+  such as `hq mesh daemon install` treat a hosted daemon as installed and hand
+  their service to it.
+
 ## [5.265.0] — 2026-09-28
 
 ### Added

package/dist/command-catalog.generated.d.ts

@@ -8978,6 +8978,9 @@ export declare const COMMAND_CATALOG: readonly [{
         }, {
             readonly flags: "--managed";
             readonly description: "Started by the OS unit, which starts the daemon again whenever it exits";
+        }, {
+            readonly flags: "--host <app>";
+            readonly description: "Run as a child of this app (only \"desktop\"), which has handed sync over to the daemon";
         }];
         readonly subcommands: readonly [];
     }, {

package/dist/command-catalog.generated.js

@@ -11611,6 +11611,10 @@ export const COMMAND_CATALOG = [
                     {
                         "flags": "--managed",
                         "description": "Started by the OS unit, which starts the daemon again whenever it exits"
+                    },
+                    {
+                        "flags": "--host <app>",
+                        "description": "Run as a child of this app (only \"desktop\"), which has handed sync over to the daemon"
                     }
                 ],
                 "subcommands": []

package/dist/commands/daemon.d.ts

@@ -15,6 +15,7 @@
  */
 import type { Command } from "commander";
 import { type LegacyUnit } from "../lib/daemon/legacy.js";
+import type { HostApp } from "../lib/daemon/supervisor.js";
 import type { RunCommand } from "../lib/service-manager/launchd.js";
 export interface DaemonCommandDeps {
     env: NodeJS.ProcessEnv;
@@ -46,6 +47,8 @@ export interface DaemonCommandDeps {
  * (HQ_ROOT, the tree around the current folder, the folder the installer or
  * menubar recorded, the well-known locations). Undefined when none resolves.
  */
+/** Validate `hq daemon run --host`; the desktop app is the only host. */
+export declare function parseDaemonHost(value: string | undefined): HostApp | undefined;
 export declare function resolveDaemonHqRoot(flag: string | undefined, where: {
     env: NodeJS.ProcessEnv;
     cwd: string;

package/dist/commands/daemon.js

@@ -36,6 +36,14 @@ class DaemonCommandError extends Error {
  * (HQ_ROOT, the tree around the current folder, the folder the installer or
  * menubar recorded, the well-known locations). Undefined when none resolves.
  */
+/** Validate `hq daemon run --host`; the desktop app is the only host. */
+export function parseDaemonHost(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === "desktop")
+        return value;
+    throw new Error(`--host must be "desktop" (got "${value}")`);
+}
 export function resolveDaemonHqRoot(flag, where) {
     if (flag)
         return path.resolve(flag);
@@ -574,13 +582,16 @@ export function registerDaemonCommand(program, over = {}) {
         .option("--foreground", "Also print the supervisor log to the terminal")
         .option("--daemon-dir <path>", "Use this folder instead of ~/.hq/daemon (how the Windows task passes HQ_DAEMON_DIR)")
         .option("--managed", "Started by the OS unit, which starts the daemon again whenever it exits")
+        .option("--host <app>", "Run as a child of this app (only \"desktop\"), which has handed sync over to the daemon")
         .action(wrap(async (d, opts) => {
+        const host = parseDaemonHost(opts.host);
         const { runDaemon } = await import("../lib/daemon/run.js");
         // Services inherit this environment, so they see the same folder.
         const env = opts.daemonDir ? { ...d.env, HQ_DAEMON_DIR: opts.daemonDir } : d.env;
         process.exitCode = await runDaemon({
             foreground: opts.foreground,
             managed: opts.managed,
+            host,
             home: d.home,
             env,
             nodeBinary: d.nodeBinary,

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

@@ -24,6 +24,8 @@ export declare function daemonRunsService(paths: DaemonPaths, service: ServiceNa
 export declare function askDaemonToStart(paths: DaemonPaths, unitId: string): void;
 /** Ask the running daemon to stop a unit and keep it down until it is started again. */
 export declare function askDaemonToStop(paths: DaemonPaths, unitId: string): void;
+/** A live daemon runs as the desktop app's child, which counts as installed even though no OS unit exists. */
+export declare function hostedDaemonRunning(paths: DaemonPaths, alive?: (pid: number) => boolean): boolean;
 export interface DaemonUnitHost {
     platform: NodeJS.Platform;
     home: string;

package/dist/lib/daemon/handoff.js

@@ -67,6 +67,15 @@ export function askDaemonToStart(paths, unitId) {
 export function askDaemonToStop(paths, unitId) {
     writeControlRequest(paths.requestsDir, { action: "stop", unit: unitId });
 }
+/** A live daemon runs as the desktop app's child, which counts as installed even though no OS unit exists. */
+export function hostedDaemonRunning(paths, alive = (pid) => isDaemonProcess(pid)) {
+    try {
+        return liveState(paths, alive)?.host === "desktop";
+    }
+    catch {
+        return false;
+    }
+}
 /** The `hq daemon` OS unit is installed on this machine (for this user, or as the box's system unit). */
 export function daemonUnitInstalled(host) {
     switch (host.platform) {
@@ -114,14 +123,14 @@ export function handOffInstall(opts) {
 /** handOffInstall for this machine and user, for the older install commands. */
 export function handOffInstallHere(services, env = process.env, opts = {}) {
     const home = os.homedir();
+    const paths = daemonPaths(home, env);
     const installed = daemonUnitInstalled({
         platform: process.platform,
         home,
         windowsTaskExists: (task) => spawnSync("schtasks.exe", ["/Query", "/TN", task], { encoding: "utf8", windowsHide: true }).status === 0,
-    });
+    }) || hostedDaemonRunning(paths);
     if (!installed)
         return null;
-    const paths = daemonPaths(home, env);
     const config = readDaemonConfig(paths.configPath);
     const machineType = detectMachineType(undefined, {
         platform: process.platform,

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

@@ -7,6 +7,8 @@
  */
 import { type UnitPlan } from "./catalog.js";
 import { type LegacyUnit } from "./legacy.js";
+import { type MachineType } from "./machine-type.js";
+import { type HostApp } from "./supervisor.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;
@@ -14,6 +16,8 @@ export interface RunDaemonOptions {
     foreground?: boolean;
     /** Started by the OS unit, which relaunches the daemon whenever it exits. */
     managed?: boolean;
+    /** The app that runs this daemon as its child (it relaunches the daemon on RESTART_EXIT_CODE when also managed). */
+    host?: HostApp;
     home?: string;
     env?: NodeJS.ProcessEnv;
     nodeBinary: string;
@@ -35,6 +39,21 @@ export declare function findUserBinary(name: string, env: NodeJS.ProcessEnv, hom
 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;
+/** A parent (the OS unit, or the app hosting the daemon) starts the daemon again after it exits with RESTART_EXIT_CODE. */
+export declare function restartsForParent(opts: {
+    managed?: boolean;
+    host?: HostApp;
+}): boolean;
+/**
+ * The desktop app runs sync itself, so the daemon's sync unit waits. When the
+ * app hosts the daemon it has handed sync over, and the daemon runs it.
+ */
+export declare function desktopAppManagesSync(opts: {
+    machineType: MachineType;
+    host?: HostApp;
+    legacy: readonly LegacyUnit[];
+    appRunning: () => boolean;
+}): 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;
 /**

package/dist/lib/daemon/run.js

@@ -133,6 +133,19 @@ export function desktopAppRunning(platform) {
     const r = spawnSync("pgrep", ["-x", "hq-sync-menubar"], { encoding: "utf8" });
     return r.status === 0;
 }
+/** A parent (the OS unit, or the app hosting the daemon) starts the daemon again after it exits with RESTART_EXIT_CODE. */
+export function restartsForParent(opts) {
+    return opts.managed === true || opts.host !== undefined;
+}
+/**
+ * The desktop app runs sync itself, so the daemon's sync unit waits. When the
+ * app hosts the daemon it has handed sync over, and the daemon runs it.
+ */
+export function desktopAppManagesSync(opts) {
+    if (opts.machineType !== "desktop" || opts.host === "desktop")
+        return false;
+    return opts.legacy.some((u) => u.service === "sync" && !u.migratable) || opts.appRunning();
+}
 function jobsReconcileScript(hqRoot) {
     if (!hqRoot)
         return null;
@@ -231,7 +244,8 @@ export async function runDaemon(opts) {
         releaseDaemonLock(paths.lockPath);
         return 1;
     }
-    log("info", `starting hq daemon (pid ${process.pid}) as ${machineType} (${detected.detail})`);
+    const hostNote = opts.host ? `, hosted by the ${opts.host} app` : "";
+    log("info", `starting hq daemon (pid ${process.pid}) as ${machineType} (${detected.detail})${hostNote}`);
     if (!resolveSyncRunnerPath())
         log("warn", "the hq-cloud sync runner was not found in this CLI install; sync is unavailable");
     const updatable = cliSelfUpdatable();
@@ -270,8 +284,12 @@ export async function runDaemon(opts) {
             legacySyncEnv: readLegacySyncEnv(platform),
             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)),
+            desktopAppManagesSync: desktopAppManagesSync({
+                machineType,
+                host: opts.host,
+                legacy,
+                appRunning: () => desktopAppRunning(platform),
+            }),
             bots: listLocalBots(),
             legacyOwner: legacyOwnerLookup(legacy),
             cliSelfUpdatable: updatable,
@@ -312,6 +330,7 @@ export async function runDaemon(opts) {
     let restartDaemon = () => { };
     const supervisor = createSupervisor({
         machineType,
+        host: opts.host,
         pid: process.pid,
         plan,
         spawn: spawnUnit,
@@ -352,7 +371,7 @@ export async function runDaemon(opts) {
             });
         };
         restartDaemon = () => {
-            if (!opts.managed) {
+            if (!restartsForParent(opts)) {
                 log("warn", "a restart was requested, but no service manager would start this daemon again; restart it yourself");
                 return;
             }

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

@@ -50,16 +50,21 @@ export interface UnitState {
     nextRunAt?: number;
     lastResult?: "ok" | "failed";
 }
+/** An app that runs the daemon as its own child process instead of an OS unit. */
+export type HostApp = "desktop";
 export interface DaemonState {
     version: 1;
     pid: number;
     startedAt: number;
     updatedAt: number;
     machineType: MachineType;
+    /** Set when an app runs the daemon as its child; absent under the OS unit. */
+    host?: HostApp;
     units: UnitState[];
 }
 export interface SupervisorDeps {
     machineType: MachineType;
+    host?: HostApp;
     pid: number;
     plan: () => UnitPlan[];
     spawn: (unit: UnitPlan) => SupervisedChild;

package/dist/lib/daemon/supervisor.js

@@ -52,6 +52,7 @@ export function createSupervisor(deps) {
         startedAt,
         updatedAt: now(),
         machineType: deps.machineType,
+        ...(deps.host ? { host: deps.host } : {}),
         units: [...slots.values()].map((s) => ({ ...s.state })),
     });
     const emit = () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.265.0",
+  "version": "5.266.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {