@alfe.ai/gateway 0.10.1 → 0.10.3

package/dist/health.js

@@ -1,4 +1,4 @@
-import { a as ErrorLineDetector, c as createLogger, i as CaptureThrottle, m as __require, o as STRICT_ERROR_CAPTURE_PROFILE, p as __commonJSMin, r as RuntimeProcess, s as toFingerprintKey, t as DRAIN_GRACE_MS } from "./runtime-process.js";
+import { a as ErrorLineDetector, c as createLogger, f as parseOpenClawVersion, h as __require, i as CaptureThrottle, m as __commonJSMin, n as OPENCLAW_EXTERNAL_SUPERVISOR_ENV, o as STRICT_ERROR_CAPTURE_PROFILE, r as RuntimeProcess, s as toFingerprintKey, t as DRAIN_GRACE_MS } from "./runtime-process.js";
 import { a as captureFatal, d as flushSentry, f as initAgentSentry, h as logger, o as captureIntegrationFailure, p as setAgentContext, s as captureMcpFailure } from "./sentry.js";
 import { chmod, mkdir, readFile, rename, stat, unlink, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
@@ -5858,16 +5858,57 @@ const log$5 = logger.child({ component: "RuntimeGate" });
 var RuntimeGate = class {
 	depth = 0;
 	wasRunning = false;
+	exclusive = false;
+	/** Brackets parked behind an exclusive hold (or an exclusive request parked behind open brackets). */
+	waiters = [];
 	constructor(getRuntime) {
 		this.getRuntime = getRuntime;
 	}
+	/** True while any bracket (shared or exclusive) is open. */
+	get isSuspended() {
+		return this.depth > 0;
+	}
+	/** True while an exclusive bracket is open. */
+	get isExclusive() {
+		return this.exclusive;
+	}
+	waitFor(ready) {
+		if (ready()) return Promise.resolve();
+		return new Promise((resolve) => {
+			const check = () => {
+				if (ready()) resolve();
+				else this.waiters.push(check);
+			};
+			this.waiters.push(check);
+		});
+	}
+	wakeWaiters() {
+		const pending = this.waiters;
+		this.waiters = [];
+		for (const wake of pending) wake();
+	}
 	/**
 	* Suspend the runtime child. Only the outermost call (depth 0 → 1) actually
 	* stops it; nested calls just bump the refcount. Remembers whether the child
 	* was running so `resume()` doesn't spuriously start a runtime that was never
-	* up (e.g. autoStartRuntime=false).
+	* up (e.g. autoStartRuntime=false). Waits while an exclusive bracket is open.
 	*/
 	async suspend() {
+		if (this.exclusive) log$5.info("Mutating reconcile parked behind an exclusive runtime hold (upgrade in flight)");
+		while (this.exclusive) await this.waitFor(() => !this.exclusive);
+		await this.enter();
+	}
+	async suspendExclusive() {
+		if (this.exclusive || this.depth !== 0) log$5.info({
+			depth: this.depth,
+			exclusive: this.exclusive
+		}, "Exclusive runtime hold parked behind open brackets (reconcile in flight)");
+		while (this.exclusive || this.depth !== 0) await this.waitFor(() => !this.exclusive && this.depth === 0);
+		log$5.info("Exclusive runtime hold acquired");
+		this.exclusive = true;
+		await this.enter();
+	}
+	async enter() {
 		if (this.depth++ > 0) return;
 		const rp = this.getRuntime();
 		this.wasRunning = rp?.isRunning ?? false;
@@ -5891,6 +5932,8 @@ var RuntimeGate = class {
 			rp.resume();
 		}
 		this.wasRunning = false;
+		if (this.exclusive) this.exclusive = false;
+		this.wakeWaiters();
 		return Promise.resolve();
 	}
 	/**
@@ -5920,6 +5963,9 @@ var NoopRuntimeGate = class {
 	suspend() {
 		return Promise.resolve();
 	}
+	suspendExclusive() {
+		return Promise.resolve();
+	}
 	resume() {
 		return Promise.resolve();
 	}
@@ -7982,6 +8028,7 @@ var IPCServer = class {
 * standalone pieces of `startDaemon()`: version detection, the one-shot
 * persona-file migration, the AI proxy listener, and the IPC server start.
 */
+const RUNTIME_VERSION_TIMEOUT_MS = 1e4;
 const execFileAsync$2 = promisify(execFile);
 /**
 * Resolve the installed @alfe.ai/cli version.
@@ -8040,9 +8087,24 @@ function resolveRuntimeVersionCommand(runtime) {
 	return RUNTIME_VERSION_COMMANDS[runtime];
 }
 /**
+* Reduce a runtime's `--version` output to the bare version the control plane
+* compares against catalog versions. Every OpenClaw release prints a branded
+* line (`OpenClaw 2026.9.5 (ec9c1a1)`); reporting that verbatim hid every
+* dashboard upgrade affordance for the agents that most needed one. The agents
+* service also normalises at ingest (it reaches hosts on older daemons); this
+* is the producer-side half. Falls back to the trimmed output when no version
+* token is found so an unexpected format is still visible rather than blank.
+*/
+function normalizeRuntimeVersion(runtime, stdout) {
+	const trimmed = stdout.trim();
+	if (!trimmed) return void 0;
+	if (runtime === "openclaw") return parseOpenClawVersion(trimmed) ?? trimmed;
+	return trimmed;
+}
+/**
 * Resolve the installed runtime version by running the per-runtime version
-* command and returning the trimmed stdout. An unknown runtime (no command in
-* the map) returns `undefined` without spawning — it must never throw.
+* command and normalising its stdout. An unknown runtime (no command in the
+* map) returns `undefined` without spawning — it must never throw.
 */
 async function getRuntimeVersion(runtime) {
 	const cmd = resolveRuntimeVersionCommand(runtime);
@@ -8051,8 +8113,14 @@ async function getRuntimeVersion(runtime) {
 		return;
 	}
 	try {
-		const { stdout } = await execFileAsync$2(cmd.command, cmd.args);
-		return stdout.trim() || void 0;
+		const { stdout } = await execFileAsync$2(cmd.command, cmd.args, {
+			timeout: RUNTIME_VERSION_TIMEOUT_MS,
+			env: {
+				...process.env,
+				...runtime === "openclaw" ? OPENCLAW_EXTERNAL_SUPERVISOR_ENV : {}
+			}
+		});
+		return normalizeRuntimeVersion(runtime, stdout);
 	} catch {
 		logger.debug({ runtime }, "Could not resolve runtime version");
 		return;
@@ -9929,6 +9997,15 @@ async function drainRuntimeBeforeExit(reason) {
 }
 async function executeCloudCommand(command) {
 	if (isWorkCommand(command.command)) return executeWorkCommand(command, config.agentId, config.runtime, ipcServer);
+	if ((command.command === "daemon.update" || command.command === "daemon.restart") && upgradingRuntime) return {
+		type: "COMMAND_ACK",
+		commandId: command.commandId,
+		status: "error",
+		result: {
+			code: "RUNTIME_UPGRADE_IN_PROGRESS",
+			message: `${command.command} refused: a runtime upgrade is in progress; retry when it has completed`
+		}
+	};
 	if (command.command === "daemon.update") {
 		const version = command.payload?.version ?? "latest";
 		setTimeout(() => {

package/dist/node-remediation.js

@@ -1,4 +1,4 @@
-import { f as supportsOpenClawNode, u as OPENCLAW_NODE_REQUIREMENT } from "./runtime-process.js";
+import { p as supportsOpenClawNode, u as OPENCLAW_NODE_REQUIREMENT } from "./runtime-process.js";
 import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";

package/dist/runtime-process.js

@@ -90,6 +90,16 @@ function supportsOpenClawNode(nodeVersion) {
 	if (major === 26) return minor >= 1;
 	return major > 26;
 }
+/**
+* Extract the semver-like version token printed by `openclaw --version`.
+* Every OpenClaw release prints a branded line (`OpenClaw 2026.6.11 (e085fa1)`,
+* `OpenClaw 2026.9.5 (ec9c1a1)`); this reduces it to the bare token. Requires
+* whitespace delimiters and a four-digit year major, so unexpected formats
+* return `undefined` and callers fall back to the raw line.
+*/
+function parseOpenClawVersion(output) {
+	return /(?:^|\s)(\d{4}\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)(?:\s|$)/u.exec(output.trim())?.[1];
+}
 //#endregion
 //#region ../../node_modules/.pnpm/dotenv@17.2.2/node_modules/dotenv/package.json
 var require_package = /* @__PURE__ */ __commonJSMin(((exports, module) => {
@@ -15766,4 +15776,4 @@ var RuntimeProcess = class {
 	}
 };
 //#endregion
-export { ErrorLineDetector as a, createLogger as c, PINNED_OPENCLAW_VERSION as d, supportsOpenClawNode as f, CaptureThrottle as i, OPENCLAW_MANAGED_NODE_MAJOR as l, __require as m, OPENCLAW_EXTERNAL_SUPERVISOR_ENV as n, STRICT_ERROR_CAPTURE_PROFILE as o, __commonJSMin as p, RuntimeProcess as r, toFingerprintKey as s, DRAIN_GRACE_MS as t, OPENCLAW_NODE_REQUIREMENT as u };
+export { ErrorLineDetector as a, createLogger as c, PINNED_OPENCLAW_VERSION as d, parseOpenClawVersion as f, __require as h, CaptureThrottle as i, OPENCLAW_MANAGED_NODE_MAJOR as l, __commonJSMin as m, OPENCLAW_EXTERNAL_SUPERVISOR_ENV as n, STRICT_ERROR_CAPTURE_PROFILE as o, supportsOpenClawNode as p, RuntimeProcess as r, toFingerprintKey as s, DRAIN_GRACE_MS as t, OPENCLAW_NODE_REQUIREMENT as u };

package/dist/runtime-upgrade.js

@@ -1,5 +1,5 @@
-import { f as supportsOpenClawNode, n as OPENCLAW_EXTERNAL_SUPERVISOR_ENV, u as OPENCLAW_NODE_REQUIREMENT } from "./runtime-process.js";
-import { c as captureNodeRemediation, h as logger } from "./sentry.js";
+import { f as parseOpenClawVersion, n as OPENCLAW_EXTERNAL_SUPERVISOR_ENV, p as supportsOpenClawNode, u as OPENCLAW_NODE_REQUIREMENT } from "./runtime-process.js";
+import { c as captureNodeRemediation, h as logger, i as captureCliFailure } from "./sentry.js";
 import { n as remediateManagedNode, t as NodeRemediationError } from "./node-remediation.js";
 import { mkdir } from "node:fs/promises";
 import { join } from "node:path";
@@ -27,6 +27,7 @@ import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
 const OPENCLAW_UPGRADE_TIMEOUT_MS = 3e5;
 const OPENCLAW_DOCTOR_TIMEOUT_MS = 9e5;
+const OPENCLAW_DOCTOR_MAX_BUFFER_BYTES = 16 * 1024 * 1024;
 /**
 * A non-diagnostic probe run right after the new package lands. 2026.9.x
 * classifies `--version`/`--help` as diagnostic and lets them succeed even when
@@ -41,6 +42,31 @@ const OPENCLAW_DOCTOR_TIMEOUT_MS = 9e5;
 * runtime regardless of config contents.
 */
 const OPENCLAW_ADMISSION_PROBE_ARGS = ["config", "file"];
+/**
+* `doctor --fix` runs the state/config migration. On 2026.9.x `--json` puts
+* doctor into READ-ONLY lint mode and it refuses the combination outright
+* (exit 2: "doctor --json runs read-only lint checks and cannot be combined
+* with --repair, --fix, or --force"), so the migration must run without it.
+* The post-upgrade audit is read-only and keeps `--json`.
+*/
+const OPENCLAW_DOCTOR_FIX_ARGS = [
+	"doctor",
+	"--fix",
+	"--non-interactive",
+	"--yes"
+];
+const OPENCLAW_DOCTOR_AUDIT_ARGS = [
+	"doctor",
+	"--post-upgrade",
+	"--json"
+];
+/** Keep the tail of a command's output in an error so a failed migration is diagnosable from the daemon log. */
+const OUTPUT_TAIL_CHARS = 1500;
+const ANSI_ESCAPE = new RegExp(`${String.fromCharCode(27)}\\[[0-9;?]*[A-Za-z]`, "g");
+function outputTail(value) {
+	const text = typeof value === "string" ? value.replace(ANSI_ESCAPE, "").trim() : "";
+	return text.length > OUTPUT_TAIL_CHARS ? `…${text.slice(-OUTPUT_TAIL_CHARS)}` : text;
+}
 function resolveUpgradeCommand(runtime, version) {
 	switch (runtime) {
 		case "openclaw":
@@ -70,10 +96,6 @@ function resolveUpgradeCommand(runtime, version) {
 		default: return;
 	}
 }
-/** Extract the semver-like version token printed by `openclaw --version`. */
-function parseOpenClawVersion(output) {
-	return /(?:^|\s)(\d{4}\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)(?:\s|$)/u.exec(output.trim())?.[1];
-}
 async function upgradeRuntime(runtime, version, runtimeProcess, options = {}) {
 	const runCommand = options.runCommand ?? (async (command, args, commandOptions) => {
 		const result = await execFileAsync(command, args, commandOptions);
@@ -210,18 +232,25 @@ async function upgradeRuntime(runtime, version, runtimeProcess, options = {}) {
 				runtimeChanged = installedVersion !== previousOpenClawVersion;
 				await runCommand("openclaw", [...OPENCLAW_ADMISSION_PROBE_ARGS], commandOptions(6e4));
 				doctorStarted = true;
-				await runCommand("openclaw", [
-					"doctor",
-					"--fix",
-					"--non-interactive",
-					"--yes",
-					"--json"
-				], commandOptions(OPENCLAW_DOCTOR_TIMEOUT_MS));
-				const audit = await runCommand("openclaw", [
-					"doctor",
-					"--post-upgrade",
-					"--json"
-				], commandOptions(OPENCLAW_DOCTOR_TIMEOUT_MS));
+				try {
+					const doctor = await runCommand("openclaw", [...OPENCLAW_DOCTOR_FIX_ARGS], {
+						...commandOptions(OPENCLAW_DOCTOR_TIMEOUT_MS),
+						maxBuffer: OPENCLAW_DOCTOR_MAX_BUFFER_BYTES
+					});
+					logger.info({ doctor: outputTail(doctor.stdout) }, "OpenClaw doctor migration completed");
+				} catch (err) {
+					const failure = err;
+					const stdout = outputTail(failure.stdout);
+					const stderr = outputTail(failure.stderr);
+					logger.error({
+						stdout,
+						stderr
+					}, "OpenClaw doctor migration failed");
+					const wrapped = new Error(`openclaw doctor --fix failed: ${failure.message ?? String(err)}` + (stderr ? `\nstderr: ${stderr}` : "") + (stdout ? `\nstdout: ${stdout}` : ""), { cause: err });
+					captureCliFailure("openclaw-doctor-migration", wrapped);
+					throw wrapped;
+				}
+				const audit = await runCommand("openclaw", [...OPENCLAW_DOCTOR_AUDIT_ARGS], commandOptions(OPENCLAW_DOCTOR_TIMEOUT_MS));
 				if (audit.stdout) logger.info({ audit: audit.stdout.trim() }, "OpenClaw post-upgrade audit completed");
 			}
 		} catch (err) {
@@ -243,7 +272,7 @@ async function upgradeRuntime(runtime, version, runtimeProcess, options = {}) {
 	try {
 		if (options.gate) {
 			gateSuspended = true;
-			await options.gate.suspend();
+			await options.gate.suspendExclusive();
 		} else if (runtimeProcess) await runtimeProcess.stopWhenIdle();
 		if (runtime === "openclaw" && options.cliLock) await options.cliLock.run(performUpgrade);
 		else await performUpgrade();

package/dist/src/index.d.ts

@@ -76,6 +76,13 @@ declare const OPENCLAW_MANAGED_NODE_MAJOR = 24;
  * Pre-release tags are rejected; build metadata (`+…`) is accepted.
  */
 declare function supportsOpenClawNode(nodeVersion: string): boolean;
+/**
+ * Extract the semver-like version token printed by `openclaw --version`.
+ * Every OpenClaw release prints a branded line (`OpenClaw 2026.6.11 (e085fa1)`,
+ * `OpenClaw 2026.9.5 (ec9c1a1)`); this reduces it to the bare token. Requires
+ * whitespace delimiters and a four-digit year major, so unexpected formats
+ * return `undefined` and callers fall back to the raw line.
+ */
 //#endregion
 //#region src/node-remediation.d.ts
 

package/dist/src/index.js

@@ -1,4 +1,4 @@
-import { d as PINNED_OPENCLAW_VERSION, f as supportsOpenClawNode, l as OPENCLAW_MANAGED_NODE_MAJOR, u as OPENCLAW_NODE_REQUIREMENT } from "../runtime-process.js";
+import { d as PINNED_OPENCLAW_VERSION, l as OPENCLAW_MANAGED_NODE_MAJOR, p as supportsOpenClawNode, u as OPENCLAW_NODE_REQUIREMENT } from "../runtime-process.js";
 import { _ as loadDaemonConfig, a as installService, c as startService, d as uninstallService, f as PROTOCOL_VERSION, g as fetchAgentConfig, h as SOCKET_PATH, i as checkExistingDaemon, l as stopExistingDaemon, m as PID_PATH, n as queryDaemonHealth, o as isServiceInstalled, p as ALFE_DIR, r as startDaemon, s as restartService, t as formatHealthReport, u as stopService, v as resolveAgentIdentity, y as PINNED_CLAUDE_CODE_HOST_VERSION } from "../health.js";
 import { a as captureFatal, d as flushSentry, f as initAgentSentry, h as logger, i as captureCliFailure, l as captureRuntimeCrash, n as AGENT_MCP_SENTRY_DSN, o as captureIntegrationFailure, p as setAgentContext, r as AGENT_RUNTIME_SENTRY_DSN, s as captureMcpFailure, t as AGENT_DAEMON_SENTRY_DSN, u as captureRuntimeErrorOutput } from "../sentry.js";
 import { n as remediateManagedNode } from "../node-remediation.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/gateway",
-  "version": "0.10.1",
+  "version": "0.10.3",
   "description": "Alfe local gateway daemon — persistent control plane for agent integrations",
   "type": "module",
   "bin": {
@@ -27,7 +27,7 @@
     "@alfe.ai/ai-proxy-local": "^0.0.17",
     "@alfe.ai/config": "^0.4.1",
     "@alfe.ai/integration-manifest": "^0.4.2",
-    "@alfe.ai/integrations": "^0.6.7",
+    "@alfe.ai/integrations": "^0.6.8",
     "@alfe.ai/mcp-bundler": "^0.4.2"
   },
   "license": "UNLICENSED",