@vama/openclaw 2026.5.5

package/dist/client-AsD46gcK.js

@@ -0,0 +1,367 @@
+import { promises } from "node:fs";
+import { basename, extname } from "node:path";
+import { Agent, FormData, fetch } from "undici";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region extensions/vama/src/client.ts
+var client_exports = /* @__PURE__ */ __exportAll({
+	BOTHUB_DEFAULT_URL: () => BOTHUB_DEFAULT_URL,
+	FetchWithRetryError: () => FetchWithRetryError,
+	attachmentHintFromExtension: () => attachmentHintFromExtension,
+	createBotHubClient: () => createBotHubClient,
+	mimeFromExtension: () => mimeFromExtension,
+	provisionBot: () => provisionBot
+});
+/** Canonical BotHub API endpoint. Can be overridden via channels.vama.bothubUrl for self-hosted deployments. */
+const BOTHUB_DEFAULT_URL = "https://bothub.vama.com";
+const botHubDispatcher = new Agent({
+	keepAliveTimeout: 1e4,
+	keepAliveMaxTimeout: 3e4,
+	connectTimeout: 5e3
+});
+/**
+* Thrown by `fetchWithRetry` when all attempts fail. Carries the number
+* of attempts actually made so the caller can log it accurately —
+* previously the catch path hardcoded `attemptsUsed: 3`, which silently
+* broke if anyone passed a non-default `attempts` value or refactored
+* the throw path. Wrapping `cause` matches the convention `request<T>`
+* uses for its own thrown errors.
+*/
+var FetchWithRetryError = class extends Error {
+	constructor(cause, attemptsUsed) {
+		const causeMsg = cause instanceof Error ? cause.message : String(cause);
+		super(causeMsg);
+		this.name = "FetchWithRetryError";
+		this.attemptsUsed = attemptsUsed;
+		this.cause = cause;
+	}
+};
+async function fetchWithRetry(url, init, attempts = 3) {
+	let lastErr;
+	for (let i = 1; i <= attempts; i++) try {
+		return {
+			res: await fetch(url, {
+				...init,
+				dispatcher: botHubDispatcher
+			}),
+			attemptsUsed: i
+		};
+	} catch (err) {
+		lastErr = err;
+		if (i === attempts) throw new FetchWithRetryError(lastErr, i);
+		await new Promise((resolve) => setTimeout(resolve, 200 * i));
+	}
+	throw new FetchWithRetryError(lastErr, attempts);
+}
+/** Truncate to 200 chars and signal it was cut. Used by error log lines
+*  so a reader knows there's more to the body than what's printed. */
+function truncateForLog(text) {
+	return text.length > 200 ? text.slice(0, 200) + "…" : text;
+}
+/**
+* Best-effort extension → MIME map for outbound file uploads. Kept minimal
+* on purpose: the message-service detects the real MIME from magic bytes
+* during upload and overrides whatever we send, so the only thing this
+* affects is the Content-Type header on the multipart Blob — useful for
+* downstream debugging tools and HTTP intermediaries but not load-bearing.
+* Unknown extensions fall through to "application/octet-stream" upstream.
+*/
+function mimeFromExtension(ext) {
+	switch (ext) {
+		case "jpg":
+		case "jpeg": return "image/jpeg";
+		case "png": return "image/png";
+		case "webp": return "image/webp";
+		case "gif": return "image/gif";
+		case "heic": return "image/heic";
+		case "heif": return "image/heif";
+		case "mp4":
+		case "m4v": return "video/mp4";
+		case "mov": return "video/quicktime";
+		case "webm": return "video/webm";
+		case "mp3": return "audio/mpeg";
+		case "m4a":
+		case "aac": return "audio/mp4";
+		case "wav": return "audio/wav";
+		case "ogg":
+		case "opus": return "audio/ogg";
+		case "flac": return "audio/flac";
+		case "pdf": return "application/pdf";
+		case "txt":
+		case "md": return "text/plain";
+		case "json": return "application/json";
+		case "html":
+		case "htm": return "text/html";
+		case "csv": return "text/csv";
+		case "zip": return "application/zip";
+		default: return;
+	}
+}
+/** Map our internal extension hint to BotHub's `attachment_type` enum. */
+function attachmentHintFromExtension(ext) {
+	switch (ext) {
+		case "jpg":
+		case "jpeg":
+		case "png":
+		case "webp":
+		case "heic":
+		case "heif": return "image";
+		case "gif": return "gif";
+		case "mp4":
+		case "mov":
+		case "webm":
+		case "m4v": return "video";
+		case "mp3":
+		case "m4a":
+		case "wav":
+		case "ogg":
+		case "opus":
+		case "flac":
+		case "aac": return "audio";
+		default: return "file";
+	}
+}
+/** Unwrap the inner transport error message from a thrown value, peeling
+*  through `FetchWithRetryError.cause` when present. Shared by the two
+*  transport-error catch paths so the unwrap stays consistent if the
+*  retry-error shape ever changes. */
+function unwrapFetchErrorMsg(err) {
+	const inner = err instanceof FetchWithRetryError ? err.cause : err;
+	return inner instanceof Error ? inner.message : String(inner);
+}
+/** Read the actual `attemptsUsed` from a thrown value. Falls back to 1 for
+*  non-retry errors (e.g. a sync throw before `fetchWithRetry` ran). */
+function attemptsUsedFromError(err) {
+	return err instanceof FetchWithRetryError ? err.attemptsUsed : 1;
+}
+/**
+* Log a single BotHub round-trip with timing, status, retry count and
+* (where applicable) message_id. Shared by `request<T>` (per-message
+* authenticated calls) and `provisionBot` (one-off unauthenticated
+* provisioning) so neither call site is missed.
+*
+* Three severity levels:
+* - error: transport throw OR non-2xx HTTP status
+* - warn: slow success (> 500ms) OR success after a retry
+* - log:  fast happy path
+*/
+function logBothubCall(opts) {
+	const elapsed = Date.now() - opts.start;
+	const retrySuffix = opts.attemptsUsed > 1 ? ` retries=${opts.attemptsUsed - 1}` : "";
+	const idSuffix = opts.messageId ? ` message_id=${opts.messageId}` : "";
+	if (opts.status === null) {
+		console.error(`[bothub] ${opts.method} ${opts.path} TRANSPORT_ERROR ${elapsed}ms${retrySuffix}: ${opts.errorMsg ?? ""}`);
+		return;
+	}
+	if (opts.status < 200 || opts.status >= 300) {
+		console.error(`[bothub] ${opts.method} ${opts.path} ${opts.status} ${elapsed}ms${retrySuffix}: ${truncateForLog(opts.bodyText ?? "")}`);
+		return;
+	}
+	if (elapsed > 500 || opts.attemptsUsed > 1) {
+		console.warn(`[bothub] ${opts.method} ${opts.path} ${opts.status} ${elapsed}ms${retrySuffix}${idSuffix}`);
+		return;
+	}
+	console.log(`[bothub] ${opts.method} ${opts.path} ${opts.status} ${elapsed}ms${idSuffix}`);
+}
+function createBotHubClient(account) {
+	const { botToken, bothubUrl } = account;
+	if (!botToken || !bothubUrl) throw new Error(`Vama account "${account.accountId}" missing botToken or bothubUrl`);
+	const baseUrl = bothubUrl.replace(/\/+$/, "");
+	async function request(method, path, body) {
+		const url = `${baseUrl}${path}`;
+		const headers = {
+			Authorization: `Bot ${botToken}`,
+			"Content-Type": "application/json"
+		};
+		const start = Date.now();
+		let resPair;
+		try {
+			resPair = await fetchWithRetry(url, {
+				method,
+				headers,
+				body: body ? JSON.stringify(body) : void 0
+			});
+		} catch (err) {
+			logBothubCall({
+				method,
+				path,
+				start,
+				status: null,
+				attemptsUsed: attemptsUsedFromError(err),
+				errorMsg: unwrapFetchErrorMsg(err)
+			});
+			throw err;
+		}
+		const { res, attemptsUsed } = resPair;
+		if (!res.ok) {
+			const text = await res.text().catch(() => "");
+			logBothubCall({
+				method,
+				path,
+				start,
+				status: res.status,
+				attemptsUsed,
+				bodyText: text
+			});
+			throw new Error(`BotHub API ${method} ${path} failed (${res.status}): ${text}`);
+		}
+		const json = await res.json();
+		const messageId = typeof json === "object" && json !== null && "message_id" in json ? json.message_id : void 0;
+		logBothubCall({
+			method,
+			path,
+			start,
+			status: res.status,
+			attemptsUsed,
+			messageId: typeof messageId === "string" ? messageId : void 0
+		});
+		return json;
+	}
+	return {
+		async sendMessage(params) {
+			const body = { text: params.text };
+			if (params.channelId) body.channel_id = params.channelId;
+			if (params.userId) body.user_id = params.userId;
+			if (params.parentId) body.parent_id = params.parentId;
+			if (params.idempotencyKey) body.idempotency_key = params.idempotencyKey;
+			return request("POST", "/v1/bot/messages", body);
+		},
+		async sendTyping(params) {
+			await request("POST", "/v1/bot/typing", { channel_id: params.channelId });
+		},
+		async sendFile(params) {
+			const path = "/v1/bot/messages/file";
+			const url = `${baseUrl}${path}`;
+			let bytes;
+			try {
+				bytes = await promises.readFile(params.path);
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				throw new Error(`Vama sendFile: failed to read ${params.path}: ${msg}`, { cause: err });
+			}
+			const fileName = params.fileName ?? basename(params.path) ?? "attachment";
+			const ext = extname(fileName).replace(/^\./, "").toLowerCase();
+			const contentType = params.contentType ?? mimeFromExtension(ext) ?? "application/octet-stream";
+			const form = new FormData();
+			form.append("file", new Blob([bytes], { type: contentType }), fileName);
+			if (params.channelId) form.append("channel_id", params.channelId);
+			if (params.userId) form.append("user_id", params.userId);
+			if (params.caption !== void 0 && params.caption !== "") form.append("caption", params.caption);
+			if (params.parentId) form.append("parent_id", params.parentId);
+			if (params.idempotencyKey) form.append("idempotency_key", params.idempotencyKey);
+			if (params.attachmentType) form.append("attachment_type", params.attachmentType);
+			const start = Date.now();
+			let resPair;
+			try {
+				resPair = await fetchWithRetry(url, {
+					method: "POST",
+					headers: { Authorization: `Bot ${botToken}` },
+					body: form
+				});
+			} catch (err) {
+				logBothubCall({
+					method: "POST",
+					path,
+					start,
+					status: null,
+					attemptsUsed: attemptsUsedFromError(err),
+					errorMsg: unwrapFetchErrorMsg(err)
+				});
+				throw err;
+			}
+			const { res, attemptsUsed } = resPair;
+			if (!res.ok) {
+				const text = await res.text().catch(() => "");
+				logBothubCall({
+					method: "POST",
+					path,
+					start,
+					status: res.status,
+					attemptsUsed,
+					bodyText: text
+				});
+				throw new Error(`BotHub API POST ${path} failed (${res.status}): ${text}`);
+			}
+			const json = await res.json();
+			logBothubCall({
+				method: "POST",
+				path,
+				start,
+				status: res.status,
+				attemptsUsed,
+				messageId: json.message_id
+			});
+			return json;
+		},
+		async getMe() {
+			return request("GET", "/v1/bot/me");
+		},
+		async registerWebhook(params) {
+			return request("PUT", "/v1/bot/webhook", { url: params.url });
+		}
+	};
+}
+/**
+* Provision a new bot via the BotHub provisioning API (unauthenticated).
+*/
+async function provisionBot(params) {
+	const baseUrl = params.bothubUrl.replace(/\/+$/, "");
+	const body = {
+		target_username: params.targetUsername,
+		platform: params.platform ?? "openclaw"
+	};
+	if (params.displayName) body.display_name = params.displayName;
+	const path = "/v1/provision/create";
+	const start = Date.now();
+	let resPair;
+	try {
+		resPair = await fetchWithRetry(`${baseUrl}${path}`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body)
+		});
+	} catch (err) {
+		logBothubCall({
+			method: "POST",
+			path,
+			start,
+			status: null,
+			attemptsUsed: attemptsUsedFromError(err),
+			errorMsg: unwrapFetchErrorMsg(err)
+		});
+		throw err;
+	}
+	const { res, attemptsUsed } = resPair;
+	if (!res.ok) {
+		const text = await res.text().catch(() => "");
+		logBothubCall({
+			method: "POST",
+			path,
+			start,
+			status: res.status,
+			attemptsUsed,
+			bodyText: text
+		});
+		throw new Error(`BotHub provisioning failed (${res.status}): ${text}`);
+	}
+	logBothubCall({
+		method: "POST",
+		path,
+		start,
+		status: res.status,
+		attemptsUsed
+	});
+	return await res.json();
+}
+//#endregion
+export { provisionBot as a, createBotHubClient as i, attachmentHintFromExtension as n, client_exports as r, BOTHUB_DEFAULT_URL as t };

package/dist/index.js

@@ -0,0 +1,55 @@
+import { n as monitorVamaProvider, r as sendMessageVama, t as probeVama } from "./probe-B2hFOc2Y.js";
+import { n as setVamaRuntime } from "./runtime-w-1oL50p.js";
+import { t as registerVamaSubagentKeepaliveHooks } from "./api-C0vtNv5b.js";
+import { t as vamaPlugin } from "./channel-plugin-api-CcZ_y9pT.js";
+import "./runtime-api.js";
+//#region extensions/vama/index.ts
+const channelEntry = {
+	kind: "bundled-channel-entry",
+	id: "vama",
+	name: "Vama",
+	description: "Vama channel plugin via BotHub",
+	configSchema: {
+		schema: {
+			type: "object",
+			additionalProperties: false,
+			properties: {}
+		},
+		runtime: { safeParse(value) {
+			if (value === void 0) return {
+				success: true,
+				data: void 0
+			};
+			if (!value || typeof value !== "object" || Array.isArray(value)) return {
+				success: false,
+				issues: [{
+					path: [],
+					message: "expected config object"
+				}]
+			};
+			if (Object.keys(value).length > 0) return {
+				success: false,
+				issues: [{
+					path: [],
+					message: "config must be empty"
+				}]
+			};
+			return {
+				success: true,
+				data: value
+			};
+		} }
+	},
+	register(api) {
+		if (api.registrationMode === "cli-metadata") return;
+		setVamaRuntime(api.runtime);
+		api.registerChannel({ plugin: vamaPlugin });
+		registerVamaSubagentKeepaliveHooks(api);
+	},
+	loadChannelPlugin: () => vamaPlugin,
+	setChannelRuntime: (runtime) => {
+		setVamaRuntime(runtime);
+	}
+};
+//#endregion
+export { channelEntry as default, monitorVamaProvider, probeVama, sendMessageVama, vamaPlugin };