@spacebar_ai/moldclaw-core 2026.3.14 → 2026.3.16

package/dist/extensions/kakao-talkchannel/index.js

@@ -0,0 +1,1762 @@
+import "../../logger-BFfIIIKH.js";
+import "../../paths-D6AgsMTU.js";
+import "../../tmp-moldclaw-dir-DWF-d8qD.js";
+import "../../theme-BSXzMzAA.js";
+import "../../globals-DESrFYmC.js";
+import "../../subsystem-S4LNMNHd.js";
+import "../../ansi-BPhP6LBZ.js";
+import "../../utils-rjVNXUns.js";
+import "../../agent-scope-DA7O8MVG.js";
+import "../../boundary-file-read-Y1cMjPlu.js";
+import "../../logger-wrbK9-ju.js";
+import "../../exec-CoBTyh8B.js";
+import "../../workspace-CxNKYS0V.js";
+import "../../registry-DcDGl2X7.js";
+import "../../resolve-route-IkBfMjBz.js";
+import "../../secret-file-Bjh19aoH.js";
+import { t as defineChannelPluginEntry } from "../../core-EKuk2FxR.js";
+import { t as createPluginRuntimeStore } from "../../runtime-store-BIrp4FYB.js";
+import { z } from "zod";
+//#region extensions/kakao-talkchannel/src/config/schema.ts
+/**
+* Zod schemas for Kakao plugin configuration validation
+*
+* Simplified: Single channel + Relay mode only
+* Direct mode and multi-channel support are planned for future releases.
+*/
+const DEFAULT_RELAY_URL = "https://k.tess.dev/";
+/**
+* Single account configuration schema
+*/
+const KakaoAccountConfigSchema = z.object({
+	enabled: z.boolean().default(true),
+	dmPolicy: z.enum([
+		"pairing",
+		"allowlist",
+		"open",
+		"disabled"
+	]).default("pairing"),
+	allowFrom: z.array(z.string()).optional(),
+	responsePrefix: z.string().optional(),
+	channelId: z.string().min(1, "channelId는 필수입니다").optional(),
+	relayUrl: z.string().default(DEFAULT_RELAY_URL),
+	relayToken: z.string().optional(),
+	sessionToken: z.string().optional(),
+	reconnectDelayMs: z.number().min(500).max(1e4).default(1e3),
+	maxReconnectDelayMs: z.number().min(5e3).max(6e4).default(3e4),
+	textChunkLimit: z.number().min(100, "textChunkLimit은 최소 100자 이상이어야 합니다").max(1e3, "textChunkLimit은 최대 1000자 이하여야 합니다").default(400),
+	chunkMode: z.enum([
+		"sentence",
+		"newline",
+		"length"
+	]).default("sentence")
+});
+z.object({ accounts: z.record(z.string(), KakaoAccountConfigSchema).optional() });
+//#endregion
+//#region extensions/kakao-talkchannel/src/adapters/config.ts
+/**
+* Get the kakao-talkchannel config object
+*/
+function getKakaoTalkchannelConfig$1(cfg) {
+	if (!cfg || typeof cfg !== "object") return void 0;
+	const channels = cfg.channels;
+	if (!channels || typeof channels !== "object") return void 0;
+	const talkchannelConfig = channels["kakao-talkchannel"];
+	if (!talkchannelConfig || typeof talkchannelConfig !== "object") return void 0;
+	return talkchannelConfig;
+}
+/**
+* Get accounts object from kakao-talkchannel config
+* Returns empty object if not present (will use defaults)
+*/
+function getAccounts(cfg) {
+	const talkchannelConfig = getKakaoTalkchannelConfig$1(cfg);
+	if (!talkchannelConfig) return {};
+	const accounts = talkchannelConfig.accounts;
+	if (!accounts || typeof accounts !== "object") return {};
+	return accounts;
+}
+/**
+* Get account config by accountId
+* Falls back to default account if not found
+*/
+function getAccountConfig(cfg, accountId) {
+	const account = getAccounts(cfg)[accountId];
+	if (account && typeof account === "object") return account;
+	return {};
+}
+/**
+* Resolve Kakao TalkChannel from configuration
+* Uses schema defaults if no config provided
+*/
+function resolveKakaoTalkChannel(cfg, accountId) {
+	const rawConfig = getAccountConfig(cfg, accountId);
+	const validationResult = KakaoAccountConfigSchema.safeParse(rawConfig);
+	if (!validationResult.success) {
+		const errors = validationResult.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ");
+		throw new Error(`Invalid Kakao TalkChannel configuration: ${errors}`);
+	}
+	const config = validationResult.data;
+	let tokenSource = "none";
+	if (config.sessionToken) tokenSource = "session";
+	else if (config.relayToken) tokenSource = "config";
+	else if (process.env.OPENCLAW_TALKCHANNEL_RELAY_TOKEN) tokenSource = "env";
+	return {
+		talkchannelId: accountId,
+		config,
+		enabled: config.enabled,
+		name: rawConfig.name,
+		channelId: config.channelId,
+		tokenSource
+	};
+}
+/**
+* Kakao channel configuration adapter (simplified)
+* Uses moldClaw standard accounts structure
+*/
+const configAdapter = {
+	listAccountIds: (cfg) => {
+		const accounts = getAccounts(cfg);
+		const ids = Object.keys(accounts);
+		return ids.length > 0 ? ids : ["default"];
+	},
+	resolveAccount: (cfg, accountId) => {
+		return resolveKakaoTalkChannel(cfg, accountId ?? "default");
+	},
+	defaultAccountId: (_cfg) => {
+		return "default";
+	},
+	isConfigured: (_account) => {
+		return true;
+	},
+	isEnabled: (account) => {
+		return account.config.enabled;
+	}
+};
+//#endregion
+//#region extensions/kakao-talkchannel/src/kakao/response.ts
+/**
+* Strip markdown formatting from text for Kakao (which doesn't support markdown)
+*
+* Handles:
+* - Headers (# ## ### etc.)
+* - Bold (**text** or __text__)
+* - Italic (*text* or _text_)
+* - Strikethrough (~~text~~)
+* - Code blocks (```code``` and `inline code`)
+* - Links ([text](url)) -> text (url)
+* - Images (![alt](url)) -> [이미지: alt]
+* - Blockquotes (> text)
+* - Horizontal rules (--- or ***)
+* - List markers (* - + and numbered lists)
+*
+* @param text - Text with potential markdown formatting
+* @returns Plain text with markdown stripped
+*/
+function stripMarkdown(text) {
+	if (!text) return text;
+	let result = text;
+	result = result.replace(/```[\s\S]*?```/g, (match) => {
+		return match.replace(/```\w*\n?/g, "").replace(/```$/g, "").trim();
+	});
+	result = result.replace(/`([^`]+)`/g, "$1");
+	result = result.replace(/!\[([^\]]*)\]\([^)]+\)/g, "[이미지: $1]");
+	result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1 ($2)");
+	result = result.replace(/^#{1,6}\s+/gm, "");
+	result = result.replace(/\*\*([^*]+)\*\*/g, "$1");
+	result = result.replace(/__([^_]+)__/g, "$1");
+	result = result.replace(/(?<!\n|\*)\*([^*\n]+)\*(?!\*)/g, "$1");
+	result = result.replace(/(?<!\n|_)_([^_\n]+)_(?!_)/g, "$1");
+	result = result.replace(/~~([^~]+)~~/g, "$1");
+	result = result.replace(/^>\s?/gm, "");
+	result = result.replace(/^[-*_]{3,}\s*$/gm, "");
+	result = result.replace(/^[\s]*[-*+]\s+/gm, "• ");
+	result = result.replace(/^[\s]*\d+\.\s+/gm, "");
+	result = result.replace(/\n{3,}/g, "\n\n");
+	result = result.trim();
+	return result;
+}
+const DEFAULT_CHUNK_LIMIT = 400;
+function chunkBySentence(text, limit) {
+	const chunks = [];
+	let remaining = text;
+	while (remaining.length > 0) {
+		if (remaining.length <= limit) {
+			chunks.push(remaining);
+			break;
+		}
+		const substring = remaining.substring(0, limit);
+		const lastSentenceEnd = Math.max(substring.lastIndexOf("."), substring.lastIndexOf("!"), substring.lastIndexOf("?"));
+		if (lastSentenceEnd > 0) {
+			chunks.push(remaining.substring(0, lastSentenceEnd + 1));
+			remaining = remaining.substring(lastSentenceEnd + 1).trim();
+		} else {
+			chunks.push(remaining.substring(0, limit));
+			remaining = remaining.substring(limit).trim();
+		}
+	}
+	return chunks;
+}
+function chunkByNewline(text, limit) {
+	const paragraphs = text.split(/\n\s*\n/);
+	const chunks = [];
+	let currentChunk = "";
+	for (const paragraph of paragraphs) {
+		const trimmed = paragraph.trim();
+		if (!trimmed) continue;
+		if (currentChunk.length === 0) if (trimmed.length <= limit) currentChunk = trimmed;
+		else chunks.push(...chunkBySentence(trimmed, limit));
+		else if (currentChunk.length + 2 + trimmed.length <= limit) currentChunk += "\n\n" + trimmed;
+		else {
+			chunks.push(currentChunk);
+			if (trimmed.length <= limit) currentChunk = trimmed;
+			else {
+				chunks.push(...chunkBySentence(trimmed, limit));
+				currentChunk = "";
+			}
+		}
+	}
+	if (currentChunk) chunks.push(currentChunk);
+	return chunks;
+}
+function chunkByLength(text, limit) {
+	const chunks = [];
+	let remaining = text;
+	while (remaining.length > 0) {
+		if (remaining.length <= limit) {
+			chunks.push(remaining);
+			break;
+		}
+		chunks.push(remaining.substring(0, limit));
+		remaining = remaining.substring(limit);
+	}
+	return chunks;
+}
+function chunkTextForKakao$1(text, limit = DEFAULT_CHUNK_LIMIT, mode = "sentence") {
+	if (!text || text.length <= limit) return [text];
+	switch (mode) {
+		case "newline": return chunkByNewline(text, limit);
+		case "length": return chunkByLength(text, limit);
+		default: return chunkBySentence(text, limit);
+	}
+}
+//#endregion
+//#region extensions/kakao-talkchannel/src/adapters/outbound.ts
+function chunkTextForKakao(text, limit = 400, mode = "sentence") {
+	return chunkTextForKakao$1(text, limit, mode);
+}
+const outboundAdapter = {
+	deliveryMode: "direct",
+	textChunkLimit: 400,
+	chunkerMode: "text",
+	chunkMode: "sentence",
+	chunker: chunkTextForKakao,
+	sendText: async (_ctx) => {
+		return {
+			channel: "kakao-talkchannel",
+			success: true
+		};
+	},
+	sendMedia: async (_ctx) => {
+		return {
+			channel: "kakao-talkchannel",
+			success: true
+		};
+	}
+};
+//#endregion
+//#region extensions/kakao-talkchannel/src/adapters/status.ts
+const statusAdapter = {
+	defaultRuntime: {
+		accountId: "default",
+		running: false,
+		lastStartAt: null,
+		lastStopAt: null,
+		lastError: null
+	},
+	probeAccount: async ({ account, timeoutMs }) => {
+		if (!account.config.relayUrl) return {
+			ok: false,
+			error: "relayUrl not configured"
+		};
+		const start = Date.now();
+		try {
+			const response = await fetch(`${account.config.relayUrl}/health`, {
+				method: "GET",
+				signal: AbortSignal.timeout(timeoutMs)
+			});
+			if (!response.ok) return {
+				ok: false,
+				error: `HTTP ${response.status}`
+			};
+			return {
+				ok: true,
+				latencyMs: Date.now() - start
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				error: String(error)
+			};
+		}
+	},
+	buildAccountSnapshot: ({ account, runtime, probe }) => {
+		const snapshot = {
+			accountId: account.talkchannelId,
+			enabled: account.config.enabled,
+			configured: Boolean(account.config.relayUrl),
+			running: runtime?.running ?? false,
+			connected: runtime?.connected,
+			lastStartAt: runtime?.lastStartAt ?? null,
+			lastStopAt: runtime?.lastStopAt ?? null,
+			lastError: runtime?.lastError ?? null,
+			lastInboundAt: runtime?.lastInboundAt ?? null,
+			lastOutboundAt: runtime?.lastOutboundAt ?? null
+		};
+		if (probe !== void 0) snapshot.probe = probe;
+		return snapshot;
+	},
+	collectStatusIssues: (accounts) => {
+		const issues = [];
+		for (const account of accounts) {
+			const ext = account;
+			if (ext.configured && !ext.enabled) issues.push({
+				level: "warn",
+				message: `Kakao TalkChannel "${ext.accountId}" is configured but disabled`
+			});
+			if (ext.probe && !ext.probe.ok) issues.push({
+				level: "error",
+				message: `Kakao relay server unreachable: ${ext.probe.error}`
+			});
+			if (ext.running && ext.lastInboundAt) {
+				const silentMs = Date.now() - ext.lastInboundAt;
+				if (silentMs > 1800 * 1e3) issues.push({
+					level: "warn",
+					message: `Kakao TalkChannel "${ext.accountId}" has not received messages for ${Math.round(silentMs / 6e4)} minutes`
+				});
+			}
+		}
+		return issues;
+	}
+};
+//#endregion
+//#region extensions/kakao-talkchannel/src/adapters/security.ts
+const securityAdapter = {
+	resolveDmPolicy: (ctx) => {
+		const account = ctx.account ?? ctx.talkchannel;
+		if (!account) return null;
+		return {
+			policy: account.config.dmPolicy ?? "pairing",
+			allowFrom: account.config.allowFrom ?? [],
+			policyPath: `channels["kakao-talkchannel"].dmPolicy`,
+			allowFromPath: `channels["kakao-talkchannel"].allowFrom`,
+			approveHint: "moldclaw pairing approve kakao-talkchannel <userId>",
+			normalizeEntry: (raw) => raw.trim().replace(/^(kakao|kakaotalk):/i, "").trim()
+		};
+	},
+	collectWarnings: (ctx) => {
+		const account = ctx.account ?? ctx.talkchannel;
+		if (!account) return [];
+		const warnings = [];
+		if (account.config.dmPolicy === "open") warnings.push("- Kakao DM: dmPolicy='open' allows any user to message. Consider 'pairing' or 'allowlist' for production.");
+		return warnings;
+	}
+};
+//#endregion
+//#region extensions/kakao-talkchannel/src/runtime.ts
+const { setRuntime: setKakaoRuntime, getRuntime: getKakaoRuntime } = createPluginRuntimeStore("Kakao runtime not initialized");
+//#endregion
+//#region extensions/kakao-talkchannel/src/adapters/pairing.ts
+/**
+* Kakao Channel Pairing Adapter
+*
+* Handles user pairing for dmPolicy="pairing" mode.
+*/
+const PAIRING_APPROVED_MESSAGE = "✅ moldClaw 연동이 승인되었습니다. 이제 대화를 시작할 수 있습니다.";
+const pairingAdapter = {
+	idLabel: "kakaoUserId",
+	normalizeAllowEntry: (entry) => {
+		return entry.trim().replace(/^(kakao|kakaotalk):/i, "").trim();
+	},
+	notifyApproval: async (ctx) => {
+		try {
+			getKakaoRuntime().logger.info(`[kakao:pairing] Approval notification for user ${ctx.id}: ${PAIRING_APPROVED_MESSAGE}`);
+		} catch {}
+	}
+};
+//#endregion
+//#region extensions/kakao-talkchannel/src/relay/sse.ts
+const DEFAULT_RECONNECT_DELAY_MS = 1e3;
+const DEFAULT_MAX_RECONNECT_DELAY_MS = 3e4;
+const DEFAULT_TIMEOUT_MS$1 = 3e5;
+function calculateReconnectDelay(attempt, baseDelayMs, maxDelayMs) {
+	const exponentialDelay = baseDelayMs * Math.pow(2, attempt);
+	const cappedDelay = Math.min(exponentialDelay, maxDelayMs);
+	const jitter = cappedDelay * .2 * Math.random();
+	return Math.floor(cappedDelay + jitter);
+}
+function parseSSEChunk(chunk) {
+	const events = [];
+	let consumed = 0;
+	let searchFrom = 0;
+	let parseErrors = 0;
+	while (true) {
+		const boundary = chunk.indexOf("\n\n", searchFrom);
+		if (boundary === -1) break;
+		const block = chunk.slice(consumed, boundary);
+		const endPos = boundary + 2;
+		const currentEvent = {};
+		const lines = block.split("\n");
+		for (const line of lines) {
+			if (line === "") continue;
+			if (line.startsWith("event:")) currentEvent.event = line.slice(6).trim();
+			else if (line.startsWith("data:")) currentEvent.data = line.slice(5).trim();
+			else if (line.startsWith("id:")) currentEvent.id = line.slice(3).trim();
+		}
+		if (currentEvent.event && currentEvent.data) try {
+			const parsedData = JSON.parse(currentEvent.data);
+			events.push({
+				event: currentEvent.event,
+				data: parsedData,
+				id: currentEvent.id
+			});
+		} catch {
+			parseErrors++;
+		}
+		consumed = endPos;
+		searchFrom = endPos;
+	}
+	return {
+		events,
+		consumed,
+		parseErrors
+	};
+}
+function createTimeoutSignal$1(timeoutMs, parentSignal) {
+	const controller = new AbortController();
+	const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+	let parentAbortHandler;
+	if (parentSignal) {
+		parentAbortHandler = () => {
+			clearTimeout(timeoutId);
+			controller.abort();
+		};
+		parentSignal.addEventListener("abort", parentAbortHandler, { once: true });
+	}
+	return {
+		signal: controller.signal,
+		clear: () => {
+			clearTimeout(timeoutId);
+			if (parentSignal && parentAbortHandler) parentSignal.removeEventListener("abort", parentAbortHandler);
+		}
+	};
+}
+async function connectSSE(config, handlers, abortSignal) {
+	const reconnectDelayMs = config.reconnectDelayMs ?? DEFAULT_RECONNECT_DELAY_MS;
+	const maxReconnectDelayMs = config.maxReconnectDelayMs ?? DEFAULT_MAX_RECONNECT_DELAY_MS;
+	const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS$1;
+	let reconnectAttempt = 0;
+	let lastEventId;
+	while (!abortSignal.aborted) {
+		const timeout = createTimeoutSignal$1(timeoutMs, abortSignal);
+		try {
+			const token = config.sessionToken ?? config.relayToken;
+			if (!token) throw new Error("SSE connection requires sessionToken or relayToken");
+			const headers = {
+				Authorization: `Bearer ${token}`,
+				Accept: "text/event-stream",
+				"Cache-Control": "no-cache"
+			};
+			if (lastEventId) headers["Last-Event-ID"] = lastEventId;
+			const baseUrl = config.relayUrl.endsWith("/") ? config.relayUrl : `${config.relayUrl}/`;
+			const response = await fetch(`${baseUrl}v1/events`, {
+				method: "GET",
+				headers,
+				signal: timeout.signal
+			});
+			if (!response.ok) {
+				if (response.status === 401 || response.status === 410) {
+					handlers.onSessionInvalidated?.(response.status);
+					throw new Error(`SSE session invalidated: HTTP ${response.status}`);
+				}
+				throw new Error(`SSE connection failed: HTTP ${response.status}`);
+			}
+			if (!response.body) throw new Error("SSE connection failed: no response body");
+			reconnectAttempt = 0;
+			handlers.onConnected?.();
+			const reader = response.body.getReader();
+			try {
+				const decoder = new TextDecoder();
+				let buffer = "";
+				while (!abortSignal.aborted) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					buffer += decoder.decode(value, { stream: true });
+					const { events, consumed, parseErrors } = parseSSEChunk(buffer);
+					if (consumed > 0) buffer = buffer.slice(consumed);
+					if (parseErrors > 0) handlers.onError?.(/* @__PURE__ */ new Error(`Skipped ${parseErrors} SSE event(s) with malformed JSON`));
+					for (const event of events) {
+						if (event.id) lastEventId = event.id;
+						if (event.event === "message") try {
+							await handlers.onMessage(event.data);
+						} catch (msgError) {
+							const err = msgError instanceof Error ? msgError : new Error(String(msgError));
+							handlers.onError?.(err);
+						}
+						else if (event.event === "error") handlers.onError?.(new Error(event.data.message));
+						else if (event.event === "pairing_complete") handlers.onPairingComplete?.(event.data);
+						else if (event.event === "pairing_expired") handlers.onPairingExpired?.(event.data.reason);
+					}
+				}
+			} finally {
+				reader.cancel().catch(() => {});
+			}
+		} catch (error) {
+			if (abortSignal.aborted) return;
+			const err = error instanceof Error ? error : new Error(String(error));
+			if (err.message.startsWith("SSE session invalidated")) {
+				handlers.onError?.(err);
+				throw err;
+			}
+			handlers.onError?.(err);
+			handlers.onDisconnected?.();
+			reconnectAttempt++;
+			handlers.onReconnect?.(reconnectAttempt);
+			if (config.maxRetries !== void 0 && reconnectAttempt >= config.maxRetries) throw new Error(`Max reconnect attempts (${config.maxRetries}) exceeded`);
+			await sleep(calculateReconnectDelay(reconnectAttempt, reconnectDelayMs, maxReconnectDelayMs), abortSignal);
+		} finally {
+			timeout.clear();
+		}
+	}
+}
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal.aborted) {
+			reject(/* @__PURE__ */ new Error("Aborted"));
+			return;
+		}
+		const abortHandler = () => {
+			clearTimeout(timeout);
+			reject(/* @__PURE__ */ new Error("Aborted"));
+		};
+		const timeout = setTimeout(() => {
+			signal.removeEventListener("abort", abortHandler);
+			resolve();
+		}, ms);
+		signal.addEventListener("abort", abortHandler, { once: true });
+	});
+}
+//#endregion
+//#region extensions/kakao-talkchannel/src/relay/session.ts
+/**
+* Relay Server Session API Client
+*
+* Handles session creation and management for relay mode.
+* Sessions are created without authentication and provide:
+* - sessionToken: For SSE connection authentication
+* - pairingCode: For users to enter in KakaoTalk
+*/
+/**
+* Create a new session on the relay server
+*
+* @param relayUrl - Relay server URL (defaults to https://k.tess.dev/)
+* @returns Session token and pairing code
+*/
+async function createSession(relayUrl = DEFAULT_RELAY_URL) {
+	const url = normalizeRelayUrl(relayUrl);
+	try {
+		const response = await fetch(`${url}v1/sessions/create`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({})
+		});
+		if (!response.ok) {
+			const errorData = await response.json().catch(() => ({}));
+			return {
+				ok: false,
+				error: {
+					code: `HTTP_${response.status}`,
+					message: errorData.message ?? `Failed to create session: HTTP ${response.status}`
+				}
+			};
+		}
+		return {
+			ok: true,
+			data: await response.json()
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error: {
+				code: "NETWORK_ERROR",
+				message: error instanceof Error ? error.message : "Unknown error"
+			}
+		};
+	}
+}
+/**
+* Normalize relay URL to ensure it ends with a slash
+*/
+function normalizeRelayUrl(url) {
+	return url.endsWith("/") ? url : `${url}/`;
+}
+//#endregion
+//#region extensions/kakao-talkchannel/src/relay/stream.ts
+const DEFAULT_STREAM_OPTIONS = { maxRetries: 10 };
+/**
+* Sanitize tokens and sensitive values from log messages.
+* Masks Bearer tokens, token= params, sessionToken= params, and UUID-like patterns in auth context.
+*/
+function sanitizeTokenFromLog(message) {
+	let sanitized = message;
+	sanitized = sanitized.replace(/Authorization:\s*Bearer\s+[^\s,;]+/gi, "Authorization: ***");
+	sanitized = sanitized.replace(/Bearer\s+[^\s,;]+/gi, "Bearer ***");
+	sanitized = sanitized.replace(/sessionToken=[^&\s]+/gi, "sessionToken=***");
+	sanitized = sanitized.replace(/(?<!session)token=[^&\s]+/gi, "token=***");
+	return sanitized;
+}
+/**
+* Resolve the authentication token for relay connection
+*
+* Priority:
+* 1. sessionToken from config
+* 2. relayToken from config
+* 3. OPENCLAW_TALKCHANNEL_RELAY_TOKEN environment variable
+* 4. Create new session (returns pairing code via callback)
+*/
+async function resolveToken(talkchannel, callbacks) {
+	const relayUrl = talkchannel.config.relayUrl ?? "https://k.tess.dev/";
+	if (talkchannel.config.sessionToken) return {
+		token: talkchannel.config.sessionToken,
+		relayUrl,
+		isNewSession: false
+	};
+	if (talkchannel.config.relayToken) return {
+		token: talkchannel.config.relayToken,
+		relayUrl,
+		isNewSession: false
+	};
+	const envToken = process.env.OPENCLAW_TALKCHANNEL_RELAY_TOKEN;
+	if (envToken) return {
+		token: envToken,
+		relayUrl,
+		isNewSession: false
+	};
+	const result = await createSession(relayUrl);
+	if (!result.ok) throw new Error(`Failed to create session: ${result.error.message}`);
+	callbacks.onPairingRequired?.(result.data.pairingCode, result.data.expiresIn);
+	return {
+		token: result.data.sessionToken,
+		relayUrl,
+		isNewSession: true
+	};
+}
+async function startRelayStream(talkchannel, onMessage, abortSignal, opts = {}, callbacks = {}, log) {
+	const runtime = getKakaoRuntime();
+	const logger = log ?? runtime.logger;
+	const options = {
+		...DEFAULT_STREAM_OPTIONS,
+		...opts
+	};
+	logger.info(`[kakao:${talkchannel.talkchannelId}] Resolving token...`);
+	const { token, relayUrl, isNewSession } = await resolveToken(talkchannel, callbacks);
+	logger.info(`[kakao:${talkchannel.talkchannelId}] Token resolved (newSession=${isNewSession})`);
+	callbacks.onTokenResolved?.(token, relayUrl);
+	const { reconnectDelayMs, maxReconnectDelayMs } = talkchannel.config;
+	await connectSSE({
+		relayUrl,
+		sessionToken: token,
+		reconnectDelayMs,
+		maxReconnectDelayMs,
+		maxRetries: options.maxRetries
+	}, {
+		onMessage: async (msg) => {
+			await onMessage(msg);
+		},
+		onConnected: () => {
+			logger.info(`[kakao:${talkchannel.talkchannelId}] SSE connected to ${relayUrl}`);
+			callbacks.onConnected?.();
+		},
+		onDisconnected: () => {
+			callbacks.onDisconnected?.();
+		},
+		onError: (error) => {
+			const sanitizedError = sanitizeTokenFromLog(error.message);
+			logger.warn(`[kakao:${talkchannel.talkchannelId}] SSE error: ${sanitizedError}`);
+		},
+		onReconnect: (attempt) => {
+			logger.info(`[kakao:${talkchannel.talkchannelId}] SSE reconnecting (attempt ${attempt}/${options.maxRetries})`);
+		},
+		onPairingComplete: (data) => {
+			logger.info(`[kakao:${talkchannel.talkchannelId}] Pairing complete: ${data.kakaoUserId}`);
+			callbacks.onPairingComplete?.(data.kakaoUserId);
+		},
+		onPairingExpired: (reason) => {
+			logger.warn(`[kakao:${talkchannel.talkchannelId}] Pairing expired: ${reason}`);
+			callbacks.onPairingExpired?.(reason);
+		},
+		onSessionInvalidated: (status) => {
+			logger.warn(`[kakao:${talkchannel.talkchannelId}] Session invalidated: HTTP ${status}`);
+			callbacks.onSessionInvalidated?.(status);
+		}
+	}, abortSignal);
+}
+//#endregion
+//#region extensions/kakao-talkchannel/src/relay/client.ts
+const DEFAULT_TIMEOUT_MS = 1e4;
+const AUTH_ERROR_STATUSES = new Set([401, 410]);
+var RelayHttpError = class extends Error {
+	constructor(status, statusText, detail) {
+		super(`HTTP ${status} ${statusText}: ${detail}`);
+		this.name = "RelayHttpError";
+		this.status = status;
+		this.statusText = statusText;
+		this.isAuthError = AUTH_ERROR_STATUSES.has(status);
+	}
+};
+function isObject(value) {
+	return value !== null && typeof value === "object";
+}
+function validateSendReplyResponse(data) {
+	if (!isObject(data)) throw new Error("Invalid relay response: expected object");
+	if (typeof data.success !== "boolean") throw new Error("Invalid relay response: success must be a boolean");
+	return data;
+}
+function createTimeoutSignal(timeoutMs) {
+	const controller = new AbortController();
+	const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+	return {
+		signal: controller.signal,
+		clear: () => clearTimeout(timeoutId)
+	};
+}
+function parseErrorBody(body) {
+	if (body === null || body === void 0) return "Unknown error";
+	if (!isObject(body)) return String(body);
+	const error = body.error;
+	if (typeof error === "string") return error;
+	if (isObject(error) && typeof error.message === "string") return error.message;
+	if (typeof body.message === "string") return body.message;
+	return "Unknown error";
+}
+async function sendReply(config, messageId, response) {
+	if (!messageId || typeof messageId !== "string") throw new Error("sendReply: messageId is required and must be a non-empty string");
+	if (!config.relayUrl || typeof config.relayUrl !== "string") throw new Error("sendReply: relayUrl is required and must be a non-empty string");
+	if (!config.relayToken || typeof config.relayToken !== "string") throw new Error("sendReply: relayToken is required and must be a non-empty string");
+	const timeout = createTimeoutSignal(config.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+	try {
+		const baseUrl = config.relayUrl.endsWith("/") ? config.relayUrl : `${config.relayUrl}/`;
+		const fetchResponse = await fetch(`${baseUrl}openclaw/reply`, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${config.relayToken}`,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify({
+				messageId,
+				response
+			}),
+			signal: timeout.signal
+		});
+		if (!fetchResponse.ok) {
+			const errorBody = await fetchResponse.json().catch(() => ({}));
+			throw new RelayHttpError(fetchResponse.status, fetchResponse.statusText, parseErrorBody(errorBody));
+		}
+		return validateSendReplyResponse(await fetchResponse.json());
+	} finally {
+		timeout.clear();
+	}
+}
+//#endregion
+//#region extensions/kakao-talkchannel/src/version.ts
+const PLUGIN_VERSION = "0.5.1";
+//#endregion
+//#region extensions/kakao-talkchannel/src/commands/card.ts
+/**
+* /card 커맨드 인수 파싱
+*
+* 입력 형식: `<type> "arg1" "arg2" --flag1 value1 --flag2 "value2"`
+* - 따옴표로 묶인 문자열 → 위치 인수 (args)
+* - `--key value` 또는 `--key "value"` → 플래그 (flags)
+* - 플래그의 따옴표 값은 위치 인수로 중복 수집되지 않음
+*/
+function parseCardArgs(input) {
+	const trimmed = input.trim();
+	const typeMatch = trimmed.match(/^(\w+)/);
+	if (!typeMatch) return {
+		type: "",
+		args: [],
+		flags: {}
+	};
+	const type = typeMatch[1].toLowerCase();
+	const rest = trimmed.slice(typeMatch[0].length).trim();
+	const args = [];
+	const flags = {};
+	const regex = /--(\w+)\s+(?:"([^"]*?)"|(\S+))|"([^"]*?)"/g;
+	let match;
+	while ((match = regex.exec(rest)) !== null) if (match[1] !== void 0) flags[match[1]] = match[2] ?? match[3] ?? "";
+	else if (match[4] !== void 0) args.push(match[4]);
+	return {
+		type,
+		args,
+		flags
+	};
+}
+/**
+* 버튼 문자열 파싱
+*
+* 형식: "라벨1|데이터1,라벨2|데이터2"
+* - 데이터가 http(s):// 로 시작 → webLink
+* - 데이터가 전화번호 형식 (7자리 이상 숫자/기호) → phone
+* - 그 외 → message
+* - 최대 3개 (카카오 제한)
+*/
+function parseButtons(input) {
+	if (!input.trim()) return [];
+	return input.split(",").map((item) => item.trim()).filter(Boolean).slice(0, 3).map((item) => {
+		const pipeIndex = item.lastIndexOf("|");
+		if (pipeIndex === -1) return {
+			label: item,
+			action: "message",
+			messageText: item
+		};
+		const label = item.slice(0, pipeIndex).trim();
+		const data = item.slice(pipeIndex + 1).trim();
+		if (data.startsWith("http://") || data.startsWith("https://")) return {
+			label,
+			action: "webLink",
+			webLinkUrl: data
+		};
+		if (/^[\d\-+\s]+$/.test(data) && data.replace(/\D/g, "").length >= 7) return {
+			label,
+			action: "phone",
+			phoneNumber: data
+		};
+		return {
+			label,
+			action: "message",
+			messageText: data
+		};
+	});
+}
+/**
+* 빠른 응답 버튼 파싱
+*
+* 형식: "라벨1,라벨2,라벨3"
+* - 모두 message action (messageText = label)
+* - 최대 10개 (카카오 제한)
+*/
+function parseQuickReplies(input) {
+	if (!input.trim()) return [];
+	return input.split(",").map((item) => item.trim()).filter(Boolean).slice(0, 10).map((label) => ({
+		label,
+		action: "message",
+		messageText: label
+	}));
+}
+function buildUsageError(type, usage) {
+	return {
+		version: "2.0",
+		template: { outputs: [{ textCard: {
+			title: `/card ${type} 사용법`,
+			description: usage
+		} }] }
+	};
+}
+function buildTextCard(args, flags) {
+	const title = args[0];
+	const description = args[1];
+	if (!title && !description) return buildUsageError("text", "/card text \"제목\" \"설명\" [--buttons \"버튼1|url,버튼2|msg\"] [--quick \"옵션1,옵션2\"]");
+	const buttons = flags.buttons ? parseButtons(flags.buttons) : void 0;
+	const quickReplies = flags.quick ? parseQuickReplies(flags.quick) : void 0;
+	return {
+		version: "2.0",
+		template: {
+			outputs: [{ textCard: {
+				...title && { title },
+				...description && { description },
+				...buttons?.length && { buttons }
+			} }],
+			...quickReplies?.length && { quickReplies }
+		}
+	};
+}
+function buildBasicCard(args, flags) {
+	const imageUrl = flags.image;
+	if (!imageUrl) return buildUsageError("basic", "/card basic \"제목\" \"설명\" --image <url> [--buttons \"버튼|url\"] [--quick \"옵션1,옵션2\"]");
+	const title = args[0];
+	const description = args[1];
+	const buttons = flags.buttons ? parseButtons(flags.buttons) : void 0;
+	const quickReplies = flags.quick ? parseQuickReplies(flags.quick) : void 0;
+	return {
+		version: "2.0",
+		template: {
+			outputs: [{ basicCard: {
+				...title && { title },
+				...description && { description },
+				thumbnail: { imageUrl },
+				...buttons?.length && { buttons }
+			} }],
+			...quickReplies?.length && { quickReplies }
+		}
+	};
+}
+function buildListCard(args, flags) {
+	const headerTitle = args[0];
+	const itemsStr = args[1];
+	if (!headerTitle || !itemsStr) return buildUsageError("list", "/card list \"헤더\" \"항목1|설명1,항목2|설명2\" [--buttons \"버튼|url\"] [--quick \"옵션1,옵션2\"]");
+	const items = itemsStr.split(",").map((item) => item.trim()).filter(Boolean).slice(0, 5).map((item) => {
+		const pipeIndex = item.lastIndexOf("|");
+		if (pipeIndex === -1) return { title: item };
+		const title = item.slice(0, pipeIndex).trim();
+		const description = item.slice(pipeIndex + 1).trim() || void 0;
+		return {
+			title,
+			...description && { description }
+		};
+	});
+	if (items.length < 2) return buildUsageError("list", "listCard는 항목이 최소 2개 필요합니다. 예: \"항목1|설명1,항목2|설명2\"");
+	const buttons = flags.buttons ? parseButtons(flags.buttons) : void 0;
+	const quickReplies = flags.quick ? parseQuickReplies(flags.quick) : void 0;
+	return {
+		version: "2.0",
+		template: {
+			outputs: [{ listCard: {
+				header: { title: headerTitle },
+				items,
+				...buttons?.length && { buttons }
+			} }],
+			...quickReplies?.length && { quickReplies }
+		}
+	};
+}
+function buildCommerceCard(args, flags) {
+	const title = args[0];
+	const priceStr = flags.price;
+	if (!title || !priceStr) return buildUsageError("commerce", "/card commerce \"상품명\" --price 15000 [--description \"설명\"] [--discount 2000] [--image <url>] [--buttons \"버튼|url\"]");
+	const price = parseInt(priceStr, 10);
+	if (isNaN(price)) return buildUsageError("commerce", "가격은 숫자여야 합니다. 예: --price 15000");
+	const imageUrl = flags.image;
+	if (!imageUrl) return buildUsageError("commerce", "/card commerce \"상품명\" --price 15000 --image <url> [--description \"설명\"] [--discount 2000] [--buttons \"버튼|url\"]");
+	const description = flags.description ?? args[1];
+	let discount;
+	if (flags.discount !== void 0) {
+		discount = parseInt(flags.discount, 10);
+		if (isNaN(discount)) return buildUsageError("commerce", "할인 금액은 숫자여야 합니다. 예: --discount 2000");
+	}
+	const buttons = flags.buttons ? parseButtons(flags.buttons) : void 0;
+	const quickReplies = flags.quick ? parseQuickReplies(flags.quick) : void 0;
+	return {
+		version: "2.0",
+		template: {
+			outputs: [{ commerceCard: {
+				title,
+				...description && { description },
+				price,
+				currency: "won",
+				...discount !== void 0 && { discount },
+				thumbnails: [{ imageUrl }],
+				...buttons?.length && { buttons }
+			} }],
+			...quickReplies?.length && { quickReplies }
+		}
+	};
+}
+function buildCardHelpResponse() {
+	return {
+		version: "2.0",
+		template: { outputs: [{ listCard: {
+			header: { title: "카드 커맨드 목록" },
+			items: [
+				{
+					title: "/card text",
+					description: "\"제목\" \"설명\" [--buttons] [--quick]"
+				},
+				{
+					title: "/card basic",
+					description: "\"제목\" \"설명\" --image <url> [--buttons]"
+				},
+				{
+					title: "/card list",
+					description: "\"헤더\" \"항목1|설명,항목2|설명\" [--buttons]"
+				},
+				{
+					title: "/card commerce",
+					description: "\"상품명\" --price 15000 --image <url> [--discount]"
+				}
+			]
+		} }] }
+	};
+}
+async function handleCardCommand(msg, _account, _accountId, relayUrl, relayToken, log) {
+	const messageText = msg.normalized.text?.trim() ?? "";
+	const argsStr = messageText.slice(5).trim();
+	let response;
+	if (!argsStr) response = buildCardHelpResponse();
+	else {
+		const { type, args, flags } = parseCardArgs(argsStr);
+		switch (type) {
+			case "text":
+				response = buildTextCard(args, flags);
+				break;
+			case "basic":
+				response = buildBasicCard(args, flags);
+				break;
+			case "list":
+				response = buildListCard(args, flags);
+				break;
+			case "commerce":
+				response = buildCommerceCard(args, flags);
+				break;
+			default: response = buildCardHelpResponse();
+		}
+	}
+	log?.info(`[kakao-talkchannel] /card: ${messageText.slice(0, 60)}`);
+	await sendReply({
+		relayUrl,
+		relayToken
+	}, msg.id, response);
+}
+//#endregion
+//#region extensions/kakao-talkchannel/src/adapters/gateway.ts
+const MAX_USER_ACTIVITY_SIZE = 1e4;
+const CLEANUP_INTERVAL = 100;
+let cleanupCounter = 0;
+const userActivity = /* @__PURE__ */ new Map();
+/**
+* TTL 만료된 항목 정리
+*/
+function cleanupExpiredUserActivity() {
+	const now = Date.now();
+	let removed = 0;
+	for (const [key, activity] of userActivity) if (now - activity.lastAccessedAt > 864e5) {
+		userActivity.delete(key);
+		removed++;
+	}
+	return removed;
+}
+/**
+* 주기적 정리 트리거 (매 CLEANUP_INTERVAL 호출마다)
+*/
+function maybeCleanup() {
+	cleanupCounter++;
+	if (cleanupCounter >= CLEANUP_INTERVAL) {
+		cleanupCounter = 0;
+		cleanupExpiredUserActivity();
+		if (userActivity.size > 1e4) {
+			const entries = [...userActivity.entries()].sort((a, b) => a[1].lastAccessedAt - b[1].lastAccessedAt);
+			const toRemove = userActivity.size - MAX_USER_ACTIVITY_SIZE;
+			for (let i = 0; i < toRemove; i++) userActivity.delete(entries[i][0]);
+		}
+	}
+}
+/**
+* 사용자 활동 업데이트 및 경고 필요 여부 판단
+* 50개 메시지마다 경고하되, 마지막 경고 후 최소 50개 간격 유지
+*/
+function shouldShowSessionWarning(userId) {
+	maybeCleanup();
+	const activity = userActivity.get(userId) || {
+		messageCount: 0,
+		lastWarningCount: -50,
+		lastAccessedAt: Date.now()
+	};
+	activity.messageCount++;
+	activity.lastAccessedAt = Date.now();
+	userActivity.set(userId, activity);
+	const isCheckpoint = activity.messageCount % 50 === 0;
+	const enoughGap = activity.messageCount - activity.lastWarningCount >= 50;
+	if (isCheckpoint && enoughGap) {
+		activity.lastWarningCount = activity.messageCount;
+		userActivity.set(userId, activity);
+		return true;
+	}
+	return false;
+}
+/**
+* 메시지 텍스트에서 카카오 카드 JSON 감지
+* JSON 형태이고 카드 키가 있으면 파싱하여 반환
+*/
+function tryParseKakaoCard(text) {
+	const trimmed = text.trim();
+	if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return null;
+	try {
+		const parsed = JSON.parse(trimmed);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+		const objectCardKeys = [
+			"textCard",
+			"basicCard",
+			"listCard",
+			"commerceCard",
+			"itemCard",
+			"carousel",
+			"simpleText",
+			"simpleImage"
+		];
+		const arrayCardKeys = ["quickReplies", "outputs"];
+		let hasValidCard = false;
+		for (const key of objectCardKeys) if (key in parsed) {
+			if (typeof parsed[key] !== "object" || parsed[key] === null || Array.isArray(parsed[key])) return null;
+			hasValidCard = true;
+		}
+		for (const key of arrayCardKeys) if (key in parsed) {
+			if (!Array.isArray(parsed[key])) return null;
+			hasValidCard = true;
+		}
+		if (hasValidCard) return parsed;
+	} catch {}
+	return null;
+}
+function buildOutputsFromChannelData(kakaoData) {
+	if (kakaoData.outputs && kakaoData.outputs.length > 0) return kakaoData.outputs;
+	const outputs = [];
+	if (kakaoData.simpleText) outputs.push({ simpleText: kakaoData.simpleText });
+	if (kakaoData.simpleImage) outputs.push({ simpleImage: kakaoData.simpleImage });
+	if (kakaoData.textCard) outputs.push({ textCard: kakaoData.textCard });
+	if (kakaoData.basicCard) outputs.push({ basicCard: kakaoData.basicCard });
+	if (kakaoData.commerceCard) outputs.push({ commerceCard: kakaoData.commerceCard });
+	if (kakaoData.listCard) outputs.push({ listCard: kakaoData.listCard });
+	if (kakaoData.itemCard) outputs.push({ itemCard: kakaoData.itemCard });
+	if (kakaoData.carousel) outputs.push({ carousel: kakaoData.carousel });
+	return outputs;
+}
+const pendingPairingInfoMap = /* @__PURE__ */ new Map();
+const activeSessionTokenMap = /* @__PURE__ */ new Map();
+function invalidateSessionToken(accountId, reason, log) {
+	if (activeSessionTokenMap.delete(accountId)) log?.warn(`[kakao-talkchannel] Session token invalidated for ${accountId}: ${reason}`);
+}
+function getPendingPairingInfo(accountId) {
+	if (accountId) {
+		const info = pendingPairingInfoMap.get(accountId) ?? null;
+		pendingPairingInfoMap.delete(accountId);
+		return info;
+	}
+	const first = pendingPairingInfoMap.entries().next();
+	if (first.done) return null;
+	pendingPairingInfoMap.delete(first.value[0]);
+	return first.value[1];
+}
+/**
+* Build moldClaw message context from InboundMessage
+*/
+function buildMessageContext(msg, account, accountId) {
+	const { normalized } = msg;
+	const sessionKey = `agent:main:kakao-talkchannel:dm:${normalized.userId}`;
+	return {
+		Body: normalized.text,
+		RawBody: normalized.text,
+		BodyForAgent: normalized.text,
+		BodyForCommands: normalized.text,
+		From: `kakao:${normalized.userId}`,
+		To: `kakao:${normalized.channelId}`,
+		Provider: "kakao-talkchannel",
+		Surface: "kakao-talkchannel",
+		MessageSid: msg.id,
+		MessageSidFull: msg.id,
+		SessionKey: sessionKey,
+		AccountId: accountId,
+		ChatType: "direct",
+		Timestamp: msg.createdAt ? new Date(msg.createdAt).getTime() : Date.now(),
+		SenderId: normalized.userId,
+		CommandAuthorized: true
+	};
+}
+/**
+* /help 또는 /? - 사용 가이드 캐러셀 (3장)
+*/
+async function handleHelpCommand(msg, account, _accountId, relayUrl, relayToken, log) {
+	const response = {
+		version: "2.0",
+		template: {
+			outputs: [{ carousel: {
+				type: "itemCard",
+				items: [
+					{
+						thumbnail: {
+							imageUrl: "https://raw.githubusercontent.com/kakao-bart-lee/openclaw-kakao-talkchannel-plugin/main/images/openclaw-icon.png",
+							fixedRatio: true
+						},
+						head: { title: "기본 사용법" },
+						itemList: [
+							{
+								title: "/help, /?",
+								description: "도움말 보기"
+							},
+							{
+								title: "/session, /s",
+								description: "세션 정보 확인"
+							},
+							{
+								title: "/relay",
+								description: "서버 상태 확인"
+							},
+							{
+								title: "/about",
+								description: "플러그인 정보"
+							}
+						],
+						buttons: [{
+							label: "GitHub",
+							action: "webLink",
+							webLinkUrl: "https://github.com/kakao-bart-lee/openclaw-kakao-talkchannel-plugin"
+						}]
+					},
+					{
+						thumbnail: {
+							imageUrl: "https://raw.githubusercontent.com/kakao-bart-lee/openclaw-kakao-talkchannel-plugin/main/images/lobster-emoji-large-google.png",
+							fixedRatio: true
+						},
+						head: { title: "세션 관리" },
+						itemList: [
+							{
+								title: "/compact",
+								description: "히스토리 압축"
+							},
+							{
+								title: "/reset",
+								description: "세션 초기화"
+							},
+							{
+								title: "/session, /s",
+								description: "세션 정보 확인"
+							}
+						],
+						buttons: [{
+							label: "compact",
+							action: "message",
+							messageText: "/compact"
+						}, {
+							label: "reset",
+							action: "message",
+							messageText: "/reset"
+						}],
+						buttonLayout: "horizontal"
+					},
+					{
+						thumbnail: {
+							imageUrl: "https://raw.githubusercontent.com/kakao-bart-lee/openclaw-kakao-talkchannel-plugin/main/images/github-social.png",
+							fixedRatio: true
+						},
+						head: { title: "릴레이 서버" },
+						itemList: [
+							{
+								title: "/pair",
+								description: "페어링 코드로 연결"
+							},
+							{
+								title: "/unpair",
+								description: "연결 해제"
+							},
+							{
+								title: "/status",
+								description: "연결 상태 확인"
+							},
+							{
+								title: "/code",
+								description: "접속 코드 생성"
+							}
+						],
+						buttons: [{
+							label: "릴레이 서버",
+							action: "webLink",
+							webLinkUrl: "https://k.tess.dev"
+						}]
+					},
+					{
+						thumbnail: {
+							imageUrl: "https://raw.githubusercontent.com/kakao-bart-lee/openclaw-kakao-talkchannel-plugin/main/images/github-logo.webp",
+							fixedRatio: true
+						},
+						head: { title: "링크 & 정보" },
+						itemList: [{
+							title: "/github",
+							description: "소스코드 보기"
+						}, {
+							title: "/about",
+							description: "플러그인 정보"
+						}],
+						buttons: [{
+							label: "이슈 제보",
+							action: "webLink",
+							webLinkUrl: "https://github.com/kakao-bart-lee/openclaw-kakao-talkchannel-plugin/issues"
+						}, {
+							label: "README",
+							action: "webLink",
+							webLinkUrl: "https://github.com/kakao-bart-lee/openclaw-kakao-talkchannel-plugin#readme"
+						}],
+						buttonLayout: "horizontal"
+					}
+				]
+			} }],
+			quickReplies: [
+				{
+					label: "session",
+					action: "message",
+					messageText: "/session"
+				},
+				{
+					label: "reset",
+					action: "message",
+					messageText: "/reset"
+				},
+				{
+					label: "about",
+					action: "message",
+					messageText: "/about"
+				}
+			]
+		}
+	};
+	try {
+		await sendReply({
+			relayUrl,
+			relayToken
+		}, msg.id, response);
+		log?.info(`[kakao-talkchannel:${account.talkchannelId}] Help carousel sent`);
+	} catch (err) {
+		const errMsg = err instanceof Error ? err.message : String(err);
+		log?.error(`[kakao-talkchannel:${account.talkchannelId}] Help command failed: ${errMsg}`);
+	}
+}
+/**
+* /github - GitHub 리포지토리 바로가기
+*/
+async function handleGithubCommand(msg, account, _accountId, relayUrl, relayToken, log) {
+	const response = {
+		version: "2.0",
+		template: { outputs: [{ basicCard: {
+			title: "📦 moldClaw Kakao TalkChannel",
+			description: "GitHub 리포지토리\n\n⭐ Star & 기여 환영!\n📖 README에서 자세한 사용법 확인\n🐛 이슈 제보 및 기능 제안",
+			thumbnail: { imageUrl: "https://github.githubassets.com/images/modules/logos_page/GitHub-Mark.png" },
+			buttons: [
+				{
+					label: "리포지토리 열기",
+					action: "webLink",
+					webLinkUrl: "https://github.com/kakao-bart-lee/openclaw-kakao-talkchannel-plugin"
+				},
+				{
+					label: "이슈 제보",
+					action: "webLink",
+					webLinkUrl: "https://github.com/kakao-bart-lee/openclaw-kakao-talkchannel-plugin/issues"
+				},
+				{
+					label: "README",
+					action: "webLink",
+					webLinkUrl: "https://github.com/kakao-bart-lee/openclaw-kakao-talkchannel-plugin#readme"
+				}
+			]
+		} }] }
+	};
+	try {
+		await sendReply({
+			relayUrl,
+			relayToken
+		}, msg.id, response);
+		log?.info(`[kakao-talkchannel:${account.talkchannelId}] GitHub card sent`);
+	} catch (err) {
+		const errMsg = err instanceof Error ? err.message : String(err);
+		log?.error(`[kakao-talkchannel:${account.talkchannelId}] GitHub command failed: ${errMsg}`);
+	}
+}
+/**
+* /about - 플러그인 정보
+*/
+async function handleAboutCommand(msg, account, _accountId, relayUrl, relayToken, log) {
+	const response = {
+		version: "2.0",
+		template: { outputs: [{ listCard: {
+			header: { title: "ℹ️ 플러그인 정보" },
+			items: [
+				{
+					title: "버전",
+					description: `v${PLUGIN_VERSION}`
+				},
+				{
+					title: "패키지",
+					description: "@moldclaw/kakao-talkchannel"
+				},
+				{
+					title: "설명",
+					description: "Kakao TalkChannel ↔ moldClaw 연결"
+				}
+			],
+			buttons: [{
+				label: "GitHub",
+				action: "webLink",
+				webLinkUrl: "https://github.com/kakao-bart-lee/openclaw-kakao-talkchannel-plugin"
+			}, {
+				label: "도움말",
+				action: "message",
+				messageText: "/help"
+			}]
+		} }] }
+	};
+	try {
+		await sendReply({
+			relayUrl,
+			relayToken
+		}, msg.id, response);
+		log?.info(`[kakao-talkchannel:${account.talkchannelId}] About card sent`);
+	} catch (err) {
+		const errMsg = err instanceof Error ? err.message : String(err);
+		log?.error(`[kakao-talkchannel:${account.talkchannelId}] About command failed: ${errMsg}`);
+	}
+}
+/**
+* /relay - 릴레이 서버 상태 확인
+*/
+async function handleRelayCommand(msg, account, _accountId, relayUrl, relayToken, log) {
+	const startTime = Date.now();
+	let status = "❌ 연결 실패";
+	let latency = "N/A";
+	let sessionStatus = "알 수 없음";
+	try {
+		const healthUrl = `${relayUrl}health`;
+		const healthResponse = await fetch(healthUrl, {
+			method: "GET",
+			headers: { "Authorization": `Bearer ${relayToken}` }
+		});
+		if (healthResponse.ok) {
+			const responseTime = Date.now() - startTime;
+			status = "✅ 정상";
+			latency = `${responseTime}ms`;
+			sessionStatus = relayToken ? "페어링 완료" : "토큰 없음";
+		} else status = `⚠️ HTTP ${healthResponse.status}`;
+	} catch (err) {
+		status = "❌ 연결 실패";
+		log?.error(`[kakao-talkchannel:${account.talkchannelId}] Relay health check failed: ${err}`);
+	}
+	const response = {
+		version: "2.0",
+		template: { outputs: [{ textCard: {
+			title: "🌐 릴레이 서버 상태",
+			description: `서버: ${relayUrl}\n상태: ${status}\n응답시간: ${latency}\n세션: ${sessionStatus}`,
+			buttons: [{
+				label: "재확인",
+				action: "message",
+				messageText: "/relay"
+			}, {
+				label: "세션 정보",
+				action: "message",
+				messageText: "/session"
+			}]
+		} }] }
+	};
+	try {
+		await sendReply({
+			relayUrl,
+			relayToken
+		}, msg.id, response);
+		log?.info(`[kakao-talkchannel:${account.talkchannelId}] Relay status sent`);
+	} catch (err) {
+		const errMsg = err instanceof Error ? err.message : String(err);
+		log?.error(`[kakao-talkchannel:${account.talkchannelId}] Relay command failed: ${errMsg}`);
+	}
+}
+/**
+* /session - 세션 정보
+*/
+async function handleSessionCommand(msg, account, _accountId, relayUrl, relayToken, log) {
+	const userId = msg.normalized.userId;
+	const activity = userActivity.get(userId);
+	const messageCount = activity?.messageCount || 0;
+	const lastWarningCount = activity?.lastWarningCount || 0;
+	const response = {
+		version: "2.0",
+		template: { outputs: [{ textCard: {
+			title: "📊 현재 세션",
+			description: `메시지: ${messageCount}개\n마지막 경고: ${lastWarningCount > 0 ? lastWarningCount + "개 시점" : "없음"}\n페어링: ✅ ${userId}\n토큰: ${relayToken ? "연결됨" : "없음"}`,
+			buttons: [{
+				label: "compact",
+				action: "message",
+				messageText: "/compact"
+			}, {
+				label: "reset",
+				action: "message",
+				messageText: "/reset"
+			}],
+			buttonLayout: "horizontal"
+		} }] }
+	};
+	try {
+		await sendReply({
+			relayUrl,
+			relayToken
+		}, msg.id, response);
+		log?.info(`[kakao-talkchannel:${account.talkchannelId}] Session info sent`);
+	} catch (err) {
+		const errMsg = err instanceof Error ? err.message : String(err);
+		log?.error(`[kakao-talkchannel:${account.talkchannelId}] Session command failed: ${errMsg}`);
+	}
+}
+/**
+* 플러그인 커맨드 맵
+*/
+const PLUGIN_COMMANDS = {
+	"/help": handleHelpCommand,
+	"/?": handleHelpCommand,
+	"/github": handleGithubCommand,
+	"/about": handleAboutCommand,
+	"/relay": handleRelayCommand,
+	"/session": handleSessionCommand,
+	"/s": handleSessionCommand,
+	"/card": handleCardCommand
+};
+/**
+* Handle inbound message by dispatching to moldClaw agent system
+*/
+async function handleInboundMessage(msg, account, accountId, cfg, log) {
+	const channel = getKakaoRuntime().channel;
+	log?.info(`[kakao-talkchannel:${account.talkchannelId}] Received message: ${msg.id}`);
+	const activeSession = activeSessionTokenMap.get(accountId);
+	const relayUrl = activeSession?.relayUrl ?? account.config.relayUrl ?? "https://k.tess.dev/";
+	const relayToken = activeSession?.sessionToken ?? account.config.sessionToken ?? account.config.relayToken ?? "";
+	const messageText = msg.normalized.text?.trim() ?? "";
+	if (messageText.startsWith("/")) {
+		const command = messageText.split(" ")[0].toLowerCase();
+		const handler = PLUGIN_COMMANDS[command];
+		if (handler) {
+			log?.info(`[kakao-talkchannel:${account.talkchannelId}] Plugin command: ${command}`);
+			try {
+				await handler(msg, account, accountId, relayUrl, relayToken, log);
+			} catch (err) {
+				const errMsg = err instanceof Error ? err.message : String(err);
+				log?.error(`[kakao-talkchannel:${account.talkchannelId}] Command ${command} error: ${errMsg}`);
+				try {
+					await sendReply({
+						relayUrl,
+						relayToken
+					}, msg.id, {
+						version: "2.0",
+						template: { outputs: [{ simpleText: { text: `명령어 처리 중 오류가 발생했습니다: ${errMsg}` } }] }
+					});
+				} catch (replyErr) {
+					const replyErrMsg = replyErr instanceof Error ? replyErr.message : String(replyErr);
+					log?.error(`[kakao-talkchannel:${account.talkchannelId}] Failed to send error feedback: ${replyErrMsg}`);
+				}
+			}
+			return;
+		}
+	}
+	const userId = msg.normalized.userId;
+	const shouldWarn = shouldShowSessionWarning(userId);
+	if (shouldWarn) log?.info(`[kakao-talkchannel:${account.talkchannelId}] Session warning triggered for ${userId}`);
+	const rawCtx = buildMessageContext(msg, account, accountId);
+	const ctxPayload = channel.reply.finalizeInboundContext(rawCtx);
+	await channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+		ctx: ctxPayload,
+		cfg,
+		dispatcherOptions: {
+			deliver: async (payload) => {
+				const outboundPayload = payload;
+				const template = { outputs: [] };
+				const kakaoData = outboundPayload.channelData?.kakao;
+				if (kakaoData) {
+					const channelOutputs = buildOutputsFromChannelData(kakaoData);
+					template.outputs.push(...channelOutputs);
+					if (kakaoData.quickReplies && kakaoData.quickReplies.length > 0) template.quickReplies = kakaoData.quickReplies.slice(0, 10);
+				}
+				if (template.outputs.length === 0) {
+					if (outboundPayload.mediaUrls && outboundPayload.mediaUrls.length > 0) for (const url of outboundPayload.mediaUrls.slice(0, 3)) template.outputs.push({ simpleImage: { imageUrl: url } });
+					if (outboundPayload.text) {
+						const cardData = tryParseKakaoCard(outboundPayload.text);
+						if (cardData) {
+							const cardOutputs = buildOutputsFromChannelData(cardData);
+							template.outputs.push(...cardOutputs);
+							if (cardData.quickReplies && cardData.quickReplies.length > 0) template.quickReplies = cardData.quickReplies.slice(0, 10);
+						} else {
+							const plainText = stripMarkdown(outboundPayload.text);
+							template.outputs.push({ simpleText: { text: plainText } });
+						}
+					}
+				}
+				if (template.outputs.length === 0) return;
+				template.outputs = template.outputs.slice(0, 3);
+				if (shouldWarn) {
+					const messageCount = userActivity.get(msg.normalized.userId)?.messageCount || 0;
+					if (!template.quickReplies) template.quickReplies = [];
+					template.quickReplies.unshift({
+						label: `💡 /compact (${messageCount}개)`,
+						action: "message",
+						messageText: "/compact"
+					}, {
+						label: "도움말",
+						action: "message",
+						messageText: "세션 관리가 뭐야?"
+					});
+					template.quickReplies = template.quickReplies.slice(0, 10);
+				}
+				const response = {
+					version: "2.0",
+					template
+				};
+				try {
+					await sendReply({
+						relayUrl,
+						relayToken
+					}, msg.id, response);
+					log?.info(`[kakao-talkchannel:${account.talkchannelId}] Reply sent for ${msg.id}`);
+				} catch (err) {
+					if (err instanceof RelayHttpError && err.isAuthError) invalidateSessionToken(accountId, `sendReply HTTP ${err.status}`, log);
+					const errMsg = err instanceof Error ? err.message : String(err);
+					log?.error(`[kakao-talkchannel:${account.talkchannelId}] Reply failed: ${errMsg}`);
+				}
+			},
+			onReplyStart: async () => {},
+			onIdle: async () => {},
+			onError: (err, info) => {
+				log?.error(`[kakao-talkchannel:${account.talkchannelId}] Dispatch ${info.kind} error: ${err.message}`);
+			}
+		}
+	});
+}
+const gatewayAdapter = {
+	startAccount: async (ctx) => {
+		const { account, accountId, cfg, abortSignal, log } = ctx;
+		log?.info(`[kakao-talkchannel:${account.talkchannelId}] Starting SSE stream to ${account.config.relayUrl}`);
+		const callbacks = {
+			onConnected: () => {
+				if (ctx.getStatus && ctx.setStatus) ctx.setStatus({
+					...ctx.getStatus(),
+					connected: true
+				});
+			},
+			onDisconnected: () => {
+				if (ctx.getStatus && ctx.setStatus) ctx.setStatus({
+					...ctx.getStatus(),
+					connected: false
+				});
+			},
+			onTokenResolved: (sessionToken, relayUrl) => {
+				activeSessionTokenMap.set(accountId, {
+					sessionToken,
+					relayUrl
+				});
+				log?.info(`[kakao-talkchannel:${account.talkchannelId}] Session token stored for account`);
+			},
+			onPairingRequired: (pairingCode, expiresIn) => {
+				pendingPairingInfoMap.set(accountId, {
+					pairingCode,
+					expiresIn
+				});
+				log?.info(`[kakao-talkchannel:${account.talkchannelId}] ========================================`);
+				log?.info(`[kakao-talkchannel:${account.talkchannelId}] 🔗 페어링 코드: ${pairingCode}`);
+				log?.info(`[kakao-talkchannel:${account.talkchannelId}] 카카오톡에서 /pair ${pairingCode} 입력하세요`);
+				log?.info(`[kakao-talkchannel:${account.talkchannelId}] 유효시간: ${Math.floor(expiresIn / 60)}분`);
+				log?.info(`[kakao-talkchannel:${account.talkchannelId}] ========================================`);
+			},
+			onPairingComplete: (kakaoUserId) => {
+				log?.info(`[kakao-talkchannel:${account.talkchannelId}] ✅ 페어링 완료: ${kakaoUserId}`);
+			},
+			onPairingExpired: (reason) => {
+				log?.info(`[kakao-talkchannel:${account.talkchannelId}] ⚠️ 페어링 만료: ${reason}`);
+			},
+			onSessionInvalidated: (status) => {
+				invalidateSessionToken(accountId, `SSE HTTP ${status}`, log);
+			}
+		};
+		const onMessage = async (msg) => {
+			await handleInboundMessage(msg, account, accountId, cfg, log);
+		};
+		return startRelayStream(account, onMessage, abortSignal, {}, callbacks, log);
+	},
+	stopAccount: async (ctx) => {
+		activeSessionTokenMap.delete(ctx.accountId);
+		return Promise.resolve();
+	},
+	getPendingPairingInfo
+};
+//#endregion
+//#region extensions/kakao-talkchannel/src/adapters/setup.ts
+function getKakaoTalkchannelConfig(cfg) {
+	const config = cfg ?? {};
+	const channels = config.channels ?? {};
+	return {
+		config,
+		channels,
+		talkchannelConfig: channels["kakao-talkchannel"] ?? {}
+	};
+}
+//#endregion
+//#region extensions/kakao-talkchannel/index.ts
+var kakao_talkchannel_default = defineChannelPluginEntry({
+	id: "kakao-talkchannel",
+	name: "Kakao TalkChannel",
+	description: "KakaoTalk 채널 챗봇을 moldClaw에 연결합니다",
+	plugin: {
+		id: "kakao-talkchannel",
+		meta: {
+			id: "kakao-talkchannel",
+			label: "Kakao TalkChannel",
+			selectionLabel: "카카오톡 채널",
+			detailLabel: "KakaoTalk Bot",
+			docsPath: "/channels/kakao-talkchannel",
+			docsLabel: "kakao-talkchannel",
+			blurb: "KakaoTalk 채널 챗봇을 moldClaw에 연결합니다",
+			systemImage: "message.fill",
+			aliases: ["kakaotalk", "kakao-channel"],
+			quickstartAllowFrom: false
+		},
+		pairing: pairingAdapter,
+		capabilities: {
+			chatTypes: ["direct"],
+			reactions: false,
+			threads: false,
+			media: true,
+			nativeCommands: false,
+			blockStreaming: true
+		},
+		reload: { configPrefixes: ["channels.kakao-talkchannel"] },
+		config: configAdapter,
+		security: securityAdapter,
+		outbound: outboundAdapter,
+		status: statusAdapter,
+		gateway: gatewayAdapter,
+		setup: {
+			resolveTalkChannelId: (_ctx) => {
+				return "default";
+			},
+			applyTalkChannelName: (ctx) => {
+				if (!ctx.name) return ctx.cfg;
+				const { config, channels, talkchannelConfig } = getKakaoTalkchannelConfig(ctx.cfg);
+				return {
+					...config,
+					channels: {
+						...channels,
+						"kakao-talkchannel": {
+							...talkchannelConfig,
+							name: ctx.name
+						}
+					}
+				};
+			},
+			validateInput: (_ctx) => {
+				return null;
+			},
+			applyTalkChannelConfig: (ctx) => {
+				const { input } = ctx;
+				const { config, channels, talkchannelConfig } = getKakaoTalkchannelConfig(ctx.cfg);
+				const accountConfig = {
+					...talkchannelConfig,
+					enabled: true,
+					dmPolicy: talkchannelConfig.dmPolicy ?? "pairing"
+				};
+				if (input.channelId) accountConfig.channelId = input.channelId;
+				if (input.relayUrl) accountConfig.relayUrl = input.relayUrl;
+				if (input.relayToken) accountConfig.relayToken = input.relayToken;
+				if (input.sessionToken) accountConfig.sessionToken = input.sessionToken;
+				if (input.name) accountConfig.name = input.name;
+				return {
+					...config,
+					channels: {
+						...channels,
+						"kakao-talkchannel": accountConfig
+					}
+				};
+			}
+		}
+	},
+	setRuntime: setKakaoRuntime
+});
+//#endregion
+export { kakao_talkchannel_default as default, getPendingPairingInfo };