openclaw-ringcentral 2026.1.29-beta1

package/src/accounts.test.ts

@@ -0,0 +1,311 @@
+import { describe, expect, it, beforeEach, afterEach, vi } from "vitest";
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import {
+  listRingCentralAccountIds,
+  resolveDefaultRingCentralAccountId,
+  resolveRingCentralAccount,
+  listEnabledRingCentralAccounts,
+} from "./accounts.js";
+
+describe("listRingCentralAccountIds", () => {
+  it("returns default account when no accounts configured", () => {
+    const cfg = { channels: {} } as OpenClawConfig;
+    expect(listRingCentralAccountIds(cfg)).toEqual(["default"]);
+  });
+
+  it("returns default account when ringcentral channel not configured", () => {
+    const cfg = { channels: { telegram: { enabled: true } } } as OpenClawConfig;
+    expect(listRingCentralAccountIds(cfg)).toEqual(["default"]);
+  });
+
+  it("returns configured account IDs sorted alphabetically", () => {
+    const cfg = {
+      channels: {
+        ringcentral: {
+          accounts: {
+            work: { enabled: true },
+            personal: { enabled: true },
+          },
+        },
+      },
+    } as OpenClawConfig;
+    expect(listRingCentralAccountIds(cfg)).toEqual(["personal", "work"]);
+  });
+});
+
+describe("resolveDefaultRingCentralAccountId", () => {
+  it("returns explicitly set default account", () => {
+    const cfg = {
+      channels: {
+        ringcentral: {
+          defaultAccount: "work",
+          accounts: {
+            work: {},
+            personal: {},
+          },
+        },
+      },
+    } as OpenClawConfig;
+    expect(resolveDefaultRingCentralAccountId(cfg)).toBe("work");
+  });
+
+  it("returns default if included in accounts", () => {
+    const cfg = {
+      channels: {
+        ringcentral: {
+          accounts: {
+            default: {},
+            other: {},
+          },
+        },
+      },
+    } as OpenClawConfig;
+    expect(resolveDefaultRingCentralAccountId(cfg)).toBe("default");
+  });
+
+  it("returns first account ID when no default specified", () => {
+    const cfg = {
+      channels: {
+        ringcentral: {
+          accounts: {
+            zebra: {},
+            alpha: {},
+          },
+        },
+      },
+    } as OpenClawConfig;
+    expect(resolveDefaultRingCentralAccountId(cfg)).toBe("alpha");
+  });
+});
+
+describe("resolveRingCentralAccount", () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    vi.resetModules();
+    process.env = { ...originalEnv };
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  it("resolves account from config credentials", () => {
+    const cfg = {
+      channels: {
+        ringcentral: {
+          enabled: true,
+          credentials: {
+            clientId: "test-client-id",
+            clientSecret: "test-client-secret",
+            jwt: "test-jwt",
+            server: "https://platform.devtest.ringcentral.com",
+          },
+        },
+      },
+    } as OpenClawConfig;
+
+    const account = resolveRingCentralAccount({ cfg });
+
+    expect(account.accountId).toBe("default");
+    expect(account.enabled).toBe(true);
+    expect(account.credentialSource).toBe("config");
+    expect(account.clientId).toBe("test-client-id");
+    expect(account.clientSecret).toBe("test-client-secret");
+    expect(account.jwt).toBe("test-jwt");
+    expect(account.server).toBe("https://platform.devtest.ringcentral.com");
+  });
+
+  it("resolves account from environment variables", () => {
+    process.env.RINGCENTRAL_CLIENT_ID = "env-client-id";
+    process.env.RINGCENTRAL_CLIENT_SECRET = "env-client-secret";
+    process.env.RINGCENTRAL_JWT = "env-jwt";
+    process.env.RINGCENTRAL_SERVER = "https://platform.devtest.ringcentral.com";
+
+    const cfg = {
+      channels: {
+        ringcentral: {
+          enabled: true,
+        },
+      },
+    } as OpenClawConfig;
+
+    const account = resolveRingCentralAccount({ cfg });
+
+    expect(account.credentialSource).toBe("env");
+    expect(account.clientId).toBe("env-client-id");
+    expect(account.clientSecret).toBe("env-client-secret");
+    expect(account.jwt).toBe("env-jwt");
+    expect(account.server).toBe("https://platform.devtest.ringcentral.com");
+  });
+
+  it("returns none source when no credentials configured", () => {
+    const cfg = {
+      channels: {
+        ringcentral: {
+          enabled: true,
+        },
+      },
+    } as OpenClawConfig;
+
+    const account = resolveRingCentralAccount({ cfg });
+
+    expect(account.credentialSource).toBe("none");
+    expect(account.clientId).toBeUndefined();
+  });
+
+  it("uses default server when not specified", () => {
+    const cfg = {
+      channels: {
+        ringcentral: {
+          enabled: true,
+          credentials: {
+            clientId: "test-client-id",
+            clientSecret: "test-client-secret",
+            jwt: "test-jwt",
+          },
+        },
+      },
+    } as OpenClawConfig;
+
+    const account = resolveRingCentralAccount({ cfg });
+
+    expect(account.server).toBe("https://platform.ringcentral.com");
+  });
+
+  it("resolves specific account from accounts map", () => {
+    const cfg = {
+      channels: {
+        ringcentral: {
+          enabled: true,
+          accounts: {
+            work: {
+              credentials: {
+                clientId: "work-client-id",
+                clientSecret: "work-client-secret",
+                jwt: "work-jwt",
+              },
+              name: "Work Account",
+            },
+          },
+        },
+      },
+    } as OpenClawConfig;
+
+    const account = resolveRingCentralAccount({ cfg, accountId: "work" });
+
+    expect(account.accountId).toBe("work");
+    expect(account.name).toBe("Work Account");
+    expect(account.clientId).toBe("work-client-id");
+  });
+
+  it("merges base config with account config", () => {
+    const cfg = {
+      channels: {
+        ringcentral: {
+          enabled: true,
+          credentials: {
+            server: "https://base.server.com",
+          },
+          accounts: {
+            work: {
+              credentials: {
+                clientId: "work-client-id",
+                clientSecret: "work-client-secret",
+                jwt: "work-jwt",
+              },
+            },
+          },
+        },
+      },
+    } as OpenClawConfig;
+
+    const account = resolveRingCentralAccount({ cfg, accountId: "work" });
+
+    expect(account.server).toBe("https://base.server.com");
+  });
+
+  it("account config overrides base config", () => {
+    const cfg = {
+      channels: {
+        ringcentral: {
+          enabled: true,
+          credentials: {
+            server: "https://base.server.com",
+          },
+          accounts: {
+            work: {
+              credentials: {
+                clientId: "work-client-id",
+                clientSecret: "work-client-secret",
+                jwt: "work-jwt",
+                server: "https://work.server.com",
+              },
+            },
+          },
+        },
+      },
+    } as OpenClawConfig;
+
+    const account = resolveRingCentralAccount({ cfg, accountId: "work" });
+
+    expect(account.server).toBe("https://work.server.com");
+  });
+});
+
+describe("listEnabledRingCentralAccounts", () => {
+  it("returns only enabled accounts", () => {
+    const cfg = {
+      channels: {
+        ringcentral: {
+          enabled: true,
+          credentials: {
+            clientId: "base-id",
+            clientSecret: "base-secret",
+            jwt: "base-jwt",
+          },
+          accounts: {
+            enabled1: {
+              enabled: true,
+              credentials: {
+                clientId: "e1-id",
+                clientSecret: "e1-secret",
+                jwt: "e1-jwt",
+              },
+            },
+            disabled1: {
+              enabled: false,
+              credentials: {
+                clientId: "d1-id",
+                clientSecret: "d1-secret",
+                jwt: "d1-jwt",
+              },
+            },
+          },
+        },
+      },
+    } as OpenClawConfig;
+
+    const accounts = listEnabledRingCentralAccounts(cfg);
+
+    expect(accounts.map((a) => a.accountId)).toContain("enabled1");
+    expect(accounts.map((a) => a.accountId)).not.toContain("disabled1");
+  });
+
+  it("returns empty array when channel is disabled", () => {
+    const cfg = {
+      channels: {
+        ringcentral: {
+          enabled: false,
+          accounts: {
+            work: { enabled: true },
+          },
+        },
+      },
+    } as OpenClawConfig;
+
+    const accounts = listEnabledRingCentralAccounts(cfg);
+
+    expect(accounts).toEqual([]);
+  });
+});

package/src/accounts.ts

@@ -0,0 +1,167 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk";
+
+import type { RingCentralAccountConfig, RingCentralConfig } from "./types.js";
+
+export type RingCentralCredentialSource = "config" | "env" | "none";
+
+export type ResolvedRingCentralAccount = {
+  accountId: string;
+  name?: string;
+  enabled: boolean;
+  config: RingCentralAccountConfig;
+  credentialSource: RingCentralCredentialSource;
+  clientId?: string;
+  clientSecret?: string;
+  jwt?: string;
+  server: string;
+};
+
+const ENV_CLIENT_ID = "RINGCENTRAL_CLIENT_ID";
+const ENV_CLIENT_SECRET = "RINGCENTRAL_CLIENT_SECRET";
+const ENV_JWT = "RINGCENTRAL_JWT";
+const ENV_SERVER = "RINGCENTRAL_SERVER";
+
+const DEFAULT_SERVER = "https://platform.ringcentral.com";
+
+function listConfiguredAccountIds(cfg: OpenClawConfig): string[] {
+  const accounts = (cfg.channels?.ringcentral as RingCentralConfig | undefined)?.accounts;
+  if (!accounts || typeof accounts !== "object") return [];
+  return Object.keys(accounts).filter(Boolean);
+}
+
+export function listRingCentralAccountIds(cfg: OpenClawConfig): string[] {
+  const ids = listConfiguredAccountIds(cfg);
+  if (ids.length === 0) return [DEFAULT_ACCOUNT_ID];
+  return ids.sort((a, b) => a.localeCompare(b));
+}
+
+export function resolveDefaultRingCentralAccountId(cfg: OpenClawConfig): string {
+  const channel = cfg.channels?.ringcentral as RingCentralConfig | undefined;
+  if (channel?.defaultAccount?.trim()) return channel.defaultAccount.trim();
+  const ids = listRingCentralAccountIds(cfg);
+  if (ids.includes(DEFAULT_ACCOUNT_ID)) return DEFAULT_ACCOUNT_ID;
+  return ids[0] ?? DEFAULT_ACCOUNT_ID;
+}
+
+function resolveAccountConfig(
+  cfg: OpenClawConfig,
+  accountId: string,
+): RingCentralAccountConfig | undefined {
+  const accounts = (cfg.channels?.ringcentral as RingCentralConfig | undefined)?.accounts;
+  if (!accounts || typeof accounts !== "object") return undefined;
+  return accounts[accountId] as RingCentralAccountConfig | undefined;
+}
+
+function mergeRingCentralAccountConfig(
+  cfg: OpenClawConfig,
+  accountId: string,
+): RingCentralAccountConfig {
+  const raw = (cfg.channels?.ringcentral ?? {}) as RingCentralConfig;
+  const { accounts: _ignored, defaultAccount: _ignored2, ...base } = raw;
+  const account = resolveAccountConfig(cfg, accountId) ?? {};
+  return {
+    ...base,
+    ...account,
+    credentials: { ...base.credentials, ...account.credentials },
+  } as RingCentralAccountConfig;
+}
+
+function resolveCredentialsFromConfig(params: {
+  accountId: string;
+  account: RingCentralAccountConfig;
+}): {
+  clientId?: string;
+  clientSecret?: string;
+  jwt?: string;
+  server: string;
+  source: RingCentralCredentialSource;
+} {
+  const { account, accountId } = params;
+
+  const creds = account.credentials;
+  const configClientId = creds?.clientId?.trim();
+  const configClientSecret = creds?.clientSecret?.trim();
+  const configJwt = creds?.jwt?.trim();
+  const configServer = creds?.server?.trim() || DEFAULT_SERVER;
+
+  // 1. Check inline config first
+  if (configClientId && configClientSecret && configJwt) {
+    return {
+      clientId: configClientId,
+      clientSecret: configClientSecret,
+      jwt: configJwt,
+      server: configServer,
+      source: "config",
+    };
+  }
+
+  // 2. Check environment variables (default account only)
+  if (accountId === DEFAULT_ACCOUNT_ID) {
+    const envClientId = process.env[ENV_CLIENT_ID]?.trim();
+    const envClientSecret = process.env[ENV_CLIENT_SECRET]?.trim();
+    const envJwt = process.env[ENV_JWT]?.trim();
+    const envServer = process.env[ENV_SERVER]?.trim() || DEFAULT_SERVER;
+
+    if (envClientId && envClientSecret && envJwt) {
+      return {
+        clientId: envClientId,
+        clientSecret: envClientSecret,
+        jwt: envJwt,
+        server: envServer,
+        source: "env",
+      };
+    }
+
+    // 3. Allow partial config + env fallback
+    const finalClientId = configClientId || envClientId;
+    const finalClientSecret = configClientSecret || envClientSecret;
+    const finalJwt = configJwt || envJwt;
+    const finalServer = configServer !== DEFAULT_SERVER ? configServer : envServer;
+
+    if (finalClientId && finalClientSecret && finalJwt) {
+      const source: RingCentralCredentialSource =
+        configClientId || configClientSecret || configJwt ? "config" : "env";
+      return {
+        clientId: finalClientId,
+        clientSecret: finalClientSecret,
+        jwt: finalJwt,
+        server: finalServer,
+        source,
+      };
+    }
+  }
+
+  return { server: configServer, source: "none" };
+}
+
+export function resolveRingCentralAccount(params: {
+  cfg: OpenClawConfig;
+  accountId?: string | null;
+}): ResolvedRingCentralAccount {
+  const accountId = normalizeAccountId(params.accountId);
+  const baseEnabled =
+    (params.cfg.channels?.ringcentral as RingCentralConfig | undefined)?.enabled !== false;
+  const merged = mergeRingCentralAccountConfig(params.cfg, accountId);
+  const accountEnabled = merged.enabled !== false;
+  const enabled = baseEnabled && accountEnabled;
+  const credentials = resolveCredentialsFromConfig({ accountId, account: merged });
+
+  return {
+    accountId,
+    name: merged.name?.trim() || undefined,
+    enabled,
+    config: merged,
+    credentialSource: credentials.source,
+    clientId: credentials.clientId,
+    clientSecret: credentials.clientSecret,
+    jwt: credentials.jwt,
+    server: credentials.server,
+  };
+}
+
+export function listEnabledRingCentralAccounts(cfg: OpenClawConfig): ResolvedRingCentralAccount[] {
+  return listRingCentralAccountIds(cfg)
+    .map((accountId) => resolveRingCentralAccount({ cfg, accountId }))
+    .filter((account) => account.enabled);
+}