@vama/openclaw 2026.5.5-5 → 2026.5.5-7

package/dist/api-CBt1Mjce.js

@@ -0,0 +1,25 @@
+import "./probe-COpuChEq.js";
+import { i as dispatchStarted, r as dispatchEnded } from "./monitor-BlnFXk24.js";
+//#region extensions/vama/src/cli-metadata.ts
+function registerVamaCliMetadata(api) {
+	api.registerCli(async ({ program }) => {
+		const { registerVamaCli } = await import("./cli-uxMxzdnO.js");
+		registerVamaCli({ program });
+	}, { descriptors: [{
+		name: "vama",
+		description: "Connect this OpenClaw to Vama and manage the Vama channel",
+		hasSubcommands: true
+	}] });
+}
+//#endregion
+//#region extensions/vama/src/subagent-keepalive-hooks.ts
+function registerVamaSubagentKeepaliveHooks(api) {
+	api.on("subagent_spawned", () => {
+		dispatchStarted();
+	});
+	api.on("subagent_ended", () => {
+		dispatchEnded();
+	});
+}
+//#endregion
+export { registerVamaCliMetadata as n, registerVamaSubagentKeepaliveHooks as t };

package/dist/api.js

@@ -1,4 +1,4 @@
-import { n as probeVama } from "./probe-Cf1xor23.js";
-import { n as sendMessageVama, t as monitorVamaProvider } from "./monitor-DLgOtdLQ.js";
-import { t as registerVamaSubagentKeepaliveHooks } from "./api-DftFHS2s.js";
-export { monitorVamaProvider, probeVama, registerVamaSubagentKeepaliveHooks, sendMessageVama };
+import { n as registerVamaCliMetadata, t as registerVamaSubagentKeepaliveHooks } from "./api-CBt1Mjce.js";
+import { n as probeVama } from "./probe-COpuChEq.js";
+import { n as sendMessageVama, t as monitorVamaProvider } from "./monitor-BlnFXk24.js";
+export { monitorVamaProvider, probeVama, registerVamaCliMetadata, registerVamaSubagentKeepaliveHooks, sendMessageVama };

package/dist/{channel-plugin-api-KLKTLQFV.js → channel-plugin-api-Bi8Gs3E6.js}

@@ -1,7 +1,7 @@
 import { a as exchangeConnectCode, i as createBotHubClient, n as attachmentHintFromExtension, o as provisionBot } from "./client-BzhfASX8.js";
-import { a as resolveDefaultVamaAccountId, i as listVamaAccountIds, n as probeVama, o as resolveVamaAccount } from "./probe-Cf1xor23.js";
-import { a as DEFAULT_ACCOUNT_ID$1, c as createDefaultChannelRuntimeState, n as sendMessageVama, o as PAIRING_APPROVED_MESSAGE, s as buildBaseChannelStatusSummary, t as monitorVamaProvider } from "./monitor-DLgOtdLQ.js";
-import { t as getVamaRuntime } from "./runtime-Cq09Y5cd.js";
+import { a as resolveDefaultVamaAccountId, i as listVamaAccountIds, n as probeVama, o as resolveVamaAccount } from "./probe-COpuChEq.js";
+import { a as DEFAULT_ACCOUNT_ID$1, c as createDefaultChannelRuntimeState, n as sendMessageVama, o as PAIRING_APPROVED_MESSAGE, s as buildBaseChannelStatusSummary, t as monitorVamaProvider } from "./monitor-BlnFXk24.js";
+import { t as getVamaRuntime } from "./runtime-CQ9kld4S.js";
 import { t as parseVamaConnectCode } from "./connect-code-Bbp9J6TH.js";
 import { jsonResult, readStringOrNumberParam, readStringParam } from "openclaw/plugin-sdk/channel-actions";
 import { extractToolSend } from "openclaw/plugin-sdk/tool-send";

package/dist/channel-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as vamaPlugin } from "./channel-plugin-api-KLKTLQFV.js";
+import { t as vamaPlugin } from "./channel-plugin-api-Bi8Gs3E6.js";
 export { vamaPlugin };

package/dist/cli-uxMxzdnO.js

@@ -0,0 +1,378 @@
+import { a as exchangeConnectCode } from "./client-BzhfASX8.js";
+import { n as probeVama, o as resolveVamaAccount, t as clearProbeCache } from "./probe-COpuChEq.js";
+import { t as getVamaRuntime } from "./runtime-CQ9kld4S.js";
+import { t as parseVamaConnectCode } from "./connect-code-Bbp9J6TH.js";
+import fs from "node:fs";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import { spawn } from "node:child_process";
+//#region extensions/vama/src/connect-verify.ts
+/**
+* Post-connect verification: make `openclaw vama connect` end with a TRUE
+* statement about liveness instead of "credentials look right, good luck".
+*
+* Two halves:
+*  1. ensureGatewayRunning — the gateway process is what actually holds the
+*     WebSocket to BotHub. If it isn't up, try `gateway start` (service
+*     installed but stopped), then `gateway install` (fresh machine —
+*     installs the launchd/systemd service, which auto-starts).
+*  2. waitForWSConnected — poll BotHub's GET /v1/bot/me (bot-token auth)
+*     until `ws_connected` flips true, proving the gateway's socket arrived
+*     server-side. Raw fetch on purpose: the BotHub client logs every call,
+*     and a 1.5s poll loop would spam ~20 log lines into the summary.
+*/
+const DEFAULT_GATEWAY_PORT = 18789;
+function resolveGatewayPort(cfg) {
+	const port = cfg.gateway?.port;
+	return typeof port === "number" && Number.isInteger(port) && port > 0 ? port : DEFAULT_GATEWAY_PORT;
+}
+/** Any HTTP response (even an error status) proves something is listening. */
+async function isGatewayUp(port, fetchImpl = fetch) {
+	try {
+		await fetchImpl(`http://127.0.0.1:${port}/`, {
+			method: "GET",
+			signal: AbortSignal.timeout(1500)
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Invoke the host CLI's `gateway` subcommand. Plugins can't import gateway
+* lifecycle internals, so we respawn the CLI we're running under: when
+* process.argv[1] is a real script on disk (npm installs), reuse it with the
+* current Node binary; otherwise (compiled single-binary builds) fall back
+* to `openclaw` on PATH.
+*/
+const runGatewayCommand = (args) => {
+	const entry = process.argv[1];
+	const viaScript = Boolean(entry && fs.existsSync(entry));
+	const bin = viaScript ? process.execPath : "openclaw";
+	const argv = viaScript ? [
+		entry,
+		"gateway",
+		...args
+	] : ["gateway", ...args];
+	return new Promise((resolve) => {
+		let output = "";
+		const child = spawn(bin, argv, {
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: process.env
+		});
+		const timer = setTimeout(() => {
+			child.kill("SIGTERM");
+		}, 6e4);
+		child.stdout?.on("data", (chunk) => {
+			output += chunk.toString();
+		});
+		child.stderr?.on("data", (chunk) => {
+			output += chunk.toString();
+		});
+		child.once("error", (err) => {
+			clearTimeout(timer);
+			resolve({
+				ok: false,
+				output: `${output}\n${err.message}`.trim()
+			});
+		});
+		child.once("close", (code) => {
+			clearTimeout(timer);
+			resolve({
+				ok: code === 0,
+				output: output.trim()
+			});
+		});
+	});
+};
+async function waitUntilUp(params) {
+	const deadline = Date.now() + params.timeoutMs;
+	while (Date.now() < deadline) {
+		if (await params.probe(params.port)) return true;
+		await params.sleep(750);
+	}
+	return false;
+}
+const defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function ensureGatewayRunning(params, deps = {}) {
+	const probe = deps.probe ?? isGatewayUp;
+	const runGateway = deps.runGateway ?? runGatewayCommand;
+	const sleep = deps.sleep ?? defaultSleep;
+	const log = params.log ?? (() => {});
+	if (await probe(params.port)) return {
+		action: "already-running",
+		up: true
+	};
+	log("Gateway not running — starting the service…");
+	const start = await runGateway(["start"]);
+	if (start.ok && await waitUntilUp({
+		port: params.port,
+		timeoutMs: 8e3,
+		probe,
+		sleep
+	})) return {
+		action: "started",
+		up: true
+	};
+	log("Gateway service not installed — installing it (auto-starts on login)…");
+	const install = await runGateway(["install"]);
+	if (install.ok && await waitUntilUp({
+		port: params.port,
+		timeoutMs: 12e3,
+		probe,
+		sleep
+	})) return {
+		action: "installed",
+		up: true
+	};
+	return {
+		action: "failed",
+		up: false,
+		detail: (install.output || start.output).split("\n").slice(-4).join("\n").trim() || void 0
+	};
+}
+/**
+* Poll GET /v1/bot/me until `ws_connected` is true. "unsupported" means the
+* server doesn't report the field yet (BotHub older than this feature) —
+* callers should fall back to a non-committal message, not an error.
+*/
+async function waitForWSConnected(params, deps = {}) {
+	const fetchImpl = deps.fetchImpl ?? fetch;
+	const sleep = deps.sleep ?? defaultSleep;
+	const baseUrl = params.bothubUrl.replace(/\/+$/, "");
+	const deadline = Date.now() + (params.timeoutMs ?? 3e4);
+	let lastError;
+	while (Date.now() < deadline) {
+		try {
+			const res = await fetchImpl(`${baseUrl}/v1/bot/me`, {
+				method: "GET",
+				headers: { Authorization: `Bot ${params.botToken}` },
+				signal: AbortSignal.timeout(5e3)
+			});
+			if (res.ok) {
+				const me = await res.json();
+				if (!("ws_connected" in me)) return { status: "unsupported" };
+				if (me.ws_connected === true) return { status: "live" };
+				lastError = void 0;
+			} else lastError = `GET /v1/bot/me returned ${res.status}`;
+		} catch (err) {
+			lastError = err instanceof Error ? err.message : String(err);
+		}
+		await sleep(1500);
+	}
+	return lastError ? {
+		status: "error",
+		error: lastError
+	} : { status: "timeout" };
+}
+//#endregion
+//#region extensions/vama/src/cli.ts
+/**
+* Apply freshly exchanged credentials to the config. Default account writes
+* top-level under channels.vama (matching the setup wizard); named accounts
+* write under channels.vama.accounts.<id>. Existing unrelated keys
+* (dmPolicy, webhookPort, …) are preserved.
+*/
+function applyVamaConnectCredentials(params) {
+	const { cfg, accountId } = params;
+	const vama = cfg.channels?.vama ?? {};
+	const credentialPatch = {
+		enabled: true,
+		botToken: params.botToken,
+		webhookSecret: params.webhookSecret
+	};
+	if (params.bothubUrl !== "https://bothub.vama.com") credentialPatch.bothubUrl = params.bothubUrl;
+	if (accountId === DEFAULT_ACCOUNT_ID) {
+		const next = {
+			...vama,
+			...credentialPatch
+		};
+		if (params.bothubUrl === "https://bothub.vama.com") delete next.bothubUrl;
+		return {
+			...cfg,
+			channels: {
+				...cfg.channels,
+				vama: {
+					...next,
+					enabled: true
+				}
+			}
+		};
+	}
+	const nextAccount = {
+		...vama.accounts?.[accountId] ?? {},
+		...credentialPatch
+	};
+	if (params.bothubUrl === "https://bothub.vama.com") delete nextAccount.bothubUrl;
+	return {
+		...cfg,
+		channels: {
+			...cfg.channels,
+			vama: {
+				...vama,
+				enabled: true,
+				accounts: {
+					...vama.accounts,
+					[accountId]: nextAccount
+				}
+			}
+		}
+	};
+}
+/**
+* `openclaw vama connect <code>` — the whole BYO onboarding in one command:
+* exchange the code for credentials, write the config, verify with a live
+* probe. WebSocket-enabled bots (the default for codes minted from Vama
+* settings) need no tunnel, no public URL, no webhook registration.
+*/
+async function runVamaConnect(params, deps = {}) {
+	const exchange = deps.exchange ?? exchangeConnectCode;
+	const probe = deps.probe ?? probeVama;
+	const ensureGateway = deps.ensureGateway ?? ensureGatewayRunning;
+	const waitForLive = deps.waitForLive ?? waitForWSConnected;
+	const log = deps.log ?? ((msg) => console.log(msg));
+	const parsed = parseVamaConnectCode(params.rawCode);
+	const runtime = getVamaRuntime();
+	const cfg = runtime.config.current();
+	const accountId = normalizeAccountId(params.account?.trim() || DEFAULT_ACCOUNT_ID);
+	const existingUrl = (cfg.channels?.vama ?? {}).bothubUrl?.trim();
+	const bothubUrl = (params.bothubUrlFlag?.trim() || parsed.bothubUrl || existingUrl || "https://bothub.vama.com").replace(/\/+$/, "");
+	log(`Exchanging connect code with ${bothubUrl}…`);
+	const exchanged = await exchange({
+		bothubUrl,
+		code: parsed.code
+	});
+	const updated = applyVamaConnectCredentials({
+		cfg,
+		accountId,
+		botToken: exchanged.bot_token,
+		webhookSecret: exchanged.webhook_secret,
+		bothubUrl
+	});
+	await runtime.config.replaceConfigFile({
+		nextConfig: updated,
+		afterWrite: { mode: "auto" }
+	});
+	clearProbeCache();
+	const result = {
+		accountId,
+		botId: exchanged.bot_id,
+		username: exchanged.username,
+		displayName: exchanged.display_name,
+		websocketEnabled: exchanged.websocket_enabled === true,
+		bothubUrl,
+		created: exchanged.created
+	};
+	try {
+		const probed = await probe(resolveVamaAccount({
+			cfg: updated,
+			accountId
+		}));
+		result.probeOk = probed.ok;
+		if (!probed.ok) result.probeError = probed.error;
+	} catch (err) {
+		result.probeOk = false;
+		result.probeError = err instanceof Error ? err.message : String(err);
+	}
+	if (params.skipGateway) {
+		result.gatewayAction = "skipped";
+		result.liveCheck = "skipped";
+		return result;
+	}
+	const gateway = await ensureGateway({
+		port: resolveGatewayPort(updated),
+		log
+	});
+	result.gatewayAction = gateway.action;
+	if (gateway.detail) result.gatewayDetail = gateway.detail;
+	if (!gateway.up) {
+		result.live = false;
+		result.liveCheck = "skipped";
+		return result;
+	}
+	if (!result.websocketEnabled) {
+		result.liveCheck = "skipped";
+		return result;
+	}
+	log("Waiting for your agent to come online…");
+	const live = await waitForLive({
+		bothubUrl,
+		botToken: exchanged.bot_token
+	});
+	result.liveCheck = live.status;
+	result.live = live.status === "live";
+	if (live.error) result.liveError = live.error;
+	return result;
+}
+const GATEWAY_ACTION_LABEL = {
+	"already-running": "already running (config reloaded)",
+	started: "started",
+	installed: "installed as a service (auto-starts on login)",
+	failed: "could not be started automatically",
+	skipped: "left alone (--no-gateway)"
+};
+function printConnectResult(result) {
+	const botLabel = result.displayName || result.username || result.botId;
+	console.log("");
+	console.log(`✔ Credentials saved for ${botLabel}${result.username ? ` (@${result.username})` : ""}`);
+	if (result.websocketEnabled) console.log("  Transport: WebSocket — no tunnel or public URL needed.");
+	else console.log("  Transport: webhook — set channels.vama.webhookUrl to a public URL (or mint a new code from Vama settings to enable WebSocket).");
+	if (result.gatewayAction) console.log(`  Gateway: ${GATEWAY_ACTION_LABEL[result.gatewayAction]}`);
+	if (result.probeOk === false && result.probeError) console.log(`  Verification warning: ${result.probeError}`);
+	console.log("");
+	if (result.live) {
+		console.log("🎉 Your agent is LIVE — open Vama and say hi.");
+		return;
+	}
+	switch (result.liveCheck) {
+		case "skipped":
+			if (result.gatewayAction === "failed") {
+				console.log("✖ NOT live yet — the gateway could not be started.");
+				if (result.gatewayDetail) console.log(`  ${result.gatewayDetail.split("\n").join("\n  ")}`);
+				console.log("  Start it yourself, then your agent connects with the saved credentials:");
+				console.log("    openclaw gateway install   # background service (recommended)");
+				console.log("    openclaw gateway run       # or foreground, for a quick test");
+			} else if (result.gatewayAction === "skipped") {
+				console.log("Gateway untouched (--no-gateway). Your agent goes live when it runs:");
+				console.log("    openclaw gateway run");
+			} else console.log("Gateway is up. Complete webhook setup to bring the agent online.");
+			return;
+		case "unsupported":
+			console.log("Gateway is up. (This BotHub doesn't report live status yet —");
+			console.log("  check the agent in Vama: it should be online now.)");
+			return;
+		default:
+			console.log("⚠ NOT live yet — gateway is up but BotHub hasn't seen its connection.");
+			if (result.liveError) console.log(`  Last error: ${result.liveError}`);
+			console.log("  It may just be slow. Check again with: openclaw channels status --probe");
+			console.log("  Gateway logs: openclaw gateway status");
+			return;
+	}
+}
+function registerVamaCli({ program }) {
+	program.command("vama").description("Vama channel tools (connect codes, account state)").command("connect").description("Connect this OpenClaw to Vama with a one-time code from Vama settings (Settings → AI Agents)").argument("<code>", "connect code (vmc1_… token or 64-char hex)").option("--bothub-url <url>", "BotHub endpoint override (defaults to the URL embedded in the code)").option("--account <id>", "Vama account id to write credentials to", DEFAULT_ACCOUNT_ID).option("--json", "print the result as JSON", false).option("--no-gateway", "save credentials only; don't start/install the gateway").action(async (code, opts) => {
+		try {
+			const result = await runVamaConnect({
+				rawCode: code,
+				bothubUrlFlag: opts.bothubUrl,
+				account: opts.account,
+				skipGateway: opts.gateway === false
+			}, { log: opts.json ? () => {} : void 0 });
+			if (opts.json) console.log(JSON.stringify(result, null, 2));
+			else printConnectResult(result);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			if (opts.json) console.log(JSON.stringify({
+				ok: false,
+				error: message
+			}, null, 2));
+			else console.error(`✖ Connect failed: ${message}`);
+			process.exitCode = 1;
+		}
+	});
+}
+//#endregion
+export { registerVamaCli };

package/dist/index.js

@@ -1,21 +1,9 @@
-import { n as probeVama } from "./probe-Cf1xor23.js";
-import { n as sendMessageVama, t as monitorVamaProvider } from "./monitor-DLgOtdLQ.js";
-import { n as setVamaRuntime } from "./runtime-Cq09Y5cd.js";
-import { t as registerVamaSubagentKeepaliveHooks } from "./api-DftFHS2s.js";
-import { t as vamaPlugin } from "./channel-plugin-api-KLKTLQFV.js";
+import { n as registerVamaCliMetadata, t as registerVamaSubagentKeepaliveHooks } from "./api-CBt1Mjce.js";
+import { n as probeVama } from "./probe-COpuChEq.js";
+import { n as sendMessageVama, t as monitorVamaProvider } from "./monitor-BlnFXk24.js";
+import { n as setVamaRuntime } from "./runtime-CQ9kld4S.js";
+import { t as vamaPlugin } from "./channel-plugin-api-Bi8Gs3E6.js";
 import "./runtime-api.js";
-//#region extensions/vama/src/cli-metadata.ts
-function registerVamaCliMetadata(api) {
-	api.registerCli(async ({ program }) => {
-		const { registerVamaCli } = await import("./cli-F0a1J9Rj.js");
-		registerVamaCli({ program });
-	}, { descriptors: [{
-		name: "vama",
-		description: "Connect this OpenClaw to Vama and manage the Vama channel",
-		hasSubcommands: true
-	}] });
-}
-//#endregion
 //#region extensions/vama/index.ts
 const channelEntry = {
 	kind: "bundled-channel-entry",

package/dist/{monitor-DLgOtdLQ.js → monitor-BlnFXk24.js}

@@ -1,7 +1,7 @@
 import { i as createBotHubClient, n as attachmentHintFromExtension } from "./client-BzhfASX8.js";
-import { o as resolveVamaAccount, r as startVamaWebSocket, t as clearProbeCache } from "./probe-Cf1xor23.js";
-import { t as getVamaRuntime } from "./runtime-Cq09Y5cd.js";
-import * as fs from "node:fs";
+import { o as resolveVamaAccount, r as startVamaWebSocket, t as clearProbeCache } from "./probe-COpuChEq.js";
+import { t as getVamaRuntime } from "./runtime-CQ9kld4S.js";
+import * as fs$1 from "node:fs";
 import { promises } from "node:fs";
 import * as http from "node:http";
 import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
@@ -125,10 +125,10 @@ function loadFcEnv() {
 	if (envCacheLoaded) return;
 	envCacheLoaded = true;
 	try {
-		cachedVmName = fs.readFileSync("/etc/openclaw/vm-name", "utf8").trim() || void 0;
+		cachedVmName = fs$1.readFileSync("/etc/openclaw/vm-name", "utf8").trim() || void 0;
 	} catch {}
 	try {
-		const m = fs.readFileSync("/etc/vmctl.env", "utf8").match(/FC_AUTH_TOKEN=["']?([^"'\n]+)/);
+		const m = fs$1.readFileSync("/etc/vmctl.env", "utf8").match(/FC_AUTH_TOKEN=["']?([^"'\n]+)/);
 		if (m) cachedAuthToken = m[1];
 	} catch {
 		if (process.env.FC_AUTH_TOKEN) cachedAuthToken = process.env.FC_AUTH_TOKEN;
@@ -756,7 +756,7 @@ const SECRET_CACHE = /* @__PURE__ */ new Map();
 function readSecretFromFile(path, log) {
 	let stat;
 	try {
-		stat = fs.statSync(path);
+		stat = fs$1.statSync(path);
 	} catch (e) {
 		log(`vama: webhookSecretFile stat failed (${path}): ${e instanceof Error ? e.message : String(e)}`);
 		return;
@@ -765,7 +765,7 @@ function readSecretFromFile(path, log) {
 	if (cached && cached.mtimeMs === stat.mtimeMs && cached.sizeBytes === stat.size) return cached.secret;
 	let raw;
 	try {
-		raw = fs.readFileSync(path, "utf8");
+		raw = fs$1.readFileSync(path, "utf8");
 	} catch (e) {
 		log(`vama: webhookSecretFile read failed (${path}): ${e instanceof Error ? e.message : String(e)}`);
 		return;

package/dist/runtime-api.js

@@ -1,2 +1,2 @@
-import { n as setVamaRuntime } from "./runtime-Cq09Y5cd.js";
+import { n as setVamaRuntime } from "./runtime-CQ9kld4S.js";
 export { setVamaRuntime };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vama/openclaw",
-  "version": "2026.5.5-5",
+  "version": "2026.5.5-7",
   "description": "OpenClaw Vama channel plugin via BotHub",
   "homepage": "https://web.vama.com/connect-guide",
   "repository": {

package/dist/api-DftFHS2s.js

@@ -1,13 +0,0 @@
-import "./probe-Cf1xor23.js";
-import { i as dispatchStarted, r as dispatchEnded } from "./monitor-DLgOtdLQ.js";
-//#region extensions/vama/src/subagent-keepalive-hooks.ts
-function registerVamaSubagentKeepaliveHooks(api) {
-	api.on("subagent_spawned", () => {
-		dispatchStarted();
-	});
-	api.on("subagent_ended", () => {
-		dispatchEnded();
-	});
-}
-//#endregion
-export { registerVamaSubagentKeepaliveHooks as t };

package/dist/cli-F0a1J9Rj.js

@@ -1,150 +0,0 @@
-import { a as exchangeConnectCode } from "./client-BzhfASX8.js";
-import { n as probeVama, o as resolveVamaAccount, t as clearProbeCache } from "./probe-Cf1xor23.js";
-import { t as getVamaRuntime } from "./runtime-Cq09Y5cd.js";
-import { t as parseVamaConnectCode } from "./connect-code-Bbp9J6TH.js";
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
-//#region extensions/vama/src/cli.ts
-/**
-* Apply freshly exchanged credentials to the config. Default account writes
-* top-level under channels.vama (matching the setup wizard); named accounts
-* write under channels.vama.accounts.<id>. Existing unrelated keys
-* (dmPolicy, webhookPort, …) are preserved.
-*/
-function applyVamaConnectCredentials(params) {
-	const { cfg, accountId } = params;
-	const vama = cfg.channels?.vama ?? {};
-	const credentialPatch = {
-		enabled: true,
-		botToken: params.botToken,
-		webhookSecret: params.webhookSecret
-	};
-	if (params.bothubUrl !== "https://bothub.vama.com") credentialPatch.bothubUrl = params.bothubUrl;
-	if (accountId === DEFAULT_ACCOUNT_ID) {
-		const next = {
-			...vama,
-			...credentialPatch
-		};
-		if (params.bothubUrl === "https://bothub.vama.com") delete next.bothubUrl;
-		return {
-			...cfg,
-			channels: {
-				...cfg.channels,
-				vama: {
-					...next,
-					enabled: true
-				}
-			}
-		};
-	}
-	const nextAccount = {
-		...vama.accounts?.[accountId] ?? {},
-		...credentialPatch
-	};
-	if (params.bothubUrl === "https://bothub.vama.com") delete nextAccount.bothubUrl;
-	return {
-		...cfg,
-		channels: {
-			...cfg.channels,
-			vama: {
-				...vama,
-				enabled: true,
-				accounts: {
-					...vama.accounts,
-					[accountId]: nextAccount
-				}
-			}
-		}
-	};
-}
-/**
-* `openclaw vama connect <code>` — the whole BYO onboarding in one command:
-* exchange the code for credentials, write the config, verify with a live
-* probe. WebSocket-enabled bots (the default for codes minted from Vama
-* settings) need no tunnel, no public URL, no webhook registration.
-*/
-async function runVamaConnect(params, deps = {}) {
-	const exchange = deps.exchange ?? exchangeConnectCode;
-	const probe = deps.probe ?? probeVama;
-	const log = deps.log ?? ((msg) => console.log(msg));
-	const parsed = parseVamaConnectCode(params.rawCode);
-	const runtime = getVamaRuntime();
-	const cfg = runtime.config.current();
-	const accountId = normalizeAccountId(params.account?.trim() || DEFAULT_ACCOUNT_ID);
-	const existingUrl = (cfg.channels?.vama ?? {}).bothubUrl?.trim();
-	const bothubUrl = (params.bothubUrlFlag?.trim() || parsed.bothubUrl || existingUrl || "https://bothub.vama.com").replace(/\/+$/, "");
-	log(`Exchanging connect code with ${bothubUrl}…`);
-	const exchanged = await exchange({
-		bothubUrl,
-		code: parsed.code
-	});
-	const updated = applyVamaConnectCredentials({
-		cfg,
-		accountId,
-		botToken: exchanged.bot_token,
-		webhookSecret: exchanged.webhook_secret,
-		bothubUrl
-	});
-	await runtime.config.replaceConfigFile({
-		nextConfig: updated,
-		afterWrite: { mode: "auto" }
-	});
-	clearProbeCache();
-	const result = {
-		accountId,
-		botId: exchanged.bot_id,
-		username: exchanged.username,
-		displayName: exchanged.display_name,
-		websocketEnabled: exchanged.websocket_enabled === true,
-		bothubUrl,
-		created: exchanged.created
-	};
-	try {
-		const probed = await probe(resolveVamaAccount({
-			cfg: updated,
-			accountId
-		}));
-		result.probeOk = probed.ok;
-		if (!probed.ok) result.probeError = probed.error;
-	} catch (err) {
-		result.probeOk = false;
-		result.probeError = err instanceof Error ? err.message : String(err);
-	}
-	return result;
-}
-function printConnectResult(result) {
-	const botLabel = result.displayName || result.username || result.botId;
-	console.log("");
-	console.log(`✔ Connected to Vama as ${botLabel}${result.username ? ` (@${result.username})` : ""}`);
-	if (result.websocketEnabled) console.log("  Transport: WebSocket — no tunnel or public URL needed.");
-	else console.log("  Transport: webhook — set channels.vama.webhookUrl to a public URL (or mint a new code from Vama settings to enable WebSocket).");
-	if (result.probeOk === false && result.probeError) {
-		console.log(`  Verification warning: ${result.probeError}`);
-		console.log("  Re-check later with: openclaw channels status --probe");
-	}
-	console.log("");
-	console.log("  If your gateway is running it reloads automatically; otherwise start it:");
-	console.log("    openclaw gateway");
-}
-function registerVamaCli({ program }) {
-	program.command("vama").description("Vama channel tools (connect codes, account state)").command("connect").description("Connect this OpenClaw to Vama with a one-time code from Vama settings (Settings → AI Agents)").argument("<code>", "connect code (vmc1_… token or 64-char hex)").option("--bothub-url <url>", "BotHub endpoint override (defaults to the URL embedded in the code)").option("--account <id>", "Vama account id to write credentials to", DEFAULT_ACCOUNT_ID).option("--json", "print the result as JSON", false).action(async (code, opts) => {
-		try {
-			const result = await runVamaConnect({
-				rawCode: code,
-				bothubUrlFlag: opts.bothubUrl,
-				account: opts.account
-			}, { log: opts.json ? () => {} : void 0 });
-			if (opts.json) console.log(JSON.stringify(result, null, 2));
-			else printConnectResult(result);
-		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			if (opts.json) console.log(JSON.stringify({
-				ok: false,
-				error: message
-			}, null, 2));
-			else console.error(`✖ Connect failed: ${message}`);
-			process.exitCode = 1;
-		}
-	});
-}
-//#endregion
-export { registerVamaCli };