@alfe.ai/gateway 0.1.5 → 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";
@@ -4480,7 +4480,8 @@ enumValues({
 });
 enumValues({
 	OpenClaw: "openclaw",
-	NanoClaw: "nanoclaw"
+	NanoClaw: "nanoclaw",
+	Hermes: "hermes"
 });
 enumValues({
 	Org: "org",
@@ -4965,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.
@@ -4994,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,
@@ -5002,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
 	};
@@ -21617,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}`);
 		}
 	}
@@ -22195,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;
@@ -22207,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):
@@ -22281,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;
 	}
 }
@@ -22437,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
@@ -22470,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)
@@ -22485,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) => {
@@ -22521,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();
@@ -22583,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();
@@ -22671,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");
@@ -22696,6 +22797,7 @@ async function handleCloudCommand(command) {
 			status: "ok",
 			result: {
 				upgrading: true,
+				runtime,
 				version
 			}
 		};
@@ -22776,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,
@@ -22800,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.5",
+  "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.3",
-    "@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.6",
+    "@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",