@alfe.ai/gateway 0.10.2 → 0.10.3

package/dist/health.js

@@ -1,4 +1,4 @@
-import { a as ErrorLineDetector, c as createLogger, f as parseOpenClawVersion, h as __require, i as CaptureThrottle, m as __commonJSMin, o as STRICT_ERROR_CAPTURE_PROFILE, 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.
@@ -8066,7 +8113,13 @@ async function getRuntimeVersion(runtime) {
 		return;
 	}
 	try {
-		const { stdout } = await execFileAsync$2(cmd.command, cmd.args);
+		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");
@@ -9944,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/runtime-upgrade.js

@@ -1,5 +1,5 @@
 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 } from "./sentry.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":
@@ -206,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) {
@@ -239,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/gateway",
-  "version": "0.10.2",
+  "version": "0.10.3",
   "description": "Alfe local gateway daemon — persistent control plane for agent integrations",
   "type": "module",
   "bin": {