@clawling/clawchat-plugin-openclaw 2026.9.11-1 → 2026.9.13-2

package/src/config.ts

@@ -1,3 +1,9 @@
+import {
+  createAccountListHelpers,
+  mergeAccountConfig,
+  normalizeAccountId,
+  resolveNormalizedAccountEntry,
+} from "openclaw/plugin-sdk/account-core";
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
 
@@ -85,7 +91,7 @@ export type OpenclawClawlingAckConfig = {
   autoResendOnTimeout?: boolean;
 };
 
-export type OpenclawClawlingConfig = {
+export type OpenclawClawlingAccountConfig = {
   enabled?: boolean;
   websocketUrl?: string;
   baseUrl?: string;
@@ -115,7 +121,18 @@ export type OpenclawClawlingConfig = {
   ack?: OpenclawClawlingAckConfig;
 };
 
-export const openclawClawlingConfigSchema = {
+/**
+ * Channel section = the `default` account (and the inheritance base for every
+ * named account) plus the account map. Named accounts live under
+ * `accounts.<id>` and accept every key except the two map keys.
+ */
+export type OpenclawClawlingConfig = OpenclawClawlingAccountConfig & {
+  /** Which account `channels list/status` treats as default when several exist. */
+  defaultAccount?: string;
+  accounts?: Record<string, OpenclawClawlingAccountConfig>;
+};
+
+export const openclawClawlingAccountConfigSchema = {
   type: "object",
   additionalProperties: false,
   properties: {
@@ -187,6 +204,19 @@ export const openclawClawlingConfigSchema = {
   },
 } as const;
 
+export const openclawClawlingConfigSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    ...openclawClawlingAccountConfigSchema.properties,
+    defaultAccount: { type: "string" },
+    accounts: {
+      type: "object",
+      additionalProperties: openclawClawlingAccountConfigSchema,
+    },
+  },
+} as const;
+
 function isOpenclawClawchatToolAllowEntry(entry: unknown): boolean {
   return entry === CHANNEL_ID || entry === "group:plugins";
 }
@@ -309,6 +339,66 @@ function readChannelSection(cfg: OpenClawConfig): Record<string, unknown> {
   return channel && typeof channel === "object" ? (channel as Record<string, unknown>) : {};
 }
 
+/** Keys that identify a ClawChat account. Never inherited by a named account from the root. */
+export const ACCOUNT_CREDENTIAL_KEYS = ["token", "refreshToken", "agentId", "userId", "ownerUserId"] as const;
+const ACCOUNT_MAP_KEYS = ["accounts", "defaultAccount"] as const;
+const NESTED_ACCOUNT_OBJECT_KEYS = ["reconnect", "heartbeat", "ack"] as const;
+
+/** Host-identical account id normalization (lowercase, `[^a-z0-9_-]` → `-`, blank → `default`). */
+export function normalizeOpenclawClawlingAccountId(value?: string | null): string {
+  return normalizeAccountId(value);
+}
+
+function readAccountsMap(section: Record<string, unknown>): Record<string, Record<string, unknown>> | undefined {
+  const accounts = section.accounts;
+  return accounts && typeof accounts === "object" && !Array.isArray(accounts)
+    ? (accounts as Record<string, Record<string, unknown>>)
+    : undefined;
+}
+
+/**
+ * The single config read point. Root = the `default` account and the
+ * inheritance base; `accounts.<id>` overrides it. Credential keys are omitted
+ * from the base for named ids so an empty `accounts.work: {}` is unconfigured
+ * rather than a clone of the default identity. `accounts.default`, when the
+ * host's single-account promotion created one, merges over the root.
+ */
+export function readOpenclawClawlingAccountSection(
+  cfg: OpenClawConfig,
+  accountId?: string | null,
+): Record<string, unknown> {
+  const root = readChannelSection(cfg);
+  const id = normalizeOpenclawClawlingAccountId(accountId);
+  const resolved = resolveNormalizedAccountEntry(readAccountsMap(root), id, normalizeAccountId);
+  // The schema says every entry is an object; the file on disk may disagree
+  // (a hand-edited `accounts.work: "work"`). Spreading a non-record merges it
+  // in character by character, so treat it as absent.
+  const entry =
+    resolved && typeof resolved === "object" && !Array.isArray(resolved) ? resolved : undefined;
+  const omitKeys: string[] = [...ACCOUNT_MAP_KEYS];
+  if (id !== DEFAULT_ACCOUNT_ID) omitKeys.push(...ACCOUNT_CREDENTIAL_KEYS);
+  return mergeAccountConfig<Record<string, unknown>>({
+    channelConfig: root,
+    accountConfig: entry ?? {},
+    omitKeys,
+    nestedObjectKeys: [...NESTED_ACCOUNT_OBJECT_KEYS],
+  });
+}
+
+const accountListHelpers = createAccountListHelpers(CHANNEL_ID, {
+  normalizeAccountId,
+  // The root section is always an account, even when unconfigured.
+  hasImplicitDefaultAccount: () => true,
+});
+
+export function listOpenclawClawlingAccountIds(cfg: OpenClawConfig): string[] {
+  return accountListHelpers.listAccountIds(cfg);
+}
+
+export function resolveOpenclawClawlingDefaultAccountId(cfg: OpenClawConfig): string {
+  return accountListHelpers.resolveDefaultAccountId(cfg);
+}
+
 function readOptionalString(value: unknown): string {
   return typeof value === "string" ? value.trim() : "";
 }
@@ -501,9 +591,19 @@ function readAck(raw: unknown): Required<OpenclawClawlingAckConfig> {
 
 export function resolveOpenclawClawlingAccount(
   cfg: OpenClawConfig,
+  accountId?: string | null,
   env: Record<string, string | undefined> = process.env,
 ): ResolvedOpenclawClawlingAccount {
-  const channel = readChannelSection(cfg);
+  const resolvedAccountId =
+    accountId === undefined || accountId === null || !accountId.trim()
+      ? resolveOpenclawClawlingDefaultAccountId(cfg)
+      : normalizeOpenclawClawlingAccountId(accountId);
+  const isDefault = resolvedAccountId === DEFAULT_ACCOUNT_ID;
+  const root = readChannelSection(cfg);
+  const channel = readOpenclawClawlingAccountSection(cfg, resolvedAccountId);
+  // Credential env vars are process-wide and can only ever describe ONE
+  // identity — they belong to the default account. Endpoint env vars are shared.
+  const credentialEnv: Record<string, string | undefined> = isDefault ? env : {};
   // Apply built-in defaults so login/gateway work without prior setup.
   const websocketUrl =
     readOptionalString(channel.websocketUrl) ||
@@ -515,16 +615,17 @@ export function resolveOpenclawClawlingAccount(
     DEFAULT_BASE_URL;
   const mediaBaseUrl =
     readOptionalString(channel.mediaBaseUrl) || readEnvString(env, CLAWCHAT_MEDIA_BASE_URL_ENV);
-  const token = readOptionalString(channel.token) || readEnvString(env, CLAWCHAT_TOKEN_ENV);
-  const agentId = readOptionalString(channel.agentId) || readEnvString(env, CLAWCHAT_AGENT_ID_ENV);
+  const token = readOptionalString(channel.token) || readEnvString(credentialEnv, CLAWCHAT_TOKEN_ENV);
+  const agentId =
+    readOptionalString(channel.agentId) || readEnvString(credentialEnv, CLAWCHAT_AGENT_ID_ENV);
   const userId = resolveUserId(
     token,
-    readOptionalString(channel.userId) || readEnvString(env, CLAWCHAT_USER_ID_ENV),
+    readOptionalString(channel.userId) || readEnvString(credentialEnv, CLAWCHAT_USER_ID_ENV),
   );
   const ownerUserId =
     rejectPlaceholderOwnerUserId(readOptionalString(channel.ownerUserId), "channel ownerUserId") ||
     rejectPlaceholderOwnerUserId(
-      readEnvString(env, CLAWCHAT_OWNER_USER_ID_ENV),
+      readEnvString(credentialEnv, CLAWCHAT_OWNER_USER_ID_ENV),
       CLAWCHAT_OWNER_USER_ID_ENV,
     ) ||
     // Fall back to the access token's `oid` (owner) claim. A provisioner may
@@ -532,7 +633,9 @@ export function resolveOpenclawClawlingAccount(
     // (hasOpenclawClawlingConnectCredentials) never passes and the plugin sits
     // in the wait-for-activation loop. The owner is always carried in the token.
     decodeJwtStringClaim(token, "oid");
-  const enabled = typeof channel.enabled === "boolean" ? channel.enabled : true;
+  const rootEnabled = typeof root.enabled === "boolean" ? root.enabled : true;
+  const sectionEnabled = typeof channel.enabled === "boolean" ? channel.enabled : true;
+  const enabled = rootEnabled && sectionEnabled;
   const outputVisibility = readOutputVisibility(channel.outputVisibility);
   const chats = readChats(channel.chats);
   const groupMode = readGroupMode(channel.groupMode);
@@ -550,8 +653,8 @@ export function resolveOpenclawClawlingAccount(
     typeof channel.livewareSample === "boolean" ? channel.livewareSample : true;
 
   return {
-    accountId: DEFAULT_ACCOUNT_ID,
-    name: CHANNEL_ID,
+    accountId: resolvedAccountId,
+    name: isDefault ? CHANNEL_ID : resolvedAccountId,
     enabled,
     configured: hasOpenclawClawlingConnectCredentials({
       websocketUrl,
@@ -582,7 +685,3 @@ export function resolveOpenclawClawlingAccount(
     ack: readAck(channel.ack),
   };
 }
-
-export function listOpenclawClawlingAccountIds(): string[] {
-  return [DEFAULT_ACCOUNT_ID];
-}

package/src/liveware-cli.ts

@@ -1,6 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
 import { resolveStateDir } from "openclaw/plugin-sdk/state-paths";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
+import { normalizeOpenclawClawlingAccountId } from "./config.ts";
 
 export const LIVEWARE_BASE_URL = "https://media.clawling.chat/liveware/";
 
@@ -21,7 +23,36 @@ export function livewareDir(stateDir?: string): string {
 }
 
 /**
- * Private HOME for the liveware CLI: `<stateDir>/clawchat/liveware-home`.
+ * Root for one account's liveware state: `<stateDir>/clawchat` for the
+ * `default` account, `<stateDir>/clawchat/accounts/<id>` for a named one.
+ *
+ * The `default` account keeps the pre-multi-account layout exactly, so an
+ * existing single-account install never has to migrate anything.
+ */
+function livewareAccountRoot(stateDir: string | undefined, accountId?: string | null): string {
+  const root = stateDir ?? resolveStateDir();
+  const id = normalizeOpenclawClawlingAccountId(accountId);
+  return id === DEFAULT_ACCOUNT_ID
+    ? path.join(root, "clawchat")
+    : path.join(root, "clawchat", "accounts", id);
+}
+
+/**
+ * Root of a NAMED account's private liveware state
+ * (`<stateDir>/clawchat/accounts/<id>`), the directory account removal
+ * deletes wholesale. Returns null for `default`, whose root is the shared
+ * `<stateDir>/clawchat` and must never be removed this way.
+ */
+export function livewareNamedAccountRootDir(stateDir: string, accountId?: string | null): string | null {
+  return normalizeOpenclawClawlingAccountId(accountId) === DEFAULT_ACCOUNT_ID
+    ? null
+    : livewareAccountRoot(stateDir, accountId);
+}
+
+/**
+ * Private HOME for the liveware CLI: `<stateDir>/clawchat/liveware-home` for
+ * the default account, `<stateDir>/clawchat/accounts/<id>/liveware-home` for a
+ * named one.
  *
  * The CLI keeps its login credentials in `$HOME/.clawling`, which is
  * host-global. Two OpenClaw instances on one box (`openclaw --profile <name>`,
@@ -32,13 +63,30 @@ export function livewareDir(stateDir?: string): string {
  * credential store per-instance, which is the same isolation the rest of the
  * plugin already gets for free.
  *
+ * Two ACCOUNTS in ONE instance have the same problem and no state dir to tell
+ * them apart, so a named account gets its own sub-root: otherwise `work`'s
+ * `liveware login` would overwrite `default`'s session in the shared home and
+ * `default`'s next `tunnel bind` / `app create` would run as `work`'s user.
+ *
  * Migration is automatic: `livewareLogin` runs on every bootstrap AND (best
  * effort) on every relaunch, so an existing install simply re-logs into its new
  * private home on the next start.
  */
-export function livewareCliHomeDir(stateDir?: string): string {
-  const root = stateDir ?? resolveStateDir();
-  return path.join(root, "clawchat", "liveware-home");
+export function livewareCliHomeDir(stateDir?: string, accountId?: string | null): string {
+  return path.join(livewareAccountRoot(stateDir, accountId), "liveware-home");
+}
+
+/**
+ * Where the Liveware Sample app tree is installed for one account:
+ * `<stateDir>/clawchat/liveware-sample` (default) or
+ * `<stateDir>/clawchat/accounts/<id>/liveware-sample` (named).
+ *
+ * Per account for the same reason as {@link livewareCliHomeDir}: two
+ * supervisors in one process otherwise install, swap and delete inside the
+ * same `app/` tree concurrently.
+ */
+export function livewareSampleRootDir(stateDir?: string, accountId?: string | null): string {
+  return path.join(livewareAccountRoot(stateDir, accountId), "liveware-sample");
 }
 
 /**

package/src/liveware-sample.ts

@@ -12,6 +12,8 @@ import path from "node:path";
 import { DEFAULT_SKILLS_REF, OFFICIAL_SKILLS_BASE, type FetchLike } from "./skill-update.ts";
 import type { LivewareSampleRow, LivewareSampleUpsert } from "./storage.ts";
 import { livewareCliEnv, type LivewareLogger } from "./liveware-cli.ts";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
+import { normalizeOpenclawClawlingAccountId } from "./config.ts";
 
 export const LIVEWARES_TARGET = "openclaw";
 export const LIVEWARE_SAMPLE_ID = "liveware-sample";
@@ -154,6 +156,16 @@ async function localInstallMatches(
   }
 }
 
+/**
+ * Suffix for the `app.tmp-…` / `app.old-…` staging dirs. The pid keeps two
+ * PROCESSES apart; the account id keeps two supervisors inside ONE process
+ * apart, which share a pid and could otherwise share a staging tree.
+ */
+function stagingSuffix(accountId?: string): string {
+  const id = normalizeOpenclawClawlingAccountId(accountId);
+  return id === DEFAULT_ACCOUNT_ID ? `${process.pid}` : `${process.pid}-${id}`;
+}
+
 /**
  * Download + verify + atomically install the sample under `<sampleRoot>/app`.
  * Preserves USER_DATA_FILES from an existing install. Throws on any failure;
@@ -172,6 +184,9 @@ export async function downloadLivewareSample(opts: {
   sampleRoot: string;
   ref?: string;
   base?: string;
+  /** Disambiguates the staging/rollback dirs when two accounts run in one
+   * process (same pid). Omitted/`default` keeps the pid-only names. */
+  accountId?: string;
 }): Promise<{ version: string; appDir: string; reused?: boolean }> {
   const ref = opts.ref ?? DEFAULT_SKILLS_REF;
   const entry = parseLivewaresManifest(
@@ -191,7 +206,8 @@ export async function downloadLivewareSample(opts: {
     }
   }
 
-  const tmpDir = path.join(opts.sampleRoot, `app.tmp-${process.pid}`);
+  const swapSuffix = stagingSuffix(opts.accountId);
+  const tmpDir = path.join(opts.sampleRoot, `app.tmp-${swapSuffix}`);
   await fs.promises.rm(tmpDir, { recursive: true, force: true });
   await fs.promises.mkdir(tmpDir, { recursive: true });
   try {
@@ -218,7 +234,7 @@ export async function downloadLivewareSample(opts: {
     // handle, and doing it first leaves no app/ at all when it fails. Renaming
     // aside puts the new tree in place first and makes the delete best-effort:
     // a leftover app.old-<pid> is swept on the next run, never a broken install.
-    const oldDir = path.join(opts.sampleRoot, `app.old-${process.pid}`);
+    const oldDir = path.join(opts.sampleRoot, `app.old-${swapSuffix}`);
     await fs.promises.rm(oldDir, { recursive: true, force: true }).catch(() => {});
     if (fs.existsSync(appDir)) {
       await withFsSwapRetry(() => fs.promises.rename(appDir, oldDir));
@@ -700,9 +716,10 @@ export type LivewareSampleSupervisorDeps = {
   ref?: string;
   spawnFn?: SpawnLike;
   execFileFn?: ExecFileLike;
-  /** Private HOME for the liveware CLI (`livewareCliHomeDir(stateDir)`), so two
-   * instances on one host do not share `$HOME/.clawling`. Absent → the CLI
-   * inherits the ambient HOME, which is the pre-isolation behavior. */
+  /** Private HOME for the liveware CLI (`livewareCliHomeDir(stateDir, accountId)`),
+   * so two instances on one host — or two accounts in one gateway — do not
+   * share `$HOME/.clawling`. Absent → the CLI inherits the ambient HOME, which
+   * is the pre-isolation behavior. */
   cliHome?: string;
   probePortFn?: ProbePortLike;
   log?: LivewareLogger;
@@ -894,6 +911,7 @@ export class LivewareSampleSupervisor {
 
     const { version, appDir } = await downloadLivewareSample({
       fetchFn: deps.fetchFn, sampleRoot: deps.sampleRoot, ref: deps.ref,
+      accountId: deps.accountId,
     });
     if (this.bailIfStopped()) return;
     const cliEnv = await this.ensureCliEnv();
@@ -977,6 +995,7 @@ export class LivewareSampleSupervisor {
     try {
       const dl = await downloadLivewareSample({
         fetchFn: deps.fetchFn, sampleRoot: deps.sampleRoot, ref: deps.ref,
+        accountId: deps.accountId,
       });
       version = dl.version;
       appDir = dl.appDir;

package/src/login.runtime.ts

@@ -3,10 +3,14 @@ import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
 import { createOpenclawClawlingApiClient } from "./api-client.ts";
 import { ClawlingApiError, type AgentConnectResult } from "./api-types.ts";
 import { resolvePluginVersion } from "./plugin-report.ts";
+import { openclawClawlingAccountSlotPath, patchOpenclawClawlingAccountSection } from "./account-config-writes.ts";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
 import {
   CHANNEL_ID,
   mergeOpenclawClawchatRuntimePluginActivation,
   mergeOpenclawClawchatToolAllow,
+  normalizeOpenclawClawlingAccountId,
+  readOpenclawClawlingAccountSection,
   resolveOpenclawClawlingAccount,
 } from "./config.ts";
 import { getClawChatStore, type ClawChatStore } from "./storage.ts";
@@ -80,8 +84,7 @@ export type ActivationIntent = "new-account" | "repair";
 /**
  * Thrown when redeeming an invite code would silently replace a live activation.
  *
- * This channel holds exactly one ClawChat identity — `channels.<id>` is a single
- * slot and `listOpenclawClawlingAccountIds()` returns a single account. Because
+ * Each account slot holds exactly one ClawChat identity. Because
  * the stored `user_id` is replayed as a re-pair hint, redeeming a *new* invite
  * code here cannot produce a second agent: the server binds the code to the
  * existing agent, consumes it, creates no second agent and no second contact
@@ -103,9 +106,9 @@ export class ExistingActivationError extends Error {
         "  - RESTORE the identity above (re-pairs that same agent; if it was " +
         "deleted this brings it back with its history): " +
         "/clawchat-activate <CODE> --repair\n" +
-        "  - To run a SECOND agent alongside this one instead, give it its own " +
-        "OpenClaw home:\n" +
-        "      OPENCLAW_HOME=<path> openclaw channels login --channel clawchat-plugin-openclaw",
+        "  - To run a SECOND agent alongside this one instead, activate it as a " +
+        "named account: /clawchat-activate <CODE> --account <name>  (or: openclaw " +
+        "channels add --channel clawchat-plugin-openclaw --account <name> --token <CODE>)",
     );
     this.name = "ExistingActivationError";
     this.userId = userId;
@@ -177,39 +180,38 @@ async function promptActivationIntentFromStdin(
   }
 }
 
-function buildLoginConfig(cfg: OpenClawConfig, result: AgentConnectResult): OpenClawConfig {
-  const channels = (cfg.channels ?? {}) as Record<string, unknown>;
-  const existing = (channels[CHANNEL_ID] ?? {}) as Record<string, unknown>;
+function buildLoginConfig(
+  cfg: OpenClawConfig,
+  accountId: string,
+  result: AgentConnectResult,
+): OpenClawConfig {
+  const existing = readOpenclawClawlingAccountSection(cfg, accountId);
   const groupMode = existing.groupMode === "mention" || existing.groupMode === "all"
     ? existing.groupMode
     : "all";
   const groupCommandMode = existing.groupCommandMode === "all" || existing.groupCommandMode === "off"
     ? existing.groupCommandMode
     : "owner";
-  const nextSection: Record<string, unknown> = {
-    ...existing,
+  const patch: Record<string, unknown> = {
     enabled: true,
-    groupMode,
-    groupCommandMode,
+    // Group policy defaults are root-level shared keys; named accounts inherit
+    // them and only carry credentials.
+    ...(accountId === DEFAULT_ACCOUNT_ID ? { groupMode, groupCommandMode } : {}),
     token: result.access_token,
+    // `undefined` deletes the key so a login without a refresh token never
+    // leaves a stale one behind.
+    refreshToken: result.refresh_token ? result.refresh_token : undefined,
     ...(result.agent.id ? { agentId: result.agent.id } : {}),
     userId: result.agent.user_id,
     ownerUserId: result.agent.owner_id,
   };
-  if (result.refresh_token) {
-    nextSection.refreshToken = result.refresh_token;
-  } else {
-    delete nextSection.refreshToken;
-  }
   return mergeOpenclawClawchatRuntimePluginActivation(
-    mergeOpenclawClawchatToolAllow({
-      ...cfg,
-      channels: { ...channels, [CHANNEL_ID]: nextSection },
-    }),
+    mergeOpenclawClawchatToolAllow(patchOpenclawClawlingAccountSection(cfg, accountId, patch)),
   );
 }
 
 async function persistLoginConfig(
+  accountId: string,
   params: LoginParams,
   result: AgentConnectResult,
 ): Promise<void> {
@@ -223,7 +225,7 @@ async function persistLoginConfig(
         reason: "clawchat-plugin-openclaw credentials changed",
       },
       mutate(draft) {
-        Object.assign(draft, buildLoginConfig(draft, result));
+        Object.assign(draft, buildLoginConfig(draft, accountId, result));
       },
     });
     params.runtime.log(
@@ -236,7 +238,7 @@ async function persistLoginConfig(
     params.runtime.log(
       `Persisting ClawChat credentials and plugin activation for userId=${result.agent.user_id} ownerUserId=${result.agent.owner_id}.`,
     );
-    await params.persistConfig(buildLoginConfig(params.cfg, result));
+    await params.persistConfig(buildLoginConfig(params.cfg, accountId, result));
     params.runtime.log(
       `ClawChat credentials and plugin activation persisted for userId=${result.agent.user_id} ownerUserId=${result.agent.owner_id}.`,
     );
@@ -280,11 +282,12 @@ function readOptionalConnectString(value: unknown, fieldName: string): string |
  */
 export async function runOpenclawClawlingLogin(params: LoginParams): Promise<void> {
   const { cfg, runtime } = params;
+  const accountId = normalizeOpenclawClawlingAccountId(params.accountId);
 
   // `resolveOpenclawClawlingAccount` falls back to the built-in
   // `DEFAULT_BASE_URL` / `DEFAULT_WEBSOCKET_URL` when the operator has not
   // overridden them, so login works without a prior `openclaw channels setup --channel clawchat-plugin-openclaw`.
-  const account = resolveOpenclawClawlingAccount(cfg);
+  const account = resolveOpenclawClawlingAccount(cfg, accountId);
 
   // Fork before the invite code is even read, so neither branch spends the code
   // before the outcome is settled. "Live" is decided by whether a usable token
@@ -405,12 +408,13 @@ export async function runOpenclawClawlingLogin(params: LoginParams): Promise<voi
       : {}),
   };
 
+  const configPath = openclawClawlingAccountSlotPath(params.cfg, accountId);
   runtime.log(
-    `Updating config: channels.${CHANNEL_ID}.token=[REDACTED] agentId=${normalizedResult.agent.id || "-"} userId=${normalizedResult.agent.user_id} ownerUserId=${normalizedResult.agent.owner_id}${
+    `Updating config: ${configPath}.token=[REDACTED] agentId=${normalizedResult.agent.id || "-"} userId=${normalizedResult.agent.user_id} ownerUserId=${normalizedResult.agent.owner_id}${
       normalizedResult.refresh_token ? " refreshToken=[REDACTED]" : ""
     } plugins.entries.${CHANNEL_ID}.enabled=true plugins.allow+=${CHANNEL_ID} …`,
   );
-  await persistLoginConfig(params, normalizedResult);
+  await persistLoginConfig(accountId, params, normalizedResult);
   try {
     const store =
       params.store ??

package/src/outbound.ts

@@ -899,8 +899,8 @@ export const openclawClawlingOutbound: ChannelOutboundAdapter = {
   textChunkLimit: 4000,
   ...createAttachedChannelResultAdapter({
     channel: CHANNEL_ID,
-    sendText: async ({ cfg, to, text }) => {
-      const account = resolveOpenclawClawlingAccount(cfg);
+    sendText: async ({ cfg, to, text, accountId }) => {
+      const account = resolveOpenclawClawlingAccount(cfg, accountId);
       const client =
         getOpenclawClawlingClient(account.accountId) ??
         (await waitForOpenclawClawlingClient(account.accountId));
@@ -936,8 +936,8 @@ export const openclawClawlingOutbound: ChannelOutboundAdapter = {
         messageId: result?.messageId ?? messageId,
       };
     },
-    sendMedia: async ({ cfg, to, text, mediaUrl, mediaAccess, mediaLocalRoots, mediaReadFile }) => {
-      const account = resolveOpenclawClawlingAccount(cfg);
+    sendMedia: async ({ cfg, to, text, mediaUrl, mediaAccess, mediaLocalRoots, mediaReadFile, accountId }) => {
+      const account = resolveOpenclawClawlingAccount(cfg, accountId);
       const client =
         getOpenclawClawlingClient(account.accountId) ??
         (await waitForOpenclawClawlingClient(account.accountId));