@openclaw/clickclack 2026.7.2-beta.1 → 2026.7.2-beta.2

package/dist/setup-surface-B346XaAu.js

@@ -0,0 +1,828 @@
+import { createAccountListHelpers, hasConfiguredAccountValue } from "openclaw/plugin-sdk/account-helpers";
+import { DEFAULT_ACCOUNT_ID, DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$2, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import { resolveMergedAccountConfig } from "openclaw/plugin-sdk/account-resolution";
+import { resolveNormalizedAccountEntry } from "openclaw/plugin-sdk/account-resolution-runtime";
+import { resolveIntegerOption } from "openclaw/plugin-sdk/number-runtime";
+import { resolveDefaultSecretProviderAlias } from "openclaw/plugin-sdk/provider-auth";
+import { tryReadSecretFileSync } from "openclaw/plugin-sdk/secret-file-runtime";
+import { buildSecretInputSchema, normalizeResolvedSecretInputString, normalizeSecretInputString, resolveSecretInputString } from "openclaw/plugin-sdk/secret-input";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { getChatChannelMeta } from "openclaw/plugin-sdk/channel-plugin-common";
+import { buildChannelConfigSchema, buildMultiAccountChannelSchema } from "openclaw/plugin-sdk/channel-config-schema";
+import { z } from "zod";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { readProviderJsonResponse, readResponseTextLimited } from "openclaw/plugin-sdk/provider-http";
+import { WebSocket } from "ws";
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, applyAccountNameToChannelSection, applySetupAccountConfigPatch, baseUrlTextInput, createSetupTranslator, createStandardChannelSetupStatus, defineTokenCredential, formatDocsLink, hasConfiguredSecretInput, migrateBaseNameToDefaultAccount, moveSingleAccountChannelSectionToDefaultAccount, setSetupChannelEnabled } from "openclaw/plugin-sdk/setup";
+import { createSetupInputPresenceValidator } from "openclaw/plugin-sdk/setup-runtime";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+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;
+};
+//#endregion
+//#region extensions/clickclack/src/accounts.ts
+/**
+* Resolves ClickClack account configuration from root channel config, named
+* account overrides, and secret-provider references.
+*/
+const DEFAULT_RECONNECT_MS = 1500;
+const MIN_RECONNECT_MS = 100;
+const MAX_RECONNECT_MS = 6e4;
+const { listAccountIds: listClickClackAccountIds, resolveDefaultAccountId: resolveDefaultClickClackAccountId } = createAccountListHelpers("clickclack", {
+	normalizeAccountId,
+	hasImplicitDefaultAccount: (cfg) => {
+		const channel = cfg.channels?.clickclack;
+		return Boolean(channel?.baseUrl?.trim() && (hasConfiguredAccountValue(channel.token) || Boolean(channel.tokenFile?.trim()) || Boolean(process.env.CLICKCLACK_BOT_TOKEN?.trim())) && channel.workspace?.trim());
+	}
+});
+function resolveClickClackAccountConfig(cfg, accountId) {
+	const channel = cfg.channels?.clickclack;
+	const merged = resolveMergedAccountConfig({
+		channelConfig: cfg.channels?.clickclack,
+		accounts: channel?.accounts,
+		accountId,
+		omitKeys: ["defaultAccount"],
+		normalizeAccountId
+	});
+	const account = resolveNormalizedAccountEntry(channel?.accounts, accountId, normalizeAccountId);
+	const accountTokenFile = account?.tokenFile?.trim();
+	if (accountTokenFile) return {
+		...merged,
+		token: account?.token,
+		tokenFile: accountTokenFile
+	};
+	if (hasConfiguredAccountValue(account?.token)) return {
+		...merged,
+		token: account?.token,
+		tokenFile: void 0
+	};
+	return merged;
+}
+function resolveClickClackToken(params) {
+	const tokenFile = params.tokenFile?.trim();
+	if (tokenFile) return tryReadSecretFileSync(tokenFile, params.accountId === DEFAULT_ACCOUNT_ID$2 ? "channels.clickclack.tokenFile" : `channels.clickclack.accounts.${params.accountId}.tokenFile`, { rejectSymlink: true }) ?? "";
+	const resolved = resolveSecretInputString({
+		value: params.value,
+		path: params.accountId === DEFAULT_ACCOUNT_ID$2 ? "channels.clickclack.token" : `channels.clickclack.accounts.${params.accountId}.token`,
+		defaults: params.cfg.secrets?.defaults,
+		mode: "inspect"
+	});
+	if (resolved.status !== "available") {
+		if (resolved.status === "missing" && params.accountId === DEFAULT_ACCOUNT_ID$2) return normalizeSecretInputString((params.env ?? process.env).CLICKCLACK_BOT_TOKEN) ?? "";
+		if (resolved.status === "configured_unavailable" && resolved.ref.source === "env") {
+			const providerConfig = params.cfg.secrets?.providers?.[resolved.ref.provider];
+			if (providerConfig) {
+				if (providerConfig.source !== "env") throw new Error(`Secret provider "${resolved.ref.provider}" has source "${providerConfig.source}" but ref requests "env".`);
+				if (providerConfig.allowlist && !providerConfig.allowlist.includes(resolved.ref.id)) throw new Error(`Environment variable "${resolved.ref.id}" is not allowlisted in secrets.providers.${resolved.ref.provider}.allowlist.`);
+			} else if (resolved.ref.provider !== resolveDefaultSecretProviderAlias({ secrets: params.cfg.secrets }, "env")) throw new Error(`Secret provider "${resolved.ref.provider}" is not configured (ref: env:${resolved.ref.provider}:${resolved.ref.id}).`);
+			return normalizeSecretInputString((params.env ?? process.env)[resolved.ref.id]) ?? "";
+		}
+		return "";
+	}
+	return normalizeResolvedSecretInputString({
+		value: resolved.value,
+		path: "channels.clickclack.token"
+	}) ?? "";
+}
+/**
+* Builds the normalized account snapshot used by gateway, outbound delivery,
+* status reporting, and channel routing.
+*/
+function resolveClickClackAccount(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	const merged = resolveClickClackAccountConfig(params.cfg, accountId);
+	const enabled = params.cfg.channels?.clickclack?.enabled !== false && merged.enabled !== false;
+	const baseUrl = merged.baseUrl?.trim().replace(/\/$/, "") ?? "";
+	const token = resolveClickClackToken({
+		cfg: params.cfg,
+		value: merged.token,
+		tokenFile: merged.tokenFile,
+		accountId,
+		env: params.env
+	});
+	const workspace = merged.workspace?.trim() ?? "";
+	return {
+		accountId,
+		enabled,
+		configured: Boolean(baseUrl && token && workspace),
+		name: normalizeOptionalString(merged.name),
+		baseUrl,
+		token,
+		workspace,
+		botUserId: normalizeOptionalString(merged.botUserId),
+		agentId: normalizeOptionalString(merged.agentId),
+		replyMode: merged.replyMode === "model" ? "model" : "agent",
+		model: normalizeOptionalString(merged.model),
+		systemPrompt: normalizeOptionalString(merged.systemPrompt),
+		timeoutSeconds: merged.timeoutSeconds,
+		toolsAllow: merged.toolsAllow,
+		defaultTo: merged.defaultTo?.trim() || "channel:general",
+		allowFrom: merged.allowFrom ?? ["*"],
+		reconnectMs: resolveIntegerOption(merged.reconnectMs, DEFAULT_RECONNECT_MS, {
+			min: MIN_RECONNECT_MS,
+			max: MAX_RECONNECT_MS
+		}),
+		agentActivity: merged.agentActivity === true,
+		commandMenu: merged.commandMenu !== false,
+		config: {
+			...merged,
+			allowFrom: merged.allowFrom ?? ["*"]
+		}
+	};
+}
+/**
+* Returns all enabled accounts, including the implicit default account when
+* legacy top-level ClickClack config is present.
+*/
+function listEnabledClickClackAccounts(cfg) {
+	return listClickClackAccountIds(cfg).map((accountId) => resolveClickClackAccount({
+		cfg,
+		accountId
+	})).filter((account) => account.enabled);
+}
+//#endregion
+//#region extensions/clickclack/src/channel-config.ts
+const CLICKCLACK_CHANNEL_ID = "clickclack";
+const clickClackMeta = { ...getChatChannelMeta(CLICKCLACK_CHANNEL_ID) };
+const clickClackConfigAdapter = {
+	listAccountIds: (cfg) => listClickClackAccountIds(cfg),
+	resolveAccount: (cfg, accountId) => resolveClickClackAccount({
+		cfg,
+		accountId
+	}),
+	defaultAccountId: (cfg) => resolveDefaultClickClackAccountId(cfg),
+	isConfigured: (account) => account.configured,
+	resolveAllowFrom: ({ cfg, accountId }) => resolveClickClackAccount({
+		cfg,
+		accountId
+	}).allowFrom,
+	resolveDefaultTo: ({ cfg, accountId }) => resolveClickClackAccount({
+		cfg,
+		accountId
+	}).defaultTo
+};
+//#endregion
+//#region extensions/clickclack/src/config-schema.ts
+/**
+* Zod-backed config schema for ClickClack channel accounts.
+*/
+const ClickClackAccountConfigSchema = z.object({
+	name: z.string().optional(),
+	enabled: z.boolean().optional(),
+	baseUrl: z.string().url().optional(),
+	token: buildSecretInputSchema().optional(),
+	tokenFile: z.string().optional(),
+	workspace: z.string().optional(),
+	botUserId: z.string().optional(),
+	agentId: z.string().optional(),
+	replyMode: z.enum(["agent", "model"]).optional(),
+	model: z.string().optional(),
+	systemPrompt: z.string().optional(),
+	timeoutSeconds: z.number().int().min(1).max(3600).optional(),
+	toolsAllow: z.array(z.string()).optional(),
+	defaultTo: z.string().optional(),
+	allowFrom: z.array(z.string()).optional(),
+	reconnectMs: z.number().int().min(100).max(6e4).optional(),
+	agentActivity: z.boolean().optional(),
+	commandMenu: z.boolean().optional()
+}).strict();
+/**
+* Config schema exported to core so `openclaw doctor` and config validation
+* understand both default and named ClickClack accounts.
+*/
+const clickClackConfigSchema = buildChannelConfigSchema(buildMultiAccountChannelSchema(ClickClackAccountConfigSchema, { accountSchema: ClickClackAccountConfigSchema.partial() }));
+//#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 = 8 * 1024;
+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 = 16 * 1024 * 1024;
+const CLICKCLACK_WEBSOCKET_HANDSHAKE_TIMEOUT_MS = 3e4;
+var ClickClackHttpError = class extends Error {
+	constructor(status, detail, headers) {
+		super(`ClickClack ${status}: ${detail}`);
+		this.status = status;
+		this.headers = headers;
+	}
+};
+/** 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 = {}) {
+		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 response = await fetcher(`${baseUrl}${path}`, {
+			...init,
+			headers: requestHeaders
+		});
+		if (!response.ok) {
+			const detail = await readResponseTextLimited(response, CLICKCLACK_ERROR_BODY_LIMIT_BYTES);
+			throw new ClickClackHttpError(response.status, detail, new Headers(response.headers));
+		}
+		return await readProviderJsonResponse(response, "ClickClack response", { maxBytes: CLICKCLACK_INBOUND_JSON_LIMIT_BYTES });
+	}
+	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 } : {}
+		};
+	}
+	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;
+		},
+		channelMessages: async (channelId, afterSeq, limit = 20) => {
+			return (await request(`/api/channels/${encodeURIComponent(channelId)}/messages?after_seq=${afterSeq}&limit=${limit}`)).messages;
+		},
+		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) => {
+			const query = new URLSearchParams({
+				workspace_id: params.workspaceId,
+				nonce: params.nonce
+			});
+			try {
+				return (await request(`/api/messages/by-nonce?${query.toString()}`)).message;
+			} catch (error) {
+				if (error instanceof ClickClackHttpError && error.status === 404) {
+					if (error.headers.get("X-ClickClack-Message-Nonce") === "supported") return;
+					throw new Error("ClickClack server does not support durable message nonce lookup", { cause: error });
+				}
+				throw error;
+			}
+		},
+		createChannelMessage: async (channelId, body, opts) => {
+			return (await request(`/api/channels/${encodeURIComponent(channelId)}/messages`, {
+				method: "POST",
+				body: JSON.stringify({
+					body,
+					...opts?.quotedMessageId ? { quoted_message_id: opts.quotedMessageId } : {},
+					...opts?.nonce ? { nonce: opts.nonce } : {},
+					...provenanceFields(opts?.provenance)
+				})
+			})).message;
+		},
+		createThreadReply: async (messageId, body, opts) => {
+			return (await request(`/api/messages/${encodeURIComponent(messageId)}/thread/replies`, {
+				method: "POST",
+				body: JSON.stringify({
+					body,
+					...opts?.nonce ? { nonce: opts.nonce } : {},
+					...provenanceFields(opts?.provenance)
+				})
+			})).message;
+		},
+		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 = new Uint8Array(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) => {
+			const query = new URLSearchParams({
+				workspace_id: params.workspaceId,
+				nonce: params.nonce
+			});
+			try {
+				return (await request(`/api/uploads/by-nonce?${query.toString()}`)).upload;
+			} catch (error) {
+				if (error instanceof ClickClackHttpError && error.status === 404) {
+					if (error.headers.get("X-ClickClack-Upload-Nonce") === "supported") return;
+					throw new Error("ClickClack server does not support durable upload nonce lookup", { cause: error });
+				}
+				throw error;
+			}
+		},
+		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;
+		},
+		createDirectMessage: async (conversationId, body, opts) => {
+			return (await request(`/api/dms/${encodeURIComponent(conversationId)}/messages`, {
+				method: "POST",
+				body: JSON.stringify({
+					body,
+					...opts?.quotedMessageId ? { quoted_message_id: opts.quotedMessageId } : {},
+					...opts?.nonce ? { nonce: opts.nonce } : {}
+				})
+			})).message;
+		},
+		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
+//#region extensions/clickclack/src/setup-core.ts
+const channel$1 = "clickclack";
+const REQUIRED_INPUT_ERROR = "ClickClack requires --token, --base-url, and --workspace (or --use-env).";
+const INVALID_BASE_URL_ERROR = "ClickClack base URL must be a valid http(s) URL.";
+function normalizeClickClackBaseUrl(value) {
+	const trimmed = value?.trim();
+	if (!trimmed) return;
+	try {
+		const parsed = new URL(trimmed);
+		if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return;
+		return parsed.toString().replace(/\/+$/, "");
+	} catch {
+		return;
+	}
+}
+function applyClickClackSetupConfigPatch(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	const namedConfig = applyAccountNameToChannelSection({
+		cfg: accountId === DEFAULT_ACCOUNT_ID ? params.cfg : moveSingleAccountChannelSectionToDefaultAccount({
+			cfg: params.cfg,
+			channelKey: channel$1
+		}),
+		channelKey: channel$1,
+		accountId,
+		name: params.name
+	});
+	return applySetupAccountConfigPatch({
+		cfg: accountId !== DEFAULT_ACCOUNT_ID ? migrateBaseNameToDefaultAccount({
+			cfg: namedConfig,
+			channelKey: channel$1
+		}) : namedConfig,
+		channelKey: channel$1,
+		accountId,
+		patch: params.patch
+	});
+}
+function clearClickClackSetupConfigFields(params) {
+	const clickclack = params.cfg.channels?.clickclack;
+	if (!clickclack) return params.cfg;
+	const accountId = normalizeAccountId(params.accountId);
+	if (accountId === DEFAULT_ACCOUNT_ID) {
+		const nextClickClack = { ...clickclack };
+		for (const field of params.fields) delete nextClickClack[field];
+		return {
+			...params.cfg,
+			channels: {
+				...params.cfg.channels,
+				clickclack: nextClickClack
+			}
+		};
+	}
+	const currentAccount = clickclack.accounts?.[accountId];
+	if (!currentAccount) return params.cfg;
+	const nextAccount = { ...currentAccount };
+	for (const field of params.fields) delete nextAccount[field];
+	return {
+		...params.cfg,
+		channels: {
+			...params.cfg.channels,
+			clickclack: {
+				...clickclack,
+				accounts: {
+					...clickclack.accounts,
+					[accountId]: nextAccount
+				}
+			}
+		}
+	};
+}
+function applyClickClackCredentialConfig(params) {
+	const fieldsToClear = params.useEnv ? ["token", "tokenFile"] : params.tokenFile ? ["token"] : params.token !== void 0 ? ["tokenFile"] : [];
+	return clearClickClackSetupConfigFields({
+		cfg: applyClickClackSetupConfigPatch({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			patch: params.useEnv ? {} : params.tokenFile ? { tokenFile: params.tokenFile } : params.token !== void 0 ? { token: params.token } : {}
+		}),
+		accountId: params.accountId,
+		fields: fieldsToClear
+	});
+}
+const clickClackSetupAdapter = {
+	resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
+	applyAccountName: ({ cfg, accountId, name }) => applyAccountNameToChannelSection({
+		cfg,
+		channelKey: channel$1,
+		accountId,
+		name
+	}),
+	validateInput: createSetupInputPresenceValidator({
+		defaultAccountOnlyEnvError: "CLICKCLACK_BOT_TOKEN can only be used for the default account.",
+		whenNotUseEnv: [
+			{
+				someOf: ["token", "tokenFile"],
+				message: REQUIRED_INPUT_ERROR
+			},
+			{
+				someOf: ["baseUrl"],
+				message: REQUIRED_INPUT_ERROR
+			},
+			{
+				someOf: ["workspace"],
+				message: REQUIRED_INPUT_ERROR
+			}
+		],
+		validate: ({ cfg, accountId, input }) => {
+			const baseUrl = normalizeClickClackBaseUrl(input.baseUrl);
+			if (input.baseUrl && !baseUrl) return INVALID_BASE_URL_ERROR;
+			if (!input.useEnv) return null;
+			const existing = resolveClickClackAccountConfig(cfg, accountId);
+			const existingBaseUrl = normalizeClickClackBaseUrl(existing.baseUrl);
+			if (!baseUrl && existing.baseUrl?.trim() && !existingBaseUrl) return INVALID_BASE_URL_ERROR;
+			if (!baseUrl && !existingBaseUrl) return REQUIRED_INPUT_ERROR;
+			if (!input.workspace?.trim() && !existing.workspace?.trim()) return REQUIRED_INPUT_ERROR;
+			return null;
+		}
+	}),
+	applyAccountConfig: ({ cfg, accountId, input }) => {
+		const existing = input.useEnv ? resolveClickClackAccountConfig(cfg, accountId) : void 0;
+		const baseUrl = normalizeClickClackBaseUrl(input.baseUrl ?? existing?.baseUrl);
+		const workspace = input.workspace?.trim() || existing?.workspace?.trim();
+		const tokenFile = input.tokenFile?.trim();
+		const token = input.token?.trim();
+		return applyClickClackCredentialConfig({
+			cfg: applyClickClackSetupConfigPatch({
+				cfg,
+				accountId,
+				name: input.name,
+				patch: {
+					...baseUrl ? { baseUrl } : {},
+					...workspace ? { workspace } : {}
+				}
+			}),
+			accountId,
+			token,
+			tokenFile,
+			useEnv: input.useEnv
+		});
+	},
+	afterAccountConfigWritten: async ({ cfg, accountId, runtime }) => {
+		const { verifyClickClackAccountAfterSetup } = await Promise.resolve().then(() => setup_verify_exports);
+		await verifyClickClackAccountAfterSetup({
+			cfg,
+			accountId,
+			runtime
+		});
+	}
+};
+//#endregion
+//#region extensions/clickclack/src/setup-verify.ts
+var setup_verify_exports = /* @__PURE__ */ __exportAll({
+	checkClickClackSetupConnection: () => checkClickClackSetupConnection,
+	verifyClickClackAccountAfterSetup: () => verifyClickClackAccountAfterSetup
+});
+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.baseUrl,
+			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
+//#region extensions/clickclack/src/setup-surface.ts
+const t = createSetupTranslator();
+const channel = "clickclack";
+function hasConfiguredClickClackCredential(account) {
+	return hasConfiguredSecretInput(account.config.token) || Boolean(account.config.tokenFile?.trim());
+}
+function isClickClackSetupConfigured(account) {
+	return Boolean(account.baseUrl && account.workspace && (account.token || hasConfiguredClickClackCredential(account)));
+}
+const clickClackSetupWizard = {
+	channel,
+	status: createStandardChannelSetupStatus({
+		channelLabel: "ClickClack",
+		configuredLabel: t("wizard.channels.statusConfigured"),
+		unconfiguredLabel: t("wizard.channels.statusNeedsSetup"),
+		configuredHint: t("wizard.channels.statusSelfHostedChat"),
+		unconfiguredHint: t("wizard.channels.statusNeedsSetup"),
+		configuredScore: 2,
+		unconfiguredScore: 1,
+		resolveConfigured: ({ cfg, accountId }) => (accountId ? [accountId] : listClickClackAccountIds(cfg)).some((resolvedAccountId) => isClickClackSetupConfigured(resolveClickClackAccount({
+			cfg,
+			accountId: resolvedAccountId
+		})))
+	}),
+	introNote: {
+		title: t("wizard.clickclack.botTokenTitle"),
+		lines: [t("wizard.clickclack.helpCreateToken"), t("wizard.channels.docs", { link: formatDocsLink("/channels/clickclack", "clickclack") })],
+		shouldShow: ({ cfg, accountId }) => !isClickClackSetupConfigured(resolveClickClackAccount({
+			cfg,
+			accountId
+		}))
+	},
+	credentials: [defineTokenCredential({
+		inputKey: "token",
+		configKey: "token",
+		configuredFields: ["token", "tokenFile"],
+		providerHint: channel,
+		credentialLabel: t("wizard.clickclack.botToken"),
+		preferredEnvVar: "CLICKCLACK_BOT_TOKEN",
+		envPrompt: t("wizard.clickclack.envPrompt"),
+		keepPrompt: t("wizard.clickclack.botTokenKeep"),
+		inputPrompt: t("wizard.clickclack.botTokenInput"),
+		allowEnv: ({ accountId }) => accountId === DEFAULT_ACCOUNT_ID$1,
+		resolveAccount: ({ cfg, accountId }) => resolveClickClackAccount({
+			cfg,
+			accountId
+		}),
+		hasConfiguredValue: hasConfiguredClickClackCredential,
+		resolvedValue: (account) => account.token || void 0,
+		envValue: ({ accountId }) => accountId === DEFAULT_ACCOUNT_ID$1 ? process.env.CLICKCLACK_BOT_TOKEN?.trim() || void 0 : void 0,
+		patchAccount: ({ cfg, accountId, mode, patch }) => mode === "env" ? applyClickClackCredentialConfig({
+			cfg,
+			accountId,
+			useEnv: true
+		}) : applyClickClackCredentialConfig({
+			cfg,
+			accountId,
+			...patch
+		}),
+		useEnv: { clearFields: ["token", "tokenFile"] },
+		set: { clearFields: ["tokenFile"] }
+	})],
+	textInputs: [baseUrlTextInput({
+		inputKey: "baseUrl",
+		configKey: "baseUrl",
+		message: t("wizard.clickclack.baseUrlPrompt"),
+		resolveAccount: ({ cfg, accountId }) => resolveClickClackAccount({
+			cfg,
+			accountId
+		}),
+		currentValue: (account) => account.baseUrl || void 0,
+		includeInitialValue: true,
+		validate: (value) => normalizeClickClackBaseUrl(value) ? void 0 : "ClickClack server URL must be a valid http(s) URL.",
+		normalize: (value) => normalizeClickClackBaseUrl(value) ?? value.trim(),
+		patchAccount: ({ cfg, accountId, patch }) => applyClickClackSetupConfigPatch({
+			cfg,
+			accountId,
+			patch
+		})
+	}), {
+		inputKey: "workspace",
+		message: t("wizard.clickclack.workspacePrompt"),
+		helpTitle: t("wizard.clickclack.workspacePrompt"),
+		helpLines: [t("wizard.clickclack.workspaceHelp")],
+		currentValue: ({ cfg, accountId }) => resolveClickClackAccount({
+			cfg,
+			accountId
+		}).workspace || void 0,
+		initialValue: ({ cfg, accountId }) => resolveClickClackAccount({
+			cfg,
+			accountId
+		}).workspace || void 0,
+		validate: ({ value }) => value.trim() ? void 0 : "Required",
+		normalizeValue: ({ value }) => value.trim(),
+		applySet: async ({ cfg, accountId, value }) => applyClickClackSetupConfigPatch({
+			cfg,
+			accountId,
+			patch: { workspace: value }
+		})
+	}],
+	finalize: async ({ cfg, accountId, credentialValues, prompter }) => {
+		const result = await checkClickClackSetupConnection({
+			cfg,
+			accountId,
+			token: credentialValues.token
+		});
+		if (result.status === "connected") {
+			await prompter.note(t("wizard.clickclack.connected", {
+				handle: result.handle,
+				workspace: result.workspaceName
+			}), t("wizard.clickclack.connectionTitle"));
+			return;
+		}
+		if (result.status === "skipped-env-token" || result.status === "skipped-unconfigured") return;
+		const message = result.status === "invalid-token" ? t("wizard.clickclack.invalidToken") : result.status === "workspace-not-found" ? t("wizard.clickclack.workspaceNotFound", { workspace: result.workspace }) : t("wizard.clickclack.connectionFailed", { error: result.error });
+		await prompter.note(message, t("wizard.clickclack.validationWarningTitle"));
+	},
+	disable: (cfg) => setSetupChannelEnabled(cfg, channel, false)
+};
+//#endregion
+export { createClickClackClient as a, CLICKCLACK_CHANNEL_ID as c, DEFAULT_ACCOUNT_ID$2 as d, listClickClackAccountIds as f, resolveDefaultClickClackAccountId as h, resolveWorkspaceId as i, clickClackConfigAdapter as l, resolveClickClackAccount as m, clickClackSetupAdapter as n, normalizeClickClackCorrelationId as o, listEnabledClickClackAccounts as p, resolveChannelId as r, clickClackConfigSchema as s, clickClackSetupWizard as t, clickClackMeta as u };