@ours.network/cli 2.0.2 → 2.0.4

package/README.md

@@ -61,6 +61,14 @@ ours daemon stop
 ours daemon restart
 ```
 
+`start` and `restart` wait up to 20 minutes for the new daemon to become ready.
+Override that wait with `--readiness-timeout-ms N` or
+`OURS_DAEMON_READINESS_TIMEOUT_MS`. The flag takes precedence. If the deadline
+is reached, the command exits with an error but never signals or stops the
+spawned daemon: it remains running and may still be completing an upgrade. Use
+`ours daemon status --json` to check it and inspect
+`ours-cli-daemon.log` in the selected state directory for progress.
+
 `stop` and `restart` control the selected daemon regardless of which CLI command
 or service launcher originally started it. The endpoint must identify itself as
 an ours daemon for the exact selected state directory; once that validation

package/dist/{boot-Y3GXCN6X.js → boot-HNJ7ZR5L.js}

@@ -1,7 +1,7 @@
 import {
   bootWrapper,
   wrapperBooted
-} from "./chunk-IL724CY2.js";
+} from "./chunk-TSYICL3I.js";
 import "./chunk-FXKFSNKS.js";
 export {
   bootWrapper,

package/dist/{chunk-DTN7MN44.js → chunk-DZH2YEXT.js}

@@ -11,6 +11,7 @@ import { join, resolve } from "node:path";
 var MANAGED_PID_FILE = "ours-cli-daemon.json";
 var LEGACY_MANAGED_PID_FILE = "daemon.pid";
 var DAEMON_LOG_FILE = "ours-cli-daemon.log";
+var DEFAULT_DAEMON_READINESS_TIMEOUT_MS = 20 * 60 * 1e3;
 var depsDefault = {
   fetch: globalThis.fetch,
   spawn: nodeSpawn,
@@ -98,7 +99,7 @@ function childEnvironment(selection) {
 async function serveDaemon(selection, managed = false) {
   if (selection.endpoint !== void 0) throw new Error("--endpoint selects a running daemon and cannot be used with daemon serve");
   Object.assign(process.env, childEnvironment(selection));
-  const { startDaemon } = await import("./daemon-A2L6UMGZ.js");
+  const { startDaemon } = await import("./daemon-LTJHJDWZ.js");
   const handle = await startDaemon();
   if (managed) {
     const response = await fetch(`http://127.0.0.1:${handle.port}/state-dir`);
@@ -111,8 +112,11 @@ async function serveDaemon(selection, managed = false) {
   }
   return await new Promise(() => void 0);
 }
-async function startDaemonManaged(selection, deps = depsDefault) {
+async function startDaemonManaged(selection, deps = depsDefault, readinessTimeoutMs = DEFAULT_DAEMON_READINESS_TIMEOUT_MS) {
   if (selection.endpoint !== void 0) throw new Error("--endpoint selects an external daemon and cannot be used with daemon start");
+  if (!Number.isSafeInteger(readinessTimeoutMs) || readinessTimeoutMs < 1) {
+    throw new Error("daemon readiness timeout must be a positive integer number of milliseconds");
+  }
   const config = await resolveSelection(selection);
   const before = await inspectDaemon(config, deps);
   if (before.state === "running") return before;
@@ -132,9 +136,9 @@ async function startDaemonManaged(selection, deps = depsDefault) {
   }
   if (!child.pid || child.pid <= 1) throw new Error(`daemon start failed; see ${logPath}`);
   child.unref();
-  const deadline = deps.now() + 2e4;
+  const deadline = deps.now() + readinessTimeoutMs;
   while (deps.now() < deadline) {
-    await deps.delay(100);
+    await deps.delay(Math.min(100, deadline - deps.now()));
     const status = await inspectDaemon(config, deps);
     if (status.state === "running" && status.info?.pid === child.pid) return status;
     try {
@@ -144,10 +148,13 @@ async function startDaemonManaged(selection, deps = depsDefault) {
     }
   }
   try {
-    deps.kill(child.pid, "SIGTERM");
+    deps.kill(child.pid, 0);
   } catch {
+    throw new Error(`daemon exited before becoming ready; see ${logPath}`);
   }
-  throw new Error(`daemon did not become ready within 20 seconds and was stopped; see ${logPath}`);
+  throw new Error(
+    `daemon is still running but did not become ready within ${readinessTimeoutMs} ms; it may still be starting. Check \`ours daemon status --json\` and ${logPath}`
+  );
 }
 function removeOwnedPidFile(status) {
   const record = readManagedRecord(status.stateDir);
@@ -188,6 +195,7 @@ export {
   MANAGED_PID_FILE,
   LEGACY_MANAGED_PID_FILE,
   DAEMON_LOG_FILE,
+  DEFAULT_DAEMON_READINESS_TIMEOUT_MS,
   readLegacyManagedPid,
   readManagedRecord,
   writeManagedRecord,

package/dist/{chunk-VFAC74XR.js → chunk-NNHFXFLS.js}

@@ -13,7 +13,7 @@ import {
   IDENTITY_PREBIND_EXCEPTIONS,
   commandSpec,
   isCommandGroup
-} from "./chunk-VA6UQKYN.js";
+} from "./chunk-QKDH6CJR.js";
 
 // src/help.ts
 var pad = (value, width = 32) => value.length >= width ? `${value} ` : value.padEnd(width);
@@ -106,6 +106,7 @@ function nativeDaemonOptions(action) {
     ["--port N", selected ? "Select daemon port 1\u201365535." : "Checked against the port recorded for this state directory; a disagreement is refused and nothing is written."],
     ["--state-dir PATH", selected ? "Select the daemon state directory." : "Select the daemon whose unit this is; the unit name derives from it (~/.ours \u2192 ours.service, ~/.ours-tg \u2192 ours-tg.service)."],
     ["--config PATH", selected ? "Use this daemon config for lifecycle selection." : action === "install-service" ? "Embed this config file\u2019s absolute path in the installed unit." : "Compatibility-only/ignored by uninstall-service."],
+    ["--readiness-timeout-ms N", action === "start" || action === "restart" ? "Wait this many milliseconds for readiness (default: 1200000; env: OURS_DAEMON_READINESS_TIMEOUT_MS). A timeout leaves the spawned daemon running." : "Compatibility-only/ignored for this action."],
     ["--identity NAME", "Compatibility-only/ignored by daemon lifecycle and service commands."],
     ["--json", action === "serve" ? "Compatibility-only/ignored because serve runs until interrupted." : "Write one JSON result to stdout."],
     ["--yes", service.has(action) ? "Confirm the service-manager change; not needed with --dry-run." : "Compatibility-only/ignored for this action."],

package/dist/{chunk-VA6UQKYN.js → chunk-QKDH6CJR.js}

@@ -15,7 +15,7 @@ var COMMAND_GROUPS = {
         kind: "daemon",
         handler: "start",
         summary: "Start a detached daemon managed by this CLI.",
-        effects: "Spawns a background process, writes a PID record and log in the selected state directory, and waits up to 20 seconds for readiness.",
+        effects: "Spawns a background process, writes a PID record and log in the selected state directory, and waits up to 20 minutes for readiness by default. Reaching the readiness deadline never stops the daemon.",
         example: "ours daemon start --config /etc/ours/config.json"
       },
       stop: {
@@ -29,7 +29,7 @@ var COMMAND_GROUPS = {
         kind: "daemon",
         handler: "restart",
         summary: "Stop and start the selected ours daemon.",
-        effects: "Stops the selected valid ours daemon, then starts a detached replacement.",
+        effects: "Stops the selected valid ours daemon, then starts a detached replacement and waits up to 20 minutes for readiness by default. Reaching the readiness deadline never stops the replacement.",
         example: "ours daemon restart --config /etc/ours/config.json"
       },
       status: {

package/dist/{chunk-IL724CY2.js → chunk-TSYICL3I.js}

@@ -89,7 +89,7 @@ function createStartupProgressReporter(stateDir, opts = {}) {
 }
 
 // ../../src/runtime/env.ts
-var VERSION = true ? "3.0.2" : "0.0.0-dev";
+var VERSION = true ? "3.0.4" : "0.0.0-dev";
 var CONFIG = loadConfig();
 var STATE_DIR = CONFIG.stateDir;
 var BROKER_URL = CONFIG.brokerUrl;
@@ -802,6 +802,7 @@ function setWrapper(w) {
   wrapper = w;
 }
 var identities = /* @__PURE__ */ new Map();
+var quarantinedIdentities = /* @__PURE__ */ new Map();
 var registrar = null;
 var registrarAdBlob = null;
 function setRegistrar(id) {
@@ -894,13 +895,13 @@ var leases = /* @__PURE__ */ new Map();
 var tombstones = /* @__PURE__ */ new Set();
 var sessionHeaders = /* @__PURE__ */ new Map();
 var outboundRemovalInFlight = /* @__PURE__ */ new Set();
-function pidAlive(pid) {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
+function pidDefinitelyDead(pid) {
+  if (!Number.isInteger(pid) || pid <= 1) return false;
   try {
     process.kill(pid, 0);
-    return true;
+    return false;
   } catch (err) {
-    return err.code === "EPERM";
+    return err.code === "ESRCH";
   }
 }
 function leaseByToken(token) {
@@ -1902,6 +1903,85 @@ async function pinRegistrar(id) {
   });
 }
 
+// ../../src/identity/migration.ts
+function wasPublished(id) {
+  return Object.values(readBook()).some((entry) => entry.container_id === id.cid);
+}
+async function finishRestoredActivation(id) {
+  wrapper.expose_packet(id.cid);
+  identities.set(id.name, id);
+  quarantinedIdentities.delete(id.name);
+  log(`[${id.name}] EXPOSED (routing + broker registration) \u2014 hierarchy reconciled after restore`);
+  try {
+    await contactRestoreSweep(id);
+  } catch (err) {
+    log(`[${id.name}] post-activation contact restore sweep failed:`, String(err));
+  }
+  try {
+    refreshUnread(id);
+  } catch (err) {
+    log(`[${id.name}] post-activation unread refresh failed:`, String(err));
+  }
+  return id;
+}
+function quarantine(id, status) {
+  const exposeLocal = wasPublished(id);
+  if (exposeLocal) unpublishFromBook(id);
+  identities.delete(id.name);
+  quarantinedIdentities.set(id.name, { identity: id, status, exposeLocal });
+  log(`[${id.name}] QUARANTINED (${status}) \u2014 management-only, unexposed and unbindable`);
+  return id;
+}
+async function reconcileRestoredIdentity(id) {
+  if (rootName === id.name) return finishRestoredActivation(id);
+  const hostRoot = rootName ? identities.get(rootName) : void 0;
+  let info;
+  try {
+    info = describeIdentity(id);
+  } catch (err) {
+    log(`[${id.name}] hierarchy classification failed:`, String(err));
+    return quarantine(id, "migration-failed");
+  }
+  if (hostRoot) {
+    if (info.hasCert && info.roleId !== "" && info.rootCid !== hostRoot.cid) {
+      log(`[${id.name}] preserved imported delegation from root ${info.rootCid.slice(0, 12)}\u2026`);
+      return finishRestoredActivation(id);
+    }
+    try {
+      await delegateRole(hostRoot, id);
+      return finishRestoredActivation(id);
+    } catch (err) {
+      log(`[${id.name}] root delegation during restore failed:`, String(err));
+      return quarantine(id, "migration-failed");
+    }
+  }
+  if (info.hasCert && info.roleId !== "") return finishRestoredActivation(id);
+  return quarantine(id, "awaiting-root");
+}
+async function adoptQuarantinedIdentities(root) {
+  const adopted = [];
+  const failed = [];
+  for (const [name, held] of [...quarantinedIdentities]) {
+    try {
+      await delegateRole(root, held.identity);
+      if (held.exposeLocal) await publishToBook(held.identity);
+      await finishRestoredActivation(held.identity);
+      quarantinedIdentities.delete(name);
+      adopted.push(name);
+    } catch (err) {
+      try {
+        unpublishFromBook(held.identity);
+      } catch {
+      }
+      held.status = "migration-failed";
+      quarantinedIdentities.set(name, held);
+      log(`[${name}] quarantine adoption failed under root "${root.name}":`, String(err));
+      failed.push(name);
+    }
+  }
+  return { adopted, failed };
+}
+
 // ../../src/identity/provision.ts
 function createPacket(name, seed, dir, track = true, signingSecret, deferExposure = false) {
   const config = new PacketWrapperConfigurator();
@@ -2086,12 +2166,9 @@ async function restoreIdentity(name) {
   } catch (err) {
     tearDownUnexposed("history_open", "FAILED (SQLite history unavailable)", err);
   }
-  wrapper.expose_packet(id.cid);
-  identities.set(name, id);
-  log(`[${name}] EXPOSED (routing + broker registration) \u2014 import phase complete`);
-  await contactRestoreSweep(id);
-  refreshUnread(id);
-  return id;
+  const restoredTemp = readTempMetaFile(id.dir);
+  if (restoredTemp) id.temp = restoredTemp;
+  return reconcileRestoredIdentity(id);
 }
 
 // ../../src/state.ts
@@ -2345,8 +2422,11 @@ async function establishRoot(id) {
   return { adopted, failed };
 }
 
-// ../../src/identity/lifecycle.ts
+// ../../src/identity/reaper.ts
 import { join as join9 } from "node:path";
+import * as fs12 from "node:fs";
+
+// ../../src/identity/lifecycle.ts
 import * as fs11 from "node:fs";
 
 // ../../src/render/adapt-to-json.ts
@@ -2724,31 +2804,46 @@ function closeTemporaryIdentity(id, cause) {
   })();
   return t.closing;
 }
-function sweepStaleTempIdentities() {
-  for (const id of [...identities.values()]) {
+
+// ../../src/identity/reaper.ts
+function sessionReaperIntervalMs(raw = process.env.OURS_SESSION_REAPER_INTERVAL_MS) {
+  if (raw === void 0 || raw.trim() === "") return 5e3;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed)) return 5e3;
+  return Math.max(100, Math.trunc(parsed));
+}
+async function reapStaleTemporaryIdentities() {
+  const all = [
+    ...identities.values(),
+    ...[...quarantinedIdentities.values()].map((held) => held.identity)
+  ];
+  const closes = [];
+  for (const id of all) {
     const t = id.temp;
-    if (!t || t.closing) continue;
-    if (pidAlive(t.owner.pid)) continue;
+    if (!t || t.closing || !pidDefinitelyDead(t.owner.pid)) continue;
     const lease = leases.get(id.name);
-    if (lease && pidAlive(lease.pid)) continue;
-    void closeTemporaryIdentity(id, `stale lease \u2014 owner pid ${t.owner.pid} is dead`).catch(
-      (err) => log(`[${id.name}] stale-temp reclaim failed:`, String(err))
+    if (lease && !pidDefinitelyDead(lease.pid)) continue;
+    closes.push(
+      closeTemporaryIdentity(id, `stale lease \u2014 owner pid ${t.owner.pid} is dead`).then(() => {
+        quarantinedIdentities.delete(id.name);
+      }).catch((err) => log(`[${id.name}] stale-temp reclaim failed:`, String(err)))
     );
   }
+  await Promise.all(closes);
 }
-function sweepOrphanTempDirs() {
-  if (!fs11.existsSync(STATE_DIR)) return;
-  for (const d of fs11.readdirSync(STATE_DIR, { withFileTypes: true })) {
-    if (!d.isDirectory() || identities.has(d.name)) continue;
+async function reapOrphanTemporaryDirectories() {
+  if (!fs12.existsSync(STATE_DIR)) return;
+  for (const d of fs12.readdirSync(STATE_DIR, { withFileTypes: true })) {
+    if (!d.isDirectory() || identities.has(d.name) || quarantinedIdentities.has(d.name)) continue;
     const dir = join9(STATE_DIR, d.name);
     const meta = readTempMetaFile(dir);
-    if (!meta || pidAlive(meta.owner.pid)) continue;
+    if (!meta || !pidDefinitelyDead(meta.owner.pid)) continue;
     try {
-      fs11.rmSync(dir, { recursive: true, force: true });
+      fs12.rmSync(dir, { recursive: true, force: true });
       reservedNames.delete(d.name);
-      log(`[${d.name}] removed orphaned temporary-identity dir (owner pid ${meta.owner.pid} dead, no live packet)`);
+      log(`[${d.name}] removed orphaned temporary-identity dir (owner pid ${meta.owner.pid} confirmed dead)`);
     } catch (err) {
-      log(`[${d.name}] failed to remove orphaned temporary-identity dir:`, String(err));
+      throw new Error(`[${d.name}] failed to remove orphaned temporary-identity dir: ${String(err)}`);
     }
   }
 }
@@ -2859,7 +2954,9 @@ async function bootWrapper() {
     log("failed to start the contact-book registrar (local contact book disabled):", String(err));
   }
   tightenIdentityPerms();
-  const names = listPersistedNames();
+  setRootName(readRootMarker());
+  const persistedNames = listPersistedNames();
+  const names = rootName && persistedNames.includes(rootName) ? [rootName, ...persistedNames.filter((name) => name !== rootName)] : persistedNames;
   const fakeRestoreCount = Math.max(0, Number(process.env.OURS_TEST_FAKE_RESTORE_COUNT || "") || 0);
   const fakeRestoreMs = Math.max(0, Number(process.env.OURS_TEST_FAKE_RESTORE_MS || "") || 0);
   const restoreTotal = names.length === 0 && fakeRestoreCount > 0 ? fakeRestoreCount : names.length;
@@ -2945,8 +3042,8 @@ async function bootWrapper() {
     if (refreshedRoles.length > 0) log(`refreshed ${refreshedRoles.length} role delegation cert(s) against the live AD on boot`);
   }
   persistBindings();
-  sweepOrphanTempDirs();
-  sweepStaleTempIdentities();
+  await reapOrphanTemporaryDirectories();
+  await reapStaleTemporaryIdentities();
 }
 
 export {
@@ -2962,6 +3059,8 @@ export {
   requireAuth,
   validateName,
   consumeOutboundHistoryFailure,
+  openHistory,
+  closeHistory,
   listIncomingMessages,
   takeUnreadMessages,
   listIncomingFiles,
@@ -2972,8 +3071,12 @@ export {
   listFileHistory,
   getFileHistoryItem,
   FILE_SELECTION_CAP,
+  wrapper,
   identities,
+  quarantinedIdentities,
   registrar,
+  identityDir,
+  keyPath,
   hashLeaseToken,
   writeTempMetaFile,
   isSelectableWireId,
@@ -2982,7 +3085,7 @@ export {
   tombstones,
   sessionHeaders,
   outboundRemovalInFlight,
-  pidAlive,
+  pidDefinitelyDead,
   leaseByToken,
   persistBindings,
   resolveBound,
@@ -3000,11 +3103,16 @@ export {
   e2eRecoverySweep,
   readBook,
   exportAdBlob,
+  exportSigningSecret,
   publishToBook,
   unpublishFromBook,
+  pinRegistrar,
+  adoptQuarantinedIdentities,
+  createPacket,
   reservedNames,
   provisionIdentity,
   saveState,
+  saveStateFailClosed,
   withScope,
   withScopeAsync,
   readonlyTx,
@@ -3025,7 +3133,8 @@ export {
   decodeWireBin,
   deleteIdentityCompletely,
   closeTemporaryIdentity,
-  sweepStaleTempIdentities,
+  sessionReaperIntervalMs,
+  reapStaleTemporaryIdentities,
   envelopeDispatch,
   PROTOCOL_VERSION,
   clusterSweep,

package/dist/commands.d.ts

@@ -37,7 +37,7 @@ export declare const COMMAND_GROUPS: {
                 readonly kind: "daemon";
                 readonly handler: "start";
                 readonly summary: "Start a detached daemon managed by this CLI.";
-                readonly effects: "Spawns a background process, writes a PID record and log in the selected state directory, and waits up to 20 seconds for readiness.";
+                readonly effects: "Spawns a background process, writes a PID record and log in the selected state directory, and waits up to 20 minutes for readiness by default. Reaching the readiness deadline never stops the daemon.";
                 readonly example: "ours daemon start --config /etc/ours/config.json";
             };
             readonly stop: {
@@ -51,7 +51,7 @@ export declare const COMMAND_GROUPS: {
                 readonly kind: "daemon";
                 readonly handler: "restart";
                 readonly summary: "Stop and start the selected ours daemon.";
-                readonly effects: "Stops the selected valid ours daemon, then starts a detached replacement.";
+                readonly effects: "Stops the selected valid ours daemon, then starts a detached replacement and waits up to 20 minutes for readiness by default. Reaching the readiness deadline never stops the replacement.";
                 readonly example: "ours daemon restart --config /etc/ours/config.json";
             };
             readonly status: {

package/dist/commands.js

@@ -4,7 +4,7 @@ import {
   IDENTITY_PREBIND_EXCEPTIONS,
   commandSpec,
   isCommandGroup
-} from "./chunk-VA6UQKYN.js";
+} from "./chunk-QKDH6CJR.js";
 export {
   COMMAND_GROUPS,
   DESTRUCTIVE_OPERATIONS,

package/dist/{daemon-A2L6UMGZ.js → daemon-LTJHJDWZ.js}

@@ -204,7 +204,7 @@ async function releaseHeld(lock) {
 async function bootKernel() {
   const { lock, acquired } = await ensureLock();
   try {
-    const { bootWrapper } = await import("./boot-Y3GXCN6X.js");
+    const { bootWrapper } = await import("./boot-HNJ7ZR5L.js");
     await bootWrapper();
   } catch (error) {
     if (acquired) await releaseHeld(lock);
@@ -214,7 +214,7 @@ async function bootKernel() {
 async function startDaemon(opts = {}) {
   const { lock, acquired } = await ensureLock();
   try {
-    const runtime = await import("./server-6BZCHN6Q.js");
+    const runtime = await import("./server-35QOYLY4.js");
     const { onRuntimeLoaded, ...daemonOptions } = opts;
     onRuntimeLoaded?.();
     const handle = await runtime.startDaemon({

package/dist/help.js

@@ -3,10 +3,10 @@ import {
   helpRequestPath,
   renderHelp,
   renderTopHelp
-} from "./chunk-VFAC74XR.js";
+} from "./chunk-NNHFXFLS.js";
 import "./chunk-MS4TDUZY.js";
 import "./chunk-6NFATG6P.js";
-import "./chunk-VA6UQKYN.js";
+import "./chunk-QKDH6CJR.js";
 export {
   helpHint,
   helpRequestPath,

package/dist/lifecycle.d.ts

@@ -5,6 +5,7 @@ export declare const MANAGED_PID_FILE = "ours-cli-daemon.json";
 /** PID file written by the pre-split @ours.network/mcp CLI. Retained only for cleanup. */
 export declare const LEGACY_MANAGED_PID_FILE = "daemon.pid";
 export declare const DAEMON_LOG_FILE = "ours-cli-daemon.log";
+export declare const DEFAULT_DAEMON_READINESS_TIMEOUT_MS: number;
 interface ManagedRecord {
     version: 1;
     owner: '@ours.network/cli';
@@ -34,6 +35,6 @@ export declare function readManagedRecord(stateDir: string): ManagedRecord | nul
 export declare function writeManagedRecord(stateDir: string, port: number): string;
 export declare function inspectDaemon(config: ResolvedDaemonConfig, deps?: LifecycleDeps): Promise<DaemonStatus>;
 export declare function serveDaemon(selection: SelectionOptions, managed?: boolean): Promise<never>;
-export declare function startDaemonManaged(selection: SelectionOptions, deps?: LifecycleDeps): Promise<DaemonStatus>;
+export declare function startDaemonManaged(selection: SelectionOptions, deps?: LifecycleDeps, readinessTimeoutMs?: number): Promise<DaemonStatus>;
 export declare function stopDaemonManaged(config: ResolvedDaemonConfig, deps?: LifecycleDeps): Promise<DaemonStatus>;
 export {};

package/dist/lifecycle.js

@@ -1,5 +1,6 @@
 import {
   DAEMON_LOG_FILE,
+  DEFAULT_DAEMON_READINESS_TIMEOUT_MS,
   LEGACY_MANAGED_PID_FILE,
   MANAGED_PID_FILE,
   inspectDaemon,
@@ -9,10 +10,11 @@ import {
   startDaemonManaged,
   stopDaemonManaged,
   writeManagedRecord
-} from "./chunk-DTN7MN44.js";
+} from "./chunk-DZH2YEXT.js";
 import "./chunk-6K2JBKHI.js";
 export {
   DAEMON_LOG_FILE,
+  DEFAULT_DAEMON_READINESS_TIMEOUT_MS,
   LEGACY_MANAGED_PID_FILE,
   MANAGED_PID_FILE,
   inspectDaemon,

package/dist/main.d.ts

@@ -1,2 +1,3 @@
+import { type LifecycleDeps } from './lifecycle.js';
 import { type CliIo } from './output.js';
-export declare function runCli(argv: string[], io?: CliIo): Promise<number>;
+export declare function runCli(argv: string[], io?: CliIo, lifecycleDeps?: LifecycleDeps): Promise<number>;

package/dist/main.js

@@ -17,7 +17,7 @@ import {
   helpHint,
   helpRequestPath,
   renderHelp
-} from "./chunk-VFAC74XR.js";
+} from "./chunk-NNHFXFLS.js";
 import {
   invokeOperation,
   isOperationName,
@@ -37,13 +37,14 @@ import {
   IDENTITY_PREBIND_EXCEPTIONS,
   commandSpec,
   isCommandGroup
-} from "./chunk-VA6UQKYN.js";
+} from "./chunk-QKDH6CJR.js";
 import {
+  DEFAULT_DAEMON_READINESS_TIMEOUT_MS,
   inspectDaemon,
   serveDaemon,
   startDaemonManaged,
   stopDaemonManaged
-} from "./chunk-DTN7MN44.js";
+} from "./chunk-DZH2YEXT.js";
 import {
   attachClient,
   defaultConfigPath,
@@ -54,9 +55,10 @@ import {
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
-var CLI_VERSION = false ? "0.0.0-dev" : "2.0.2";
+var CLI_VERSION = false ? "0.0.0-dev" : "2.0.4";
 var COMMON_VALUES = /* @__PURE__ */ new Set(["--endpoint", "--port", "--state-dir", "--config", "--identity"]);
 var COMMON_BOOLEANS = /* @__PURE__ */ new Set(["--json", "--yes", "--help"]);
+var DAEMON_READINESS_TIMEOUT_ENV = "OURS_DAEMON_READINESS_TIMEOUT_MS";
 function selectionFrom(values) {
   return {
     endpoint: values["--endpoint"],
@@ -186,11 +188,17 @@ async function runConfig(args, io) {
   writeResult(io, setupConfig(flags.values["--config"] ?? defaultConfigPath(), patch, flags.booleans.has("--dry-run")), json, "config updated");
   return 0;
 }
-async function runDaemon(args, io) {
+function daemonReadinessTimeoutMs(values) {
+  const flag = values["--readiness-timeout-ms"];
+  if (flag !== void 0) return parseInteger(flag, "--readiness-timeout-ms", 1);
+  const configured = process.env[DAEMON_READINESS_TIMEOUT_ENV];
+  return configured === void 0 ? DEFAULT_DAEMON_READINESS_TIMEOUT_MS : parseInteger(configured, DAEMON_READINESS_TIMEOUT_ENV, 1);
+}
+async function runDaemon(args, io, lifecycleDeps) {
   const action = args[0];
   const spec = action === void 0 ? void 0 : commandSpec("daemon", action);
   if (spec?.kind === "operation") return runGrouped("daemon", args, io);
-  const values = new Set(COMMON_VALUES);
+  const values = /* @__PURE__ */ new Set([...COMMON_VALUES, "--readiness-timeout-ms"]);
   const booleans = /* @__PURE__ */ new Set([...COMMON_BOOLEANS, "--managed", "--dry-run", "--force"]);
   const flags = parseFlags(args, values, booleans);
   if (flags.positionals.length !== 1) throw new CliUsageError("daemon accepts exactly one command");
@@ -198,24 +206,25 @@ async function runDaemon(args, io) {
   const handler = spec.handler;
   const selection = selectionFrom(flags.values);
   const json = flags.booleans.has("--json");
+  const readinessTimeoutMs = handler === "start" || handler === "restart" ? daemonReadinessTimeoutMs(flags.values) : void 0;
   if (handler === "serve") return serveDaemon(selection, flags.booleans.has("--managed"));
   if (handler === "status") {
-    const status = await inspectDaemon(await resolveSelection(selection));
+    const status = await inspectDaemon(await resolveSelection(selection), lifecycleDeps);
     writeResult(io, status, json, status.state);
     return status.state === "running" ? 0 : 3;
   }
   if (handler === "start") {
-    writeResult(io, await startDaemonManaged(selection), json, "started");
+    writeResult(io, await startDaemonManaged(selection, lifecycleDeps, readinessTimeoutMs), json, "started");
     return 0;
   }
   if (handler === "stop") {
-    writeResult(io, await stopDaemonManaged(await resolveSelection(selection)), json, "stopped");
+    writeResult(io, await stopDaemonManaged(await resolveSelection(selection), lifecycleDeps), json, "stopped");
     return 0;
   }
   if (handler === "restart") {
     if (selection.endpoint !== void 0) throw new CliUsageError("--endpoint selects a running daemon and cannot be used with daemon restart");
-    await stopDaemonManaged(await resolveSelection(selection));
-    writeResult(io, await startDaemonManaged(selection), json, "restarted");
+    await stopDaemonManaged(await resolveSelection(selection), lifecycleDeps);
+    writeResult(io, await startDaemonManaged(selection, lifecycleDeps, readinessTimeoutMs), json, "restarted");
     return 0;
   }
   if (handler === "install-service" || handler === "uninstall-service") {
@@ -234,7 +243,7 @@ async function runDaemon(args, io) {
   const unsupported = handler;
   throw new Error(`unsupported daemon handler: ${String(unsupported)}`);
 }
-async function runCli(argv, io = processIo) {
+async function runCli(argv, io = processIo, lifecycleDeps) {
   const wantsJson = argv.includes("--json");
   try {
     const helpPath = helpRequestPath(argv);
@@ -249,7 +258,7 @@ async function runCli(argv, io = processIo) {
     }
     if (command === "api") return await runApi(args, io);
     if (isCommandGroup(command)) {
-      if (command === "daemon") return await runDaemon(args, io);
+      if (command === "daemon") return await runDaemon(args, io, lifecycleDeps);
       if (command === "config") return await runConfig(args, io);
       return await runGrouped(command, args, io);
     }