@gaodefa/daocore 2026.5.51 → 2026.5.53

package/dist/sessions-history-http-CG934aaV.js

@@ -0,0 +1,430 @@
+import { a as normalizeLowercaseStringOrEmpty, c as normalizeOptionalString } from "./string-coerce-DyL154ka.js";
+import { t as createSubsystemLogger } from "./subsystem-CppbuBPw.js";
+import { i as getRuntimeConfig } from "./io-Ct2JqgbR.js";
+import { n as authorizeOperatorScopesForMethod } from "./method-scopes-Ce2SpYo5.js";
+import { t as loadSessionStore } from "./store-load-B817r-3Z.js";
+import "./sessions-4ZNlAnYc.js";
+import { n as asPositiveSafeInteger } from "./number-coercion-CgoBR0cm.js";
+import { n as onSessionTranscriptUpdate } from "./transcript-events-ClYG_P1o.js";
+import { a as readRecentSessionMessagesWithStatsAsync, l as readSessionMessagesAsync, t as attachDaoCoreTranscriptMeta } from "./session-utils.fs-CG2Uh2qt.js";
+import { a as resolveSessionTranscriptCandidates } from "./session-transcript-files.fs-Bv7kT0GX.js";
+import { f as resolveFreshestSessionEntryFromStoreKeys, m as resolveGatewaySessionStoreTarget } from "./session-utils-a8kpMSXX.js";
+import { a as sendJson, i as sendInvalidRequest, l as setSseHeaders, o as sendMethodNotAllowed } from "./http-common-BuKjxzdr.js";
+import { a as getHeader, d as resolveSharedSecretHttpOperatorScopes, n as authorizeScopedGatewayHttpRequestOrReply, r as checkGatewayHttpRequestAuth } from "./http-auth-utils-CfGXUgQ0.js";
+import "./http-utils-CQdYQoVZ.js";
+import { i as projectChatDisplayMessages, t as DEFAULT_CHAT_HISTORY_TEXT_MAX_CHARS } from "./chat-display-projection-ge8L4Z0O.js";
+import "./chat-BV-WLur6.js";
+import fs from "node:fs";
+import path from "node:path";
+//#region src/gateway/session-history-state.ts
+function resolveSessionHistoryTailReadOptions(limit) {
+	const rawWindow = Math.max(1, Math.floor(limit)) * 20 + 20;
+	return {
+		maxMessages: rawWindow,
+		maxLines: rawWindow
+	};
+}
+function resolveCursorSeq(cursor) {
+	if (!cursor) return;
+	const normalized = cursor.startsWith("seq:") ? cursor.slice(4) : cursor;
+	const value = Number.parseInt(normalized, 10);
+	return Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function toSessionHistoryMessages(messages) {
+	return messages.filter((message) => Boolean(message) && typeof message === "object" && !Array.isArray(message));
+}
+function buildPaginatedSessionHistory(params) {
+	return {
+		items: params.messages,
+		messages: params.messages,
+		hasMore: params.hasMore,
+		...params.nextCursor ? { nextCursor: params.nextCursor } : {}
+	};
+}
+function resolveMessageSeq(message) {
+	return asPositiveSafeInteger(message?.["__daocore"]?.seq);
+}
+function isMessageToolMirrorMessage(message) {
+	return message.daocoreMessageToolMirror !== void 0;
+}
+function paginateSessionMessages(messages, limit, cursor) {
+	const cursorSeq = resolveCursorSeq(cursor);
+	let endExclusive = messages.length;
+	if (typeof cursorSeq === "number") {
+		endExclusive = messages.findIndex((message, index) => {
+			const seq = resolveMessageSeq(message);
+			if (typeof seq === "number") return seq >= cursorSeq;
+			return index + 1 >= cursorSeq;
+		});
+		if (endExclusive < 0) endExclusive = messages.length;
+	}
+	const start = typeof limit === "number" && limit > 0 ? Math.max(0, endExclusive - limit) : 0;
+	const paginatedMessages = messages.slice(start, endExclusive);
+	const firstSeq = resolveMessageSeq(paginatedMessages[0]);
+	return buildPaginatedSessionHistory({
+		messages: paginatedMessages,
+		hasMore: start > 0,
+		...start > 0 && typeof firstSeq === "number" ? { nextCursor: String(firstSeq) } : {}
+	});
+}
+function buildSessionHistorySnapshot(params) {
+	const history = paginateSessionMessages(toSessionHistoryMessages(projectChatDisplayMessages(params.rawMessages, { maxChars: params.maxChars ?? 8e3 })), params.limit, params.cursor);
+	if (!params.cursor && typeof params.totalRawMessages === "number" && params.totalRawMessages > params.rawMessages.length && history.messages.length > 0) {
+		const firstSeq = resolveMessageSeq(history.messages[0]);
+		history.hasMore = true;
+		if (typeof firstSeq === "number") history.nextCursor = String(firstSeq);
+	}
+	const rawHistoryMessages = toSessionHistoryMessages(params.rawMessages);
+	return {
+		history,
+		rawTranscriptSeq: params.rawTranscriptSeq ?? resolveMessageSeq(rawHistoryMessages.at(-1)) ?? rawHistoryMessages.length
+	};
+}
+var SessionHistorySseState = class SessionHistorySseState {
+	static fromRawSnapshot(params) {
+		return new SessionHistorySseState({
+			target: params.target,
+			maxChars: params.maxChars,
+			limit: params.limit,
+			cursor: params.cursor,
+			initialRawMessages: params.rawMessages,
+			rawTranscriptSeq: params.rawTranscriptSeq,
+			totalRawMessages: params.totalRawMessages
+		});
+	}
+	constructor(params) {
+		this.target = params.target;
+		this.maxChars = params.maxChars ?? 8e3;
+		this.limit = params.limit;
+		this.cursor = params.cursor;
+		const rawSnapshot = {
+			rawMessages: params.initialRawMessages,
+			...typeof params.rawTranscriptSeq === "number" ? { rawTranscriptSeq: params.rawTranscriptSeq } : {},
+			...typeof params.totalRawMessages === "number" ? { totalRawMessages: params.totalRawMessages } : {}
+		};
+		const snapshot = buildSessionHistorySnapshot({
+			rawMessages: rawSnapshot.rawMessages,
+			maxChars: this.maxChars,
+			limit: this.limit,
+			cursor: this.cursor,
+			...typeof rawSnapshot.rawTranscriptSeq === "number" ? { rawTranscriptSeq: rawSnapshot.rawTranscriptSeq } : {},
+			...typeof rawSnapshot.totalRawMessages === "number" ? { totalRawMessages: rawSnapshot.totalRawMessages } : {}
+		});
+		this.sentHistory = snapshot.history;
+		this.rawTranscriptSeq = snapshot.rawTranscriptSeq;
+	}
+	snapshot() {
+		return this.sentHistory;
+	}
+	appendInlineMessage(update) {
+		if (this.limit !== void 0 || this.cursor !== void 0) return null;
+		const carriedSeq = asPositiveSafeInteger(update.messageSeq);
+		if (carriedSeq !== void 0) {
+			if (carriedSeq <= this.rawTranscriptSeq) return { shouldRefresh: true };
+			this.rawTranscriptSeq = carriedSeq;
+		} else this.rawTranscriptSeq += 1;
+		const nextMessage = attachDaoCoreTranscriptMeta(update.message, {
+			...typeof update.messageId === "string" ? { id: update.messageId } : {},
+			seq: this.rawTranscriptSeq
+		});
+		const projectedMessages = toSessionHistoryMessages(projectChatDisplayMessages([...this.sentHistory.messages, nextMessage], { maxChars: this.maxChars }));
+		if (projectedMessages.length > this.sentHistory.messages.length) {
+			const addedMessages = projectedMessages.slice(this.sentHistory.messages.length);
+			if (addedMessages.length > 1) {
+				this.sentHistory = buildPaginatedSessionHistory({
+					messages: projectedMessages,
+					hasMore: false
+				});
+				return { shouldRefresh: true };
+			}
+			const projectedMessage = addedMessages[0];
+			if (projectedMessage !== void 0) {
+				const emittedMessage = isMessageToolMirrorMessage(projectedMessage) || resolveMessageSeq(projectedMessage) === void 0 ? attachDaoCoreTranscriptMeta(projectedMessage, { seq: this.rawTranscriptSeq }) : projectedMessage;
+				const nextMessages = [...this.sentHistory.messages, emittedMessage];
+				this.sentHistory = buildPaginatedSessionHistory({
+					messages: nextMessages,
+					hasMore: false
+				});
+				return {
+					message: emittedMessage,
+					messageSeq: resolveMessageSeq(emittedMessage)
+				};
+			}
+		}
+		const [sanitizedMessage] = toSessionHistoryMessages(projectChatDisplayMessages([nextMessage], { maxChars: this.maxChars }));
+		if (!sanitizedMessage) {
+			if (projectedMessages.length < this.sentHistory.messages.length) {
+				this.sentHistory = buildPaginatedSessionHistory({
+					messages: projectedMessages,
+					hasMore: false
+				});
+				return { shouldRefresh: true };
+			}
+			return null;
+		}
+		if (projectedMessages.length <= this.sentHistory.messages.length) {
+			this.sentHistory = buildPaginatedSessionHistory({
+				messages: projectedMessages,
+				hasMore: false
+			});
+			return { shouldRefresh: true };
+		}
+		const projectedMessage = projectedMessages.at(-1) ?? sanitizedMessage;
+		const nextMessages = [...this.sentHistory.messages, projectedMessage];
+		this.sentHistory = buildPaginatedSessionHistory({
+			messages: nextMessages,
+			hasMore: false
+		});
+		return {
+			message: projectedMessage,
+			messageSeq: resolveMessageSeq(projectedMessage)
+		};
+	}
+	async refreshAsync() {
+		const rawSnapshot = await this.readRawSnapshotAsync();
+		const snapshot = buildSessionHistorySnapshot({
+			rawMessages: rawSnapshot.rawMessages,
+			maxChars: this.maxChars,
+			limit: this.limit,
+			cursor: this.cursor,
+			...typeof rawSnapshot.rawTranscriptSeq === "number" ? { rawTranscriptSeq: rawSnapshot.rawTranscriptSeq } : {},
+			...typeof rawSnapshot.totalRawMessages === "number" ? { totalRawMessages: rawSnapshot.totalRawMessages } : {}
+		});
+		this.rawTranscriptSeq = snapshot.rawTranscriptSeq;
+		this.sentHistory = snapshot.history;
+		return snapshot.history;
+	}
+	async readRawSnapshotAsync() {
+		if (this.cursor === void 0 && typeof this.limit === "number") {
+			const snapshot = await readRecentSessionMessagesWithStatsAsync(this.target.sessionId, this.target.storePath, this.target.sessionFile, { ...resolveSessionHistoryTailReadOptions(this.limit) });
+			return {
+				rawMessages: snapshot.messages,
+				rawTranscriptSeq: snapshot.totalMessages,
+				totalRawMessages: snapshot.totalMessages
+			};
+		}
+		return { rawMessages: await readSessionMessagesAsync(this.target.sessionId, this.target.storePath, this.target.sessionFile, {
+			mode: "full",
+			reason: "session history cursor pagination"
+		}) };
+	}
+};
+//#endregion
+//#region src/gateway/sessions-history-http.ts
+const log = createSubsystemLogger("gateway/sessions-history-sse");
+const MAX_SESSION_HISTORY_LIMIT = 1e3;
+function resolveSessionHistoryPath(req) {
+	const match = new URL(req.url ?? "/", "http://localhost").pathname.match(/^\/sessions\/([^/]+)\/history$/);
+	if (!match) return null;
+	try {
+		return normalizeOptionalString(decodeURIComponent(match[1] ?? "")) ?? null;
+	} catch {
+		return "";
+	}
+}
+function shouldStreamSse(req) {
+	return normalizeLowercaseStringOrEmpty(getHeader(req, "accept")).includes("text/event-stream");
+}
+function getRequestUrl(req) {
+	return new URL(req.url ?? "/", "http://localhost");
+}
+function resolveLimit(req) {
+	const raw = getRequestUrl(req).searchParams.get("limit");
+	if (raw == null || raw.trim() === "") return;
+	const value = Number.parseInt(raw, 10);
+	if (!Number.isFinite(value) || value < 1) return 1;
+	return Math.min(MAX_SESSION_HISTORY_LIMIT, Math.max(1, value));
+}
+function canonicalizePath(value) {
+	const trimmed = normalizeOptionalString(value);
+	if (!trimmed) return;
+	const resolved = path.resolve(trimmed);
+	try {
+		return fs.realpathSync(resolved);
+	} catch {
+		return resolved;
+	}
+}
+function sseWrite(res, event, payload) {
+	res.write(`event: ${event}\n`);
+	res.write(`data: ${JSON.stringify(payload)}\n\n`);
+}
+async function handleSessionHistoryHttpRequest(req, res, opts) {
+	const sessionKey = resolveSessionHistoryPath(req);
+	if (sessionKey === null) return false;
+	if (!sessionKey) {
+		sendInvalidRequest(res, "invalid session key");
+		return true;
+	}
+	if (req.method !== "GET") {
+		sendMethodNotAllowed(res, "GET");
+		return true;
+	}
+	const authResult = await authorizeScopedGatewayHttpRequestOrReply({
+		req,
+		res,
+		auth: opts.auth,
+		trustedProxies: opts.trustedProxies,
+		allowRealIpFallback: opts.allowRealIpFallback,
+		rateLimiter: opts.rateLimiter,
+		operatorMethod: "chat.history",
+		resolveOperatorScopes: resolveSharedSecretHttpOperatorScopes
+	});
+	if (!authResult) return true;
+	const { cfg } = authResult;
+	const target = resolveGatewaySessionStoreTarget({
+		cfg,
+		key: sessionKey
+	});
+	const entry = resolveFreshestSessionEntryFromStoreKeys(loadSessionStore(target.storePath), target.storeKeys);
+	if (!entry?.sessionId) {
+		sendJson(res, 404, {
+			ok: false,
+			error: {
+				type: "not_found",
+				message: `Session not found: ${sessionKey}`
+			}
+		});
+		return true;
+	}
+	const limit = resolveLimit(req);
+	const cursor = normalizeOptionalString(getRequestUrl(req).searchParams.get("cursor"));
+	const effectiveMaxChars = typeof cfg.gateway?.webchat?.chatHistoryMaxChars === "number" ? cfg.gateway.webchat.chatHistoryMaxChars : DEFAULT_CHAT_HISTORY_TEXT_MAX_CHARS;
+	const boundedSnapshot = cursor === void 0 && typeof limit === "number" ? await readRecentSessionMessagesWithStatsAsync(entry.sessionId, target.storePath, entry.sessionFile, resolveSessionHistoryTailReadOptions(limit)) : void 0;
+	const rawSnapshot = boundedSnapshot?.messages ?? (entry?.sessionId ? await readSessionMessagesAsync(entry.sessionId, target.storePath, entry.sessionFile, {
+		mode: "full",
+		reason: "session history cursor pagination"
+	}) : []);
+	const history = buildSessionHistorySnapshot({
+		rawMessages: rawSnapshot,
+		maxChars: effectiveMaxChars,
+		limit,
+		cursor,
+		rawTranscriptSeq: boundedSnapshot?.totalMessages,
+		totalRawMessages: boundedSnapshot?.totalMessages
+	}).history;
+	if (!shouldStreamSse(req)) {
+		sendJson(res, 200, {
+			sessionKey: target.canonicalKey,
+			...history
+		});
+		return true;
+	}
+	const transcriptCandidates = entry?.sessionId ? new Set(resolveSessionTranscriptCandidates(entry.sessionId, target.storePath, entry.sessionFile, target.agentId).map((candidate) => canonicalizePath(candidate)).filter((candidate) => typeof candidate === "string")) : /* @__PURE__ */ new Set();
+	let sentHistory = history;
+	const sseState = SessionHistorySseState.fromRawSnapshot({
+		target: {
+			sessionId: entry.sessionId,
+			storePath: target.storePath,
+			sessionFile: entry.sessionFile
+		},
+		rawMessages: rawSnapshot,
+		rawTranscriptSeq: boundedSnapshot?.totalMessages,
+		totalRawMessages: boundedSnapshot?.totalMessages,
+		maxChars: effectiveMaxChars,
+		limit,
+		cursor
+	});
+	sentHistory = sseState.snapshot();
+	setSseHeaders(res);
+	res.write("retry: 1000\n\n");
+	sseWrite(res, "history", {
+		sessionKey: target.canonicalKey,
+		...sentHistory
+	});
+	let cleanedUp = false;
+	let streamQueue = Promise.resolve();
+	let heartbeat;
+	let unsubscribe;
+	const cleanup = () => {
+		if (cleanedUp) return;
+		cleanedUp = true;
+		if (heartbeat) clearInterval(heartbeat);
+		if (unsubscribe) unsubscribe();
+	};
+	const closeStream = () => {
+		cleanup();
+		if (!res.writableEnded) res.end();
+	};
+	const queueStreamWork = (work) => {
+		streamQueue = streamQueue.then(async () => {
+			if (cleanedUp || res.writableEnded) return;
+			await work();
+		}).catch((error) => {
+			log.warn("session history SSE stream work failed; closing stream", { error });
+			closeStream();
+		});
+	};
+	const isStreamStillAuthorized = async () => {
+		const cfg = getRuntimeConfig();
+		const currentRequestAuth = await checkGatewayHttpRequestAuth({
+			req,
+			auth: opts.getResolvedAuth?.() ?? opts.auth,
+			trustedProxies: cfg.gateway?.trustedProxies,
+			allowRealIpFallback: cfg.gateway?.allowRealIpFallback,
+			rateLimiter: opts.rateLimiter,
+			cfg
+		});
+		if (!currentRequestAuth.ok) return false;
+		return authorizeOperatorScopesForMethod("chat.history", resolveSharedSecretHttpOperatorScopes(req, currentRequestAuth.requestAuth)).allowed;
+	};
+	heartbeat = setInterval(() => {
+		queueStreamWork(async () => {
+			if (!await isStreamStillAuthorized()) {
+				closeStream();
+				return;
+			}
+			if (!res.writableEnded) res.write(": keepalive\n\n");
+		});
+	}, 15e3);
+	unsubscribe = onSessionTranscriptUpdate((update) => {
+		if (!entry?.sessionId) return;
+		const updatePath = canonicalizePath(update.sessionFile);
+		if (!updatePath || !transcriptCandidates.has(updatePath)) return;
+		queueStreamWork(async () => {
+			if (res.writableEnded) return;
+			if (!await isStreamStillAuthorized()) {
+				closeStream();
+				return;
+			}
+			if (update.message !== void 0) {
+				if (limit === void 0 && cursor === void 0) {
+					const nextEvent = sseState.appendInlineMessage({
+						message: update.message,
+						messageId: update.messageId,
+						messageSeq: update.messageSeq
+					});
+					if (!nextEvent) return;
+					if (nextEvent.shouldRefresh) {
+						sentHistory = await sseState.refreshAsync();
+						sseWrite(res, "history", {
+							sessionKey: target.canonicalKey,
+							...sentHistory
+						});
+						return;
+					}
+					if (nextEvent.message === void 0) return;
+					sentHistory = sseState.snapshot();
+					sseWrite(res, "message", {
+						sessionKey: target.canonicalKey,
+						message: nextEvent.message,
+						...typeof update.messageId === "string" ? { messageId: update.messageId } : {},
+						messageSeq: nextEvent.messageSeq
+					});
+					return;
+				}
+			}
+			sentHistory = await sseState.refreshAsync();
+			sseWrite(res, "history", {
+				sessionKey: target.canonicalKey,
+				...sentHistory
+			});
+		});
+	});
+	req.on("close", cleanup);
+	res.on("close", cleanup);
+	res.on("finish", cleanup);
+	return true;
+}
+//#endregion
+export { handleSessionHistoryHttpRequest };

package/dist/sessions.runtime-Cl91aZ2M.js

@@ -0,0 +1,2 @@
+import { a as emitGatewaySessionEndPluginHook, c as performGatewaySessionReset, i as emitGatewayBeforeResetPluginHook, n as cleanupSessionBeforeMutation, o as emitGatewaySessionStartPluginHook, s as emitSessionUnboundLifecycleEvent, t as archiveSessionTranscriptsForSessionDetailed } from "./session-reset-service-Bw6li9Te.js";
+export { archiveSessionTranscriptsForSessionDetailed, cleanupSessionBeforeMutation, emitGatewayBeforeResetPluginHook, emitGatewaySessionEndPluginHook, emitGatewaySessionStartPluginHook, emitSessionUnboundLifecycleEvent, performGatewaySessionReset };

package/dist/sessions.runtime.js

@@ -1 +1 @@
-export * from "./sessions.runtime-CTD1EISY.js";
+export * from "./sessions.runtime-Cl91aZ2M.js";

package/dist/setup-api-DAqXqbGP.js

@@ -0,0 +1,29 @@
+import { r as loadBundledEntryExportSync } from "./channel-entry-contract-BGOdyVAr.js";
+import "./setup-core-Czt7XqlN.js";
+//#region extensions/zalo/setup-api.ts
+function createLazyObjectValue(load) {
+	return new Proxy({}, {
+		get(_target, property, receiver) {
+			return Reflect.get(load(), property, receiver);
+		},
+		has(_target, property) {
+			return property in load();
+		},
+		ownKeys() {
+			return Reflect.ownKeys(load());
+		},
+		getOwnPropertyDescriptor(_target, property) {
+			const descriptor = Object.getOwnPropertyDescriptor(load(), property);
+			return descriptor ? {
+				...descriptor,
+				configurable: true
+			} : void 0;
+		}
+	});
+}
+function loadSetupSurfaceModule() {
+	return loadBundledEntryExportSync(import.meta.url, { specifier: "./src/setup-surface.js" });
+}
+const zaloSetupWizard = createLazyObjectValue(() => loadSetupSurfaceModule().zaloSetupWizard);
+//#endregion
+export { zaloSetupWizard as t };

package/dist/setup-core-Czt7XqlN.js

@@ -0,0 +1,174 @@
+import { t as formatDocsLink } from "./links-CM5vg8_V.js";
+import { n as normalizeAccountId } from "./account-id-B32J-iNN.js";
+import { a as createSetupInputPresenceValidator, i as createPatchedAccountSetupAdapter } from "./setup-helpers-BC9z9VvG.js";
+import { t as createSetupTranslator } from "./i18n-Bm-nunfC.js";
+import { t as addWildcardAllowFrom, v as mergeAllowFromEntries } from "./setup-wizard-helpers-DXfnYF4t.js";
+import { a as createDelegatedSetupWizardProxy } from "./setup-wizard-proxy-D4lRbJrw.js";
+import "./setup-Bk8ieh5V.js";
+import { i as resolveZaloAccount, r as resolveDefaultZaloAccountId } from "./accounts-DdAZRSd-.js";
+//#region extensions/zalo/src/setup-allow-from.ts
+const t$1 = createSetupTranslator();
+async function noteZaloTokenHelp(prompter) {
+	await prompter.note([
+		t$1("wizard.zalo.helpOpenPlatform"),
+		t$1("wizard.zalo.helpCreateBot"),
+		t$1("wizard.zalo.helpTokenFormat"),
+		t$1("wizard.zalo.helpEnvTip"),
+		`Docs: ${formatDocsLink("/channels/zalo", "zalo")}`
+	].join("\n"), t$1("wizard.zalo.botTokenTitle"));
+}
+async function promptZaloAllowFrom(params) {
+	const { cfg, prompter } = params;
+	const accountId = params.accountId ?? resolveDefaultZaloAccountId(cfg);
+	const existingAllowFrom = resolveZaloAccount({
+		cfg,
+		accountId
+	}).config.allowFrom ?? [];
+	const unique = mergeAllowFromEntries(existingAllowFrom, [(await prompter.text({
+		message: t$1("wizard.zalo.allowFromPrompt"),
+		placeholder: "123456789",
+		initialValue: existingAllowFrom[0] ? String(existingAllowFrom[0]) : void 0,
+		validate: (value) => {
+			const raw = (value ?? "").trim();
+			if (!raw) return t$1("common.required");
+			if (!/^\d+$/.test(raw)) return t$1("wizard.zalo.allowFromNumeric");
+		}
+	})).trim()]);
+	if (accountId === "default") return {
+		...cfg,
+		channels: {
+			...cfg.channels,
+			zalo: {
+				...cfg.channels?.zalo,
+				enabled: true,
+				dmPolicy: "allowlist",
+				allowFrom: unique
+			}
+		}
+	};
+	const currentAccount = cfg.channels?.zalo?.accounts?.[accountId];
+	return {
+		...cfg,
+		channels: {
+			...cfg.channels,
+			zalo: {
+				...cfg.channels?.zalo,
+				enabled: true,
+				accounts: {
+					...cfg.channels?.zalo?.accounts,
+					[accountId]: {
+						...currentAccount,
+						enabled: currentAccount?.enabled ?? true,
+						dmPolicy: "allowlist",
+						allowFrom: unique
+					}
+				}
+			}
+		}
+	};
+}
+//#endregion
+//#region extensions/zalo/src/setup-core.ts
+const t = createSetupTranslator();
+const channel = "zalo";
+const zaloSetupAdapter = createPatchedAccountSetupAdapter({
+	channelKey: channel,
+	validateInput: createSetupInputPresenceValidator({
+		defaultAccountOnlyEnvError: "ZALO_BOT_TOKEN can only be used for the default account.",
+		whenNotUseEnv: [{
+			someOf: ["token", "tokenFile"],
+			message: "Zalo requires token or --token-file (or --use-env)."
+		}]
+	}),
+	buildPatch: (input) => input.useEnv ? {} : input.tokenFile ? { tokenFile: input.tokenFile } : input.token ? { botToken: input.token } : {}
+});
+const zaloDmPolicy = {
+	label: "Zalo",
+	channel,
+	policyKey: "channels.zalo.dmPolicy",
+	allowFromKey: "channels.zalo.allowFrom",
+	resolveConfigKeys: (cfg, accountId) => (accountId ?? resolveDefaultZaloAccountId(cfg)) !== "default" ? {
+		policyKey: `channels.zalo.accounts.${accountId ?? resolveDefaultZaloAccountId(cfg)}.dmPolicy`,
+		allowFromKey: `channels.zalo.accounts.${accountId ?? resolveDefaultZaloAccountId(cfg)}.allowFrom`
+	} : {
+		policyKey: "channels.zalo.dmPolicy",
+		allowFromKey: "channels.zalo.allowFrom"
+	},
+	getCurrent: (cfg, accountId) => resolveZaloAccount({
+		cfg,
+		accountId: accountId ?? resolveDefaultZaloAccountId(cfg)
+	}).config.dmPolicy ?? "pairing",
+	setPolicy: (cfg, policy, accountId) => {
+		const resolvedAccountId = accountId && normalizeAccountId(accountId) ? normalizeAccountId(accountId) ?? "default" : resolveDefaultZaloAccountId(cfg);
+		const resolved = resolveZaloAccount({
+			cfg,
+			accountId: resolvedAccountId
+		});
+		if (resolvedAccountId === "default") return {
+			...cfg,
+			channels: {
+				...cfg.channels,
+				zalo: {
+					...cfg.channels?.zalo,
+					enabled: true,
+					dmPolicy: policy,
+					...policy === "open" ? { allowFrom: addWildcardAllowFrom(resolved.config.allowFrom) } : {}
+				}
+			}
+		};
+		const currentAccount = cfg.channels?.zalo?.accounts?.[resolvedAccountId];
+		return {
+			...cfg,
+			channels: {
+				...cfg.channels,
+				zalo: {
+					...cfg.channels?.zalo,
+					enabled: true,
+					accounts: {
+						...cfg.channels?.zalo?.accounts,
+						[resolvedAccountId]: {
+							...currentAccount,
+							enabled: currentAccount?.enabled ?? true,
+							dmPolicy: policy,
+							...policy === "open" ? { allowFrom: addWildcardAllowFrom(resolved.config.allowFrom) } : {}
+						}
+					}
+				}
+			}
+		};
+	},
+	promptAllowFrom: async ({ cfg, prompter, accountId }) => promptZaloAllowFrom({
+		cfg,
+		prompter,
+		accountId: accountId ?? resolveDefaultZaloAccountId(cfg)
+	})
+};
+function createZaloSetupWizardProxy(loadWizard) {
+	return createDelegatedSetupWizardProxy({
+		channel,
+		loadWizard,
+		status: {
+			configuredLabel: t("wizard.channels.statusConfigured"),
+			unconfiguredLabel: t("wizard.channels.statusNeedsToken"),
+			configuredHint: t("wizard.channels.statusRecommendedConfigured"),
+			unconfiguredHint: t("wizard.channels.statusRecommendedNewcomerFriendly"),
+			configuredScore: 1,
+			unconfiguredScore: 10
+		},
+		credentials: [],
+		delegateFinalize: true,
+		dmPolicy: zaloDmPolicy,
+		disable: (cfg) => ({
+			...cfg,
+			channels: {
+				...cfg.channels,
+				zalo: {
+					...cfg.channels?.zalo,
+					enabled: false
+				}
+			}
+		})
+	});
+}
+//#endregion
+export { promptZaloAllowFrom as a, noteZaloTokenHelp as i, zaloDmPolicy as n, zaloSetupAdapter as r, createZaloSetupWizardProxy as t };