@feihan-im/openclaw-plugin 0.1.0

package/src/index.test.ts

@@ -0,0 +1,164 @@
+// Copyright (c) 2026 上海飞函安全科技有限公司 (Shanghai Feihan Security Technology Co., Ltd.)
+// SPDX-License-Identifier: Apache-2.0
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import register from "./index.js";
+import type { PluginApi } from "./types.js";
+
+vi.mock("./core/feihan-client.js", () => ({
+  createClient: vi.fn(),
+  destroyAllClients: vi.fn().mockResolvedValue(undefined),
+  clientCount: vi.fn().mockReturnValue(0),
+}));
+
+vi.mock("./messaging/outbound.js", () => ({
+  makeDeliver: vi.fn().mockReturnValue(vi.fn()),
+  setTyping: vi.fn().mockResolvedValue(undefined),
+  clearTyping: vi.fn().mockResolvedValue(undefined),
+  readMessage: vi.fn().mockResolvedValue(undefined),
+}));
+
+import { createClient, clientCount } from "./core/feihan-client.js";
+
+function createMockApi(config: unknown = {}): PluginApi {
+  return {
+    registerChannel: vi.fn(),
+    registerService: vi.fn(),
+    config: config as PluginApi["config"],
+    runtime: {
+      channel: {
+        reply: { dispatchReplyWithBufferedBlockDispatcher: vi.fn() },
+        session: { recordInboundSession: vi.fn() },
+        routing: { resolveAgentRoute: vi.fn() },
+      },
+    },
+    logger: {
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      debug: vi.fn(),
+    },
+  };
+}
+
+function extractStartFn(api: PluginApi): () => Promise<void> {
+  const call = (api.registerService as ReturnType<typeof vi.fn>).mock.calls[0];
+  return call[0].start;
+}
+
+describe("register", () => {
+  beforeEach(() => {
+    vi.mocked(clientCount).mockReturnValue(0);
+    vi.mocked(createClient).mockResolvedValue({ client: {}, config: {} } as any);
+  });
+
+  it("registers channel and service", () => {
+    const api = createMockApi();
+    register(api);
+
+    expect(api.registerChannel).toHaveBeenCalledOnce();
+    expect(api.registerChannel).toHaveBeenCalledWith(
+      expect.objectContaining({ plugin: expect.objectContaining({ id: "feihan" }) }),
+    );
+
+    expect(api.registerService).toHaveBeenCalledOnce();
+    expect(api.registerService).toHaveBeenCalledWith(
+      expect.objectContaining({ id: "feihan-sdk" }),
+    );
+  });
+
+  it("logs plugin registration", () => {
+    const api = createMockApi();
+    register(api);
+    expect(api.logger!.info).toHaveBeenCalledWith("[feihan] plugin registered");
+  });
+});
+
+describe("service start — config validation", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(clientCount).mockReturnValue(0);
+    vi.mocked(createClient).mockResolvedValue({ client: {}, config: {} } as any);
+  });
+
+  it("skips account with empty appId and logs warning", async () => {
+    const api = createMockApi({
+      channels: {
+        feihan: {
+          accounts: {
+            broken: { appId: "", appSecret: "s", backendUrl: "https://x.io", enabled: true },
+          },
+        },
+      },
+    });
+    register(api);
+    await extractStartFn(api)();
+
+    expect(api.logger!.warn).toHaveBeenCalledWith(
+      expect.stringContaining("skipping account=broken"),
+    );
+    expect(api.logger!.warn).toHaveBeenCalledWith(
+      expect.stringContaining("appId is required"),
+    );
+    expect(createClient).not.toHaveBeenCalled();
+  });
+
+  it("skips account with invalid backendUrl scheme and logs warning", async () => {
+    const api = createMockApi({
+      channels: {
+        feihan: {
+          accounts: {
+            bad: { appId: "a", appSecret: "s", backendUrl: "ftp://bad.url", enabled: true },
+          },
+        },
+      },
+    });
+    register(api);
+    await extractStartFn(api)();
+
+    expect(api.logger!.warn).toHaveBeenCalledWith(
+      expect.stringContaining("must start with http://"),
+    );
+    expect(createClient).not.toHaveBeenCalled();
+  });
+
+  it("connects valid accounts normally", async () => {
+    const api = createMockApi({
+      channels: {
+        feihan: { appId: "a", appSecret: "s", backendUrl: "https://ok.io" },
+      },
+    });
+    register(api);
+    await extractStartFn(api)();
+
+    expect(createClient).toHaveBeenCalledOnce();
+    expect(api.logger!.info).toHaveBeenCalledWith(
+      expect.stringContaining("connected"),
+    );
+  });
+
+  it("skips invalid account but connects valid one in multi-account config", async () => {
+    const api = createMockApi({
+      channels: {
+        feihan: {
+          accounts: {
+            bad: { appId: "", appSecret: "s", backendUrl: "https://x.io", enabled: true },
+            good: { appId: "a", appSecret: "s", backendUrl: "https://x.io", enabled: true },
+          },
+        },
+      },
+    });
+    register(api);
+    await extractStartFn(api)();
+
+    // bad account skipped with warning
+    expect(api.logger!.warn).toHaveBeenCalledWith(
+      expect.stringContaining("skipping account=bad"),
+    );
+    // good account connected
+    expect(createClient).toHaveBeenCalledOnce();
+    expect(api.logger!.info).toHaveBeenCalledWith(
+      expect.stringContaining("account=good connected"),
+    );
+  });
+});

package/src/index.ts

@@ -0,0 +1,112 @@
+// Copyright (c) 2026 上海飞函安全科技有限公司 (Shanghai Feihan Security Technology Co., Ltd.)
+// SPDX-License-Identifier: Apache-2.0
+
+import { feihanPlugin } from "./channel.js";
+import { listEnabledAccountConfigs, validateAccountConfig } from "./config.js";
+import {
+  createClient,
+  destroyAllClients,
+  clientCount,
+} from "./core/feihan-client.js";
+import { processInboundMessage } from "./messaging/inbound.js";
+import { makeDeliver, setTyping, clearTyping, readMessage } from "./messaging/outbound.js";
+import type { PluginApi, FeihanAccountConfig, FeihanMessageEvent } from "./types.js";
+
+export default function register(api: PluginApi): void {
+  api.registerChannel({ plugin: feihanPlugin });
+
+  api.registerService({
+    id: "feihan-sdk",
+    start: async () => {
+      if (clientCount() > 0) return;
+
+      const accounts = listEnabledAccountConfigs(api.config);
+      if (accounts.length === 0) {
+        api.logger?.warn("[feihan] no enabled account config found — service idle");
+        return;
+      }
+
+      for (const account of accounts) {
+        const errors = validateAccountConfig(account);
+        if (errors.length > 0) {
+          api.logger?.warn(
+            `[feihan] skipping account=${account.accountId}: ${errors.map((e) => e.message).join("; ")}`,
+          );
+          continue;
+        }
+
+        try {
+          await startAccount(api, account);
+          api.logger?.info(
+            `[feihan] account=${account.accountId} connected (appId=${account.appId})`,
+          );
+        } catch (err) {
+          api.logger?.error(
+            `[feihan] account=${account.accountId} failed to start: ${err instanceof Error ? err.message : String(err)}`,
+          );
+        }
+      }
+
+      api.logger?.info(`[feihan] service started with ${clientCount()} account(s)`);
+    },
+    stop: async () => {
+      await destroyAllClients();
+      api.logger?.info("[feihan] service stopped — all clients disconnected");
+    },
+  });
+
+  api.logger?.info("[feihan] plugin registered");
+}
+
+/**
+ * Start a single account — create client, subscribe to inbound events.
+ */
+async function startAccount(
+  api: PluginApi,
+  account: FeihanAccountConfig,
+): Promise<void> {
+  const deliver = makeDeliver(account.accountId, (msg) => api.logger?.warn(msg));
+
+  await createClient({
+    config: account,
+    log: (msg: string) => api.logger?.debug(msg),
+    onMessage: (event: FeihanMessageEvent, accountConfig: FeihanAccountConfig) => {
+      // Fire-and-forget: process inbound with typing indicator
+      handleInbound(api, accountConfig, event, deliver).catch((err) => {
+        api.logger?.error(
+          `[feihan] unhandled inbound error for account=${accountConfig.accountId}: ${err}`,
+        );
+      });
+    },
+  });
+}
+
+/**
+ * Handle a single inbound message with typing indicator lifecycle.
+ */
+async function handleInbound(
+  api: PluginApi,
+  account: FeihanAccountConfig,
+  event: FeihanMessageEvent,
+  deliver: (chatId: string, text: string) => Promise<void>,
+): Promise<void> {
+  const chatId = event.message?.chatId;
+  const messageId = event.message?.messageId;
+
+  // Set typing indicator and mark message as read before processing
+  if (chatId) {
+    setTyping(chatId, account.accountId).catch(() => {});
+  }
+  if (messageId) {
+    readMessage(messageId, account.accountId).catch(() => {});
+  }
+
+  try {
+    await processInboundMessage(api, account, event, { deliver });
+  } finally {
+    // Clear typing after dispatch completes
+    if (chatId) {
+      clearTyping(chatId, account.accountId).catch(() => {});
+    }
+  }
+}