@ours.network/cli 0.6.0 → 1.0.0

package/dist/{chunk-4IFFMMQO.js → chunk-QZIL3IT7.js}

@@ -2,7 +2,7 @@ import {
   attachClient,
   defaultConfigPath,
   resolveSelection
-} from "./chunk-6W3RHW3C.js";
+} from "./chunk-6K2JBKHI.js";
 
 // src/lifecycle.ts
 import { spawn as nodeSpawn } from "node:child_process";
@@ -54,7 +54,7 @@ async function inspectDaemon(config, deps = depsDefault) {
   try {
     client = await attachClient(config, { fetch: deps.fetch, leaseToken: "ours-cli-status" });
   } catch (error) {
-    if (error instanceof Error && error.name === "DaemonSelectionError" && /could not be reached/.test(error.message)) {
+    if (error instanceof Error && error.name === "DaemonUnavailableError") {
       return { state: "stopped", managed: false, info: null, ...base };
     }
     throw error;
@@ -87,7 +87,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("@ours.network/sdk/daemon");
+  const { startDaemon } = await import("./daemon-UUG6P6GK.js");
   const handle = await startDaemon();
   if (managed) {
     const response = await fetch(`http://127.0.0.1:${handle.port}/state-dir`);

package/dist/{chunk-RJWUCR3R.js → chunk-ZFE47KH3.js}

@@ -126,7 +126,6 @@ function nativeConfigOptions(action) {
     ["--identity NAME", "Compatibility-only/ignored by config commands."],
     ["--broker-url URL", show ? "Compatibility-only/ignored by config show." : "Set the broker WebSocket URL."],
     ["--gc-interval-ms N", show ? "Compatibility-only/ignored by config show." : "Set a positive garbage-collection interval in milliseconds."],
-    ["--auto-start true|false", show ? "Compatibility-only/ignored by config show." : "Set automatic daemon startup (1/0 are also accepted)."],
     ["--api-visibility MODE", show ? "Compatibility-only/ignored by config show." : "Set owner, shared, or open API visibility."],
     ["--dry-run", show ? "Compatibility-only/ignored by config show." : "Return the merged redacted result without writing the file."],
     ["--json", "Write one JSON value to stdout."],

package/dist/config-command.js

@@ -1,8 +1,8 @@
 import {
   setupConfig,
   showConfig
-} from "./chunk-G2GHHOYX.js";
-import "./chunk-6W3RHW3C.js";
+} from "./chunk-DRQEV4SN.js";
+import "./chunk-6K2JBKHI.js";
 export {
   setupConfig,
   showConfig

package/dist/connection.js

@@ -3,7 +3,7 @@ import {
   defaultConfigPath,
   redactedSelection,
   resolveSelection
-} from "./chunk-6W3RHW3C.js";
+} from "./chunk-6K2JBKHI.js";
 export {
   attachClient,
   defaultConfigPath,

package/dist/daemon-UUG6P6GK.js

@@ -0,0 +1,250 @@
+import {
+  assertConfigNotDrifted,
+  loadConfig
+} from "./chunk-FXKFSNKS.js";
+
+// ../../src/internal/daemon.ts
+import * as fs2 from "node:fs";
+
+// ../../src/internal/state-root-lock.ts
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as net from "node:net";
+import { dirname, join, resolve } from "node:path";
+var SUPPORTED_PLATFORMS = /* @__PURE__ */ new Set(["linux", "darwin"]);
+var MAX_SOCKET_PATH_BYTES = 103;
+var MAX_ACQUIRE_ATTEMPTS = 8;
+var StateRootLockedError = class extends Error {
+  constructor(stateDir, ownerPid, owner) {
+    super(
+      `ours daemon state directory ${JSON.stringify(stateDir)} is already owned by ` + (ownerPid === null ? "another live process" : `pid ${ownerPid}`) + ". Stop that daemon through the ours CLI before starting another one for the same state directory."
+    );
+    this.stateDir = stateDir;
+    this.ownerPid = ownerPid;
+    this.owner = owner;
+    this.name = "StateRootLockedError";
+  }
+  code = "STATE_ROOT_LOCKED";
+};
+function fsCode(error) {
+  return error && typeof error === "object" && "code" in error ? String(error.code) : void 0;
+}
+function canonicalStateDir(input) {
+  let cursor = resolve(input);
+  const missing = [];
+  while (true) {
+    try {
+      const canonicalPrefix = fs.realpathSync.native(cursor);
+      return resolve(canonicalPrefix, ...missing.reverse());
+    } catch (error) {
+      if (fsCode(error) !== "ENOENT") throw error;
+      const parent = dirname(cursor);
+      if (parent === cursor) throw error;
+      missing.push(cursor.slice(parent.length + (parent.endsWith("/") ? 0 : 1)));
+      cursor = parent;
+    }
+  }
+}
+function ensurePrivateDirectory(path, uid) {
+  try {
+    fs.mkdirSync(path, { mode: 448 });
+  } catch (error) {
+    if (fsCode(error) !== "EEXIST") throw error;
+  }
+  const stat = fs.lstatSync(path);
+  if (!stat.isDirectory() || stat.isSymbolicLink()) {
+    throw new Error(`daemon lock path ${JSON.stringify(path)} must be a real directory, not a symlink or file`);
+  }
+  if (stat.uid !== uid) {
+    throw new Error(`daemon lock path ${JSON.stringify(path)} is owned by uid ${stat.uid}, expected uid ${uid}`);
+  }
+  fs.chmodSync(path, 448);
+}
+function stateRootLockPath(stateDir) {
+  if (!SUPPORTED_PLATFORMS.has(process.platform)) {
+    throw new Error(
+      `the ours daemon state-root lock supports Linux and macOS only; platform ${JSON.stringify(process.platform)} has no verified Unix-domain-socket lock contract, so startup is refused`
+    );
+  }
+  const getuid = process.getuid;
+  if (typeof getuid !== "function") {
+    throw new Error("the ours daemon state-root lock requires a Unix uid; startup is refused");
+  }
+  const uid = getuid.call(process);
+  const base = `/tmp/ours-${uid}`;
+  const directory = join(base, "locks");
+  ensurePrivateDirectory(base, uid);
+  ensurePrivateDirectory(directory, uid);
+  const key = createHash("sha256").update(stateDir).digest("hex");
+  const socketPath = join(directory, `${key}.sock`);
+  if (Buffer.byteLength(socketPath) > MAX_SOCKET_PATH_BYTES) {
+    throw new Error(
+      `daemon lock socket path is ${Buffer.byteLength(socketPath)} bytes, exceeding the portable ${MAX_SOCKET_PATH_BYTES}-byte Linux/macOS contract: ${JSON.stringify(socketPath)}`
+    );
+  }
+  return { directory, socketPath };
+}
+function probeSocket(socketPath) {
+  return new Promise((resolveProbe) => {
+    const socket = net.createConnection(socketPath);
+    let data = "";
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      resolveProbe(result);
+    };
+    socket.setEncoding("utf8");
+    socket.setTimeout(1e3);
+    socket.on("data", (chunk) => {
+      data += chunk;
+    });
+    socket.once("end", () => {
+      try {
+        const parsed = JSON.parse(data);
+        const owner = Number.isInteger(parsed.pid) && typeof parsed.stateDir === "string" && typeof parsed.startedAt === "string" ? parsed : null;
+        finish({ kind: "live", owner });
+      } catch {
+        finish({ kind: "live", owner: null });
+      }
+    });
+    socket.once("timeout", () => finish({ kind: "ambiguous", error: new Error("timed out probing the live lock socket") }));
+    socket.once("error", (error) => {
+      const code = fsCode(error);
+      if (code === "ECONNREFUSED" || code === "ENOENT") finish({ kind: "stale" });
+      else finish({ kind: "ambiguous", error });
+    });
+  });
+}
+function listen(server, socketPath) {
+  return new Promise((resolveListen, reject) => {
+    const onError = (error) => reject(error);
+    server.once("error", onError);
+    server.listen(socketPath, () => {
+      server.off("error", onError);
+      resolveListen();
+    });
+  });
+}
+async function acquireStateRootLock(inputStateDir) {
+  const stateDir = canonicalStateDir(inputStateDir);
+  const { socketPath } = stateRootLockPath(stateDir);
+  const owner = { pid: process.pid, stateDir, startedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  for (let attempt = 1; attempt <= MAX_ACQUIRE_ATTEMPTS; attempt++) {
+    const server = net.createServer((socket) => socket.end(`${JSON.stringify(owner)}
+`));
+    try {
+      await listen(server, socketPath);
+      server.unref();
+      let closed = false;
+      return {
+        stateDir,
+        socketPath,
+        owner,
+        close: async () => {
+          if (closed) return;
+          closed = true;
+          await new Promise((resolveClose) => server.close(() => resolveClose()));
+          try {
+            fs.unlinkSync(socketPath);
+          } catch (error) {
+            if (fsCode(error) !== "ENOENT") throw error;
+          }
+        }
+      };
+    } catch (error) {
+      try {
+        server.close();
+      } catch {
+      }
+      if (fsCode(error) !== "EADDRINUSE") throw error;
+      const probe = await probeSocket(socketPath);
+      if (probe.kind === "live") {
+        throw new StateRootLockedError(stateDir, probe.owner?.pid ?? null, probe.owner);
+      }
+      if (probe.kind === "ambiguous") {
+        throw new Error(
+          `could not prove whether daemon lock ${JSON.stringify(socketPath)} is live or stale; refusing to remove it: ${probe.error.message}`
+        );
+      }
+      try {
+        fs.unlinkSync(socketPath);
+      } catch (unlinkError) {
+        if (fsCode(unlinkError) !== "ENOENT") throw unlinkError;
+      }
+    }
+  }
+  throw new Error(`could not acquire daemon state-root lock for ${JSON.stringify(stateDir)} after ${MAX_ACQUIRE_ATTEMPTS} races`);
+}
+
+// ../../src/internal/daemon.ts
+var ENTRY_CONFIG = loadConfig();
+var heldLock = null;
+async function ensureLock() {
+  assertConfigNotDrifted();
+  if (heldLock) return { lock: heldLock, acquired: false };
+  const lock = await acquireStateRootLock(ENTRY_CONFIG.stateDir);
+  fs2.mkdirSync(lock.stateDir, { recursive: true, mode: 448 });
+  const actual = fs2.realpathSync.native(lock.stateDir);
+  if (actual !== lock.stateDir) {
+    await lock.close();
+    throw new Error(
+      `state directory canonical path changed during lock acquisition: locked ${JSON.stringify(lock.stateDir)}, created ${JSON.stringify(actual)}`
+    );
+  }
+  heldLock = lock;
+  return { lock, acquired: true };
+}
+async function releaseHeld(lock) {
+  if (heldLock !== lock) return;
+  heldLock = null;
+  await lock.close();
+}
+async function bootKernel() {
+  const { lock, acquired } = await ensureLock();
+  try {
+    const { bootWrapper } = await import("./boot-35BOHNSZ.js");
+    await bootWrapper();
+  } catch (error) {
+    if (acquired) await releaseHeld(lock);
+    throw error;
+  }
+}
+async function startDaemon(opts = {}) {
+  const { lock, acquired } = await ensureLock();
+  try {
+    const runtime = await import("./server-TDJBEWTU.js");
+    const { onRuntimeLoaded, ...daemonOptions } = opts;
+    onRuntimeLoaded?.();
+    const handle = await runtime.startDaemon({
+      ...daemonOptions,
+      // The server owns its existing signal behavior. This callback releases
+      // the lock after teardown and before its signal path exits the process.
+      onShutdown: async () => releaseHeld(lock)
+    });
+    let closed = false;
+    return {
+      port: handle.port,
+      close: async () => {
+        if (closed) return;
+        closed = true;
+        try {
+          await handle.close();
+        } finally {
+          await releaseHeld(lock);
+        }
+      }
+    };
+  } catch (error) {
+    if (acquired) await releaseHeld(lock);
+    throw error;
+  }
+}
+export {
+  StateRootLockedError,
+  bootKernel,
+  canonicalStateDir,
+  startDaemon,
+  stateRootLockPath
+};

package/dist/help.js

@@ -3,7 +3,7 @@ import {
   helpRequestPath,
   renderHelp,
   renderTopHelp
-} from "./chunk-RJWUCR3R.js";
+} from "./chunk-ZFE47KH3.js";
 import "./chunk-QRNZFPNJ.js";
 import "./chunk-6NFATG6P.js";
 import "./chunk-SDNTPCKW.js";

package/dist/lifecycle.js

@@ -7,8 +7,8 @@ import {
   startDaemonManaged,
   stopDaemonManaged,
   writeManagedRecord
-} from "./chunk-4IFFMMQO.js";
-import "./chunk-6W3RHW3C.js";
+} from "./chunk-QZIL3IT7.js";
+import "./chunk-6K2JBKHI.js";
 export {
   DAEMON_LOG_FILE,
   MANAGED_PID_FILE,

package/dist/main.js

@@ -12,12 +12,12 @@ import {
 import {
   setupConfig,
   showConfig
-} from "./chunk-G2GHHOYX.js";
+} from "./chunk-DRQEV4SN.js";
 import {
   helpHint,
   helpRequestPath,
   renderHelp
-} from "./chunk-RJWUCR3R.js";
+} from "./chunk-ZFE47KH3.js";
 import {
   invokeOperation,
   isOperationName,
@@ -29,7 +29,6 @@ import {
 } from "./chunk-QRNZFPNJ.js";
 import {
   CliUsageError,
-  parseBoolean,
   parseFlags,
   parseInteger
 } from "./chunk-6NFATG6P.js";
@@ -44,18 +43,18 @@ import {
   serveDaemon,
   startDaemonManaged,
   stopDaemonManaged
-} from "./chunk-4IFFMMQO.js";
+} from "./chunk-QZIL3IT7.js";
 import {
   attachClient,
   defaultConfigPath,
   resolveSelection
-} from "./chunk-6W3RHW3C.js";
+} from "./chunk-6K2JBKHI.js";
 
 // src/main.ts
 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" : "0.6.0";
+var CLI_VERSION = false ? "0.0.0-dev" : "1.0.0";
 var COMMON_VALUES = /* @__PURE__ */ new Set(["--endpoint", "--port", "--state-dir", "--config", "--identity"]);
 var COMMON_BOOLEANS = /* @__PURE__ */ new Set(["--json", "--yes", "--help"]);
 function selectionFrom(values) {
@@ -163,7 +162,7 @@ async function runGrouped(group, args, io) {
   return 0;
 }
 async function runConfig(args, io) {
-  const values = /* @__PURE__ */ new Set([...COMMON_VALUES, "--broker-url", "--gc-interval-ms", "--auto-start", "--api-visibility"]);
+  const values = /* @__PURE__ */ new Set([...COMMON_VALUES, "--broker-url", "--gc-interval-ms", "--api-visibility"]);
   const flags = parseFlags(args, values, /* @__PURE__ */ new Set(["--json", "--dry-run", "--help"]));
   const action = flags.positionals[0];
   const spec = action === void 0 ? void 0 : commandSpec("config", action);
@@ -178,7 +177,6 @@ async function runConfig(args, io) {
   if (flags.values["--port"]) patch.port = parseInteger(flags.values["--port"], "--port", 1, 65535);
   if (flags.values["--state-dir"]) patch.stateDir = resolve(flags.values["--state-dir"]);
   if (flags.values["--gc-interval-ms"]) patch.gcIntervalMs = parseInteger(flags.values["--gc-interval-ms"], "--gc-interval-ms", 1);
-  if (flags.values["--auto-start"]) patch.autoStart = parseBoolean(flags.values["--auto-start"], "--auto-start");
   if (flags.values["--api-visibility"]) {
     const visibility = flags.values["--api-visibility"];
     if (!["owner", "shared", "open"].includes(visibility)) throw new CliUsageError("--api-visibility must be owner, shared, or open");