omnivibe-openclaw-plugin 0.1.0

package/dist/channel.js

@@ -0,0 +1,321 @@
+import { ApiClient } from "./api-client.js";
+import { SSEBridge } from "./bridge.js";
+import { getOmniVibeRuntime } from "./runtime.js";
+const DEFAULT_ACCOUNT_ID = "default";
+/**
+ * Dispatch an inbound OmniVibe message into OpenClaw's channel routing system.
+ * Follows the same pattern as BotCord's dispatchInbound.
+ */
+async function dispatchOmniVibeInbound(params) {
+    const core = getOmniVibeRuntime();
+    if (!core?.channel?.routing) {
+        params.ctx.log?.warn?.("[OmniVibe] Runtime channel routing not available — cannot dispatch inbound");
+        return;
+    }
+    const { cfg, accountId, envelope } = params;
+    const senderId = envelope.sender.id;
+    const senderName = envelope.sender.name || senderId;
+    const channelId = typeof envelope.target?.id === "string"
+        ? envelope.target.id.replace(/^omnivibe:/, "")
+        : "";
+    const chatType = envelope.target?.kind === "group" ? "group" : "direct";
+    const route = core.channel.routing.resolveAgentRoute({
+        cfg,
+        channel: "omnivibe",
+        accountId,
+        peer: {
+            kind: chatType,
+            id: chatType === "group" ? channelId : senderId,
+        },
+    });
+    const sessionKey = route.sessionKey || `omnivibe:${channelId}:${senderId}`;
+    const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
+    const formattedBody = core.channel.reply.formatAgentEnvelope({
+        channel: "OmniVibe",
+        from: senderName,
+        timestamp: new Date(envelope.timestamp || Date.now()),
+        envelope: envelopeOptions,
+        body: envelope.text,
+    });
+    const ctxPayload = core.channel.reply.finalizeInboundContext({
+        Body: formattedBody,
+        BodyForAgent: envelope.text,
+        RawBody: envelope.text,
+        CommandBody: envelope.text,
+        From: `omnivibe:${senderId}`,
+        To: `omnivibe:${accountId}`,
+        SessionKey: sessionKey,
+        AccountId: accountId,
+        ChatType: chatType,
+        GroupSubject: chatType === "group" ? channelId : undefined,
+        SenderName: senderName,
+        SenderId: senderId,
+        Provider: "omnivibe",
+        Surface: "omnivibe",
+        MessageSid: `omnivibe-${Date.now()}`,
+        Timestamp: Date.now(),
+        // OmniVibe agents respond to all messages in channels they joined
+        WasMentioned: true,
+        CommandAuthorized: true,
+        OriginatingChannel: "omnivibe",
+        OriginatingTo: `omnivibe:${accountId}`,
+        ConversationLabel: chatType === "group" ? channelId : senderName,
+    });
+    await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+        ctx: ctxPayload,
+        cfg,
+        dispatcherOptions: {
+            deliver: async (payload) => {
+                // Auto-deliver reply back to the same OmniVibe channel
+                // OpenClaw passes either a string or {text, replyToId, ...}
+                const text = typeof payload === "string" ? payload : payload?.text ?? String(payload);
+                const account = resolveOmniVibeAccount({ cfg, accountId });
+                const client = new ApiClient(account.apiKey, account.baseUrl);
+                await client.post(`/v1/channels/${channelId}/messages`, {
+                    content: text,
+                    message_type: "text",
+                });
+            },
+            onError: (err, info) => {
+                console.error(`[omnivibe] ${info?.kind ?? "unknown"} reply error:`, err);
+            },
+        },
+        replyOptions: {},
+    });
+}
+export function resolveOmniVibeAccount(params) {
+    const channelCfg = params.cfg?.channels?.omnivibe || {};
+    const apiKey = channelCfg.apiKey || "";
+    return {
+        accountId: params.accountId || DEFAULT_ACCOUNT_ID,
+        name: "OmniVibe",
+        enabled: channelCfg.enabled !== false,
+        configured: !!apiKey,
+        apiKey,
+        baseUrl: (channelCfg.baseUrl || "https://api.omnivibe.me").replace(/\/+$/, ""),
+        dmPolicy: channelCfg.dmPolicy || "open",
+        autoJoinChannels: channelCfg.autoJoinChannels || [],
+    };
+}
+// Track active bridges per account
+const activeBridges = new Map();
+const omniVibeConfigSchema = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        enabled: { type: "boolean" },
+        apiKey: { type: "string" },
+        baseUrl: { type: "string" },
+        dmPolicy: { type: "string", enum: ["open", "disabled"] },
+        autoJoinChannels: {
+            type: "array",
+            items: { type: "string" },
+        },
+    },
+};
+export const omnivibePlugin = {
+    id: "omnivibe",
+    meta: {
+        id: "omnivibe",
+        label: "OmniVibe",
+        selectionLabel: "OmniVibe (Agent Workspace)",
+        blurb: "Trusted workspace for the agent internet — channels, memory, trust, and payments for AI agents.",
+        order: 120,
+    },
+    capabilities: {
+        chatTypes: ["direct", "group"],
+        media: false,
+        blockStreaming: false,
+    },
+    reload: { configPrefixes: ["channels.omnivibe"] },
+    configSchema: {
+        schema: omniVibeConfigSchema,
+    },
+    config: {
+        listAccountIds: (cfg) => {
+            return cfg?.channels?.omnivibe ? [DEFAULT_ACCOUNT_ID] : [];
+        },
+        resolveAccount: (cfg, accountId) => {
+            return resolveOmniVibeAccount({ cfg, accountId });
+        },
+        defaultAccountId: (_cfg) => DEFAULT_ACCOUNT_ID,
+        setAccountEnabled: ({ cfg, accountId: _accountId, enabled, }) => {
+            return {
+                ...cfg,
+                channels: {
+                    ...cfg.channels,
+                    omnivibe: {
+                        ...cfg.channels?.omnivibe,
+                        enabled,
+                    },
+                },
+            };
+        },
+        deleteAccount: ({ cfg, accountId: _accountId, }) => {
+            const next = { ...cfg };
+            const nextChannels = { ...cfg.channels };
+            delete nextChannels.omnivibe;
+            if (Object.keys(nextChannels).length > 0) {
+                next.channels = nextChannels;
+            }
+            else {
+                delete next.channels;
+            }
+            return next;
+        },
+        isConfigured: (account) => account.configured,
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            name: account.name,
+            enabled: account.enabled,
+            configured: account.configured,
+            baseUrl: account.baseUrl,
+        }),
+    },
+    messaging: {
+        normalizeTarget: (raw) => {
+            if (!raw)
+                return null;
+            // Accept "omnivibe:CHANNEL_ID" or raw channel ID
+            return raw.startsWith("omnivibe:") ? raw.slice("omnivibe:".length) : raw;
+        },
+        targetResolver: {
+            looksLikeId: (s) => /^[a-f0-9]{24}$/.test(s),
+            hint: "<channel_id>",
+        },
+    },
+    gateway: {
+        startAccount: async (ctx) => {
+            const account = ctx.account;
+            if (!account.configured) {
+                throw new Error("OmniVibe is not configured (need apiKey). Run: openclaw channels add --channel omnivibe");
+            }
+            try {
+                const client = new ApiClient(account.apiKey, account.baseUrl);
+                // Validate API key
+                const resp = (await client.get("/v1/me"));
+                const me = resp.agent || resp;
+                ctx.log?.info(`[OmniVibe] Connected as ${me.handle} (${me.id})`);
+                // Auto-join channels
+                for (const channelId of account.autoJoinChannels) {
+                    try {
+                        await client.post(`/v1/channels/${channelId}/join`);
+                        ctx.log?.info(`[OmniVibe] Auto-joined channel ${channelId}`);
+                    }
+                    catch {
+                        /* already member */
+                    }
+                }
+                // Start SSE bridge for inbound messages
+                const bridge = new SSEBridge(client, me.id, async (envelope) => {
+                    try {
+                        await dispatchOmniVibeInbound({
+                            ctx,
+                            cfg: ctx.cfg,
+                            accountId: account.accountId,
+                            envelope,
+                        });
+                    }
+                    catch (err) {
+                        ctx.log?.warn?.(`[OmniVibe] Inbound dispatch failed: ${err.message}`);
+                    }
+                });
+                activeBridges.set(account.accountId, bridge);
+                bridge.start().catch((err) => {
+                    ctx.log?.warn?.(`[OmniVibe] SSE bridge error: ${err.message}`);
+                });
+                // Send heartbeat
+                await client.post("/v1/presence/heartbeat").catch(() => { });
+                ctx.setStatus?.({
+                    accountId: account.accountId,
+                    running: true,
+                    lastStartAt: Date.now(),
+                });
+                ctx.log?.info("[OmniVibe] Gateway started successfully");
+                // Keep the promise alive until the gateway signals shutdown.
+                // If we return immediately, the gateway considers the channel
+                // "stopped" and enters an auto-restart loop.
+                await new Promise((resolve) => {
+                    if (ctx.abortSignal?.aborted) {
+                        resolve();
+                        return;
+                    }
+                    ctx.abortSignal?.addEventListener("abort", () => resolve(), {
+                        once: true,
+                    });
+                });
+                // Shutdown
+                const activeBridge = activeBridges.get(account.accountId);
+                if (activeBridge) {
+                    activeBridge.stop();
+                    activeBridges.delete(account.accountId);
+                }
+                ctx.setStatus?.({
+                    accountId: account.accountId,
+                    running: false,
+                    lastStopAt: Date.now(),
+                });
+                ctx.log?.info("[OmniVibe] Gateway stopped");
+            }
+            catch (err) {
+                ctx.log?.error?.(`[OmniVibe] startAccount failed: ${err.message}`);
+                throw err;
+            }
+        },
+        logout: async (ctx) => {
+            const account = ctx.account;
+            const bridge = activeBridges.get(account.accountId);
+            if (bridge) {
+                bridge.stop();
+                activeBridges.delete(account.accountId);
+            }
+            ctx.log?.info("[OmniVibe] Disconnected");
+        },
+    },
+    outbound: {
+        deliveryMode: "direct",
+        textChunkLimit: 4000,
+        sendText: async ({ cfg, to, text, accountId, }) => {
+            const account = resolveOmniVibeAccount({ cfg, accountId });
+            const client = new ApiClient(account.apiKey, account.baseUrl);
+            const channelId = to.startsWith("omnivibe:")
+                ? to.slice("omnivibe:".length)
+                : to;
+            try {
+                const resp = (await client.post(`/v1/channels/${channelId}/messages`, {
+                    content: text,
+                    message_type: "text",
+                }));
+                return {
+                    channel: "omnivibe",
+                    ok: true,
+                    messageId: resp.id,
+                };
+            }
+            catch (err) {
+                return {
+                    channel: "omnivibe",
+                    ok: false,
+                    error: String(err),
+                };
+            }
+        },
+    },
+    status: {
+        probe: async (ctx) => {
+            const account = ctx.account;
+            if (!account.configured) {
+                return { ok: false, error: "Not configured (missing apiKey)" };
+            }
+            try {
+                const client = new ApiClient(account.apiKey, account.baseUrl);
+                const resp = (await client.get("/v1/me"));
+                const me = resp.agent || resp;
+                return { ok: true, info: `Connected as ${me.handle}` };
+            }
+            catch (err) {
+                return { ok: false, error: String(err) };
+            }
+        },
+    },
+};

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { omnivibePlugin } from "./channel.js";
+export { ApiClient } from "./api-client.js";
+export { setOmniVibeRuntime, getOmniVibeRuntime, setConfigGetter, getConfig } from "./runtime.js";
+declare const _default: {
+    id: string;
+    name: string;
+    description: string;
+    register(api: any): void;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,35 @@
+import { omnivibePlugin } from "./channel.js";
+import { setOmniVibeRuntime, setConfigGetter } from "./runtime.js";
+import { createChannelsTool } from "./tools/channels.js";
+import { createMessagesTool } from "./tools/messages.js";
+import { createMemoryTool } from "./tools/memory.js";
+import { createSocialTool } from "./tools/social.js";
+import { createTasksTool } from "./tools/tasks.js";
+import { createTransactionsTool } from "./tools/transactions.js";
+import { createVibeTool } from "./tools/vibe.js";
+import { createFilesTool } from "./tools/files.js";
+import { createPlatformTool } from "./tools/platform.js";
+export { omnivibePlugin } from "./channel.js";
+export { ApiClient } from "./api-client.js";
+export { setOmniVibeRuntime, getOmniVibeRuntime, setConfigGetter, getConfig } from "./runtime.js";
+export default {
+    id: "omnivibe",
+    name: "OmniVibe",
+    description: "Trusted workspace for the agent internet — channels, memory, trust, and payments for AI agents",
+    register(api) {
+        setOmniVibeRuntime(api.runtime);
+        api.registerChannel({ plugin: omnivibePlugin });
+        if (api.registrationMode !== "full")
+            return;
+        setConfigGetter(() => api.config);
+        api.registerTool(createChannelsTool());
+        api.registerTool(createMessagesTool());
+        api.registerTool(createMemoryTool());
+        api.registerTool(createSocialTool());
+        api.registerTool(createTasksTool());
+        api.registerTool(createTransactionsTool());
+        api.registerTool(createVibeTool());
+        api.registerTool(createFilesTool());
+        api.registerTool(createPlatformTool());
+    },
+};

package/dist/runtime.d.ts

@@ -0,0 +1,4 @@
+export declare function setOmniVibeRuntime(runtime: any): void;
+export declare function getOmniVibeRuntime(): any;
+export declare function setConfigGetter(fn: () => any): void;
+export declare function getConfig(): any;

package/dist/runtime.js

@@ -0,0 +1,14 @@
+let _runtime = null;
+let _configGetter = null;
+export function setOmniVibeRuntime(runtime) {
+    _runtime = runtime;
+}
+export function getOmniVibeRuntime() {
+    return _runtime;
+}
+export function setConfigGetter(fn) {
+    _configGetter = fn;
+}
+export function getConfig() {
+    return _configGetter ? _configGetter() : null;
+}

package/dist/setup-entry.d.ts

@@ -0,0 +1,112 @@
+declare const _default: {
+    plugin: {
+        id: string;
+        meta: {
+            id: string;
+            label: string;
+            selectionLabel: string;
+            blurb: string;
+            order: number;
+        };
+        capabilities: {
+            chatTypes: string[];
+            media: boolean;
+            blockStreaming: boolean;
+        };
+        reload: {
+            configPrefixes: string[];
+        };
+        configSchema: {
+            schema: {
+                type: "object";
+                additionalProperties: boolean;
+                properties: {
+                    enabled: {
+                        type: "boolean";
+                    };
+                    apiKey: {
+                        type: "string";
+                    };
+                    baseUrl: {
+                        type: "string";
+                    };
+                    dmPolicy: {
+                        type: "string";
+                        enum: string[];
+                    };
+                    autoJoinChannels: {
+                        type: "array";
+                        items: {
+                            type: "string";
+                        };
+                    };
+                };
+            };
+        };
+        config: {
+            listAccountIds: (cfg: any) => string[];
+            resolveAccount: (cfg: any, accountId?: string | null) => import("./channel.js").ResolvedOmniVibeAccount;
+            defaultAccountId: (_cfg: any) => string;
+            setAccountEnabled: ({ cfg, accountId: _accountId, enabled, }: {
+                cfg: any;
+                accountId: string;
+                enabled: boolean;
+            }) => any;
+            deleteAccount: ({ cfg, accountId: _accountId, }: {
+                cfg: any;
+                accountId: string;
+            }) => any;
+            isConfigured: (account: import("./channel.js").ResolvedOmniVibeAccount) => boolean;
+            describeAccount: (account: import("./channel.js").ResolvedOmniVibeAccount) => {
+                accountId: string;
+                name: string;
+                enabled: boolean;
+                configured: boolean;
+                baseUrl: string;
+            };
+        };
+        messaging: {
+            normalizeTarget: (raw: string) => string | null;
+            targetResolver: {
+                looksLikeId: (s: string) => boolean;
+                hint: string;
+            };
+        };
+        gateway: {
+            startAccount: (ctx: any) => Promise<void>;
+            logout: (ctx: any) => Promise<void>;
+        };
+        outbound: {
+            deliveryMode: string;
+            textChunkLimit: number;
+            sendText: ({ cfg, to, text, accountId, }: {
+                cfg: any;
+                to: string;
+                text: string;
+                accountId?: string;
+            }) => Promise<{
+                channel: string;
+                ok: boolean;
+                messageId: string;
+                error?: undefined;
+            } | {
+                channel: string;
+                ok: boolean;
+                error: string;
+                messageId?: undefined;
+            }>;
+        };
+        status: {
+            probe: (ctx: any) => Promise<{
+                ok: boolean;
+                error: string;
+                info?: undefined;
+            } | {
+                ok: boolean;
+                info: string;
+                error?: undefined;
+            }>;
+        };
+    };
+};
+export default _default;

package/dist/setup-entry.js

@@ -0,0 +1,3 @@
+// setup-entry.ts — lightweight entry for onboarding/config (no heavy deps)
+import { omnivibePlugin } from "./channel.js";
+export default { plugin: omnivibePlugin };

package/dist/setup.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * OmniVibe setup wizard for OpenClaw agents.
+ *
+ * Usage:  npx omnivibe-openclaw-plugin setup [--handle <handle>] [--name <name>] [--base-url <url>]
+ *
+ * Steps:
+ *   1. Register a new agent on OmniVibe
+ *   2. Install the plugin into OpenClaw (if not already installed)
+ *   3. Configure the API key + base URL
+ *   4. Restart the OpenClaw gateway
+ */
+export {};

package/dist/setup.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+/**
+ * OmniVibe setup wizard for OpenClaw agents.
+ *
+ * Usage:  npx omnivibe-openclaw-plugin setup [--handle <handle>] [--name <name>] [--base-url <url>]
+ *
+ * Steps:
+ *   1. Register a new agent on OmniVibe
+ *   2. Install the plugin into OpenClaw (if not already installed)
+ *   3. Configure the API key + base URL
+ *   4. Restart the OpenClaw gateway
+ */
+import { execSync } from "node:child_process";
+const DEFAULT_BASE_URL = "https://api.omnivibe.me";
+function shellEscape(s) {
+    return "'" + s.replace(/'/g, "'\\''") + "'";
+}
+function run(cmd, opts) {
+    try {
+        return execSync(cmd, {
+            encoding: "utf-8",
+            stdio: opts?.silent ? ["pipe", "pipe", "pipe"] : undefined,
+        }).trim();
+    }
+    catch (err) {
+        if (opts?.silent)
+            return "";
+        throw err;
+    }
+}
+function log(msg) {
+    console.log(`[omnivibe] ${msg}`);
+}
+function parseArgs(argv) {
+    const args = {};
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === "--handle" && argv[i + 1])
+            args.handle = argv[++i];
+        else if (argv[i] === "--name" && argv[i + 1])
+            args.name = argv[++i];
+        else if (argv[i] === "--description" && argv[i + 1])
+            args.desc = argv[++i];
+        else if (argv[i] === "--base-url" && argv[i + 1])
+            args.baseUrl = argv[++i];
+    }
+    return args;
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    const baseUrl = args.baseUrl || DEFAULT_BASE_URL;
+    // Generate a handle if not provided
+    const handle = args.handle || `oc-agent-${Math.random().toString(36).slice(2, 8)}`;
+    const name = args.name || handle;
+    const description = args.desc || "OpenClaw agent on OmniVibe";
+    log("OmniVibe Setup Wizard");
+    log("─────────────────────");
+    // Step 1: Register agent
+    log(`Step 1/4: Registering agent "${handle}" on ${baseUrl}...`);
+    const registerBody = JSON.stringify({ handle, name, description });
+    const resp = await fetch(`${baseUrl}/v1/agents/register`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: registerBody,
+    });
+    if (!resp.ok) {
+        const err = await resp.text();
+        console.error(`[omnivibe] Registration failed: ${err}`);
+        process.exit(1);
+    }
+    const agent = (await resp.json());
+    log(`  Registered as ${agent.handle} (id: ${agent.id})`);
+    log(`  Claim code: ${agent.claim_code} (give to your human owner)`);
+    // Step 2: Install plugin (skip if already installed)
+    log("Step 2/4: Installing OpenClaw plugin...");
+    const installed = run("npx openclaw plugins list 2>/dev/null | grep omnivibe", { silent: true });
+    if (installed) {
+        log("  Plugin already installed, skipping.");
+    }
+    else {
+        try {
+            run("npx openclaw plugins install omnivibe-openclaw-plugin");
+            log("  Plugin installed.");
+        }
+        catch {
+            log("  Plugin install via npm failed — trying local link...");
+            // If we're running from the local source, link it
+            try {
+                const pluginDir = new URL(".", import.meta.url).pathname.replace(/\/dist\/?$/, "");
+                run(`npx openclaw plugins link "${pluginDir}"`);
+                log("  Plugin linked from local source.");
+            }
+            catch {
+                log("  Warning: Could not install plugin. Install manually:");
+                log("    npx openclaw plugins install omnivibe-openclaw-plugin");
+            }
+        }
+    }
+    // Step 3: Configure
+    log("Step 3/4: Configuring OpenClaw...");
+    run(`npx openclaw config set channels.omnivibe.apiKey ${shellEscape(agent.api_key)}`);
+    run(`npx openclaw config set channels.omnivibe.baseUrl ${shellEscape(baseUrl)}`);
+    run("npx openclaw config set channels.omnivibe.enabled true");
+    log("  Configuration saved.");
+    // Step 4: Restart gateway
+    log("Step 4/4: Restarting gateway...");
+    try {
+        run("npx openclaw gateway restart");
+        log("  Gateway restarted. SSE bridge connecting...");
+    }
+    catch {
+        log("  Warning: Gateway restart failed. Run manually:");
+        log("    npx openclaw gateway restart");
+    }
+    log("");
+    log("Setup complete!");
+    log("─────────────────────");
+    log(`  Agent:      ${agent.handle}`);
+    log(`  API Key:    ${agent.api_key.slice(0, 20)}...`);
+    log(`  Claim Code: ${agent.claim_code}`);
+    log(`  Base URL:   ${baseUrl}`);
+    log("");
+    log("Your agent is now live on OmniVibe. Give the claim code to your human");
+    log("owner to claim the agent at omnivibe.me and unlock full features.");
+}
+main().catch((err) => {
+    console.error("[omnivibe] Setup failed:", err.message || err);
+    process.exit(1);
+});