@vibe-lark/larkpal 0.1.86 → 0.1.87

package/dist/image-2w3cApg7-CxpHvoB5.mjs

@@ -1,207 +0,0 @@
-import { d as resolveProviderRequestCapabilities } from "./io-CH2g3vsv-BOGlLlB8.mjs";
-import { n as requireApiKey, r as normalizeModelRef, t as ensureOpenClawModelsJson } from "./models-config-BmpSQJQF-Gfvh1n3A.mjs";
-import { s as complete } from "./oauth-DOJeGfcE.mjs";
-import { a as minimaxUnderstandImage, c as getApiKeyForModel, i as isMinimaxVlmModel, l as resolveApiKeyForProvider, n as coerceImageAssistantText, r as hasImageReasoningOnlyResponse, t as registerProviderStreamForModel } from "./provider-stream-COLujAAo-CbJPDngm.mjs";
-//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/image-2w3cApg7.js
-let piModelDiscoveryRuntimePromise = null;
-function loadPiModelDiscoveryRuntime() {
-	piModelDiscoveryRuntimePromise ??= import("./pi-model-discovery-runtime-CCCZxkd8.mjs");
-	return piModelDiscoveryRuntimePromise;
-}
-function resolveImageToolMaxTokens(modelMaxTokens, requestedMaxTokens = 4096) {
-	if (typeof modelMaxTokens !== "number" || !Number.isFinite(modelMaxTokens) || modelMaxTokens <= 0) return requestedMaxTokens;
-	return Math.min(requestedMaxTokens, modelMaxTokens);
-}
-function isRecord(value) {
-	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function isNativeResponsesReasoningPayload(model) {
-	if (model.api !== "openai-responses" && model.api !== "azure-openai-responses" && model.api !== "openai-codex-responses") return false;
-	return resolveProviderRequestCapabilities({
-		provider: model.provider,
-		api: model.api,
-		baseUrl: model.baseUrl,
-		capability: "image",
-		transport: "media-understanding"
-	}).usesKnownNativeOpenAIRoute;
-}
-function removeReasoningInclude(value) {
-	if (!Array.isArray(value)) return value;
-	const next = value.filter((entry) => entry !== "reasoning.encrypted_content");
-	return next.length > 0 ? next : void 0;
-}
-function disableReasoningForImageRetryPayload(payload, model) {
-	if (!isRecord(payload)) return;
-	const next = { ...payload };
-	delete next.reasoning;
-	delete next.reasoning_effort;
-	const include = removeReasoningInclude(next.include);
-	if (include === void 0) delete next.include;
-	else next.include = include;
-	if (isNativeResponsesReasoningPayload(model)) next.reasoning = { effort: "none" };
-	return next;
-}
-function isImageModelNoTextError(err) {
-	return err instanceof Error && /^Image model returned no text\b/.test(err.message);
-}
-async function resolveImageRuntime(params) {
-	await ensureOpenClawModelsJson(params.cfg, params.agentDir);
-	const { discoverAuthStorage, discoverModels } = await loadPiModelDiscoveryRuntime();
-	const authStorage = discoverAuthStorage(params.agentDir);
-	const modelRegistry = discoverModels(authStorage, params.agentDir);
-	const resolvedRef = normalizeModelRef(params.provider, params.model);
-	const model = modelRegistry.find(resolvedRef.provider, resolvedRef.model);
-	if (!model) throw new Error(`Unknown model: ${resolvedRef.provider}/${resolvedRef.model}`);
-	if (!model.input?.includes("image")) throw new Error(`Model does not support images: ${params.provider}/${params.model}`);
-	const apiKey = requireApiKey(await getApiKeyForModel({
-		model,
-		cfg: params.cfg,
-		agentDir: params.agentDir,
-		profileId: params.profile,
-		preferredProfile: params.preferredProfile,
-		store: params.authStore
-	}), model.provider);
-	authStorage.setRuntimeApiKey(model.provider, apiKey);
-	return {
-		apiKey,
-		model
-	};
-}
-function buildImageContext(prompt, images) {
-	return {
-		systemPrompt: prompt,
-		messages: [{
-			role: "user",
-			content: images.map((image) => ({
-				type: "image",
-				data: image.buffer.toString("base64"),
-				mimeType: image.mime ?? "image/jpeg"
-			})),
-			timestamp: Date.now()
-		}]
-	};
-}
-async function describeImagesWithMinimax(params) {
-	const responses = [];
-	for (const [index, image] of params.images.entries()) {
-		const prompt = params.images.length > 1 ? `${params.prompt}\n\nDescribe image ${index + 1} of ${params.images.length} independently.` : params.prompt;
-		const text = await minimaxUnderstandImage({
-			apiKey: params.apiKey,
-			prompt,
-			imageDataUrl: `data:${image.mime ?? "image/jpeg"};base64,${image.buffer.toString("base64")}`,
-			modelBaseUrl: params.modelBaseUrl
-		});
-		responses.push(params.images.length > 1 ? `Image ${index + 1}:\n${text.trim()}` : text.trim());
-	}
-	return {
-		text: responses.join("\n\n").trim(),
-		model: params.modelId
-	};
-}
-function isUnknownModelError(err) {
-	return err instanceof Error && /^Unknown model:/i.test(err.message);
-}
-function resolveConfiguredProviderBaseUrl(cfg, provider) {
-	const direct = cfg.models?.providers?.[provider];
-	if (typeof direct?.baseUrl === "string" && direct.baseUrl.trim()) return direct.baseUrl.trim();
-}
-async function resolveMinimaxVlmFallbackRuntime(params) {
-	return {
-		apiKey: requireApiKey(await resolveApiKeyForProvider({
-			provider: params.provider,
-			cfg: params.cfg,
-			profileId: params.profile,
-			preferredProfile: params.preferredProfile,
-			agentDir: params.agentDir
-		}), params.provider),
-		modelBaseUrl: resolveConfiguredProviderBaseUrl(params.cfg, params.provider)
-	};
-}
-async function describeImagesWithModel(params) {
-	const prompt = params.prompt ?? "Describe the image.";
-	let apiKey;
-	let model;
-	try {
-		const resolved = await resolveImageRuntime(params);
-		apiKey = resolved.apiKey;
-		model = resolved.model;
-	} catch (err) {
-		if (!isMinimaxVlmModel(params.provider, params.model) || !isUnknownModelError(err)) throw err;
-		const fallback = await resolveMinimaxVlmFallbackRuntime(params);
-		return await describeImagesWithMinimax({
-			apiKey: fallback.apiKey,
-			modelId: params.model,
-			modelBaseUrl: fallback.modelBaseUrl,
-			prompt,
-			images: params.images
-		});
-	}
-	if (isMinimaxVlmModel(model.provider, model.id)) return await describeImagesWithMinimax({
-		apiKey,
-		modelId: model.id,
-		modelBaseUrl: model.baseUrl,
-		prompt,
-		images: params.images
-	});
-	registerProviderStreamForModel({
-		model,
-		cfg: params.cfg,
-		agentDir: params.agentDir
-	});
-	const context = buildImageContext(prompt, params.images);
-	const controller = new AbortController();
-	const timeout = typeof params.timeoutMs === "number" && Number.isFinite(params.timeoutMs) && params.timeoutMs > 0 ? setTimeout(() => controller.abort(), params.timeoutMs) : void 0;
-	const maxTokens = resolveImageToolMaxTokens(model.maxTokens, params.maxTokens ?? 512);
-	const completeImage = async (onPayload) => await complete(model, context, {
-		apiKey,
-		maxTokens,
-		signal: controller.signal,
-		...onPayload ? { onPayload } : {}
-	});
-	try {
-		const message = await completeImage();
-		try {
-			return {
-				text: coerceImageAssistantText({
-					message,
-					provider: model.provider,
-					model: model.id
-				}),
-				model: model.id
-			};
-		} catch (err) {
-			if (!isImageModelNoTextError(err) || !hasImageReasoningOnlyResponse(message)) throw err;
-		}
-		return {
-			text: coerceImageAssistantText({
-				message: await completeImage(disableReasoningForImageRetryPayload),
-				provider: model.provider,
-				model: model.id
-			}),
-			model: model.id
-		};
-	} finally {
-		clearTimeout(timeout);
-	}
-}
-async function describeImageWithModel(params) {
-	return await describeImagesWithModel({
-		images: [{
-			buffer: params.buffer,
-			fileName: params.fileName,
-			mime: params.mime
-		}],
-		model: params.model,
-		provider: params.provider,
-		prompt: params.prompt,
-		maxTokens: params.maxTokens,
-		timeoutMs: params.timeoutMs,
-		profile: params.profile,
-		preferredProfile: params.preferredProfile,
-		authStore: params.authStore,
-		agentDir: params.agentDir,
-		cfg: params.cfg
-	});
-}
-//#endregion
-export { describeImageWithModel, describeImagesWithModel };

package/dist/interactive-init-BXQBalNr.mjs

@@ -1,450 +0,0 @@
-import { t as larkLogger } from "./lark-logger-D7_pEVQc.mjs";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { homedir } from "node:os";
-import { execSync, spawn } from "node:child_process";
-import { createInterface } from "node:readline";
-import * as Lark from "@larksuiteoapi/node-sdk";
-import qrcodeTerminal from "qrcode-terminal";
-//#region src/credentials/app-registration.ts
-async function registerFeishuAppCredentials(options) {
-	const result = await (options.registerApp ?? defaultRegisterApp)({
-		source: options.source ?? "larkpal",
-		signal: options.signal,
-		onQRCodeReady: options.onQRCodeReady,
-		onStatusChange: options.onStatusChange
-	});
-	if (!result.client_id || !result.client_secret) throw new Error("飞书应用创建完成但未返回 App ID 或 App Secret");
-	await options.saveCredentials({
-		appId: result.client_id,
-		appSecret: result.client_secret
-	});
-	return {
-		appId: result.client_id,
-		appSecret: result.client_secret,
-		creatorOpenId: result.user_info?.open_id,
-		tenantBrand: result.user_info?.tenant_brand
-	};
-}
-async function defaultRegisterApp(options) {
-	return Lark.registerApp(options);
-}
-//#endregion
-//#region src/init/landing-presentation.ts
-function renderFeishuAppCreationQRCode(input) {
-	return [
-		"  请扫码创建飞书智能体应用，或打开下面的链接：",
-		"",
-		renderQRCodeOrFallback(input.url, input.createQRCode ?? createQRCode),
-		`  ${input.url}`,
-		`  链接有效期 ${input.expireIn} 秒。`
-	].join("\n");
-}
-function formatRuntimeSelectionSummary(runtimeName) {
-	switch (runtimeName) {
-		case "codex-app-server": return [
-			"已选择 Codex app-server 作为 agent runtime。",
-			"启动前请确保 Codex CLI 可用：codex",
-			"启动配置：LARKPAL_RUNTIME=codex-app-server"
-		].join("\n");
-		case "larkpal-agent": return [
-			"已选择 larkpal-agent 作为 agent runtime。",
-			"启动前请配置 larkpal-agent 所需的 LLM 和 scenario provider 环境变量。",
-			"启动配置：LARKPAL_RUNTIME=larkpal-agent"
-		].join("\n");
-		case "claude-code": return [
-			"已选择 Claude Code 作为 agent runtime。",
-			"启动前请确保 Claude Code CLI 可用：claude",
-			"启动配置：LARKPAL_RUNTIME=claude-code"
-		].join("\n");
-	}
-}
-function renderRuntimeSelectionPrompt(currentRuntime) {
-	return [
-		"Agent runtime 选择",
-		"",
-		`  [1] Claude Code (claude-code)${currentRuntime === "claude-code" ? "（当前）" : ""}`,
-		`  [2] Codex app-server (codex-app-server)${currentRuntime === "codex-app-server" ? "（当前）" : ""}`,
-		`  [3] larkpal-agent${currentRuntime === "larkpal-agent" ? "（当前）" : ""}`
-	].join("\n");
-}
-function resolveRuntimeSelection(choice, currentRuntime) {
-	const normalized = choice.trim().toLowerCase();
-	if (!normalized) return currentRuntime;
-	if (normalized === "1" || normalized === "claude" || normalized === "claude-code") return "claude-code";
-	if (normalized === "2" || normalized === "codex" || normalized === "codex-app-server") return "codex-app-server";
-	if (normalized === "3" || normalized === "larkpal-agent") return "larkpal-agent";
-	return currentRuntime;
-}
-function createQRCode(url) {
-	let qrCode = "";
-	qrcodeTerminal.setErrorLevel("L");
-	qrcodeTerminal.generate(url, { small: true }, (code) => {
-		qrCode = code;
-	});
-	return qrCode.trimEnd();
-}
-function renderQRCodeOrFallback(url, renderer) {
-	try {
-		return renderer(url).trimEnd() || "  [二维码渲染失败，请使用下方链接]";
-	} catch {
-		return "  [二维码渲染失败，请使用下方链接]";
-	}
-}
-//#endregion
-//#region src/init/prerequisites.ts
-function assessInitPrerequisites(deps) {
-	const larkCli = deps.detectCli("lark-cli");
-	const runtimeCliName = resolveRuntimeCliName(deps.runtimeName);
-	const runtimeCli = runtimeCliName ? deps.detectCli(runtimeCliName) : { installed: true };
-	const warnings = [];
-	if (runtimeCliName && !runtimeCli.installed) warnings.push(runtimeCliName === "codex" ? "OpenAI Codex CLI is not installed. Feishu app credentials can still be configured now, but service startup with LARKPAL_RUNTIME=codex-app-server will require codex later." : "Claude Code is not installed. Feishu app credentials can still be configured now, but service startup with the default runtime will require Claude Code later.");
-	if (!larkCli.installed) warnings.push("lark-cli is not installed. Basic Feishu bot chat can be configured with app credentials, but execution-layer tools for documents, calendars, mail, tasks, and personal data will require lark-cli later.");
-	return {
-		canConfigureFeishuCredentials: true,
-		larkCli: {
-			...larkCli,
-			ready: larkCli.installed,
-			requiredForBasicChat: false
-		},
-		runtime: {
-			...runtimeCli,
-			ready: runtimeCli.installed,
-			name: deps.runtimeName,
-			cliName: runtimeCliName ?? deps.runtimeName
-		},
-		warnings
-	};
-}
-function resolveRuntimeCliName(runtimeName) {
-	if (runtimeName === "codex-app-server") return "codex";
-	if (runtimeName === "larkpal-agent") return void 0;
-	return "claude";
-}
-//#endregion
-//#region src/init/interactive-init.ts
-/**
-* 交互式初始化流程
-*
-* 引导用户完成 LarkPal 首次配置：
-*   Step 1: 检查前置依赖（claude、lark-cli）
-*   Step 2: 配置飞书应用凭证（lark-cli config init + 补充 App Secret）
-*   Step 3: 打印成功信息
-*
-* 仅使用 Node.js 内置模块，不依赖第三方包。
-*/
-const log = larkLogger("init");
-const CYAN = "\x1B[36m";
-const GREEN = "\x1B[32m";
-const YELLOW = "\x1B[33m";
-const RED = "\x1B[31m";
-const BOLD = "\x1B[1m";
-const DIM = "\x1B[2m";
-const RESET = "\x1B[0m";
-/** LarkPal 自身配置目录 */
-const LARKPAL_CONFIG_DIR = join(homedir(), ".larkpal");
-/** LarkPal 凭证文件（存储 appId + appSecret） */
-const LARKPAL_CREDENTIALS_PATH = join(LARKPAL_CONFIG_DIR, "credentials.json");
-/** readline 问答封装 */
-function ask(rl, question) {
-	return new Promise((resolve) => {
-		rl.question(question, (answer) => resolve(answer.trim()));
-	});
-}
-/** 检测 CLI 工具是否已安装 */
-function isCliInstalled(name) {
-	try {
-		return !!execSync(`which ${name}`, {
-			encoding: "utf-8",
-			timeout: 5e3
-		}).trim();
-	} catch {
-		return false;
-	}
-}
-/** 通过 lark-cli config show 获取当前配置的 appId */
-function getAppIdFromLarkCli() {
-	try {
-		const jsonMatch = execSync("lark-cli config show", {
-			encoding: "utf-8",
-			timeout: 1e4,
-			stdio: [
-				"pipe",
-				"pipe",
-				"pipe"
-			]
-		}).match(/\{[\s\S]*\}/);
-		if (jsonMatch) return JSON.parse(jsonMatch[0]).appId || null;
-	} catch {}
-	return null;
-}
-/** 写入凭证到 LarkPal 配置文件 */
-function writeCredentials(appId, appSecret) {
-	try {
-		if (!existsSync(LARKPAL_CONFIG_DIR)) {
-			mkdirSync(LARKPAL_CONFIG_DIR, { recursive: true });
-			log.info("创建 LarkPal 配置目录", { path: LARKPAL_CONFIG_DIR });
-		}
-		writeFileSync(LARKPAL_CREDENTIALS_PATH, JSON.stringify({
-			app_id: appId,
-			app_secret: appSecret
-		}, null, 2) + "\n", {
-			encoding: "utf-8",
-			mode: 384
-		});
-		log.info("凭证已写入", {
-			path: LARKPAL_CREDENTIALS_PATH,
-			appId
-		});
-		return true;
-	} catch (err) {
-		const msg = err instanceof Error ? err.message : String(err);
-		log.error("写入凭证文件失败", {
-			path: LARKPAL_CREDENTIALS_PATH,
-			error: msg
-		});
-		return false;
-	}
-}
-async function saveCredentialsOrThrow(credentials) {
-	if (!writeCredentials(credentials.appId, credentials.appSecret)) throw new Error("凭证保存失败");
-}
-/** 检查 LarkPal 凭证文件是否已有有效凭证 */
-function hasLarkPalCredentials() {
-	if (!existsSync(LARKPAL_CREDENTIALS_PATH)) return null;
-	try {
-		const raw = readFileSync(LARKPAL_CREDENTIALS_PATH, "utf-8");
-		const creds = JSON.parse(raw);
-		if (creds.app_id && creds.app_secret) return {
-			appId: creds.app_id,
-			appSecret: creds.app_secret
-		};
-	} catch {}
-	return null;
-}
-function checkPrerequisites(runtimeName) {
-	console.log(`\n${BOLD}🔍 检查前置依赖${RESET}\n`);
-	const assessment = assessInitPrerequisites({
-		runtimeName,
-		detectCli: (name) => ({ installed: isCliInstalled(name) })
-	});
-	if (assessment.runtime.ready) console.log(`  ${GREEN}✅ ${assessment.runtime.cliName} 已安装${RESET}`);
-	else console.log(`  ${YELLOW}⚠️  ${assessment.runtime.cliName} 未安装${RESET}`);
-	if (assessment.larkCli.ready) console.log(`  ${GREEN}✅ lark-cli 已安装${RESET}`);
-	else console.log(`  ${YELLOW}⚠️  lark-cli 未安装（基础飞书连接不阻塞）${RESET}`);
-	for (const warning of assessment.warnings) console.log(`  ${DIM}${warning}${RESET}`);
-	console.log();
-}
-async function configureRuntime(rl) {
-	const currentRuntime = resolveConfiguredRuntime(process.env.LARKPAL_RUNTIME);
-	console.log(`\n${BOLD}🤖 Agent runtime 配置${RESET}\n`);
-	console.log(renderRuntimeSelectionPrompt(currentRuntime));
-	console.log();
-	const selectedRuntime = resolveRuntimeSelection(await ask(rl, `  请选择 [1/2/3]（默认当前）: `), currentRuntime);
-	process.env.LARKPAL_RUNTIME = selectedRuntime;
-	console.log(`\n${formatRuntimeSelectionSummary(selectedRuntime)}\n`);
-	log.info("用户选择 agent runtime", { runtimeName: selectedRuntime });
-	return selectedRuntime;
-}
-/**
-* 通过 lark-cli config init 子进程配置凭证。
-* 返回解析到的 appId（成功）或 null（失败）。
-*/
-function runLarkCliConfigInit() {
-	return new Promise((resolve) => {
-		console.log(`\n${DIM}正在启动 lark-cli config init ...${RESET}\n`);
-		log.info("启动子进程: lark-cli config init");
-		let capturedOutput = "";
-		const child = spawn("lark-cli", ["config", "init"], { stdio: [
-			"inherit",
-			"pipe",
-			"pipe"
-		] });
-		child.stdout?.on("data", (chunk) => {
-			const text = chunk.toString();
-			capturedOutput += text;
-			process.stdout.write(text);
-		});
-		child.stderr?.on("data", (chunk) => {
-			const text = chunk.toString();
-			capturedOutput += text;
-			process.stderr.write(text);
-		});
-		child.on("error", (err) => {
-			log.error("lark-cli config init 启动失败", { error: err.message });
-			console.log(`\n${RED}启动 lark-cli config init 失败: ${err.message}${RESET}`);
-			resolve(null);
-		});
-		child.on("close", (code) => {
-			log.info("lark-cli config init 执行完毕", {
-				exitCode: code,
-				output: capturedOutput.substring(0, 500)
-			});
-			if (code === 0) {
-				let appId = capturedOutput.match(/App\s*ID:\s*(\S+)/i)?.[1] || null;
-				if (!appId) appId = getAppIdFromLarkCli();
-				if (appId) {
-					log.info("lark-cli config init 成功", { appId });
-					console.log(`\n${GREEN}✅ 飞书应用创建成功${RESET} ${DIM}(App ID: ${appId})${RESET}`);
-				} else console.log(`\n${GREEN}✅ lark-cli config init 完成${RESET}`);
-				resolve(appId);
-			} else {
-				console.log(`\n${YELLOW}⚠️  lark-cli config init 退出码: ${code}${RESET}`);
-				resolve(null);
-			}
-		});
-	});
-}
-/**
-* 提示用户输入 App Secret 并保存到 LarkPal 凭证文件。
-*
-* lark-cli 新版使用 master key 加密存储 secret，LarkPal 无法直接读取。
-* 需要用户从飞书开放平台复制 App Secret 并输入。
-*/
-async function promptAppSecret(rl, appId) {
-	console.log(`\n${BOLD}🔑 输入 App Secret${RESET}\n`);
-	console.log(`  ${DIM}lark-cli 已完成应用配置，但 LarkPal 还需要 App Secret 来启动服务。${RESET}`);
-	console.log(`  ${DIM}请在飞书开放平台的应用管理页面（凭证与基础信息）中复制 App Secret：${RESET}\n`);
-	console.log(`    ${CYAN}https://open.feishu.cn/app/${appId}${RESET}\n`);
-	const appSecret = await ask(rl, `  App Secret: `);
-	if (!appSecret) {
-		console.log(`\n${RED}App Secret 不能为空${RESET}`);
-		return false;
-	}
-	if (writeCredentials(appId, appSecret)) {
-		console.log(`\n${GREEN}✅ 凭证已保存${RESET} ${DIM}(${LARKPAL_CREDENTIALS_PATH})${RESET}`);
-		return true;
-	}
-	console.log(`\n${RED}凭证保存失败${RESET}`);
-	return false;
-}
-/** 手动输入完整凭证（App ID + App Secret） */
-async function manualCredentialInput(rl) {
-	console.log(`\n${BOLD}📝 手动输入飞书应用凭证${RESET}\n`);
-	console.log(`  ${DIM}你可以在飞书开放平台 (https://open.feishu.cn) 的应用管理页面找到这些信息。${RESET}\n`);
-	const appId = await ask(rl, `  App ID: `);
-	if (!appId) {
-		console.log(`\n${RED}App ID 不能为空${RESET}`);
-		return false;
-	}
-	const appSecret = await ask(rl, `  App Secret: `);
-	if (!appSecret) {
-		console.log(`\n${RED}App Secret 不能为空${RESET}`);
-		return false;
-	}
-	if (writeCredentials(appId, appSecret)) {
-		console.log(`\n${GREEN}✅ 凭证已保存${RESET} ${DIM}(${LARKPAL_CREDENTIALS_PATH})${RESET}`);
-		return true;
-	}
-	console.log(`\n${RED}凭证保存失败${RESET}`);
-	return false;
-}
-async function scanCreateAppCredentials() {
-	console.log(`\n${BOLD}📱 扫码创建飞书智能体应用${RESET}\n`);
-	console.log(`  LarkPal 会通过飞书官方一键创建应用能力获取 App ID 和 App Secret。`);
-	console.log(`  ${DIM}这一步只配置应用凭据；个人日历、文档、邮件等能力后续通过 lark-cli auth login 授权。${RESET}\n`);
-	try {
-		const result = await registerFeishuAppCredentials({
-			saveCredentials: saveCredentialsOrThrow,
-			onQRCodeReady: ({ url, expireIn }) => {
-				console.log(renderFeishuAppCreationQRCode({
-					url,
-					expireIn
-				}));
-				console.log();
-			},
-			onStatusChange: ({ status }) => {
-				if (status === "polling") console.log(`  ${DIM}等待飞书确认中...${RESET}`);
-				else if (status === "slow_down") console.log(`  ${DIM}飞书要求降低轮询频率，继续等待...${RESET}`);
-				else if (status === "domain_switched") console.log(`  ${DIM}已根据租户切换认证域名，继续等待...${RESET}`);
-			},
-			source: "larkpal-init"
-		});
-		console.log(`\n${GREEN}✅ 飞书应用创建并保存成功${RESET} ${DIM}(App ID: ${result.appId})${RESET}`);
-		return true;
-	} catch (err) {
-		console.log(`\n${RED}扫码创建飞书应用失败: ${err instanceof Error ? err.message : String(err)}${RESET}`);
-		return false;
-	}
-}
-async function configureCredentials(rl) {
-	if (process.env.LARK_APP_ID && process.env.LARK_APP_SECRET) {
-		console.log(`${GREEN}✅ 飞书应用凭证已通过环境变量配置${RESET}`);
-		log.info("凭证已通过环境变量配置");
-		return true;
-	}
-	const existing = hasLarkPalCredentials();
-	if (existing) {
-		console.log(`${GREEN}✅ 飞书应用凭证已配置${RESET} ${DIM}(App ID: ${existing.appId})${RESET}`);
-		log.info("LarkPal 凭证文件已存在", { appId: existing.appId });
-		return true;
-	}
-	const existingAppId = getAppIdFromLarkCli();
-	if (existingAppId) {
-		console.log(`${GREEN}✅ 飞书应用已配置${RESET} ${DIM}(App ID: ${existingAppId})${RESET}`);
-		console.log(`\n  ${YELLOW}但 LarkPal 还需要 App Secret 才能启动。${RESET}`);
-		return promptAppSecret(rl, existingAppId);
-	}
-	console.log(`${BOLD}📋 飞书应用配置${RESET}\n`);
-	console.log(`  LarkPal 需要飞书应用凭据才能进入飞书会话。推荐使用飞书官方扫码创建应用能力：\n`);
-	console.log(`  ${DIM}[1] 扫码创建飞书智能体应用（推荐）${RESET}`);
-	console.log(`  ${DIM}[2] 手动输入 App ID 和 App Secret${RESET}`);
-	console.log(`  ${DIM}[3] 使用 lark-cli config init（兼容旧流程）${RESET}\n`);
-	const choice = await ask(rl, `  请选择 [1/2/3]（默认 1）: `);
-	const option = choice === "2" ? 2 : choice === "3" ? 3 : 1;
-	log.info("用户选择凭证配置方式", { option });
-	if (option === 1) {
-		if (await scanCreateAppCredentials()) return true;
-		console.log(`\n  ${YELLOW}扫码创建未完成，是否手动输入凭证？${RESET}`);
-		if ((await ask(rl, `  手动输入？ [y/N]: `)).toLowerCase() === "y") return manualCredentialInput(rl);
-		return false;
-	}
-	if (option === 3) {
-		const appId = await runLarkCliConfigInit();
-		if (appId) return promptAppSecret(rl, appId);
-		console.log(`\n  ${YELLOW}lark-cli 配置未成功，是否手动输入凭证？${RESET}`);
-		if ((await ask(rl, `  手动输入？ [y/N]: `)).toLowerCase() === "y") return manualCredentialInput(rl);
-		return false;
-	}
-	return manualCredentialInput(rl);
-}
-/**
-* 执行交互式初始化流程。
-*
-* @returns 0 成功，1 失败
-*/
-async function runInteractiveInit() {
-	console.log(`\n${BOLD}${CYAN}╔══════════════════════════════════════╗${RESET}`);
-	console.log(`${BOLD}${CYAN}║         LarkPal 初始化向导           ║${RESET}`);
-	console.log(`${BOLD}${CYAN}╚══════════════════════════════════════╝${RESET}\n`);
-	log.info("开始交互式初始化流程");
-	const rl = createInterface({
-		input: process.stdin,
-		output: process.stdout
-	});
-	let credentialsOk;
-	let selectedRuntime;
-	try {
-		selectedRuntime = await configureRuntime(rl);
-		checkPrerequisites(selectedRuntime);
-		credentialsOk = await configureCredentials(rl);
-	} finally {
-		rl.close();
-	}
-	if (!credentialsOk) {
-		console.log(`\n${RED}凭证配置未完成。你可以稍后运行 ${CYAN}larkpal init${RED} 重新配置。${RESET}\n`);
-		return 1;
-	}
-	console.log(`\n${BOLD}${GREEN}🎉 初始化完成！${RESET}\n`);
-	console.log(`  ${DIM}下一步:${RESET}`);
-	console.log(`    ${formatRuntimeSelectionSummary(selectedRuntime)}`);
-	console.log(`    运行 ${CYAN}larkpal${RESET} 启动服务\n`);
-	log.info("交互式初始化流程完成");
-	return 0;
-}
-function resolveConfiguredRuntime(value) {
-	if (value === "codex-app-server" || value === "larkpal-agent" || value === "claude-code") return value;
-	return "claude-code";
-}
-//#endregion
-export { runInteractiveInit };