@clawling/clawchat-plugin-openclaw 2026.9.7-1 → 2026.9.8-2

package/README.md

@@ -31,7 +31,7 @@ Install and activate the ClawChat plugin from npm package @clawling/clawchat-plu
 Pick one of these invite-code activation paths after the plugin is loaded
 into OpenClaw:
 
-- **Runtime slash command (recommended).** Send `/clawchat-activate A1B2C3`
+- **Runtime slash command (recommended).** Send `/clawchat-activate K7RM4TQP`
   in the chat where OpenClaw is running. Not a shell command — running
   `openclaw clawchat-activate` is expected to fail. This is the reliable
   first-time activation path on OpenClaw 2026.5.5 and newer.

package/dist/src/commands.js

@@ -4,9 +4,27 @@ const ACTIVATION_FLAGS = ["--new-account", "--repair"];
 function stripActivationFlags(raw) {
     return ACTIVATION_FLAGS.reduce((acc, flag) => acc.split(flag).join(" "), raw);
 }
+/**
+ * A whole argument token that looks like a ClawChat connect code.
+ *
+ * member-backend mints **8** characters drawn from
+ * `ABCDEFGHJKLMNPQRSTUVWXYZ23456789`, with 0/1/I/O excluded so humans can
+ * transcribe them. This deliberately accepts a band around that length rather
+ * than exactly 8: the length is the server's to choose, and pinning it here is
+ * what previously broke activation outright. A too-long or too-short token is left for the server to reject —
+ * the code is checked there anyway, so a permissive local filter costs nothing
+ * while a strict one silently swallows valid codes.
+ *
+ * Matching whole tokens (not a substring scan) is what keeps the command word
+ * itself out of the result when `ctx.args` is absent and we fall back to
+ * `ctx.commandBody`, which still carries `/clawchat-activate`.
+ */
+const INVITE_CODE_PATTERN = /^[A-Z0-9]{6,12}$/u;
 function extractInviteCode(value) {
     const raw = typeof value === "string" ? value.trim() : "";
-    return stripActivationFlags(raw).match(/\b[A-Z0-9]{6}\b/u)?.[0] ?? "";
+    return (stripActivationFlags(raw)
+        .split(/\s+/u)
+        .find((token) => INVITE_CODE_PATTERN.test(token)) ?? "");
 }
 /**
  * Read the activation intent from the command args.
@@ -102,14 +120,14 @@ function formatOutputVisibilityResult(outputVisibility) {
 export function registerOpenclawClawlingCommands(api) {
     api.registerCommand({
         name: "clawchat-activate",
-        description: "Activate ClawChat with an invite code, e.g. /clawchat-activate A1B2C3.",
+        description: "Activate ClawChat with an invite code, e.g. /clawchat-activate K7RM4TQP.",
         acceptsArgs: true,
         requireAuth: true,
         async handler(ctx) {
             const rawArgs = ctx.args ?? ctx.commandBody;
             const code = extractInviteCode(rawArgs);
             if (!code) {
-                return { text: "ClawChat invite code is required. Usage: /clawchat-activate A1B2C3" };
+                return { text: "ClawChat invite code is required. Usage: /clawchat-activate K7RM4TQP" };
             }
             const intent = extractActivationIntent(rawArgs);
             try {

package/dist/src/login.runtime.js

@@ -37,17 +37,17 @@ export class ExistingActivationError extends Error {
     agentId;
     constructor(userId, agentId = "") {
         const who = agentId ? `agent ${agentId} (shadow user ${userId})` : `agent ${userId}`;
-        super(`this OpenClaw instance is already paired to ClawChat ${who}. ` +
-            "Redeeming another invite code here would re-bind that code to the SAME " +
-            "agent — no second agent is created, and this instance's credentials are " +
-            "overwritten.\n" +
-            "  - To run a SECOND agent alongside this one, give it its own OpenClaw " +
-            "home:\n" +
-            "      OPENCLAW_HOME=<path> openclaw channels login --channel clawchat-plugin-openclaw\n" +
-            "  - To REPLACE this instance's agent with a brand-new identity: " +
-            "/clawchat-activate <CODE> --new-account\n" +
-            "  - To re-pair THIS agent (e.g. after losing its token): " +
-            "/clawchat-activate <CODE> --repair");
+        super(`this OpenClaw instance is already paired to ClawChat ${who}, and there is ` +
+            "nobody here to ask which outcome you want. The invite code was NOT " +
+            "spent. Re-run stating the intent:\n" +
+            "  - Pair as a BRAND-NEW agent (this instance stops using the identity " +
+            "above): /clawchat-activate <CODE> --new-account\n" +
+            "  - 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");
         this.name = "ExistingActivationError";
         this.userId = userId;
         this.agentId = agentId;
@@ -76,6 +76,43 @@ async function promptInviteCodeFromStdin(runtime) {
         rl?.close();
     }
 }
+/**
+ * Ask the operator which outcome they want, on the same stdin channel the
+ * invite-code prompt already uses.
+ *
+ * Returns `null` when nobody can answer. Both outcomes are irreversible in
+ * opposite directions — "new" strands the agent this instance currently holds,
+ * "restore" can revive an agent the owner just deleted — so an unattended run
+ * must not pick one. `null` refuses instead, leaving the code redeemable.
+ *
+ * A non-TTY stdin is the unattended case: a piped/closed stdin makes
+ * `rl.question` resolve instantly with an empty line, which would otherwise
+ * read as a silent answer. An unrecognized reply is also `null`: this is the
+ * one prompt where guessing at the operator's meaning is worse than stopping.
+ */
+async function promptActivationIntentFromStdin(runtime, who) {
+    if (!process.stdin.isTTY)
+        return null;
+    runtime.log(`This OpenClaw instance already holds ClawChat ${who}.\n` +
+        "  [1] Pair as a BRAND-NEW agent — this instance stops using that identity.\n" +
+        "  [2] RESTORE that identity — re-pairs the same agent; if it was deleted, " +
+        "this brings it back with its history.\n" +
+        "Enter 1 or 2 (press Enter to submit):");
+    let rl;
+    try {
+        rl = createInterface({ input: process.stdin, output: process.stdout });
+        const answer = (await rl.question("> ")).trim();
+        if (answer === "1")
+            return "new-account";
+        if (answer === "2")
+            return "repair";
+        runtime.log(`Unrecognized choice ${JSON.stringify(answer)} — not activating.`);
+        return null;
+    }
+    finally {
+        rl?.close();
+    }
+}
 function buildLoginConfig(cfg, result) {
     const channels = (cfg.channels ?? {});
     const existing = (channels[CHANNEL_ID] ?? {});
@@ -165,13 +202,32 @@ export async function runOpenclawClawlingLogin(params) {
     // `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);
-    // Guard before the invite code is even read, so a refused activation never
-    // spends the code — the operator can still redeem it the right way. "Live" is
-    // decided by whether a usable token remains: auto-logout (§C) blanks the
-    // tokens but preserves the identity, so a logged-out instance still re-pairs
-    // with no flag at all, which is the flow the replay exists for.
-    if (account.userId.trim() && account.token.trim() && !params.newAccount && !params.repair) {
-        throw new ExistingActivationError(account.userId.trim(), account.agentId.trim());
+    // 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
+    // remains: auto-logout (§C) blanks the tokens but preserves the identity, so a
+    // logged-out instance still re-pairs with no flag at all, which is the flow
+    // the replay exists for.
+    //
+    // Holding an identity is not itself an error — it just means the run is
+    // ambiguous, because redeeming a code here can either mint a new agent or
+    // re-pair the incumbent one. Ask which, and only refuse when nobody answers.
+    // An explicit `newAccount` / `repair` from the caller has already settled it,
+    // so no prompt.
+    let newAccount = params.newAccount;
+    if (account.userId.trim() && account.token.trim() && !newAccount && !params.repair) {
+        const identity = account.agentId.trim()
+            ? `agent ${account.agentId.trim()} (shadow user ${account.userId.trim()})`
+            : `agent ${account.userId.trim()}`;
+        const intent = await (params.readActivationIntent ??
+            (() => promptActivationIntentFromStdin(runtime, identity)))();
+        // Only "new-account" changes what gets sent. Restoring needs no flag:
+        // replaying the stored `user_id` IS the re-pair, and that is already the
+        // default below — so choosing it simply means "don't refuse".
+        if (intent === "new-account")
+            newAccount = true;
+        else if (intent === null) {
+            throw new ExistingActivationError(account.userId.trim(), account.agentId.trim());
+        }
     }
     const inviteCode = (await (params.readInviteCode ?? (() => promptInviteCodeFromStdin(runtime)))()).trim();
     if (!inviteCode) {
@@ -189,7 +245,7 @@ export async function runOpenclawClawlingLogin(params) {
     let result;
     // A brand-new identity is precisely "do not replay" — the replay is the only
     // thing that would bind this code to the incumbent agent.
-    const existingUserId = params.newAccount ? "" : account.userId.trim();
+    const existingUserId = newAccount ? "" : account.userId.trim();
     try {
         result = await apiClient.agentsConnect({
             code: inviteCode,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawling/clawchat-plugin-openclaw",
-  "version": "2026.9.7-1",
+  "version": "2026.9.8-2",
   "description": "OpenClaw ClawChat channel plugin",
   "license": "MIT",
   "author": "CLAWLING PTE. LTD.",

package/src/commands.ts

@@ -10,9 +10,30 @@ function stripActivationFlags(raw: string): string {
   return ACTIVATION_FLAGS.reduce((acc, flag) => acc.split(flag).join(" "), raw);
 }
 
+/**
+ * A whole argument token that looks like a ClawChat connect code.
+ *
+ * member-backend mints **8** characters drawn from
+ * `ABCDEFGHJKLMNPQRSTUVWXYZ23456789`, with 0/1/I/O excluded so humans can
+ * transcribe them. This deliberately accepts a band around that length rather
+ * than exactly 8: the length is the server's to choose, and pinning it here is
+ * what previously broke activation outright. A too-long or too-short token is left for the server to reject —
+ * the code is checked there anyway, so a permissive local filter costs nothing
+ * while a strict one silently swallows valid codes.
+ *
+ * Matching whole tokens (not a substring scan) is what keeps the command word
+ * itself out of the result when `ctx.args` is absent and we fall back to
+ * `ctx.commandBody`, which still carries `/clawchat-activate`.
+ */
+const INVITE_CODE_PATTERN = /^[A-Z0-9]{6,12}$/u;
+
 function extractInviteCode(value: unknown): string {
   const raw = typeof value === "string" ? value.trim() : "";
-  return stripActivationFlags(raw).match(/\b[A-Z0-9]{6}\b/u)?.[0] ?? "";
+  return (
+    stripActivationFlags(raw)
+      .split(/\s+/u)
+      .find((token) => INVITE_CODE_PATTERN.test(token)) ?? ""
+  );
 }
 
 /**
@@ -118,14 +139,14 @@ function formatOutputVisibilityResult(outputVisibility: OutputVisibility): strin
 export function registerOpenclawClawlingCommands(api: Pick<OpenClawPluginApi, "registerCommand" | "logger" | "runtime">): void {
   api.registerCommand({
     name: "clawchat-activate",
-    description: "Activate ClawChat with an invite code, e.g. /clawchat-activate A1B2C3.",
+    description: "Activate ClawChat with an invite code, e.g. /clawchat-activate K7RM4TQP.",
     acceptsArgs: true,
     requireAuth: true,
     async handler(ctx) {
       const rawArgs = ctx.args ?? ctx.commandBody;
       const code = extractInviteCode(rawArgs);
       if (!code) {
-        return { text: "ClawChat invite code is required. Usage: /clawchat-activate A1B2C3" };
+        return { text: "ClawChat invite code is required. Usage: /clawchat-activate K7RM4TQP" };
       }
       const intent = extractActivationIntent(rawArgs);
       try {

package/src/login.runtime.ts

@@ -63,8 +63,20 @@ export interface LoginParams {
   newAccount?: boolean;
   /** Re-pair the agent this instance already holds (keeps its identity). */
   repair?: boolean;
+  /**
+   * Ask the operator which outcome they want when this instance already holds
+   * an identity and the caller stated no intent.
+   *
+   * Resolving `null` means "nobody could be asked" and activation is refused
+   * with `ExistingActivationError`. Defaults to
+   * `promptActivationIntentFromStdin`; overridden by tests.
+   */
+  readActivationIntent?: () => Promise<ActivationIntent | null>;
 }
 
+/** The two outcomes available once an identity is already stored. */
+export type ActivationIntent = "new-account" | "repair";
+
 /**
  * Thrown when redeeming an invite code would silently replace a live activation.
  *
@@ -83,17 +95,17 @@ export class ExistingActivationError extends Error {
   constructor(userId: string, agentId = "") {
     const who = agentId ? `agent ${agentId} (shadow user ${userId})` : `agent ${userId}`;
     super(
-      `this OpenClaw instance is already paired to ClawChat ${who}. ` +
-        "Redeeming another invite code here would re-bind that code to the SAME " +
-        "agent — no second agent is created, and this instance's credentials are " +
-        "overwritten.\n" +
-        "  - To run a SECOND agent alongside this one, give it its own OpenClaw " +
-        "home:\n" +
-        "      OPENCLAW_HOME=<path> openclaw channels login --channel clawchat-plugin-openclaw\n" +
-        "  - To REPLACE this instance's agent with a brand-new identity: " +
-        "/clawchat-activate <CODE> --new-account\n" +
-        "  - To re-pair THIS agent (e.g. after losing its token): " +
-        "/clawchat-activate <CODE> --repair",
+      `this OpenClaw instance is already paired to ClawChat ${who}, and there is ` +
+        "nobody here to ask which outcome you want. The invite code was NOT " +
+        "spent. Re-run stating the intent:\n" +
+        "  - Pair as a BRAND-NEW agent (this instance stops using the identity " +
+        "above): /clawchat-activate <CODE> --new-account\n" +
+        "  - 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",
     );
     this.name = "ExistingActivationError";
     this.userId = userId;
@@ -126,6 +138,45 @@ async function promptInviteCodeFromStdin(runtime: {
   }
 }
 
+/**
+ * Ask the operator which outcome they want, on the same stdin channel the
+ * invite-code prompt already uses.
+ *
+ * Returns `null` when nobody can answer. Both outcomes are irreversible in
+ * opposite directions — "new" strands the agent this instance currently holds,
+ * "restore" can revive an agent the owner just deleted — so an unattended run
+ * must not pick one. `null` refuses instead, leaving the code redeemable.
+ *
+ * A non-TTY stdin is the unattended case: a piped/closed stdin makes
+ * `rl.question` resolve instantly with an empty line, which would otherwise
+ * read as a silent answer. An unrecognized reply is also `null`: this is the
+ * one prompt where guessing at the operator's meaning is worse than stopping.
+ */
+async function promptActivationIntentFromStdin(
+  runtime: { log: (message: string) => void },
+  who: string,
+): Promise<ActivationIntent | null> {
+  if (!process.stdin.isTTY) return null;
+  runtime.log(
+    `This OpenClaw instance already holds ClawChat ${who}.\n` +
+      "  [1] Pair as a BRAND-NEW agent — this instance stops using that identity.\n" +
+      "  [2] RESTORE that identity — re-pairs the same agent; if it was deleted, " +
+      "this brings it back with its history.\n" +
+      "Enter 1 or 2 (press Enter to submit):",
+  );
+  let rl: ReadlineInterface | undefined;
+  try {
+    rl = createInterface({ input: process.stdin, output: process.stdout });
+    const answer = (await rl.question("> ")).trim();
+    if (answer === "1") return "new-account";
+    if (answer === "2") return "repair";
+    runtime.log(`Unrecognized choice ${JSON.stringify(answer)} — not activating.`);
+    return null;
+  } finally {
+    rl?.close();
+  }
+}
+
 function buildLoginConfig(cfg: OpenClawConfig, result: AgentConnectResult): OpenClawConfig {
   const channels = (cfg.channels ?? {}) as Record<string, unknown>;
   const existing = (channels[CHANNEL_ID] ?? {}) as Record<string, unknown>;
@@ -235,13 +286,31 @@ export async function runOpenclawClawlingLogin(params: LoginParams): Promise<voi
   // overridden them, so login works without a prior `openclaw channels setup --channel clawchat-plugin-openclaw`.
   const account = resolveOpenclawClawlingAccount(cfg);
 
-  // Guard before the invite code is even read, so a refused activation never
-  // spends the code — the operator can still redeem it the right way. "Live" is
-  // decided by whether a usable token remains: auto-logout (§C) blanks the
-  // tokens but preserves the identity, so a logged-out instance still re-pairs
-  // with no flag at all, which is the flow the replay exists for.
-  if (account.userId.trim() && account.token.trim() && !params.newAccount && !params.repair) {
-    throw new ExistingActivationError(account.userId.trim(), account.agentId.trim());
+  // 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
+  // remains: auto-logout (§C) blanks the tokens but preserves the identity, so a
+  // logged-out instance still re-pairs with no flag at all, which is the flow
+  // the replay exists for.
+  //
+  // Holding an identity is not itself an error — it just means the run is
+  // ambiguous, because redeeming a code here can either mint a new agent or
+  // re-pair the incumbent one. Ask which, and only refuse when nobody answers.
+  // An explicit `newAccount` / `repair` from the caller has already settled it,
+  // so no prompt.
+  let newAccount = params.newAccount;
+  if (account.userId.trim() && account.token.trim() && !newAccount && !params.repair) {
+    const identity = account.agentId.trim()
+      ? `agent ${account.agentId.trim()} (shadow user ${account.userId.trim()})`
+      : `agent ${account.userId.trim()}`;
+    const intent = await (params.readActivationIntent ??
+      (() => promptActivationIntentFromStdin(runtime, identity)))();
+    // Only "new-account" changes what gets sent. Restoring needs no flag:
+    // replaying the stored `user_id` IS the re-pair, and that is already the
+    // default below — so choosing it simply means "don't refuse".
+    if (intent === "new-account") newAccount = true;
+    else if (intent === null) {
+      throw new ExistingActivationError(account.userId.trim(), account.agentId.trim());
+    }
   }
 
   const inviteCode = (
@@ -264,7 +333,7 @@ export async function runOpenclawClawlingLogin(params: LoginParams): Promise<voi
   let result;
   // A brand-new identity is precisely "do not replay" — the replay is the only
   // thing that would bind this code to the incumbent agent.
-  const existingUserId = params.newAccount ? "" : account.userId.trim();
+  const existingUserId = newAccount ? "" : account.userId.trim();
   try {
     result = await apiClient.agentsConnect({
       code: inviteCode,