@clawling/clawchat-plugin-openclaw 2026.10.19-1 → 2026.10.21-1

package/dist/src/channel.setup.js

@@ -142,12 +142,14 @@ export const openclawClawlingSetupPlugin = {
             lastInboundAt: null,
             lastOutboundAt: null,
         }),
-        resolveAccountSnapshot: ({ account }) => ({
+        resolveAccountSnapshot: ({ account, runtime }) => ({
             accountId: account.accountId,
             name: account.name,
             enabled: account.enabled,
             configured: account.configured,
             extra: {
+                ...Object.fromEntries(["installId", "superseded", "supersededAt", "byClientVersion", "ownerNotifiedAt"]
+                    .map((key) => [key, runtime?.[key] ?? null])),
                 websocketUrl: account.websocketUrl || null,
                 baseUrl: account.baseUrl || null,
                 userId: account.userId || null,

package/dist/src/client.js

@@ -37,6 +37,7 @@ export function createOpenclawClawlingClient(account, overrides = {}) {
         token: account.token,
         deviceId,
         clientVersion: resolvePluginVersion(),
+        ...(overrides.installId ? { installId: overrides.installId } : {}),
         ...(overrides.transport ? { transport: overrides.transport } : {}),
         reconnect: {
             enabled: true,

package/dist/src/commands.js

@@ -1,3 +1,6 @@
+import { hasReclaimWaiter, installationStatus, recalledSuperseded, rememberSuperseded, signalReclaim } from "./install-conflict.js";
+import { resolveInstallId } from "./install-identity.js";
+import { clawChatDbPathForStateDir, getClawChatStore } from "./storage.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. */
@@ -198,4 +201,48 @@ export function registerOpenclawClawlingCommands(api) {
             return { text: formatOutputVisibilityResult(outputVisibility) };
         },
     });
+    for (const action of ["reclaim", "status"]) {
+        api.registerCommand({
+            name: `clawchat-${action}`,
+            description: action === "reclaim" ? "Reclaim an agent superseded by another installation." : "Show ClawChat installation and connection status.",
+            requireAuth: true,
+            acceptsArgs: true,
+            async handler(ctx) {
+                const flag = extractAccountFlag(ctx.args ?? ctx.commandBody);
+                if (flag.error)
+                    return { text: `${flag.error}. Usage: /clawchat-${action} [--account <id>]` };
+                const accountId = flag.accountId ?? normalizeOpenclawClawlingAccountId(ctx.accountId);
+                try {
+                    const stateDir = api.runtime.state?.resolveStateDir?.();
+                    const store = getClawChatStore(stateDir ? { dbPath: clawChatDbPathForStateDir(stateDir) } : {});
+                    const lookup = store.lookupSuperseded(accountId);
+                    if (lookup.status === "unavailable")
+                        return { text: "ClawChat installation conflict storage unavailable; try again after storage recovers (a gateway restart also drops a stop that could not be saved)." };
+                    if (action === "reclaim") {
+                        if (lookup.status === "absent" && !hasReclaimWaiter(accountId) && !recalledSuperseded(accountId))
+                            return { text: "This ClawChat installation is not superseded; nothing to reclaim." };
+                        if (!store.clearSuperseded(accountId))
+                            return { text: "Unable to clear ClawChat installation conflict; reclaim failed." };
+                        rememberSuperseded(accountId, null);
+                        return { text: signalReclaim(accountId)
+                                ? "ClawChat reclaim requested; reconnecting this installation."
+                                : "ClawChat conflict cleared; restart the OpenClaw gateway to reconnect this installation." };
+                    }
+                    const fields = installationStatus(lookup.status === "row" ? lookup.row : recalledSuperseded(accountId), resolveInstallId(store));
+                    const { getOpenclawClawlingClient } = await import("./runtime.js");
+                    const connection = fields.superseded ? "superseded" : getOpenclawClawlingClient(accountId)?.state ?? "disconnected";
+                    return { text: [
+                            `ClawChat account: ${accountId}`, `install_id: ${fields.installId ?? "unavailable"}`,
+                            `connection: ${connection}`, `superseded: ${fields.superseded}`,
+                            `superseded_at: ${fields.supersededAt ? new Date(fields.supersededAt).toISOString() : "-"}`,
+                            `by_client_version: ${fields.byClientVersion ?? "unknown"}`,
+                            `owner_notified: ${Boolean(fields.ownerNotifiedAt)}`,
+                        ].join("\n") };
+                }
+                catch {
+                    return { text: "ClawChat installation conflict storage unavailable; command failed." };
+                }
+            },
+        });
+    }
 }

package/dist/src/install-conflict.js

@@ -0,0 +1,76 @@
+const key = Symbol.for("clawchat-plugin-openclaw.reclaimWaiters");
+const markersKey = Symbol.for("clawchat-plugin-openclaw.supersededMarkersByIdentity");
+const state = globalThis;
+const waiters = state[key] ??= new Map();
+const markers = state[markersKey] ??= new Map();
+export function rememberSuperseded(accountId, marker) {
+    if (marker) {
+        const identities = markers.get(accountId) ?? new Map();
+        identities.set(marker.userId, marker);
+        markers.set(accountId, identities);
+    }
+    else
+        markers.delete(accountId);
+}
+/** Fence per account and identity, retained across runtime calls and module generations.
+ * Only explicit reclaim or successful activation clears all identities of an account.
+ */
+export function isInstallationSuperseded(accountId, userId) {
+    const identities = markers.get(accountId);
+    return userId === undefined ? Boolean(identities?.size) : Boolean(identities?.has(userId));
+}
+export function recalledSuperseded(accountId, userId) {
+    const identities = markers.get(accountId);
+    if (userId !== undefined)
+        return identities?.get(userId) ?? null;
+    let newest = null;
+    for (const marker of identities?.values() ?? []) {
+        if (!newest || marker.supersededAt > newest.supersededAt)
+            newest = marker;
+    }
+    return newest;
+}
+export function resetInstallationConflictsForTests() {
+    markers.clear();
+}
+/** Register synchronously, before any notification or other asynchronous work. */
+export function waitForReclaim(accountId, signal) {
+    return new Promise((resolve) => {
+        const entries = waiters.get(accountId) ?? new Set();
+        waiters.set(accountId, entries);
+        const finish = (reclaim) => {
+            entries.delete(wake);
+            if (!entries.size)
+                waiters.delete(accountId);
+            signal.removeEventListener("abort", abort);
+            resolve(reclaim);
+        };
+        const wake = () => finish(true);
+        const abort = () => finish(false);
+        entries.add(wake);
+        signal.addEventListener("abort", abort, { once: true });
+        if (signal.aborted)
+            abort();
+    });
+}
+export function hasReclaimWaiter(accountId) {
+    return Boolean(waiters.get(accountId)?.size);
+}
+export function signalReclaim(accountId) {
+    const entries = waiters.get(accountId);
+    if (!entries?.size)
+        return false;
+    for (const wake of [...entries])
+        wake();
+    return true;
+}
+/** The same fields are used by slash commands and the host status adapter. */
+export function installationStatus(marker, installId) {
+    return {
+        installId: installId?.slice(0, 8) ?? marker?.installId.slice(0, 8) ?? null,
+        superseded: Boolean(marker),
+        supersededAt: marker?.supersededAt ?? null,
+        byClientVersion: marker?.byClientVersion ?? null,
+        ownerNotifiedAt: marker?.ownerNotifiedAt ?? null,
+    };
+}

package/dist/src/install-identity.js

@@ -0,0 +1,86 @@
+import childProcess from "node:child_process";
+import { createHash } from "node:crypto";
+import fs, { realpathSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+let cachedMachineFingerprint;
+export function resetMachineFingerprintForTests() {
+    cachedMachineFingerprint = undefined;
+}
+export function readMachineFingerprint(deps) {
+    if (deps === undefined && cachedMachineFingerprint !== undefined)
+        return cachedMachineFingerprint;
+    const fingerprint = detectMachineFingerprint(deps ?? {});
+    if (deps === undefined)
+        cachedMachineFingerprint = fingerprint;
+    return fingerprint;
+}
+function detectMachineFingerprint(deps) {
+    const platform = deps.platform ?? process.platform;
+    const execFile = deps.execFile ?? ((command, args) => childProcess.execFileSync(command, args, {
+        timeout: 2000, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"],
+    }));
+    try {
+        if (platform === "darwin") {
+            const output = execFile("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"]);
+            const value = /"IOPlatformUUID"\s*=\s*"([^"\r\n]+)"/.exec(output)?.[1]?.trim().toLowerCase();
+            if (value)
+                return `mac:${value}`;
+        }
+        else if (platform === "win32") {
+            const output = execFile("reg.exe", ["query", "HKLM\\SOFTWARE\\Microsoft\\Cryptography", "/v", "MachineGuid"]);
+            const value = /^[\t ]*MachineGuid[\t ]+REG_SZ[\t ]+([^\r\n]+)/im.exec(output)?.[1]?.trim().toLowerCase();
+            if (value)
+                return `win:${value}`;
+        }
+    }
+    catch { /* Fall through without logging machine identifiers. */ }
+    const readFile = deps.readFile ?? ((file) => fs.readFileSync(file, "utf8"));
+    for (const file of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
+        try {
+            const value = readFile(file).trim();
+            if (value)
+                return value;
+        }
+        catch { /* Try the fallback without logging machine identifiers. */ }
+    }
+    try {
+        const mac = Object.values((deps.networkInterfaces ?? os.networkInterfaces)())
+            .flatMap((interfaces) => interfaces ?? [])
+            .filter((entry) => !entry.internal)
+            .map((entry) => entry.mac.toLowerCase())
+            .filter((value) => value && value !== "00:00:00:00:00:00")
+            .sort()[0];
+        if (mac)
+            return `host:${createHash("sha256").update(`${(deps.hostname ?? os.hostname)()}:${mac}`).digest("hex").slice(0, 24)}`;
+    }
+    catch { /* No usable host fingerprint; preserve legacy empty material. */ }
+    return "";
+}
+/** Resolve symlinks so one state directory reached through an alias keeps one ID. */
+function canonicalDir(dir) {
+    try {
+        return realpathSync(dir);
+    }
+    catch {
+        return dir;
+    }
+}
+export function resolveInstallId(store, options = {}) {
+    try {
+        const uuid = store?.getOrCreateInstallUuid?.();
+        if (!uuid)
+            throw new Error("Install identity unavailable");
+        // The state directory's absolute path separates a copy of the same state
+        // into another directory (or OS user) on the same machine: that copy keeps
+        // the persisted device id, so it must not look like the same installation.
+        const stateDir = options.stateDir ?? (store?.dbPath ? canonicalDir(path.dirname(path.resolve(store.dbPath))) : "");
+        return createHash("sha256")
+            .update(`${uuid}:${options.fingerprint ?? readMachineFingerprint()}:${options.hostname ?? os.hostname()}:${stateDir}`)
+            .digest("hex").slice(0, 24);
+    }
+    catch {
+        options.warn?.("clawchat.install_identity unavailable; using legacy connection behavior");
+        return undefined;
+    }
+}

package/dist/src/login.runtime.js

@@ -5,6 +5,7 @@ import { resolvePluginVersion } from "./plugin-report.js";
 import { openclawClawlingAccountSlotPath, patchOpenclawClawlingAccountSection } from "./account-config-writes.js";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
 import { CHANNEL_ID, mergeOpenclawClawchatRuntimePluginActivation, mergeOpenclawClawchatToolAllow, normalizeOpenclawClawlingAccountId, readOpenclawClawlingAccountSection, resolveOpenclawClawlingAccount, } from "./config.js";
+import { rememberSuperseded, signalReclaim } from "./install-conflict.js";
 import { getClawChatStore } from "./storage.js";
 import { buildOnboardingContext, RECONNECT_GUIDE_URL } from "./onboarding-context.js";
 import { boundCodeNewIdentityMessage, preCheckConnectCode, unpairableMessage } from "./connect-check.js";
@@ -405,6 +406,10 @@ export async function runOpenclawClawlingLogin(params) {
             // sends the same device id the backend baked into the session.
             deviceId: CHANNEL_ID,
         });
+        if (store.clearSuperseded?.(accountId) === true) {
+            rememberSuperseded(accountId, null);
+            signalReclaim(accountId);
+        }
     }
     catch {
         runtime.log("clawchat-plugin-openclaw sqlite activation persistence failed; login continues.");

package/dist/src/owner-sibling-notify.js

@@ -0,0 +1,59 @@
+import { randomUUID } from "node:crypto";
+import os from "node:os";
+import { resolveOwnerIdentity } from "./owner-identity.js";
+import { resolveOwnerLanguage } from "./owner-language.js";
+import { createClawChatClient } from "./ws-client.js";
+export const STANDALONE_DEVICE_SUFFIX = "-standalone";
+export const OWNER_NOTICE_TIMEOUT_MS = 20_000;
+export function formatSupersededOwnerNotice(locale, version, hostname) {
+    const language = resolveOwnerLanguage(locale);
+    const host = hostname?.trim();
+    return language === "zh" || language === "zh_Hant"
+        ? `⚠️ 这个 agent 已在另一处安装上线${version ? `(对方版本 ${version})` : ""},${host ? `本机(${host})上的` : "这里的"}这份安装已停止连接,避免两边互相顶号。如需切回本机,请在本机的 OpenClaw 里发送 /clawchat-reclaim。`
+        : `⚠️ This agent was started by another installation${version ? ` (version ${version})` : ""}, so the installation on ${host ? `this machine (${host})` : "this machine"} has stopped connecting to avoid the two kicking each other offline. To switch back to this machine, send /clawchat-reclaim in OpenClaw on this machine.`;
+}
+export async function notifySupersededOwner(options) {
+    const { store, marker, warn } = options;
+    let client;
+    let timer;
+    const close = () => client?.close();
+    try {
+        const owner = resolveOwnerIdentity(store, marker.accountId);
+        const token = store?.getActivationCredentials?.({ platform: "openclaw", accountId: marker.accountId })?.accessToken;
+        if (!owner.conversationId || !token) {
+            warn("clawchat.superseded owner notice skipped; owner chat or stored credentials unavailable");
+            return;
+        }
+        if (options.signal?.aborted || !store?.claimSupersededNotification?.(marker.accountId, Date.now(), marker.supersededAt))
+            return;
+        client = (options.createClient ?? createClawChatClient)({
+            url: options.url, token, deviceId: `${marker.deviceId}${STANDALONE_DEVICE_SUFFIX}`,
+            reconnect: { enabled: false }, heartbeat: { enabled: false },
+            ack: { timeout: OWNER_NOTICE_TIMEOUT_MS, autoResendOnTimeout: false },
+        });
+        options.signal?.addEventListener("abort", close, { once: true });
+        const send = async () => {
+            await client.connect();
+            const locale = store?.getOwnerProfile?.({ platform: "openclaw", accountId: marker.accountId })?.locale;
+            await client.sendAckableEnvelope({
+                eventName: "message.send", chatId: owner.conversationId,
+                payload: {
+                    message_id: randomUUID(), message_mode: "normal",
+                    message: { body: { fragments: [{ kind: "text", text: formatSupersededOwnerNotice(locale, marker.byClientVersion, os.hostname()) }] },
+                        context: { mentions: [], reply: null } },
+                },
+            });
+        };
+        await Promise.race([send(), new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error("Owner notice timeout")), OWNER_NOTICE_TIMEOUT_MS);
+            })]);
+    }
+    catch {
+        warn("clawchat.superseded owner notice failed; will not retry");
+    }
+    finally {
+        clearTimeout(timer);
+        options.signal?.removeEventListener("abort", close);
+        close();
+    }
+}