@clawling/clawchat-plugin-openclaw 2026.5.12-28

package/dist/src/clawchat-metadata.js

@@ -0,0 +1,310 @@
+import { readClawChatMemoryFile, writeClawChatMetadata, } from "./clawchat-memory.js";
+function asRecord(value) {
+    return value && typeof value === "object" ? value : null;
+}
+function hasOwn(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key);
+}
+function stringField(record, key) {
+    if (!hasOwn(record, key))
+        return undefined;
+    const value = record[key];
+    return typeof value === "string" ? value : undefined;
+}
+function addStringField(metadata, outputKey, record, inputKey = outputKey) {
+    const value = stringField(record, inputKey);
+    if (value !== undefined)
+        metadata[outputKey] = value;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function ownerMetadataFromAgent(agent, params) {
+    const metadata = {};
+    addStringField(metadata, "updated_at", agent);
+    const agentId = stringField(agent, "user_id") ?? params.accountUserId;
+    if (agentId !== undefined)
+        metadata.agent_id = agentId;
+    const ownerId = stringField(agent, "owner_id") ?? params.accountOwnerUserId;
+    if (ownerId !== undefined)
+        metadata.agent_owner_id = ownerId;
+    addStringField(metadata, "agent_nickname", agent, "nickname");
+    addStringField(metadata, "agent_avatar_url", agent, "avatar_url");
+    addStringField(metadata, "agent_bio", agent, "bio");
+    addStringField(metadata, "agent_behavior", agent, "behavior");
+    return metadata;
+}
+function addOwnerProfileMetadata(metadata, ownerProfile) {
+    addStringField(metadata, "agent_owner_nickname", ownerProfile, "nickname");
+    addStringField(metadata, "agent_owner_avatar_url", ownerProfile, "avatar_url");
+    addStringField(metadata, "agent_owner_bio", ownerProfile, "bio");
+}
+function userMetadataFromRecord(record, targetUserId) {
+    const metadata = {};
+    addStringField(metadata, "updated_at", record);
+    metadata.id = targetUserId;
+    addStringField(metadata, "nickname", record);
+    addStringField(metadata, "avatar_url", record);
+    addStringField(metadata, "bio", record);
+    addStringField(metadata, "profile_type", record, "type");
+    return metadata;
+}
+function userMetadataFromProfile(profile, userId) {
+    const metadata = userMetadataFromRecord(profile, userId);
+    if (metadata === null) {
+        throw new Error("ClawChat user metadata response is missing id");
+    }
+    return metadata;
+}
+function participantUserMetadata(participant) {
+    const userRecord = asRecord(participant.user);
+    const source = userRecord ?? participant;
+    const userId = stringField(source, "id") ?? stringField(participant, "user_id");
+    if (!userId)
+        return null;
+    const metadata = userMetadataFromRecord(source, userId);
+    return metadata ? { userId, metadata } : null;
+}
+function normalizeSkipUserIds(values) {
+    const ids = new Set();
+    for (const value of values ?? []) {
+        if (typeof value !== "string")
+            continue;
+        const id = value.trim();
+        if (id)
+            ids.add(id);
+    }
+    return ids;
+}
+function groupMetadataFromConversation(conversation, groupId) {
+    const record = conversation;
+    const metadata = {};
+    addStringField(metadata, "updated_at", record);
+    metadata.group_id = groupId;
+    addStringField(metadata, "group_type", record, "type");
+    addStringField(metadata, "group_title", record, "title");
+    addStringField(metadata, "group_description", record, "description");
+    addStringField(metadata, "group_owner_id", record, "creator_id");
+    addStringField(metadata, "group_created_at", record, "created_at");
+    const participants = Array.isArray(conversation.participants) ? conversation.participants : [];
+    const participantIds = [];
+    const seen = new Set();
+    for (const participant of participants) {
+        const participantRecord = participant;
+        const userRecord = asRecord(participantRecord.user);
+        const source = userRecord ?? participantRecord;
+        const userId = stringField(participantRecord, "id") ?? stringField(participantRecord, "user_id");
+        if (!userId || seen.has(userId))
+            continue;
+        seen.add(userId);
+        participantIds.push(userId);
+        if (!metadata.group_owner_id && stringField(participantRecord, "role") === "owner") {
+            metadata.group_owner_id = userId;
+        }
+        if (metadata.group_owner_id === userId) {
+            addStringField(metadata, "group_owner_nickname", source, "nickname");
+            addStringField(metadata, "group_owner_profile_type", source, "type");
+        }
+    }
+    if (participantIds.length > 0)
+        metadata.participant_ids = participantIds.join(",");
+    return metadata;
+}
+function pickUpdatePatch(patchInput, keys) {
+    const patch = {};
+    for (const key of keys) {
+        if (hasOwn(patchInput, key) && typeof patchInput[key] === "string") {
+            patch[key] = patchInput[key];
+        }
+    }
+    if (Object.keys(patch).length === 0) {
+        throw new Error("ClawChat metadata update must include at least one mutable field");
+    }
+    return patch;
+}
+export async function pullOwnerMetadata(params) {
+    const getAgent = params.api.getAgentDetail ?? params.api.getAgentProfile;
+    if (!getAgent)
+        throw new Error("ClawChat metadata pull requires getAgentDetail");
+    if (!params.agentId)
+        throw new Error("ClawChat owner metadata pull requires agentId");
+    const data = await getAgent(params.agentId);
+    const metadata = ownerMetadataFromAgent(asRecord(data.agent) ?? {}, params);
+    const ownerId = metadata.agent_owner_id;
+    const getOwner = params.api.getUserProfile ?? params.api.getUserInfo;
+    if (ownerId && getOwner) {
+        addOwnerProfileMetadata(metadata, asRecord(await getOwner(ownerId)) ?? {});
+    }
+    await writeClawChatMetadata(params.memoryRoot, { targetType: "owner", targetId: "owner" }, metadata);
+    return { ok: true, writes: [{ targetType: "owner", targetId: "owner" }], failures: [] };
+}
+export async function pullUserMetadata(params) {
+    const getUser = params.api.getUserProfile ?? params.api.getUserInfo;
+    if (!getUser)
+        throw new Error("ClawChat metadata pull requires getUserProfile");
+    const profile = await getUser(params.userId);
+    const metadata = userMetadataFromProfile(profile, params.userId);
+    await writeClawChatMetadata(params.memoryRoot, { targetType: "user", targetId: params.userId }, metadata);
+    return { ok: true, writes: [{ targetType: "user", targetId: params.userId }], failures: [] };
+}
+export async function pullGroupMetadata(params) {
+    if (!params.api.getConversation)
+        throw new Error("ClawChat metadata pull requires getConversation");
+    const getUser = params.api.getUserProfile ?? params.api.getUserInfo;
+    const data = await params.api.getConversation(params.groupId);
+    const writes = [];
+    const failures = [];
+    const conversationType = stringField(data.conversation, "type")
+        ?.trim()
+        .toLowerCase();
+    if (conversationType === "direct" || conversationType === "dm") {
+        return { ok: true, writes, failures, conversation: data.conversation };
+    }
+    const groupMetadata = groupMetadataFromConversation(data.conversation, params.groupId);
+    const skipUserIds = normalizeSkipUserIds(params.skipUserIds);
+    if (groupMetadata.group_owner_id &&
+        !groupMetadata.group_owner_nickname &&
+        getUser &&
+        !skipUserIds.has(groupMetadata.group_owner_id)) {
+        try {
+            const ownerProfile = asRecord(await getUser(groupMetadata.group_owner_id)) ?? {};
+            addStringField(groupMetadata, "group_owner_nickname", ownerProfile, "nickname");
+            addStringField(groupMetadata, "group_owner_profile_type", ownerProfile, "type");
+        }
+        catch (error) {
+            failures.push({ targetType: "user", targetId: groupMetadata.group_owner_id, error: errorMessage(error) });
+        }
+    }
+    await writeClawChatMetadata(params.memoryRoot, { targetType: "group", targetId: params.groupId }, groupMetadata);
+    writes.push({ targetType: "group", targetId: params.groupId });
+    const participants = Array.isArray(data.conversation.participants)
+        ? data.conversation.participants
+        : [];
+    for (const participant of participants) {
+        const mapped = participantUserMetadata(participant);
+        if (!mapped)
+            continue;
+        if (skipUserIds.has(mapped.userId))
+            continue;
+        try {
+            const existing = await readClawChatMemoryFile(params.memoryRoot, {
+                targetType: "user",
+                targetId: mapped.userId,
+            });
+            if (existing.exists)
+                continue;
+            if (!getUser)
+                throw new Error("ClawChat participant metadata pull requires getUserProfile");
+            const profile = await getUser(mapped.userId);
+            const metadata = userMetadataFromProfile(profile, mapped.userId);
+            await writeClawChatMetadata(params.memoryRoot, { targetType: "user", targetId: mapped.userId }, metadata);
+            writes.push({ targetType: "user", targetId: mapped.userId });
+        }
+        catch (error) {
+            failures.push({ targetType: "user", targetId: mapped.userId, error: errorMessage(error) });
+        }
+    }
+    return { ok: failures.length === 0, writes, failures, conversation: data.conversation };
+}
+export async function pushMetadata(params) {
+    const file = await readClawChatMemoryFile(params.memoryRoot, {
+        targetType: params.targetType,
+        targetId: params.targetId,
+    });
+    return await updateMetadata({
+        memoryRoot: params.memoryRoot,
+        targetType: params.targetType,
+        targetId: params.targetId,
+        agentId: params.agentId,
+        accountUserId: params.accountUserId,
+        patch: pickPushPatch(params.targetType, params.targetId, file.metadata, {
+            fields: params.fields,
+            agentId: params.agentId,
+            accountUserId: params.accountUserId,
+        }),
+        api: params.api,
+    });
+}
+function mutableFieldsForTarget(targetType, targetId, params) {
+    if (targetType === "owner") {
+        if (targetId !== "owner")
+            throw new Error("ClawChat owner metadata targetId must be owner");
+        if (!params.agentId)
+            throw new Error("ClawChat owner metadata update requires agentId");
+        return ["agent_behavior"];
+    }
+    if (targetType === "user") {
+        if (!params.accountUserId)
+            throw new Error("ClawChat user metadata update requires accountUserId");
+        if (targetId !== params.accountUserId) {
+            throw new Error("ClawChat user metadata update is allowed only for the connected user");
+        }
+        return ["nickname", "avatar_url", "bio"];
+    }
+    return ["group_title", "group_description"];
+}
+function pickPushPatch(targetType, targetId, metadata, params) {
+    if (!Array.isArray(params.fields) || params.fields.length === 0) {
+        throw new Error("fields are required for metadata push");
+    }
+    const allowed = mutableFieldsForTarget(targetType, targetId, params);
+    const patch = {};
+    for (const field of params.fields) {
+        if (typeof field !== "string" || field.length === 0) {
+            throw new Error("fields must contain non-empty strings");
+        }
+        if (!allowed.includes(field)) {
+            throw new Error(`fields contain non-pushable metadata field: ${field}`);
+        }
+        if (!hasOwn(metadata, field)) {
+            throw new Error(`missing_metadata_field: ${field}`);
+        }
+        patch[field] = metadata[field];
+    }
+    return patch;
+}
+export async function updateMetadata(params) {
+    if (params.targetType === "owner") {
+        if (!params.agentId)
+            throw new Error("ClawChat owner metadata update requires agentId");
+        if (!params.api.updateAgentBehavior) {
+            throw new Error("ClawChat owner metadata update requires updateAgentBehavior");
+        }
+        const localPatch = pickUpdatePatch(params.patch, ["agent_behavior"]);
+        const response = await params.api.updateAgentBehavior(localPatch.agent_behavior);
+        const metadata = ownerMetadataFromAgent(response.agent, {
+            accountUserId: params.accountUserId,
+        });
+        const ownerId = metadata.agent_owner_id;
+        const getOwner = params.api.getUserProfile ?? params.api.getUserInfo;
+        if (ownerId && getOwner) {
+            addOwnerProfileMetadata(metadata, asRecord(await getOwner(ownerId)) ?? {});
+        }
+        await writeClawChatMetadata(params.memoryRoot, { targetType: "owner", targetId: "owner" }, metadata);
+        return { ok: true, writes: [{ targetType: "owner", targetId: "owner" }], failures: [], metadata };
+    }
+    if (params.targetType === "user") {
+        if (!params.accountUserId)
+            throw new Error("ClawChat user metadata update requires accountUserId");
+        if (params.targetId !== params.accountUserId) {
+            throw new Error("ClawChat user metadata update is allowed only for the connected user");
+        }
+        if (!params.api.updateMyProfile)
+            throw new Error("ClawChat user metadata update requires updateMyProfile");
+        const patch = pickUpdatePatch(params.patch, ["nickname", "avatar_url", "bio"]);
+        const profile = await params.api.updateMyProfile(patch);
+        const metadata = userMetadataFromProfile(profile, params.targetId);
+        await writeClawChatMetadata(params.memoryRoot, { targetType: "user", targetId: params.targetId }, metadata);
+        return { ok: true, writes: [{ targetType: "user", targetId: params.targetId }], failures: [], metadata };
+    }
+    if (!params.api.patchConversation)
+        throw new Error("ClawChat group metadata update requires patchConversation");
+    const patch = pickUpdatePatch(params.patch, ["group_title", "group_description"]);
+    const response = await params.api.patchConversation(params.targetId, {
+        title: patch.group_title,
+        description: patch.group_description,
+    });
+    const metadata = groupMetadataFromConversation(response.conversation, params.targetId);
+    await writeClawChatMetadata(params.memoryRoot, { targetType: "group", targetId: params.targetId }, metadata);
+    return { ok: true, writes: [{ targetType: "group", targetId: params.targetId }], failures: [], metadata };
+}

package/dist/src/client.js

@@ -0,0 +1,35 @@
+import { createClawChatClient } from "./ws-client.js";
+export function createOpenclawClawlingClient(account, overrides = {}) {
+    const client = createClawChatClient({
+        url: account.websocketUrl,
+        token: account.token,
+        deviceId: account.userId,
+        ...(overrides.transport ? { transport: overrides.transport } : {}),
+        reconnect: {
+            enabled: true,
+            initialDelay: account.reconnect.initialDelay,
+            maxDelay: account.reconnect.maxDelay,
+            jitterRatio: account.reconnect.jitterRatio,
+            maxRetries: account.reconnect.maxRetries,
+        },
+        heartbeat: {
+            enabled: true,
+            interval: account.heartbeat.interval,
+            timeout: account.heartbeat.timeout,
+        },
+        ack: {
+            timeout: account.ack.timeout,
+            autoResendOnTimeout: account.ack.autoResendOnTimeout,
+        },
+    });
+    if (overrides.wsLifecycle?.onConnectFrameSent) {
+        const sendRawEnvelope = client.sendRawEnvelope.bind(client);
+        client.sendRawEnvelope = (env) => {
+            sendRawEnvelope(env);
+            if (env.event === "connect") {
+                overrides.wsLifecycle?.onConnectFrameSent?.(env);
+            }
+        };
+    }
+    return client;
+}

package/dist/src/commands.js

@@ -0,0 +1,35 @@
+function extractInviteCode(value) {
+    const raw = typeof value === "string" ? value.trim() : "";
+    return raw.match(/\b[A-Z0-9]{6}\b/u)?.[0] ?? "";
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+export function registerOpenclawClawlingCommands(api) {
+    api.registerCommand({
+        name: "clawchat-activate",
+        description: "Activate ClawChat with an invite code, e.g. /clawchat-activate A1B2C3.",
+        acceptsArgs: true,
+        requireAuth: true,
+        async handler(ctx) {
+            const code = extractInviteCode(ctx.args ?? ctx.commandBody);
+            if (!code) {
+                return { text: "ClawChat invite code is required. Usage: /clawchat-activate A1B2C3" };
+            }
+            try {
+                const { runOpenclawClawlingLogin } = await import("./login.runtime.js");
+                await runOpenclawClawlingLogin({
+                    cfg: ctx.config,
+                    accountId: ctx.accountId ?? null,
+                    runtime: { log: (message) => api.logger?.info?.(message) },
+                    readInviteCode: async () => code,
+                    mutateConfigFile: api.runtime.config.mutateConfigFile,
+                });
+                return { text: "✅ ClawChat activated successfully." };
+            }
+            catch (err) {
+                return { text: `❌ ${errorMessage(err)}` };
+            }
+        },
+    });
+}

package/dist/src/config.js

@@ -0,0 +1,274 @@
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
+export const CHANNEL_ID = "clawchat-plugin-openclaw";
+export const CLAWCHAT_TOKEN_ENV = "CLAWCHAT_TOKEN";
+export const CLAWCHAT_AGENT_ID_ENV = "CLAWCHAT_AGENT_ID";
+export const CLAWCHAT_USER_ID_ENV = "CLAWCHAT_USER_ID";
+export const CLAWCHAT_OWNER_USER_ID_ENV = "CLAWCHAT_OWNER_USER_ID";
+export const CLAWCHAT_REFRESH_TOKEN_ENV = "CLAWCHAT_REFRESH_TOKEN";
+export const CLAWCHAT_BASE_URL_ENV = "CLAWCHAT_BASE_URL";
+export const CLAWCHAT_WEBSOCKET_URL_ENV = "CLAWCHAT_WEBSOCKET_URL";
+/**
+ * Built-in defaults for the Clawling Chat endpoints so `openclaw channel
+ * login` works out of the box without requiring a prior `openclaw channel
+ * setup` call. Operators can still override either one via config.
+ *
+ */
+export const DEFAULT_BASE_URL = "https://app.clawling.com";
+export const DEFAULT_WEBSOCKET_URL = "wss://app.clawling.com/ws";
+export const DEFAULT_RECONNECT = {
+    // Snappier first retry on transient drops (vs. 1_000).
+    initialDelay: 500,
+    // Cap exponential backoff at 15s — a background gateway reconnecting
+    // every 30s feels unresponsive; 15s is the common IM chat bar.
+    maxDelay: 15_000,
+    // Standard jitter ratio to avoid thundering herd on server restart.
+    jitterRatio: 0.3,
+    // Never give up — the gateway is a long-lived background process.
+    maxRetries: Number.POSITIVE_INFINITY,
+};
+export const DEFAULT_HEARTBEAT = {
+    // 20s keeps NAT/firewall state warm without wasting bandwidth.
+    interval: 20_000,
+    // Pong must arrive within 10s or we tear down and reconnect.
+    timeout: 10_000,
+};
+export const DEFAULT_ACK = {
+    // 15s tolerates a slow server + one retry without false timeouts.
+    timeout: 15_000,
+    // Keep false: auto-resend on timeout risks duplicate messages; the
+    // reconnect path re-queues via `queueWhileReconnecting` instead.
+    autoResendOnTimeout: false,
+};
+export const openclawClawlingConfigSchema = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        enabled: { type: "boolean" },
+        websocketUrl: { type: "string" },
+        baseUrl: { type: "string" },
+        token: { type: "string" },
+        refreshToken: { type: "string" },
+        agentId: { type: "string" },
+        userId: { type: "string" },
+        ownerUserId: { type: "string" },
+        groupMode: { type: "string", enum: ["mention", "all"] },
+        groupCommandMode: { type: "string", enum: ["owner", "all", "off"] },
+        groups: {
+            type: "object",
+            additionalProperties: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    groupMode: { type: "string", enum: ["mention", "all"] },
+                    groupCommandMode: { type: "string", enum: ["owner", "all", "off"] },
+                },
+            },
+        },
+        forwardThinking: { type: "boolean" },
+        forwardToolCalls: { type: "boolean" },
+        richInteractions: { type: "boolean" },
+        reconnect: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                initialDelay: { type: "integer", minimum: 100 },
+                maxDelay: { type: "integer", minimum: 100 },
+                jitterRatio: { type: "number", minimum: 0 },
+                maxRetries: { type: "integer", minimum: 0 },
+            },
+        },
+        heartbeat: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                interval: { type: "integer", minimum: 1000 },
+                timeout: { type: "integer", minimum: 1000 },
+            },
+        },
+        ack: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                timeout: { type: "integer", minimum: 100 },
+                autoResendOnTimeout: { type: "boolean" },
+            },
+        },
+    },
+};
+function isOpenclawClawchatToolAllowEntry(entry) {
+    return entry === CHANNEL_ID || entry === "group:plugins";
+}
+function mergeToolPolicyEntryAlsoAllow(cfg, entry, isAlreadyCovered) {
+    const currentTools = (cfg.tools ?? {});
+    const currentAlsoAllow = Array.isArray(currentTools.alsoAllow)
+        ? currentTools.alsoAllow.slice()
+        : [];
+    const currentAllow = Array.isArray(currentTools.allow) ? currentTools.allow.slice() : [];
+    const alreadyCovered = [...currentAllow, ...currentAlsoAllow].some(isAlreadyCovered);
+    if (alreadyCovered) {
+        return {
+            ...cfg,
+            tools: {
+                ...currentTools,
+                ...(Array.isArray(currentTools.allow) ? { allow: currentAllow } : {}),
+                ...(Array.isArray(currentTools.alsoAllow) ? { alsoAllow: currentAlsoAllow } : {}),
+            },
+        };
+    }
+    return {
+        ...cfg,
+        tools: {
+            ...currentTools,
+            alsoAllow: [...currentAlsoAllow, entry],
+        },
+    };
+}
+export function mergeOpenclawClawchatToolAllow(cfg) {
+    return mergeToolPolicyEntryAlsoAllow(cfg, CHANNEL_ID, isOpenclawClawchatToolAllowEntry);
+}
+function readRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+export function mergeOpenclawClawchatRuntimePluginActivation(cfg) {
+    const currentPlugins = readRecord(cfg.plugins);
+    const currentEntries = readRecord(currentPlugins.entries);
+    const currentEntry = readRecord(currentEntries[CHANNEL_ID]);
+    const currentAllow = Array.isArray(currentPlugins.allow) ? currentPlugins.allow.slice() : [];
+    const nextPlugins = {
+        ...currentPlugins,
+        entries: {
+            ...currentEntries,
+            [CHANNEL_ID]: {
+                ...currentEntry,
+                enabled: true,
+            },
+        },
+    };
+    if (!currentAllow.includes(CHANNEL_ID)) {
+        nextPlugins.allow = [...currentAllow, CHANNEL_ID];
+    }
+    return {
+        ...cfg,
+        plugins: nextPlugins,
+    };
+}
+function readChannelSection(cfg) {
+    const channels = (cfg.channels ?? {});
+    const channel = channels[CHANNEL_ID];
+    return channel && typeof channel === "object" ? channel : {};
+}
+function readOptionalString(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function readEnvString(env, key) {
+    return readOptionalString(env[key]);
+}
+function readGroupMode(value) {
+    return value === "mention" ? "mention" : "all";
+}
+function readGroupCommandMode(value) {
+    return value === "all" || value === "off" ? value : "owner";
+}
+function readGroups(value) {
+    const rawGroups = value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+    const groups = {};
+    for (const [chatId, rawGroup] of Object.entries(rawGroups)) {
+        if (!chatId)
+            continue;
+        const group = rawGroup && typeof rawGroup === "object" && !Array.isArray(rawGroup)
+            ? rawGroup
+            : {};
+        groups[chatId] = {
+            groupMode: readGroupMode(group.groupMode),
+            groupCommandMode: readGroupCommandMode(group.groupCommandMode),
+        };
+    }
+    return groups;
+}
+export function effectiveGroupMode(account, chatId) {
+    return account.groups[chatId]?.groupMode
+        ?? account.groups["*"]?.groupMode
+        ?? account.groupMode;
+}
+export function effectiveGroupCommandMode(account, chatId) {
+    return account.groups[chatId]?.groupCommandMode
+        ?? account.groups["*"]?.groupCommandMode
+        ?? account.groupCommandMode;
+}
+function readReconnect(raw) {
+    const s = raw && typeof raw === "object" ? raw : {};
+    return {
+        initialDelay: typeof s.initialDelay === "number" ? s.initialDelay : DEFAULT_RECONNECT.initialDelay,
+        maxDelay: typeof s.maxDelay === "number" ? s.maxDelay : DEFAULT_RECONNECT.maxDelay,
+        jitterRatio: typeof s.jitterRatio === "number" ? s.jitterRatio : DEFAULT_RECONNECT.jitterRatio,
+        maxRetries: typeof s.maxRetries === "number" && Number.isFinite(s.maxRetries)
+            ? s.maxRetries
+            : DEFAULT_RECONNECT.maxRetries,
+    };
+}
+function readHeartbeat(raw) {
+    const s = raw && typeof raw === "object" ? raw : {};
+    return {
+        interval: typeof s.interval === "number" ? s.interval : DEFAULT_HEARTBEAT.interval,
+        timeout: typeof s.timeout === "number" ? s.timeout : DEFAULT_HEARTBEAT.timeout,
+    };
+}
+function readAck(raw) {
+    const s = raw && typeof raw === "object" ? raw : {};
+    return {
+        timeout: typeof s.timeout === "number" ? s.timeout : DEFAULT_ACK.timeout,
+        autoResendOnTimeout: typeof s.autoResendOnTimeout === "boolean"
+            ? s.autoResendOnTimeout
+            : DEFAULT_ACK.autoResendOnTimeout,
+    };
+}
+export function resolveOpenclawClawlingAccount(cfg, env = process.env) {
+    const channel = readChannelSection(cfg);
+    // Apply built-in defaults so login/gateway work without prior setup.
+    const websocketUrl = readOptionalString(channel.websocketUrl) ||
+        readEnvString(env, CLAWCHAT_WEBSOCKET_URL_ENV) ||
+        DEFAULT_WEBSOCKET_URL;
+    const baseUrl = readOptionalString(channel.baseUrl) ||
+        readEnvString(env, CLAWCHAT_BASE_URL_ENV) ||
+        DEFAULT_BASE_URL;
+    const token = readOptionalString(channel.token) || readEnvString(env, CLAWCHAT_TOKEN_ENV);
+    const agentId = readOptionalString(channel.agentId) || readEnvString(env, CLAWCHAT_AGENT_ID_ENV);
+    const userId = readOptionalString(channel.userId) || readEnvString(env, CLAWCHAT_USER_ID_ENV);
+    const ownerUserId = readOptionalString(channel.ownerUserId) || readEnvString(env, CLAWCHAT_OWNER_USER_ID_ENV);
+    const enabled = typeof channel.enabled === "boolean" ? channel.enabled : true;
+    const groupMode = readGroupMode(channel.groupMode);
+    const groupCommandMode = readGroupCommandMode(channel.groupCommandMode);
+    const groups = readGroups(channel.groups);
+    const forwardThinking = typeof channel.forwardThinking === "boolean" ? channel.forwardThinking : true;
+    const forwardToolCalls = typeof channel.forwardToolCalls === "boolean" ? channel.forwardToolCalls : false;
+    const richInteractions = typeof channel.richInteractions === "boolean" ? channel.richInteractions : false;
+    return {
+        accountId: DEFAULT_ACCOUNT_ID,
+        name: CHANNEL_ID,
+        enabled,
+        configured: Boolean(websocketUrl && token && userId && ownerUserId),
+        websocketUrl,
+        baseUrl,
+        token,
+        agentId,
+        userId,
+        ownerUserId,
+        groupMode,
+        groupCommandMode,
+        groups,
+        forwardThinking,
+        forwardToolCalls,
+        richInteractions,
+        allowFrom: [],
+        reconnect: readReconnect(channel.reconnect),
+        heartbeat: readHeartbeat(channel.heartbeat),
+        ack: readAck(channel.ack),
+    };
+}
+export function listOpenclawClawlingAccountIds() {
+    return [DEFAULT_ACCOUNT_ID];
+}