@openclaw/clickclack 2026.9.6 → 2026.9.7

package/dist/.setup/resolve-BHGLohni.mjs

@@ -0,0 +1,336 @@
+import { createRequire } from "node:module";
+import { bufferToBlobPart } from "openclaw/plugin-sdk/blob-runtime";
+import { redactToolPayloadText } from "openclaw/plugin-sdk/logging-core";
+import { readProviderJsonResponse, readResponseTextLimited } from "openclaw/plugin-sdk/provider-http";
+import path from "node:path";
+//#region extensions/clickclack/src/ws-runtime.ts
+const require = createRequire(import.meta.url);
+const WebSocket = require(path.join(path.dirname(require.resolve("ws/package.json")), "index.js"));
+//#endregion
+//#region extensions/clickclack/src/http-client.ts
+/**
+* Thin ClickClack REST/websocket client used by gateway, resolver, and outbound
+* delivery code.
+*/
+/**
+* Serializes optional provenance into the wire fields. Unknown JSON fields
+* are ignored by servers without the provenance columns, so these are safe
+* to send unconditionally when present.
+*/
+function provenanceFields(provenance) {
+	const fields = {};
+	if (provenance?.model?.trim()) fields.author_model = provenance.model.trim();
+	if (provenance?.thinking?.trim()) fields.author_thinking = provenance.thinking.trim();
+	if (provenance?.runtime?.trim()) fields.author_runtime = provenance.runtime.trim();
+	return fields;
+}
+const CLICKCLACK_ERROR_BODY_LIMIT_BYTES = 8192;
+const CLICKCLACK_CORRELATION_ID_MAX_LENGTH = 128;
+const CLICKCLACK_CORRELATION_ID_PATTERN = /^[A-Za-z0-9._:-]+$/u;
+const CLICKCLACK_CORRELATION_ID_HEADER = "X-Correlation-ID";
+const CLICKCLACK_INBOUND_JSON_LIMIT_BYTES = 16777216;
+const CLICKCLACK_WEBSOCKET_HANDSHAKE_TIMEOUT_MS = 3e4;
+const CLICKCLACK_EPHEMERAL_REQUEST_TIMEOUT_MS = 15e3;
+const CLICKCLACK_MESSAGE_PAGE_LIMIT = 200;
+const CLICKCLACK_DISCUSSION_ROOT_PAGE_LIMIT = 8;
+const CLICKCLACK_DISCUSSION_THREAD_REQUEST_LIMIT = 24;
+function compareMessages(left, right) {
+	return left.created_at.localeCompare(right.created_at) || left.id.localeCompare(right.id);
+}
+function keepLatestMessages(messages, limit) {
+	return messages.toSorted(compareMessages).slice(-limit);
+}
+var ClickClackHttpError = class extends Error {
+	constructor(status, detail, headers) {
+		super(`ClickClack ${status}: ${detail}`);
+		this.status = status;
+		this.headers = headers;
+	}
+};
+/** Matches the workspace/name uniqueness error returned by current ClickClack servers. */
+function isClickClackChannelNameConflict(error) {
+	if (!(error instanceof ClickClackHttpError) || error.status !== 400 && error.status !== 409) return false;
+	const message = error.message.toLowerCase();
+	return (message.includes("unique") || message.includes("duplicate")) && message.includes("channel") && /workspace.*name|name.*workspace/u.test(message);
+}
+/** Accepts the same bounded request-correlation shape as the ClickClack API. */
+function normalizeClickClackCorrelationId(value) {
+	if (typeof value !== "string") return;
+	const normalized = value.trim();
+	if (!normalized || normalized.length > CLICKCLACK_CORRELATION_ID_MAX_LENGTH || !CLICKCLACK_CORRELATION_ID_PATTERN.test(normalized)) return;
+	return normalized;
+}
+/**
+* Creates a typed client for the ClickClack API using bearer-token auth.
+*/
+function createClickClackClient(options) {
+	const baseUrl = options.baseUrl.replace(/\/$/, "");
+	const fetcher = options.fetch ?? fetch;
+	const correlationId = normalizeClickClackCorrelationId(options.correlationId);
+	const headers = {
+		Authorization: `Bearer ${options.token}`,
+		Accept: "application/json"
+	};
+	async function request(path, init = {}, requestOptions = {}) {
+		const requestHeaders = new Headers(init.headers);
+		for (const [key, value] of Object.entries(headers)) requestHeaders.set(key, value);
+		if (correlationId) requestHeaders.set(CLICKCLACK_CORRELATION_ID_HEADER, correlationId);
+		if (init.body && !(init.body instanceof FormData)) requestHeaders.set("Content-Type", "application/json");
+		const controller = requestOptions.timeoutMs !== void 0 && !init.signal ? new AbortController() : void 0;
+		const timeout = controller ? setTimeout(() => controller.abort(), requestOptions.timeoutMs) : void 0;
+		try {
+			const response = await fetcher(`${baseUrl}${path}`, {
+				...init,
+				...controller ? { signal: controller.signal } : {},
+				headers: requestHeaders
+			});
+			if (!response.ok) {
+				const detail = await readResponseTextLimited(response, CLICKCLACK_ERROR_BODY_LIMIT_BYTES);
+				throw new ClickClackHttpError(response.status, redactToolPayloadText(detail), new Headers(response.headers));
+			}
+			if (requestOptions.responseMode === "none") {
+				try {
+					await response.body?.cancel();
+				} catch {}
+				return;
+			}
+			return await readProviderJsonResponse(response, "ClickClack response", { maxBytes: CLICKCLACK_INBOUND_JSON_LIMIT_BYTES });
+		} finally {
+			if (timeout) clearTimeout(timeout);
+		}
+	}
+	async function fetchEventPage(workspaceId, pageOptions = {}) {
+		const query = new URLSearchParams({ workspace_id: workspaceId });
+		if (pageOptions.afterCursor) query.set("after_cursor", pageOptions.afterCursor);
+		if (pageOptions.limit !== void 0) query.set("limit", String(pageOptions.limit));
+		if (pageOptions.includeTail) query.set("include_tail", "true");
+		const data = await request(`/api/realtime/events?${query.toString()}`);
+		return {
+			events: data.events,
+			...typeof data.tail_cursor === "string" ? { tailCursor: data.tail_cursor } : {}
+		};
+	}
+	async function createMessage(path, body, opts) {
+		return (await request(path, {
+			method: "POST",
+			body: JSON.stringify({
+				body,
+				...opts?.quotedMessageId ? { quoted_message_id: opts.quotedMessageId } : {},
+				...opts?.nonce ? { nonce: opts.nonce } : {},
+				...provenanceFields(opts?.provenance)
+			})
+		})).message;
+	}
+	async function findByNonce(kind, params) {
+		const query = new URLSearchParams({
+			workspace_id: params.workspaceId,
+			nonce: params.nonce
+		});
+		try {
+			return (await request(`/api/${kind}s/by-nonce?${query.toString()}`))[kind];
+		} catch (error) {
+			if (error instanceof ClickClackHttpError && error.status === 404) {
+				if (error.headers.get(`X-ClickClack-${kind}-Nonce`) === "supported") return;
+				throw new Error(`ClickClack server does not support durable ${kind} nonce lookup`, { cause: error });
+			}
+			throw error;
+		}
+	}
+	return {
+		me: async () => {
+			return (await request("/api/me")).user;
+		},
+		setBotCommands: async (commands) => {
+			return (await request("/api/bots/self/commands", {
+				method: "PUT",
+				body: JSON.stringify({ commands })
+			})).bot_commands;
+		},
+		workspaces: async () => {
+			return (await request("/api/workspaces")).workspaces;
+		},
+		channels: async (workspaceId) => {
+			return (await request(`/api/workspaces/${encodeURIComponent(workspaceId)}/channels`)).channels;
+		},
+		createChannel: async (workspaceId, channel) => {
+			return (await request(`/api/workspaces/${encodeURIComponent(workspaceId)}/channels`, {
+				method: "POST",
+				body: JSON.stringify(channel)
+			})).channel;
+		},
+		updateChannel: async (channelId, patch) => {
+			return (await request(`/api/channels/${encodeURIComponent(channelId)}`, {
+				method: "PATCH",
+				body: JSON.stringify(patch)
+			})).channel;
+		},
+		channelMessages: async (channelId, afterSeq, limit = 20) => {
+			return (await request(`/api/channels/${encodeURIComponent(channelId)}/messages?after_seq=${afterSeq}&limit=${limit}`)).messages;
+		},
+		latestChannelMessages: async (channelId, limit = 30) => {
+			const boundedLimit = Math.max(1, Math.min(CLICKCLACK_MESSAGE_PAGE_LIMIT, limit));
+			let beforeSeq;
+			let latest = [];
+			let rootPageCount = 0;
+			let threadRequestCount = 0;
+			let truncated = false;
+			while (true) {
+				rootPageCount += 1;
+				const query = new URLSearchParams({ limit: String(CLICKCLACK_MESSAGE_PAGE_LIMIT) });
+				if (beforeSeq !== void 0) query.set("before_seq", String(beforeSeq));
+				const page = await request(`/api/channels/${encodeURIComponent(channelId)}/messages?${query.toString()}`);
+				for (const root of page.messages) {
+					latest = keepLatestMessages([...latest, root], boundedLimit);
+					const lastReplyAt = root.thread_state?.last_reply_at;
+					const cutoff = latest.length === boundedLimit ? latest[0]?.created_at : void 0;
+					if (!root.thread_state?.reply_count || lastReplyAt !== void 0 && cutoff !== void 0 && lastReplyAt < cutoff) continue;
+					if (threadRequestCount >= CLICKCLACK_DISCUSSION_THREAD_REQUEST_LIMIT) {
+						truncated = true;
+						continue;
+					}
+					threadRequestCount += 1;
+					const threadQuery = new URLSearchParams({ limit: String(CLICKCLACK_MESSAGE_PAGE_LIMIT) });
+					const thread = await request(`/api/messages/${encodeURIComponent(root.id)}/thread?${threadQuery.toString()}`);
+					if (thread.replies.length < root.thread_state.reply_count) {
+						truncated = true;
+						continue;
+					}
+					latest = keepLatestMessages([...latest, ...thread.replies], boundedLimit);
+				}
+				if (!page.has_older) return {
+					messages: latest,
+					truncated
+				};
+				if (rootPageCount >= CLICKCLACK_DISCUSSION_ROOT_PAGE_LIMIT) return {
+					messages: latest,
+					truncated: true
+				};
+				if (page.messages.length === 0 || !Number.isSafeInteger(page.oldest_seq) || page.oldest_seq < 0 || page.oldest_seq === beforeSeq) throw new Error("ClickClack message pagination did not advance");
+				beforeSeq = page.oldest_seq;
+			}
+		},
+		directMessages: async (conversationId, afterSeq, limit = 20) => {
+			return (await request(`/api/dms/${encodeURIComponent(conversationId)}/messages?after_seq=${afterSeq}&limit=${limit}`)).messages;
+		},
+		thread: async (messageId) => await request(`/api/messages/${encodeURIComponent(messageId)}/thread`),
+		message: async (messageId) => {
+			return (await request(`/api/messages/${encodeURIComponent(messageId)}`)).message;
+		},
+		findMessageByNonce: async (params) => findByNonce("message", params),
+		createChannelMessage: async (channelId, body, opts) => createMessage(`/api/channels/${encodeURIComponent(channelId)}/messages`, body, opts),
+		createThreadReply: async (messageId, body, opts) => createMessage(`/api/messages/${encodeURIComponent(messageId)}/thread/replies`, body, {
+			nonce: opts?.nonce,
+			provenance: opts?.provenance
+		}),
+		createDirectConversation: async (workspaceId, memberIds) => {
+			return (await request("/api/dms", {
+				method: "POST",
+				body: JSON.stringify({
+					workspace_id: workspaceId,
+					member_ids: memberIds
+				})
+			})).conversation;
+		},
+		createUpload: async (params) => {
+			const form = new FormData();
+			const bytes = bufferToBlobPart(params.buffer);
+			form.append("file", new Blob([bytes], { type: params.contentType }), params.filename);
+			const query = new URLSearchParams({ workspace_id: params.workspaceId });
+			if (params.nonce) query.set("nonce", params.nonce);
+			return (await request(`/api/uploads?${query.toString()}`, {
+				method: "POST",
+				body: form
+			})).upload;
+		},
+		findUploadByNonce: async (params) => findByNonce("upload", params),
+		attachUpload: async (messageId, uploadId) => {
+			await request(`/api/messages/${encodeURIComponent(messageId)}/attachments`, {
+				method: "POST",
+				body: JSON.stringify({ upload_id: uploadId })
+			});
+		},
+		/**
+		* POSTs a durable agent activity row (agent_commentary / agent_tool)
+		* through the normal message create path. Requires a bot token carrying
+		* the agent_activity:write scope on the ClickClack side.
+		*/
+		createActivityMessage: async (params) => {
+			if (!params.channelId && !params.conversationId) throw new Error("createActivityMessage requires a channelId or conversationId");
+			return (await request(params.channelId ? `/api/channels/${encodeURIComponent(params.channelId)}/messages` : `/api/dms/${encodeURIComponent(params.conversationId ?? "")}/messages`, {
+				method: "POST",
+				body: JSON.stringify({
+					body: params.body,
+					kind: params.kind,
+					turn_id: params.turnId,
+					...provenanceFields(params.provenance)
+				})
+			})).message;
+		},
+		/** PATCHes the body of an existing message (activity row coalescing). */
+		updateMessageBody: async (messageId, body) => {
+			return (await request(`/api/messages/${encodeURIComponent(messageId)}`, {
+				method: "PATCH",
+				body: JSON.stringify({ body })
+			})).message;
+		},
+		/**
+		* Publishes an ephemeral realtime signal such as native agent progress.
+		* These frames are intentionally not persisted as messages.
+		*/
+		publishEphemeral: async (params) => {
+			await request("/api/realtime/ephemeral", {
+				method: "POST",
+				body: JSON.stringify({
+					workspace_id: params.workspaceId,
+					...params.channelId ? { channel_id: params.channelId } : {},
+					...params.conversationId ? { direct_conversation_id: params.conversationId } : {},
+					type: params.type,
+					payload: params.payload ?? {}
+				})
+			}, {
+				timeoutMs: CLICKCLACK_EPHEMERAL_REQUEST_TIMEOUT_MS,
+				responseMode: "none"
+			});
+		},
+		createDirectMessage: async (conversationId, body, opts) => createMessage(`/api/dms/${encodeURIComponent(conversationId)}/messages`, body, {
+			quotedMessageId: opts?.quotedMessageId,
+			nonce: opts?.nonce
+		}),
+		events: async (workspaceId, afterCursor) => (await fetchEventPage(workspaceId, { afterCursor })).events,
+		eventPage: fetchEventPage,
+		websocket: (workspaceId, afterCursor) => {
+			const url = new URL(`${baseUrl}/api/realtime/ws`);
+			url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+			url.searchParams.set("workspace_id", workspaceId);
+			if (afterCursor) url.searchParams.set("after_cursor", afterCursor);
+			return new WebSocket(url, {
+				headers: { Authorization: `Bearer ${options.token}` },
+				handshakeTimeout: CLICKCLACK_WEBSOCKET_HANDSHAKE_TIMEOUT_MS,
+				maxPayload: CLICKCLACK_INBOUND_JSON_LIMIT_BYTES
+			});
+		}
+	};
+}
+//#endregion
+//#region extensions/clickclack/src/resolve.ts
+/**
+* Resolves a workspace slug/name/id from config to a ClickClack workspace id.
+*/
+async function resolveWorkspaceId(client, workspace) {
+	if (workspace.startsWith("wsp_")) return workspace;
+	const found = (await client.workspaces()).find((candidate) => candidate.id === workspace || candidate.slug === workspace || candidate.name === workspace);
+	if (!found) throw new Error(`ClickClack workspace not found: ${workspace}`);
+	return found.id;
+}
+/**
+* Resolves a channel name/id from config or target input to a ClickClack
+* channel id.
+*/
+async function resolveChannelId(client, workspaceId, channel) {
+	if (channel.startsWith("chn_")) return channel;
+	const found = (await client.channels(workspaceId)).find((candidate) => candidate.id === channel || candidate.name === channel);
+	if (!found) throw new Error(`ClickClack channel not found: ${channel}`);
+	return found.id;
+}
+//#endregion
+export { isClickClackChannelNameConflict as a, createClickClackClient as i, resolveWorkspaceId as n, normalizeClickClackCorrelationId as o, ClickClackHttpError as r, resolveChannelId as t };

package/dist/.setup/rolldown-runtime-B4FMCO8f.mjs

@@ -0,0 +1,28 @@
+import "node:module";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+//#endregion
+export { __reExport as n, __exportAll as t };

package/dist/.setup/{runtime-api-A9r1b12d.mjs → runtime-api-BvP8DrPQ.mjs}

@@ -1,5 +1,6 @@
-import { b as resolveClickClackAccount, d as isClickClackChannelNameConflict, l as ClickClackHttpError, u as createClickClackClient, v as listClickClackAccountIds } from "./setup-surface-BBl3rvVx.mjs";
-import { C as slugifyDiscussionLabel, D as listPendingDiscussionOpens, E as clearPendingDiscussionOpen, O as recordPendingDiscussionOpen, S as resolveDiscussionLabel, T as clearDiscussionBindingGeneration, _ as getClickClackDiscussionBindingStore, b as fallbackDiscussionLabel, c as markClickClackDiscussionChannelIdentityRevoked, d as discussionInfoForBinding, f as normalizedServerBaseUrl, g as bindingMatchesActiveSessionIncarnation, h as attachBindingToCurrentActiveSession, k as reserveDiscussionBindingGeneration, l as markClickClackDiscussionChannelRevoked, o as clearClickClackDiscussionChannelRevoked, p as resolveDiscussionBindingAccount, s as isClickClackDiscussionChannelRevoked, u as discussionAccounts, v as discussionCredentialFingerprint, w as truncateDiscussionDisplayTitle, x as isDiscussionSessionKey, y as discussionExternalRef } from "./channel-CT4CVd4d.mjs";
+import { h as resolveClickClackAccount, p as listClickClackAccountIds } from "./setup-surface-BW1Q06w5.mjs";
+import { C as slugifyDiscussionLabel, D as listPendingDiscussionOpens, E as clearPendingDiscussionOpen, O as recordPendingDiscussionOpen, S as resolveDiscussionLabel, T as clearDiscussionBindingGeneration, _ as getClickClackDiscussionBindingStore, b as fallbackDiscussionLabel, c as markClickClackDiscussionChannelIdentityRevoked, d as discussionInfoForBinding, f as normalizedServerBaseUrl, g as bindingMatchesActiveSessionIncarnation, h as attachBindingToCurrentActiveSession, k as reserveDiscussionBindingGeneration, l as markClickClackDiscussionChannelRevoked, o as clearClickClackDiscussionChannelRevoked, p as resolveDiscussionBindingAccount, s as isClickClackDiscussionChannelRevoked, u as discussionAccounts, v as discussionCredentialFingerprint, w as truncateDiscussionDisplayTitle, x as isDiscussionSessionKey, y as discussionExternalRef } from "./channel-Bcwtohk7.mjs";
+import { a as isClickClackChannelNameConflict, i as createClickClackClient, r as ClickClackHttpError } from "./resolve-BHGLohni.mjs";
 import "../api.js";
 import { randomUUID } from "node:crypto";
 import { buildControlUiSessionPath, registerSessionDiscussionProvider } from "openclaw/plugin-sdk/session-discussion";
@@ -1073,9 +1074,11 @@ function registerClickClackDiscussions(api) {
 	api.lifecycle.registerRuntimeLifecycle({
 		id: "clickclack-discussions",
 		description: "Stops the lifecycle reconciler for managed ClickClack discussions.",
-		cleanup: () => {
-			unregisterSessionAccess();
-			return service.cleanup();
+		cleanup: ({ reason, sessionKey, runId }) => {
+			if (sessionKey === void 0 && runId === void 0 && (reason === "restart" || reason === "disable")) {
+				unregisterSessionAccess();
+				return service.cleanup();
+			}
 		}
 	});
 }

package/dist/.setup/{setup-claim-t5SbtvZy.mjs → setup-claim-Cx8knvXs.mjs}

@@ -1,4 +1,4 @@
-import { a as isClickClackSetupLoopbackHost, i as buildClickClackSetupClaimUrl, o as requireClickClackSetupApiBaseUrl } from "./setup-surface-BBl3rvVx.mjs";
+import { a as isClickClackSetupLoopbackHost, i as buildClickClackSetupClaimUrl, o as requireClickClackSetupApiBaseUrl } from "./setup-surface-BW1Q06w5.mjs";
 import { withTimeout } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createProviderOperationDeadline, readProviderJsonResponse, readResponseTextLimited, resolveProviderOperationTimeoutMs } from "openclaw/plugin-sdk/provider-http";
 import { fetchWithSsrFGuard, resolvePinnedHostnameWithPolicy, ssrfPolicyFromHttpBaseUrlAllowedHostname } from "openclaw/plugin-sdk/ssrf-runtime";

package/dist/.setup/setup-plugin-api-BH_nw-AP.mjs

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

package/dist/.setup/{setup-plugin-api-BUwBPYpy.mjs → setup-plugin-api-C9QcBJuW.mjs}

@@ -1,4 +1,4 @@
-import { g as clickClackMeta, h as clickClackConfigAdapter, n as clickClackSetupContract, p as clickClackConfigSchema, t as clickClackSetupWizard } from "./setup-surface-BBl3rvVx.mjs";
+import { l as clickClackConfigAdapter, n as clickClackSetupContract, s as clickClackConfigSchema, t as clickClackSetupWizard, u as clickClackMeta } from "./setup-surface-BW1Q06w5.mjs";
 //#region extensions/clickclack/src/channel.setup.ts
 const clickClackSetupPlugin = {
 	id: "clickclack",