multi-openim-channel 0.1.0

package/dist/index.js

@@ -0,0 +1,71 @@
+/**
+ * multi-openim-channel — OpenClaw plugin entry point.
+ *
+ * Wires up: SDK polyfills → register the channel descriptor → register
+ * lifecycle handlers on the channel object so OpenClaw's health-monitor
+ * can drive us → register MCP tools → register the setup CLI → register
+ * the long-running SDK service.
+ */
+import "./polyfills.js";
+import { createChannelPlugin } from "./channel.js";
+import { connectedClientCount, setInboundDispatcher, startAccountClient, stopAllClients, } from "./clients.js";
+import { listEnabledAccountConfigs, normalizeChannelConfig } from "./config.js";
+import { createPluginContext } from "./context.js";
+import { processInboundMessage } from "./inbound.js";
+import { registerTools } from "./tools.js";
+import { CHANNEL_ID } from "./types.js";
+import { formatSdkError, logTag } from "./utils.js";
+export default function register(api) {
+    const { channel, issues } = normalizeChannelConfig(api, api.logger);
+    for (const issue of issues) {
+        api.logger?.warn?.(`${logTag("register")} account=${issue.accountId} skipped: ${issue.reason}`);
+    }
+    const ctx = createPluginContext(api, channel);
+    setInboundDispatcher(processInboundMessage);
+    const channelPlugin = createChannelPlugin(ctx);
+    api.registerChannel?.({ plugin: channelPlugin });
+    if (typeof api.registerCli === "function") {
+        api.registerCli((cliCtx) => {
+            const prog = cliCtx.program;
+            if (prog && typeof prog.command === "function") {
+                const sub = prog.command("multi-openim").description("Multi-OpenIM channel configuration");
+                sub
+                    .command("setup")
+                    .description("Interactive setup for a multi-openim account (default account: \"primary\")")
+                    .action(async () => {
+                    const { runSetup } = await import("./setup.js");
+                    await runSetup();
+                });
+            }
+        }, { commands: ["multi-openim"] });
+    }
+    registerTools(api);
+    api.registerService?.({
+        id: `${CHANNEL_ID}-sdk`,
+        start: async () => {
+            if (connectedClientCount() > 0) {
+                ctx.logger.info?.(`${logTag("service")} already started; reusing existing clients`);
+                return;
+            }
+            const accounts = listEnabledAccountConfigs(api);
+            if (accounts.length === 0) {
+                ctx.logger.warn?.(`${logTag("service")} no enabled accounts found in channels.${CHANNEL_ID}.accounts`);
+                return;
+            }
+            for (const account of accounts) {
+                try {
+                    await startAccountClient(ctx, account);
+                }
+                catch (e) {
+                    ctx.logger.error?.(`${logTag("service")} account=${account.accountId} start failed: ${formatSdkError(e)}`);
+                }
+            }
+            ctx.logger.info?.(`${logTag("service")} started with ${connectedClientCount()}/${accounts.length} connected account(s)`);
+        },
+        stop: async () => {
+            await stopAllClients(ctx);
+            ctx.logger.info?.(`${logTag("service")} stopped`);
+        },
+    });
+    ctx.logger.info?.(`${logTag("register")} plugin loaded (healthCheck=${channel.healthCheckIntervalMinutes}min, tokenRefresh.mode=${channel.tokenRefresh.mode}, disableFriendSdk=${channel.disableFriendSdk})`);
+}

package/dist/media.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Outbound media helpers. Wraps OpenIM SDK message-create + sendMessage
+ * flows for text / image / file. Video is delivered as a file message
+ * because the SDK's native video message has poor cross-client fidelity.
+ */
+import type { ClientState, ParsedTarget } from "./types.js";
+export declare function sendTextToTarget(client: ClientState, target: ParsedTarget, text: string): Promise<void>;
+export declare function sendImageToTarget(client: ClientState, target: ParsedTarget, image: string): Promise<void>;
+export declare function sendFileToTarget(client: ClientState, target: ParsedTarget, filePathOrUrl: string, name?: string): Promise<void>;
+export declare function sendVideoToTarget(client: ClientState, target: ParsedTarget, video: string, name?: string): Promise<void>;

package/dist/media.js

@@ -0,0 +1,157 @@
+/**
+ * Outbound media helpers. Wraps OpenIM SDK message-create + sendMessage
+ * flows for text / image / file. Video is delivered as a file message
+ * because the SDK's native video message has poor cross-client fidelity.
+ */
+import { File } from "node:buffer";
+import { randomUUID } from "node:crypto";
+import { readFile, stat } from "node:fs/promises";
+import { basename, extname } from "node:path";
+import { getRecvAndGroupID } from "./targets.js";
+const MIME_TABLE = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".bmp": "image/bmp",
+    ".webp": "image/webp",
+    ".mp4": "video/mp4",
+    ".mov": "video/quicktime",
+    ".mkv": "video/x-matroska",
+    ".avi": "video/x-msvideo",
+    ".pdf": "application/pdf",
+    ".txt": "text/plain",
+    ".json": "application/json",
+    ".zip": "application/zip",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".xls": "application/vnd.ms-excel",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+};
+function isHttpUrl(input) {
+    return /^https?:\/\//i.test(input.trim());
+}
+function fromFileUrl(input) {
+    const raw = input.trim();
+    if (raw.startsWith("file://")) {
+        return decodeURIComponent(raw.slice("file://".length));
+    }
+    return raw;
+}
+function guessMime(nameOrPath, fallback = "application/octet-stream") {
+    const ext = extname(nameOrPath).toLowerCase();
+    return MIME_TABLE[ext] ?? fallback;
+}
+function nameFromUrl(url, fallback) {
+    try {
+        const u = new URL(url);
+        const name = basename(u.pathname || "");
+        return name || fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+async function readLocalFile(pathInput, forcedName) {
+    const filePath = fromFileUrl(pathInput);
+    const st = await stat(filePath);
+    const data = await readFile(filePath);
+    const fileName = forcedName?.trim() || basename(filePath) || `file-${Date.now()}`;
+    const mime = guessMime(fileName);
+    const file = new File([new Uint8Array(data)], fileName, { type: mime });
+    return { file, filePath, fileName, size: st.size, mime };
+}
+export async function sendTextToTarget(client, target, text) {
+    const created = await client.sdk.createTextMessage(text);
+    const message = created?.data;
+    if (!message) {
+        throw new Error("createTextMessage returned no message");
+    }
+    const { recvID, groupID } = getRecvAndGroupID(target);
+    await client.sdk.sendMessage({ recvID, groupID, message });
+}
+export async function sendImageToTarget(client, target, image) {
+    const input = image.trim();
+    if (!input)
+        throw new Error("image is empty");
+    let message;
+    if (isHttpUrl(input)) {
+        const name = nameFromUrl(input, "image.jpg");
+        const pic = {
+            uuid: randomUUID(),
+            type: guessMime(name, "image/jpeg"),
+            size: 0,
+            width: 0,
+            height: 0,
+            url: input,
+        };
+        const created = await client.sdk.createImageMessageByURL({
+            sourcePicture: pic,
+            bigPicture: { ...pic },
+            snapshotPicture: { ...pic },
+            sourcePath: name,
+        });
+        message = created?.data;
+    }
+    else {
+        const local = await readLocalFile(input);
+        const pic = {
+            uuid: randomUUID(),
+            type: local.mime,
+            size: local.size,
+            width: 0,
+            height: 0,
+            url: "",
+        };
+        const created = await client.sdk.createImageMessageByFile({
+            sourcePicture: pic,
+            bigPicture: { ...pic },
+            snapshotPicture: { ...pic },
+            sourcePath: local.filePath,
+            file: local.file,
+        });
+        message = created?.data;
+    }
+    if (!message)
+        throw new Error("createImageMessage returned no message");
+    const { recvID, groupID } = getRecvAndGroupID(target);
+    await client.sdk.sendMessage({ recvID, groupID, message });
+}
+export async function sendFileToTarget(client, target, filePathOrUrl, name) {
+    const input = filePathOrUrl.trim();
+    if (!input)
+        throw new Error("file is empty");
+    let message;
+    if (isHttpUrl(input)) {
+        const fileName = name?.trim() || nameFromUrl(input, "file.bin");
+        const created = await client.sdk.createFileMessageByURL({
+            filePath: fileName,
+            fileName,
+            uuid: randomUUID(),
+            sourceUrl: input,
+            fileSize: 0,
+            fileType: guessMime(fileName),
+        });
+        message = created?.data;
+    }
+    else {
+        const local = await readLocalFile(input, name);
+        const created = await client.sdk.createFileMessageByFile({
+            filePath: local.filePath,
+            fileName: local.fileName,
+            uuid: randomUUID(),
+            sourceUrl: "",
+            fileSize: local.size,
+            fileType: local.mime,
+            file: local.file,
+        });
+        message = created?.data;
+    }
+    if (!message)
+        throw new Error("createFileMessage returned no message");
+    const { recvID, groupID } = getRecvAndGroupID(target);
+    await client.sdk.sendMessage({ recvID, groupID, message });
+}
+export async function sendVideoToTarget(client, target, video, name) {
+    return sendFileToTarget(client, target, video, name);
+}

package/dist/polyfills.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Browser-API polyfills required by `@openim/client-sdk` when running under
+ * Node. Imported for side-effects at plugin startup.
+ */
+export {};

package/dist/polyfills.js

@@ -0,0 +1,27 @@
+/**
+ * Browser-API polyfills required by `@openim/client-sdk` when running under
+ * Node. Imported for side-effects at plugin startup.
+ */
+class NodeFileReader {
+    result = null;
+    error = null;
+    onload = null;
+    onerror = null;
+    readAsArrayBuffer(blob) {
+        blob
+            .arrayBuffer()
+            .then((buf) => {
+            this.result = buf;
+            this.onload?.({ target: this });
+        })
+            .catch((err) => {
+            this.error = err instanceof Error ? err : new Error(String(err));
+            this.onerror?.(err);
+        });
+    }
+}
+const g = globalThis;
+if (typeof g.FileReader === "undefined") {
+    g.FileReader = NodeFileReader;
+}
+export {};

package/dist/setup.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Interactive setup wizard: `openclaw multi-openim setup`.
+ *
+ * Writes a single account into `channels.multi-openim.accounts.<id>` inside
+ * `~/.openclaw/openclaw.json`. The default accountId is `primary`.
+ */
+export interface SetupOptions {
+    accountId?: string;
+}
+export declare function runSetup(opts?: SetupOptions): Promise<void>;

package/dist/setup.js

@@ -0,0 +1,69 @@
+/**
+ * Interactive setup wizard: `openclaw multi-openim setup`.
+ *
+ * Writes a single account into `channels.multi-openim.accounts.<id>` inside
+ * `~/.openclaw/openclaw.json`. The default accountId is `primary`.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import * as readline from "node:readline/promises";
+import { CHANNEL_ID } from "./types.js";
+const OPENCLAW_HOME = join(homedir(), ".openclaw");
+const CONFIG_PATH = join(OPENCLAW_HOME, "openclaw.json");
+const DEFAULT_ACCOUNT_NAME = "primary";
+async function ask(rl, label, defaultValue) {
+    const suffix = defaultValue ? ` [${defaultValue}]` : "";
+    const answer = await rl.question(`${label}${suffix}: `);
+    const trimmed = String(answer ?? "").trim();
+    return trimmed || defaultValue;
+}
+export async function runSetup(opts = {}) {
+    const accountId = String(opts.accountId ?? DEFAULT_ACCOUNT_NAME).trim() || DEFAULT_ACCOUNT_NAME;
+    process.stdout.write(`\nMulti-OpenIM Channel Setup (account="${accountId}")\n`);
+    process.stdout.write("Press Ctrl-C to cancel.\n\n");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    let token;
+    let wsAddr;
+    let apiAddr;
+    try {
+        token = await ask(rl, "OpenIM Access Token", process.env.MULTI_OPENIM_TOKEN || "");
+        wsAddr = await ask(rl, "OpenIM WebSocket endpoint", process.env.MULTI_OPENIM_WS_ADDR || "ws://127.0.0.1:10001");
+        apiAddr = await ask(rl, "OpenIM REST API endpoint", process.env.MULTI_OPENIM_API_ADDR || "http://127.0.0.1:10002");
+    }
+    finally {
+        rl.close();
+    }
+    if (!token || !wsAddr || !apiAddr) {
+        process.stderr.write("Fields `token`, `wsAddr`, and `apiAddr` cannot be empty.\n");
+        process.exit(1);
+    }
+    let existing = {};
+    if (existsSync(CONFIG_PATH)) {
+        try {
+            existing = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+        }
+        catch {
+            existing = {};
+        }
+    }
+    const channels = (existing.channels ?? {});
+    const channelBlock = (channels[CHANNEL_ID] ?? {});
+    const accounts = (channelBlock.accounts ?? {});
+    accounts[accountId] = {
+        enabled: true,
+        token,
+        wsAddr,
+        apiAddr,
+    };
+    channelBlock.accounts = accounts;
+    if (channelBlock.enabled !== true)
+        channelBlock.enabled = true;
+    channels[CHANNEL_ID] = channelBlock;
+    const next = { ...existing, channels };
+    mkdirSync(OPENCLAW_HOME, { recursive: true });
+    writeFileSync(CONFIG_PATH, JSON.stringify(next, null, 2), "utf-8");
+    process.stdout.write(`\nAccount "${accountId}" written to ${CONFIG_PATH}\n`);
+    process.stdout.write("userID/platformID will be auto-derived from JWT claims.\n");
+    process.stdout.write("Run `openclaw gateway restart` to load the updated configuration.\n");
+}

package/dist/targets.d.ts

@@ -0,0 +1,7 @@
+import type { ParsedTarget } from "./types.js";
+export declare function parseTarget(to: unknown): ParsedTarget | null;
+export declare function formatTarget(target: ParsedTarget): string;
+export declare function getRecvAndGroupID(target: ParsedTarget): {
+    recvID: string;
+    groupID: string;
+};

package/dist/targets.js

@@ -0,0 +1,38 @@
+import { CHANNEL_ID } from "./types.js";
+const PREFIX_PATTERNS = [
+    new RegExp(`^${CHANNEL_ID}:`, "i"),
+    /^openim:/i,
+    /^im:/i,
+];
+function stripChannelPrefix(raw) {
+    for (const re of PREFIX_PATTERNS) {
+        if (re.test(raw)) {
+            return raw.replace(re, "");
+        }
+    }
+    return raw;
+}
+export function parseTarget(to) {
+    const raw = String(to ?? "").trim();
+    if (!raw)
+        return null;
+    const stripped = stripChannelPrefix(raw);
+    if (/^user:/i.test(stripped)) {
+        const id = stripped.slice("user:".length).trim();
+        return id ? { kind: "user", id } : null;
+    }
+    if (/^group:/i.test(stripped)) {
+        const id = stripped.slice("group:".length).trim();
+        return id ? { kind: "group", id } : null;
+    }
+    return { kind: "user", id: stripped };
+}
+export function formatTarget(target) {
+    return `${target.kind}:${target.id}`;
+}
+export function getRecvAndGroupID(target) {
+    return {
+        recvID: target.kind === "user" ? target.id : "",
+        groupID: target.kind === "group" ? target.id : "",
+    };
+}

package/dist/token-refresh.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Token-refresh orchestration. Invoked from clients.ts when the SDK reports
+ * a token-related failure (OnUserTokenExpired / OnUserTokenInvalid /
+ * OnConnectFailed / OnKickedOffline / initial login() rejection).
+ *
+ * Three modes, picked by `tokenRefresh.mode`:
+ *
+ *   - "http": a fully config-driven HTTP request, performed in-process via
+ *     the standard `fetch`. Reads context from an optional state JSON file
+ *     keyed by accountId, substitutes `{accountId}` / `{state.<field>}`
+ *     placeholders into the configured endpoint / headers / body, posts
+ *     the request, extracts the new token by dot-path from the response,
+ *     optionally writes-back response fields into the state file, and
+ *     patches the gateway's openclaw.json so the new token survives a
+ *     restart. The channel does not embed any backend-specific strings.
+ *
+ *   - "hook": call `globalThis.__multiOpenimTokenRefresher(accountId,
+ *     reason)`. Power-user escape hatch when refresh logic is too
+ *     imperative for HTTP-template config.
+ *
+ *   - "off": skip recovery, write the manual-login marker immediately.
+ *
+ * The plugin never spawns subprocesses; both recovery paths are pure JS.
+ */
+import type { PluginContext } from "./context.js";
+import type { TokenRefreshConfig } from "./types.js";
+export interface RefreshOutcome {
+    ok: boolean;
+    token?: string;
+    userID?: string;
+    error?: string;
+    via?: "hook" | "off" | "no-hook" | "http" | "no-http";
+}
+/**
+ * Resolve the per-account marker file path. `manualLoginMarkerPath` is a
+ * template into which the accountId is inserted:
+ *
+ *   "/path/to/manual-login.json"  → "/path/to/manual-login.<accountId>.json"
+ *   "/path/to/markers/"           → "/path/to/markers/<accountId>.json"
+ *   "/path/no-ext"                → "/path/no-ext.<accountId>"
+ */
+export declare function resolveManualLoginMarkerPath(cfg: TokenRefreshConfig, accountId: string): string | undefined;
+export declare function writeManualLoginMarker(ctx: PluginContext, accountId: string, detail: string): void;
+export declare function clearManualLoginMarker(cfg: TokenRefreshConfig, accountId: string): void;
+export interface RefreshOrchestratorArgs {
+    ctx: PluginContext;
+    accountId: string;
+    reason: string;
+}
+export declare function refreshAccountToken(args: RefreshOrchestratorArgs): Promise<RefreshOutcome>;