@openclaw/clickclack 2026.9.6 → 2026.9.8

package/dist/.setup/setup-verify-Msgd70_M.mjs

@@ -0,0 +1,111 @@
+import { h as resolveClickClackAccount } from "./setup-surface-BW1Q06w5.mjs";
+import { i as createClickClackClient, n as resolveWorkspaceId } from "./resolve-BHGLohni.mjs";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { hasConfiguredSecretInput } from "openclaw/plugin-sdk/setup";
+//#region extensions/clickclack/src/setup-verify.ts
+const GATEWAY_RUNNING_MESSAGE = "OpenClaw is running — ClickClack will connect automatically.";
+const GATEWAY_NOT_RUNNING_MESSAGE = "Start OpenClaw to connect: openclaw gateway";
+const GATEWAY_UNKNOWN_MESSAGE = "If OpenClaw is running it connects automatically; otherwise start it with: openclaw gateway";
+function isHttpStatus(error, status) {
+	return typeof error === "object" && error !== null && "status" in error && error.status === status;
+}
+function isWorkspaceNotFound(error) {
+	return error instanceof Error && error.message.startsWith("ClickClack workspace not found:");
+}
+function usesUnavailableImplicitEnvToken(account, tokenOverride) {
+	return account.accountId === DEFAULT_ACCOUNT_ID && Boolean(account.baseUrl && account.workspace) && !tokenOverride && !account.token && !hasConfiguredSecretInput(account.config.token) && !account.config.tokenFile?.trim();
+}
+async function checkClickClackSetupConnection(params) {
+	let workspaceInput = "";
+	try {
+		const account = resolveClickClackAccount({
+			cfg: params.cfg,
+			accountId: params.accountId
+		});
+		workspaceInput = account.workspace;
+		const token = params.token?.trim() || account.token;
+		if (usesUnavailableImplicitEnvToken(account, token)) return { status: "skipped-env-token" };
+		if (!account.baseUrl || !account.workspace || !token) return { status: "skipped-unconfigured" };
+		const client = createClickClackClient({
+			baseUrl: account.apiEndpoint,
+			token
+		});
+		const me = await client.me();
+		const workspaceId = await resolveWorkspaceId(client, account.workspace);
+		const workspace = (await client.workspaces()).find((candidate) => candidate.id === workspaceId);
+		if (!workspace) throw new Error(`ClickClack workspace not found: ${account.workspace}`);
+		return {
+			status: "connected",
+			handle: me.handle,
+			workspaceName: workspace.name
+		};
+	} catch (error) {
+		if (isHttpStatus(error, 401)) return { status: "invalid-token" };
+		if (isWorkspaceNotFound(error)) return {
+			status: "workspace-not-found",
+			workspace: workspaceInput
+		};
+		return {
+			status: "failed",
+			error: formatErrorMessage(error)
+		};
+	}
+}
+function isGatewayNotRunningError(error) {
+	if (typeof error === "object" && error !== null && "name" in error && "kind" in error && "code" in error && error.name === "GatewayTransportError" && error.kind === "closed" && error.code === 1006) return true;
+	const message = formatErrorMessage(error).toLowerCase();
+	return message.includes("econnrefused") || message.includes("connection refused");
+}
+async function probeClickClackGatewayStatus() {
+	try {
+		const { callGatewayFromCli } = await import("openclaw/plugin-sdk/gateway-runtime");
+		await callGatewayFromCli("health", {
+			timeout: "1000",
+			json: true
+		}, void 0, {
+			expectFinal: false,
+			progress: false
+		});
+		return "running";
+	} catch (error) {
+		return isGatewayNotRunningError(error) ? "not-running" : "unavailable";
+	}
+}
+function formatClickClackConnectionLog(result) {
+	switch (result.status) {
+		case "connected": return `Connected as @${result.handle} — workspace ${result.workspaceName} resolved.`;
+		case "invalid-token": return "ClickClack rejected the bot token (401). Copy a current token and rerun setup.";
+		case "workspace-not-found": return `Workspace "${result.workspace}" was not found. Check the id, slug, or name, list available workspaces, and rerun setup.`;
+		case "failed": return `Connection check failed: ${result.error}. Setup was saved; fix the connection and rerun setup.`;
+		case "skipped-env-token": return "Token comes from CLICKCLACK_BOT_TOKEN; verification skipped.";
+		case "skipped-unconfigured": return;
+	}
+}
+function formatClickClackGatewayLog(status) {
+	switch (status) {
+		case "running": return GATEWAY_RUNNING_MESSAGE;
+		case "not-running": return GATEWAY_NOT_RUNNING_MESSAGE;
+		case "unavailable": return GATEWAY_UNKNOWN_MESSAGE;
+	}
+	return GATEWAY_UNKNOWN_MESSAGE;
+}
+async function verifyClickClackAccountAfterSetup(params) {
+	try {
+		const message = formatClickClackConnectionLog(await checkClickClackSetupConnection({
+			cfg: params.cfg,
+			accountId: params.accountId
+		}));
+		if (message) params.runtime.log(message);
+	} catch (error) {
+		params.runtime.log(`Connection check failed: ${formatErrorMessage(error)}. Setup was saved; fix the connection and rerun setup.`);
+	}
+	try {
+		const status = await probeClickClackGatewayStatus();
+		params.runtime.log(formatClickClackGatewayLog(status));
+	} catch {
+		params.runtime.log(GATEWAY_UNKNOWN_MESSAGE);
+	}
+}
+//#endregion
+export { checkClickClackSetupConnection, verifyClickClackAccountAfterSetup };

package/dist/api.js

@@ -1,3 +1,4 @@
-import { _ as DEFAULT_ACCOUNT_ID, b as resolveClickClackAccount, p as clickClackConfigSchema, u as createClickClackClient, v as listClickClackAccountIds, x as resolveDefaultClickClackAccountId, y as listEnabledClickClackAccounts } from "./.setup/setup-surface-BBl3rvVx.mjs";
-import { a as setClickClackRuntime, i as getClickClackRuntime, n as buildClickClackTarget, r as parseClickClackTarget, t as clickClackPlugin } from "./.setup/channel-CT4CVd4d.mjs";
+import { _ as resolveDefaultClickClackAccountId, d as DEFAULT_ACCOUNT_ID, h as resolveClickClackAccount, m as listEnabledClickClackAccounts, p as listClickClackAccountIds, s as clickClackConfigSchema } from "./.setup/setup-surface-BW1Q06w5.mjs";
+import { a as setClickClackRuntime, i as getClickClackRuntime, n as buildClickClackTarget, r as parseClickClackTarget, t as clickClackPlugin } from "./.setup/channel-Bcwtohk7.mjs";
+import { i as createClickClackClient } from "./.setup/resolve-BHGLohni.mjs";
 export { DEFAULT_ACCOUNT_ID, buildClickClackTarget, clickClackConfigSchema, clickClackPlugin, createClickClackClient, getClickClackRuntime, listClickClackAccountIds, listEnabledClickClackAccounts, parseClickClackTarget, resolveClickClackAccount, resolveDefaultClickClackAccountId, setClickClackRuntime };

package/dist/channel-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as clickClackPlugin } from "./.setup/channel-CT4CVd4d.mjs";
+import { t as clickClackPlugin } from "./.setup/channel-Bcwtohk7.mjs";
 export { clickClackPlugin };

package/dist/doctor-contract-api.js

@@ -1,7 +1,164 @@
-import { asObjectRecord } from "openclaw/plugin-sdk/runtime-doctor-migrations";
+import { n as __reExport, t as __exportAll } from "./.setup/rolldown-runtime-B4FMCO8f.mjs";
+//#region packages/normalization-core/src/record-coerce.ts
+/** Type guard for non-array object records at browser-safe boundaries. */
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** Returns a non-array record or null. */
+function asNullableRecord(value) {
+	return isRecord(value) ? value : null;
+}
+//#endregion
+//#region src/config/channel-config-normalization.ts
+/** Applies one channel-specific doctor migration to every object-shaped account. */
+function normalizeChannelAccounts(params) {
+	const rawAccounts = asNullableRecord(params.entry.accounts);
+	if (!rawAccounts) return {
+		entry: params.entry,
+		changed: false
+	};
+	let changed = false;
+	const accounts = { ...rawAccounts };
+	for (const [accountId, value] of Object.entries(rawAccounts)) {
+		const account = asNullableRecord(value);
+		if (!account) continue;
+		const normalized = params.normalizeAccount({
+			account,
+			accountId,
+			pathPrefix: `${params.pathPrefix}.accounts.${accountId}`,
+			changes: params.changes
+		});
+		if (normalized.changed) {
+			accounts[accountId] = normalized.entry;
+			changed = true;
+		}
+	}
+	return changed ? {
+		entry: {
+			...params.entry,
+			accounts
+		},
+		changed: true
+	} : {
+		entry: params.entry,
+		changed: false
+	};
+}
+/** Applies the same channel-specific doctor migration at root and account scope. */
+function normalizeChannelConfigEntries(params) {
+	const changes = params.changes ?? [];
+	const channels = params.cfg.channels;
+	const entry = asNullableRecord(channels?.[params.channelId]);
+	if (!entry) return {
+		config: params.cfg,
+		changes
+	};
+	const channelPath = `channels.${params.channelId}`;
+	const root = params.normalizeEntry({
+		entry,
+		pathPrefix: channelPath,
+		changes
+	});
+	const accounts = normalizeChannelAccounts({
+		entry: root.entry,
+		pathPrefix: channelPath,
+		changes,
+		normalizeAccount: (accountParams) => params.normalizeEntry({
+			entry: accountParams.account,
+			accountId: accountParams.accountId,
+			pathPrefix: accountParams.pathPrefix,
+			changes: accountParams.changes
+		})
+	});
+	if (!root.changed && !accounts.changed) return {
+		config: params.cfg,
+		changes
+	};
+	return {
+		config: {
+			...params.cfg,
+			channels: {
+				...channels,
+				[params.channelId]: accounts.entry
+			}
+		},
+		changes
+	};
+}
+//#endregion
+//#region src/plugin-sdk/legacy-webhook-listener-migration.ts
+/** Preserve explicitly configured webhook listeners while moving ingress onto Gateway routes. */
+function createLegacyWebhookListenerDoctorContract(params) {
+	const portKey = params.portKey ?? "webhookPort";
+	const hostKey = params.hostKey === void 0 ? "webhookHost" : params.hostKey;
+	const source = (entry) => params.webhookKey ? asNullableRecord(entry[params.webhookKey]) : entry;
+	const hasLegacy = (value) => {
+		const entry = asNullableRecord(value);
+		const listener = entry && source(entry);
+		return Boolean(listener && (Object.hasOwn(listener, portKey) || hostKey && Object.hasOwn(listener, hostKey)));
+	};
+	const prefix = `channels.${params.channelKey}`;
+	return {
+		legacyConfigRules: [{
+			path: ["channels", params.channelKey],
+			message: `${prefix} webhook listeners moved to Gateway routes. Run "openclaw doctor --fix" to preserve explicitly configured listener settings as legacyWebhook.`,
+			match: (value) => {
+				const accounts = asNullableRecord(asNullableRecord(value)?.accounts);
+				return hasLegacy(value) || Object.values(accounts ?? {}).some(hasLegacy);
+			}
+		}],
+		normalizeCompatibilityConfig: ({ cfg }) => {
+			const root = asNullableRecord(asNullableRecord(cfg.channels)?.[params.channelKey]);
+			const inherited = root && source(root);
+			const canonicalRoot = asNullableRecord(root?.legacyWebhook);
+			return normalizeChannelConfigEntries({
+				cfg,
+				channelId: params.channelKey,
+				normalizeEntry: ({ entry, accountId, pathPrefix, changes }) => {
+					const listener = source(entry);
+					if (!listener || !hasLegacy(entry)) return {
+						entry,
+						changed: false
+					};
+					const next = { ...entry };
+					const port = Object.hasOwn(listener, portKey) ? listener[portKey] : (accountId ? canonicalRoot?.port ?? inherited?.[portKey] : void 0) ?? params.defaultPort;
+					const inheritedHost = accountId ? canonicalRoot ? canonicalRoot.host : (hostKey ? inherited?.[hostKey] : void 0) ?? params.defaultHost : params.defaultHost;
+					const host = hostKey ? listener[hostKey] ?? inheritedHost : inheritedHost;
+					const legacyPath = [pathPrefix, params.webhookKey].filter(Boolean).join(".");
+					if (Object.hasOwn(entry, "legacyWebhook")) changes.push(`Removed ${legacyPath} legacy listener keys; ${pathPrefix}.legacyWebhook is already configured.`);
+					else if (accountId && root?.legacyWebhook === false) changes.push(`Removed ${legacyPath} legacy listener keys; ${prefix}.legacyWebhook: false keeps this account's inherited listener disabled.`);
+					else {
+						next.legacyWebhook = {
+							port,
+							...host !== void 0 ? { host } : {}
+						};
+						changes.push(`Moved ${legacyPath} listener settings to ${pathPrefix}.legacyWebhook. Point the external callback or reverse proxy at the Gateway port and webhook path, verify delivery, then set legacyWebhook: false to disable legacy forwarding.`);
+					}
+					const updated = params.webhookKey ? { ...listener } : next;
+					delete updated[portKey];
+					if (hostKey) delete updated[hostKey];
+					if (params.webhookKey) {
+						if (Object.keys(updated).length) next[params.webhookKey] = updated;
+						else delete next[params.webhookKey];
+					}
+					return {
+						entry: next,
+						changed: true
+					};
+				}
+			});
+		}
+	};
+}
+//#endregion
+//#region \0openclaw:bundled-sdk:openclaw/plugin-sdk/runtime-doctor-migrations
+var runtime_doctor_migrations_exports = /* @__PURE__ */ __exportAll({ createLegacyWebhookListenerDoctorContract: () => createLegacyWebhookListenerDoctorContract });
+import * as import_openclaw_plugin_sdk_runtime_doctor_migrations from "openclaw/plugin-sdk/runtime-doctor-migrations";
+__reExport(runtime_doctor_migrations_exports, import_openclaw_plugin_sdk_runtime_doctor_migrations);
+//#endregion
 //#region extensions/clickclack/src/doctor-contract.ts
 function stripTimeoutSeconds(value) {
-	const record = asObjectRecord(value);
+	const record = (0, runtime_doctor_migrations_exports.asObjectRecord)(value);
 	if (!record) return {
 		value,
 		changed: false
@@ -23,7 +180,7 @@ function stripTimeoutSeconds(value) {
 	};
 }
 function normalizeCompatibilityConfig({ cfg }) {
-	const rawEntry = asObjectRecord(cfg.channels?.clickclack);
+	const rawEntry = (0, runtime_doctor_migrations_exports.asObjectRecord)(cfg.channels?.clickclack);
 	if (!rawEntry) return {
 		config: cfg,
 		changes: []

package/dist/index.js

@@ -1,4 +1,4 @@
-import { t as registerClickClackDiscussions } from "./.setup/runtime-api-A9r1b12d.mjs";
+import { t as registerClickClackDiscussions } from "./.setup/runtime-api-BvP8DrPQ.mjs";
 import { defineBundledChannelEntry } from "openclaw/plugin-sdk/channel-entry-contract";
 //#region extensions/clickclack/index.ts
 /**

package/dist/runtime-api.js

@@ -1,4 +1,5 @@
-import { b as resolveClickClackAccount, u as createClickClackClient } from "./.setup/setup-surface-BBl3rvVx.mjs";
-import { a as setClickClackRuntime, r as parseClickClackTarget } from "./.setup/channel-CT4CVd4d.mjs";
-import { t as registerClickClackDiscussions } from "./.setup/runtime-api-A9r1b12d.mjs";
+import { h as resolveClickClackAccount } from "./.setup/setup-surface-BW1Q06w5.mjs";
+import { a as setClickClackRuntime, r as parseClickClackTarget } from "./.setup/channel-Bcwtohk7.mjs";
+import { i as createClickClackClient } from "./.setup/resolve-BHGLohni.mjs";
+import { t as registerClickClackDiscussions } from "./.setup/runtime-api-BvP8DrPQ.mjs";
 export { createClickClackClient, parseClickClackTarget, registerClickClackDiscussions, resolveClickClackAccount, setClickClackRuntime };

package/dist/setup-entry.js

@@ -4,7 +4,7 @@ import { fileURLToPath } from "node:url";
 var setup_entry_default = defineBundledChannelSetupEntry({
 	importMetaUrl: import.meta.url,
 	plugin: {
-		specifier: fileURLToPath(new URL(".setup/setup-plugin-api-B19mjQvl.mjs", import.meta.url).href),
+		specifier: fileURLToPath(new URL(".setup/setup-plugin-api-BH_nw-AP.mjs", import.meta.url).href),
 		exportName: "clickClackSetupPlugin"
 	},
 	secrets: {

package/dist/setup-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as clickClackSetupPlugin } from "./.setup/setup-plugin-api-BUwBPYpy.mjs";
+import { t as clickClackSetupPlugin } from "./.setup/setup-plugin-api-C9QcBJuW.mjs";
 export { clickClackSetupPlugin };

package/openclaw.plugin.json

@@ -237,6 +237,9 @@
           "requireMention": {
             "type": "boolean"
           },
+          "requireMentionInBotThreads": {
+            "type": "boolean"
+          },
           "mentionPatterns": {
             "type": "array",
             "items": {
@@ -254,6 +257,9 @@
                 "requireMention": {
                   "type": "boolean"
                 },
+                "requireMentionInBotThreads": {
+                  "type": "boolean"
+                },
                 "mentionPatterns": {
                   "type": "array",
                   "items": {
@@ -548,6 +554,9 @@
                 "requireMention": {
                   "type": "boolean"
                 },
+                "requireMentionInBotThreads": {
+                  "type": "boolean"
+                },
                 "mentionPatterns": {
                   "type": "array",
                   "items": {
@@ -565,6 +574,9 @@
                       "requireMention": {
                         "type": "boolean"
                       },
+                      "requireMentionInBotThreads": {
+                        "type": "boolean"
+                      },
                       "mentionPatterns": {
                         "type": "array",
                         "items": {
@@ -640,7 +652,25 @@
         "additionalProperties": false
       },
       "label": "ClickClack",
-      "description": "ClickClack channel accounts and group activation policy."
+      "description": "ClickClack channel accounts and group activation policy.",
+      "uiHints": {
+        "requireMentionInBotThreads": {
+          "label": "Require Mention in Bot Threads",
+          "help": "Override mention requirements in threads rooted in this bot's messages. Unset keeps the normal mention policy."
+        },
+        "groups.*.requireMentionInBotThreads": {
+          "label": "Require Mention in Bot Threads",
+          "help": "Override the account policy for threads rooted in this bot's messages in this channel."
+        },
+        "accounts.*.requireMentionInBotThreads": {
+          "label": "Require Mention in Bot Threads",
+          "help": "Override mention requirements in threads rooted in this bot's messages. Unset inherits the channel configuration."
+        },
+        "accounts.*.groups.*.requireMentionInBotThreads": {
+          "label": "Require Mention in Bot Threads",
+          "help": "Override the account policy for threads rooted in this bot's messages in this channel."
+        }
+      }
     }
   },
   "contracts": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/clickclack",
-  "version": "2026.9.6",
+  "version": "2026.9.8",
   "description": "OpenClaw ClickClack channel plugin",
   "type": "module",
   "exports": {
@@ -13,7 +13,7 @@
     "zod": "4.6.5"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.9.6"
+    "openclaw": ">=2026.9.8"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -139,10 +139,10 @@
       "allowInvalidConfigRecovery": true
     },
     "compat": {
-      "pluginApi": ">=2026.9.6"
+      "pluginApi": ">=2026.9.8"
     },
     "build": {
-      "openclawVersion": "2026.9.6",
+      "openclawVersion": "2026.9.8",
       "bundledDist": false
     },
     "release": {

package/dist/.setup/setup-plugin-api-B19mjQvl.mjs

@@ -1,2 +0,0 @@
-import { t as clickClackSetupPlugin } from "./setup-plugin-api-BUwBPYpy.mjs";
-export { clickClackSetupPlugin };