@alfe.ai/gateway 0.0.4 → 0.0.6

package/dist/bin/gateway.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as installService, d as SOCKET_PATH, h as LOG_FILE, i as checkExistingDaemon, n as queryDaemonHealth, o as stopExistingDaemon, r as startDaemon, s as uninstallService, t as formatHealthReport } from "../health.js";
+import { a as installService, c as uninstallService, f as SOCKET_PATH, g as LOG_FILE, i as checkExistingDaemon, n as queryDaemonHealth, r as startDaemon, s as stopExistingDaemon, t as formatHealthReport } from "../health.js";
 import { spawn } from "node:child_process";
 //#region bin/gateway.ts
 /**
@@ -118,7 +118,9 @@ Examples:
 }
 main().catch((err) => {
 	const message = err instanceof Error ? err.message : String(err);
+	const stack = err instanceof Error ? err.stack : void 0;
 	console.error("Fatal error:", message);
+	if (stack) console.error(stack);
 	process.exit(1);
 });
 //#endregion

package/dist/health.js

@@ -11,6 +11,7 @@ import WebSocket from "ws";
 import { createConnection, createServer } from "node:net";
 import { execSync, spawn } from "node:child_process";
 import { IntegrationManager, IntegrationManagerAdapter, OpenClawApplier } from "@alfe.ai/integrations";
+import { randomUUID } from "node:crypto";
 import stream, { Readable } from "stream";
 import util, { format } from "util";
 import http from "http";
@@ -19,7 +20,6 @@ import url from "url";
 import http2 from "http2";
 import zlib from "zlib";
 import { EventEmitter } from "events";
-import { randomUUID } from "node:crypto";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -58,22 +58,25 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 * Daemon logger — pino with rolling file output.
 *
 * Writes to ~/.alfe/logs/gateway.log with 10MB rotation, keep 5 files.
-* Also outputs to stdout in development mode.
+* In managed mode (ECS Fargate): always stdout for CloudWatch capture.
+* In development: stdout.
 */
 const LOG_DIR = join(homedir(), ".alfe", "logs");
 const LOG_FILE = join(LOG_DIR, "gateway.log");
-try {
+const isDev = process.env.NODE_ENV !== "production";
+const isManaged = process.env.ALFE_MANAGED === "true";
+if (!isManaged) try {
 	mkdirSync(LOG_DIR, { recursive: true });
 } catch {}
-const isDev = process.env.NODE_ENV !== "production";
 /**
 * Create the daemon logger.
-* In development: pretty-prints to stdout.
-* In production: JSON to rolling file.
+* Managed mode (ECS): JSON to stdout (CloudWatch captures via awslogs driver).
+* Development: JSON to stdout.
+* Production (local): JSON to rolling file.
 */
 function createLogger$1() {
-	if (isDev) return pino({
-		level: process.env.LOG_LEVEL ?? "debug",
+	if (isDev || isManaged) return pino({
+		level: process.env.LOG_LEVEL ?? (isDev ? "debug" : "info"),
 		transport: {
 			target: "pino/file",
 			options: { destination: 1 }
@@ -101,6 +104,15 @@ const ID_PREFIXES = {
 	transaction: "txn",
 	subscription: "sub",
 	conversation: "conv",
+	referral: "ref",
+	promoCode: "prc",
+	promoRedemption: "prr",
+	pendingPromo: "pdp",
+	webhook: "whk",
+	webhookDelivery: "wdl",
+	onboardingSession: "obs",
+	inviteToken: "inv",
+	claimToken: "clm",
 	run: "run",
 	request: "req",
 	connection: "conn",
@@ -378,6 +390,21 @@ var AuthService = class {
 	deleteToken(tokenId) {
 		return this.client.request(`${this.prefix}/tokens/${tokenId}`, { method: "DELETE" });
 	}
+	getReferralCode() {
+		return this.client.request(`${this.prefix}/referral/code`);
+	}
+	redeemCode(code) {
+		return this.client.request(`${this.prefix}/referral/redeem`, {
+			method: "POST",
+			body: JSON.stringify({ code })
+		});
+	}
+	getReferralStatus() {
+		return this.client.request(`${this.prefix}/referral/status`);
+	}
+	getReferralHistory() {
+		return this.client.request(`${this.prefix}/referral/history`);
+	}
 };
 //#endregion
 //#region ../../packages-internal/types/dist/lib/enum-values.js
@@ -3066,7 +3093,8 @@ enumValues({
 });
 enumValues({
 	Anthropic: "anthropic",
-	OpenAI: "openai"
+	OpenAI: "openai",
+	ElevenLabs: "elevenlabs"
 });
 enumValues({
 	Month: "month",
@@ -3092,6 +3120,7 @@ enumValues({
 	Provisioning: "provisioning",
 	Running: "running",
 	Stopped: "stopped",
+	Failing: "failing",
 	Failed: "failed",
 	BillingSuspended: "billing_suspended"
 });
@@ -3118,6 +3147,8 @@ enumValues({
 	SubscriptionCredit: "subscription_credit",
 	AutoRecharge: "auto_recharge",
 	AdminGift: "admin_gift",
+	ReferralCredit: "referral_credit",
+	PromoCredit: "promo_credit",
 	Refund: "refund"
 });
 enumValues({
@@ -3131,6 +3162,36 @@ enumValues({
 	Week: "week",
 	Month: "month"
 });
+enumValues({
+	Active: "active",
+	Paused: "paused",
+	Revoked: "revoked"
+});
+enumValues({
+	Pending: "pending",
+	Completed: "completed",
+	Failed: "failed"
+});
+enumValues({
+	BalanceCredit: "balance_credit",
+	SubscriptionDiscount: "subscription_discount",
+	FreeTrial: "free_trial"
+});
+enumValues({
+	Active: "active",
+	Paused: "paused",
+	Revoked: "revoked"
+});
+enumValues({
+	Pending: "pending",
+	Completed: "completed",
+	Failed: "failed"
+});
+enumValues({
+	Pending: "pending",
+	Consumed: "consumed",
+	Expired: "expired"
+});
 enumValues({
 	Synced: "synced",
 	Stale: "stale",
@@ -3161,6 +3222,51 @@ enumValues({
 	Live: "live"
 });
 //#endregion
+//#region ../../packages-internal/types/dist/models.js
+const AnthropicModel = {
+	Opus: "claude-opus-4-6",
+	Sonnet: "claude-sonnet-4-6",
+	Haiku: "claude-haiku-4-5"
+};
+const ANTHROPIC_MODELS = enumValues(AnthropicModel);
+const OpenAIModel = {
+	GPT4o: "gpt-4o",
+	GPT4oMini: "gpt-4o-mini",
+	O3: "o3"
+};
+const OPENAI_MODELS = enumValues(OpenAIModel);
+[...ANTHROPIC_MODELS, ...OPENAI_MODELS];
+_enum(ANTHROPIC_MODELS);
+_enum(OPENAI_MODELS);
+_enum([...ANTHROPIC_MODELS, ...OPENAI_MODELS]);
+AnthropicModel.Opus, AnthropicModel.Sonnet, AnthropicModel.Haiku, OpenAIModel.GPT4o, OpenAIModel.GPT4oMini, OpenAIModel.O3;
+AnthropicModel.Opus, AnthropicModel.Sonnet, AnthropicModel.Haiku, OpenAIModel.GPT4o, OpenAIModel.GPT4oMini, OpenAIModel.O3;
+enumValues({
+	PendingChallenge: "pending_challenge",
+	Creating: "creating",
+	Complete: "complete",
+	Failed: "failed",
+	Expired: "expired"
+});
+enumValues({
+	Active: "active",
+	Used: "used",
+	Expired: "expired",
+	Revoked: "revoked"
+});
+enumValues({
+	Pending: "pending",
+	Claimed: "claimed",
+	Expired: "expired"
+});
+enumValues({
+	Mcp: "mcp",
+	Api: "api",
+	Cli: "cli",
+	Dashboard: "dashboard",
+	Agent: "agent"
+});
+//#endregion
 //#region src/config.ts
 /**
 * Daemon configuration — reads ~/.alfe/config.toml and resolves agent identity.
@@ -3179,6 +3285,10 @@ const PID_PATH = join(ALFE_DIR, "gateway.pid");
 * Returns agentId (derived from tokenId) and orgId (tenantId).
 */
 async function resolveAgentIdentity(apiKey, apiEndpoint) {
+	logger$1.debug({
+		apiEndpoint,
+		keyPrefix: apiKey.slice(0, 8) + "..."
+	}, "Resolving agent identity...");
 	const auth = new AuthService(new AlfeApiClient({
 		apiBaseUrl: apiEndpoint,
 		getToken: () => Promise.resolve(apiKey)
@@ -3186,22 +3296,47 @@ async function resolveAgentIdentity(apiKey, apiEndpoint) {
 	const maxAttempts = 3;
 	const delayMs = 3e3;
 	for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+		logger$1.debug({
+			attempt,
+			maxAttempts
+		}, "Validating token...");
 		const result = await auth.validate(apiKey);
 		if (!result.ok) {
+			logger$1.debug({
+				status: result.status,
+				error: result.error,
+				attempt
+			}, "Token validation failed");
 			if (result.status === 401 || result.status === 403) throw new Error(`Token validation failed: ${result.error}. Is your API key valid? Run \`alfe login\` to reconfigure.`);
 			if (attempt < maxAttempts) {
+				logger$1.debug({
+					delayMs,
+					attempt
+				}, "Retrying token validation after transient error...");
 				await new Promise((r) => setTimeout(r, delayMs));
 				continue;
 			}
 			throw new Error(`Token validation failed after ${String(maxAttempts)} attempts: ${result.error}. Is your API key valid? Run \`alfe login\` to reconfigure.`);
 		}
+		logger$1.debug({
+			valid: result.data.valid,
+			tenantId: result.data.tenantId,
+			tokenId: result.data.tokenId
+		}, "Token validation response");
 		if (!result.data.valid) throw new Error("API key invalid: validation failed. Run `alfe login` to reconfigure.");
 		const orgId = result.data.tenantId;
 		if (!orgId) throw new Error("Token validation returned no tenantId — cannot determine org.");
+		const agentId = result.data.tokenId ?? deriveAgentId(apiKey);
+		const runtime = result.data.runtime ?? "openclaw";
+		logger$1.debug({
+			agentId,
+			orgId,
+			runtime
+		}, "Agent identity resolved");
 		return {
-			agentId: result.data.tokenId ?? deriveAgentId(apiKey),
+			agentId,
 			orgId,
-			runtime: result.data.runtime ?? "openclaw"
+			runtime
 		};
 	}
 	throw new Error("Token validation failed: exhausted retries.");
@@ -3260,20 +3395,33 @@ function isManagedMode() {
 * All config comes from environment variables — no local files needed.
 */
 async function loadManagedConfig() {
+	logger$1.debug("Loading managed config from environment...");
 	const apiKey = process.env.ALFE_API_KEY;
 	const apiEndpoint = process.env.ALFE_API_ENDPOINT;
-	if (!apiKey || !apiEndpoint) throw new Error("ALFE_API_KEY and ALFE_API_ENDPOINT required in managed mode");
+	if (!apiKey || !apiEndpoint) throw new Error(`ALFE_API_KEY and ALFE_API_ENDPOINT required in managed mode (apiKey=${apiKey ? "set" : "missing"}, apiEndpoint=${apiEndpoint ? "set" : "missing"})`);
+	logger$1.debug({
+		apiEndpoint,
+		gatewayWsUrlEnv: process.env.ALFE_GATEWAY_WS_URL ?? "(not set)"
+	}, "Environment loaded, resolving identity...");
 	const identity = await resolveAgentIdentity(apiKey, apiEndpoint);
+	const gatewayWsUrl = process.env.ALFE_GATEWAY_WS_URL ?? deriveGatewayWsUrl(apiEndpoint);
+	logger$1.debug({
+		agentId: identity.agentId,
+		orgId: identity.orgId,
+		runtime: identity.runtime,
+		gatewayWsUrl
+	}, "Managed config resolved");
 	return {
 		apiKey,
 		apiEndpoint,
-		gatewayWsUrl: process.env.ALFE_GATEWAY_WS_URL ?? deriveGatewayWsUrl(apiEndpoint),
-		socketPath: "",
+		gatewayWsUrl,
+		socketPath: "/tmp/alfe-gateway.sock",
 		pidPath: "",
 		agentId: identity.agentId,
 		orgId: identity.orgId,
 		runtime: identity.runtime,
-		runtimes: identity.runtime === "openclaw" ? { openclaw: { workspace: join(homedir(), ".openclaw") } } : {}
+		runtimes: identity.runtime === "openclaw" ? { openclaw: { workspace: join(homedir(), ".openclaw") } } : {},
+		autoStartRuntime: true
 	};
 }
 /**
@@ -3304,7 +3452,8 @@ async function loadDaemonConfig() {
 		agentId: identity.agentId,
 		orgId: identity.orgId,
 		runtime: identity.runtime,
-		runtimes
+		runtimes,
+		autoStartRuntime: alfeConfig.auto_start_runtime ?? false
 	};
 }
 /**
@@ -3317,26 +3466,44 @@ async function loadDaemonConfig() {
 */
 async function fetchAgentConfig(apiKey, apiEndpoint) {
 	try {
+		logger$1.debug({ apiEndpoint }, "Fetching agent workspace config...");
 		const wsResponse = await fetch(`${apiEndpoint}/agents/me/workspace`, {
 			method: "GET",
 			headers: { "Authorization": `Bearer ${apiKey}` }
 		});
-		if (!wsResponse.ok) return null;
+		if (!wsResponse.ok) {
+			logger$1.debug({ status: wsResponse.status }, "Workspace config fetch failed");
+			return null;
+		}
 		const templateKey = (await wsResponse.json()).data?.templateKey;
-		if (!templateKey) return null;
+		if (!templateKey) {
+			logger$1.debug("No templateKey in workspace response");
+			return null;
+		}
+		logger$1.debug({ templateKey }, "Fetching template files...");
 		const filesResponse = await fetch(`${apiEndpoint}/templates/${encodeURIComponent(templateKey)}/files`, {
 			method: "GET",
 			headers: { "Authorization": `Bearer ${apiKey}` }
 		});
-		if (!filesResponse.ok) return {
+		if (!filesResponse.ok) {
+			logger$1.debug({ status: filesResponse.status }, "Template files fetch failed");
+			return {
+				templateKey,
+				files: {}
+			};
+		}
+		const filesResult = await filesResponse.json();
+		const fileCount = Object.keys(filesResult.data?.files ?? {}).length;
+		logger$1.debug({
 			templateKey,
-			files: {}
-		};
+			fileCount
+		}, "Template files fetched");
 		return {
 			templateKey,
-			files: (await filesResponse.json()).data?.files ?? {}
+			files: filesResult.data?.files ?? {}
 		};
-	} catch {
+	} catch (err) {
+		logger$1.debug({ err: err instanceof Error ? err.message : String(err) }, "fetchAgentConfig failed");
 		return null;
 	}
 }
@@ -3696,6 +3863,10 @@ var CloudClient = class {
 	* Start the cloud connection with auto-reconnect.
 	*/
 	start() {
+		logger$1.debug({
+			wsUrl: this.config.wsUrl,
+			agentId: this.config.agentId
+		}, "Cloud client starting...");
 		this.closed = false;
 		this.doConnect();
 	}
@@ -3703,15 +3874,18 @@ var CloudClient = class {
 	* Stop the cloud connection and all timers.
 	*/
 	stop() {
+		logger$1.debug("Cloud client stopping...");
 		this.closed = true;
 		this.stopPingTimer();
 		if (this.ws) {
+			logger$1.debug({ readyState: this.ws.readyState }, "Cloud: closing WebSocket");
 			try {
 				this.ws.close(1e3, "Daemon shutting down");
 			} catch {}
 			this.ws = null;
 		}
 		this.registered = false;
+		logger$1.debug("Cloud client stopped");
 	}
 	/**
 	* Get connection latency (time since last pong).
@@ -3722,22 +3896,36 @@ var CloudClient = class {
 		return Date.now() - this.lastPong;
 	}
 	doConnect() {
-		if (this.closed) return;
-		logger$1.info({ url: this.config.wsUrl }, "Connecting to cloud gateway...");
+		if (this.closed) {
+			logger$1.debug("Cloud: doConnect skipped — client is closed");
+			return;
+		}
+		logger$1.info({
+			url: this.config.wsUrl,
+			backoffMs: this.backoffMs
+		}, "Connecting to cloud gateway...");
+		logger$1.debug({
+			agentId: this.config.agentId,
+			keyPrefix: this.config.apiKey.slice(0, 12) + "..."
+		}, "Cloud: connection details");
 		this.ws = new WebSocket(this.config.wsUrl, {
 			headers: { authorization: `Bearer ${this.config.apiKey}` },
-			maxPayload: 10 * 1024 * 1024
+			maxPayload: 10 * 1024 * 1024,
+			handshakeTimeout: 1e4
 		});
 		this.ws.on("open", () => {
 			logger$1.info("Cloud WebSocket connected");
+			logger$1.debug({ readyState: this.ws?.readyState }, "Cloud: WebSocket open, sending registration...");
 			this.backoffMs = 1e3;
 			this.sendRegister();
 		});
 		this.ws.on("message", (data) => {
 			const text = Buffer.isBuffer(data) ? data.toString("utf-8") : Buffer.from(data).toString("utf-8");
+			logger$1.debug({ size: text.length }, "Cloud: received message");
 			this.handleMessage(text);
 		});
 		this.ws.on("ping", () => {
+			logger$1.debug("Cloud: received ping, sending pong");
 			this.ws?.pong();
 		});
 		this.ws.on("close", (code, reason) => {
@@ -3751,11 +3939,18 @@ var CloudClient = class {
 			this.scheduleReconnect();
 		});
 		this.ws.on("error", (err) => {
-			logger$1.error({ err: err.message }, "Cloud WebSocket error");
+			logger$1.error({
+				err: err.message,
+				url: this.config.wsUrl
+			}, "Cloud WebSocket error");
 		});
 	}
 	sendRegister() {
 		const msg = createServiceRegister(this.config.agentId);
+		logger$1.debug({
+			serviceId: msg.serviceId,
+			agentIds: msg.agentIds
+		}, "Cloud: sending SERVICE_REGISTER");
 		this.send(msg);
 		logger$1.info({ serviceId: msg.serviceId }, "Sent SERVICE_REGISTER");
 	}
@@ -3868,6 +4063,7 @@ var CloudClient = class {
 	}
 	send(msg) {
 		if (this.ws?.readyState === WebSocket.OPEN) this.ws.send(JSON.stringify(msg));
+		else logger$1.debug({ readyState: this.ws?.readyState }, "Cloud: send skipped — WebSocket not open");
 	}
 	startPingTimer() {
 		this.stopPingTimer();
@@ -3888,10 +4084,16 @@ var CloudClient = class {
 		}
 	}
 	scheduleReconnect() {
-		if (this.closed) return;
+		if (this.closed) {
+			logger$1.debug("Cloud: reconnect skipped — client is closed");
+			return;
+		}
 		const delay = this.backoffMs;
 		this.backoffMs = Math.min(this.backoffMs * 2, 3e4);
-		logger$1.info({ delayMs: delay }, "Cloud: reconnecting...");
+		logger$1.info({
+			delayMs: delay,
+			nextBackoffMs: this.backoffMs
+		}, "Cloud: scheduling reconnect...");
 		setTimeout(() => {
 			this.doConnect();
 		}, delay);
@@ -4324,6 +4526,12 @@ var CommandQueue = class {
 */
 const LAUNCHD_LABEL = "ai.alfe.gateway";
 const SYSTEMD_SERVICE = "alfe-gateway";
+function isRootUser() {
+	return process.getuid?.() === 0;
+}
+function getSystemdSystemServicePath() {
+	return `/etc/systemd/system/${SYSTEMD_SERVICE}.service`;
+}
 function getLaunchdPlistPath() {
 	return join(homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
 }
@@ -4384,9 +4592,13 @@ function generateLaunchdPlist() {
 </plist>`;
 }
 /**
-* Generate a systemd user unit for Linux.
+* Generate a systemd unit for Linux.
+* Root users get a system-level unit; non-root get a user-level unit.
 */
 function generateSystemdUnit() {
+	const nodePath = getNodePath();
+	const gatewayBin = getGatewayBinPath();
+	const root = isRootUser();
 	return `[Unit]
 Description=Alfe Gateway Daemon
 After=network-online.target
@@ -4394,13 +4606,13 @@ Wants=network-online.target
 
 [Service]
 Type=simple
-ExecStart=${getNodePath()} ${getGatewayBinPath()} daemon
+ExecStart=${nodePath} ${gatewayBin} daemon
 Restart=always
 RestartSec=10
-Environment=NODE_ENV=production
+Environment=NODE_ENV=production${root ? "\nEnvironment=HOME=/root\nWorkingDirectory=/root" : ""}
 
 [Install]
-WantedBy=default.target`;
+WantedBy=${root ? "multi-user.target" : "default.target"}`;
 }
 /**
 * Install the service unit for the current platform.
@@ -4441,31 +4653,57 @@ async function uninstallLaunchd() {
 	return `Uninstalled: ${plistPath}`;
 }
 async function installSystemd() {
-	const unitPath = getSystemdServicePath();
-	await mkdir(join(homedir(), ".config", "systemd", "user"), { recursive: true });
+	const root = isRootUser();
+	const unitPath = root ? getSystemdSystemServicePath() : getSystemdServicePath();
+	const dir = root ? "/etc/systemd/system" : join(homedir(), ".config", "systemd", "user");
+	const ctl = root ? "systemctl" : "systemctl --user";
+	if (!root) await mkdir(dir, { recursive: true });
 	await writeFile(unitPath, generateSystemdUnit(), "utf-8");
-	logger$1.info({ path: unitPath }, "Wrote systemd unit");
+	logger$1.info({
+		path: unitPath,
+		root
+	}, "Wrote systemd unit");
 	try {
-		execSync("systemctl --user daemon-reload", { stdio: "pipe" });
-		execSync(`systemctl --user enable ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
+		execSync(`${ctl} daemon-reload`, { stdio: "pipe" });
+		execSync(`${ctl} enable ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
 	} catch {}
-	return `Installed: ${unitPath}\nService enabled for user session.`;
+	return `Installed: ${unitPath}\nService enabled${root ? " (system-level)" : " for user session"}.`;
 }
 async function uninstallSystemd() {
-	const unitPath = getSystemdServicePath();
+	const root = isRootUser();
+	const unitPath = root ? getSystemdSystemServicePath() : getSystemdServicePath();
+	const ctl = root ? "systemctl" : "systemctl --user";
 	try {
-		execSync(`systemctl --user disable ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
-		execSync(`systemctl --user stop ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
+		execSync(`${ctl} disable ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
+		execSync(`${ctl} stop ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
 	} catch {}
 	try {
 		await unlink(unitPath);
 	} catch {}
 	try {
-		execSync("systemctl --user daemon-reload", { stdio: "pipe" });
+		execSync(`${ctl} daemon-reload`, { stdio: "pipe" });
 	} catch {}
 	return `Uninstalled: ${unitPath}`;
 }
 /**
+* Start the installed service via systemctl/launchctl.
+*/
+function startService() {
+	const platform = process.platform;
+	if (platform === "darwin") {
+		const plistPath = getLaunchdPlistPath();
+		execSync(`launchctl start ${LAUNCHD_LABEL}`, { stdio: "pipe" });
+		logger$1.info({ path: plistPath }, "Started launchd service");
+		return;
+	}
+	if (platform === "linux") {
+		execSync(`${isRootUser() ? "systemctl" : "systemctl --user"} start ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
+		logger$1.info("Started systemd service");
+		return;
+	}
+	throw new Error(`Unsupported platform: ${platform}`);
+}
+/**
 * Write the current process PID to the PID file.
 */
 async function writePidFile() {
@@ -19500,7 +19738,11 @@ var RuntimeProcess = class {
 		switch (this.options.runtime) {
 			case "openclaw": return {
 				command: "openclaw",
-				args: ["--workspace", this.options.workspace]
+				args: [
+					"gateway",
+					"run",
+					"--allow-unconfigured"
+				]
 			};
 			default: throw new Error(`Unsupported runtime: ${this.options.runtime}`);
 		}
@@ -19635,6 +19877,7 @@ var LocalAgentRelay = class {
 	* Start connecting to the local runtime WS.
 	*/
 	start() {
+		log.debug({ wsUrl: this.options.wsUrl }, "Local relay starting...");
 		this.stopped = false;
 		this.doConnect();
 	}
@@ -19642,12 +19885,14 @@ var LocalAgentRelay = class {
 	* Stop the relay and close the local WS connection.
 	*/
 	stop() {
+		log.debug("Local relay stopping...");
 		this.stopped = true;
 		if (this.retryTimer) {
 			clearTimeout(this.retryTimer);
 			this.retryTimer = null;
 		}
 		if (this.ws) {
+			log.debug({ readyState: this.ws.readyState }, "Local relay: closing WebSocket");
 			try {
 				this.ws.close(1e3);
 			} catch (err) {
@@ -19656,25 +19901,33 @@ var LocalAgentRelay = class {
 			this.ws = null;
 		}
 		this.connected = false;
+		log.debug("Local relay stopped");
 	}
 	/**
 	* Forward a message payload from the cloud to the local runtime WS.
 	*/
 	forward(payload) {
 		if (this.ws?.readyState !== WebSocket.OPEN) {
-			log.warn("Cannot forward to local runtime — not connected");
+			log.warn({ readyState: this.ws?.readyState }, "Cannot forward to local runtime — not connected");
 			return;
 		}
 		const data = typeof payload === "string" ? payload : JSON.stringify(payload);
+		log.debug({ size: data.length }, "Local relay: forwarding message to runtime");
 		this.ws.send(data);
 	}
 	get isConnected() {
 		return this.connected;
 	}
 	doConnect() {
-		if (this.stopped) return;
-		log.info({ url: this.options.wsUrl }, "Connecting to local runtime WS...");
-		this.ws = new WebSocket(this.options.wsUrl);
+		if (this.stopped) {
+			log.debug("Local relay: doConnect skipped — relay is stopped");
+			return;
+		}
+		log.info({
+			url: this.options.wsUrl,
+			retryCount: this.retryCount
+		}, "Connecting to local runtime WS...");
+		this.ws = new WebSocket(this.options.wsUrl, { handshakeTimeout: 1e4 });
 		this.ws.on("open", () => {
 			log.info("Local runtime WS connected — performing handshake");
 			this.retryCount = 0;
@@ -19682,6 +19935,7 @@ var LocalAgentRelay = class {
 		});
 		this.ws.on("message", (data) => {
 			const text = Buffer.isBuffer(data) ? data.toString("utf-8") : Buffer.from(data).toString("utf-8");
+			log.debug({ size: text.length }, "Local relay: received message");
 			this.handleLocalMessage(text);
 		});
 		this.ws.on("close", (code, reason) => {
@@ -19693,10 +19947,14 @@ var LocalAgentRelay = class {
 			this.scheduleReconnect();
 		});
 		this.ws.on("error", (err) => {
-			log.debug({ err: err.message }, "Local runtime WS error");
+			log.warn({
+				err: err.message,
+				url: this.options.wsUrl
+			}, "Local runtime WS error");
 		});
 	}
 	performHandshake() {
+		log.debug("Local relay: sending connect handshake");
 		const connectReq = {
 			type: "req",
 			id: randomUUID(),
@@ -19705,7 +19963,7 @@ var LocalAgentRelay = class {
 				minProtocol: 3,
 				maxProtocol: 3,
 				client: {
-					id: "alfe-daemon-relay",
+					id: "gateway-client",
 					displayName: "Alfe Daemon Relay",
 					version: "0.1.0",
 					platform: process.platform,
@@ -19781,20 +20039,37 @@ let integrationManager;
 let aiProxyServer = null;
 let runtimeProcess = null;
 let localRelay = null;
+let aiProxyUrl = null;
+let aiProxyRunning = false;
 let cloudConnected = false;
 let shuttingDown = false;
+/**
+* Flush pino's async transport and exit.
+* process.exit() can drop buffered log lines — this ensures they're written first.
+*/
+async function flushAndExit(code) {
+	await new Promise((resolve) => {
+		logger$1.flush();
+		setTimeout(resolve, 500);
+	});
+	process.exit(code);
+}
 async function startDaemon() {
 	startedAt = Date.now();
 	const managed = isManagedMode();
-	logger$1.info({ managed }, "Starting Alfe Gateway Daemon...");
+	logger$1.info({
+		managed,
+		pid: process.pid
+	}, "Starting Alfe Gateway Daemon...");
 	if (!managed) {
 		await mkdir(join(homedir(), ".alfe"), { recursive: true });
 		const existingPid = await checkExistingDaemon();
 		if (existingPid) {
 			logger$1.error({ pid: existingPid }, "Daemon already running. Use `alfe gateway stop` first.");
-			process.exit(1);
+			await flushAndExit(1);
 		}
 	}
+	logger$1.debug("Loading daemon config...");
 	try {
 		config = await loadDaemonConfig();
 		logger$1.info({
@@ -19804,26 +20079,33 @@ async function startDaemon() {
 		}, "Config loaded, identity resolved");
 	} catch (err) {
 		const message = err instanceof Error ? err.message : String(err);
-		logger$1.error({ err: message }, "Failed to load config");
-		process.exit(1);
-	}
+		const stack = err instanceof Error ? err.stack : void 0;
+		logger$1.error({
+			err: message,
+			stack
+		}, "Failed to load config");
+		await flushAndExit(1);
+	}
+	logger$1.debug("Initializing command queue...");
 	commandQueue = new CommandQueue();
 	commandQueue.startGC();
+	logger$1.debug("Starting AI proxy...");
 	try {
-		const { createProxyServer } = await import("@alfe.ai/ai-proxy-local");
+		const { createProxyServer, DEFAULT_AI_PROXY_PORT } = await import("@alfe.ai/ai-proxy-local");
 		const { getAiServiceUrlFromToken } = await import("@alfe.ai/config");
 		const proxyUrl = getAiServiceUrlFromToken(config.apiKey);
-		const AI_PROXY_PORT = 18193;
 		aiProxyServer = createProxyServer({
-			port: AI_PROXY_PORT,
+			port: DEFAULT_AI_PROXY_PORT,
 			apiKey: config.apiKey,
 			proxyUrl
 		});
 		const server = aiProxyServer;
 		await new Promise((resolve, reject) => {
-			server.listen(AI_PROXY_PORT, "127.0.0.1", () => {
+			server.listen(DEFAULT_AI_PROXY_PORT, "127.0.0.1", () => {
+				aiProxyRunning = true;
+				aiProxyUrl = `http://127.0.0.1:${String(DEFAULT_AI_PROXY_PORT)}`;
 				logger$1.info({
-					port: AI_PROXY_PORT,
+					port: DEFAULT_AI_PROXY_PORT,
 					upstream: proxyUrl
 				}, "AI proxy started");
 				resolve();
@@ -19832,17 +20114,31 @@ async function startDaemon() {
 		});
 	} catch (err) {
 		const message = err instanceof Error ? err.message : String(err);
-		logger$1.error({ err: message }, "Failed to start AI proxy — LLM requests will fail");
+		const stack = err instanceof Error ? err.stack : void 0;
+		logger$1.error({
+			err: message,
+			stack
+		}, "Failed to start AI proxy — LLM requests will fail");
 	}
+	logger$1.debug({ socketPath: config.socketPath }, "Starting IPC server...");
 	ipcServer = new IPCServer(config.socketPath);
 	ipcServer.setRequestHandler(handlePluginRequest);
 	try {
 		await ipcServer.start();
+		logger$1.debug("IPC server started");
 	} catch (err) {
 		const message = err instanceof Error ? err.message : String(err);
-		logger$1.error({ err: message }, "Failed to start IPC server");
-		process.exit(1);
-	}
+		const stack = err instanceof Error ? err.stack : void 0;
+		logger$1.error({
+			err: message,
+			stack
+		}, "Failed to start IPC server");
+		await flushAndExit(1);
+	}
+	logger$1.debug({
+		wsUrl: config.gatewayWsUrl,
+		agentId: config.agentId
+	}, "Connecting cloud client...");
 	cloudClient = new CloudClient({
 		wsUrl: config.gatewayWsUrl,
 		apiKey: config.apiKey,
@@ -19869,9 +20165,16 @@ async function startDaemon() {
 	const integrationAdapter = new IntegrationManagerAdapter(integrationManager);
 	cloudClient.setIntegrationManager(integrationAdapter);
 	cloudClient.start();
-	if (managed && config.runtime) {
+	logger$1.debug("Cloud client started");
+	if (config.autoStartRuntime && config.runtime) {
+		logger$1.debug({ runtime: config.runtime }, "Starting agent runtime...");
 		const runtimeCfg = config.runtimes[config.runtime];
 		if (runtimeCfg) {
+			const runtimeToken = randomUUID();
+			logger$1.debug({
+				runtime: config.runtime,
+				workspace: runtimeCfg.workspace
+			}, "Creating runtime process...");
 			runtimeProcess = new RuntimeProcess({
 				runtime: config.runtime,
 				workspace: runtimeCfg.workspace,
@@ -19880,14 +20183,18 @@ async function startDaemon() {
 					ALFE_API_KEY: config.apiKey,
 					ALFE_API_URL: config.apiEndpoint,
 					ALFE_AGENT_ID: config.agentId,
-					ANTHROPIC_BASE_URL: "http://127.0.0.1:18193",
-					OPENAI_BASE_URL: "http://127.0.0.1:18193"
+					ANTHROPIC_BASE_URL: aiProxyUrl ?? "http://127.0.0.1:18193",
+					OPENAI_BASE_URL: aiProxyUrl ?? "http://127.0.0.1:18193",
+					OPENCLAW_GATEWAY_TOKEN: runtimeToken
 				}
 			});
 			runtimeProcess.start();
+			logger$1.debug("Runtime process started");
+			const RUNTIME_WS_PORT = 18789;
+			logger$1.debug({ runtimeWsPort: RUNTIME_WS_PORT }, "Creating local agent relay...");
 			const relay = new LocalAgentRelay({
-				wsUrl: `ws://127.0.0.1:${String(18789)}`,
-				apiKey: config.apiKey,
+				wsUrl: `ws://127.0.0.1:${String(RUNTIME_WS_PORT)}`,
+				apiKey: runtimeToken,
 				onAgentMessage: (payload) => {
 					cloudClient.sendAgentEvent(payload);
 				}
@@ -19896,6 +20203,7 @@ async function startDaemon() {
 			cloudClient.setServiceRelayHandler((msg) => {
 				relay.forward(msg.payload);
 			});
+			logger$1.debug("Scheduling local relay start in 2s (waiting for runtime WS server)...");
 			setTimeout(() => {
 				relay.start();
 			}, 2e3);
@@ -19906,22 +20214,39 @@ async function startDaemon() {
 		if (shuttingDown) return;
 		shuttingDown = true;
 		logger$1.info({ signal }, "Shutting down...");
-		if (localRelay) localRelay.stop();
-		if (runtimeProcess) await runtimeProcess.stop();
-		if (ipcServer) await ipcServer.stop();
+		if (localRelay) {
+			logger$1.debug("Stopping local relay...");
+			localRelay.stop();
+			logger$1.debug("Local relay stopped");
+		}
+		if (runtimeProcess) {
+			logger$1.debug("Stopping runtime process...");
+			await runtimeProcess.stop();
+			logger$1.debug("Runtime process stopped");
+		}
+		if (ipcServer) {
+			logger$1.debug("Stopping IPC server...");
+			await ipcServer.stop();
+			logger$1.debug("IPC server stopped");
+		}
 		if (aiProxyServer) {
+			logger$1.debug("Stopping AI proxy...");
 			const proxy = aiProxyServer;
 			await new Promise((resolve) => {
 				proxy.close(() => {
 					resolve();
 				});
 			});
+			aiProxyRunning = false;
+			logger$1.debug("AI proxy stopped");
 		}
+		logger$1.debug("Stopping cloud client...");
 		cloudClient.stop();
+		logger$1.debug("Cloud client stopped");
 		commandQueue.stopGC();
 		if (!managed) await removePidFile();
 		logger$1.info("Daemon stopped");
-		process.exit(0);
+		await flushAndExit(0);
 	};
 	process.on("SIGTERM", () => {
 		shutdown("SIGTERM");
@@ -19937,33 +20262,94 @@ async function startDaemon() {
 	}, "Alfe Gateway Daemon started ✅");
 }
 async function handleCloudCommand(command) {
-	if (command.command === "support.diagnostic") try {
-		const { runDiagnostic } = await import("@alfe.ai/doctor");
+	if (command.command === "support.diagnostic") {
 		const payload = command.payload;
-		const workspacePath = Object.values(config.runtimes)[0]?.workspace ?? "~/.openclaw";
-		const report = await runDiagnostic({
-			task: payload.task,
-			workspacePath,
-			timeoutSeconds: 300
-		});
-		return {
-			type: "COMMAND_ACK",
-			commandId: command.commandId,
-			status: report.success ? "ok" : "error",
-			result: report
-		};
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		logger$1.error({ err: message }, "Diagnostic failed");
-		return {
+		if (!payload.apiKey && !aiProxyRunning) return {
 			type: "COMMAND_ACK",
 			commandId: command.commandId,
 			status: "error",
 			result: {
-				code: "DIAGNOSTIC_FAILED",
-				message
+				code: "PROXY_NOT_RUNNING",
+				message: "AI proxy is not running — diagnostic requires LLM access"
 			}
 		};
+		let proxyUrl;
+		if (aiProxyRunning) proxyUrl = aiProxyUrl ?? void 0;
+		else {
+			const { getAiServiceUrlFromToken } = await import("@alfe.ai/config");
+			proxyUrl = getAiServiceUrlFromToken(config.apiKey);
+		}
+		try {
+			const { runDiagnostic } = await import("@alfe.ai/doctor");
+			const workspacePath = Object.values(config.runtimes)[0]?.workspace ?? "~/.openclaw";
+			const report = await runDiagnostic({
+				task: payload.task,
+				workspacePath,
+				timeoutSeconds: 300,
+				proxyUrl,
+				apiKey: payload.apiKey
+			});
+			return {
+				type: "COMMAND_ACK",
+				commandId: command.commandId,
+				status: report.success ? "ok" : "error",
+				result: report
+			};
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			logger$1.error({ err: message }, "Diagnostic failed");
+			return {
+				type: "COMMAND_ACK",
+				commandId: command.commandId,
+				status: "error",
+				result: {
+					code: "DIAGNOSTIC_FAILED",
+					message
+				}
+			};
+		}
+	}
+	if (command.command === "integration.status") {
+		const payload = command.payload;
+		try {
+			if (payload?.integrationId) {
+				const info = integrationManager.get(payload.integrationId);
+				if (!info) return {
+					type: "COMMAND_ACK",
+					commandId: command.commandId,
+					status: "error",
+					result: {
+						code: "NOT_FOUND",
+						message: `Integration "${payload.integrationId}" not found`
+					}
+				};
+				return {
+					type: "COMMAND_ACK",
+					commandId: command.commandId,
+					status: "ok",
+					result: { integrations: [info] }
+				};
+			}
+			const integrations = integrationManager.list();
+			return {
+				type: "COMMAND_ACK",
+				commandId: command.commandId,
+				status: "ok",
+				result: { integrations }
+			};
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			logger$1.error({ err: message }, "Integration status failed");
+			return {
+				type: "COMMAND_ACK",
+				commandId: command.commandId,
+				status: "error",
+				result: {
+					code: "STATUS_FAILED",
+					message
+				}
+			};
+		}
 	}
 	const ipcRequest = cloudCommandToIPCRequest(command);
 	if (!ipcRequest) {
@@ -20049,6 +20435,7 @@ function handleStatus() {
 				status: cloudConnected ? "connected" : "disconnected",
 				latencyMs: cloudClient.getLatencyMs()
 			},
+			aiProxy: { status: aiProxyRunning ? "running" : "stopped" },
 			plugins: (ipcServer?.getRegisteredPlugins() ?? []).map(([, info]) => ({
 				name: info.name,
 				version: info.version,
@@ -20136,6 +20523,7 @@ async function queryDaemonHealth(socketPath, timeoutMs = 5e3) {
 			if (err.code === "ECONNREFUSED" || err.code === "ENOENT") resolve({
 				daemon: { status: "stopped" },
 				cloud: { status: "unknown" },
+				aiProxy: { status: "stopped" },
 				plugins: [],
 				commandQueue: { totalPending: 0 }
 			});
@@ -20152,6 +20540,8 @@ function formatHealthReport(health) {
 	lines.push(`  Gateway daemon      ${daemonIcon}  ${health.daemon.status}` + (health.daemon.uptime ? ` (uptime: ${formatUptime(health.daemon.uptime)})` : "") + (health.daemon.version ? ` v${health.daemon.version}` : ""));
 	const cloudIcon = health.cloud.status === "connected" ? "✓" : "✗";
 	lines.push(`  Cloud connection    ${cloudIcon}  ${health.cloud.status}` + (health.cloud.latencyMs !== void 0 ? ` (latency: ${String(health.cloud.latencyMs)}ms)` : ""));
+	const proxyIcon = health.aiProxy.status === "running" ? "✓" : "✗";
+	lines.push(`  AI proxy            ${proxyIcon}  ${health.aiProxy.status}`);
 	if (health.plugins.length === 0) lines.push("  Plugins             –  none connected");
 	else for (const plugin of health.plugins) {
 		const lastSeenAgo = Date.now() - plugin.lastSeen;
@@ -20173,4 +20563,4 @@ function formatDuration(ms) {
 	return `${String(Math.round(seconds / 3600))}h`;
 }
 //#endregion
-export { installService as a, PROTOCOL_VERSION as c, SOCKET_PATH as d, fetchAgentConfig as f, LOG_FILE as h, checkExistingDaemon as i, ALFE_DIR as l, resolveAgentIdentity as m, queryDaemonHealth as n, stopExistingDaemon as o, loadDaemonConfig as p, startDaemon as r, uninstallService as s, formatHealthReport as t, PID_PATH as u };
+export { logger$1 as _, installService as a, uninstallService as c, PID_PATH as d, SOCKET_PATH as f, LOG_FILE 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 };

package/dist/src/index.d.ts

@@ -1,3 +1,5 @@
+import pino from "pino";
+
 //#region src/protocol.d.ts
 
 interface IPCRequest {
@@ -58,6 +60,8 @@ interface DaemonConfig {
   runtime: string;
   /** Runtime configurations keyed by runtime name (e.g. 'openclaw') */
   runtimes: Record<string, RuntimeConfig>;
+  /** Whether to auto-start the agent runtime process (e.g. openclaw) */
+  autoStartRuntime: boolean;
 }
 interface AgentIdentity {
   agentId: string;
@@ -111,6 +115,9 @@ interface DaemonHealth {
     status: 'connected' | 'disconnected' | 'unknown';
     latencyMs?: number;
   };
+  aiProxy: {
+    status: 'running' | 'stopped';
+  };
   plugins: {
     name: string;
     version: string;
@@ -132,6 +139,9 @@ 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
 /**
  * Process management — launchd/systemd service installation.
@@ -147,6 +157,10 @@ declare function installService(): Promise<string>;
  * Uninstall the service unit for the current platform.
  */
 declare function uninstallService(): Promise<string>;
+/**
+ * Start the installed service via systemctl/launchctl.
+ */
+declare function startService(): void;
 /**
  * Write the current process PID to the PID file.
  */
@@ -161,4 +175,4 @@ declare function checkExistingDaemon(): Promise<number | null>;
  */
 declare function stopExistingDaemon(): Promise<boolean>;
 //#endregion
-export { ALFE_DIR, type AgentIdentity, type AgentWorkspaceConfig, type DaemonConfig, type DaemonHealth, type IPCEvent, type IPCRequest, type IPCResponse, PID_PATH, PROTOCOL_VERSION, SOCKET_PATH, checkExistingDaemon, fetchAgentConfig, formatHealthReport, installService, loadDaemonConfig, queryDaemonHealth, resolveAgentIdentity, startDaemon, stopExistingDaemon, uninstallService };
+export { ALFE_DIR, type AgentIdentity, type AgentWorkspaceConfig, type DaemonConfig, type DaemonHealth, type IPCEvent, type IPCRequest, type IPCResponse, PID_PATH, PROTOCOL_VERSION, SOCKET_PATH, checkExistingDaemon, fetchAgentConfig, formatHealthReport, installService, loadDaemonConfig, logger, queryDaemonHealth, resolveAgentIdentity, startDaemon, startService, stopExistingDaemon, uninstallService };

package/dist/src/index.js

@@ -1,2 +1,2 @@
-import { a as installService, c as PROTOCOL_VERSION, d as SOCKET_PATH, f as fetchAgentConfig, i as checkExistingDaemon, l as ALFE_DIR, m as resolveAgentIdentity, n as queryDaemonHealth, o as stopExistingDaemon, p as loadDaemonConfig, r as startDaemon, s as uninstallService, t as formatHealthReport, u as PID_PATH } from "../health.js";
-export { ALFE_DIR, PID_PATH, PROTOCOL_VERSION, SOCKET_PATH, checkExistingDaemon, fetchAgentConfig, formatHealthReport, installService, loadDaemonConfig, queryDaemonHealth, resolveAgentIdentity, startDaemon, stopExistingDaemon, uninstallService };
+import { _ as logger, a as installService, c as uninstallService, d as PID_PATH, f as SOCKET_PATH, 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";
+export { ALFE_DIR, PID_PATH, PROTOCOL_VERSION, SOCKET_PATH, checkExistingDaemon, fetchAgentConfig, formatHealthReport, installService, loadDaemonConfig, logger, queryDaemonHealth, resolveAgentIdentity, startDaemon, startService, stopExistingDaemon, uninstallService };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/gateway",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Alfe local gateway daemon — persistent control plane for agent integrations",
   "type": "module",
   "bin": {
@@ -19,8 +19,8 @@
   ],
   "dependencies": {
     "pino": "^9.6.0",
-    "smol-toml": "^1.3.0",
     "pino-roll": "^1.2.0",
+    "smol-toml": ">=1.6.1",
     "ws": "^8.18.0",
     "@alfe.ai/ai-proxy-local": "^0.0.2",
     "@alfe.ai/config": "^0.0.2",