multi-openim-channel 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Multi-OpenIM
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,255 @@
+# multi-openim-channel
+
+An OpenClaw gateway plugin for connecting to **OpenIM** servers
+(via `@openim/client-sdk`) with multi-account / multi-server support,
+config-driven token refresh, and an optional friend-API guard.
+
+## Highlights
+
+- **Multi-account, multi-server out of the box.** Each `accounts.<id>` has its
+  own `wsAddr` / `apiAddr` / `token`, so a single plugin instance can hold
+  long-lived connections to several different OpenIM servers in parallel.
+- **No silent `default` account.** The single-account fallback (top-level
+  `token` / `wsAddr` / `apiAddr` on the channel block) is intentionally
+  removed. Named accounts under `accounts.<id>` are mandatory.
+- **Per-account session keys.** Direct-chat session keys are always
+  `multi-openim:<sendID>:<accountId>` (lower-cased), so two accounts in
+  the same conversation with the same peer never collide.
+- **Optional friend SDK guard.** When `disableFriendSdk` is true (the
+  default), the OpenIM JS SDK's friend methods (`addFriend` /
+  `acceptFriendApplication` / ...) are stubbed with throwing functions
+  that surface a grep-able error code (`MULTI_OPENIM_FRIEND_API_DISABLED`).
+  Use this when an external system owns friend relationships; set
+  `disableFriendSdk: false` to restore raw SDK behavior.
+- **Config-driven HTTP token refresh.** When the SDK emits
+  `OnUserTokenExpired` / `OnUserTokenInvalid` / `OnConnectFailed` /
+  `OnKickedOffline`, the plugin performs an in-process `fetch` against an
+  operator-supplied refresh endpoint, parses the response by configurable
+  dot-paths, optionally writes fields back into a sidecar JSON state file,
+  and patches `openclaw.json` so the new token survives a restart. The
+  channel does not embed any backend-specific strings — every backend
+  detail is operator input. No subprocesses, no bridge plugin. A
+  `globalThis.__multiOpenimTokenRefresher` hook is still supported for
+  power users who need imperative recovery. On terminal failure a
+  per-account manual-login marker JSON is written.
+- **Strict accountId in tools.** MCP tools (`multi_openim_send_text` /
+  `multi_openim_send_image` / `multi_openim_send_video` /
+  `multi_openim_send_file`) require `accountId`; no "first connected wins"
+  surprises.
+- **Per-channel health-monitor interval.** `healthCheckIntervalMinutes`
+  (default 30) overrides the gateway global without an unrelated
+  `gateway.channelHealthCheckMinutes` knob.
+
+## Install
+
+```bash
+# from a local checkout (recommended while iterating):
+openclaw plugins install /path/to/multi-openim-channel
+
+# from the npm registry (when published):
+openclaw plugins install multi-openim-channel
+```
+
+After install:
+
+```bash
+openclaw multi-openim setup       # interactive (writes channels.multi-openim.accounts.primary)
+openclaw gateway restart          # load the channel
+openclaw plugins inspect multi-openim-channel --json
+```
+
+## Identity mapping
+
+- **npm package**: `multi-openim-channel`
+- **plugin id**: `multi-openim-channel`
+- **channel id**: `multi-openim` (used in `openclaw.json` under `channels.multi-openim`)
+- **setup command**: `openclaw multi-openim setup [--account <id>]`
+- **MCP tools**: `multi_openim_send_text`, `multi_openim_send_image`,
+  `multi_openim_send_video`, `multi_openim_send_file`
+
+## Configuration (`~/.openclaw/openclaw.json`)
+
+```json
+{
+  "channels": {
+    "multi-openim": {
+      "enabled": true,
+      "healthCheckIntervalMinutes": 30,
+      "disableFriendSdk": true,
+      "tokenRefresh": {
+        "mode": "http",
+        "http": {
+          "stateFile": "/abs/path/to/tokens.json",
+          "endpoint":  "https://auth.example.com/refresh",
+          "headers":   { "content-type": "application/json" },
+          "body":      { "refreshToken": "{state.refresh_token}" },
+          "responseTokenPath": "token"
+        }
+      },
+      "accounts": {
+        "primary": {
+          "enabled": true,
+          "token":   "<JWT for OpenIM server A>",
+          "wsAddr":  "ws://im-a.example.com:10001",
+          "apiAddr": "http://im-a.example.com:10002"
+        },
+        "team-b": {
+          "enabled": true,
+          "token":   "<JWT for OpenIM server B>",
+          "wsAddr":  "ws://im-b.example.com:10001",
+          "apiAddr": "http://im-b.example.com:10002",
+          "requireMention": true,
+          "inboundWhitelist": []
+        }
+      }
+    }
+  }
+}
+```
+
+`userID` / `platformID` are optional and auto-derived from JWT `UserID` /
+`PlatformID` claims when omitted.
+
+See [SCHEMA.md](./SCHEMA.md) for the full field reference.
+
+## Token refresh
+
+Three modes, selected by `channels.multi-openim.tokenRefresh.mode`:
+
+| Mode | Behavior |
+|---|---|
+| `http` *(recommended)* | Pure in-process `fetch` driven by `tokenRefresh.http`. Reads optional context from a `stateFile`, substitutes `{accountId}` / `{state.<field>}` placeholders into the configured endpoint / headers / body, posts the request, extracts the new token by dot-path, optionally writes-back response fields into the state file, and patches `openclaw.json`. |
+| `hook` *(default for back-compat)* | Call `globalThis.__multiOpenimTokenRefresher(accountId, reason)`. If unset, or it returns null / throws, write the manual-login marker. |
+| `off` | Don't try to recover — write the manual-login marker immediately. |
+
+Manual-login marker default path template:
+`~/.openclaw/multi-openim/manual-login.json`. The configured value is
+treated as a template — the accountId is inserted before the extension,
+so the actual files written are
+`~/.openclaw/multi-openim/manual-login.<accountId>.json`. This guarantees
+N accounts produce N independent markers instead of silently overwriting
+each other. Override via `tokenRefresh.manualLoginMarkerPath`.
+
+### `tokenRefresh.http` (config-driven HTTP refresh)
+
+The channel does not know your auth backend. Every backend-specific
+string — the URL, the request body shape, the JSON paths to find the new
+token — is configuration. `{accountId}` and `{state.<field>}` are
+substituted into string templates (URL, header values, body string leaves,
+`clearOnSuccess` paths). `state.<field>` reads `stateFile[accountId][field]`.
+
+Minimal example, against an auth server that exposes `POST /refresh` with
+a `{refreshToken}` body and a `{token: ...}` response:
+
+```jsonc
+{
+  "channels": {
+    "multi-openim": {
+      "tokenRefresh": {
+        "mode": "http",
+        "http": {
+          "stateFile": "/abs/path/to/tokens.json",
+          "endpoint":  "https://auth.example.com/refresh",
+          "method":    "POST",
+          "headers":   { "content-type": "application/json" },
+          "body":      { "refreshToken": "{state.refresh_token}" },
+          "responseTokenPath":    "token",
+          "stateWriteBack":       { "refresh_token": "refresh_token" }
+        }
+      }
+    }
+  }
+}
+```
+
+The expected `tokens.json` shape is keyed by `accountId`:
+
+```json
+{
+  "primary": { "refresh_token": "..." },
+  "team-b":  { "refresh_token": "..." }
+}
+```
+
+Multi-server example (different auth backend per account, response has
+the new token under `tokens.openimToken` with a `data.openimToken`
+fallback, and three response fields are persisted back into state):
+
+```jsonc
+{
+  "tokenRefresh": {
+    "mode": "http",
+    "http": {
+      "stateFile":  "/abs/path/to/tokens.json",
+      "endpoint":   "{state.auth_server_url}/api/refresh",
+      "method":     "POST",
+      "headers":    { "content-type": "application/json" },
+      "body":       { "refreshToken": "{state.refresh_token}" },
+      "timeoutMs":  15000,
+      "responseTokenPath":  ["tokens.openimToken", "data.openimToken"],
+      "stateWriteBack": {
+        "openim_token":  ["tokens.openimToken",  "data.openimToken"],
+        "access_token":  ["tokens.accessToken",  "data.accessToken"],
+        "refresh_token": ["tokens.refreshToken", "data.refreshToken"]
+      },
+      "clearOnSuccess": ["/abs/path/to/manual-login.{accountId}.json"]
+    }
+  }
+}
+```
+
+On a successful refresh the new token is also written to
+`channels.multi-openim.accounts.<accountId>.token` in
+`~/.openclaw/openclaw.json` (or `$OPENCLAW_CONFIG_PATH`) so it survives a
+gateway restart.
+
+### `globalThis.__multiOpenimTokenRefresher` (programmatic hook)
+
+Available for `mode: "hook"`. Use this when the refresh logic is too
+imperative for HTTP-template config:
+
+```ts
+globalThis.__multiOpenimTokenRefresher = async (accountId, reason) => {
+  // reason looks like "OnUserTokenExpired" or "OnConnectFailed errCode=10001"
+  const newToken = await yourTokenStore.refresh(accountId, reason);
+  if (!newToken) return null;
+  return { token: newToken };        // optionally include `userID` if your store rotates identity
+};
+```
+
+## Friend-guard (default ON)
+
+```text
+MULTI_OPENIM_FRIEND_API_DISABLED: SDK addFriend() is disabled by multi-openim-channel
+(account=primary). Route friend operations through your own backend.
+```
+
+The following SDK methods are replaced with throwing stubs on every
+connected account: `addFriend`, `addFriendV2`, `applyFriend`,
+`acceptFriendApplication`, `refuseFriendApplication`, `deleteFriend`,
+`checkFriend`, `setFriendRemark`, `addBlack`, `removeBlack`,
+`getFriendApplicationListAsApplicant`,
+`getFriendApplicationListAsRecipient`, `getFriendApplicationList`,
+`getRecvFriendApplicationList`, `getSendFriendApplicationList`,
+`getFriendList`.
+
+Set `disableFriendSdk: false` on the channel block (or per account) to
+restore raw SDK behavior. Recommended when an external system is the
+authoritative store for friend relationships and you want a single source
+of truth.
+
+## Development
+
+```bash
+npm install
+npm run build
+npm run validate    # static checks on dist + manifest
+npm run smoke       # optional live SDK login test (needs .env)
+```
+
+For `npm run smoke`, copy `.env.example` to `.env` and fill in test
+credentials.
+
+## License
+
+MIT. See [LICENSE](./LICENSE).

package/SCHEMA.md

@@ -0,0 +1,167 @@
+# Configuration Schema
+
+Lives under `channels.multi-openim` in `~/.openclaw/openclaw.json`.
+
+## Channel block
+
+```jsonc
+{
+  "channels": {
+    "multi-openim": {
+      "enabled": true,                       // optional, default true
+      "healthCheckIntervalMinutes": 30,      // optional, default 30; min 1
+      "disableFriendSdk": true,              // optional, default true
+      "tokenRefresh": { ... },               // optional
+      "accounts": { ... }                    // REQUIRED; must contain ≥ 1 named entry
+    }
+  }
+}
+```
+
+The plugin **rejects** the single-account fallback. Any of
+`token` / `wsAddr` / `apiAddr` / `userID` / `platformID` placed at the
+channel level (next to `accounts`) will be logged as a warning and ignored.
+
+### `tokenRefresh`
+
+```jsonc
+{
+  "tokenRefresh": {
+    "mode": "http",                            // "http" | "hook" | "off"
+    "manualLoginMarkerPath": "/abs/path.json", // optional, template — <accountId> is inserted before the extension, so the actual path is /abs/path.<accountId>.json. Default: ~/.openclaw/multi-openim/manual-login.json → manual-login.<accountId>.json
+    "http": { ... }                            // required when mode="http"; see below
+  }
+}
+```
+
+| Mode | Behavior |
+|---|---|
+| `http` *(recommended)* | Pure in-process `fetch` driven by `tokenRefresh.http`. See "`tokenRefresh.http`" below. |
+| `hook` *(default for back-compat)* | Call `globalThis.__multiOpenimTokenRefresher(accountId, reason)`. If unset, or it returns null/throws, write the manual-login marker. |
+| `off` | Don't try to recover; write the manual-login marker immediately. |
+
+The plugin never spawns subprocesses; both `http` and `hook` are pure JS.
+The `globalThis.__multiOpenimTokenRefresher(accountId, reason) => Promise<{token, userID?} | null>`
+hook is supported when imperative recovery is needed.
+
+### `tokenRefresh.http`
+
+Fully config-driven. The channel knows nothing about your auth backend's
+domain model — every backend-specific string is provided here. Templates
+support these placeholders:
+
+- `{accountId}` → the account being refreshed
+- `{state.<field>}` → `stateFile[accountId][field]`, coerced to string
+
+```jsonc
+{
+  "tokenRefresh": {
+    "mode": "http",
+    "http": {
+      "stateFile": "/abs/path/to/tokens.json",   // optional; JSON keyed by accountId
+      "endpoint":  "{state.server_url}/auth/refresh",  // REQUIRED
+      "method":    "POST",                       // default POST
+      "headers":   { "content-type": "application/json" },
+      "body":      { "refreshToken": "{state.refresh_token}" },  // object → JSON; string → verbatim
+      "timeoutMs": 15000,                        // default 15000
+
+      // REQUIRED — first non-empty wins
+      "responseTokenPath": ["tokens.openimToken", "data.openimToken"],
+
+      // optional userID rotation
+      "responseUserIdPath": "tokens.userId",
+
+      // optional: persist response fields back into stateFile
+      "stateWriteBack": {
+        "refresh_token": "tokens.refreshToken",
+        "access_token":  "tokens.accessToken"
+      },
+
+      // optional: extra paths to delete on success (supports {accountId})
+      "clearOnSuccess": ["/abs/path/manual-login.{accountId}.json"]
+    }
+  }
+}
+```
+
+Behavior:
+
+1. Read `stateFile[accountId]` if `stateFile` is set.
+2. Substitute `{accountId}` and `{state.<field>}` placeholders into
+   `endpoint`, header values, `body` (recursively into string leaves of
+   object bodies), and `clearOnSuccess` items.
+3. `fetch(url, { method, headers, body, signal: AbortSignal.timeout(timeoutMs) })`.
+4. Treat any non-2xx as failure (logged with response body truncated to
+   300 chars).
+5. Parse response as JSON; extract `responseTokenPath` (and optionally
+   `responseUserIdPath`) by dot-path. First non-empty path wins.
+6. If `stateWriteBack` is set and any field resolved, merge them into
+   `stateFile[accountId]` and write the file back atomically.
+7. Patch `~/.openclaw/openclaw.json` (or `$OPENCLAW_CONFIG_PATH`)
+   `channels.multi-openim.accounts.<accountId>.token` so the new JWT
+   survives a gateway restart.
+8. `unlink` each `clearOnSuccess` entry (best-effort; "missing" is fine).
+9. Return the new token to the recovery loop, which logs the SDK out and
+   back in.
+
+When `mode: "http"` but `tokenRefresh.http.endpoint` or
+`responseTokenPath` is missing, the plugin logs a warning at startup and
+downgrades the mode to `off` (so you get a clear manual-login marker
+rather than silent retries).
+
+## Account block
+
+```jsonc
+{
+  "accounts": {
+    "<accountId>": {
+      "enabled": true,                  // optional, default true
+      "token":   "<JWT>",               // REQUIRED — OpenIM JWT
+      "wsAddr":  "ws://host:10001",     // REQUIRED — OpenIM long-poll endpoint
+      "apiAddr": "http://host:10002",   // REQUIRED — OpenIM REST endpoint
+      "userID": "<openim user id>",     // optional — auto-derived from JWT "UserID" claim
+      "platformID": 5,                  // optional — auto-derived from JWT "PlatformID" or defaults to 5
+      "requireMention": true,           // optional, default true (in groups, reply only if @-mentioned)
+      "inboundWhitelist": [],           // optional, default [] (when non-empty, ONLY listed userIDs trigger)
+      "disableFriendSdk": true          // optional, overrides channel-level
+    }
+  }
+}
+```
+
+Failure modes (logged + skipped on startup):
+
+| Missing | Plugin behavior |
+|---|---|
+| `token` / `wsAddr` / `apiAddr` | Skip the account; log a warning. Other accounts continue. |
+| `userID` (and no JWT `UserID` claim) | Skip the account; log a warning. |
+
+The accountId you pick is significant — it shows up as the suffix of
+every direct session key (`multi-openim:<sendID>:<accountId>`), in MCP
+tool calls, in log lines, and in the manual-login marker. Pick something
+stable and short: `primary`, `team-b`, `support`, etc. **Do not name it
+`default`** unless you truly mean it.
+
+## Status reporting
+
+Each account reports lifecycle status back to the gateway via OpenClaw's
+`setStatus` callback. Snapshot shape:
+
+```ts
+{
+  accountId: string;
+  enabled: boolean;
+  configured: true;
+  running: boolean;
+  connected: boolean;
+  lastConnectedAt?: number;   // ms epoch
+  lastError?: string | null;  // truncated to 500 chars
+}
+```
+
+## Environment overrides
+
+The plugin does not read OpenIM-style `OPENIM_TOKEN` / `OPENIM_WS_ADDR`
+env vars at runtime. The smoke test env vars (`MULTI_OPENIM_TEST_*`, see
+`.env.example`) are only used by `npm run smoke`. Production accounts
+must be declared in `openclaw.json`.

package/dist/channel.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Channel descriptor factory. The descriptor closes over the active
+ * PluginContext, so a hypothetical re-register cleanly produces a fresh
+ * descriptor instead of sharing mutable state with the previous one.
+ */
+import type { PluginContext } from "./context.js";
+import type { AccountConfig, GatewayStartAccountCtx, GatewayStopAccountCtx } from "./types.js";
+export interface OutboundSendTextArgs {
+    to: string;
+    text: string;
+    accountId?: string;
+}
+export interface OutboundResult {
+    ok: boolean;
+    provider?: string;
+    error?: Error;
+}
+export declare function createChannelPlugin(ctx: PluginContext): {
+    id: "multi-openim";
+    meta: {
+        id: "multi-openim";
+        label: string;
+        selectionLabel: string;
+        docsPath: string;
+        blurb: string;
+        aliases: string[];
+    };
+    capabilities: {
+        chatTypes: readonly ["direct", "group"];
+    };
+    config: {
+        listAccountIds: (cfg: unknown) => string[];
+        resolveAccount: (cfg: unknown, accountId?: string) => {
+            accountId: string;
+        } & Partial<AccountConfig>;
+    };
+    gateway: {
+        healthCheckIntervalMinutes: number;
+        startAccount: (lifecycleCtx: GatewayStartAccountCtx) => Promise<void>;
+        stopAccount: (lifecycleCtx: GatewayStopAccountCtx) => Promise<void>;
+    };
+    outbound: {
+        deliveryMode: "direct";
+        resolveTarget: ({ to }: {
+            to?: string;
+        }) => {
+            ok: false;
+            error: Error;
+            to?: undefined;
+        } | {
+            ok: true;
+            to: string;
+            error?: undefined;
+        };
+        sendText: ({ to, text, accountId }: OutboundSendTextArgs) => Promise<OutboundResult>;
+    };
+};

package/dist/channel.js

@@ -0,0 +1,104 @@
+/**
+ * Channel descriptor factory. The descriptor closes over the active
+ * PluginContext, so a hypothetical re-register cleanly produces a fresh
+ * descriptor instead of sharing mutable state with the previous one.
+ */
+import { getConnectedClient, hasConnectedAccountClient, snapshotAccountStatus, startAccountClient, stopAccountClient, } from "./clients.js";
+import { getAccountConfig, listAccountIds, resolveAccountConfig } from "./config.js";
+import { sendTextToTarget } from "./media.js";
+import { parseTarget } from "./targets.js";
+import { CHANNEL_ID } from "./types.js";
+import { formatSdkError, logTag } from "./utils.js";
+function waitUntilAborted(signal) {
+    if (!signal)
+        return new Promise(() => undefined);
+    if (signal.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        signal.addEventListener("abort", () => resolve(), { once: true });
+    });
+}
+export function createChannelPlugin(ctx) {
+    return {
+        id: CHANNEL_ID,
+        meta: {
+            id: CHANNEL_ID,
+            label: "Multi-OpenIM",
+            selectionLabel: "Multi-OpenIM",
+            docsPath: `/channels/${CHANNEL_ID}`,
+            blurb: "Multi-account / multi-server OpenIM channel with config-driven token refresh",
+            aliases: [CHANNEL_ID, "multi-openim-im", "mopenim"],
+        },
+        capabilities: {
+            chatTypes: ["direct", "group"],
+        },
+        config: {
+            listAccountIds: (cfg) => listAccountIds(cfg),
+            resolveAccount: (cfg, accountId) => resolveAccountConfig(cfg, accountId),
+        },
+        gateway: {
+            healthCheckIntervalMinutes: ctx.channel.healthCheckIntervalMinutes,
+            startAccount: async (lifecycleCtx) => {
+                const account = getAccountConfig(lifecycleCtx.cfg, lifecycleCtx.accountId);
+                if (!account || !account.enabled) {
+                    throw new Error(`${CHANNEL_ID} account "${lifecycleCtx.accountId}" is not configured or disabled`);
+                }
+                lifecycleCtx.setStatus?.({
+                    accountId: account.accountId,
+                    enabled: account.enabled,
+                    configured: true,
+                    lastError: null,
+                });
+                if (!hasConnectedAccountClient(account.accountId)) {
+                    await startAccountClient(ctx, account);
+                }
+                if (!hasConnectedAccountClient(account.accountId)) {
+                    throw new Error(`${CHANNEL_ID} account "${account.accountId}" failed to connect`);
+                }
+                lifecycleCtx.setStatus?.(snapshotAccountStatus(account.accountId));
+                lifecycleCtx.log?.info?.(`${logTag("lifecycle")} account=${account.accountId} running`);
+                try {
+                    await waitUntilAborted(lifecycleCtx.abortSignal);
+                }
+                finally {
+                    await stopAccountClient(ctx, account.accountId);
+                    lifecycleCtx.log?.info?.(`${logTag("lifecycle")} account=${account.accountId} stopped`);
+                }
+            },
+            stopAccount: async (lifecycleCtx) => {
+                await stopAccountClient(ctx, lifecycleCtx.accountId);
+            },
+        },
+        outbound: {
+            deliveryMode: "direct",
+            resolveTarget: ({ to }) => {
+                const target = parseTarget(to);
+                if (!target) {
+                    return { ok: false, error: new Error("multi-openim requires --to <user:ID|group:ID>") };
+                }
+                return { ok: true, to: `${target.kind}:${target.id}` };
+            },
+            sendText: async ({ to, text, accountId }) => {
+                const target = parseTarget(to);
+                if (!target) {
+                    return { ok: false, error: new Error("invalid target, expected user:<id> or group:<id>") };
+                }
+                const id = String(accountId ?? "").trim();
+                if (!id) {
+                    return { ok: false, error: new Error("accountId is required (no default fallback)") };
+                }
+                const client = getConnectedClient(id);
+                if (!client) {
+                    return { ok: false, error: new Error(`multi-openim account "${id}" is not connected`) };
+                }
+                try {
+                    await sendTextToTarget(client, target, text);
+                    return { ok: true, provider: CHANNEL_ID };
+                }
+                catch (e) {
+                    return { ok: false, error: new Error(formatSdkError(e)) };
+                }
+            },
+        },
+    };
+}

package/dist/clients.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Per-account OpenIM SDK client lifecycle. Strict accountId lookups (no
+ * "default" fallback), per-account recovery backoff, and a decoupled
+ * inbound dispatcher slot so this module can be imported without forming
+ * a static cycle with inbound.ts.
+ */
+import type { MessageItem } from "@openim/client-sdk";
+import type { PluginContext } from "./context.js";
+import type { AccountConfig, ClientState, GatewayLifecycleStatus } from "./types.js";
+export type InboundDispatcher = (ctx: PluginContext, state: ClientState, msg: MessageItem) => Promise<void>;
+export declare function setInboundDispatcher(fn: InboundDispatcher): void;
+export declare function getConnectedClient(accountId: string | undefined | null): ClientState | null;
+export declare function hasConnectedAccountClient(accountId: string | undefined | null): boolean;
+export declare function connectedClientCount(): number;
+export declare function listConnectedAccountIds(): string[];
+export declare function startAccountClient(ctx: PluginContext, account: AccountConfig): Promise<void>;
+export declare function stopAccountClient(ctx: PluginContext, accountId: string): Promise<boolean>;
+export declare function stopAllClients(ctx: PluginContext): Promise<void>;
+export declare function snapshotAccountStatus(accountId: string): GatewayLifecycleStatus;
+export declare function _internal_resetClients(): void;