openclaw-channel-openswitchy 0.1.0 → 0.1.2

package/dist/channel.d.ts

@@ -1,2 +1,3 @@
-import type { ChannelPlugin, AccountConfig } from "./types.js";
+import type { ChannelPlugin } from "openclaw/plugin-sdk";
+import type { AccountConfig } from "./types.js";
 export declare const openswitchyChannel: ChannelPlugin<AccountConfig>;

package/dist/channel.js

@@ -47,7 +47,7 @@ async function listenSse(conn) {
                 signal,
             });
             if (!res.ok || !res.body) {
-                console.error(`[openswitchy] SSE connect failed (${res.status}), retrying in 5s`);
+                conn.gatewayCtx.log?.error(`SSE connect failed (${res.status}), retrying in 5s`);
                 await sleep(5000);
                 continue;
             }
@@ -72,7 +72,7 @@ async function listenSse(conn) {
                             await handleNewMessage(conn, data);
                         }
                         catch (err) {
-                            console.error("[openswitchy] Failed to parse SSE data:", err);
+                            conn.gatewayCtx.log?.error(`Failed to parse SSE data: ${err}`);
                         }
                         currentEvent = "";
                     }
@@ -85,7 +85,7 @@ async function listenSse(conn) {
         catch (err) {
             if (signal.aborted)
                 return;
-            console.error("[openswitchy] SSE error, reconnecting in 5s:", err);
+            conn.gatewayCtx.log?.error(`SSE error, reconnecting in 5s: ${err}`);
             await sleep(5000);
         }
     }
@@ -99,23 +99,69 @@ async function handleNewMessage(conn, data) {
     const latest = history.messages[history.messages.length - 1];
     if (!latest)
         return;
-    const mentioned = data.mentioned === true ||
-        (latest.metadata?.mentionedAgentIds || []).includes(conn.agentId);
-    const envelope = {
+    const ctx = conn.gatewayCtx;
+    const { channelRuntime } = ctx;
+    if (!channelRuntime) {
+        ctx.log?.warn("channelRuntime not available, skipping AI dispatch");
+        return;
+    }
+    // Resolve agent route for this sender
+    const route = channelRuntime.routing.resolveAgentRoute({
+        cfg: ctx.cfg,
         channel: "openswitchy",
-        accountId: conn.accountId,
-        from: data.from.agentId,
-        to: data.chatRoomId,
-        body: latest.content,
+        accountId: ctx.accountId,
+        peer: { kind: "direct", id: data.from.agentId },
+    });
+    // Build the inbound envelope body via the SDK runtime
+    const storePath = channelRuntime.session.resolveStorePath(undefined, {
+        agentId: route.agentId,
+    });
+    const envelopeOpts = channelRuntime.reply.resolveEnvelopeFormatOptions(ctx.cfg);
+    const body = channelRuntime.reply.formatAgentEnvelope({
+        channel: "openswitchy",
+        from: data.from.name,
         timestamp: new Date(latest.createdAt).getTime() || Date.now(),
-        metadata: {
-            messageId: latest._id || data.messageId,
-            fromName: data.from.name,
-            chatRoomId: data.chatRoomId,
-            mentioned,
-        },
+        envelope: envelopeOpts,
+        body: latest.content,
+    });
+    const mentioned = data.mentioned === true ||
+        (latest.metadata?.mentionedAgentIds || []).includes(conn.agentId);
+    // Build MsgContext for the SDK pipeline
+    const msgCtx = {
+        Body: body,
+        From: data.from.agentId,
+        To: data.chatRoomId,
+        AccountId: ctx.accountId,
+        SessionKey: route.sessionKey,
+        ChatType: "direct",
+        SenderName: data.from.name,
     };
-    conn.dispatchInbound(envelope);
+    // Record inbound session
+    const chatRoomId = data.chatRoomId;
+    await channelRuntime.session.recordInboundSession({
+        storePath,
+        sessionKey: route.sessionKey,
+        ctx: msgCtx,
+        onRecordError: (err) => {
+            ctx.log?.error(`Session record error: ${err}`);
+        },
+    });
+    // Dispatch AI reply
+    await channelRuntime.reply.dispatchReplyWithBufferedBlockDispatcher({
+        ctx: msgCtx,
+        cfg: ctx.cfg,
+        dispatcherOptions: {
+            deliver: async (payload) => {
+                const text = payload.text;
+                if (!text)
+                    return;
+                await apiCall(conn.baseUrl, conn.apiKey, "POST", "/chat", {
+                    chatRoomId,
+                    message: text,
+                });
+            },
+        },
+    });
 }
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -137,20 +183,22 @@ export const openswitchyChannel = {
     /* ── Config Adapter ── */
     config: {
         listAccountIds(cfg) {
-            const accounts = cfg.channels?.openswitchy?.accounts;
-            if (!accounts)
+            const channels = cfg.channels;
+            const osSection = channels?.openswitchy;
+            if (!osSection?.accounts)
                 return [];
-            return Object.keys(accounts);
+            return Object.keys(osSection.accounts);
         },
         resolveAccount(cfg, accountId) {
-            const accounts = cfg.channels?.openswitchy?.accounts;
-            if (!accounts)
+            const channels = cfg.channels;
+            const osSection = channels?.openswitchy;
+            if (!osSection?.accounts)
                 return {};
-            if (accountId && accounts[accountId])
-                return accounts[accountId];
+            if (accountId && osSection.accounts[accountId])
+                return osSection.accounts[accountId];
             // Fall back to first account
-            const firstKey = Object.keys(accounts)[0];
-            return firstKey ? accounts[firstKey] : {};
+            const firstKey = Object.keys(osSection.accounts)[0];
+            return firstKey ? osSection.accounts[firstKey] : {};
         },
         isConfigured(account) {
             return Boolean(account.joinCode && account.agentName);
@@ -167,25 +215,23 @@ export const openswitchyChannel = {
                 throw new Error("[openswitchy] Missing joinCode or agentName in config");
             }
             const baseUrl = account.url || DEFAULT_URL;
-            console.log(`[openswitchy] Registering "${account.agentName}" at ${baseUrl}`);
+            ctx.log?.info(`Registering "${account.agentName}" at ${baseUrl}`);
             const reg = await registerAgent(account);
-            console.log(`[openswitchy] Registered as ${reg.name} (${reg.agentId}) in "${reg.orgName}" — status: ${reg.status}`);
+            ctx.log?.info(`Registered as ${reg.name} (${reg.agentId}) in "${reg.orgName}" — status: ${reg.status}`);
             const conn = {
                 apiKey: reg.apiKey,
                 agentId: reg.agentId,
                 baseUrl,
                 accountId,
                 abortController: new AbortController(),
-                dispatchInbound: (envelope) => {
-                    ctx.channelRuntime?.reply.dispatchInbound(envelope);
-                },
+                gatewayCtx: ctx,
             };
             // Link abort to OpenClaw's signal
             abortSignal.addEventListener("abort", () => conn.abortController.abort());
             connections.set(accountId, conn);
             // Start SSE listener (fire-and-forget, reconnects internally)
             listenSse(conn);
-            console.log("[openswitchy] SSE connected, listening for messages");
+            ctx.log?.info("SSE connected, listening for messages");
         },
         async stopAccount(ctx) {
             const conn = connections.get(ctx.accountId);
@@ -193,7 +239,7 @@ export const openswitchyChannel = {
                 conn.abortController.abort();
                 connections.delete(ctx.accountId);
             }
-            console.log(`[openswitchy] Disconnected account ${ctx.accountId}`);
+            ctx.log?.info(`Disconnected account ${ctx.accountId}`);
         },
     },
     /* ── Outbound Adapter ── */
@@ -206,7 +252,7 @@ export const openswitchyChannel = {
                 throw new Error("[openswitchy] No active connection for this account");
             }
             const result = await apiCall(conn.baseUrl, conn.apiKey, "POST", "/chat", { chatRoomId: ctx.to, message: ctx.text });
-            return { messageId: result.messageId };
+            return { channel: "openswitchy", messageId: result.messageId };
         },
     },
     /* ── Security Adapter ── */

package/dist/channel.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/channel.test.js

@@ -0,0 +1,211 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { openswitchyChannel } from "./channel.js";
+/* ── Helper to build a fake OpenClawConfig ── */
+function makeConfig(accounts) {
+    return { channels: { openswitchy: { accounts } } };
+}
+/* ── Config Adapter ── */
+describe("config adapter", () => {
+    const { config } = openswitchyChannel;
+    it("listAccountIds returns account IDs from config", () => {
+        const cfg = makeConfig({
+            default: { joinCode: "abc", agentName: "Bot" },
+            work: { joinCode: "xyz", agentName: "WorkBot" },
+        });
+        expect(config.listAccountIds(cfg)).toEqual(["default", "work"]);
+    });
+    it("listAccountIds returns empty array when no config", () => {
+        expect(config.listAccountIds({})).toEqual([]);
+    });
+    it("listAccountIds returns empty when no accounts section", () => {
+        const cfg = { channels: { openswitchy: {} } };
+        expect(config.listAccountIds(cfg)).toEqual([]);
+    });
+    it("resolveAccount returns the correct account config", () => {
+        const cfg = makeConfig({
+            default: { joinCode: "abc", agentName: "Bot1" },
+            work: { joinCode: "xyz", agentName: "Bot2" },
+        });
+        const account = config.resolveAccount(cfg, "work");
+        expect(account).toEqual({ joinCode: "xyz", agentName: "Bot2" });
+    });
+    it("resolveAccount falls back to first account when ID not found", () => {
+        const cfg = makeConfig({
+            default: { joinCode: "abc", agentName: "Bot1" },
+        });
+        const account = config.resolveAccount(cfg, "nonexistent");
+        expect(account).toEqual({ joinCode: "abc", agentName: "Bot1" });
+    });
+    it("resolveAccount returns empty object when no accounts", () => {
+        const account = config.resolveAccount({}, "anything");
+        expect(account).toEqual({});
+    });
+    it("isConfigured returns true when joinCode and agentName are set", () => {
+        expect(config.isConfigured({ joinCode: "abc", agentName: "Bot" }, {})).toBe(true);
+    });
+    it("isConfigured returns false when joinCode is missing", () => {
+        expect(config.isConfigured({ agentName: "Bot" }, {})).toBe(false);
+    });
+    it("isConfigured returns false when agentName is missing", () => {
+        expect(config.isConfigured({ joinCode: "abc" }, {})).toBe(false);
+    });
+    it("isEnabled returns true by default", () => {
+        expect(config.isEnabled({}, {})).toBe(true);
+    });
+    it("isEnabled returns false when explicitly disabled", () => {
+        expect(config.isEnabled({ enabled: false }, {})).toBe(false);
+    });
+    it("isEnabled returns true when explicitly enabled", () => {
+        expect(config.isEnabled({ enabled: true }, {})).toBe(true);
+    });
+});
+/* ── Meta & Capabilities ── */
+describe("meta and capabilities", () => {
+    it("has correct id", () => {
+        expect(openswitchyChannel.id).toBe("openswitchy");
+    });
+    it("meta.label is OpenSwitchy", () => {
+        expect(openswitchyChannel.meta.label).toBe("OpenSwitchy");
+    });
+    it("meta has docsPath", () => {
+        expect(openswitchyChannel.meta.docsPath).toBe("channels/openswitchy");
+    });
+    it("supports direct and group chats", () => {
+        expect(openswitchyChannel.capabilities.chatTypes).toContain("direct");
+        expect(openswitchyChannel.capabilities.chatTypes).toContain("group");
+    });
+});
+/* ── Security Adapter ── */
+describe("security adapter", () => {
+    const security = openswitchyChannel.security;
+    it("resolveDmPolicy returns open by default", () => {
+        const result = security.resolveDmPolicy({
+            cfg: {},
+            account: {},
+        });
+        expect(result?.policy).toBe("open");
+    });
+    it("resolveDmPolicy returns configured policy", () => {
+        const result = security.resolveDmPolicy({
+            cfg: {},
+            account: { dmPolicy: "pairing" },
+        });
+        expect(result?.policy).toBe("pairing");
+    });
+    it("resolveDmPolicy includes allowFromPath", () => {
+        const result = security.resolveDmPolicy({
+            cfg: {},
+            account: {},
+        });
+        expect(result?.allowFromPath).toBe("channels.openswitchy.allowFrom");
+    });
+});
+/* ── Outbound Adapter ── */
+describe("outbound adapter", () => {
+    const outbound = openswitchyChannel.outbound;
+    it("textChunkLimit is 4096", () => {
+        expect(outbound.textChunkLimit).toBe(4096);
+    });
+    it("deliveryMode is direct", () => {
+        expect(outbound.deliveryMode).toBe("direct");
+    });
+    it("sendText throws when no active connection", async () => {
+        await expect(outbound.sendText({
+            cfg: {},
+            to: "room-123",
+            text: "hello",
+            accountId: "nonexistent",
+        })).rejects.toThrow("No active connection");
+    });
+});
+/* ── Gateway Adapter ── */
+describe("gateway adapter", () => {
+    const gateway = openswitchyChannel.gateway;
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it("startAccount throws when joinCode is missing", async () => {
+        const ctx = {
+            cfg: {},
+            accountId: "test",
+            account: { agentName: "Bot" },
+            abortSignal: new AbortController().signal,
+            runtime: {},
+            getStatus: vi.fn(),
+            setStatus: vi.fn(),
+        };
+        await expect(gateway.startAccount(ctx)).rejects.toThrow("Missing joinCode or agentName");
+    });
+    it("startAccount throws when agentName is missing", async () => {
+        const ctx = {
+            cfg: {},
+            accountId: "test",
+            account: { joinCode: "abc" },
+            abortSignal: new AbortController().signal,
+            runtime: {},
+            getStatus: vi.fn(),
+            setStatus: vi.fn(),
+        };
+        await expect(gateway.startAccount(ctx)).rejects.toThrow("Missing joinCode or agentName");
+    });
+    it("startAccount registers and stores connection", async () => {
+        const mockFetch = vi.fn()
+            // registration call
+            .mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                agentId: "agent-1",
+                name: "TestBot",
+                orgId: "org-1",
+                orgName: "TestOrg",
+                apiKey: "sb_test_key",
+                status: "approved",
+                message: "Registered",
+            }),
+        })
+            // SSE call (return a never-resolving body to keep SSE alive)
+            .mockResolvedValueOnce({
+            ok: true,
+            body: {
+                getReader: () => ({
+                    read: () => new Promise(() => { }), // hangs forever (SSE stream)
+                }),
+            },
+        });
+        vi.stubGlobal("fetch", mockFetch);
+        const abortController = new AbortController();
+        const ctx = {
+            cfg: {},
+            accountId: "test-acc",
+            account: { joinCode: "abc", agentName: "TestBot", url: "http://localhost:3000" },
+            abortSignal: abortController.signal,
+            runtime: {},
+            getStatus: vi.fn(),
+            setStatus: vi.fn(),
+            log: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+        };
+        await gateway.startAccount(ctx);
+        // Verify registration was called
+        expect(mockFetch).toHaveBeenCalledWith("http://localhost:3000/register", expect.objectContaining({
+            method: "POST",
+            body: expect.stringContaining('"joinCode":"abc"'),
+        }));
+        // Cleanup
+        abortController.abort();
+        vi.unstubAllGlobals();
+    });
+    it("stopAccount cleans up", async () => {
+        const ctx = {
+            cfg: {},
+            accountId: "nonexistent-acc",
+            account: {},
+            abortSignal: new AbortController().signal,
+            runtime: {},
+            getStatus: vi.fn(),
+            setStatus: vi.fn(),
+            log: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+        };
+        // Should not throw even if no connection exists
+        await expect(gateway.stopAccount(ctx)).resolves.toBeUndefined();
+    });
+});

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import type { OpenClawPluginApi } from "./types.js";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 declare const _default: {
     id: string;
     name: string;

package/dist/types.d.ts

@@ -1,117 +1,9 @@
 /**
- * OpenClaw plugin types — matches the real adapter pattern from openclaw SDK.
- * Only includes what this plugin needs.
+ * OpenSwitchy-specific types for the channel plugin.
+ *
+ * OpenClaw SDK types (ChannelPlugin, OpenClawPluginApi, etc.) are imported
+ * directly from "openclaw/plugin-sdk" — only OpenSwitchy API shapes live here.
  */
-export interface OpenClawPluginApi {
-    id: string;
-    name: string;
-    config: OpenClawConfig;
-    logger: PluginLogger;
-    registerChannel(registration: {
-        plugin: ChannelPlugin;
-    }): void;
-}
-export interface PluginLogger {
-    info(msg: string, ...args: unknown[]): void;
-    warn(msg: string, ...args: unknown[]): void;
-    error(msg: string, ...args: unknown[]): void;
-}
-export type ChatType = "direct" | "group";
-export interface ChannelPlugin<ResolvedAccount = unknown> {
-    id: string;
-    meta: ChannelMeta;
-    capabilities: ChannelCapabilities;
-    config: ChannelConfigAdapter<ResolvedAccount>;
-    gateway?: ChannelGatewayAdapter<ResolvedAccount>;
-    outbound?: ChannelOutboundAdapter;
-    security?: ChannelSecurityAdapter<ResolvedAccount>;
-}
-export interface ChannelMeta {
-    id: string;
-    label: string;
-    selectionLabel: string;
-    docsPath: string;
-    blurb: string;
-    aliases?: string[];
-}
-export interface ChannelCapabilities {
-    chatTypes: ChatType[];
-    media?: boolean;
-    reactions?: boolean;
-    threads?: boolean;
-}
-export interface ChannelConfigAdapter<ResolvedAccount> {
-    listAccountIds(cfg: OpenClawConfig): string[];
-    resolveAccount(cfg: OpenClawConfig, accountId?: string | null): ResolvedAccount;
-    isConfigured?(account: ResolvedAccount, cfg: OpenClawConfig): boolean;
-    isEnabled?(account: ResolvedAccount, cfg: OpenClawConfig): boolean;
-}
-export interface ChannelGatewayAdapter<ResolvedAccount> {
-    startAccount?(ctx: ChannelGatewayContext<ResolvedAccount>): Promise<unknown>;
-    stopAccount?(ctx: ChannelGatewayContext<ResolvedAccount>): Promise<void>;
-}
-export interface ChannelGatewayContext<ResolvedAccount> {
-    cfg: OpenClawConfig;
-    accountId: string;
-    account: ResolvedAccount;
-    abortSignal: AbortSignal;
-    log?: {
-        info(msg: string): void;
-        error(msg: string): void;
-    };
-    channelRuntime?: PluginChannelRuntime;
-}
-export interface PluginChannelRuntime {
-    reply: {
-        dispatchInbound(envelope: InboundEnvelope): void;
-    };
-}
-export interface InboundEnvelope {
-    channel: string;
-    accountId: string;
-    from: string;
-    to: string;
-    body: string;
-    timestamp?: number;
-    metadata?: Record<string, unknown>;
-}
-export interface ChannelOutboundAdapter {
-    deliveryMode: "direct" | "gateway" | "hybrid";
-    textChunkLimit?: number;
-    sendText?(ctx: ChannelOutboundContext): Promise<OutboundDeliveryResult>;
-}
-export interface ChannelOutboundContext {
-    cfg: OpenClawConfig;
-    to: string;
-    text: string;
-    accountId?: string | null;
-}
-export interface OutboundDeliveryResult {
-    messageId?: string;
-}
-export interface ChannelSecurityAdapter<ResolvedAccount> {
-    resolveDmPolicy?(ctx: ChannelSecurityContext<ResolvedAccount>): ChannelSecurityDmPolicy | null;
-}
-export interface ChannelSecurityContext<ResolvedAccount> {
-    cfg: OpenClawConfig;
-    accountId?: string | null;
-    account: ResolvedAccount;
-}
-export interface ChannelSecurityDmPolicy {
-    policy: string;
-    allowFrom?: Array<string | number> | null;
-    allowFromPath: string;
-    approveHint: string;
-}
-export interface OpenClawConfig {
-    channels?: {
-        openswitchy?: {
-            accounts?: Record<string, AccountConfig>;
-        };
-        [key: string]: unknown;
-    };
-    [key: string]: unknown;
-}
 export interface AccountConfig {
     url?: string;
     joinCode?: string;

package/dist/types.js

@@ -1,5 +1,7 @@
 /**
- * OpenClaw plugin types — matches the real adapter pattern from openclaw SDK.
- * Only includes what this plugin needs.
+ * OpenSwitchy-specific types for the channel plugin.
+ *
+ * OpenClaw SDK types (ChannelPlugin, OpenClawPluginApi, etc.) are imported
+ * directly from "openclaw/plugin-sdk" — only OpenSwitchy API shapes live here.
  */
 export {};

package/package.json

@@ -1,24 +1,36 @@
 {
   "name": "openclaw-channel-openswitchy",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "OpenSwitchy channel plugin for OpenClaw",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": ["dist", "openclaw.plugin.json"],
+  "files": [
+    "dist",
+    "openclaw.plugin.json"
+  ],
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "test": "vitest run"
   },
-  "keywords": ["openclaw", "openswitchy", "channel", "plugin", "ai-agents"],
+  "keywords": [
+    "openclaw",
+    "openswitchy",
+    "channel",
+    "plugin",
+    "ai-agents"
+  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/OpenSwitchy/openclaw-channel-openswitchy.git"
   },
   "license": "MIT",
   "devDependencies": {
+    "@types/node": "^22.0.0",
+    "openclaw": "^2026.3.7",
     "typescript": "^5.7.0",
-    "@types/node": "^22.0.0"
+    "vitest": "^4.0.18"
   }
 }