@vama/openclaw 2026.5.5-5 → 2026.5.5-6

package/api.ts

@@ -0,0 +1,5 @@
+export { registerVamaCliMetadata } from "./src/cli-metadata.js";
+export { monitorVamaProvider } from "./src/monitor.js";
+export { probeVama } from "./src/probe.js";
+export { sendMessageVama } from "./src/send.js";
+export { registerVamaSubagentKeepaliveHooks } from "./src/subagent-keepalive-hooks.js";

package/channel-plugin-api.ts

@@ -0,0 +1 @@
+export { vamaPlugin } from "./src/channel.js";

package/index.ts

@@ -0,0 +1,88 @@
+import type {
+  BundledChannelEntryContract,
+  OpenClawPluginApi,
+} from "openclaw/plugin-sdk/channel-entry-contract";
+// Entry files must not import "./src/" statically (bundled.shape-guard);
+// root-level barrels like ./api.js are the sanctioned indirection.
+import { registerVamaCliMetadata, registerVamaSubagentKeepaliveHooks } from "./api.js";
+import { vamaPlugin } from "./channel-plugin-api.js";
+import { setVamaRuntime } from "./runtime-api.js";
+import type { PluginRuntime } from "./runtime-api.js";
+
+export { monitorVamaProvider, probeVama, sendMessageVama } from "./api.js";
+export { vamaPlugin } from "./channel-plugin-api.js";
+
+// We satisfy the bundled-channel-entry contract shape so the runtime loader
+// (src/plugins/loader.ts → resolveBundledRuntimeChannelRegistration) and the
+// build-time smoke check (scripts/test-built-bundled-channel-entry-smoke.mjs)
+// both accept us, but we deliberately bypass `defineBundledChannelEntry`.
+//
+// Why: the generic bundled-entry helper resolves `runtime.specifier` through
+// `loadBundledEntryExportSync`, which uses jiti to load runtime-api.js as a
+// SEPARATE module instance from the one vamaPlugin (loaded via normal ESM
+// `import` from ./src/channel.js) imports. setVamaRuntime() then writes to
+// the jiti copy of `_runtime`; vamaPlugin reads from the ESM copy and finds
+// undefined → "Vama runtime not initialized" on every webhook delivery.
+//
+// By importing vamaPlugin and setVamaRuntime directly here, we keep them in
+// the same module instance as the channel handlers, so the runtime setter
+// and reader share state. This is the same pattern that worked through
+// 2026.4.15-1; only the wrapper around it has changed.
+const channelEntry: BundledChannelEntryContract = {
+  kind: "bundled-channel-entry",
+  id: "vama",
+  name: "Vama",
+  description: "Vama channel plugin via BotHub",
+  // Inlined empty channel config schema: vama takes no plugin config,
+  // and we hand-roll the contract object (rather than calling
+  // emptyChannelConfigSchema()) to keep this entry self-contained for
+  // the same module-identity reasons that drive the bypass above.
+  configSchema: {
+    schema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {},
+    },
+    runtime: {
+      safeParse(value: unknown) {
+        if (value === undefined) {
+          return { success: true, data: undefined };
+        }
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+          return {
+            success: false,
+            issues: [{ path: [], message: "expected config object" }],
+          };
+        }
+        if (Object.keys(value as Record<string, unknown>).length > 0) {
+          return {
+            success: false,
+            issues: [{ path: [], message: "config must be empty" }],
+          };
+        }
+        return { success: true, data: value };
+      },
+    },
+  },
+  register(api: OpenClawPluginApi) {
+    const mode = api.registrationMode as string;
+    if (mode === "cli-metadata") {
+      registerVamaCliMetadata(api);
+      return;
+    }
+    setVamaRuntime(api.runtime);
+    api.registerChannel({ plugin: vamaPlugin });
+    registerVamaSubagentKeepaliveHooks(api);
+    // Match defineBundledChannelEntry's mode handling: CLI surfaces register
+    // in discovery + full, but not tool-discovery.
+    if (mode === "discovery" || mode === "full") {
+      registerVamaCliMetadata(api);
+    }
+  },
+  loadChannelPlugin: () => vamaPlugin,
+  setChannelRuntime: (runtime: PluginRuntime) => {
+    setVamaRuntime(runtime);
+  },
+};
+
+export default channelEntry;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vama/openclaw",
-  "version": "2026.5.5-5",
+  "version": "2026.5.5-6",
   "description": "OpenClaw Vama channel plugin via BotHub",
   "homepage": "https://web.vama.com/connect-guide",
   "repository": {
@@ -39,22 +39,6 @@
     "release": {
       "publishToNpm": true,
       "publishToClawHub": true
-    },
-    "runtimeExtensions": [
-      "./dist/index.js"
-    ]
-  },
-  "files": [
-    "dist/**",
-    "openclaw.plugin.json",
-    "README.md"
-  ],
-  "peerDependencies": {
-    "openclaw": ">=2026.5.12"
-  },
-  "peerDependenciesMeta": {
-    "openclaw": {
-      "optional": true
     }
   }
 }

package/runtime-api.ts

@@ -0,0 +1,2 @@
+export { setVamaRuntime } from "./src/runtime.js";
+export type { PluginRuntime } from "./src/host-sdk.js";

package/src/accounts.test.ts

@@ -0,0 +1,236 @@
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
+import type { ClawdbotConfig } from "openclaw/plugin-sdk/vama";
+import { describe, expect, it } from "vitest";
+import {
+  listEnabledVamaAccounts,
+  listVamaAccountIds,
+  resolveDefaultVamaAccountId,
+  resolveVamaAccount,
+} from "./accounts.js";
+
+function makeCfg(vama?: Record<string, unknown>): ClawdbotConfig {
+  return { channels: { vama } } as ClawdbotConfig;
+}
+
+describe("listVamaAccountIds", () => {
+  it("returns DEFAULT_ACCOUNT_ID when no accounts configured", () => {
+    expect(listVamaAccountIds(makeCfg({ enabled: true }))).toEqual([DEFAULT_ACCOUNT_ID]);
+  });
+
+  it("returns DEFAULT_ACCOUNT_ID when channels.vama is missing", () => {
+    expect(listVamaAccountIds({} as ClawdbotConfig)).toEqual([DEFAULT_ACCOUNT_ID]);
+  });
+
+  it("returns sorted account IDs when accounts are configured", () => {
+    const cfg = makeCfg({
+      accounts: {
+        beta: { botToken: "t2" },
+        alpha: { botToken: "t1" },
+      },
+    });
+    expect(listVamaAccountIds(cfg)).toEqual(["alpha", "beta"]);
+  });
+
+  it("filters empty account keys", () => {
+    const cfg = makeCfg({
+      accounts: {
+        "": { botToken: "t1" },
+        valid: { botToken: "t2" },
+      },
+    });
+    expect(listVamaAccountIds(cfg)).toEqual(["valid"]);
+  });
+});
+
+describe("resolveDefaultVamaAccountId", () => {
+  it("returns DEFAULT_ACCOUNT_ID for single-account config", () => {
+    expect(resolveDefaultVamaAccountId(makeCfg({ enabled: true }))).toBe(DEFAULT_ACCOUNT_ID);
+  });
+
+  it("returns first sorted account when no default exists", () => {
+    const cfg = makeCfg({ accounts: { zulu: {}, alpha: {} } });
+    expect(resolveDefaultVamaAccountId(cfg)).toBe("alpha");
+  });
+});
+
+describe("resolveVamaAccount", () => {
+  it("resolves default single-account config", () => {
+    const cfg = makeCfg({
+      enabled: true,
+      botToken: "tok-123",
+      bothubUrl: "https://bothub.example.com",
+      webhookSecret: "secret-abc",
+    });
+    const account = resolveVamaAccount({ cfg });
+    expect(account.accountId).toBe(DEFAULT_ACCOUNT_ID);
+    expect(account.enabled).toBe(true);
+    expect(account.configured).toBe(true);
+    expect(account.botToken).toBe("tok-123");
+    expect(account.bothubUrl).toBe("https://bothub.example.com");
+    expect(account.webhookSecret).toBe("secret-abc");
+  });
+
+  it("reports not configured when botToken is missing", () => {
+    const cfg = makeCfg({ enabled: true, bothubUrl: "https://bothub.example.com" });
+    const account = resolveVamaAccount({ cfg });
+    expect(account.configured).toBe(false);
+  });
+
+  it("surfaces webhookSecretFile alongside webhookSecret", () => {
+    // Both fields can coexist — monitor resolver prefers the file
+    // (warm-pool hot-swap path). Pre-PR-F configs that only set
+    // webhookSecret continue to work unchanged.
+    const cfg = makeCfg({
+      enabled: true,
+      botToken: "tok",
+      webhookSecret: "literal-fallback",
+      webhookSecretFile: "/etc/openclaw/vama-secret",
+    });
+    const account = resolveVamaAccount({ cfg });
+    expect(account.webhookSecret).toBe("literal-fallback");
+    expect(account.webhookSecretFile).toBe("/etc/openclaw/vama-secret");
+  });
+
+  it("trims webhookSecretFile and treats empty as undefined", () => {
+    // Whitespace-only file paths must collapse to undefined so the
+    // monitor's optional-resolver branch behaves correctly. Otherwise
+    // a misconfigured deployment could end up calling fs.statSync("")
+    // and getting an ENOENT on every webhook.
+    const cfg = makeCfg({
+      enabled: true,
+      botToken: "tok",
+      webhookSecretFile: "   ",
+    });
+    const account = resolveVamaAccount({ cfg });
+    expect(account.webhookSecretFile).toBeUndefined();
+  });
+
+  it("round-trips webhookUrl and treats empty/whitespace as unset", () => {
+    // Empty string must collapse to undefined: the Vama app's config
+    // snippet ships `"webhookUrl": ""` as a visible fill-me-in
+    // placeholder, which must NOT trigger a registration attempt.
+    const set = resolveVamaAccount({
+      cfg: makeCfg({
+        enabled: true,
+        botToken: "tok",
+        webhookUrl: "https://claw.example.com/vama/events",
+      }),
+    });
+    expect(set.webhookUrl).toBe("https://claw.example.com/vama/events");
+
+    const empty = resolveVamaAccount({
+      cfg: makeCfg({ enabled: true, botToken: "tok", webhookUrl: "  " }),
+    });
+    expect(empty.webhookUrl).toBeUndefined();
+  });
+
+  it("account-level webhookUrl overrides base", () => {
+    const cfg = makeCfg({
+      enabled: true,
+      botToken: "tok",
+      webhookUrl: "https://base.example.com/vama/events",
+      accounts: {
+        staging: { webhookUrl: "https://staging.example.com/vama/events" },
+      },
+    });
+    const account = resolveVamaAccount({ cfg, accountId: "staging" });
+    expect(account.webhookUrl).toBe("https://staging.example.com/vama/events");
+  });
+
+  it("is configured when only botToken is set (bothubUrl defaults to canonical)", () => {
+    const cfg = makeCfg({ enabled: true, botToken: "tok" });
+    const account = resolveVamaAccount({ cfg });
+    expect(account.configured).toBe(true);
+    expect(account.bothubUrl).toBe("https://bothub.vama.com");
+  });
+
+  it("treats whitespace-only credentials as missing", () => {
+    const cfg = makeCfg({ enabled: true, botToken: "  ", bothubUrl: "  " });
+    const account = resolveVamaAccount({ cfg });
+    expect(account.configured).toBe(false);
+    expect(account.botToken).toBeUndefined();
+    // bothubUrl falls back to the canonical default even when config is whitespace-only
+    expect(account.bothubUrl).toBe("https://bothub.vama.com");
+  });
+
+  it("merges named account config over base", () => {
+    const cfg = makeCfg({
+      enabled: true,
+      botToken: "base-token",
+      bothubUrl: "https://base.example.com",
+      accounts: {
+        staging: {
+          botToken: "staging-token",
+          bothubUrl: "https://staging.example.com",
+          name: "Staging Bot",
+        },
+      },
+    });
+    const account = resolveVamaAccount({ cfg, accountId: "staging" });
+    expect(account.accountId).toBe("staging");
+    expect(account.botToken).toBe("staging-token");
+    expect(account.bothubUrl).toBe("https://staging.example.com");
+    expect(account.name).toBe("Staging Bot");
+    expect(account.configured).toBe(true);
+  });
+
+  it("inherits base config when account does not override", () => {
+    const cfg = makeCfg({
+      enabled: true,
+      botToken: "base-token",
+      bothubUrl: "https://base.example.com",
+      accounts: {
+        minimal: { name: "Minimal" },
+      },
+    });
+    const account = resolveVamaAccount({ cfg, accountId: "minimal" });
+    expect(account.botToken).toBe("base-token");
+    expect(account.bothubUrl).toBe("https://base.example.com");
+    expect(account.name).toBe("Minimal");
+  });
+
+  it("disabled when base is disabled", () => {
+    const cfg = makeCfg({
+      enabled: false,
+      botToken: "tok",
+      bothubUrl: "https://bothub.example.com",
+    });
+    const account = resolveVamaAccount({ cfg });
+    expect(account.enabled).toBe(false);
+  });
+
+  it("disabled when account is disabled", () => {
+    const cfg = makeCfg({
+      enabled: true,
+      accounts: {
+        off: { enabled: false, botToken: "tok", bothubUrl: "https://bothub.example.com" },
+      },
+    });
+    const account = resolveVamaAccount({ cfg, accountId: "off" });
+    expect(account.enabled).toBe(false);
+  });
+
+  it("normalizes null accountId to default", () => {
+    const cfg = makeCfg({ enabled: true, botToken: "tok", bothubUrl: "https://b.com" });
+    const account = resolveVamaAccount({ cfg, accountId: null });
+    expect(account.accountId).toBe(DEFAULT_ACCOUNT_ID);
+  });
+});
+
+describe("listEnabledVamaAccounts", () => {
+  it("returns only enabled and configured accounts", () => {
+    const cfg = makeCfg({
+      enabled: true,
+      accounts: {
+        good: { botToken: "tok2", bothubUrl: "https://b2.com" },
+        disabled: { enabled: false, botToken: "tok3", bothubUrl: "https://b3.com" },
+        unconfigured: { name: "no creds" },
+      },
+    });
+    const accounts = listEnabledVamaAccounts(cfg);
+    const ids = accounts.map((a) => a.accountId);
+    expect(ids).toContain("good");
+    expect(ids).not.toContain("disabled");
+    expect(ids).not.toContain("unconfigured");
+  });
+});

package/src/accounts.ts

@@ -0,0 +1,96 @@
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import { BOTHUB_DEFAULT_URL } from "./client.js";
+import type { ClawdbotConfig } from "./host-sdk.js";
+import type { VamaConfig, VamaAccountConfig, ResolvedVamaAccount } from "./types.js";
+
+function listConfiguredAccountIds(cfg: ClawdbotConfig): string[] {
+  const accounts = (cfg.channels?.vama as VamaConfig)?.accounts;
+  if (!accounts || typeof accounts !== "object") {
+    return [];
+  }
+  return Object.keys(accounts).filter(Boolean);
+}
+
+export function listVamaAccountIds(cfg: ClawdbotConfig): string[] {
+  const ids = listConfiguredAccountIds(cfg);
+  if (ids.length === 0) {
+    return [DEFAULT_ACCOUNT_ID];
+  }
+  return [...ids].toSorted((a, b) => a.localeCompare(b));
+}
+
+export function resolveDefaultVamaAccountId(cfg: ClawdbotConfig): string {
+  const ids = listVamaAccountIds(cfg);
+  if (ids.includes(DEFAULT_ACCOUNT_ID)) {
+    return DEFAULT_ACCOUNT_ID;
+  }
+  return ids[0] ?? DEFAULT_ACCOUNT_ID;
+}
+
+function resolveAccountConfig(
+  cfg: ClawdbotConfig,
+  accountId: string,
+): VamaAccountConfig | undefined {
+  const accounts = (cfg.channels?.vama as VamaConfig)?.accounts;
+  if (!accounts || typeof accounts !== "object") {
+    return undefined;
+  }
+  return accounts[accountId];
+}
+
+function mergeVamaAccountConfig(cfg: ClawdbotConfig, accountId: string): VamaConfig {
+  const vamaCfg = cfg.channels?.vama as VamaConfig | undefined;
+  const { accounts: _ignored, ...base } = vamaCfg ?? {};
+  const account = resolveAccountConfig(cfg, accountId) ?? {};
+  return { ...base, ...account } as VamaConfig;
+}
+
+export function resolveVamaAccount(params: {
+  cfg: ClawdbotConfig;
+  accountId?: string | null;
+}): ResolvedVamaAccount {
+  const accountId = normalizeAccountId(params.accountId);
+  const vamaCfg = params.cfg.channels?.vama as VamaConfig | undefined;
+
+  const baseEnabled = vamaCfg?.enabled !== false;
+  const merged = mergeVamaAccountConfig(params.cfg, accountId);
+  const accountEnabled = merged.enabled !== false;
+  const enabled = baseEnabled && accountEnabled;
+
+  const botToken = merged.botToken?.trim() || undefined;
+  const webhookSecret = merged.webhookSecret?.trim() || undefined;
+  const webhookSecretFile = merged.webhookSecretFile?.trim() || undefined;
+  // Fall back to the canonical BotHub endpoint; overridable for self-hosted deployments.
+  const bothubUrl = merged.bothubUrl?.trim() || BOTHUB_DEFAULT_URL;
+  // Empty string is treated as unset so config templates can ship the key
+  // as a visible "fill me in" placeholder without triggering registration.
+  const webhookUrl = merged.webhookUrl?.trim() || undefined;
+  // Unknown values fall back to undefined (= "auto") rather than erroring:
+  // a typo'd transport must never take the channel down.
+  const rawTransport = merged.transport?.trim();
+  const transport =
+    rawTransport === "auto" || rawTransport === "webhook" || rawTransport === "websocket"
+      ? rawTransport
+      : undefined;
+  const configured = Boolean(botToken);
+
+  return {
+    accountId,
+    enabled,
+    configured,
+    name: (merged as VamaAccountConfig).name?.trim() || undefined,
+    botToken,
+    webhookSecret,
+    webhookSecretFile,
+    bothubUrl,
+    webhookUrl,
+    transport,
+    config: merged,
+  };
+}
+
+export function listEnabledVamaAccounts(cfg: ClawdbotConfig): ResolvedVamaAccount[] {
+  return listVamaAccountIds(cfg)
+    .map((accountId) => resolveVamaAccount({ cfg, accountId }))
+    .filter((account) => account.enabled && account.configured);
+}