@openclaw/feishu 2026.7.2-beta.7 → 2026.7.34

package/dist/accounts-u9X5Wsan.js

@@ -1,469 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { isRecord, normalizeOptionalString, normalizeStringEntries, readStringValue } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { DEFAULT_ACCOUNT_ID, createAccountListHelpers, hasConfiguredAccountValue, normalizeAccountId, normalizeOptionalAccountId } from "openclaw/plugin-sdk/account-resolution";
-import { coerceSecretRef } from "openclaw/plugin-sdk/provider-auth";
-import { retryAsync } from "openclaw/plugin-sdk/retry-runtime";
-//#region extensions/feishu/src/comment-target.ts
-const FEISHU_COMMENT_FILE_TYPES = [
-	"doc",
-	"docx",
-	"file",
-	"sheet",
-	"slides"
-];
-function normalizeCommentFileType(value) {
-	return typeof value === "string" && FEISHU_COMMENT_FILE_TYPES.includes(value) ? value : void 0;
-}
-function buildFeishuCommentTarget(params) {
-	return `comment:${params.fileType}:${params.fileToken}:${params.commentId}`;
-}
-function parseFeishuCommentTarget(raw) {
-	const trimmed = raw?.trim();
-	if (!trimmed?.startsWith("comment:")) return null;
-	const parts = trimmed.split(":");
-	if (parts.length !== 4) return null;
-	const fileType = normalizeCommentFileType(parts[1]);
-	const fileToken = parts[2]?.trim();
-	const commentId = parts[3]?.trim();
-	if (!fileType || !fileToken || !commentId) return null;
-	return {
-		fileType,
-		fileToken,
-		commentId
-	};
-}
-//#endregion
-//#region extensions/feishu/src/send-rate-limit.ts
-const FEISHU_SEND_RATE_LIMIT_CODES = /* @__PURE__ */ new Set([230020, 11232]);
-function getFeishuSendRateLimitCode(error) {
-	if (!isRecord(error)) return;
-	const response = isRecord(error.response) ? error.response : void 0;
-	if (response?.status === 429) return 429;
-	const code = (isRecord(response?.data) ? response.data : void 0)?.code;
-	return typeof code === "number" && FEISHU_SEND_RATE_LIMIT_CODES.has(code) ? code : void 0;
-}
-function getFeishuSendRateLimitCodeFromResponse(response) {
-	if (!isRecord(response)) return;
-	const code = response.code;
-	return typeof code === "number" && FEISHU_SEND_RATE_LIMIT_CODES.has(code) ? code : void 0;
-}
-//#endregion
-//#region extensions/feishu/src/comment-shared.ts
-function encodeQuery(params) {
-	const query = new URLSearchParams();
-	for (const [key, value] of Object.entries(params)) {
-		const trimmed = value?.trim();
-		if (trimmed) query.set(key, trimmed);
-	}
-	const queryString = query.toString();
-	return queryString ? `?${queryString}` : "";
-}
-const readString = readStringValue;
-const normalizeString = normalizeOptionalString;
-const isRecord$1 = isRecord;
-function formatFeishuApiError(error, options = {}) {
-	if (!isRecord$1(error)) return typeof error === "string" ? error : JSON.stringify(error);
-	const config = isRecord$1(error.config) ? error.config : void 0;
-	const response = isRecord$1(error.response) ? error.response : void 0;
-	const responseData = isRecord$1(response?.data) ? response?.data : void 0;
-	const feishuLogId = readString(responseData?.log_id) || (options.includeNestedErrorLogId ? readString(isRecord$1(responseData?.error) ? responseData.error.log_id : void 0) : void 0);
-	const nestedError = isRecord$1(responseData?.error) ? responseData.error : void 0;
-	return JSON.stringify({
-		message: typeof error.message === "string" ? error.message : typeof error === "string" ? error : JSON.stringify(error),
-		code: readString(error.code),
-		method: readString(config?.method),
-		url: readString(config?.url),
-		...options.includeConfigParams ? { params: config?.params } : {},
-		http_status: typeof response?.status === "number" ? response.status : void 0,
-		feishu_code: typeof responseData?.code === "number" ? responseData.code : readString(responseData?.code),
-		feishu_msg: readString(responseData?.msg),
-		feishu_log_id: feishuLogId,
-		feishu_troubleshooter: readString(responseData?.troubleshooter) || readString(nestedError?.troubleshooter)
-	});
-}
-function formatFeishuApiFailure(error, errorPrefix, options = {}) {
-	return `${errorPrefix}: ${formatFeishuApiError(error, options) || "unknown error"}`;
-}
-function createFeishuApiError(error, errorPrefix, options = {}) {
-	return new Error(formatFeishuApiFailure(error, errorPrefix, options), { cause: error });
-}
-const FEISHU_SEND_RETRY_BASE_MS = 500;
-async function requestFeishuApi(request, errorPrefix, options = {}) {
-	try {
-		return await retryAsync(async () => {
-			const result = await request();
-			const fulfilledRateLimit = getFeishuSendRateLimitCodeFromResponse(result);
-			if (fulfilledRateLimit !== void 0) throw Object.assign(/* @__PURE__ */ new Error(`Request fulfilled with rate-limit code ${fulfilledRateLimit}`), { response: {
-				status: 200,
-				data: result
-			} });
-			return result;
-		}, {
-			attempts: 3,
-			minDelayMs: options.retryDelayMs ?? FEISHU_SEND_RETRY_BASE_MS,
-			shouldRetry: (error) => getFeishuSendRateLimitCode(error) !== void 0
-		});
-	} catch (error) {
-		throw createFeishuApiError(error, errorPrefix, options);
-	}
-}
-function readDocsLinkUrl(element) {
-	const docsLink = isRecord$1(element.docs_link) ? element.docs_link : void 0;
-	return normalizeString(docsLink?.url) || normalizeString(docsLink?.link) || normalizeString(element.url) || normalizeString(element.link) || void 0;
-}
-function readMentionUserId(element) {
-	const mention = isRecord$1(element.mention) ? element.mention : void 0;
-	const person = isRecord$1(element.person) ? element.person : void 0;
-	return normalizeString(person?.user_id) || normalizeString(mention?.user_id) || normalizeString(mention?.open_id) || normalizeString(element.mention_user) || normalizeString(element.user_id) || void 0;
-}
-function readMentionDisplayText(element, userId) {
-	const mention = isRecord$1(element.mention) ? element.mention : void 0;
-	const mentionName = normalizeString(mention?.name) || normalizeString(mention?.display_name) || normalizeString(element.name);
-	return mentionName ? `@${mentionName}` : `@${userId}`;
-}
-function normalizeCommentText(parts) {
-	return parts.join("").trim() || void 0;
-}
-function normalizeCommentSemanticText(parts) {
-	return parts.join("").replace(/\s+/g, " ").trim() || void 0;
-}
-function readElementTextPreservingWhitespace(element) {
-	return (isRecord$1(element.text_run) ? readString(element.text_run.content) || readString(element.text_run.text) : void 0) || readString(element.text) || readString(element.content) || readString(element.name) || void 0;
-}
-const FEISHU_LINK_TOKEN_MIN_LENGTH = 22;
-const FEISHU_LINK_TOKEN_MAX_LENGTH = 28;
-const COMMENT_LINK_KIND_ALIASES = /* @__PURE__ */ new Map([
-	["doc", "doc"],
-	["docs", "doc"],
-	["docx", "docx"],
-	["sheet", "sheet"],
-	["sheets", "sheet"],
-	["slide", "slides"],
-	["slides", "slides"],
-	["file", "file"],
-	["files", "file"],
-	["wiki", "wiki"],
-	["mindnote", "mindnote"],
-	["mindnotes", "mindnote"],
-	["bitable", "bitable"],
-	["base", "base"]
-]);
-function isCommentFileType(value) {
-	return typeof value === "string" && FEISHU_COMMENT_FILE_TYPES.includes(value);
-}
-function isReasonableFeishuLinkToken(token) {
-	return typeof token === "string" && token.length >= FEISHU_LINK_TOKEN_MIN_LENGTH && token.length <= FEISHU_LINK_TOKEN_MAX_LENGTH;
-}
-function parseCommentLinkedDocumentPath(pathname) {
-	const segments = normalizeStringEntries(pathname.split("/"));
-	const offset = segments[0]?.toLowerCase() === "space" ? 1 : 0;
-	const kind = COMMENT_LINK_KIND_ALIASES.get(segments[offset]?.toLowerCase() ?? "");
-	const token = normalizeString(segments[offset + 1]);
-	if (!kind || !isReasonableFeishuLinkToken(token)) return null;
-	return {
-		urlKind: kind,
-		token
-	};
-}
-function hasResolvedLinkedDocumentReference(link) {
-	return link.urlKind !== "unknown" && (Boolean(link.resolvedObjToken) || Boolean(link.wikiNodeToken));
-}
-function resolveCommentLinkedDocumentFromUrl(params) {
-	const link = {
-		rawUrl: params.rawUrl,
-		urlKind: "unknown"
-	};
-	try {
-		const parsedPath = parseCommentLinkedDocumentPath(new URL(params.rawUrl).pathname);
-		if (!parsedPath) return link;
-		const { urlKind, token } = parsedPath;
-		link.urlKind = urlKind;
-		if (urlKind === "wiki") {
-			link.urlKind = "wiki";
-			link.wikiNodeToken = token;
-		} else {
-			link.resolvedObjType = urlKind;
-			link.resolvedObjToken = token;
-		}
-		if (link.resolvedObjType && link.resolvedObjToken && isCommentFileType(link.resolvedObjType) && params.currentDocument?.fileType === link.resolvedObjType && params.currentDocument.fileToken === link.resolvedObjToken) link.isCurrentDocument = true;
-		else if (link.resolvedObjType && link.resolvedObjToken && isCommentFileType(link.resolvedObjType)) link.isCurrentDocument = false;
-	} catch {
-		return link;
-	}
-	return link;
-}
-function parseCommentContentElements(params) {
-	const elements = Array.isArray(params.elements) ? params.elements : [];
-	const plainTextParts = [];
-	const semanticTextParts = [];
-	const mentions = [];
-	const linkedDocuments = [];
-	const botIds = new Set(Array.from(params.botOpenIds ?? []).map((value) => normalizeString(value)).filter((value) => Boolean(value)));
-	const linkedDocumentKeys = /* @__PURE__ */ new Set();
-	let botMentioned = false;
-	for (const rawElement of elements) {
-		if (!isRecord$1(rawElement)) continue;
-		const element = rawElement;
-		const type = normalizeString(element.type);
-		const text = (type === "text_run" ? readElementTextPreservingWhitespace(element) : void 0) || (type === "text" ? readElementTextPreservingWhitespace(element) : void 0) || (type === "docs_link" || type === "link" ? readDocsLinkUrl(element) : void 0) || (type === "mention" || type === "mention_user" || type === "person" ? (() => {
-			const userId = readMentionUserId(element);
-			return userId ? readMentionDisplayText(element, userId) : void 0;
-		})() : void 0) || readElementTextPreservingWhitespace(element) || void 0;
-		if (type === "mention" || type === "mention_user" || type === "person") {
-			const userId = readMentionUserId(element);
-			if (userId) {
-				const displayText = readMentionDisplayText(element, userId);
-				const isBotMention = botIds.has(userId);
-				mentions.push({
-					userId,
-					displayText,
-					isBotMention
-				});
-				plainTextParts.push(displayText);
-				if (!isBotMention) semanticTextParts.push(displayText);
-				else botMentioned = true;
-				continue;
-			}
-		}
-		if (type === "docs_link" || type === "link") {
-			const rawUrl = readDocsLinkUrl(element);
-			if (rawUrl) {
-				plainTextParts.push(rawUrl);
-				semanticTextParts.push(rawUrl);
-				const linkedDocument = resolveCommentLinkedDocumentFromUrl({
-					rawUrl,
-					currentDocument: params.currentDocument
-				});
-				if (hasResolvedLinkedDocumentReference(linkedDocument)) {
-					const key = [
-						linkedDocument.rawUrl,
-						linkedDocument.urlKind,
-						linkedDocument.resolvedObjType,
-						linkedDocument.resolvedObjToken,
-						linkedDocument.wikiNodeToken
-					].join(":");
-					if (!linkedDocumentKeys.has(key)) {
-						linkedDocumentKeys.add(key);
-						linkedDocuments.push(linkedDocument);
-					}
-				}
-				continue;
-			}
-		}
-		if (text) {
-			plainTextParts.push(text);
-			semanticTextParts.push(text);
-		}
-	}
-	return {
-		plainText: normalizeCommentText(plainTextParts),
-		semanticText: normalizeCommentSemanticText(semanticTextParts),
-		mentions,
-		linkedDocuments,
-		botMentioned
-	};
-}
-function extractReplyText(reply) {
-	if (!reply || !isRecord$1(reply.content)) return;
-	return parseCommentContentElements({ elements: Array.isArray(reply.content.elements) ? reply.content.elements : [] }).plainText;
-}
-//#endregion
-//#region extensions/feishu/src/accounts.ts
-var accounts_exports = /* @__PURE__ */ __exportAll({
-	FeishuSecretRefUnavailableError: () => FeishuSecretRefUnavailableError,
-	inspectFeishuCredentials: () => inspectFeishuCredentials,
-	listEnabledFeishuAccounts: () => listEnabledFeishuAccounts,
-	listFeishuAccountIds: () => listFeishuAccountIds,
-	resolveDefaultFeishuAccountId: () => resolveDefaultFeishuAccountId,
-	resolveDefaultFeishuAccountSelection: () => resolveDefaultFeishuAccountSelection,
-	resolveFeishuAccount: () => resolveFeishuAccount,
-	resolveFeishuCredentials: () => resolveFeishuCredentials,
-	resolveFeishuRuntimeAccount: () => resolveFeishuRuntimeAccount
-});
-const { listAccountIds: listFeishuAccountIds, resolveDefaultAccountId, resolveAccountConfig: resolveMergedFeishuAccountConfig } = createAccountListHelpers("feishu", {
-	allowUnlistedDefaultAccount: true,
-	omitKeys: ["defaultAccount"],
-	nestedObjectKeys: ["tools"],
-	hasImplicitDefaultAccount: (cfg) => {
-		const feishu = cfg.channels?.feishu;
-		return hasConfiguredAccountValue(feishu?.appId) && hasConfiguredAccountValue(feishu?.appSecret);
-	}
-});
-function formatSecretRefLabel(ref) {
-	return `${ref.source}:${ref.provider}:${ref.id}`;
-}
-var FeishuSecretRefUnavailableError = class extends Error {
-	constructor(path, ref) {
-		super(`${path}: unresolved SecretRef "${formatSecretRefLabel(ref)}". Resolve this command against an active gateway runtime snapshot before reading it.`);
-		this.name = "FeishuSecretRefUnavailableError";
-		this.path = path;
-	}
-};
-function resolveFeishuSecretLike(params) {
-	const asString = normalizeString(params.value);
-	if (asString) return asString;
-	const ref = coerceSecretRef(params.value);
-	if (!ref) return;
-	if (params.mode === "inspect") {
-		if (params.allowEnvSecretRefRead && ref.source === "env") {
-			const envValue = normalizeString(process.env[ref.id]);
-			if (envValue) return envValue;
-		}
-		return;
-	}
-	throw new FeishuSecretRefUnavailableError(params.path, ref);
-}
-function resolveFeishuBaseCredentials(cfg, mode) {
-	const appId = resolveFeishuSecretLike({
-		value: cfg?.appId,
-		path: "channels.feishu.appId",
-		mode,
-		allowEnvSecretRefRead: true
-	});
-	const appSecret = resolveFeishuSecretLike({
-		value: cfg?.appSecret,
-		path: "channels.feishu.appSecret",
-		mode,
-		allowEnvSecretRefRead: true
-	});
-	if (!appId || !appSecret) return null;
-	return {
-		appId,
-		appSecret,
-		domain: cfg?.domain ?? "feishu"
-	};
-}
-function resolveFeishuEventSecrets(cfg, mode) {
-	return {
-		encryptKey: (cfg?.connectionMode ?? "websocket") === "webhook" ? resolveFeishuSecretLike({
-			value: cfg?.encryptKey,
-			path: "channels.feishu.encryptKey",
-			mode,
-			allowEnvSecretRefRead: true
-		}) : normalizeString(cfg?.encryptKey),
-		verificationToken: resolveFeishuSecretLike({
-			value: cfg?.verificationToken,
-			path: "channels.feishu.verificationToken",
-			mode,
-			allowEnvSecretRefRead: true
-		})
-	};
-}
-/**
-* Resolve the default account selection and its source.
-*/
-function resolveDefaultFeishuAccountSelection(cfg) {
-	const preferred = normalizeOptionalAccountId((cfg.channels?.feishu)?.defaultAccount);
-	if (preferred) return {
-		accountId: preferred,
-		source: "explicit-default"
-	};
-	const ids = listFeishuAccountIds(cfg);
-	if (ids.includes(DEFAULT_ACCOUNT_ID)) return {
-		accountId: DEFAULT_ACCOUNT_ID,
-		source: "mapped-default"
-	};
-	return {
-		accountId: ids[0] ?? DEFAULT_ACCOUNT_ID,
-		source: "fallback"
-	};
-}
-/**
-* Resolve the default account ID.
-*/
-function resolveDefaultFeishuAccountId(cfg) {
-	return resolveDefaultAccountId(cfg);
-}
-/**
-* Merge top-level config with account-specific config.
-* Account-specific fields override top-level fields.
-*/
-function mergeFeishuAccountConfig(cfg, accountId) {
-	const feishuCfg = cfg.channels?.feishu;
-	const merged = resolveMergedFeishuAccountConfig(cfg, accountId);
-	const topTools = feishuCfg?.tools;
-	if (merged.tools === void 0 && topTools !== void 0) return {
-		...merged,
-		tools: topTools
-	};
-	if (topTools?.bitable === false) return {
-		...merged,
-		tools: {
-			...merged.tools,
-			bitable: false
-		}
-	};
-	return merged;
-}
-function resolveFeishuCredentials(cfg, options) {
-	const mode = options?.mode ?? (options?.allowUnresolvedSecretRef ? "inspect" : "strict");
-	const base = resolveFeishuBaseCredentials(cfg, mode);
-	if (!base) return null;
-	const eventSecrets = resolveFeishuEventSecrets(cfg, mode);
-	return {
-		...base,
-		...eventSecrets
-	};
-}
-function inspectFeishuCredentials(cfg) {
-	return resolveFeishuCredentials(cfg, { mode: "inspect" });
-}
-function buildResolvedFeishuAccount(params) {
-	const hasExplicitAccountId = typeof params.accountId === "string" && params.accountId.trim() !== "";
-	const defaultSelection = hasExplicitAccountId ? null : resolveDefaultFeishuAccountSelection(params.cfg);
-	const accountId = hasExplicitAccountId ? normalizeAccountId(params.accountId) : defaultSelection?.accountId ?? DEFAULT_ACCOUNT_ID;
-	const selectionSource = hasExplicitAccountId ? "explicit" : defaultSelection?.source ?? "fallback";
-	const baseEnabled = (params.cfg.channels?.feishu)?.enabled !== false;
-	const merged = mergeFeishuAccountConfig(params.cfg, accountId);
-	const accountEnabled = merged.enabled !== false;
-	const enabled = baseEnabled && accountEnabled;
-	const baseCreds = resolveFeishuBaseCredentials(merged, params.baseMode);
-	const eventSecrets = resolveFeishuEventSecrets(merged, params.eventSecretMode);
-	const accountName = merged.name;
-	return {
-		accountId,
-		selectionSource,
-		enabled,
-		configured: Boolean(baseCreds),
-		name: typeof accountName === "string" ? accountName.trim() || void 0 : void 0,
-		appId: baseCreds?.appId,
-		appSecret: baseCreds?.appSecret,
-		encryptKey: eventSecrets.encryptKey,
-		verificationToken: eventSecrets.verificationToken,
-		domain: baseCreds?.domain ?? "feishu",
-		config: merged
-	};
-}
-/**
-* Resolve a read-only Feishu account snapshot for CLI/config surfaces.
-* Unresolved SecretRefs are treated as unavailable instead of throwing.
-*/
-function resolveFeishuAccount(params) {
-	return buildResolvedFeishuAccount({
-		...params,
-		baseMode: "inspect",
-		eventSecretMode: "inspect"
-	});
-}
-/**
-* Resolve a runtime Feishu account.
-* Required app credentials stay strict; event-only secrets can be required by callers.
-*/
-function resolveFeishuRuntimeAccount(params, options) {
-	return buildResolvedFeishuAccount({
-		...params,
-		baseMode: "strict",
-		eventSecretMode: options?.requireEventSecrets ? "strict" : "inspect"
-	});
-}
-/**
-* List all enabled and configured accounts.
-*/
-function listEnabledFeishuAccounts(cfg) {
-	return listFeishuAccountIds(cfg).map((accountId) => resolveFeishuAccount({
-		cfg,
-		accountId
-	})).filter((account) => account.enabled && account.configured);
-}
-//#endregion
-export { normalizeCommentFileType as _, resolveDefaultFeishuAccountId as a, encodeQuery as c, isRecord$1 as d, normalizeString as f, buildFeishuCommentTarget as g, requestFeishuApi as h, listFeishuAccountIds as i, extractReplyText as l, readString as m, inspectFeishuCredentials as n, resolveFeishuAccount as o, parseCommentContentElements as p, listEnabledFeishuAccounts as r, resolveFeishuRuntimeAccount as s, accounts_exports as t, formatFeishuApiError as u, parseFeishuCommentTarget as v };

package/dist/app-registration-cN1bVV6s.js

@@ -1,201 +0,0 @@
-import { t as readFeishuJsonResponse } from "./json-response-CheljwGr.js";
-import { finiteSecondsToTimerSafeMilliseconds } from "openclaw/plugin-sdk/number-runtime";
-import { renderQrTerminal } from "openclaw/plugin-sdk/media-runtime";
-import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
-import { fetchWithSsrFGuard } from "openclaw/plugin-sdk/ssrf-runtime";
-//#region extensions/feishu/src/app-registration.ts
-/**
-* Feishu app registration via OAuth device-code flow.
-*
-* Migrated from feishu-plugin-cli's `feishu-auth.ts` and `install-prompts.ts`.
-* Replaces axios with native fetch, removes inquirer/ora/chalk in favor of
-* the openclaw WizardPrompter surface.
-*/
-const FEISHU_ACCOUNTS_URL = "https://accounts.feishu.cn";
-const LARK_ACCOUNTS_URL = "https://accounts.larksuite.com";
-const REGISTRATION_PATH = "/oauth/v1/app/registration";
-const APP_REGISTRATION_REQUEST_TIMEOUT_MS = 1e4;
-const DEFAULT_REGISTRATION_POLL_INTERVAL_SECONDS = 5;
-const DEFAULT_REGISTRATION_EXPIRE_SECONDS = 600;
-function accountsBaseUrl(domain) {
-	return domain === "lark" ? LARK_ACCOUNTS_URL : FEISHU_ACCOUNTS_URL;
-}
-async function postRegistration(baseUrl, body, options) {
-	return await fetchFeishuJson({
-		url: `${baseUrl}${REGISTRATION_PATH}`,
-		init: {
-			method: "POST",
-			headers: { "Content-Type": "application/x-www-form-urlencoded" },
-			body: new URLSearchParams(body).toString()
-		},
-		auditContext: "feishu.app-registration.post",
-		fetchImpl: options?.fetchImpl,
-		lookupFn: options?.lookupFn,
-		timeoutMs: options?.timeoutMs
-	});
-}
-async function fetchFeishuJson(params) {
-	const timeoutMs = params.timeoutMs ?? APP_REGISTRATION_REQUEST_TIMEOUT_MS;
-	const { response, release } = await fetchWithSsrFGuard({
-		url: params.url,
-		init: params.init,
-		fetchImpl: params.fetchImpl,
-		lookupFn: params.lookupFn,
-		timeoutMs,
-		policy: { allowedHostnames: [new URL(params.url).hostname] },
-		auditContext: params.auditContext
-	});
-	try {
-		return await readFeishuJsonResponse(response);
-	} finally {
-		await release();
-	}
-}
-/**
-* Step 1: Initialize registration and verify the environment supports
-* `client_secret` auth.
-*
-* @throws If the environment does not support `client_secret`.
-*/
-async function initAppRegistration(domain = "feishu", options) {
-	if (!(await postRegistration(accountsBaseUrl(domain), { action: "init" }, options)).supported_auth_methods?.includes("client_secret")) throw new Error("Current environment does not support client_secret auth method");
-}
-/**
-* Step 2: Begin the device-code flow. Returns a device code and a QR URL
-* that the user should scan with Feishu/Lark mobile app.
-*/
-async function beginAppRegistration(domain = "feishu", options) {
-	const res = await postRegistration(accountsBaseUrl(domain), {
-		action: "begin",
-		archetype: "PersonalAgent",
-		auth_method: "client_secret",
-		request_user_info: "open_id"
-	}, options);
-	const qrUrl = new URL(res.verification_uri_complete);
-	qrUrl.searchParams.set("from", "oc_onboard");
-	qrUrl.searchParams.set("tp", "ob_cli_app");
-	return {
-		deviceCode: res.device_code,
-		qrUrl: qrUrl.toString(),
-		userCode: res.user_code,
-		interval: finiteSecondsToTimerSafeMilliseconds(res.interval) === void 0 ? DEFAULT_REGISTRATION_POLL_INTERVAL_SECONDS : res.interval,
-		expireIn: finiteSecondsToTimerSafeMilliseconds(res.expire_in) === void 0 ? DEFAULT_REGISTRATION_EXPIRE_SECONDS : res.expire_in
-	};
-}
-/**
-* Step 3: Poll for authorization result until success, denial, expiry, or
-* timeout. Automatically handles domain switching when `tenant_brand` is
-* detected as "lark".
-*/
-async function pollAppRegistration(params) {
-	const { deviceCode, expireIn, initialDomain = "feishu", abortSignal, tp, fetchImpl, lookupFn } = params;
-	let currentInterval = params.interval;
-	let domain = initialDomain;
-	let domainSwitched = false;
-	const expireInMs = finiteSecondsToTimerSafeMilliseconds(expireIn) ?? DEFAULT_REGISTRATION_EXPIRE_SECONDS * 1e3;
-	const deadline = Date.now() + expireInMs;
-	while (Date.now() < deadline) {
-		if (abortSignal?.aborted) return { status: "timeout" };
-		const baseUrl = accountsBaseUrl(domain);
-		let pollRes;
-		try {
-			pollRes = await postRegistration(baseUrl, {
-				action: "poll",
-				device_code: deviceCode,
-				...tp ? { tp } : {}
-			}, {
-				fetchImpl,
-				lookupFn
-			});
-		} catch {
-			await sleepRegistrationPollInterval(currentInterval, abortSignal);
-			continue;
-		}
-		if (pollRes.user_info?.tenant_brand) {
-			const isLark = pollRes.user_info.tenant_brand === "lark";
-			if (!domainSwitched && isLark) {
-				domain = "lark";
-				domainSwitched = true;
-				continue;
-			}
-		}
-		if (pollRes.client_id && pollRes.client_secret) return {
-			status: "success",
-			result: {
-				appId: pollRes.client_id,
-				appSecret: pollRes.client_secret,
-				domain,
-				openId: pollRes.user_info?.open_id
-			}
-		};
-		if (pollRes.error) if (pollRes.error === "authorization_pending") {} else if (pollRes.error === "slow_down") currentInterval += 5;
-		else if (pollRes.error === "access_denied") return { status: "access_denied" };
-		else if (pollRes.error === "expired_token") return { status: "expired" };
-		else return {
-			status: "error",
-			message: `${pollRes.error}: ${pollRes.error_description ?? "unknown"}`
-		};
-		await sleepRegistrationPollInterval(currentInterval, abortSignal);
-	}
-	return { status: "timeout" };
-}
-/**
-* Print QR code directly to stdout.
-*
-* QR codes must be printed without any surrounding box/border decoration,
-* otherwise the pattern is corrupted and cannot be scanned.
-*/
-async function printQrCode(url) {
-	const output = await renderQrTerminal(url, { small: true });
-	process.stdout.write(output.endsWith("\n") ? output : `${output}\n`);
-}
-/**
-* Fetch the app owner's open_id using the application.v6.application.get API.
-*
-* Used during setup to auto-populate security policy allowlists.
-* Returns undefined on any failure (fail-open).
-*/
-async function getAppOwnerOpenId(params) {
-	const baseUrl = params.domain === "lark" ? "https://open.larksuite.com" : "https://open.feishu.cn";
-	try {
-		const tokenData = await fetchFeishuJson({
-			url: `${baseUrl}/open-apis/auth/v3/tenant_access_token/internal`,
-			init: {
-				method: "POST",
-				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify({
-					app_id: params.appId,
-					app_secret: params.appSecret
-				})
-			},
-			auditContext: "feishu.app-registration.owner-token",
-			fetchImpl: params.fetchImpl,
-			lookupFn: params.lookupFn
-		});
-		if (!tokenData.tenant_access_token) return;
-		const appData = await fetchFeishuJson({
-			url: `${baseUrl}/open-apis/application/v6/applications/${params.appId}?user_id_type=open_id`,
-			init: {
-				method: "GET",
-				headers: {
-					Authorization: `Bearer ${tokenData.tenant_access_token}`,
-					"Content-Type": "application/json"
-				}
-			},
-			auditContext: "feishu.app-registration.owner-app",
-			fetchImpl: params.fetchImpl,
-			lookupFn: params.lookupFn
-		});
-		if (appData.code !== 0) return;
-		const app = appData.data?.app;
-		const owner = app?.owner;
-		return (owner?.owner_type ?? owner?.type) === 2 && owner?.owner_id ? owner.owner_id : app?.creator_id ?? owner?.owner_id;
-	} catch {
-		return;
-	}
-}
-async function sleepRegistrationPollInterval(intervalSeconds, abortSignal) {
-	await sleepWithAbort(finiteSecondsToTimerSafeMilliseconds(intervalSeconds) ?? DEFAULT_REGISTRATION_POLL_INTERVAL_SECONDS * 1e3, abortSignal).catch(() => {});
-}
-//#endregion
-export { beginAppRegistration, getAppOwnerOpenId, initAppRegistration, pollAppRegistration, printQrCode };