@alfe.ai/gateway 0.0.5 → 0.0.7

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
 /**

package/dist/health.js

@@ -104,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",
@@ -381,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
@@ -3069,7 +3093,8 @@ enumValues({
 });
 enumValues({
 	Anthropic: "anthropic",
-	OpenAI: "openai"
+	OpenAI: "openai",
+	ElevenLabs: "elevenlabs"
 });
 enumValues({
 	Month: "month",
@@ -3095,6 +3120,7 @@ enumValues({
 	Provisioning: "provisioning",
 	Running: "running",
 	Stopped: "stopped",
+	Failing: "failing",
 	Failed: "failed",
 	BillingSuspended: "billing_suspended"
 });
@@ -3121,6 +3147,8 @@ enumValues({
 	SubscriptionCredit: "subscription_credit",
 	AutoRecharge: "auto_recharge",
 	AdminGift: "admin_gift",
+	ReferralCredit: "referral_credit",
+	PromoCredit: "promo_credit",
 	Refund: "refund"
 });
 enumValues({
@@ -3134,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",
@@ -3183,6 +3241,31 @@ _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
 /**
@@ -3243,7 +3326,7 @@ async function resolveAgentIdentity(apiKey, apiEndpoint) {
 		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 agentId = result.data.agentId ?? deriveAgentId(apiKey);
 		const runtime = result.data.runtime ?? "openclaw";
 		logger$1.debug({
 			agentId,
@@ -3314,14 +3397,11 @@ function isManagedMode() {
 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 (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...");
+	if (!apiKey) throw new Error("ALFE_API_KEY required in managed mode");
+	const apiEndpoint = process.env.ALFE_API_ENDPOINT ?? getEndpointFromToken(apiKey);
+	logger$1.debug({ apiEndpoint }, "Environment loaded, resolving identity...");
 	const identity = await resolveAgentIdentity(apiKey, apiEndpoint);
-	const gatewayWsUrl = process.env.ALFE_GATEWAY_WS_URL ?? deriveGatewayWsUrl(apiEndpoint);
+	const gatewayWsUrl = deriveGatewayWsUrl(apiEndpoint);
 	logger$1.debug({
 		agentId: identity.agentId,
 		orgId: identity.orgId,
@@ -3337,7 +3417,8 @@ async function loadManagedConfig() {
 		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
 	};
 }
 /**
@@ -3368,7 +3449,8 @@ async function loadDaemonConfig() {
 		agentId: identity.agentId,
 		orgId: identity.orgId,
 		runtime: identity.runtime,
-		runtimes
+		runtimes,
+		autoStartRuntime: alfeConfig.auto_start_runtime ?? false
 	};
 }
 /**
@@ -4441,6 +4523,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`);
 }
@@ -4455,6 +4543,10 @@ function getGatewayBinPath() {
 	if (globalBin) return globalBin;
 	const builtBin = join(import.meta.dirname, "..", "bin", "gateway.js");
 	if (existsSync(builtBin)) return builtBin;
+	try {
+		const resolved = execSync("node -e \"console.log(require.resolve('@alfe.ai/gateway/bin/gateway.js'))\"", { encoding: "utf-8" }).trim();
+		if (existsSync(resolved)) return resolved;
+	} catch {}
 	return "alfe-gateway";
 }
 function getNodePath() {
@@ -4501,9 +4593,18 @@ 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();
+	const envLines = [
+		"ALFE_MANAGED",
+		"ALFE_API_KEY",
+		"LOG_LEVEL"
+	].filter((key) => process.env[key]).map((key) => `Environment=${key}=${process.env[key] ?? ""}`).join("\n");
 	return `[Unit]
 Description=Alfe Gateway Daemon
 After=network-online.target
@@ -4511,13 +4612,14 @@ 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" : ""}
+${envLines}
 
 [Install]
-WantedBy=default.target`;
+WantedBy=${root ? "multi-user.target" : "default.target"}`;
 }
 /**
 * Install the service unit for the current platform.
@@ -4558,31 +4660,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() {
@@ -19918,6 +20046,8 @@ let integrationManager;
 let aiProxyServer = null;
 let runtimeProcess = null;
 let localRelay = null;
+let aiProxyUrl = null;
+let aiProxyRunning = false;
 let cloudConnected = false;
 let shuttingDown = false;
 /**
@@ -19968,20 +20098,21 @@ async function startDaemon() {
 	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();
@@ -20042,8 +20173,8 @@ async function startDaemon() {
 	cloudClient.setIntegrationManager(integrationAdapter);
 	cloudClient.start();
 	logger$1.debug("Cloud client started");
-	if (managed && config.runtime) {
-		logger$1.debug({ runtime: config.runtime }, "Starting agent runtime (managed mode)...");
+	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();
@@ -20059,8 +20190,8 @@ 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
 				}
 			});
@@ -20113,6 +20244,7 @@ async function startDaemon() {
 					resolve();
 				});
 			});
+			aiProxyRunning = false;
 			logger$1.debug("AI proxy stopped");
 		}
 		logger$1.debug("Stopping cloud client...");
@@ -20137,33 +20269,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) {
@@ -20249,6 +20442,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,
@@ -20336,6 +20530,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 }
 			});
@@ -20352,6 +20547,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;
@@ -20373,4 +20570,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, logger$1 as g, 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

@@ -60,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;
@@ -113,6 +115,9 @@ interface DaemonHealth {
     status: 'connected' | 'disconnected' | 'unknown';
     latencyMs?: number;
   };
+  aiProxy: {
+    status: 'running' | 'stopped';
+  };
   plugins: {
     name: string;
     version: string;
@@ -152,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.
  */
@@ -166,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, logger, 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, g as logger, 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, logger, 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.5",
+  "version": "0.0.7",
   "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",