@vama/openclaw 2026.5.5-7 → 2026.5.5-8

package/dist/{api-CBt1Mjce.js → api-BrUg_tjH.js}

@@ -3,7 +3,7 @@ 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");
+		const { registerVamaCli } = await import("./cli-Cvvx81W1.js");
 		registerVamaCli({ program });
 	}, { descriptors: [{
 		name: "vama",

package/dist/api.js

@@ -1,4 +1,4 @@
-import { n as registerVamaCliMetadata, t as registerVamaSubagentKeepaliveHooks } from "./api-CBt1Mjce.js";
+import { n as registerVamaCliMetadata, t as registerVamaSubagentKeepaliveHooks } from "./api-BrUg_tjH.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/{cli-uxMxzdnO.js → cli-Cvvx81W1.js}

@@ -4,8 +4,10 @@ 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";
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
 //#region extensions/vama/src/connect-verify.ts
+const execFileAsync = promisify(execFile);
 /**
 * Post-connect verification: make `openclaw vama connect` end with a TRUE
 * statement about liveness instead of "credentials look right, good luck".
@@ -134,6 +136,86 @@ async function ensureGatewayRunning(params, deps = {}) {
 		detail: (install.output || start.output).split("\n").slice(-4).join("\n").trim() || void 0
 	};
 }
+/** lsof-based lookup of whoever LISTENs on the gateway port (POSIX only). */
+async function findGatewayPortOwner(port) {
+	try {
+		const { stdout } = await execFileAsync("lsof", [
+			"-ti",
+			`tcp:${port}`,
+			"-sTCP:LISTEN"
+		], { timeout: 5e3 });
+		const pid = Number.parseInt(stdout.trim().split("\n")[0] ?? "", 10);
+		if (!Number.isInteger(pid) || pid <= 0) return null;
+		const { stdout: comm } = await execFileAsync("ps", [
+			"-p",
+			String(pid),
+			"-o",
+			"comm="
+		], { timeout: 5e3 });
+		return {
+			pid,
+			command: comm.trim()
+		};
+	} catch {
+		return null;
+	}
+}
+const OPENCLAW_PROCESS_RE = /openclaw|node|bun/i;
+/**
+* Kill a wedged gateway process squatting the port. Real-world case (seen on
+* a user machine): a days-old `openclaw gateway run` whose HTTP side still
+* answers /health but whose WS stack hangs up every connection — config
+* reloads can't reach it, and it never dials BotHub. Killing it is the only
+* way to one-step that machine. Refuses to touch processes that don't look
+* like an OpenClaw/Node gateway.
+*/
+async function killStaleGateway(port, deps = {}) {
+	const findOwner = deps.findOwner ?? findGatewayPortOwner;
+	const probe = deps.probe ?? isGatewayUp;
+	const sleep = deps.sleep ?? defaultSleep;
+	const kill = deps.kill ?? ((pid, signal) => process.kill(pid, signal));
+	const owner = await findOwner(port);
+	if (!owner) return {
+		killed: false,
+		reason: `could not identify the process on port ${port}`
+	};
+	if (!OPENCLAW_PROCESS_RE.test(owner.command)) return {
+		killed: false,
+		pid: owner.pid,
+		reason: `port ${port} is held by "${owner.command}" (pid ${owner.pid}), which does not look like an OpenClaw gateway — not touching it`
+	};
+	try {
+		kill(owner.pid, "SIGTERM");
+	} catch (err) {
+		return {
+			killed: false,
+			pid: owner.pid,
+			reason: err instanceof Error ? err.message : String(err)
+		};
+	}
+	for (let i = 0; i < 8; i += 1) {
+		await sleep(500);
+		if (!await probe(port)) return {
+			killed: true,
+			pid: owner.pid
+		};
+	}
+	try {
+		kill(owner.pid, "SIGKILL");
+	} catch {}
+	for (let i = 0; i < 4; i += 1) {
+		await sleep(500);
+		if (!await probe(port)) return {
+			killed: true,
+			pid: owner.pid
+		};
+	}
+	return {
+		killed: false,
+		pid: owner.pid,
+		reason: `process ${owner.pid} survived SIGTERM+SIGKILL or the port did not free up`
+	};
+}
 /**
 * 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) —
@@ -233,6 +315,7 @@ async function runVamaConnect(params, deps = {}) {
 	const probe = deps.probe ?? probeVama;
 	const ensureGateway = deps.ensureGateway ?? ensureGatewayRunning;
 	const waitForLive = deps.waitForLive ?? waitForWSConnected;
+	const killStale = deps.killStale ?? killStaleGateway;
 	const log = deps.log ?? ((msg) => console.log(msg));
 	const parsed = parseVamaConnectCode(params.rawCode);
 	const runtime = getVamaRuntime();
@@ -282,8 +365,9 @@ async function runVamaConnect(params, deps = {}) {
 		result.liveCheck = "skipped";
 		return result;
 	}
+	const port = resolveGatewayPort(updated);
 	const gateway = await ensureGateway({
-		port: resolveGatewayPort(updated),
+		port,
 		log
 	});
 	result.gatewayAction = gateway.action;
@@ -298,10 +382,30 @@ async function runVamaConnect(params, deps = {}) {
 		return result;
 	}
 	log("Waiting for your agent to come online…");
-	const live = await waitForLive({
+	let live = await waitForLive({
 		bothubUrl,
 		botToken: exchanged.bot_token
 	});
+	if (live.status !== "live" && live.status !== "unsupported" && gateway.action === "already-running") {
+		log("A gateway is running but never connected to Vama — replacing it…");
+		const killed = await killStale(port);
+		if (killed.killed) {
+			result.staleGatewayKilled = true;
+			const retry = await ensureGateway({
+				port,
+				log
+			});
+			result.gatewayAction = retry.action;
+			if (retry.detail) result.gatewayDetail = retry.detail;
+			if (retry.up) {
+				log("Waiting for your agent to come online…");
+				live = await waitForLive({
+					bothubUrl,
+					botToken: exchanged.bot_token
+				});
+			}
+		} else if (killed.reason) result.gatewayDetail = killed.reason;
+	}
 	result.liveCheck = live.status;
 	result.live = live.status === "live";
 	if (live.error) result.liveError = live.error;
@@ -321,6 +425,7 @@ function printConnectResult(result) {
 	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.staleGatewayKilled) console.log("  Replaced a stale gateway process that was holding the port.");
 	if (result.probeOk === false && result.probeError) console.log(`  Verification warning: ${result.probeError}`);
 	console.log("");
 	if (result.live) {
@@ -347,6 +452,7 @@ function printConnectResult(result) {
 		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}`);
+			if (result.gatewayDetail) console.log(`  ${result.gatewayDetail}`);
 			console.log("  It may just be slow. Check again with: openclaw channels status --probe");
 			console.log("  Gateway logs: openclaw gateway status");
 			return;

package/dist/index.js

@@ -1,4 +1,4 @@
-import { n as registerVamaCliMetadata, t as registerVamaSubagentKeepaliveHooks } from "./api-CBt1Mjce.js";
+import { n as registerVamaCliMetadata, t as registerVamaSubagentKeepaliveHooks } from "./api-BrUg_tjH.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";

package/package.json

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