@nextclaw/aigen 0.1.0-beta.0

package/dist/app/main.js

@@ -0,0 +1,963 @@
+#!/usr/bin/env node
+import { Command, CommanderError, InvalidArgumentError } from "commander";
+import { chmod, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { createHash } from "node:crypto";
+//#region src/types/cli-output.types.ts
+var AigenError = class extends Error {
+	code;
+	retryable;
+	constructor(code, message, options) {
+		super(message);
+		this.name = "AigenError";
+		this.code = code;
+		this.retryable = options?.retryable ?? false;
+	}
+};
+//#endregion
+//#region src/utils/route.utils.ts
+const parseModelRoute = (route) => {
+	const slashIndex = route.indexOf("/");
+	if (slashIndex <= 0 || slashIndex === route.length - 1) throw new AigenError("INVALID_ARGUMENT", "Model route must use <provider-id>/<provider-local-model>.");
+	return {
+		providerId: route.slice(0, slashIndex),
+		providerLocalModel: route.slice(slashIndex + 1)
+	};
+};
+const assertResourceId = (id, label) => {
+	if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(id)) throw new AigenError("INVALID_ARGUMENT", `${label} must be a stable resource id.`);
+};
+//#endregion
+//#region src/controllers/doctor.controller.ts
+var DoctorController = class {
+	constructor(configRepository, secretsRepository, providerRuntimeManager) {
+		this.configRepository = configRepository;
+		this.secretsRepository = secretsRepository;
+		this.providerRuntimeManager = providerRuntimeManager;
+	}
+	run = async (options) => {
+		const { provider, model } = options;
+		const checks = [];
+		const config = await this.configRepository.readConfig();
+		checks.push({
+			name: "config",
+			ok: true
+		});
+		if (provider) await this.checkProvider(provider, checks);
+		if (model) {
+			const route = parseModelRoute(model);
+			await this.configRepository.getModel(route.providerId, route.providerLocalModel);
+			await this.checkProvider(route.providerId, checks);
+			checks.push({
+				name: "model",
+				ok: true
+			});
+		}
+		return {
+			ok: true,
+			providerCount: Object.keys(config.providers).length,
+			checks
+		};
+	};
+	checkProvider = async (providerId, checks) => {
+		const providerConfig = await this.configRepository.getProvider(providerId);
+		this.providerRuntimeManager.getImageProvider(providerConfig.apiFormat);
+		checks.push({
+			name: "provider",
+			ok: true
+		});
+		await this.secretsRepository.getProviderSecret(providerId);
+		checks.push({
+			name: "secret",
+			ok: true
+		});
+	};
+};
+//#endregion
+//#region src/controllers/image.controller.ts
+var ImageController = class {
+	constructor(imageGenerationManager) {
+		this.imageGenerationManager = imageGenerationManager;
+	}
+	generate = async (options) => this.imageGenerationManager.generate(options);
+};
+//#endregion
+//#region src/controllers/models.controller.ts
+var ModelsController = class {
+	constructor(configRepository, secretsRepository, providerRuntimeManager) {
+		this.configRepository = configRepository;
+		this.secretsRepository = secretsRepository;
+		this.providerRuntimeManager = providerRuntimeManager;
+	}
+	list = async (options) => options.remote ? this.listRemote(options) : this.listLocal(options);
+	listLocal = async (options) => {
+		return {
+			ok: true,
+			models: (await this.configRepository.listModels(options.provider, options.kind)).map((model) => ({
+				route: model.route,
+				provider: model.providerId,
+				providerLocalModel: model.providerLocalModel,
+				kind: model.config.kind,
+				displayName: model.config.displayName,
+				capabilities: model.config.capabilities
+			}))
+		};
+	};
+	listRemote = async (options) => {
+		if (!options.provider) throw new AigenError("INVALID_ARGUMENT", "Missing required --provider for remote model listing.");
+		const providerId = options.provider;
+		const providerConfig = await this.configRepository.getProvider(providerId);
+		const provider = this.providerRuntimeManager.getRemoteModelListProvider(providerConfig.apiFormat);
+		const apiKey = await this.secretsRepository.getProviderApiKey(providerId);
+		const result = await provider.listRemoteModels({ kind: options.kind }, {
+			providerId,
+			apiFormat: providerConfig.apiFormat,
+			apiBase: providerConfig.apiBase,
+			apiKey,
+			headers: providerConfig.headers
+		});
+		return {
+			ok: true,
+			models: result.models.map((model) => ({
+				route: `${providerId}/${model.providerLocalModel}`,
+				provider: providerId,
+				apiFormat: providerConfig.apiFormat,
+				providerLocalModel: model.providerLocalModel,
+				kind: "image",
+				displayName: model.displayName,
+				inputModalities: model.inputModalities,
+				outputModalities: model.outputModalities,
+				pricing: model.pricing,
+				metadata: model.metadata
+			})),
+			metadata: result.metadata
+		};
+	};
+	get = async (modelRoute) => {
+		const route = parseModelRoute(modelRoute);
+		const modelConfig = await this.configRepository.getModel(route.providerId, route.providerLocalModel);
+		return {
+			ok: true,
+			model: {
+				route: modelRoute,
+				provider: route.providerId,
+				providerLocalModel: route.providerLocalModel,
+				kind: modelConfig.kind,
+				displayName: modelConfig.displayName,
+				capabilities: modelConfig.capabilities
+			}
+		};
+	};
+	add = async (modelRoute, options) => {
+		const route = parseModelRoute(modelRoute);
+		const modelConfig = this.fullModelConfigFromOptions(options);
+		await this.configRepository.addModel(route.providerId, route.providerLocalModel, modelConfig);
+		return {
+			ok: true,
+			model: {
+				route: modelRoute,
+				provider: route.providerId,
+				providerLocalModel: route.providerLocalModel,
+				...modelConfig
+			}
+		};
+	};
+	update = async (modelRoute, options) => {
+		const route = parseModelRoute(modelRoute);
+		const modelConfig = await this.configRepository.updateModel(route.providerId, route.providerLocalModel, this.modelConfigFromOptions(options));
+		return {
+			ok: true,
+			model: {
+				route: modelRoute,
+				provider: route.providerId,
+				providerLocalModel: route.providerLocalModel,
+				...modelConfig
+			}
+		};
+	};
+	remove = async (modelRoute) => {
+		const route = parseModelRoute(modelRoute);
+		await this.configRepository.removeModel(route.providerId, route.providerLocalModel);
+		return {
+			ok: true,
+			removed: true,
+			model: modelRoute
+		};
+	};
+	fullModelConfigFromOptions = (options) => {
+		return {
+			kind: options.kind ?? "image",
+			displayName: options.displayName,
+			capabilities: this.capabilitiesFromOptions(options)
+		};
+	};
+	modelConfigFromOptions = (options) => {
+		return {
+			kind: options.kind,
+			displayName: options.displayName,
+			capabilities: this.capabilitiesFromOptions(options)
+		};
+	};
+	capabilitiesFromOptions = (options) => {
+		const maxCount = options.maxCount;
+		const generate = options.generate ?? false;
+		const edit = options.edit ?? false;
+		if (maxCount === void 0 && !generate && !edit) return;
+		return {
+			generate: generate || void 0,
+			edit: edit || void 0,
+			maxCount
+		};
+	};
+};
+//#endregion
+//#region src/controllers/providers.controller.ts
+var ProvidersController = class {
+	constructor(configRepository) {
+		this.configRepository = configRepository;
+	}
+	list = async () => {
+		return {
+			ok: true,
+			providers: (await this.configRepository.listProviders()).map(({ id, config }) => this.toProviderOutput(id, config))
+		};
+	};
+	get = async (providerId) => ({
+		ok: true,
+		provider: this.toProviderOutput(providerId, await this.configRepository.getProvider(providerId))
+	});
+	add = async (providerId, options) => {
+		const { apiFormat, displayName, apiBase } = options;
+		const providerConfig = {
+			apiFormat,
+			displayName,
+			apiKeyRef: `provider:${providerId}`,
+			apiBase: apiBase ?? this.defaultApiBase(apiFormat),
+			models: {}
+		};
+		await this.configRepository.addProvider(providerId, providerConfig);
+		return {
+			ok: true,
+			provider: this.toProviderOutput(providerId, providerConfig)
+		};
+	};
+	update = async (providerId, options) => {
+		const { apiFormat, displayName, apiBase } = options;
+		const providerConfig = await this.configRepository.updateProvider(providerId, {
+			apiFormat,
+			displayName,
+			apiBase
+		});
+		return {
+			ok: true,
+			provider: this.toProviderOutput(providerId, providerConfig)
+		};
+	};
+	remove = async (providerId) => {
+		await this.configRepository.removeProvider(providerId);
+		return {
+			ok: true,
+			removed: true,
+			providerId
+		};
+	};
+	toProviderOutput = (providerId, config) => ({
+		id: providerId,
+		apiFormat: config.apiFormat,
+		displayName: config.displayName,
+		apiBase: config.apiBase,
+		apiKeyRef: config.apiKeyRef,
+		modelCount: Object.keys(config.models).length
+	});
+	defaultApiBase = (apiFormat) => {
+		if (apiFormat === "openrouter") return "https://openrouter.ai/api/v1";
+		if (apiFormat === "openai") return "https://api.openai.com/v1";
+		return "";
+	};
+};
+//#endregion
+//#region src/controllers/secrets.controller.ts
+var SecretsController = class {
+	constructor(secretsRepository) {
+		this.secretsRepository = secretsRepository;
+	}
+	list = async () => ({
+		ok: true,
+		secrets: await this.secretsRepository.listSecrets()
+	});
+	get = async (providerId) => ({
+		ok: true,
+		secret: await this.secretsRepository.getProviderSecret(providerId)
+	});
+	set = async (providerId) => {
+		return {
+			ok: true,
+			secret: await this.secretsRepository.setProviderApiKey(providerId, await this.readStdin())
+		};
+	};
+	remove = async (providerId) => {
+		await this.secretsRepository.removeProviderSecret(providerId);
+		return {
+			ok: true,
+			removed: true,
+			providerId
+		};
+	};
+	readStdin = async () => new Promise((resolve, reject) => {
+		let value = "";
+		process.stdin.setEncoding("utf8");
+		process.stdin.on("data", (chunk) => {
+			value += chunk;
+		});
+		process.stdin.on("end", () => {
+			resolve(value);
+		});
+		process.stdin.on("error", reject);
+	});
+};
+//#endregion
+//#region src/app/register-aigen-commands.ts
+const registerAigenCommands = (program, controllers, sink) => {
+	registerImageCommand(program, controllers, sink);
+	registerProvidersCommands(program, controllers, sink);
+	registerModelsCommands(program, controllers, sink);
+	registerSecretsCommands(program, controllers, sink);
+	registerDoctorCommand(program, controllers, sink);
+};
+const registerImageCommand = (program, controllers, sink) => {
+	withOutputOptions(program.command("image").description("Generate an image").requiredOption("--model <route>", "Model route in <provider-id>/<provider-local-model> format").requiredOption("--prompt <text>", "Generation prompt").option("--size <size>", "Image size").option("--n <count>", "Number of images to generate", parseNumberOption, 1).option("--quality <quality>", "Image quality").option("--background <background>", "Background mode").option("--output-format <format>", "Output format").option("--output-compression <value>", "Output compression", parseNumberOption).option("--moderation <mode>", "Moderation mode").requiredOption("--output-dir <dir>", "Directory for generated assets").requiredOption("--output-name <name>", "Base output file name")).action(async (options) => {
+		sink(await controllers.imageController.generate(options));
+	});
+};
+const registerProvidersCommands = (program, controllers, sink) => {
+	const providers = program.command("providers").description("Manage image generation providers");
+	withOutputOptions(providers.command("list").description("List configured providers")).action(async () => {
+		sink(await controllers.providersController.list());
+	});
+	withOutputOptions(providers.command("get <providerId>").description("Get a configured provider")).action(async (providerId) => {
+		sink(await controllers.providersController.get(providerId));
+	});
+	withOutputOptions(providers.command("add <providerId>").description("Add a provider").requiredOption("--api-format <format>", "Provider API format, for example openrouter or openai").option("--display-name <name>", "Provider display name").option("--api-base <url>", "Provider API base URL")).action(async (providerId, options) => {
+		sink(await controllers.providersController.add(providerId, options));
+	});
+	withOutputOptions(providers.command("update <providerId>").description("Update a provider").option("--api-format <format>", "Provider API format").option("--display-name <name>", "Provider display name").option("--api-base <url>", "Provider API base URL")).action(async (providerId, options) => {
+		sink(await controllers.providersController.update(providerId, options));
+	});
+	withOutputOptions(providers.command("remove <providerId>").description("Remove a provider")).action(async (providerId) => {
+		sink(await controllers.providersController.remove(providerId));
+	});
+};
+const registerModelsCommands = (program, controllers, sink) => {
+	const models = program.command("models").description("Manage provider models");
+	withOutputOptions(models.command("list").description("List configured models, or remote provider models with --remote").option("--remote", "List remote models from a provider", false).option("--provider <providerId>", "Provider id").option("--kind <kind>", "Model kind")).action(async (options) => {
+		sink(await controllers.modelsController.list(options));
+	});
+	withOutputOptions(models.command("get <modelRoute>").description("Get a configured model")).action(async (modelRoute) => {
+		sink(await controllers.modelsController.get(modelRoute));
+	});
+	withOutputOptions(models.command("add <modelRoute>").description("Add a model under a provider").option("--kind <kind>", "Model kind", "image").option("--display-name <name>", "Model display name").option("--generate", "Mark model as generation-capable", false).option("--edit", "Mark model as edit-capable", false).option("--max-count <count>", "Maximum generated asset count", parseNumberOption)).action(async (modelRoute, options) => {
+		sink(await controllers.modelsController.add(modelRoute, options));
+	});
+	withOutputOptions(models.command("update <modelRoute>").description("Update a model").option("--kind <kind>", "Model kind").option("--display-name <name>", "Model display name").option("--generate", "Mark model as generation-capable").option("--edit", "Mark model as edit-capable").option("--max-count <count>", "Maximum generated asset count", parseNumberOption)).action(async (modelRoute, options) => {
+		sink(await controllers.modelsController.update(modelRoute, options));
+	});
+	withOutputOptions(models.command("remove <modelRoute>").description("Remove a model")).action(async (modelRoute) => {
+		sink(await controllers.modelsController.remove(modelRoute));
+	});
+};
+const registerSecretsCommands = (program, controllers, sink) => {
+	const secrets = program.command("secrets").description("Manage provider API keys");
+	withOutputOptions(secrets.command("list").description("List masked provider secrets")).action(async () => {
+		sink(await controllers.secretsController.list());
+	});
+	withOutputOptions(secrets.command("get <providerId>").description("Get masked provider secret metadata")).action(async (providerId) => {
+		sink(await controllers.secretsController.get(providerId));
+	});
+	withOutputOptions(secrets.command("set <providerId>").description("Set provider API key from stdin").option("--stdin", "Read provider API key from stdin", false)).action(async (providerId) => {
+		sink(await controllers.secretsController.set(providerId));
+	});
+	withOutputOptions(secrets.command("remove <providerId>").description("Remove provider API key")).action(async (providerId) => {
+		sink(await controllers.secretsController.remove(providerId));
+	});
+};
+const registerDoctorCommand = (program, controllers, sink) => {
+	withOutputOptions(program.command("doctor").description("Run local configuration diagnostics").option("--provider <providerId>", "Provider id to check").option("--model <modelRoute>", "Model route to check")).action(async (options) => {
+		sink(await controllers.doctorController.run(options));
+	});
+};
+const withOutputOptions = (command) => command.option("--json", "Output JSON", false).option("--debug", "Print debug diagnostics to stderr", false);
+const parseNumberOption = (value) => {
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed)) throw new InvalidArgumentError("must be a number");
+	return parsed;
+};
+//#endregion
+//#region src/managers/image-generation.manager.ts
+var ImageGenerationManager = class {
+	constructor(configRepository, secretsRepository, providerRuntimeManager, outputFileManager) {
+		this.configRepository = configRepository;
+		this.secretsRepository = secretsRepository;
+		this.providerRuntimeManager = providerRuntimeManager;
+		this.outputFileManager = outputFileManager;
+	}
+	generate = async (input) => {
+		const route = parseModelRoute(input.model);
+		const providerConfig = await this.configRepository.getProvider(route.providerId);
+		await this.configRepository.getModel(route.providerId, route.providerLocalModel);
+		const provider = this.providerRuntimeManager.getImageProvider(providerConfig.apiFormat);
+		const apiKey = await this.secretsRepository.getProviderApiKey(route.providerId);
+		const result = await provider.generateImage({
+			providerLocalModel: route.providerLocalModel,
+			prompt: input.prompt,
+			size: input.size,
+			n: input.n ?? 1,
+			quality: input.quality,
+			background: input.background,
+			outputFormat: input.outputFormat,
+			outputCompression: input.outputCompression,
+			moderation: input.moderation
+		}, {
+			providerId: route.providerId,
+			apiFormat: providerConfig.apiFormat,
+			apiBase: providerConfig.apiBase,
+			apiKey,
+			headers: providerConfig.headers
+		});
+		const assets = await this.outputFileManager.writeImages(result.images, input.outputDir, input.outputName);
+		return {
+			ok: true,
+			kind: "image",
+			provider: route.providerId,
+			apiFormat: providerConfig.apiFormat,
+			model: input.model,
+			providerLocalModel: route.providerLocalModel,
+			assets,
+			usage: result.usage,
+			metadata: {
+				...result.metadata,
+				upstreamRequestId: result.upstreamRequestId
+			}
+		};
+	};
+};
+//#endregion
+//#region src/utils/mime.utils.ts
+const mimeTypeToExtension = (mimeType) => {
+	switch (mimeType.toLowerCase()) {
+		case "image/jpeg":
+		case "image/jpg": return "jpg";
+		case "image/png": return "png";
+		case "image/webp": return "webp";
+		case "image/gif": return "gif";
+		default: return "bin";
+	}
+};
+const extensionToMimeType = (extension) => {
+	switch (extension.toLowerCase()) {
+		case "jpg":
+		case "jpeg": return "image/jpeg";
+		case "png": return "image/png";
+		case "webp": return "image/webp";
+		case "gif": return "image/gif";
+		default: return "application/octet-stream";
+	}
+};
+//#endregion
+//#region src/managers/output-file.manager.ts
+var OutputFileManager = class {
+	writeImages = async (images, outputDir, outputName) => {
+		this.assertOutputName(outputName);
+		await mkdir(outputDir, { recursive: true });
+		const resolvedOutputDir = resolve(outputDir);
+		const assets = [];
+		for (let index = 0; index < images.length; index += 1) {
+			const image = images[index];
+			const extension = image.format ?? mimeTypeToExtension(image.mimeType);
+			const filename = this.createFilename(outputName, extension, images.length, index);
+			const path = resolve(resolvedOutputDir, filename);
+			this.assertContainedPath(resolvedOutputDir, path);
+			await writeFile(path, image.bytes, { flag: "wx" });
+			const fileStat = await stat(path);
+			assets.push({
+				path,
+				filename,
+				mimeType: image.mimeType,
+				format: extension,
+				width: image.width,
+				height: image.height,
+				sizeBytes: fileStat.size
+			});
+		}
+		return assets;
+	};
+	assertOutputName = (outputName) => {
+		if (!outputName || outputName !== basename(outputName) || outputName.includes("/") || outputName.includes("\\")) throw new AigenError("INVALID_ARGUMENT", "output-name must be a basename without path separators.");
+	};
+	assertContainedPath = (outputDir, path) => {
+		if (path !== outputDir && !path.startsWith(`${outputDir}/`)) throw new AigenError("FILE_WRITE_FAILED", "Generated file path escaped output-dir.");
+	};
+	createFilename = (outputName, extension, count, index) => {
+		return `${outputName}${count === 1 ? "" : `-${index + 1}`}.${extension}`;
+	};
+};
+//#endregion
+//#region src/types/provider.types.ts
+const isRemoteModelListProvider = (provider) => "listRemoteModels" in provider && typeof provider.listRemoteModels === "function";
+//#endregion
+//#region src/managers/provider-runtime.manager.ts
+var ProviderRuntimeManager = class {
+	providers = /* @__PURE__ */ new Map();
+	constructor(providers) {
+		providers.forEach((provider) => {
+			this.providers.set(provider.apiFormat, provider);
+		});
+	}
+	getImageProvider = (apiFormat) => {
+		const provider = this.providers.get(apiFormat);
+		if (!provider) throw new AigenError("PROVIDER_RUNTIME_NOT_FOUND", `API format '${apiFormat}' is not supported.`);
+		return provider;
+	};
+	getRemoteModelListProvider = (apiFormat) => {
+		const provider = this.getImageProvider(apiFormat);
+		if (!isRemoteModelListProvider(provider)) throw new AigenError("UNSUPPORTED_PARAMETER", `API format '${apiFormat}' does not support remote model list.`);
+		return provider;
+	};
+};
+//#endregion
+//#region src/utils/data-url.utils.ts
+const parseImageDataUrl = (value) => {
+	const match = /^data:([^;,]+);base64,(.+)$/s.exec(value);
+	if (!match) throw new AigenError("PROVIDER_REQUEST_FAILED", "Provider returned an invalid image data URL.");
+	return {
+		mimeType: match[1] ?? "application/octet-stream",
+		bytes: Uint8Array.from(Buffer.from(match[2] ?? "", "base64"))
+	};
+};
+const isDataUrl = (value) => value.startsWith("data:");
+//#endregion
+//#region src/providers/openrouter.provider.ts
+var OpenRouterProvider = class {
+	apiFormat = "openrouter";
+	generateImage = async (request, context) => {
+		const response = await fetch(this.url(context.apiBase, "/chat/completions"), {
+			method: "POST",
+			headers: this.headers(context),
+			body: JSON.stringify(this.toChatCompletionsBody(request))
+		});
+		const payload = await this.readJson(response);
+		if (!response.ok) throw new AigenError("PROVIDER_REQUEST_FAILED", "OpenRouter image generation request failed.", { retryable: response.status >= 500 });
+		return {
+			images: await this.extractImages(payload),
+			usage: this.recordOrUndefined(payload.usage),
+			upstreamRequestId: this.stringOrUndefined(payload.id),
+			metadata: { model: this.stringOrUndefined(payload.model) }
+		};
+	};
+	listRemoteModels = async (_request, context) => {
+		const response = await fetch(this.url(context.apiBase, "/models?output_modalities=image"), {
+			method: "GET",
+			headers: this.headers(context)
+		});
+		const payload = await this.readJson(response);
+		if (!response.ok) throw new AigenError("PROVIDER_REQUEST_FAILED", "OpenRouter models request failed.", { retryable: response.status >= 500 });
+		return { models: (Array.isArray(payload.data) ? payload.data : []).flatMap((entry) => {
+			const model = this.recordOrUndefined(entry);
+			const id = this.stringOrUndefined(model?.id);
+			if (!model || !id) return [];
+			return [{
+				providerLocalModel: id,
+				displayName: this.stringOrUndefined(model.name),
+				inputModalities: this.stringArrayOrUndefined(this.recordOrUndefined(model.architecture)?.input_modalities),
+				outputModalities: this.stringArrayOrUndefined(this.recordOrUndefined(model.architecture)?.output_modalities),
+				pricing: this.recordOrUndefined(model.pricing),
+				metadata: model
+			}];
+		}) };
+	};
+	toChatCompletionsBody = (request) => {
+		const body = {
+			model: request.providerLocalModel,
+			messages: [{
+				role: "user",
+				content: request.prompt
+			}],
+			modalities: ["image"],
+			stream: false
+		};
+		if (request.size) body.image_config = { image_size: request.size };
+		return body;
+	};
+	extractImages = async (payload) => {
+		const urls = (Array.isArray(payload.choices) ? payload.choices : []).flatMap((choice) => this.extractImageUrls(choice));
+		if (urls.length === 0) throw new AigenError("PROVIDER_REQUEST_FAILED", "OpenRouter response did not include generated images.");
+		return Promise.all(urls.map((url) => this.loadImageUrl(url)));
+	};
+	extractImageUrls = (choice) => {
+		const message = this.recordOrUndefined(this.recordOrUndefined(choice)?.message);
+		return (Array.isArray(message?.images) ? message.images : []).flatMap((image) => {
+			const url = this.stringOrUndefined(this.recordOrUndefined(this.recordOrUndefined(image)?.image_url)?.url);
+			return url ? [url] : [];
+		});
+	};
+	loadImageUrl = async (url) => {
+		if (isDataUrl(url)) {
+			const dataUrl = parseImageDataUrl(url);
+			return {
+				bytes: dataUrl.bytes,
+				mimeType: dataUrl.mimeType
+			};
+		}
+		const response = await fetch(url);
+		if (!response.ok) throw new AigenError("PROVIDER_REQUEST_FAILED", "Failed to download generated image.", { retryable: response.status >= 500 });
+		const contentType = response.headers.get("content-type") ?? this.mimeTypeFromUrl(url);
+		return {
+			bytes: new Uint8Array(await response.arrayBuffer()),
+			mimeType: contentType
+		};
+	};
+	readJson = async (response) => {
+		const value = await response.json();
+		const record = this.recordOrUndefined(value);
+		if (!record) throw new AigenError("PROVIDER_REQUEST_FAILED", "Provider returned a non-object JSON response.");
+		return record;
+	};
+	headers = (context) => ({
+		authorization: `Bearer ${context.apiKey}`,
+		"content-type": "application/json",
+		...context.headers
+	});
+	url = (apiBase, path) => `${apiBase.replace(/\/$/, "")}${path}`;
+	recordOrUndefined = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+	stringOrUndefined = (value) => typeof value === "string" ? value : void 0;
+	stringArrayOrUndefined = (value) => Array.isArray(value) && value.every((item) => typeof item === "string") ? value : void 0;
+	mimeTypeFromUrl = (url) => {
+		const extension = url.split("?")[0]?.split(".").pop();
+		return extension ? extensionToMimeType(extension) : "application/octet-stream";
+	};
+};
+//#endregion
+//#region src/types/config.types.ts
+const createEmptyAigenConfig = () => ({
+	version: 1,
+	providers: {}
+});
+//#endregion
+//#region src/repositories/config.repository.ts
+var ConfigRepository = class {
+	homeDir;
+	configPath;
+	constructor(homeDir = process.env.AIGEN_HOME ?? join(homedir(), ".aigen")) {
+		this.homeDir = homeDir;
+		this.configPath = join(homeDir, "config.json");
+	}
+	readConfig = async () => {
+		try {
+			const text = await readFile(this.configPath, "utf8");
+			return this.parseConfig(text);
+		} catch (error) {
+			if (this.isNotFoundError(error)) throw new AigenError("CONFIG_NOT_FOUND", "aigen config.json does not exist.");
+			throw error;
+		}
+	};
+	readConfigOrCreate = async () => {
+		try {
+			return await this.readConfig();
+		} catch (error) {
+			if (error instanceof AigenError && error.code === "CONFIG_NOT_FOUND") return createEmptyAigenConfig();
+			throw error;
+		}
+	};
+	writeConfig = async (config) => {
+		await mkdir(this.homeDir, { recursive: true });
+		await writeFile(this.configPath, `${JSON.stringify(config, null, 2)}\n`, { mode: 384 });
+	};
+	listProviders = async () => {
+		const config = await this.readConfig();
+		return Object.entries(config.providers).map(([id, providerConfig]) => ({
+			id,
+			config: providerConfig
+		}));
+	};
+	getProvider = async (providerId) => {
+		const providerConfig = (await this.readConfig()).providers[providerId];
+		if (!providerConfig) throw new AigenError("PROVIDER_NOT_FOUND", `Provider '${providerId}' does not exist.`);
+		return providerConfig;
+	};
+	addProvider = async (providerId, providerConfig) => {
+		assertResourceId(providerId, "Provider id");
+		const config = await this.readConfigOrCreate();
+		if (config.providers[providerId]) throw new AigenError("INVALID_ARGUMENT", `Provider '${providerId}' already exists.`);
+		config.providers[providerId] = providerConfig;
+		await this.writeConfig(config);
+	};
+	updateProvider = async (providerId, patch) => {
+		const config = await this.readConfig();
+		const current = config.providers[providerId];
+		if (!current) throw new AigenError("PROVIDER_NOT_FOUND", `Provider '${providerId}' does not exist.`);
+		const next = {
+			...current,
+			apiFormat: patch.apiFormat ?? current.apiFormat,
+			displayName: patch.displayName ?? current.displayName,
+			apiBase: patch.apiBase ?? current.apiBase,
+			apiKeyRef: patch.apiKeyRef ?? current.apiKeyRef,
+			headers: patch.headers ?? current.headers
+		};
+		config.providers[providerId] = next;
+		await this.writeConfig(config);
+		return next;
+	};
+	removeProvider = async (providerId) => {
+		const config = await this.readConfig();
+		if (!config.providers[providerId]) throw new AigenError("PROVIDER_NOT_FOUND", `Provider '${providerId}' does not exist.`);
+		delete config.providers[providerId];
+		await this.writeConfig(config);
+	};
+	listModels = async (providerId, kind) => {
+		const config = await this.readConfig();
+		return (providerId ? [[providerId, await this.getProvider(providerId)]] : Object.entries(config.providers)).flatMap(([id, providerConfig]) => Object.entries(providerConfig.models).filter(([, modelConfig]) => !kind || modelConfig.kind === kind).map(([providerLocalModel, modelConfig]) => ({
+			route: `${id}/${providerLocalModel}`,
+			providerId: id,
+			providerLocalModel,
+			config: modelConfig
+		})));
+	};
+	getModel = async (providerId, providerLocalModel) => {
+		const modelConfig = (await this.getProvider(providerId)).models[providerLocalModel];
+		if (!modelConfig) throw new AigenError("MODEL_NOT_FOUND", `Model '${providerId}/${providerLocalModel}' does not exist.`);
+		return modelConfig;
+	};
+	addModel = async (providerId, providerLocalModel, modelConfig) => {
+		const config = await this.readConfig();
+		const providerConfig = config.providers[providerId];
+		if (!providerConfig) throw new AigenError("PROVIDER_NOT_FOUND", `Provider '${providerId}' does not exist.`);
+		if (providerConfig.models[providerLocalModel]) throw new AigenError("INVALID_ARGUMENT", `Model '${providerId}/${providerLocalModel}' already exists.`);
+		providerConfig.models[providerLocalModel] = modelConfig;
+		await this.writeConfig(config);
+	};
+	updateModel = async (providerId, providerLocalModel, patch) => {
+		const config = await this.readConfig();
+		const providerConfig = config.providers[providerId];
+		if (!providerConfig) throw new AigenError("PROVIDER_NOT_FOUND", `Provider '${providerId}' does not exist.`);
+		const current = providerConfig.models[providerLocalModel];
+		if (!current) throw new AigenError("MODEL_NOT_FOUND", `Model '${providerId}/${providerLocalModel}' does not exist.`);
+		const next = {
+			...current,
+			kind: patch.kind ?? current.kind,
+			displayName: patch.displayName ?? current.displayName,
+			capabilities: patch.capabilities ?? current.capabilities
+		};
+		providerConfig.models[providerLocalModel] = next;
+		await this.writeConfig(config);
+		return next;
+	};
+	removeModel = async (providerId, providerLocalModel) => {
+		const config = await this.readConfig();
+		const providerConfig = config.providers[providerId];
+		if (!providerConfig) throw new AigenError("PROVIDER_NOT_FOUND", `Provider '${providerId}' does not exist.`);
+		if (!providerConfig.models[providerLocalModel]) throw new AigenError("MODEL_NOT_FOUND", `Model '${providerId}/${providerLocalModel}' does not exist.`);
+		delete providerConfig.models[providerLocalModel];
+		await this.writeConfig(config);
+	};
+	clear = async () => {
+		await rm(this.configPath, { force: true });
+	};
+	parseConfig = (text) => {
+		const value = JSON.parse(text);
+		if (value.version !== 1 || !value.providers || typeof value.providers !== "object") throw new AigenError("CONFIG_INVALID", "aigen config.json is invalid.");
+		return {
+			version: 1,
+			providers: value.providers
+		};
+	};
+	isNotFoundError = (error) => error instanceof Error && "code" in error && error.code === "ENOENT";
+};
+//#endregion
+//#region src/repositories/secrets.repository.ts
+var SecretsRepository = class {
+	homeDir;
+	secretsPath;
+	constructor(homeDir = process.env.AIGEN_HOME ?? join(homedir(), ".aigen")) {
+		this.homeDir = homeDir;
+		this.secretsPath = join(homeDir, "secrets.json");
+	}
+	setProviderApiKey = async (providerId, value) => {
+		const trimmedValue = value.trim();
+		if (!trimmedValue) throw new AigenError("INVALID_ARGUMENT", "API key cannot be empty.");
+		const secretsFile = await this.readSecretsOrCreate();
+		const ref = this.providerRef(providerId);
+		secretsFile.secrets[ref] = {
+			kind: "apiKey",
+			value: trimmedValue,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		await this.writeSecrets(secretsFile);
+		return this.toMetadata(ref, secretsFile.secrets[ref]);
+	};
+	getProviderApiKey = async (providerId) => {
+		const ref = this.providerRef(providerId);
+		return (await this.getSecretEntry(ref)).value;
+	};
+	getProviderSecret = async (providerId) => {
+		const ref = this.providerRef(providerId);
+		const entry = await this.getSecretEntry(ref);
+		return this.toMetadata(ref, entry);
+	};
+	listSecrets = async () => {
+		const secretsFile = await this.readSecretsOrCreate();
+		return Object.entries(secretsFile.secrets).map(([ref, entry]) => this.toMetadata(ref, entry));
+	};
+	removeProviderSecret = async (providerId) => {
+		const secretsFile = await this.readSecretsOrCreate();
+		const ref = this.providerRef(providerId);
+		if (!secretsFile.secrets[ref]) throw new AigenError("SECRET_NOT_FOUND", `Secret '${ref}' does not exist.`);
+		delete secretsFile.secrets[ref];
+		await this.writeSecrets(secretsFile);
+	};
+	clear = async () => {
+		await rm(this.secretsPath, { force: true });
+	};
+	getSecretEntry = async (ref) => {
+		const entry = (await this.readSecretsOrCreate()).secrets[ref];
+		if (!entry) throw new AigenError("MISSING_API_KEY", `Secret '${ref}' does not exist.`);
+		return entry;
+	};
+	readSecretsOrCreate = async () => {
+		try {
+			const text = await readFile(this.secretsPath, "utf8");
+			const value = JSON.parse(text);
+			if (value.version !== 1 || !value.secrets || typeof value.secrets !== "object") throw new AigenError("CONFIG_INVALID", "aigen secrets.json is invalid.");
+			return {
+				version: 1,
+				secrets: value.secrets
+			};
+		} catch (error) {
+			if (error instanceof Error && "code" in error && error.code === "ENOENT") return {
+				version: 1,
+				secrets: {}
+			};
+			throw error;
+		}
+	};
+	writeSecrets = async (secretsFile) => {
+		await mkdir(this.homeDir, { recursive: true });
+		await writeFile(this.secretsPath, `${JSON.stringify(secretsFile, null, 2)}\n`, { mode: 384 });
+		await chmod(this.secretsPath, 384);
+	};
+	providerRef = (providerId) => `provider:${providerId}`;
+	toMetadata = (ref, entry) => ({
+		ref,
+		kind: entry.kind,
+		exists: true,
+		maskedValue: this.maskValue(entry.value),
+		fingerprint: this.fingerprint(entry.value),
+		updatedAt: entry.updatedAt
+	});
+	maskValue = (value) => {
+		if (value.length <= 8) return "********";
+		return `${value.slice(0, 3)}...${value.slice(-4)}`;
+	};
+	fingerprint = (value) => `sha256:${createHash("sha256").update(value).digest("hex").slice(0, 12)}`;
+};
+//#endregion
+//#region src/utils/error.utils.ts
+const toCommandFailure = (error) => {
+	if (error instanceof AigenError) return {
+		ok: false,
+		error: {
+			code: error.code,
+			message: error.message,
+			retryable: error.retryable
+		}
+	};
+	return {
+		ok: false,
+		error: {
+			code: "PROVIDER_REQUEST_FAILED",
+			message: error instanceof Error ? error.message : "Unknown aigen failure.",
+			retryable: false
+		}
+	};
+};
+//#endregion
+//#region src/app/aigen-app.ts
+var AigenApp = class {
+	constructor(imageController, providersController, modelsController, secretsController, doctorController) {
+		this.imageController = imageController;
+		this.providersController = providersController;
+		this.modelsController = modelsController;
+		this.secretsController = secretsController;
+		this.doctorController = doctorController;
+	}
+	run = async (argv) => {
+		let commandOutput;
+		let commanderOut = "";
+		let commanderErr = "";
+		const program = this.createProgram((output) => {
+			commandOutput = output;
+		});
+		program.configureOutput({
+			writeOut: (value) => {
+				commanderOut += value;
+			},
+			writeErr: (value) => {
+				commanderErr += value;
+			}
+		});
+		try {
+			if (argv.length === 0) throw new AigenError("INVALID_ARGUMENT", "Missing command.");
+			await program.parseAsync(argv, { from: "user" });
+			return commandOutput ?? {
+				ok: true,
+				output: commanderOut.trim()
+			};
+		} catch (error) {
+			if (error instanceof CommanderError) return this.commanderFailure(error, commanderOut, commanderErr);
+			return toCommandFailure(error);
+		}
+	};
+	createProgram = (sink) => {
+		const program = new Command();
+		program.name("aigen").description("Stateless AI media generation CLI.").version("0.0.0", "-v, --version");
+		program.exitOverride();
+		program.showHelpAfterError();
+		registerAigenCommands(program, {
+			imageController: this.imageController,
+			providersController: this.providersController,
+			modelsController: this.modelsController,
+			secretsController: this.secretsController,
+			doctorController: this.doctorController
+		}, sink);
+		return program;
+	};
+	commanderFailure = (error, capturedOutput, capturedError) => {
+		const output = capturedOutput.trim();
+		if (error.exitCode === 0) return {
+			ok: true,
+			output
+		};
+		return {
+			ok: false,
+			error: {
+				code: "INVALID_ARGUMENT",
+				message: capturedError.trim() || error.message,
+				retryable: false
+			}
+		};
+	};
+};
+const createAigenApp = (homeDir) => {
+	const configRepository = new ConfigRepository(homeDir);
+	const secretsRepository = new SecretsRepository(homeDir);
+	const providerRuntimeManager = new ProviderRuntimeManager([new OpenRouterProvider()]);
+	return new AigenApp(new ImageController(new ImageGenerationManager(configRepository, secretsRepository, providerRuntimeManager, new OutputFileManager())), new ProvidersController(configRepository), new ModelsController(configRepository, secretsRepository, providerRuntimeManager), new SecretsController(secretsRepository), new DoctorController(configRepository, secretsRepository, providerRuntimeManager));
+};
+//#endregion
+//#region src/app/main.ts
+const output = await createAigenApp().run(process.argv.slice(2));
+process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+process.exitCode = output.ok ? 0 : 1;
+//#endregion
+export {};
+
+//# sourceMappingURL=main.js.map