@alfe.ai/gateway 0.1.4 → 0.2.0

package/dist/health.js

@@ -12,7 +12,7 @@ import crypto from "crypto";
 import { parse } from "smol-toml";
 import WebSocket from "ws";
 import { createConnection, createServer } from "node:net";
-import { IntegrationManager, IntegrationManagerAdapter, McpApplier, OpenClawApplier } from "@alfe.ai/integrations";
+import { HermesApplier, HermesMcpSync, IntegrationManager, IntegrationManagerAdapter, McpApplier, OpenClawApplier } from "@alfe.ai/integrations";
 import { AgentApiClient } from "@alfe.ai/agent-api-client";
 import { Manager, McpBundler, defaultConnect } from "@alfe.ai/mcp-bundler";
 import stream, { Readable } from "stream";
@@ -109,6 +109,8 @@ const ID_PREFIXES = {
 	identityVerification: "ivf",
 	role: "role",
 	directGrant: "dgr",
+	revision: "rev",
+	fact: "kfc",
 	oauthConnection: "con",
 	channel: "chn",
 	oauthConnectionRequest: "crq",
@@ -1292,6 +1294,7 @@ const string$1 = (params) => {
 };
 const integer = /^-?\d+$/;
 const number$1 = /^-?\d+(?:\.\d+)?$/;
+const boolean$1 = /^(?:true|false)$/i;
 const lowercase = /^[^A-Z]*$/;
 const uppercase = /^[^a-z]*$/;
 //#endregion
@@ -2066,6 +2069,24 @@ const $ZodNumberFormat = /* @__PURE__ */ $constructor("$ZodNumberFormat", (inst,
 	$ZodCheckNumberFormat.init(inst, def);
 	$ZodNumber.init(inst, def);
 });
+const $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.pattern = boolean$1;
+	inst._zod.parse = (payload, _ctx) => {
+		if (def.coerce) try {
+			payload.value = Boolean(payload.value);
+		} catch (_) {}
+		const input = payload.value;
+		if (typeof input === "boolean") return payload;
+		payload.issues.push({
+			expected: "boolean",
+			code: "invalid_type",
+			input,
+			inst
+		});
+		return payload;
+	};
+});
 const $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload) => payload;
@@ -3046,6 +3067,13 @@ function _int(Class, params) {
 	});
 }
 /* @__NO_SIDE_EFFECTS__ */
+function _boolean(Class, params) {
+	return new Class({
+		type: "boolean",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
 function _unknown(Class) {
 	return new Class({ type: "unknown" });
 }
@@ -3588,6 +3616,9 @@ const numberProcessor = (schema, ctx, _json, _params) => {
 	}
 	if (typeof multipleOf === "number") json.multipleOf = multipleOf;
 };
+const booleanProcessor = (_schema, _ctx, json, _params) => {
+	json.type = "boolean";
+};
 const neverProcessor = (_schema, _ctx, json, _params) => {
 	json.not = {};
 };
@@ -4063,6 +4094,14 @@ const ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, d
 function int(params) {
 	return /* @__PURE__ */ _int(ZodNumberFormat, params);
 }
+const ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
+	$ZodBoolean.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => booleanProcessor(inst, ctx, json, params);
+});
+function boolean(params) {
+	return /* @__PURE__ */ _boolean(ZodBoolean, params);
+}
 const ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
 	$ZodUnknown.init(inst, def);
 	ZodType.init(inst, def);
@@ -4391,7 +4430,10 @@ enumValues({
 	Month: "month",
 	Year: "year"
 });
-object({ gracePeriodDays: number().int().positive().optional() });
+object({
+	gracePeriodDays: number().int().positive().optional(),
+	launchDiscountEnabled: boolean().optional()
+});
 enumValues({
 	ManagedHosting: "managed-hosting",
 	PlatformTier: "platform-tier",
@@ -4399,12 +4441,13 @@ enumValues({
 	Other: "other"
 });
 enumValues({
-	Free: "free",
-	Personal: "personal",
-	PersonalPlus: "personal_plus",
-	PersonalPro: "personal_pro",
-	Tier1: "tier_1",
-	Tier2: "tier_2"
+	IndividualLite: "individual_lite",
+	IndividualNormal: "individual_normal",
+	IndividualPro: "individual_pro",
+	IndividualMax: "individual_max",
+	OrgFree: "org_free",
+	OrgProfessional: "org_professional",
+	OrgEnterprise: "org_enterprise"
 });
 enumValues({
 	Pending: "pending",
@@ -4437,7 +4480,8 @@ enumValues({
 });
 enumValues({
 	OpenClaw: "openclaw",
-	NanoClaw: "nanoclaw"
+	NanoClaw: "nanoclaw",
+	Hermes: "hermes"
 });
 enumValues({
 	Org: "org",
@@ -4922,17 +4966,33 @@ async function loadManagedConfig() {
 		agentId: identity.agentId,
 		orgId: identity.orgId,
 		runtime: identity.runtime,
-		runtimes: identity.runtime === "openclaw" ? (() => {
-			const home = join(homedir(), ".openclaw");
-			return { openclaw: {
-				workspace: home,
-				agentWorkspace: deriveAgentWorkspace("openclaw", home)
-			} };
-		})() : {},
+		runtimes: buildManagedRuntimes(identity.runtime),
 		autoStartRuntime: true
 	};
 }
 /**
+* Build the managed-mode `runtimes` map for a single resolved runtime.
+* Returns an empty map for unknown runtimes (the daemon then skips runtime
+* start rather than crashing).
+*/
+function buildManagedRuntimes(runtime) {
+	if (runtime === "openclaw") {
+		const home = join(homedir(), ".openclaw");
+		return { openclaw: {
+			workspace: home,
+			agentWorkspace: deriveAgentWorkspace("openclaw", home)
+		} };
+	}
+	if (runtime === "hermes") {
+		const home = join(homedir(), ".hermes");
+		return { hermes: {
+			workspace: home,
+			agentWorkspace: deriveAgentWorkspace("hermes", home)
+		} };
+	}
+	return {};
+}
+/**
 * Load full daemon configuration.
 * Reads config.toml, validates the API key, resolves agent identity,
 * and parses runtime configurations.
@@ -4951,6 +5011,7 @@ async function loadDaemonConfig() {
 	const identity = await resolveAgentIdentity(alfeConfig.api_key, apiEndpoint);
 	const gatewayWsUrl = alfeConfig.gateway_url ?? deriveGatewayWsUrl(apiEndpoint);
 	const runtimes = await loadRuntimeConfigs();
+	const runtime = alfeConfig.runtime ?? identity.runtime;
 	return {
 		apiKey: alfeConfig.api_key,
 		apiEndpoint,
@@ -4959,7 +5020,7 @@ async function loadDaemonConfig() {
 		pidPath: PID_PATH,
 		agentId: identity.agentId,
 		orgId: identity.orgId,
-		runtime: identity.runtime,
+		runtime,
 		runtimes,
 		autoStartRuntime: alfeConfig.auto_start_runtime ?? true
 	};
@@ -5172,7 +5233,18 @@ const PROTOCOL_VERSION = 1;
 //#endregion
 //#region src/reconciliation.ts
 const log$2 = logger$1.child({ component: "Reconciliation" });
+/**
+* How many times reconcile will re-attempt activation of an intact integration
+* stuck in `error` (with no reinstall requested) before giving up and waiting
+* for a manual reinstall. Each reconcile pass = one cloud DESIRED_STATE push,
+* so these attempts are spread across pushes, not a tight loop. This lets a
+* transient activation failure (e.g. an `openclaw config set` racing a runtime
+* hot-reload) self-heal without the user clicking Reinstall.
+*/
+const MAX_ERROR_ACTIVATE_ATTEMPTS = 3;
 var ReconciliationEngine = class {
+	/** Consecutive re-activation attempts for an intact error-state integration, keyed by id. */
+	activateAttempts = /* @__PURE__ */ new Map();
 	constructor(manager) {
 		this.manager = manager;
 	}
@@ -5236,6 +5308,7 @@ var ReconciliationEngine = class {
 				if (desired.reinstallRequestedAt && local.installedAt && desired.reinstallRequestedAt > local.installedAt) {
 					log$2.info(`Reinstalling ${id} from error state (requested: ${desired.reinstallRequestedAt}, installed: ${local.installedAt})`);
 					this.manager.resetReinstallAttempts(id);
+					this.activateAttempts.delete(id);
 					if ((await this.manager.reinstall(id, desired.version, desired.config, desired.customSource)).configApplied) report.configApplied = true;
 					report.installed.push(id);
 					report.activated.push(id);
@@ -5267,6 +5340,7 @@ var ReconciliationEngine = class {
 					try {
 						if ((await this.manager.reinstall(id, desired.version, desired.config, desired.customSource)).configApplied) report.configApplied = true;
 						this.manager.resetReinstallAttempts(id);
+						this.activateAttempts.delete(id);
 						report.installed.push(id);
 						report.activated.push(id);
 						report.results.push({
@@ -5290,7 +5364,37 @@ var ReconciliationEngine = class {
 					}
 					return;
 				}
-				log$2.warn(`Integration ${id} is in error state — waiting for reinstall request`);
+				const activateAttempts = this.activateAttempts.get(id) ?? 0;
+				if (activateAttempts < MAX_ERROR_ACTIVATE_ATTEMPTS) {
+					this.activateAttempts.set(id, activateAttempts + 1);
+					log$2.info(`Re-activating ${id} from error state (attempt ${String(activateAttempts + 1)}/${String(MAX_ERROR_ACTIVATE_ATTEMPTS)})`);
+					try {
+						if ((await this.manager.activate(id)).configApplied) report.configApplied = true;
+						this.activateAttempts.delete(id);
+						report.activated.push(id);
+						report.results.push({
+							integrationId: id,
+							action: "activated",
+							actualStatus: "active"
+						});
+						return;
+					} catch (reactivateErr) {
+						const reactivateMsg = reactivateErr instanceof Error ? reactivateErr.message : String(reactivateErr);
+						log$2.warn(`Re-activation of ${id} from error state failed (attempt ${String(activateAttempts + 1)}/${String(MAX_ERROR_ACTIVATE_ATTEMPTS)}): ${reactivateMsg}`);
+						report.errors.push({
+							integrationId: id,
+							error: reactivateMsg
+						});
+						report.results.push({
+							integrationId: id,
+							action: "error",
+							actualStatus: "error",
+							errorMessage: reactivateMsg
+						});
+						return;
+					}
+				}
+				log$2.warn(`Integration ${id} is in error state — re-activation exhausted, waiting for reinstall request`);
 				report.errors.push({
 					integrationId: id,
 					error: "Integration is in error state"
@@ -5317,6 +5421,7 @@ var ReconciliationEngine = class {
 			if (desired.reinstallRequestedAt && local.installedAt && desired.reinstallRequestedAt > local.installedAt) {
 				log$2.info(`Reinstall requested for ${id} (requested: ${desired.reinstallRequestedAt}, installed: ${local.installedAt})`);
 				this.manager.resetReinstallAttempts(id);
+				this.activateAttempts.delete(id);
 				if ((await this.manager.reinstall(id, desired.version, desired.config, desired.customSource)).configApplied) report.configApplied = true;
 				report.installed.push(id);
 				report.activated.push(id);
@@ -5327,6 +5432,7 @@ var ReconciliationEngine = class {
 				});
 				return;
 			}
+			this.activateAttempts.delete(id);
 			report.results.push({
 				integrationId: id,
 				action: "up_to_date",
@@ -21529,6 +21635,10 @@ var RuntimeProcess = class {
 					"--allow-unconfigured"
 				]
 			};
+			case "hermes": return {
+				command: "hermes",
+				args: ["gateway", "run"]
+			};
 			default: throw new Error(`Unsupported runtime: ${this.options.runtime}`);
 		}
 	}
@@ -22107,6 +22217,12 @@ let startedAt;
 let integrationManager;
 let mcpBundler = null;
 let mcpManagerRef = null;
+/**
+* Hermes-only MCP store consumer (Approach B). Mirrors the runtime-agnostic MCP
+* store into ~/.hermes/config.yaml. Null for openclaw agents (never constructed)
+* and for managed/self-hosted runtimes other than hermes.
+*/
+let hermesMcpSync = null;
 let aiProxyServer = null;
 let runtimeProcess = null;
 let aiProxyUrl = null;
@@ -22119,6 +22235,12 @@ let resolvedRuntimeVersion;
 let upgradingRuntime = false;
 let stopPairingApprovalPoller = null;
 /**
+* Module-level handle on the runtime appliers built during start(), so the
+* module-scoped command handler can route `alfe.config_set` to the active
+* runtime's applier (mirrors `mcpManagerRef`). Null until start() builds it.
+*/
+let runtimeAppliersRef = null;
+/**
 * Resolve the installed @alfe.ai/cli version.
 *
 * Strategy (in order):
@@ -22193,15 +22315,44 @@ async function getCliVersion() {
 	logger$1.debug("Could not resolve @alfe.ai/cli version");
 }
 /**
-* Resolve the installed runtime (OpenClaw) version.
-* Runs `openclaw --version` and returns the trimmed output.
+* Per-runtime "print installed version" commands. Local to the gateway — we do
+* NOT import the CLI's `detectRuntime` (`@alfe.ai/gateway` must not depend on
+* `@alfe.ai/cli`). Unknown runtimes resolve to `undefined` (never throw) so the
+* connection-status report degrades gracefully instead of crashing.
+*/
+const RUNTIME_VERSION_COMMANDS = {
+	openclaw: {
+		command: "openclaw",
+		args: ["--version"]
+	},
+	hermes: {
+		command: "hermes",
+		args: ["version"]
+	}
+};
+/**
+* Pure resolver (exported for tests) — the per-runtime version command, or
+* `undefined` for an unknown runtime.
+*/
+function resolveRuntimeVersionCommand(runtime) {
+	return RUNTIME_VERSION_COMMANDS[runtime];
+}
+/**
+* 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.
 */
-async function getRuntimeVersion() {
+async function getRuntimeVersion(runtime) {
+	const cmd = resolveRuntimeVersionCommand(runtime);
+	if (!cmd) {
+		logger$1.debug({ runtime }, "No version command for runtime — skipping version detection");
+		return;
+	}
 	try {
-		const { stdout } = await execFileAsync("openclaw", ["--version"]);
+		const { stdout } = await execFileAsync(cmd.command, cmd.args);
 		return stdout.trim() || void 0;
 	} catch {
-		logger$1.debug("Could not resolve openclaw runtime version");
+		logger$1.debug({ runtime }, "Could not resolve runtime version");
 		return;
 	}
 }
@@ -22349,7 +22500,7 @@ async function startDaemon() {
 		await flushAndExit(1);
 	}
 	resolvedCliVersion = await getCliVersion();
-	resolvedRuntimeVersion = await getRuntimeVersion();
+	resolvedRuntimeVersion = await getRuntimeVersion(config.runtime);
 	logger$1.info({
 		cliVersion: resolvedCliVersion,
 		runtimeVersion: resolvedRuntimeVersion
@@ -22382,7 +22533,14 @@ async function startDaemon() {
 			home: runtimeCfg.workspace,
 			agentWorkspace: runtimeCfg.agentWorkspace
 		}, "Registered OpenClaw runtime applier");
+	} else if (name === "hermes") {
+		runtimeAppliers.set(name, new HermesApplier({ home: runtimeCfg.workspace }));
+		logger$1.info({
+			runtime: name,
+			home: runtimeCfg.workspace
+		}, "Registered Hermes runtime applier");
 	} else logger$1.warn({ runtime: name }, "Unknown runtime type — skipping");
+	runtimeAppliersRef = runtimeAppliers;
 	const integrationsService = new IntegrationsService(new AlfeApiClient({
 		apiBaseUrl: config.apiEndpoint,
 		getToken: () => Promise.resolve(config.apiKey)
@@ -22397,22 +22555,25 @@ async function startDaemon() {
 		logger: logger$1,
 		idleTtlMs: 0
 	}, { connect: defaultConnect });
-	await mcpManager.loadIntoBundler(mcpBundler);
-	const warmBundler = (reason) => {
-		if (!mcpBundler) return;
-		mcpBundler.warmup().catch((err) => {
-			logger$1.warn({
-				err: err instanceof Error ? err.message : String(err),
-				reason
-			}, "MCP bundler warmup failed");
+	if (config.runtime === "hermes") logger$1.info("Hermes runtime — daemon MCP bundler left idle (store mirrored to config.yaml by HermesMcpSync)");
+	else {
+		await mcpManager.loadIntoBundler(mcpBundler);
+		const warmBundler = (reason) => {
+			if (!mcpBundler) return;
+			mcpBundler.warmup().catch((err) => {
+				logger$1.warn({
+					err: err instanceof Error ? err.message : String(err),
+					reason
+				}, "MCP bundler warmup failed");
+			});
+		};
+		warmBundler("startup");
+		mcpManager.onChange(() => {
+			warmBundler("store change");
 		});
-	};
-	warmBundler("startup");
-	mcpManager.onChange(() => {
-		warmBundler("store change");
-	});
-	logger$1.info("MCP bundler attached to manager — warming children");
-	await runOpenclawMcpCleanup({
+		logger$1.info("MCP bundler attached to manager — warming children");
+	}
+	if (config.runtime === "openclaw") await runOpenclawMcpCleanup({
 		manager: mcpManager,
 		logger: logger$1
 	}).catch((err) => {
@@ -22433,14 +22594,27 @@ async function startDaemon() {
 	});
 	const integrationAdapter = new IntegrationManagerAdapter(integrationManager);
 	cloudClient.setIntegrationManager(integrationAdapter);
-	cloudClient.setRuntimeRestartNeededHandler(() => {
+	const requestRuntimeRestart = () => {
 		if (runtimeProcess) {
 			logger$1.info("Runtime state changed — restarting runtime");
 			runtimeProcess.restart().catch((err) => {
 				logger$1.error({ err: err instanceof Error ? err.message : String(err) }, "Failed to restart runtime");
 			});
 		}
-	});
+	};
+	cloudClient.setRuntimeRestartNeededHandler(requestRuntimeRestart);
+	if (config.runtime === "hermes") {
+		const hermesCfg = config.runtimes[config.runtime];
+		if (hermesCfg) {
+			hermesMcpSync = new HermesMcpSync({
+				manager: mcpManager,
+				home: hermesCfg.workspace,
+				apiKey: config.apiKey,
+				requestRestart: requestRuntimeRestart
+			});
+			hermesMcpSync.start();
+		}
+	}
 	cloudClient.setOnReconciliationComplete(() => {
 		try {
 			const activeCommands = integrationManager.getActiveCommands();
@@ -22495,6 +22669,10 @@ async function startDaemon() {
 			await runtimeProcess.stop();
 			logger$1.debug("Runtime process stopped");
 		}
+		if (hermesMcpSync) {
+			hermesMcpSync.stop();
+			hermesMcpSync = null;
+		}
 		if (mcpBundler) {
 			logger$1.debug("Stopping MCP bundler...");
 			await mcpBundler.dispose();
@@ -22583,17 +22761,28 @@ async function handleCloudCommand(command) {
 				message: "Runtime upgrade already in progress"
 			}
 		};
-		const version = command.payload?.version ?? "2026.6.8";
+		const payload = command.payload;
+		const runtime = config.runtime;
+		const version = payload?.version ?? (runtime === "openclaw" ? "2026.6.8" : void 0);
 		upgradingRuntime = true;
 		setTimeout(() => {
 			(async () => {
 				try {
 					const { upgradeRuntime } = await import("./runtime-upgrade.js");
-					if ((await upgradeRuntime(version, runtimeProcess)).success) {
-						resolvedRuntimeVersion = await getRuntimeVersion();
-						if (!resolvedRuntimeVersion) logger$1.warn({ requestedVersion: version }, "Could not detect runtime version after upgrade — using requested version");
-						logger$1.info({ runtimeVersion: resolvedRuntimeVersion ?? version }, "Runtime version updated after upgrade");
-						cloudClient.updateRuntimeVersionAndReRegister(resolvedRuntimeVersion ?? version);
+					if ((await upgradeRuntime(runtime, version, runtimeProcess)).success) {
+						resolvedRuntimeVersion = await getRuntimeVersion(runtime);
+						const reportedVersion = resolvedRuntimeVersion ?? version;
+						if (!resolvedRuntimeVersion) logger$1.warn({
+							runtime,
+							requestedVersion: version
+						}, "Could not detect runtime version after upgrade");
+						if (reportedVersion) {
+							logger$1.info({
+								runtime,
+								runtimeVersion: reportedVersion
+							}, "Runtime version updated after upgrade");
+							cloudClient.updateRuntimeVersionAndReRegister(reportedVersion);
+						} else logger$1.warn({ runtime }, "No runtime version to report after upgrade — skipping re-register");
 					}
 				} catch (err) {
 					logger$1.error({ err: err instanceof Error ? err.message : String(err) }, "Runtime upgrade failed");
@@ -22608,6 +22797,7 @@ async function handleCloudCommand(command) {
 			status: "ok",
 			result: {
 				upgrading: true,
+				runtime,
 				version
 			}
 		};
@@ -22688,17 +22878,30 @@ async function handleCloudCommand(command) {
 				message: "alfe.config_set requires key and value"
 			}
 		};
+		const runtime = config.runtime;
+		const applier = runtimeAppliersRef?.get(runtime);
+		if (!applier || typeof applier.setConfigRaw !== "function") {
+			const message = `No runtime applier supports config_set for runtime "${runtime}"`;
+			logger$1.warn({
+				runtime,
+				key
+			}, message);
+			return {
+				type: "COMMAND_ACK",
+				commandId: command.commandId,
+				status: "error",
+				result: {
+					code: "CONFIG_SET_UNSUPPORTED",
+					message
+				}
+			};
+		}
 		try {
-			await execFileAsync("openclaw", [
-				"config",
-				"set",
-				key,
-				value
-			], { timeout: 1e4 });
+			await applier.setConfigRaw(key, value);
 			logger$1.info({
-				key,
-				value
-			}, "Applied config via openclaw config set");
+				runtime,
+				key
+			}, "Applied config via runtime applier setConfigRaw");
 			return {
 				type: "COMMAND_ACK",
 				commandId: command.commandId,
@@ -22712,9 +22915,9 @@ async function handleCloudCommand(command) {
 			const message = err instanceof Error ? err.message : String(err);
 			logger$1.error({
 				err: message,
-				key,
-				value
-			}, "Failed to apply config via openclaw");
+				runtime,
+				key
+			}, "Failed to apply config via runtime applier");
 			return {
 				type: "COMMAND_ACK",
 				commandId: command.commandId,

package/dist/runtime-upgrade.js

@@ -3,40 +3,87 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 //#region src/runtime-upgrade.ts
 /**
-* Runtime upgrade — npm install then cycle the RuntimeProcess.
+* Runtime upgrade — install/update the runtime binary then cycle the RuntimeProcess.
 *
 * Unlike CLI upgrade (which exits the daemon for systemd restart),
 * runtime upgrade keeps the daemon running and just restarts the child process.
 *
-* Flow:
+* Flow (generic across runtimes):
 *   1. Stop the RuntimeProcess child (SIGTERM + grace period)
-*   2. npm install -g openclaw@{version}
+*   2. Run the per-runtime upgrade command (see `resolveUpgradeCommand`)
 *   3. Restart the RuntimeProcess child
 *
-* On npm failure, the runtime is restarted on the old version.
+* On install failure, the runtime is restarted on the old version.
 */
 const execFileAsync = promisify(execFile);
-async function upgradeRuntime(version, runtimeProcess) {
-	logger.info({ version }, "Upgrading OpenClaw runtime...");
+/**
+* Resolve the per-runtime upgrade command.
+*
+* - `openclaw`: `npm install -g openclaw@<version>` — version-pinned (unchanged).
+* - `hermes`:   `hermes update --yes` — Hermes self-updates from its own channel.
+*               A pinned version does not map to a Hermes CLI flag, so the
+*               `version` arg is intentionally ignored on this branch.
+*
+* Returns `undefined` for an unknown runtime (or openclaw with no version),
+* which the caller treats as a failed upgrade (restart on the old version).
+*/
+function resolveUpgradeCommand(runtime, version) {
+	switch (runtime) {
+		case "openclaw":
+			if (!version) return void 0;
+			return {
+				command: "npm",
+				args: [
+					"install",
+					"-g",
+					`openclaw@${version}`
+				]
+			};
+		case "hermes": return {
+			command: "hermes",
+			args: ["update", "--yes"]
+		};
+		default: return;
+	}
+}
+async function upgradeRuntime(runtime, version, runtimeProcess) {
+	const cmd = resolveUpgradeCommand(runtime, version);
+	if (!cmd) {
+		const message = `No upgrade command for runtime '${runtime}'`;
+		logger.error({
+			runtime,
+			version
+		}, message);
+		return {
+			success: false,
+			runtime,
+			version,
+			error: message
+		};
+	}
+	logger.info({
+		runtime,
+		version
+	}, "Upgrading runtime...");
 	if (runtimeProcess) {
 		logger.info("Stopping runtime for upgrade...");
 		await runtimeProcess.stop();
 	}
 	try {
-		const { stdout, stderr } = await execFileAsync("npm", [
-			"install",
-			"-g",
-			`openclaw@${version}`
-		], { timeout: 12e4 });
-		if (stdout) logger.debug({ stdout: stdout.trim() }, "npm install stdout");
-		if (stderr) logger.debug({ stderr: stderr.trim() }, "npm install stderr");
-		logger.info({ version }, "OpenClaw runtime upgraded successfully");
+		const { stdout, stderr } = await execFileAsync(cmd.command, cmd.args, { timeout: 12e4 });
+		if (stdout) logger.debug({ stdout: stdout.trim() }, "runtime upgrade stdout");
+		if (stderr) logger.debug({ stderr: stderr.trim() }, "runtime upgrade stderr");
+		logger.info({
+			runtime,
+			version
+		}, "Runtime upgraded successfully");
 	} catch (err) {
 		const message = err instanceof Error ? err.message : String(err);
 		logger.error({
 			err: message,
+			runtime,
 			version
-		}, "Runtime upgrade npm install failed");
+		}, "Runtime upgrade install command failed");
 		if (runtimeProcess) try {
 			logger.info("Restarting runtime on previous version after failed upgrade...");
 			await runtimeProcess.restart();
@@ -46,6 +93,7 @@ async function upgradeRuntime(version, runtimeProcess) {
 		}
 		return {
 			success: false,
+			runtime,
 			version,
 			error: message
 		};
@@ -56,6 +104,7 @@ async function upgradeRuntime(version, runtimeProcess) {
 	}
 	return {
 		success: true,
+		runtime,
 		version
 	};
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/gateway",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "Alfe local gateway daemon — persistent control plane for agent integrations",
   "type": "module",
   "bin": {
@@ -22,11 +22,11 @@
     "pino-roll": "^1.2.0",
     "smol-toml": ">=1.6.1",
     "ws": "^8.18.0",
-    "@alfe.ai/agent-api-client": "^0.2.2",
-    "@alfe.ai/ai-proxy-local": "^0.0.10",
-    "@alfe.ai/config": "^0.0.9",
-    "@alfe.ai/integration-manifest": "^0.2.1",
-    "@alfe.ai/integrations": "^0.1.5",
+    "@alfe.ai/agent-api-client": "^0.3.0",
+    "@alfe.ai/ai-proxy-local": "^0.0.11",
+    "@alfe.ai/config": "^0.1.0",
+    "@alfe.ai/integration-manifest": "^0.3.0",
+    "@alfe.ai/integrations": "^0.2.0",
     "@alfe.ai/mcp-bundler": "^0.2.1"
   },
   "license": "UNLICENSED",