pi-model-manager 0.1.0

package/tui/header-profiles-panel.ts

@@ -0,0 +1,307 @@
+// tui/header-profiles-panel.ts
+//
+// 管理可复用的客户端请求头。接入编辑器只选择已存在的请求头，
+// 不在模型内部新增一次性 JSON，避免配置分散。
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { formatUnknownError, parseStringRecordJson } from "../common.ts";
+import { deleteRequestHeaderProfileConfiguration, saveRequestHeaderProfileConfiguration } from "../header-profile-mutations.ts";
+import { CLAUDE_CODE_CLIENT_HEADERS, CODEX_CLI_CLIENT_HEADERS } from "../presets/builtin-client-headers.ts";
+import {
+	countModelsUsingRequestHeaderProfile,
+	createRequestHeaderProfileDraft,
+	createRequestHeaderProfileDraftFromStored,
+	validateRequestHeaderProfileDraft,
+} from "../state-document.ts";
+import { readState } from "../state-store.ts";
+import type { RequestHeaderProfileDraft, StoredClientHeaderCapture, StoredRequestHeaderProfile } from "../types.ts";
+import { padLabel, showPersistentFormMenu, showPersistentShortcutMenu, type MenuCursor } from "./persistent-menu.ts";
+
+interface ProfileRow {
+	profileId: string;
+	label: string;
+}
+
+interface FieldRow {
+	id: string;
+	label: string;
+	value: string;
+}
+
+interface HeaderTemplate {
+	id: string;
+	label: string;
+	description: string;
+	headers: Record<string, string>;
+}
+
+const HEADER_TEMPLATES: HeaderTemplate[] = [
+	{
+		id: "codex-cli",
+		label: "Codex",
+		description: "OpenAI 兼容端点使用的终端 Codex TUI 请求头。",
+		headers: CODEX_CLI_CLIENT_HEADERS,
+	},
+	{
+		id: "claude-code",
+		label: "ClaudeCode",
+		description: "Anthropic 兼容端点常用的 ClaudeCode 请求头。",
+		headers: CLAUDE_CODE_CLIENT_HEADERS,
+	},
+	{
+		id: "empty",
+		label: "清空",
+		description: "清空当前请求头，重新手动填写。",
+		headers: {},
+	},
+];
+
+function buildRows(profileIds: string[]): ProfileRow[] {
+	return profileIds.map((profileId) => ({ profileId, label: "" }));
+}
+
+function formatCapturedAt(capturedAt: string): string {
+	return capturedAt.replace("T", " ").replace(/\.\d{3}Z$/, "Z").slice(0, 19);
+}
+
+function formatCaptureLine(label: string, capture: StoredClientHeaderCapture | undefined): string {
+	if (!capture) return `  ${padLabel(label, 12)} 未抓包`;
+	return `  ${padLabel(label, 12)} 已抓包 ${formatCapturedAt(capture.capturedAt)} · ${Object.keys(capture.headers).length} headers`;
+}
+
+function formatProfileRow(profileId: string, profile: StoredRequestHeaderProfile, usedCount: number): string {
+	return `${padLabel(profileId, 22)} ${padLabel(`${Object.keys(profile.headers).length} headers`, 12)} ${padLabel(`${usedCount} models`, 10)} ${profile.name}`.trimEnd();
+}
+
+function formatProfileDetailLines(profileId: string, profile: StoredRequestHeaderProfile, usedCount: number): string[] {
+	const headerNames = Object.keys(profile.headers);
+	const preview = headerNames.length > 0
+		? headerNames.slice(0, 6).join(", ") + (headerNames.length > 6 ? ", ..." : "")
+		: "<empty>";
+	return [
+		`${profile.name} (${profileId})`,
+		`  usage     ${usedCount} models`,
+		`  headers   ${preview}`,
+	];
+}
+
+function buildEditorRows(draft: RequestHeaderProfileDraft): FieldRow[] {
+	return [
+		{ id: "profileId", label: "请求头 ID", value: draft.profileId || "<未填写>" },
+		{ id: "profileName", label: "请求头名称", value: draft.profileName || "<未填写>" },
+		{ id: "template", label: "快速模板", value: "选择后填充" },
+		{ id: "headers", label: "请求头 JSON", value: Object.keys(draft.headers).length > 0 ? `${Object.keys(draft.headers).length}项` : "未配置" },
+	];
+}
+
+function notifyValidationErrors(ctx: ExtensionCommandContext, errors: string[]): void {
+	ctx.ui.notify(`请求头无效：\n${errors.map((error) => `- ${error}`).join("\n")}`, "warning");
+}
+
+function formatHeadersEditorText(headers: Record<string, string>): string {
+	if (Object.keys(headers).length > 0) return JSON.stringify(headers, null, 2);
+	return `{
+  // 可先返回上一级选择“快速模板”，也可在这里填写：
+  // "user-agent": "custom-client/1.0"
+}
+`;
+}
+
+async function editHeaders(ctx: ExtensionCommandContext, draft: RequestHeaderProfileDraft): Promise<void> {
+	ctx.ui.notify("结构：JSON 对象；key 是客户端 header 名，value 是字符串。复杂示例请用“快速模板”。", "info");
+	while (true) {
+		const answer = await ctx.ui.editor("请求头 JSON", formatHeadersEditorText(draft.headers));
+		if (answer === undefined) return;
+		try {
+			draft.headers = parseStringRecordJson(answer, "请求头");
+			return;
+		} catch (error) {
+			ctx.ui.notify(`请求头 JSON 无效：${formatUnknownError(error)}`, "warning");
+		}
+	}
+}
+
+async function applyTemplate(ctx: ExtensionCommandContext, draft: RequestHeaderProfileDraft): Promise<void> {
+	const labels = HEADER_TEMPLATES.map((template) => `${template.label} — ${template.description}`);
+	const picked = await ctx.ui.select("选择请求头模板", labels);
+	if (!picked) return;
+	const index = labels.indexOf(picked);
+	if (index < 0) return;
+	const template = HEADER_TEMPLATES[index]!;
+	draft.headers = { ...template.headers };
+	ctx.ui.notify(
+		template.id === "empty"
+			? "已清空请求头"
+			: `已填充模板：${template.label}，可继续进入“请求头 JSON”微调。`,
+		"info",
+	);
+}
+
+async function editField(ctx: ExtensionCommandContext, draft: RequestHeaderProfileDraft, fieldId: string): Promise<void> {
+	if (fieldId === "profileId") {
+		const value = await ctx.ui.input("请求头 ID（接入引用这个 ID；字母/数字/._-）", draft.profileId);
+		if (value !== undefined) draft.profileId = value.trim();
+		return;
+	}
+	if (fieldId === "profileName") {
+		const value = await ctx.ui.input("请求头名称（显示用）", draft.profileName);
+		if (value !== undefined) draft.profileName = value.trim();
+		return;
+	}
+	if (fieldId === "template") {
+		await applyTemplate(ctx, draft);
+		return;
+	}
+	if (fieldId === "headers") {
+		await editHeaders(ctx, draft);
+		return;
+	}
+}
+
+async function editProfile(
+	ctx: ExtensionCommandContext,
+	draft: RequestHeaderProfileDraft,
+	titlePrefix: string,
+): Promise<{ action: "save"; draft: RequestHeaderProfileDraft } | { action: "cancel" }> {
+	const cursor: MenuCursor = { index: 0 };
+	while (true) {
+		const rows = buildEditorRows(draft);
+		const menuRows = rows.map((row) => ({ id: row.id, label: `${padLabel(row.label, 16)}${row.value}` }));
+		const action = await showPersistentFormMenu(
+			ctx,
+			titlePrefix,
+			"",
+			menuRows,
+			cursor,
+			{
+				summaryLines: [
+					"认证类敏感 header 会被拒绝；API key 请放在接入配置中",
+				],
+				footer: "↑↓ 选择   Enter 编辑   Ctrl+S 保存并同步   Esc 返回",
+			},
+		);
+		if (action.type === "cancel") return { action: "cancel" };
+		if (action.type === "save") return { action: "save", draft };
+		await editField(ctx, draft, action.id);
+	}
+}
+
+async function saveProfile(
+	pi: ExtensionAPI,
+	ctx: ExtensionCommandContext,
+	draft: RequestHeaderProfileDraft,
+	oldProfileId: string | undefined,
+): Promise<boolean> {
+	const state = await readState();
+	const errors = validateRequestHeaderProfileDraft(draft, state, oldProfileId);
+	if (errors.length > 0) {
+		notifyValidationErrors(ctx, errors);
+		return false;
+	}
+	try {
+		await saveRequestHeaderProfileConfiguration(pi, ctx, state, draft, oldProfileId);
+		return true;
+	} catch (error) {
+		ctx.ui.notify(`保存失败：${formatUnknownError(error)}`, "error");
+		return false;
+	}
+}
+
+async function deleteProfile(pi: ExtensionAPI, ctx: ExtensionCommandContext, profileId: string): Promise<boolean> {
+	const state = await readState();
+	const profile = state.requestHeaderProfiles[profileId];
+	if (!profile) {
+		ctx.ui.notify(`请求头不存在：${profileId}`, "warning");
+		return true;
+	}
+	const affected = countModelsUsingRequestHeaderProfile(state, profileId);
+	const ok = await ctx.ui.confirm(
+		`删除请求头 ${profileId}`,
+		`将删除 ${profile.name}。${affected > 0 ? `\n${affected} 个模型会自动改回“自动推荐”。` : ""}`,
+	);
+	if (!ok) return false;
+	try {
+		await deleteRequestHeaderProfileConfiguration(pi, ctx, state, profileId);
+		return true;
+	} catch (error) {
+		ctx.ui.notify(`删除失败：${formatUnknownError(error)}`, "error");
+		return false;
+	}
+}
+
+async function editStoredProfile(pi: ExtensionAPI, ctx: ExtensionCommandContext, profileId: string): Promise<boolean> {
+	const state = await readState();
+	const profile = state.requestHeaderProfiles[profileId];
+	if (!profile) {
+		ctx.ui.notify(`请求头不存在：${profileId}`, "warning");
+		return true;
+	}
+	const outcome = await editProfile(ctx, createRequestHeaderProfileDraftFromStored(profileId, profile), `编辑请求头 ${profileId}`);
+	if (outcome.action !== "save") return false;
+	return saveProfile(pi, ctx, outcome.draft, profileId);
+}
+
+type HeaderProfileShortcut = "new-profile" | "delete-profile";
+
+export async function runHeaderProfilesPanel(pi: ExtensionAPI, ctx: ExtensionCommandContext): Promise<void> {
+	const cursor: MenuCursor = { index: 0 };
+	while (true) {
+		const state = await readState();
+		const profileIds = Object.keys(state.requestHeaderProfiles).sort((a, b) => a.localeCompare(b));
+		const rows = buildRows(profileIds).map((row) => {
+			const profile = state.requestHeaderProfiles[row.profileId]!;
+			const usedCount = countModelsUsingRequestHeaderProfile(state, row.profileId);
+			return {
+				...row,
+				label: formatProfileRow(row.profileId, profile, usedCount),
+			};
+		});
+		const action = await showPersistentShortcutMenu<HeaderProfileShortcut>(
+			ctx,
+			"/model-manager / 请求头",
+			"",
+			rows.map((row, index) => ({ id: `${index}`, label: row.label })),
+			cursor,
+			[
+				{ input: "n", shortcut: "new-profile" },
+				{ input: "d", shortcut: "delete-profile" },
+			],
+			{
+				summaryLines: [
+					"Built-in captures",
+					formatCaptureLine("ClaudeCode", state.clientHeaderCaptures["claude-code"]),
+					formatCaptureLine("Codex", state.clientHeaderCaptures["codex-cli"]),
+					`Custom profiles: ${rows.length}`,
+				],
+				tableHeader: `${padLabel("自定义 ID", 22)} ${padLabel("Headers", 12)} ${padLabel("Used", 10)} 名称`,
+				getDetailLines: (selectedRow) => {
+					const row = rows[Number.parseInt(selectedRow?.id ?? "", 10)];
+					const profile = row ? state.requestHeaderProfiles[row.profileId] : undefined;
+					return row && profile
+						? formatProfileDetailLines(row.profileId, profile, countModelsUsingRequestHeaderProfile(state, row.profileId))
+						: [];
+				},
+				footer: "↑↓ 选择   Enter 编辑请求头   n 新建自定义   d 删除   Esc 返回",
+				emptyLabel: "暂无自定义请求头；按 n 新建",
+			},
+		);
+		if (action.type === "cancel") return;
+		if (action.type === "shortcut") {
+			if (action.shortcut === "new-profile") {
+				const outcome = await editProfile(ctx, createRequestHeaderProfileDraft(), "新建请求头");
+				if (outcome.action === "save") await saveProfile(pi, ctx, outcome.draft, undefined);
+				continue;
+			}
+			const selectedProfileId = rows[cursor.index]?.profileId;
+			if (!selectedProfileId) {
+				ctx.ui.notify("没有可删除的请求头。", "info");
+				continue;
+			}
+			await deleteProfile(pi, ctx, selectedProfileId);
+			continue;
+		}
+		const row = rows[Number.parseInt(action.id, 10)];
+		if (!row) return;
+		await editStoredProfile(pi, ctx, row.profileId);
+	}
+}

package/tui/model-list-fetch.ts

@@ -0,0 +1,259 @@
+// 从上游 API 拉取模型列表（OpenAI / Anthropic / Google）。
+// 拉取失败 / 取消时给用户 fallback 到手动输入。
+
+import { ModelRuntime, type ProviderConfig } from "@earendil-works/pi-coding-agent";
+import { formatUnknownError, isObjectRecord } from "../common.ts";
+import { openTemporaryLocalProxyRoute, type TemporaryLocalProxyRoute } from "../local-proxy-service.ts";
+import { getClientHeadersForProfile } from "../presets/client-headers.ts";
+import { resolveRuntimeBaseUrl } from "../runtime-base-url.ts";
+import type { ApiKind, BuiltInClientHeaderProfileId, ClientHeaderProfileId, ModelListFetchOutcome, StoredClientHeaderCapture } from "../types.ts";
+
+const MODEL_LIST_TIMEOUT_MS = 10_000;
+const TEMP_PROVIDER_ID = "pi-model-manager-fetch";
+const TEMP_MODEL_ID = "__model_list_probe__";
+
+// 临时 runtime 只解析本次表单中的认证，不得读取或写入用户认证文件。
+const emptyCredentialStore = {
+	async read(): Promise<undefined> {
+		return undefined;
+	},
+	async list(): Promise<readonly []> {
+		return [];
+	},
+	async modify(): Promise<undefined> {
+		return undefined;
+	},
+	async delete(): Promise<void> {
+		return undefined;
+	},
+};
+
+function escapeRegExp(value: string): string {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function redactSecrets(message: string, secrets: string[]): string {
+	let redacted = message;
+	for (const secret of secrets) {
+		if (secret.length < 3) continue;
+		redacted = redacted.replace(new RegExp(escapeRegExp(secret), "g"), "REDACTED");
+	}
+	redacted = redacted.replace(/([?&]key=)[^&\s]+/gi, "$1REDACTED");
+	redacted = redacted.replace(/(Authorization:\s*Bearer\s+)[^\s,;]+/gi, "$1REDACTED");
+	redacted = redacted.replace(/((?:x-api-key|api-key)\s*[:=]\s*)[^\s,;]+/gi, "$1REDACTED");
+	return redacted;
+}
+
+function buildOpenAIUrl(baseUrl: string, api: Extract<ApiKind, "openai-completions" | "openai-responses">): string {
+	return `${resolveRuntimeBaseUrl(api, baseUrl)}/models`;
+}
+
+function buildAnthropicUrl(baseUrl: string): string {
+	// 根路径（无 path）追加 /v1/models，自定义后缀直接追加 /models
+	const trimmed = baseUrl.trim().replace(/\/+$/, "");
+	try {
+		const parsed = new URL(trimmed);
+		if ((parsed.pathname === "" || parsed.pathname === "/") && !parsed.search && !parsed.hash) {
+			return `${trimmed}/v1/models`;
+		}
+	} catch {
+		return `${trimmed}/models`;
+	}
+	return `${trimmed}/models`;
+}
+
+/** 从 baseUrl 提取主机根路径（不含路径部分）。
+ *  例："https://api.deepseek.com/anthropic" → "https://api.deepseek.com" */
+function deriveOrigin(url: string): string {
+	try {
+		const parsed = new URL(url);
+		return `${parsed.protocol}//${parsed.host}`;
+	} catch {
+		return url;
+	}
+}
+
+function buildGoogleUrl(baseUrl: string, apiKey: string): string {
+	const url = new URL(`${baseUrl.replace(/\/+$/, "")}/models`);
+	url.searchParams.set("key", apiKey);
+	return url.toString();
+}
+
+function extractModelIds(envelope: unknown, api: ApiKind): string[] {
+	if (!isObjectRecord(envelope)) return [];
+	if (api === "google-generative-ai") {
+		const models = envelope.models;
+		if (!Array.isArray(models)) return [];
+		return models
+			.map((m) => isObjectRecord(m) && typeof m.name === "string" ? m.name.replace(/^models\//, "") : undefined)
+			.filter((id): id is string => Boolean(id));
+	}
+	const data = envelope.data;
+	if (!Array.isArray(data)) return [];
+	return data
+		.map((m) => isObjectRecord(m) && typeof m.id === "string" ? m.id : undefined)
+		.filter((id): id is string => Boolean(id));
+}
+
+interface ResolvedFetchAuth {
+	apiKey: string;
+	headers: Record<string, string>;
+	redactionSecrets: string[];
+}
+
+function collectSensitiveHeaderValues(headers: Record<string, string> | undefined): string[] {
+	if (!headers) return [];
+	return Object.entries(headers)
+		.filter(([name]) => /authorization|cookie|api-key|x-api-key|secret|token|key/i.test(name))
+		.map(([, value]) => value);
+}
+
+async function resolveFetchAuth(
+	params: FetchModelIdsParams,
+	profileHeaders: Record<string, string> | undefined,
+): Promise<ResolvedFetchAuth> {
+	const providerConfig: ProviderConfig = {
+		name: "pi-model-manager model list probe",
+		baseUrl: resolveRuntimeBaseUrl(params.api, params.baseUrl),
+		apiKey: params.apiKey.trim(),
+		api: params.api,
+		authHeader: params.authHeader,
+		headers: profileHeaders,
+		models: [{
+			id: TEMP_MODEL_ID,
+			name: TEMP_MODEL_ID,
+			api: params.api,
+			reasoning: false,
+			input: ["text"],
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+			contextWindow: 1,
+			maxTokens: 1,
+		}],
+	};
+
+	const runtime = await ModelRuntime.create({
+		credentials: emptyCredentialStore,
+		modelsPath: null,
+		allowModelNetwork: false,
+	});
+	runtime.registerProvider(TEMP_PROVIDER_ID, providerConfig);
+	const model = runtime.getModel(TEMP_PROVIDER_ID, TEMP_MODEL_ID);
+	if (!model) throw new Error("临时模型注册失败，无法解析模型列表认证");
+
+	const resolvedAuth = await runtime.getAuth(model);
+	if (!resolvedAuth) throw new Error("请求认证解析失败");
+	const apiKey = resolvedAuth.auth.apiKey;
+	if (!apiKey) throw new Error("API key 未配置或解析为空，无法拉取模型列表");
+
+	const headers: Record<string, string> = {};
+	for (const [name, value] of Object.entries(resolvedAuth.auth.headers ?? {})) {
+		if (typeof value === "string") headers[name] = value;
+	}
+	return {
+		apiKey,
+		headers,
+		redactionSecrets: [params.apiKey.trim(), apiKey, ...collectSensitiveHeaderValues(headers)].filter(Boolean),
+	};
+}
+interface ModelListProxyConfig {
+	providerId: string;
+	proxyUrl: string;
+}
+
+async function requestModelIds(
+	url: string,
+	headers: Record<string, string>,
+	api: ApiKind,
+	proxyConfig: ModelListProxyConfig | undefined,
+): Promise<string[]> {
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(new Error("模型列表请求超时")), MODEL_LIST_TIMEOUT_MS);
+	let temporaryProxyRoute: TemporaryLocalProxyRoute | undefined;
+	try {
+		temporaryProxyRoute = proxyConfig
+			? await openTemporaryLocalProxyRoute(proxyConfig.providerId, url, proxyConfig.proxyUrl)
+			: undefined;
+		const response = await fetch(temporaryProxyRoute?.url ?? url, { headers, signal: controller.signal });
+		const text = await response.text();
+		if (!response.ok) throw new Error(`HTTP ${response.status}: ${text.slice(0, 240)}`);
+		return extractModelIds(JSON.parse(text), api).sort((a, b) => a.localeCompare(b));
+	} finally {
+		temporaryProxyRoute?.close();
+		clearTimeout(timeout);
+	}
+}
+
+export interface FetchModelIdsParams {
+	providerId: string;
+	api: ApiKind;
+	baseUrl: string;
+	apiKey: string;
+	authHeader?: boolean;
+	clientHeaderProfile: ClientHeaderProfileId;
+	customClientHeaders: Record<string, string>;
+	httpProxyEnabled: boolean;
+	httpProxyUrl: string;
+	clientHeaderCaptures?: Partial<Record<BuiltInClientHeaderProfileId, StoredClientHeaderCapture>>;
+}
+
+
+export async function fetchModelIds(params: FetchModelIdsParams): Promise<ModelListFetchOutcome> {
+	const redactionSecrets = [params.apiKey.trim()].filter(Boolean);
+	try {
+		const profileHeaders = getClientHeadersForProfile(
+			params.clientHeaderProfile,
+			params.api,
+			params.customClientHeaders,
+			params.clientHeaderCaptures ?? {},
+		);
+		const auth = await resolveFetchAuth(params, profileHeaders);
+		redactionSecrets.push(...auth.redactionSecrets);
+		const headers: Record<string, string> = { Accept: "application/json", ...auth.headers };
+		const proxyConfig = params.httpProxyEnabled
+			? { providerId: params.providerId, proxyUrl: params.httpProxyUrl }
+			: undefined;
+
+		if (params.api === "google-generative-ai") {
+			const modelIds = await requestModelIds(
+				buildGoogleUrl(resolveRuntimeBaseUrl(params.api, params.baseUrl), auth.apiKey),
+				headers,
+				params.api,
+				proxyConfig,
+			);
+			return { status: "loaded", modelIds };
+		}
+		if (params.api === "anthropic-messages") {
+			// 优先 x-api-key（多数 Anthropic 兼容端点），失败 fallback 到 Bearer
+			const apiKeyHeaders = { ...headers, "x-api-key": auth.apiKey, "anthropic-version": headers["anthropic-version"] ?? "2023-06-01" };
+			try {
+				const modelIds = await requestModelIds(buildAnthropicUrl(params.baseUrl), apiKeyHeaders, params.api, proxyConfig);
+				return { status: "loaded", modelIds };
+			} catch {
+				const bearerHeaders = { ...headers, Authorization: `Bearer ${auth.apiKey}`, "anthropic-version": headers["anthropic-version"] ?? "2023-06-01" };
+				delete (bearerHeaders as any)["x-api-key"];
+				try {
+					const modelIds = await requestModelIds(buildAnthropicUrl(params.baseUrl), bearerHeaders, params.api, proxyConfig);
+					return { status: "loaded", modelIds };
+				} catch {
+					// 最终 fallback：尝试派生主机根路径，用 OpenAI 格式 /v1/models 拉取
+					// 兼容 DeepSeek 等同时提供 Anthropic 代理 + OpenAI 模型列表端点的服务
+					const origin = deriveOrigin(params.baseUrl);
+					const fallbackUrl = `${origin}/v1/models`;
+					const fallbackHeaders = { ...headers, Authorization: `Bearer ${auth.apiKey}` };
+					const modelIds = await requestModelIds(fallbackUrl, fallbackHeaders, params.api, proxyConfig);
+					return { status: "loaded", modelIds };
+				}
+			}
+		}
+		// openai-completions / openai-responses
+		const modelIds = await requestModelIds(
+			buildOpenAIUrl(params.baseUrl, params.api),
+			{ ...headers, Authorization: `Bearer ${auth.apiKey}` },
+			params.api,
+			proxyConfig,
+		);
+		return { status: "loaded", modelIds };
+	} catch (error) {
+		return { status: "failed", message: redactSecrets(formatUnknownError(error), redactionSecrets) };
+	}
+}