@clawling/clawchat-plugin-openclaw 2026.9.10-1 → 2026.9.13-1

package/dist/src/account-config-writes.js

@@ -0,0 +1,66 @@
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
+import { CHANNEL_ID, normalizeOpenclawClawlingAccountId } from "./config.js";
+function readRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function findAccountKey(accounts, accountId) {
+    return Object.keys(accounts).find((key) => normalizeOpenclawClawlingAccountId(key) === accountId);
+}
+function applyPatch(target, patch) {
+    const next = { ...target };
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === undefined)
+            delete next[key];
+        else
+            next[key] = value;
+    }
+    return next;
+}
+/**
+ * The RAW object a patch for `accountId` lands in (not the merged view — use
+ * `readOpenclawClawlingAccountSection` for that). Default: the `accounts.default`
+ * entry when the host's single-account promotion created one, else the root.
+ * Named: the matching `accounts.<key>` entry (case-insensitive) or `{}`.
+ */
+export function readOpenclawClawlingAccountEntry(cfg, accountId) {
+    const id = normalizeOpenclawClawlingAccountId(accountId);
+    const section = readRecord(readRecord(cfg.channels)[CHANNEL_ID]);
+    const accounts = readRecord(section.accounts);
+    const key = findAccountKey(accounts, id);
+    if (key !== undefined)
+        return readRecord(accounts[key]);
+    return id === DEFAULT_ACCOUNT_ID ? section : {};
+}
+/**
+ * The single config write point. Pure. Default → root section (or
+ * `accounts.default` when that entry exists, so a host-promoted token is never
+ * shadowed by a stale copy); named → `accounts.<id>` keeping the existing key
+ * spelling. A patch value of `undefined` deletes the key. `enabled` is only
+ * touched when the patch carries it.
+ */
+export function patchOpenclawClawlingAccountSection(cfg, accountId, patch) {
+    const id = normalizeOpenclawClawlingAccountId(accountId);
+    const channels = readRecord(cfg.channels);
+    const section = readRecord(channels[CHANNEL_ID]);
+    const accounts = readRecord(section.accounts);
+    const existingKey = findAccountKey(accounts, id);
+    if (id === DEFAULT_ACCOUNT_ID && existingKey === undefined) {
+        return {
+            ...cfg,
+            channels: { ...channels, [CHANNEL_ID]: applyPatch(section, patch) },
+        };
+    }
+    const key = existingKey ?? id;
+    return {
+        ...cfg,
+        channels: {
+            ...channels,
+            [CHANNEL_ID]: {
+                ...section,
+                accounts: { ...accounts, [key]: applyPatch(readRecord(accounts[key]), patch) },
+            },
+        },
+    };
+}

package/dist/src/account-removal.js

@@ -0,0 +1,21 @@
+import { normalizeOpenclawClawlingAccountId } from "./config.js";
+/**
+ * `openclaw channels remove --account <id> [--delete]` — the host has already
+ * rewritten the config (hybrid adapter) and stopped the account. Blank that
+ * account's SQLite credentials so a later start of the same id cannot resume
+ * the old identity from the row. Identity columns are kept (re-pair mode).
+ */
+export function clearOpenclawClawlingAccountOnRemoval(params) {
+    const accountId = normalizeOpenclawClawlingAccountId(params.accountId);
+    if (!params.store) {
+        params.log?.(`[${accountId}] clawchat-plugin-openclaw account removed; sqlite unavailable, nothing to clear`);
+        return;
+    }
+    try {
+        params.store.clearActivationCredentials({ platform: "openclaw", accountId });
+        params.log?.(`[${accountId}] clawchat-plugin-openclaw account removed; sqlite credentials cleared`);
+    }
+    catch (err) {
+        params.log?.(`[${accountId}] clawchat-plugin-openclaw account removed; sqlite clear failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}

package/dist/src/channel.js

@@ -1,8 +1,10 @@
 import { createChatChannelPlugin } from "openclaw/plugin-sdk/core";
 import { createEmptyChannelDirectoryAdapter } from "openclaw/plugin-sdk/directory-runtime";
+import { clearOpenclawClawlingAccountOnRemoval } from "./account-removal.js";
 import { CHANNEL_ID, canStartOpenclawClawlingAccount, resolveOpenclawClawlingAccount, } from "./config.js";
 import { openclawClawlingOutbound } from "./outbound.js";
 import { getOpenclawClawlingRuntime, startOpenclawClawlingGateway } from "./runtime.js";
+import { clawChatDbPathForStateDir, getClawChatStore } from "./storage.js";
 import { openclawClawlingSetupPlugin } from "./channel.setup.js";
 import { getClawChatPlatformPrompt } from "./plugin-prompts.js";
 export const openclawClawlingPlugin = createChatChannelPlugin({
@@ -23,9 +25,29 @@ export const openclawClawlingPlugin = createChatChannelPlugin({
                 });
             },
         },
+        lifecycle: {
+            onAccountRemoved: ({ accountId, runtime }) => {
+                let store = null;
+                try {
+                    const stateDir = getOpenclawClawlingRuntime().state?.resolveStateDir?.();
+                    store = getClawChatStore({
+                        ...(stateDir ? { dbPath: clawChatDbPathForStateDir(stateDir) } : {}),
+                        log: { error: (message) => runtime.error(message) },
+                    });
+                }
+                catch {
+                    store = null;
+                }
+                clearOpenclawClawlingAccountOnRemoval({
+                    accountId,
+                    store,
+                    log: (message) => runtime.log(message),
+                });
+            },
+        },
         gateway: {
             startAccount: async (ctx) => {
-                const account = ctx.account ?? resolveOpenclawClawlingAccount(ctx.cfg);
+                const account = ctx.account ?? resolveOpenclawClawlingAccount(ctx.cfg, ctx.accountId);
                 ctx.log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw lifecycle START_ACCOUNT_CALLED configured=${account.configured} enabled=${account.enabled} hasToken=${Boolean(account.token)} hasUserId=${Boolean(account.userId)} websocketUrl=${account.websocketUrl || "(empty)"}`);
                 if (!canStartOpenclawClawlingAccount(account)) {
                     ctx.log?.error?.(`[${account.accountId}] clawchat-plugin-openclaw lifecycle startAccount refused: websocketUrl is required`);

package/dist/src/channel.setup.js

@@ -1,68 +1,96 @@
-import { createTopLevelChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
+import { createHybridChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
 import { mutateConfigFile } from "openclaw/plugin-sdk/config-mutation";
+import { patchOpenclawClawlingAccountSection } from "./account-config-writes.js";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
 import { createComputedAccountStatusAdapter, createDefaultChannelRuntimeState, } from "openclaw/plugin-sdk/status-helpers";
-import { CHANNEL_ID, canStartOpenclawClawlingAccount, listOpenclawClawlingAccountIds, openclawClawlingConfigSchema, resolveOpenclawClawlingAccount, } from "./config.js";
-const configAdapter = createTopLevelChannelConfigAdapter({
+import { CHANNEL_ID, canStartOpenclawClawlingAccount, listOpenclawClawlingAccountIds, normalizeOpenclawClawlingAccountId, openclawClawlingConfigSchema, resolveOpenclawClawlingAccount, resolveOpenclawClawlingDefaultAccountId, } from "./config.js";
+/** Keys a `channels remove --account default --delete` clears from the section. */
+const CLEAR_BASE_FIELDS = [
+    "websocketUrl",
+    "baseUrl",
+    "token",
+    "refreshToken",
+    "agentId",
+    "userId",
+    "ownerUserId",
+    "forwardThinking",
+    "forwardToolCalls",
+    "richInteractions",
+    "enabled",
+];
+/**
+ * Hybrid layout: the channel root IS the `default` account (and the
+ * inheritance base); named accounts live under `accounts.<id>`. The SDK
+ * adapter branches `setAccountEnabled` / `deleteAccount` on the id for us.
+ */
+const hybridConfigAdapter = createHybridChannelConfigAdapter({
     sectionKey: CHANNEL_ID,
-    resolveAccount: (cfg) => resolveOpenclawClawlingAccount(cfg),
-    listAccountIds: () => listOpenclawClawlingAccountIds(),
-    defaultAccountId: () => DEFAULT_ACCOUNT_ID,
-    deleteMode: "clear-fields",
-    clearBaseFields: [
-        "websocketUrl",
-        "baseUrl",
-        "token",
-        "userId",
-        "forwardThinking",
-        "forwardToolCalls",
-        "richInteractions",
-        "enabled",
-    ],
+    resolveAccount: (cfg, accountId) => resolveOpenclawClawlingAccount(cfg, accountId),
+    listAccountIds: (cfg) => listOpenclawClawlingAccountIds(cfg),
+    defaultAccountId: (cfg) => resolveOpenclawClawlingDefaultAccountId(cfg),
+    preserveSectionOnDefaultDelete: true,
+    clearBaseFields: [...CLEAR_BASE_FIELDS],
     resolveAllowFrom: (account) => account.allowFrom,
     formatAllowFrom: () => [],
 });
+/** `{ token: undefined, refreshToken: undefined, … }` — `undefined` deletes. */
+const CLEAR_BASE_FIELDS_PATCH = Object.fromEntries(CLEAR_BASE_FIELDS.map((key) => [key, undefined]));
+const configAdapter = {
+    ...hybridConfigAdapter,
+    /**
+     * The SDK's default branch clears `clearBaseFields` from the ROOT only. Once
+     * the host's single-account promotion has moved the identity into
+     * `accounts.default`, that leaves the deleted default fully credentialed:
+     * the default reader merges the promoted entry back over the blanked root,
+     * `ownerUserId` returns via the token's `oid` claim, and the account resolves
+     * `configured: true` again on the next gateway start. Clear the same keys
+     * from the promoted entry so `--delete` actually deletes. Named ids are the
+     * SDK's alone — it removes the whole `accounts.<id>` entry.
+     */
+    deleteAccount: (args) => {
+        const next = hybridConfigAdapter.deleteAccount?.(args) ?? args.cfg;
+        if (normalizeOpenclawClawlingAccountId(args.accountId) !== DEFAULT_ACCOUNT_ID)
+            return next;
+        return patchOpenclawClawlingAccountSection(next, DEFAULT_ACCOUNT_ID, CLEAR_BASE_FIELDS_PATCH);
+    },
+};
+function readInviteCode(input) {
+    return typeof input.code === "string" && input.code.trim()
+        ? input.code.trim()
+        : typeof input.token === "string"
+            ? input.token.trim()
+            : "";
+}
 /**
  * Invite-code setup adapter used by OpenClaw setup surfaces.
  *
- * `channels add --token` passes the invite code as setup input. The setup
- * write leaves channel config unchanged; `afterAccountConfigWritten` exchanges
- * the invite code and persists token/userId through the host runtime mutator.
+ * `channels add [--account <id>] --token <code>` passes the invite code as
+ * setup input and the (optional) account id from the host. The setup write
+ * leaves channel config unchanged; `afterAccountConfigWritten` exchanges the
+ * invite code and persists credentials for THAT account through the host
+ * runtime mutator.
  */
 const setupAdapter = {
-    resolveAccountId: () => DEFAULT_ACCOUNT_ID,
-    validateInput: ({ input }) => {
-        const inviteCode = typeof input.code === "string" && input.code.trim()
-            ? input.code.trim()
-            : typeof input.token === "string"
-                ? input.token.trim()
-                : "";
-        if (!inviteCode) {
-            return "ClawChat invite code is required.";
-        }
-        return null;
-    },
+    resolveAccountId: ({ accountId }) => normalizeOpenclawClawlingAccountId(accountId),
+    validateInput: ({ input }) => readInviteCode(input) ? null : "ClawChat invite code is required.",
     applyAccountConfig: ({ cfg }) => cfg,
-    afterAccountConfigWritten: async ({ cfg, input, runtime }) => {
-        runtime.log("[default] clawchat-plugin-openclaw setup afterAccountConfigWritten invoked");
-        const code = typeof input.code === "string" && input.code.trim()
-            ? input.code.trim()
-            : typeof input.token === "string"
-                ? input.token.trim()
-                : "";
+    afterAccountConfigWritten: async ({ cfg, accountId, input, runtime }) => {
+        const id = normalizeOpenclawClawlingAccountId(accountId);
+        runtime.log(`[${id}] clawchat-plugin-openclaw setup afterAccountConfigWritten invoked`);
+        const code = readInviteCode(input);
         if (!code) {
-            runtime.log("[default] clawchat-plugin-openclaw setup afterAccountConfigWritten skipped: empty invite code");
+            runtime.log(`[${id}] clawchat-plugin-openclaw setup afterAccountConfigWritten skipped: empty invite code`);
             return;
         }
         const { runOpenclawClawlingLogin } = await import("./login.runtime.js");
         await runOpenclawClawlingLogin({
             cfg,
-            accountId: null,
+            accountId: id,
             runtime: { log: (message) => runtime.log(message) },
             readInviteCode: async () => code,
             mutateConfigFile: mutateConfigFile,
         });
-        runtime.log("[default] clawchat-plugin-openclaw setup afterAccountConfigWritten completed");
+        runtime.log(`[${id}] clawchat-plugin-openclaw setup afterAccountConfigWritten completed`);
     },
 };
 export const openclawClawlingSetupPlugin = {

package/dist/src/commands.js

@@ -1,9 +1,34 @@
-import { CHANNEL_ID } from "./config.js";
+import { patchOpenclawClawlingAccountSection } from "./account-config-writes.js";
+import { CHANNEL_ID, normalizeOpenclawClawlingAccountId, readOpenclawClawlingAccountSection, } from "./config.js";
 /** Activation intent flags — the two escape hatches out of the live-activation guard. */
 const ACTIVATION_FLAGS = ["--new-account", "--repair"];
 function stripActivationFlags(raw) {
     return ACTIVATION_FLAGS.reduce((acc, flag) => acc.split(flag).join(" "), raw);
 }
+/** `--account <id>` / `--account=<id>`; the value is removed before the code scan so it can never be mistaken for a code. */
+const ACCOUNT_FLAG_PATTERN = /(?:^|\s)--account(?:=|\s+)(\S+)/u;
+/** `--account` with nothing after it — including a dangling `--account=`, which
+ * is a typo rather than "use the default account". */
+const BARE_ACCOUNT_FLAG_PATTERN = /(?:^|\s)--account=?(?=\s|$)/u;
+function extractAccountFlag(value) {
+    const raw = typeof value === "string" ? value : "";
+    const match = ACCOUNT_FLAG_PATTERN.exec(raw);
+    if (match) {
+        const id = match[1] ?? "";
+        if (!id || id.startsWith("--")) {
+            return { accountId: null, rest: raw, error: "--account requires an account id" };
+        }
+        return {
+            accountId: normalizeOpenclawClawlingAccountId(id),
+            rest: raw.replace(match[0], " "),
+            error: null,
+        };
+    }
+    if (BARE_ACCOUNT_FLAG_PATTERN.test(raw)) {
+        return { accountId: null, rest: raw, error: "--account requires an account id" };
+    }
+    return { accountId: null, rest: raw, error: null };
+}
 /**
  * A whole argument token that looks like a ClawChat connect code.
  *
@@ -80,27 +105,19 @@ function resolveCommandChatId(ctx) {
             ? String(ctx.messageThreadId).trim()
             : "");
 }
-function persistOutputVisibility(draft, chatId, outputVisibility) {
-    const channels = readRecord(draft.channels);
-    const channel = readRecord(channels[CHANNEL_ID]);
-    const chats = readRecord(channel.chats);
+function persistOutputVisibility(draft, accountId, chatId, outputVisibility) {
+    // Seeded from the MERGED view, never the raw target entry: `mergeAccountConfig`
+    // REPLACES `chats` rather than deep-merging it, so a first write seeded from an
+    // entry that has no `chats` of its own (a named account, or a `default` the
+    // host has promoted into `accounts.default`) would shadow every inherited
+    // conversation. Copying the inherited map forward and overriding one key keeps
+    // the resolved view additive.
+    const merged = readOpenclawClawlingAccountSection(draft, accountId);
+    const chats = readRecord(merged.chats);
     const chat = readRecord(chats[chatId]);
-    Object.assign(draft, {
-        ...draft,
-        channels: {
-            ...channels,
-            [CHANNEL_ID]: {
-                ...channel,
-                chats: {
-                    ...chats,
-                    [chatId]: {
-                        ...chat,
-                        outputVisibility,
-                    },
-                },
-            },
-        },
-    });
+    Object.assign(draft, patchOpenclawClawlingAccountSection(draft, accountId, {
+        chats: { ...chats, [chatId]: { ...chat, outputVisibility } },
+    }));
 }
 function formatOutputVisibilityResult(outputVisibility) {
     const detailLevel = {
@@ -120,21 +137,26 @@ function formatOutputVisibilityResult(outputVisibility) {
 export function registerOpenclawClawlingCommands(api) {
     api.registerCommand({
         name: "clawchat-activate",
-        description: "Activate ClawChat with an invite code, e.g. /clawchat-activate K7RM4TQP.",
+        description: "Activate ClawChat with an invite code, e.g. /clawchat-activate K7RM4TQP [--account <id>].",
         acceptsArgs: true,
         requireAuth: true,
         async handler(ctx) {
             const rawArgs = ctx.args ?? ctx.commandBody;
-            const code = extractInviteCode(rawArgs);
+            const accountFlag = extractAccountFlag(rawArgs);
+            if (accountFlag.error) {
+                return { text: `${accountFlag.error}. Usage: /clawchat-activate K7RM4TQP [--account <id>]` };
+            }
+            const code = extractInviteCode(accountFlag.rest);
             if (!code) {
-                return { text: "ClawChat invite code is required. Usage: /clawchat-activate K7RM4TQP" };
+                return { text: "ClawChat invite code is required. Usage: /clawchat-activate K7RM4TQP [--account <id>]" };
             }
-            const intent = extractActivationIntent(rawArgs);
+            const intent = extractActivationIntent(accountFlag.rest);
+            const accountId = accountFlag.accountId ?? normalizeOpenclawClawlingAccountId(ctx.accountId);
             try {
                 const { runOpenclawClawlingLogin } = await import("./login.runtime.js");
                 await runOpenclawClawlingLogin({
                     cfg: ctx.config,
-                    accountId: ctx.accountId ?? null,
+                    accountId,
                     runtime: { log: (message) => api.logger?.info?.(message) },
                     readInviteCode: async () => code,
                     mutateConfigFile: api.runtime.config.mutateConfigFile,
@@ -166,10 +188,11 @@ export function registerOpenclawClawlingCommands(api) {
             if (!mutateConfigFile) {
                 return { text: "OpenClaw runtime config mutation is unavailable for /clawchat-output." };
             }
+            const accountId = normalizeOpenclawClawlingAccountId(ctx.accountId);
             await mutateConfigFile({
                 afterWrite: { mode: "auto" },
                 mutate(draft) {
-                    persistOutputVisibility(draft, chatId, outputVisibility);
+                    persistOutputVisibility(draft, accountId, chatId, outputVisibility);
                 },
             });
             return { text: formatOutputVisibilityResult(outputVisibility) };

package/dist/src/config.js

@@ -1,3 +1,4 @@
+import { createAccountListHelpers, mergeAccountConfig, normalizeAccountId, resolveNormalizedAccountEntry, } from "openclaw/plugin-sdk/account-core";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
 export const CHANNEL_ID = "clawchat-plugin-openclaw";
 export const CLAWCHAT_TOKEN_ENV = "CLAWCHAT_TOKEN";
@@ -40,7 +41,7 @@ export const DEFAULT_ACK = {
     // reconnect path re-queues via `queueWhileReconnecting` instead.
     autoResendOnTimeout: false,
 };
-export const openclawClawlingConfigSchema = {
+export const openclawClawlingAccountConfigSchema = {
     type: "object",
     additionalProperties: false,
     properties: {
@@ -111,6 +112,18 @@ export const openclawClawlingConfigSchema = {
         },
     },
 };
+export const openclawClawlingConfigSchema = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        ...openclawClawlingAccountConfigSchema.properties,
+        defaultAccount: { type: "string" },
+        accounts: {
+            type: "object",
+            additionalProperties: openclawClawlingAccountConfigSchema,
+        },
+    },
+};
 function isOpenclawClawchatToolAllowEntry(entry) {
     return entry === CHANNEL_ID || entry === "group:plugins";
 }
@@ -181,6 +194,56 @@ function readChannelSection(cfg) {
     const channel = channels[CHANNEL_ID];
     return channel && typeof channel === "object" ? channel : {};
 }
+/** 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"];
+const ACCOUNT_MAP_KEYS = ["accounts", "defaultAccount"];
+const NESTED_ACCOUNT_OBJECT_KEYS = ["reconnect", "heartbeat", "ack"];
+/** Host-identical account id normalization (lowercase, `[^a-z0-9_-]` → `-`, blank → `default`). */
+export function normalizeOpenclawClawlingAccountId(value) {
+    return normalizeAccountId(value);
+}
+function readAccountsMap(section) {
+    const accounts = section.accounts;
+    return accounts && typeof accounts === "object" && !Array.isArray(accounts)
+        ? accounts
+        : 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, accountId) {
+    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 = [...ACCOUNT_MAP_KEYS];
+    if (id !== DEFAULT_ACCOUNT_ID)
+        omitKeys.push(...ACCOUNT_CREDENTIAL_KEYS);
+    return mergeAccountConfig({
+        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) {
+    return accountListHelpers.listAccountIds(cfg);
+}
+export function resolveOpenclawClawlingDefaultAccountId(cfg) {
+    return accountListHelpers.resolveDefaultAccountId(cfg);
+}
 function readOptionalString(value) {
     return typeof value === "string" ? value.trim() : "";
 }
@@ -345,8 +408,16 @@ function readAck(raw) {
             : DEFAULT_ACK.autoResendOnTimeout,
     };
 }
-export function resolveOpenclawClawlingAccount(cfg, env = process.env) {
-    const channel = readChannelSection(cfg);
+export function resolveOpenclawClawlingAccount(cfg, accountId, env = process.env) {
+    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 = isDefault ? env : {};
     // Apply built-in defaults so login/gateway work without prior setup.
     const websocketUrl = readOptionalString(channel.websocketUrl) ||
         readEnvString(env, CLAWCHAT_WEBSOCKET_URL_ENV) ||
@@ -355,17 +426,19 @@ export function resolveOpenclawClawlingAccount(cfg, env = process.env) {
         readEnvString(env, CLAWCHAT_BASE_URL_ENV) ||
         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 userId = resolveUserId(token, readOptionalString(channel.userId) || readEnvString(env, CLAWCHAT_USER_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(credentialEnv, CLAWCHAT_USER_ID_ENV));
     const ownerUserId = rejectPlaceholderOwnerUserId(readOptionalString(channel.ownerUserId), "channel ownerUserId") ||
-        rejectPlaceholderOwnerUserId(readEnvString(env, CLAWCHAT_OWNER_USER_ID_ENV), CLAWCHAT_OWNER_USER_ID_ENV) ||
+        rejectPlaceholderOwnerUserId(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
         // inject token + userId but omit ownerUserId; without it the connect gate
         // (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);
@@ -377,8 +450,8 @@ export function resolveOpenclawClawlingAccount(cfg, env = process.env) {
     const awarenessNote = typeof channel.awarenessNote === "boolean" ? channel.awarenessNote : false;
     const livewareSample = 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,
@@ -409,6 +482,3 @@ export function resolveOpenclawClawlingAccount(cfg, env = process.env) {
         ack: readAck(channel.ack),
     };
 }
-export function listOpenclawClawlingAccountIds() {
-    return [DEFAULT_ACCOUNT_ID];
-}

package/dist/src/liveware-cli.js

@@ -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.js";
 export const LIVEWARE_BASE_URL = "https://media.clawling.chat/liveware/";
 // A non-default User-Agent is required: the CDN (Cloudflare) returns 403 for
 // known scripting/default UAs, so download requests must identify themselves.
@@ -11,7 +13,23 @@ export function livewareDir(stateDir) {
     return path.join(root, "clawchat", "liveware");
 }
 /**
- * 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, accountId) {
+    const root = stateDir ?? resolveStateDir();
+    const id = normalizeOpenclawClawlingAccountId(accountId);
+    return id === DEFAULT_ACCOUNT_ID
+        ? path.join(root, "clawchat")
+        : path.join(root, "clawchat", "accounts", id);
+}
+/**
+ * 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>`,
@@ -22,13 +40,29 @@ export function livewareDir(stateDir) {
  * 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) {
-    const root = stateDir ?? resolveStateDir();
-    return path.join(root, "clawchat", "liveware-home");
+export function livewareCliHomeDir(stateDir, accountId) {
+    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, accountId) {
+    return path.join(livewareAccountRoot(stateDir, accountId), "liveware-sample");
 }
 /**
  * Environment for every liveware CLI invocation: the ambient env with HOME