@alfe.ai/gateway 0.8.2 → 0.9.0

package/dist/bin/gateway.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as installService, c as uninstallService, f as SOCKET_PATH, i as checkExistingDaemon, n as queryDaemonHealth, r as startDaemon, s as stopExistingDaemon, t as formatHealthReport } from "../health.js";
+import { a as installService, d as uninstallService, h as SOCKET_PATH, i as checkExistingDaemon, l as stopExistingDaemon, n as queryDaemonHealth, r as startDaemon, t as formatHealthReport } from "../health.js";
 import { t as LOG_FILE } from "../logger.js";
 import { spawn } from "node:child_process";
 //#region bin/gateway.ts

package/dist/health.js

@@ -76,6 +76,26 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 */
 const PINNED_OPENCLAW_VERSION = "2026.6.11";
 //#endregion
+//#region src/claude-code-host-version.ts
+/**
+* The `@alfe.ai/claude-code-host` version Alfe pins the claude-code runtime to —
+* the single source of truth for its install paths:
+*   - `@alfe.ai/cli` `installClaudeCodeHost` (fresh `alfe setup`)
+*   - the daemon `runtime.update` default (this package)
+*
+* Pinning (rather than floating `npm install -g @alfe.ai/claude-code-host` →
+* `latest`) is deliberate: the host is the claude-code runtime child on every
+* self-hosted claude-code agent, so a bad `latest` publish would auto-reach
+* every new `alfe setup` with no CLI gate. Bump deliberately after validating a
+* new host, then cut a CLI release so the pin travels with the CLI version. The
+* dashboard still surfaces npm-`latest` as an explicit opt-in upgrade.
+*
+* NOTE: claude-code is self-hosted-only (no managed Docker image), so — unlike
+* `PINNED_OPENCLAW_VERSION` — there is no `services/compute/Dockerfile` mirror to
+* keep in sync.
+*/
+const PINNED_CLAUDE_CODE_HOST_VERSION = "0.1.2";
+//#endregion
 //#region ../../packages-internal/ids/dist/prefixes.js
 const ID_PREFIXES = {
 	agent: "agt",
@@ -7073,12 +7093,25 @@ async function uninstallSystemd() {
 	return `Uninstalled: ${unitPath}`;
 }
 /**
-* Start the installed service via systemctl/launchctl.
+* Bootstrap (load) the launchd service from its plist if it isn't already
+* loaded. Already-loaded is an error we ignore. Needed so `start`/`restart`
+* work after `stopService()` boots the service OUT.
+*/
+function ensureLaunchdLoaded(uid) {
+	try {
+		execSync(`launchctl bootstrap gui/${uid} ${getLaunchdPlistPath()}`, { stdio: "pipe" });
+	} catch {}
+}
+/**
+* Start the installed service via systemctl/launchctl. Bootstraps the launchd
+* service first so this also works after `stopService()` booted it out.
 */
 function startService() {
 	const platform = process.platform;
 	if (platform === "darwin") {
-		execSync(`launchctl kickstart -k gui/${getLaunchdUid()}/${LAUNCHD_LABEL}`, { stdio: "pipe" });
+		const uid = getLaunchdUid();
+		ensureLaunchdLoaded(uid);
+		execSync(`launchctl kickstart -k gui/${uid}/${LAUNCHD_LABEL}`, { stdio: "pipe" });
 		logger$1.info("Started launchd service");
 		return;
 	}
@@ -7090,6 +7123,59 @@ function startService() {
 	throw new Error(`Unsupported platform: ${platform}`);
 }
 /**
+* Restart the installed service via systemctl/launchctl. This is the
+* service-manager-native restart (`kickstart -k` / `systemctl restart`) — the
+* CLI uses it instead of killing the process inline, which would fight launchd
+* `KeepAlive` / systemd `Restart=always`.
+*/
+function restartService() {
+	const platform = process.platform;
+	if (platform === "darwin") {
+		const uid = getLaunchdUid();
+		ensureLaunchdLoaded(uid);
+		execSync(`launchctl kickstart -k gui/${uid}/${LAUNCHD_LABEL}`, { stdio: "pipe" });
+		logger$1.info("Restarted launchd service");
+		return;
+	}
+	if (platform === "linux") {
+		execSync(`${isRootUser() ? "systemctl" : "systemctl --user"} restart ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
+		logger$1.info("Restarted systemd service");
+		return;
+	}
+	throw new Error(`Unsupported platform: ${platform}`);
+}
+/**
+* Stop the installed service via systemctl/launchctl. On macOS this boots the
+* service OUT (unloads it) so launchd's `KeepAlive` does NOT respawn it;
+* `startService()` bootstraps it again. On Linux the unit stays enabled (starts
+* on next boot); `systemctl stop` just halts the current run.
+*/
+function stopService() {
+	const platform = process.platform;
+	if (platform === "darwin") {
+		execSync(`launchctl bootout gui/${getLaunchdUid()}/${LAUNCHD_LABEL}`, { stdio: "pipe" });
+		logger$1.info("Stopped launchd service");
+		return;
+	}
+	if (platform === "linux") {
+		execSync(`${isRootUser() ? "systemctl" : "systemctl --user"} stop ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
+		logger$1.info("Stopped systemd service");
+		return;
+	}
+	throw new Error(`Unsupported platform: ${platform}`);
+}
+/**
+* True when the gateway is installed as a system service (launchd plist /
+* systemd unit present). Lets the CLI restart/stop/start THROUGH the service
+* manager instead of driving the daemon inline via the PID file.
+*/
+function isServiceInstalled() {
+	const platform = process.platform;
+	if (platform === "darwin") return existsSync(getLaunchdPlistPath());
+	if (platform === "linux") return existsSync(isRootUser() ? getSystemdSystemServicePath() : getSystemdServicePath());
+	return false;
+}
+/**
 * Write the current process PID to the PID file.
 */
 async function writePidFile() {
@@ -23814,7 +23900,10 @@ async function startDaemon() {
 		await mcpManager.loadIntoBundler(mcpBundler);
 		const warmBundler = (reason) => {
 			if (!mcpBundler) return;
-			mcpBundler.warmup().catch((err) => {
+			const target = mcpBundler;
+			target.warmup().then(() => {
+				warnFailedMcpServers(target, logger$1, reason);
+			}).catch((err) => {
 				logger$1.warn({
 					err: err instanceof Error ? err.message : String(err),
 					reason
@@ -24102,7 +24191,7 @@ async function executeCloudCommand(command) {
 		};
 		const payload = command.payload;
 		const runtime = config.runtime;
-		const version = payload?.version ?? (runtime === "openclaw" ? "2026.6.11" : void 0);
+		const version = payload?.version ?? (runtime === "openclaw" ? "2026.6.11" : runtime === "claude-code" ? "0.1.2" : void 0);
 		upgradingRuntime = true;
 		setTimeout(() => {
 			(async () => {
@@ -24442,6 +24531,28 @@ function handleMcpListTools(bundler) {
 	};
 }
 /**
+* Observability backstop for the INTEGRATION warm path. `applyForIntegration`
+* registers MCP servers into the store and the daemon warms them silently via
+* the store-change `onChange` hook — so a server that fails its connect (e.g.
+* an MCP server whose backing account/credential wasn't resolvable at warm
+* time, like ctrader-mcp `exit(1)`-ing on empty accounts) leaves NO trace,
+* making the black hole undiagnosable. After a warm, read `bundler.statuses()`
+* and warn once per still-failed server so the failure is visible. These
+* self-heal on the bundler's background retry sweep once the dependency
+* appears. Returns the servers it warned about (for tests / callers).
+*/
+function warnFailedMcpServers(bundler, log, reason) {
+	if (!bundler) return [];
+	const failed = bundler.statuses().filter((s) => !s.connected && s.lastError !== void 0);
+	for (const status of failed) log.warn({
+		server: status.name,
+		reason,
+		consecutiveFailures: status.consecutiveFailures,
+		lastError: status.lastError
+	}, `MCP server "${status.name}" failed to connect: ${status.lastError ?? ""}`);
+	return failed;
+}
+/**
 * Route a tool call to the appropriate MCP child via the daemon-hosted
 * bundler. `name` is the prefixed (`mcp__<server>__<tool>`) name; args is
 * the raw JSON object the LLM produced.
@@ -24780,4 +24891,4 @@ function formatDuration(ms) {
 	return `${String(Math.round(seconds / 3600))}h`;
 }
 //#endregion
-export { installService as a, uninstallService as c, PID_PATH as d, SOCKET_PATH as f, PINNED_OPENCLAW_VERSION as g, resolveAgentIdentity as h, checkExistingDaemon as i, PROTOCOL_VERSION as l, loadDaemonConfig as m, queryDaemonHealth as n, startService as o, fetchAgentConfig as p, startDaemon as r, stopExistingDaemon as s, formatHealthReport as t, ALFE_DIR as u };
+export { loadDaemonConfig as _, installService as a, PINNED_OPENCLAW_VERSION as b, startService as c, uninstallService as d, PROTOCOL_VERSION as f, fetchAgentConfig as g, SOCKET_PATH as h, checkExistingDaemon as i, stopExistingDaemon as l, PID_PATH as m, queryDaemonHealth as n, isServiceInstalled as o, ALFE_DIR as p, startDaemon as r, restartService as s, formatHealthReport as t, stopService as u, resolveAgentIdentity as v, PINNED_CLAUDE_CODE_HOST_VERSION as y };

package/dist/runtime-upgrade.js

@@ -19,13 +19,19 @@ const execFileAsync = promisify(execFile);
 /**
 * 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.
+* - `openclaw`:    `npm install -g openclaw@<version>` — version-pinned.
+* - `claude-code`: `npm install -g @alfe.ai/claude-code-host@<version>` — the
+*                  runtime child is the host binary; mirrors openclaw. The
+*                  caller defaults a missing version to the pin.
+* - `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).
+* Returns `undefined` for an unknown runtime (or openclaw/claude-code with no
+* version), which the caller treats as a failed upgrade (restart on the old
+* version). `upgradeRuntime` restarts the RuntimeProcess child regardless of
+* runtime, so a new branch here is all that's needed to cycle onto the new
+* version.
 */
 function resolveUpgradeCommand(runtime, version) {
 	switch (runtime) {
@@ -39,6 +45,16 @@ function resolveUpgradeCommand(runtime, version) {
 					`openclaw@${version}`
 				]
 			};
+		case "claude-code":
+			if (!version) return void 0;
+			return {
+				command: "npm",
+				args: [
+					"install",
+					"-g",
+					`@alfe.ai/claude-code-host@${version}`
+				]
+			};
 		case "hermes": return {
 			command: "hermes",
 			args: ["update", "--yes"]

package/dist/src/index.d.ts

@@ -1,5 +1,9 @@
 import pino from "pino";
 
+//#region src/logger.d.ts
+
+declare const logger: pino.Logger<never, boolean>;
+//#endregion
 //#region src/protocol.d.ts
 
 interface IPCRequest {
@@ -55,6 +59,26 @@ declare function startDaemon(): Promise<void>;
  */
 declare const PINNED_OPENCLAW_VERSION = "2026.6.11";
 //#endregion
+//#region src/claude-code-host-version.d.ts
+/**
+ * The `@alfe.ai/claude-code-host` version Alfe pins the claude-code runtime to —
+ * the single source of truth for its install paths:
+ *   - `@alfe.ai/cli` `installClaudeCodeHost` (fresh `alfe setup`)
+ *   - the daemon `runtime.update` default (this package)
+ *
+ * Pinning (rather than floating `npm install -g @alfe.ai/claude-code-host` →
+ * `latest`) is deliberate: the host is the claude-code runtime child on every
+ * self-hosted claude-code agent, so a bad `latest` publish would auto-reach
+ * every new `alfe setup` with no CLI gate. Bump deliberately after validating a
+ * new host, then cut a CLI release so the pin travels with the CLI version. The
+ * dashboard still surfaces npm-`latest` as an explicit opt-in upgrade.
+ *
+ * NOTE: claude-code is self-hosted-only (no managed Docker image), so — unlike
+ * `PINNED_OPENCLAW_VERSION` — there is no `services/compute/Dockerfile` mirror to
+ * keep in sync.
+ */
+declare const PINNED_CLAUDE_CODE_HOST_VERSION = "0.1.2";
+//#endregion
 //#region src/sentry.d.ts
 /**
  * Agent-side error reporting (Sentry) for the Alfe CLI + gateway daemon.
@@ -335,9 +359,6 @@ declare function queryDaemonHealth(socketPath: string, timeoutMs?: number): Prom
  */
 declare function formatHealthReport(health: DaemonHealth): string;
 //#endregion
-//#region src/logger.d.ts
-declare const logger: pino.Logger<never, boolean>;
-//#endregion
 //#region src/process-manager.d.ts
 /**
  * Install the service unit for the current platform.
@@ -348,9 +369,30 @@ declare function installService(): Promise<string>;
  */
 declare function uninstallService(): Promise<string>;
 /**
- * Start the installed service via systemctl/launchctl.
+ * Start the installed service via systemctl/launchctl. Bootstraps the launchd
+ * service first so this also works after `stopService()` booted it out.
  */
 declare function startService(): void;
+/**
+ * Restart the installed service via systemctl/launchctl. This is the
+ * service-manager-native restart (`kickstart -k` / `systemctl restart`) — the
+ * CLI uses it instead of killing the process inline, which would fight launchd
+ * `KeepAlive` / systemd `Restart=always`.
+ */
+declare function restartService(): void;
+/**
+ * Stop the installed service via systemctl/launchctl. On macOS this boots the
+ * service OUT (unloads it) so launchd's `KeepAlive` does NOT respawn it;
+ * `startService()` bootstraps it again. On Linux the unit stays enabled (starts
+ * on next boot); `systemctl stop` just halts the current run.
+ */
+declare function stopService(): void;
+/**
+ * True when the gateway is installed as a system service (launchd plist /
+ * systemd unit present). Lets the CLI restart/stop/start THROUGH the service
+ * manager instead of driving the daemon inline via the PID file.
+ */
+declare function isServiceInstalled(): boolean;
 /**
  * Write the current process PID to the PID file.
  */
@@ -365,4 +407,4 @@ declare function checkExistingDaemon(): Promise<number | null>;
  */
 declare function stopExistingDaemon(): Promise<boolean>;
 //#endregion
-export { AGENT_DAEMON_SENTRY_DSN, AGENT_MCP_SENTRY_DSN, AGENT_RUNTIME_SENTRY_DSN, ALFE_DIR, type AgentIdentity, type AgentWorkspaceConfig, type DaemonConfig, type DaemonHealth, type IPCEvent, type IPCRequest, type IPCResponse, type InitAgentSentryOptions, PID_PATH, PINNED_OPENCLAW_VERSION, PROTOCOL_VERSION, type RuntimeOutputLine, SOCKET_PATH, type SentrySurface, captureCliFailure, captureFatal, captureIntegrationFailure, captureMcpFailure, captureRuntimeCrash, captureRuntimeErrorOutput, checkExistingDaemon, fetchAgentConfig, flushSentry, formatHealthReport, initAgentSentry, installService, loadDaemonConfig, logger, queryDaemonHealth, resolveAgentIdentity, setAgentContext, startDaemon, startService, stopExistingDaemon, uninstallService };
+export { AGENT_DAEMON_SENTRY_DSN, AGENT_MCP_SENTRY_DSN, AGENT_RUNTIME_SENTRY_DSN, ALFE_DIR, type AgentIdentity, type AgentWorkspaceConfig, type DaemonConfig, type DaemonHealth, type IPCEvent, type IPCRequest, type IPCResponse, type InitAgentSentryOptions, PID_PATH, PINNED_CLAUDE_CODE_HOST_VERSION, PINNED_OPENCLAW_VERSION, PROTOCOL_VERSION, type RuntimeOutputLine, SOCKET_PATH, type SentrySurface, captureCliFailure, captureFatal, captureIntegrationFailure, captureMcpFailure, captureRuntimeCrash, captureRuntimeErrorOutput, checkExistingDaemon, fetchAgentConfig, flushSentry, formatHealthReport, initAgentSentry, installService, isServiceInstalled, loadDaemonConfig, logger, queryDaemonHealth, resolveAgentIdentity, restartService, setAgentContext, startDaemon, startService, stopExistingDaemon, stopService, uninstallService };

package/dist/src/index.js

@@ -1,4 +1,4 @@
-import { a as installService, c as uninstallService, d as PID_PATH, f as SOCKET_PATH, g as PINNED_OPENCLAW_VERSION, h as resolveAgentIdentity, i as checkExistingDaemon, l as PROTOCOL_VERSION, m as loadDaemonConfig, n as queryDaemonHealth, o as startService, p as fetchAgentConfig, r as startDaemon, s as stopExistingDaemon, t as formatHealthReport, u as ALFE_DIR } from "../health.js";
+import { _ as loadDaemonConfig, a as installService, b as PINNED_OPENCLAW_VERSION, 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 { n as logger } from "../logger.js";
 import { a as captureFatal, c as captureRuntimeCrash, d as initAgentSentry, f as setAgentContext, i as captureCliFailure, l as captureRuntimeErrorOutput, n as AGENT_MCP_SENTRY_DSN, o as captureIntegrationFailure, r as AGENT_RUNTIME_SENTRY_DSN, s as captureMcpFailure, t as AGENT_DAEMON_SENTRY_DSN, u as flushSentry } from "../sentry.js";
-export { AGENT_DAEMON_SENTRY_DSN, AGENT_MCP_SENTRY_DSN, AGENT_RUNTIME_SENTRY_DSN, ALFE_DIR, PID_PATH, PINNED_OPENCLAW_VERSION, PROTOCOL_VERSION, SOCKET_PATH, captureCliFailure, captureFatal, captureIntegrationFailure, captureMcpFailure, captureRuntimeCrash, captureRuntimeErrorOutput, checkExistingDaemon, fetchAgentConfig, flushSentry, formatHealthReport, initAgentSentry, installService, loadDaemonConfig, logger, queryDaemonHealth, resolveAgentIdentity, setAgentContext, startDaemon, startService, stopExistingDaemon, uninstallService };
+export { AGENT_DAEMON_SENTRY_DSN, AGENT_MCP_SENTRY_DSN, AGENT_RUNTIME_SENTRY_DSN, ALFE_DIR, PID_PATH, PINNED_CLAUDE_CODE_HOST_VERSION, PINNED_OPENCLAW_VERSION, PROTOCOL_VERSION, SOCKET_PATH, captureCliFailure, captureFatal, captureIntegrationFailure, captureMcpFailure, captureRuntimeCrash, captureRuntimeErrorOutput, checkExistingDaemon, fetchAgentConfig, flushSentry, formatHealthReport, initAgentSentry, installService, isServiceInstalled, loadDaemonConfig, logger, queryDaemonHealth, resolveAgentIdentity, restartService, setAgentContext, startDaemon, startService, stopExistingDaemon, stopService, uninstallService };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/gateway",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "description": "Alfe local gateway daemon — persistent control plane for agent integrations",
   "type": "module",
   "bin": {
@@ -25,10 +25,10 @@
     "ws": "^8.18.0",
     "@alfe.ai/agent-api-client": "^0.11.0",
     "@alfe.ai/ai-proxy-local": "^0.0.13",
-    "@alfe.ai/integration-manifest": "^0.3.2",
     "@alfe.ai/config": "^0.3.0",
-    "@alfe.ai/integrations": "^0.5.1",
-    "@alfe.ai/mcp-bundler": "^0.3.1"
+    "@alfe.ai/integration-manifest": "^0.3.2",
+    "@alfe.ai/integrations": "^0.5.2",
+    "@alfe.ai/mcp-bundler": "^0.3.2"
   },
   "license": "UNLICENSED",
   "homepage": "https://alfe.ai",