imgrelay 0.0.0-stage → 0.2.0

package/dist/index.mjs

@@ -0,0 +1,1138 @@
+#!/usr/bin/env node
+import { createHash, randomUUID } from "node:crypto";
+import { access, lstat, mkdir, open, readFile, rename, rmdir, unlink, writeFile } from "node:fs/promises";
+import { basename, dirname, join, parse, resolve } from "node:path";
+import { fileTypeFromBuffer } from "file-type";
+import { imageSize } from "image-size";
+import { z } from "zod";
+import { setTimeout } from "node:timers/promises";
+import { homedir } from "node:os";
+import { Command, CommanderError } from "commander";
+import * as prompts from "@clack/prompts";
+//#region ../core/dist/index.mjs
+var ImgRelayError = class extends Error {
+	category;
+	exitCode;
+	httpStatus;
+	constructor(category, message, exitCode = 2, httpStatus) {
+		super(message);
+		this.name = "ImgRelayError";
+		this.category = category;
+		this.exitCode = exitCode;
+		this.httpStatus = httpStatus;
+	}
+};
+/** Redact before serialization; never retain an upstream response as a diagnostic. */
+var Redactor = class {
+	secrets = /* @__PURE__ */ new Set();
+	add(secret) {
+		if (secret) this.secrets.add(secret);
+	}
+	text(value) {
+		let text = value;
+		for (const secret of [...this.secrets].toSorted((a, b) => b.length - a.length)) text = text.replaceAll(secret, "[REDACTED]");
+		return text.replace(/https?:\/\/[^\s<>"']+/gi, (raw) => {
+			try {
+				const url = new URL(raw);
+				if (url.username || url.password) {
+					url.username = "REDACTED";
+					url.password = "";
+				}
+				if (url.search) url.search = "?REDACTED";
+				if (url.hash) url.hash = "#REDACTED";
+				return url.toString();
+			} catch {
+				return "[REDACTED_URL]";
+			}
+		});
+	}
+	value(value) {
+		if (typeof value === "string") return this.text(value);
+		if (Array.isArray(value)) return value.map((item) => this.value(item));
+		if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, item]) => [this.text(key), this.value(item)]));
+		return value;
+	}
+	error(error) {
+		if (error instanceof ImgRelayError) return {
+			category: error.category,
+			message: this.text(error.message),
+			...error.httpStatus === void 0 ? {} : { httpStatus: error.httpStatus }
+		};
+		return {
+			category: "internal_error",
+			message: this.text(error instanceof Error ? error.message : "发生未知错误")
+		};
+	}
+};
+function parseApiUrl(value) {
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		throw new ImgRelayError("config_error", "API 地址必须是完整的 HTTP 或 HTTPS URL");
+	}
+	if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash) throw new ImgRelayError("config_error", "API 地址只能使用 HTTP(S)，不能包含凭据、查询参数或片段");
+	return url;
+}
+function normalizeAddress(value) {
+	const url = parseApiUrl(value);
+	const path = url.pathname.replace(/\/+$/, "");
+	const isGeneration = path.endsWith("/images/generations");
+	url.pathname = isGeneration ? path.slice(0, -19) : path;
+	return {
+		baseUrl: url.toString().replace(/\/+$/, ""),
+		...isGeneration ? { generationPath: "/images/generations" } : {}
+	};
+}
+function validateEndpoint(path) {
+	try {
+		return path.startsWith("/") && !/[?#\\]/.test(path) && !path.includes("//") && !path.split("/").some((part) => ["..", "."].includes(decodeURIComponent(part)));
+	} catch {
+		return false;
+	}
+}
+function resolveEndpoint(baseUrl, endpoint) {
+	if (!validateEndpoint(endpoint)) throw new ImgRelayError("config_error", "端点必须是路径，不能包含主机、查询参数或上级目录");
+	const url = parseApiUrl(baseUrl);
+	const basePath = url.pathname.replace(/\/+$/, "");
+	url.pathname = `${basePath}${basePath.endsWith("/v1") && endpoint.startsWith("/v1/") ? endpoint.slice(3) : endpoint}`;
+	return url.toString();
+}
+const shortText = z.string().trim().min(1).max(256);
+const providerNameSchema = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/);
+const parameterSchema = z.strictObject({
+	size: shortText.optional(),
+	n: z.number().int().positive().optional(),
+	quality: shortText.optional(),
+	outputFormat: shortText.optional(),
+	responseFormat: z.enum(["url", "b64_json"]).optional()
+});
+const parameterCapabilitySchema = z.strictObject({
+	supported: z.boolean().optional(),
+	values: z.array(shortText).min(1).optional(),
+	min: z.number().optional(),
+	max: z.number().optional()
+});
+const modelCapabilitySchema = z.strictObject({
+	source: z.enum([
+		"official_documentation",
+		"provider_override",
+		"call_verification"
+	]).default("provider_override"),
+	sourceUrl: z.url().optional(),
+	verifiedAt: z.iso.datetime().optional(),
+	parameters: z.strictObject({
+		size: parameterCapabilitySchema.optional(),
+		n: parameterCapabilitySchema.optional(),
+		quality: parameterCapabilitySchema.optional(),
+		outputFormat: parameterCapabilitySchema.optional(),
+		responseFormat: parameterCapabilitySchema.optional()
+	})
+});
+const endpointSchema = z.string().max(1024).refine((value) => {
+	try {
+		return validateEndpoint(value);
+	} catch {
+		return false;
+	}
+}, "端点必须是有效路径");
+const providerSchema = z.strictObject({
+	protocol: z.literal("openai-images"),
+	baseUrl: z.string(),
+	apiKey: z.string().trim().min(1).refine((key) => !/[\r\n\0]/.test(key), "密钥不能包含换行或空字符").optional(),
+	defaultModel: shortText.optional(),
+	defaults: parameterSchema.default({}),
+	endpoints: z.strictObject({
+		generate: endpointSchema.optional(),
+		models: endpointSchema.optional()
+	}).default({}),
+	modelOverrides: z.record(shortText, modelCapabilitySchema).default({}),
+	timeoutSeconds: z.number().positive().max(2147483).finite().default(600),
+	revision: z.number().int().positive().default(1)
+}).transform((provider) => {
+	const address = normalizeAddress(provider.baseUrl);
+	return {
+		...provider,
+		baseUrl: address.baseUrl,
+		endpoints: address.generationPath && !provider.endpoints.generate ? {
+			...provider.endpoints,
+			generate: address.generationPath
+		} : provider.endpoints
+	};
+});
+const configSchema = z.strictObject({
+	schemaVersion: z.literal(1),
+	defaultProvider: providerNameSchema.optional(),
+	providers: z.record(providerNameSchema, providerSchema)
+});
+function parseProvider(input) {
+	const result = providerSchema.safeParse(input);
+	if (!result.success) throw new ImgRelayError("config_error", `供应商配置无效：${result.error.issues.map((issue) => `${issue.path.join(".")} ${issue.message}`).join("；")}`);
+	return result.data;
+}
+const CUBENCE_PRESET = {
+	protocol: "openai-images",
+	baseUrl: "https://api-lb.cubence.ai/v1",
+	defaultModel: "gpt-image-2.5-flare",
+	defaults: {
+		size: "auto",
+		n: 1,
+		quality: "high",
+		outputFormat: "png"
+	}
+};
+const GPT_IMAGE_CAPABILITY = {
+	source: "official_documentation",
+	sourceUrl: "https://developers.openai.com/api/reference/python/resources/images/methods/generate",
+	verifiedAt: "2026-10-10T10:03:00.000Z",
+	parameters: {
+		n: {
+			min: 1,
+			max: 10
+		},
+		size: { values: [
+			"auto",
+			"1024x1024",
+			"1536x1024",
+			"1024x1536"
+		] },
+		quality: { values: [
+			"auto",
+			"low",
+			"medium",
+			"high"
+		] },
+		outputFormat: { values: [
+			"png",
+			"jpeg",
+			"webp"
+		] },
+		responseFormat: { supported: false }
+	}
+};
+const KNOWN_MODEL_CAPABILITIES = {
+	"gpt-image-1": GPT_IMAGE_CAPABILITY,
+	"gpt-image-1-mini": GPT_IMAGE_CAPABILITY
+};
+function resolveParameters(provider, model, supplied) {
+	const parsed = parameterSchema.safeParse({
+		n: 1,
+		...provider.defaults,
+		...supplied
+	});
+	if (!parsed.success) throw new ImgRelayError("input_error", "生成参数无效：数量必须是正整数，各参数必须是非空字符串");
+	const result = parsed.data;
+	const known = Object.hasOwn(KNOWN_MODEL_CAPABILITIES, model) ? KNOWN_MODEL_CAPABILITIES[model] : void 0;
+	const override = Object.hasOwn(provider.modelOverrides, model) ? provider.modelOverrides[model] : void 0;
+	const limits = {
+		...known?.parameters,
+		...override?.parameters
+	};
+	for (const name of [
+		"size",
+		"n",
+		"quality",
+		"outputFormat",
+		"responseFormat"
+	]) {
+		const value = result[name];
+		const limit = limits[name];
+		if (value === void 0 || !limit) continue;
+		if (limit.supported === false && name === "n" && supplied.n === void 0 && provider.defaults.n === void 0) {
+			delete result.n;
+			continue;
+		}
+		if (limit.supported === false || limit.values && !limit.values.includes(String(value)) || typeof value === "number" && (limit.min !== void 0 && value < limit.min || limit.max !== void 0 && value > limit.max)) throw new ImgRelayError("parameter_unsupported", `模型 ${model} 不支持参数 ${name}=${value}；请检查模型能力或供应商覆盖`, 2);
+	}
+	return result;
+}
+function isNotFound(error) {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+async function assertRegular(path) {
+	const stat = await lstat(path);
+	if (!stat.isFile() || stat.isSymbolicLink()) throw new ImgRelayError("credential_error", "配置或凭据文件必须是普通文件，不能使用符号链接");
+}
+async function writeAtomic(path, value) {
+	const temporary = join(dirname(path), `.${randomUUID()}.tmp`);
+	const handle = await open(temporary, "wx");
+	try {
+		await handle.writeFile(`${JSON.stringify(value, null, 2)}\n`, "utf8");
+		await handle.sync();
+		await handle.close();
+		await rename(temporary, path);
+	} finally {
+		await handle.close().catch(() => {});
+		await unlink(temporary).catch(() => {});
+	}
+}
+async function readJson(path) {
+	await assertRegular(path);
+	return JSON.parse(await readFile(path, "utf8"));
+}
+const MAX_JSON_BYTES = 134217728;
+const MAX_IMAGE_BYTES = 33554432;
+async function readBounded(response, limit) {
+	if (Number(response.headers.get("content-length")) > limit) {
+		await response.body?.cancel();
+		throw new ImgRelayError("invalid_response", "上游响应超过大小限制", 3);
+	}
+	if (!response.body) return Buffer.alloc(0);
+	const reader = response.body.getReader();
+	const chunks = [];
+	let size = 0;
+	try {
+		for (;;) {
+			const { value, done } = await reader.read();
+			if (done) break;
+			size += value.byteLength;
+			if (size > limit) throw new ImgRelayError("invalid_response", "上游响应超过大小限制", 3);
+			chunks.push(value);
+		}
+		return Buffer.concat(chunks, size);
+	} finally {
+		await reader.cancel().catch(() => {});
+		reader.releaseLock();
+	}
+}
+function httpError(status, text, redactor) {
+	let detail = "";
+	try {
+		const parsed = JSON.parse(text);
+		if (parsed && typeof parsed === "object" && "error" in parsed) {
+			const error = parsed.error;
+			if (typeof error === "string") detail = error;
+			else if (error && typeof error === "object" && "message" in error && typeof error.message === "string") detail = error.message;
+		}
+	} catch {}
+	let category = "upstream_error";
+	if (status === 401 || status === 403) category = "auth_error";
+	else if (status === 429) category = "rate_limit";
+	else if (status === 402 || /insufficient.*(quota|balance)|余额不足/i.test(detail)) category = "quota_exceeded";
+	else if (/model.*(not found|not exist|unavailable|invalid)|模型.*(不存在|不可用)/i.test(detail)) category = "model_unavailable";
+	else if (/unsupported.*(param|size|quality|format)|unknown parameter|参数.*(不支持|无效)/i.test(detail)) category = "parameter_unsupported";
+	return new ImgRelayError(category, redactor.text(`上游返回 HTTP ${status}${detail ? `：${detail.slice(0, 1e3)}` : "，请检查接口、权限和请求参数"}`), 3, status);
+}
+async function requestJson(options) {
+	const method = options.method || "GET";
+	const attempts = method === "GET" && options.retry ? 2 : 1;
+	for (let attempt = 0; attempt < attempts; attempt++) {
+		const timeout = AbortSignal.timeout(Math.ceil((options.timeoutSeconds || 15) * 1e3));
+		const signal = options.signal ? AbortSignal.any([timeout, options.signal]) : timeout;
+		try {
+			const response = await fetch(options.url, {
+				method,
+				headers: {
+					Authorization: `Bearer ${options.key}`,
+					...method === "POST" ? { "Content-Type": "application/json" } : {}
+				},
+				...options.body === void 0 ? {} : { body: JSON.stringify(options.body) },
+				redirect: "manual",
+				signal
+			});
+			const text = (await readBounded(response, response.ok ? MAX_JSON_BYTES : 65536)).toString("utf8");
+			if (!response.ok) throw httpError(response.status, text, options.redactor);
+			try {
+				return JSON.parse(text);
+			} catch {
+				throw new ImgRelayError("invalid_response", "上游成功响应不是有效 JSON", 3);
+			}
+		} catch (error) {
+			if (options.signal?.aborted) throw new ImgRelayError("interrupted", method === "POST" ? "已停止本地等待，无法保证取消已提交的上游生成" : "用户中断请求", 130);
+			const retryable = !(error instanceof ImgRelayError) || error.httpStatus === 429 || error.httpStatus !== void 0 && error.httpStatus >= 500;
+			if (attempt + 1 < attempts && retryable) {
+				await setTimeout(150);
+				continue;
+			}
+			if (error instanceof ImgRelayError) throw error;
+			throw new ImgRelayError(method === "POST" ? "result_unknown" : "upstream_error", method === "POST" ? "生成请求超时或网络断开，结果未知；上游可能仍在生成，请勿直接重复提交" : "模型查询超时或网络失败，请检查地址和网络", 3);
+		}
+	}
+	throw new ImgRelayError("internal_error", "请求执行状态无效", 1);
+}
+function base64Bytes(value) {
+	const encoded = value.replace(/^data:image\/[^;,]+;base64,/, "").replace(/\s/g, "");
+	if (encoded.length > Math.ceil(33554432 / 3) * 4 || !/^[A-Za-z0-9+/]+={0,2}$/.test(encoded) || encoded.length % 4 === 1) throw new ImgRelayError("image_decode_error", "Base64 图片无效或超过 32 MiB 限制", 3);
+	const bytes = Buffer.from(encoded, "base64");
+	if (bytes.length > 33554432 || bytes.toString("base64").replace(/=+$/, "") !== encoded.replace(/=+$/, "")) throw new ImgRelayError("image_decode_error", "Base64 图片解码失败", 3);
+	return bytes;
+}
+async function download(urlString, signal) {
+	let current = urlString;
+	try {
+		for (let redirects = 0; redirects <= 3; redirects++) {
+			const url = new URL(current);
+			if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) throw new ImgRelayError("image_download_error", "图片地址必须为不含内嵌凭据的 HTTP(S) URL", 3);
+			const timeout = AbortSignal.timeout(6e4);
+			const response = await fetch(url, {
+				redirect: "manual",
+				signal: signal ? AbortSignal.any([signal, timeout]) : timeout
+			});
+			if (response.status >= 300 && response.status < 400) {
+				const location = response.headers.get("location");
+				await response.body?.cancel();
+				if (!location) throw new ImgRelayError("image_download_error", "图片重定向缺少目标地址", 3);
+				current = new URL(location, url).toString();
+				continue;
+			}
+			if (!response.ok) {
+				await response.body?.cancel();
+				throw new ImgRelayError("image_download_error", `图片下载返回 HTTP ${response.status}`, 3, response.status);
+			}
+			return await readBounded(response, MAX_IMAGE_BYTES);
+		}
+		throw new ImgRelayError("image_download_error", "图片下载重定向超过三次", 3);
+	} catch (error) {
+		if (signal?.aborted) throw new ImgRelayError("interrupted", "已停止本地保存；无法保证取消已提交的上游生成", 130);
+		if (error instanceof ImgRelayError) throw error;
+		throw new ImgRelayError("image_download_error", "图片下载超时或网络失败；不会重新生成图片", 3);
+	}
+}
+function usageNumbers(value, depth = 0) {
+	if (depth > 4) return void 0;
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const entries = Object.entries(value).slice(0, 100).flatMap(([key, item]) => {
+		if (!/^[a-z_][a-z0-9_]{0,63}$/i.test(key)) return [];
+		const result = usageNumbers(item, depth + 1);
+		return result === void 0 ? [] : [[key, result]];
+	});
+	return entries.length ? Object.fromEntries(entries) : void 0;
+}
+async function generate(store, options) {
+	if (!options.prompt.trim()) throw new ImgRelayError("input_error", "提示词不能为空");
+	if (options.timeoutSeconds !== void 0 && (!Number.isFinite(options.timeoutSeconds) || options.timeoutSeconds <= 0 || options.timeoutSeconds > 2147483)) throw new ImgRelayError("input_error", "超时必须是有效的正数秒数");
+	if (options.filename && (basename(options.filename) !== options.filename || /[<>:"/\\|?*]/.test(options.filename) || options.filename.split("").some((character) => character.charCodeAt(0) < 32) || !parse(options.filename).name || [".", ".."].includes(options.filename))) throw new ImgRelayError("input_error", "--filename 必须是普通文件名，保存目录使用 --output-dir");
+	const selected = await store.selected(options.provider);
+	const model = (options.model || selected.provider.defaultModel || "").trim();
+	if (!model) throw new ImgRelayError("config_error", "未配置默认模型，请通过 --model 指定或运行 provider edit");
+	const key = await store.key(selected.provider);
+	const outputDir = resolve(options.outputDir || "output/imagegen");
+	const requestId = randomUUID();
+	const recordPath = join(outputDir, `${requestId}-report.json`);
+	const supplied = {};
+	for (const name of [
+		"size",
+		"n",
+		"quality",
+		"outputFormat",
+		"responseFormat"
+	]) {
+		const value = options[name];
+		if (value !== void 0) Object.assign(supplied, { [name]: value });
+	}
+	const data = {
+		requestId,
+		provider: selected.name,
+		requestedModel: model,
+		requestedCount: supplied.n || selected.provider.defaults.n || 1,
+		returnedCount: 0,
+		parameters: {
+			...selected.provider.defaults,
+			...supplied
+		},
+		endpoint: resolveEndpoint(selected.provider.baseUrl, selected.provider.endpoints.generate || "/v1/images/generations"),
+		capabilityEvidence: {
+			known: Object.hasOwn(KNOWN_MODEL_CAPABILITIES, model) ? KNOWN_MODEL_CAPABILITIES[model] || null : null,
+			provider: Object.hasOwn(selected.provider.modelOverrides, model) ? selected.provider.modelOverrides[model] || null : null
+		},
+		images: [],
+		failures: [],
+		recordPath,
+		submissionStatus: "not_submitted"
+	};
+	const record = {
+		schemaVersion: 1,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		prompt: options.prompt,
+		...data
+	};
+	try {
+		await mkdir(outputDir, { recursive: true });
+		if (options.filename && !options.overwrite) try {
+			await access(join(outputDir, options.filename));
+			throw new ImgRelayError("save_error", "目标文件已存在，请使用其他文件名或显式 --overwrite", 4);
+		} catch (error) {
+			if (!isNotFound(error)) throw error;
+		}
+		await writeFile(recordPath, `${JSON.stringify(store.redactor.value({
+			...record,
+			status: "prepared"
+		}), null, 2)}\n`, {
+			flag: "wx",
+			mode: 384
+		});
+	} catch (error) {
+		if (error instanceof ImgRelayError) throw error;
+		throw new ImgRelayError("save_error", "无法创建输出目录或请求记录；未提交生成请求", 4);
+	}
+	let outcome;
+	try {
+		data.parameters = resolveParameters(selected.provider, model, supplied);
+		const body = {
+			model,
+			prompt: options.prompt
+		};
+		for (const [name, value] of Object.entries(data.parameters)) {
+			const wire = {
+				outputFormat: "output_format",
+				responseFormat: "response_format"
+			}[name] || name;
+			body[wire] = value;
+		}
+		if (options.signal?.aborted) throw new ImgRelayError("interrupted", "用户中断，未提交生成请求", 130);
+		options.progress?.("正在等待生图接口，生成请求只提交一次…");
+		data.submissionStatus = "submitted";
+		const response = await requestJson({
+			url: data.endpoint,
+			key,
+			redactor: store.redactor,
+			method: "POST",
+			body,
+			timeoutSeconds: options.timeoutSeconds || selected.provider.timeoutSeconds,
+			...options.signal ? { signal: options.signal } : {}
+		});
+		data.submissionStatus = "result_received";
+		if (!response || typeof response !== "object" || !("data" in response) || !Array.isArray(response.data) || response.data.length === 0) throw new ImgRelayError("invalid_response", "上游响应没有有效的 data[] 图片结果", 3);
+		if ("model" in response && typeof response.model === "string") data.reportedModel = response.model;
+		if ("usage" in response) {
+			const usage = usageNumbers(response.usage);
+			if (usage !== void 0) data.usage = usage;
+		}
+		data.returnedCount = response.data.length;
+		for (const [offset, item] of response.data.entries()) {
+			const index = offset + 1;
+			try {
+				if (options.signal?.aborted) throw new ImgRelayError("interrupted", "用户中断保存，已保存的文件保持不变", 130);
+				if (!item || typeof item !== "object") throw new ImgRelayError("invalid_response", "图片条目不是对象", 3);
+				let bytes;
+				if ("b64_json" in item && typeof item.b64_json === "string" && item.b64_json) bytes = base64Bytes(item.b64_json);
+				else if ("url" in item && typeof item.url === "string" && item.url) bytes = await download(item.url, options.signal);
+				else throw new ImgRelayError("invalid_response", "图片条目缺少 b64_json 或 url", 3);
+				let dimensions;
+				let format;
+				try {
+					format = await fileTypeFromBuffer(bytes);
+					dimensions = imageSize(bytes);
+					if (!format?.mime.startsWith("image/") || !dimensions.width || !dimensions.height) throw new Error("Invalid image");
+				} catch {
+					throw new ImgRelayError("image_decode_error", "返回数据不是可识别的有效图片", 3);
+				}
+				const stem = options.filename ? parse(options.filename).name : requestId;
+				const sequence = !options.filename || response.data.length > 1 ? `-${String(index).padStart(2, "0")}` : "";
+				const path = join(outputDir, `${stem}${sequence}.${format.ext}`);
+				const handle = await open(path, options.overwrite ? "w" : "wx", 384).catch(() => {
+					throw new ImgRelayError("save_error", "无法保存图片；请检查文件重名和目录权限", 4);
+				});
+				try {
+					await handle.writeFile(bytes);
+					await handle.sync();
+				} catch {
+					await handle.close().catch(() => {});
+					await unlink(path).catch(() => {});
+					throw new ImgRelayError("save_error", "图片写入失败；不会重新提交生成", 4);
+				} finally {
+					await handle.close().catch(() => {});
+				}
+				data.images.push({
+					index,
+					path,
+					format: format.ext,
+					width: dimensions.width,
+					height: dimensions.height,
+					bytes: bytes.length
+				});
+				options.progress?.(`已保存 ${index}/${data.returnedCount} 张图片`);
+			} catch (error) {
+				data.failures.push({
+					index,
+					error: store.redactor.error(error)
+				});
+				if (error instanceof ImgRelayError && error.category === "interrupted") throw error;
+			}
+		}
+		const failed = data.failures.length > 0;
+		const error = data.failures[0]?.error;
+		outcome = data.images.length ? {
+			status: failed ? "partial_success" : "success",
+			exitCode: failed ? 5 : 0,
+			data
+		} : {
+			status: "error",
+			exitCode: data.failures.some((failure) => failure.error.category === "save_error") ? 4 : 3,
+			data,
+			...error ? { error } : {}
+		};
+	} catch (error) {
+		const info = store.redactor.error(error);
+		if (info.category === "result_unknown") data.submissionStatus = "unknown";
+		outcome = {
+			status: info.category === "result_unknown" ? "unknown" : info.category === "interrupted" ? "interrupted" : "error",
+			exitCode: error instanceof ImgRelayError ? error.exitCode : 1,
+			data,
+			error: info
+		};
+	}
+	try {
+		await writeAtomic(recordPath, store.redactor.value({
+			...record,
+			...data,
+			status: outcome.status,
+			error: outcome.error || null,
+			completedAt: (/* @__PURE__ */ new Date()).toISOString()
+		}));
+	} catch {
+		data.recordPath = null;
+		return {
+			status: "error",
+			exitCode: 4,
+			data,
+			error: {
+				category: "save_error",
+				message: "生成记录保存失败；已保存的图片路径仍可使用，不会重新生成"
+			}
+		};
+	}
+	return outcome;
+}
+const modelsResponse = z.object({ data: z.array(z.object({
+	id: z.string().min(1),
+	type: z.string().optional()
+})) });
+const cachedModels = z.object({
+	fetchedAt: z.iso.datetime(),
+	models: modelsResponse.shape.data,
+	url: z.string(),
+	revision: z.number()
+});
+async function discoverModels(provider, key, redactor, signal) {
+	const url = resolveEndpoint(provider.baseUrl, provider.endpoints.models || "/v1/models");
+	const response = modelsResponse.safeParse(await requestJson({
+		url,
+		key,
+		redactor,
+		retry: true,
+		...signal ? { signal } : {}
+	}));
+	if (!response.success) throw new ImgRelayError("invalid_response", "模型接口未返回 data[].id；仍可手动配置模型后生成", 3);
+	return response.data.data;
+}
+async function models(store, options = {}) {
+	const selected = await store.selected(options.provider);
+	const key = await store.key(selected.provider);
+	const url = resolveEndpoint(selected.provider.baseUrl, selected.provider.endpoints.models || "/v1/models");
+	const cacheKey = createHash("sha256").update(JSON.stringify([
+		selected.name,
+		url,
+		selected.provider.revision,
+		key
+	])).digest("hex");
+	if (!options.refresh) {
+		const cache = z.record(z.string(), z.unknown()).safeParse(await store.cache());
+		const cached = cachedModels.safeParse(cache.success ? cache.data[cacheKey] : void 0);
+		if (cached.success && Date.now() - Date.parse(cached.data.fetchedAt) >= 0 && Date.now() - Date.parse(cached.data.fetchedAt) < 9e5) return {
+			...cached.data,
+			provider: selected.name,
+			cached: true
+		};
+	}
+	const discovered = await discoverModels(selected.provider, key, store.redactor, options.signal);
+	const result = {
+		fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		models: discovered,
+		url,
+		revision: selected.provider.revision
+	};
+	await store.saveCache(cacheKey, result);
+	return {
+		...result,
+		provider: selected.name,
+		cached: false
+	};
+}
+async function doctor(store, options = {}) {
+	let selected;
+	try {
+		selected = await store.selected(options.provider);
+	} catch (error) {
+		const info = store.redactor.error(error);
+		return {
+			exitCode: error instanceof ImgRelayError ? error.exitCode : 1,
+			error: info,
+			data: {
+				provider: options.provider || null,
+				endpoints: null,
+				configuration: "invalid",
+				authentication: "not_checked",
+				modelDiscovery: { status: "not_checked" },
+				generation: "not_verified"
+			}
+		};
+	}
+	const endpoints = {
+		generate: resolveEndpoint(selected.provider.baseUrl, selected.provider.endpoints.generate || "/v1/images/generations"),
+		models: resolveEndpoint(selected.provider.baseUrl, selected.provider.endpoints.models || "/v1/models")
+	};
+	try {
+		const result = await models(store, {
+			...options,
+			refresh: true
+		});
+		return {
+			exitCode: 0,
+			data: {
+				provider: selected.name,
+				endpoints,
+				configuration: "valid",
+				authentication: "verified_for_models",
+				modelDiscovery: result,
+				generation: "not_verified",
+				defaultModelListed: selected.provider.defaultModel ? result.models.some((model) => model.id === selected.provider.defaultModel) : null
+			}
+		};
+	} catch (error) {
+		if (error instanceof ImgRelayError && error.category === "interrupted") throw error;
+		const info = store.redactor.error(error);
+		return {
+			exitCode: error instanceof ImgRelayError ? error.exitCode : 1,
+			error: info,
+			data: {
+				provider: selected.name,
+				endpoints,
+				configuration: "valid",
+				authentication: info.category === "auth_error" ? "failed" : "unknown",
+				modelDiscovery: {
+					status: "unavailable",
+					error: info
+				},
+				generation: "not_verified",
+				message: "模型列表不可用时，仍可手动设置模型；生成能力尚未验证"
+			}
+		};
+	}
+}
+function defaultConfigDirectory() {
+	if (process.env.IMGRELAY_CONFIG_DIR) return resolve(process.env.IMGRELAY_CONFIG_DIR);
+	return join(homedir(), ".imgrelay");
+}
+var Store = class {
+	directory;
+	redactor = new Redactor();
+	initialized = false;
+	constructor(directory = defaultConfigDirectory()) {
+		this.directory = resolve(directory);
+		if (this.directory === parse(this.directory).root) throw new ImgRelayError("config_error", "配置目录不能是文件系统根目录");
+	}
+	async config() {
+		try {
+			const raw = await readJson(join(this.directory, "config.json"));
+			if (raw && typeof raw === "object" && "schemaVersion" in raw && raw.schemaVersion !== 1) throw new ImgRelayError("config_error", "不支持此配置版本；当前仅支持 schemaVersion=1");
+			const result = configSchema.safeParse(raw);
+			if (!result.success) throw new ImgRelayError("config_error", "配置文件结构或版本无效；请检查 config.json");
+			for (const provider of Object.values(result.data.providers)) if (provider.apiKey) this.redactor.add(provider.apiKey);
+			return result.data;
+		} catch (error) {
+			if (isNotFound(error)) return {
+				schemaVersion: 1,
+				providers: {}
+			};
+			if (error instanceof ImgRelayError) throw error;
+			throw new ImgRelayError("config_error", "无法读取配置文件；请检查文件格式及访问权限");
+		}
+	}
+	async selected(name) {
+		const config = await this.config();
+		const selected = name || config.defaultProvider;
+		if (!selected) throw new ImgRelayError("config_error", "未设置默认供应商，请运行 imgrelay provider use <名称>");
+		const provider = Object.hasOwn(config.providers, selected) ? config.providers[selected] : void 0;
+		if (!provider) throw new ImgRelayError("config_error", `供应商 ${selected} 不存在，请运行 imgrelay provider add ${selected}`);
+		return {
+			name: selected,
+			provider
+		};
+	}
+	async initialize() {
+		if (!this.initialized) {
+			await mkdir(this.directory, { recursive: true });
+			this.initialized = true;
+		}
+	}
+	async locked(operation) {
+		await this.initialize();
+		const lock = join(this.directory, ".write-lock");
+		const owner = join(lock, "owner.json");
+		const deadline = Date.now() + 1e4;
+		for (;;) try {
+			await mkdir(lock);
+			break;
+		} catch (error) {
+			if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
+			try {
+				const data = z.object({ pid: z.number().int().positive() }).parse(await readJson(owner));
+				try {
+					process.kill(data.pid, 0);
+				} catch (checkError) {
+					if (checkError instanceof Error && "code" in checkError && checkError.code === "ESRCH") {
+						await unlink(owner);
+						await rmdir(lock);
+						continue;
+					}
+				}
+			} catch {
+				try {
+					if (Date.now() - (await lstat(lock)).mtimeMs > 6e4) {
+						await unlink(owner).catch(() => {});
+						await rmdir(lock);
+						continue;
+					}
+				} catch {}
+			}
+			if (Date.now() >= deadline) throw new ImgRelayError("config_busy", "配置正在被其他进程修改，请稍后重试");
+			await setTimeout(50);
+		}
+		try {
+			await writeFile(owner, JSON.stringify({ pid: process.pid }));
+			return await operation();
+		} finally {
+			await unlink(owner).catch(() => {});
+			await rmdir(lock).catch(() => {});
+		}
+	}
+	async key(provider) {
+		const key = provider.apiKey;
+		if (!key) throw new ImgRelayError("credential_error", "未配置 API 密钥，请运行 imgrelay provider edit <名称>");
+		if (/[\r\n\0]/.test(key)) throw new ImgRelayError("credential_error", "密钥不能包含换行或空字符");
+		this.redactor.add(key);
+		return key;
+	}
+	async put(name, input, options = {}) {
+		if (!providerNameSchema.safeParse(name).success) throw new ImgRelayError("input_error", "供应商名称只能包含字母、数字、下划线和连字符");
+		if (input.apiKey) this.redactor.add(input.apiKey);
+		if (options.secret) this.redactor.add(options.secret);
+		const proposed = parseProvider({
+			...input,
+			...options.secret !== void 0 ? { apiKey: options.secret } : {}
+		});
+		if (proposed.apiKey) this.redactor.add(proposed.apiKey);
+		return this.locked(async () => {
+			const config = await this.config();
+			const previous = Object.hasOwn(config.providers, name) ? config.providers[name] : void 0;
+			if (options.edit ? !previous : previous) throw new ImgRelayError("config_error", options.edit ? "供应商不存在" : "供应商已存在，请使用 provider edit");
+			if (options.expectedRevision !== void 0 && previous?.revision !== options.expectedRevision) throw new ImgRelayError("config_busy", "配置已被其他进程修改，请重新执行编辑");
+			proposed.revision = (previous?.revision || 0) + 1;
+			config.providers[name] = proposed;
+			if (options.makeDefault) config.defaultProvider = name;
+			await writeAtomic(join(this.directory, "config.json"), config);
+			return proposed;
+		});
+	}
+	async use(name) {
+		await this.locked(async () => {
+			const config = await this.config();
+			if (!Object.hasOwn(config.providers, name)) throw new ImgRelayError("config_error", "供应商不存在");
+			config.defaultProvider = name;
+			await writeAtomic(join(this.directory, "config.json"), config);
+		});
+	}
+	async remove(name) {
+		await this.locked(async () => {
+			const config = await this.config();
+			if (!Object.hasOwn(config.providers, name)) throw new ImgRelayError("config_error", "供应商不存在");
+			delete config.providers[name];
+			if (config.defaultProvider === name) delete config.defaultProvider;
+			await writeAtomic(join(this.directory, "config.json"), config);
+		});
+	}
+	async cache() {
+		try {
+			return await readJson(join(this.directory, "models-cache.json"));
+		} catch {
+			return {};
+		}
+	}
+	async saveCache(key, value) {
+		await this.locked(async () => {
+			const parsed = z.record(z.string(), z.unknown()).safeParse(await this.cache());
+			const cache = parsed.success ? parsed.data : {};
+			cache[key] = value;
+			const entries = Object.entries(cache).slice(-100);
+			await writeAtomic(join(this.directory, "models-cache.json"), Object.fromEntries(entries));
+		});
+	}
+};
+//#endregion
+//#region package.json
+var version = "0.2.0";
+//#endregion
+//#region src/provider.ts
+function answer(value) {
+	if (typeof value === "symbol") throw new ImgRelayError("interrupted", "用户取消配置，未保存修改", 130);
+	return value;
+}
+function providerOptions(command) {
+	return command.option("--base-url <URL>", "API 基础地址，推荐包含 /v1").option("--protocol <协议>", "首版支持 openai-images").option("--preset <名称>", "使用已验证配置预设：cubence").option("--model <ID>", "默认模型，允许手动填写").option("--clear-key", "清除配置中保存的密钥").option("--default", "保存后设为默认供应商").option("--size <尺寸>", "默认尺寸").option("--n <数量>", "默认生成数量").option("--quality <质量>", "默认质量").option("--output-format <格式>", "默认图片格式").option("--response-format <格式>", "供应商要求的返回格式：url 或 b64_json").option("--generation-path <路径>", "生成端点覆盖").option("--models-path <路径>", "模型端点覆盖").option("--capabilities-file <文件>", "按模型的能力覆盖 JSON 文件").option("--timeout <秒数>", "默认生成超时");
+}
+async function configureProvider(store, name, flags, interactive, signal, existing) {
+	if (flags.preset && flags.preset !== "cubence") throw new ImgRelayError("input_error", "未知预设；当前提供 cubence");
+	if (!existing && !interactive) throw new ImgRelayError("config_error", "新增供应商需要隐藏输入 API 密钥，请在交互终端不带 --json 运行 provider add");
+	const input = {
+		protocol: "openai-images",
+		baseUrl: "",
+		...flags.preset ? CUBENCE_PRESET : {},
+		...existing
+	};
+	if (flags.protocol) {
+		if (flags.protocol !== "openai-images") throw new ImgRelayError("config_error", "首版仅支持 openai-images 协议");
+		input.protocol = flags.protocol;
+	}
+	if (flags.baseUrl !== void 0) input.baseUrl = flags.baseUrl;
+	if (flags.model !== void 0) input.defaultModel = flags.model;
+	input.defaults = { ...input.defaults };
+	input.endpoints = { ...input.endpoints };
+	if (flags.size !== void 0) input.defaults.size = flags.size;
+	if (flags.n !== void 0) input.defaults.n = Number(flags.n);
+	if (flags.quality !== void 0) input.defaults.quality = flags.quality;
+	if (flags.outputFormat !== void 0) input.defaults.outputFormat = flags.outputFormat;
+	if (flags.responseFormat !== void 0) {
+		if (flags.responseFormat !== "url" && flags.responseFormat !== "b64_json") throw new ImgRelayError("input_error", "返回格式只能是 url 或 b64_json");
+		input.defaults.responseFormat = flags.responseFormat;
+	}
+	if (flags.generationPath !== void 0) input.endpoints.generate = flags.generationPath;
+	if (flags.modelsPath !== void 0) input.endpoints.models = flags.modelsPath;
+	if (flags.timeout !== void 0) input.timeoutSeconds = Number(flags.timeout);
+	if (flags.capabilitiesFile) try {
+		const modelOverrides = JSON.parse(await readFile(resolve(flags.capabilitiesFile), "utf8"));
+		input.modelOverrides = parseProvider({
+			...input,
+			modelOverrides
+		}).modelOverrides;
+	} catch {
+		throw new ImgRelayError("input_error", "能力覆盖文件必须是可读的 UTF-8 JSON");
+	}
+	let secret;
+	if (flags.clearKey) delete input.apiKey;
+	if (interactive) {
+		prompts.intro(existing ? `编辑供应商 ${name}` : `添加供应商 ${name}`);
+		if (flags.baseUrl === void 0) input.baseUrl = answer(await prompts.text({
+			message: "API 基础地址",
+			initialValue: input.baseUrl,
+			validate: (value) => value?.trim() ? void 0 : "请输入地址"
+		}));
+		if (!flags.clearKey) {
+			secret = answer(await prompts.password({
+				message: input.apiKey ? "API 密钥（留空保留当前密钥）" : "API 密钥",
+				validate: (value) => value?.trim() || input.apiKey ? void 0 : "密钥不能为空"
+			})).trim() || void 0;
+			if (secret) store.redactor.add(secret);
+		}
+	}
+	if (!existing && !secret) throw new ImgRelayError("config_error", "新增供应商需要非空 API 密钥");
+	if (interactive && flags.model === void 0) {
+		let ids = [];
+		try {
+			const key = secret || await store.key(input);
+			ids = (await discoverModels(parseProvider(input), key, store.redactor, signal)).map((model) => model.id);
+		} catch (error) {
+			if (error instanceof ImgRelayError && error.category === "interrupted") throw error;
+			prompts.log.warn("未能查询模型列表，可以手动填写模型 ID；生成能力尚未验证");
+		}
+		const choice = ids.length ? answer(await prompts.select({
+			message: "默认模型",
+			options: [...ids.map((id) => ({
+				value: id,
+				label: store.redactor.text(id)
+			})), {
+				value: "\0manual",
+				label: "手动填写模型 ID"
+			}]
+		})) : "\0manual";
+		input.defaultModel = choice === "\0manual" ? answer(await prompts.text({
+			message: "默认模型（留空可稍后设置）",
+			initialValue: input.defaultModel || ""
+		})) : choice;
+		if (!input.defaultModel) delete input.defaultModel;
+	}
+	if (interactive && answer(await prompts.confirm({
+		message: "设置尺寸、数量、质量和格式的默认值？",
+		initialValue: false
+	}))) for (const [field, label] of [
+		["size", "尺寸"],
+		["n", "数量"],
+		["quality", "质量"],
+		["outputFormat", "图片格式"]
+	]) {
+		const value = answer(await prompts.text({
+			message: `${label}（留空表示不设置）`,
+			initialValue: String(input.defaults[field] || "")
+		}));
+		if (value) Object.assign(input.defaults, { [field]: field === "n" ? Number(value) : value });
+		else delete input.defaults[field];
+	}
+	const makeDefault = flags.default || (interactive ? answer(await prompts.confirm({
+		message: "设为默认供应商？",
+		initialValue: !(await store.config()).defaultProvider
+	})) : false);
+	const saved = await store.put(name, input, {
+		...existing ? {
+			edit: true,
+			expectedRevision: existing.revision
+		} : {},
+		...secret ? { secret } : {},
+		makeDefault
+	});
+	if (interactive) prompts.outro("配置已保存；此流程没有生成图片");
+	return saved;
+}
+//#endregion
+//#region src/index.ts
+const json = process.argv.includes("--json");
+const controller = new AbortController();
+process.once("SIGINT", () => controller.abort());
+process.once("SIGTERM", () => controller.abort());
+let commandName = "imgrelay";
+let outputWritten = false;
+let helpOutput = "";
+let store;
+function output(data, options = {}) {
+	if (outputWritten) return;
+	outputWritten = true;
+	const envelope = {
+		schemaVersion: 1,
+		command: commandName,
+		status: options.status || "success",
+		data,
+		error: options.error || null
+	};
+	const safe = store ? store.redactor.value(envelope) : envelope;
+	if (json) process.stdout.write(`${JSON.stringify(safe)}\n`);
+	else {
+		if (options.error) process.stderr.write(`${store?.redactor.text(options.error.message) || options.error.message}\n`);
+		if (data !== null) process.stdout.write(`${JSON.stringify(store ? store.redactor.value(data) : data, null, 2)}\n`);
+	}
+	process.exitCode = options.exitCode || 0;
+}
+function active(name) {
+	commandName = name;
+	store ||= new Store();
+	return store;
+}
+const program = new Command().name("imgrelay").description("通过统一入口调用 OpenAI Images 兼容中转站").version(version).option("--json", "输出一个最终 JSON 对象，禁用交互输入").exitOverride().configureOutput({
+	writeOut: (value) => {
+		if (json) helpOutput += value;
+		else process.stdout.write(value);
+	},
+	writeErr: (value) => {
+		if (!json) process.stderr.write(value);
+	}
+});
+const provider = program.command("provider").description("管理供应商配置与凭据");
+providerOptions(provider.command("add <名称>").description("添加供应商")).action(async (name, flags) => {
+	output({
+		provider: name,
+		configuration: await configureProvider(active("provider add"), name, flags, !json && process.stdin.isTTY && process.stdout.isTTY, controller.signal)
+	});
+});
+providerOptions(provider.command("edit <名称>").description("修改供应商")).action(async (name, flags) => {
+	const current = active("provider edit");
+	const existing = await current.selected(name);
+	output({
+		provider: name,
+		configuration: await configureProvider(current, name, flags, !json && process.stdin.isTTY && process.stdout.isTTY, controller.signal, existing.provider)
+	});
+});
+provider.command("list").description("列出供应商摘要").action(async () => {
+	const config = await active("provider list").config();
+	output({
+		defaultProvider: config.defaultProvider || null,
+		providers: Object.entries(config.providers).map(([name, entry]) => ({
+			name,
+			protocol: entry.protocol,
+			baseUrl: entry.baseUrl,
+			defaultModel: entry.defaultModel || null,
+			credentialSource: entry.apiKey ? "config" : null,
+			default: name === config.defaultProvider
+		}))
+	});
+});
+provider.command("show <名称>").description("查看脱敏配置").action(async (name) => {
+	output({
+		provider: name,
+		configuration: (await active("provider show").selected(name)).provider
+	});
+});
+provider.command("use <名称>").description("设置默认供应商").action(async (name) => {
+	await active("provider use").use(name);
+	output({ defaultProvider: name });
+});
+provider.command("remove <名称>").description("移除供应商及其已保存的密钥").action(async (name) => {
+	await active("provider remove").remove(name);
+	output({ removed: name });
+});
+program.command("models").description("查询模型列表或查看 15 分钟缓存").option("--provider <名称>", "本次使用的供应商").option("--refresh", "强制刷新模型列表").action(async (flags) => {
+	output(await models(active("models"), {
+		...flags,
+		signal: controller.signal
+	}));
+});
+program.command("doctor").description("检查配置与模型接口，不生成图片").option("--provider <名称>", "检查指定供应商").action(async (flags) => {
+	const result = await doctor(active("doctor"), {
+		...flags,
+		signal: controller.signal
+	});
+	output(result.data, {
+		status: result.exitCode ? "error" : "success",
+		exitCode: result.exitCode,
+		...result.error ? { error: result.error } : {}
+	});
+});
+program.command("generate").description("生成图片并保存原图和记录").option("--prompt <文本>", "直接提供非空提示词（必填）").option("--provider <名称>", "本次使用的供应商").option("--model <ID>", "本次使用的模型").option("--size <尺寸>", "图片尺寸，如 auto 或 1024x1024").option("--n <数量>", "请求图片数量，不自动拆单").option("--quality <质量>", "请求质量").option("--output-format <格式>", "请求图片格式").option("--output-dir <目录>", "保存目录，默认 output/imagegen").option("--filename <名称>", "文件名；多图追加序号，扩展名按实际格式").option("--overwrite", "允许覆盖图片文件").option("--timeout <秒数>", "生成等待超时，默认 600 秒").action(async (flags) => {
+	const current = active("generate");
+	if (flags.prompt === void 0) throw new ImgRelayError("input_error", "请通过 --prompt 提供非空提示词");
+	const result = await generate(current, {
+		prompt: flags.prompt,
+		...flags.provider ? { provider: flags.provider } : {},
+		...flags.model ? { model: flags.model } : {},
+		...flags.size !== void 0 ? { size: flags.size } : {},
+		...flags.n !== void 0 ? { n: Number(flags.n) } : {},
+		...flags.quality !== void 0 ? { quality: flags.quality } : {},
+		...flags.outputFormat !== void 0 ? { outputFormat: flags.outputFormat } : {},
+		...flags.outputDir !== void 0 ? { outputDir: flags.outputDir } : {},
+		...flags.filename !== void 0 ? { filename: flags.filename } : {},
+		...flags.timeout !== void 0 ? { timeoutSeconds: Number(flags.timeout) } : {},
+		overwrite: Boolean(flags.overwrite),
+		signal: controller.signal,
+		progress: (message) => process.stderr.write(`${message}\n`)
+	});
+	output(result.data, {
+		status: result.status,
+		exitCode: result.exitCode,
+		...result.error ? { error: result.error } : {}
+	});
+});
+program.action(() => {
+	if (json) output({ help: program.helpInformation() });
+	else program.outputHelp();
+});
+try {
+	await program.parseAsync(process.argv);
+} catch (error) {
+	if (error instanceof CommanderError && error.exitCode === 0) {
+		if (json) output({ help: helpOutput.trim() });
+		process.exitCode = 0;
+	} else {
+		const failure = error instanceof CommanderError ? new ImgRelayError("input_error", error.message) : error;
+		const info = store ? store.redactor.error(failure) : {
+			category: failure instanceof ImgRelayError ? failure.category : "internal_error",
+			message: failure instanceof Error ? failure.message : "发生未知错误"
+		};
+		output(null, {
+			status: info.category === "interrupted" ? "interrupted" : "error",
+			exitCode: failure instanceof ImgRelayError ? failure.exitCode : 1,
+			error: info
+		});
+	}
+}
+//#endregion
+export {};
+
+//# sourceMappingURL=index.mjs.map