@agimon-ai/model-proxy-mcp 0.2.0

package/dist/cli.mjs

@@ -0,0 +1,630 @@
+#!/usr/bin/env node
+import { c as DEFAULT_HTTP_PORT, i as GatewayService, l as DEFAULT_SERVICE_NAME, n as createServer, o as ProfileStore, r as createHttpServer, s as consoleLogger, t as StdioTransportHandler } from "./stdio-C23n_O3v.mjs";
+import { existsSync, readFileSync } from "node:fs";
+import path, { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Command } from "commander";
+import { execFile, spawn } from "node:child_process";
+import { randomBytes, randomUUID } from "node:crypto";
+import fs$1 from "node:fs/promises";
+import os from "node:os";
+import { promisify } from "node:util";
+import { serve } from "@hono/node-server";
+
+//#region src/services/HttpServerHealthCheck.ts
+var HttpServerHealthCheck = class {
+	async check(port) {
+		try {
+			const response = await fetch(`http://127.0.0.1:${port}/health`);
+			if (!response.ok) return {
+				healthy: false,
+				error: `Health check failed with status ${response.status}`
+			};
+			return {
+				healthy: true,
+				serviceName: (await response.json()).service
+			};
+		} catch (error) {
+			return {
+				healthy: false,
+				error: error instanceof Error ? error.message : String(error)
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/services/HttpServerManager.ts
+const WORKSPACE_MARKERS = [
+	"pnpm-workspace.yaml",
+	"nx.json",
+	".git"
+];
+const PORT_SCAN_RANGE = 25;
+const SHELL_BINARY = "sh";
+const LSOF_COMMAND_PREFIX = "lsof -n -P -sTCP:LISTEN";
+const HEALTH_CHECK_STABILIZE_MS = 5e3;
+const HEALTH_CHECK_POLL_INTERVAL_MS = 250;
+const PROCESS_SHUTDOWN_WAIT_MS = 1e3;
+const SIGTERM_SIGNAL = "SIGTERM";
+const SIGKILL_SIGNAL = "SIGKILL";
+const STATE_FILE_PREFIX = "model-proxy-mcp-http";
+const STATE_FILE_ENCODING = "utf8";
+const execFileAsync = promisify(execFile);
+function resolveWorkspaceRoot(startPath = process.cwd()) {
+	let currentDir = path.resolve(startPath);
+	while (true) {
+		for (const marker of WORKSPACE_MARKERS) if (existsSync(path.join(currentDir, marker))) return currentDir;
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) return process.cwd();
+		currentDir = parentDir;
+	}
+}
+var HttpServerManager = class {
+	repositoryPath = resolveWorkspaceRoot(process.cwd());
+	serviceName = DEFAULT_SERVICE_NAME;
+	stateFilePath = path.join(os.tmpdir(), `${STATE_FILE_PREFIX}-${Buffer.from(resolveWorkspaceRoot(process.cwd())).toString("hex")}.json`);
+	constructor(healthCheck = new HttpServerHealthCheck()) {
+		this.healthCheck = healthCheck;
+	}
+	createEmptyStatus(overrides = {}) {
+		return {
+			running: false,
+			scope: "default",
+			activeProfileId: null,
+			auth: {
+				configured: false,
+				authFilePath: ""
+			},
+			profiles: [],
+			slotModels: {},
+			...overrides
+		};
+	}
+	async getRegistration() {
+		try {
+			const rawState = await fs$1.readFile(this.stateFilePath, STATE_FILE_ENCODING);
+			const parsed = JSON.parse(rawState);
+			return parsed.port ? parsed : null;
+		} catch (error) {
+			if (error.code === "ENOENT") return null;
+			throw error;
+		}
+	}
+	async releaseService(pid) {
+		const registration = await this.getRegistration();
+		if (pid && registration?.pid && registration.pid !== pid) return;
+		await fs$1.rm(this.stateFilePath, { force: true });
+	}
+	async listListeningProcesses(port) {
+		try {
+			const { stdout } = await execFileAsync(SHELL_BINARY, ["-lc", `${LSOF_COMMAND_PREFIX} -iTCP:${port} || true`], { encoding: "utf8" });
+			return stdout.split("\n").slice(1).map((line) => line.trim()).filter(Boolean).map((line) => line.split(/\s+/)).map((parts) => ({
+				pid: Number.parseInt(parts[1] || "", 10),
+				port
+			})).filter((listener) => Number.isInteger(listener.pid) && listener.pid > 0);
+		} catch (error) {
+			return [];
+		}
+	}
+	async findHealthyServicePort(startPort) {
+		for (let offset = 0; offset <= PORT_SCAN_RANGE; offset += 1) {
+			const candidatePort = startPort + offset;
+			const health = await this.healthCheck.check(candidatePort);
+			if (health.healthy && health.serviceName === this.serviceName) return candidatePort;
+		}
+		return null;
+	}
+	async clearPortListeners(port, preservePid) {
+		const listeners = await this.listListeningProcesses(port);
+		for (const listener of listeners) {
+			if (preservePid && listener.pid === preservePid) continue;
+			await this.killProcess(listener.pid);
+		}
+	}
+	async registerService(port, pid) {
+		await fs$1.writeFile(this.stateFilePath, JSON.stringify({
+			port,
+			pid
+		}), STATE_FILE_ENCODING);
+	}
+	async findAvailablePort(startPort) {
+		const minimumPort = Math.min(DEFAULT_HTTP_PORT, startPort);
+		const maximumPort = Math.max(DEFAULT_HTTP_PORT + 1e3, startPort);
+		for (let candidatePort = startPort; candidatePort <= maximumPort; candidatePort += 1) if ((await this.listListeningProcesses(candidatePort)).length === 0) return candidatePort;
+		for (let candidatePort = minimumPort; candidatePort < startPort; candidatePort += 1) if ((await this.listListeningProcesses(candidatePort)).length === 0) return candidatePort;
+		throw new Error(`No available port found from ${startPort}`);
+	}
+	async fileExists(filePath) {
+		try {
+			await fs$1.access(filePath);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async startHttpServer(port) {
+		const distCliPath = path.join(this.repositoryPath, "packages", "mcp", "model-proxy-mcp", "dist", "cli.mjs");
+		const srcCliPath = path.join(this.repositoryPath, "packages", "mcp", "model-proxy-mcp", "src", "cli.ts");
+		const command = "node";
+		let args;
+		if (await this.fileExists(distCliPath)) args = [
+			distCliPath,
+			"http-serve",
+			"--port",
+			String(port)
+		];
+		else if (await this.fileExists(srcCliPath)) args = [
+			"--loader",
+			"ts-node/esm",
+			srcCliPath,
+			"http-serve",
+			"--port",
+			String(port)
+		];
+		else throw new Error("Cannot find model-proxy-mcp CLI");
+		const child = spawn(command, args, {
+			detached: true,
+			stdio: "ignore",
+			env: {
+				...process.env,
+				NODE_ENV: process.env.NODE_ENV || "development"
+			}
+		});
+		child.unref();
+		if (!child.pid) throw new Error("Failed to spawn HTTP server");
+		return child.pid;
+	}
+	async killProcess(pid) {
+		try {
+			process.kill(pid, SIGTERM_SIGNAL);
+			await new Promise((resolve) => setTimeout(resolve, PROCESS_SHUTDOWN_WAIT_MS));
+			try {
+				process.kill(pid, 0);
+				process.kill(pid, SIGKILL_SIGNAL);
+			} catch {
+				return;
+			}
+		} catch {
+			return;
+		}
+	}
+	async waitForHealthy(port) {
+		const deadline = Date.now() + HEALTH_CHECK_STABILIZE_MS;
+		let lastError = "Server failed health check after startup";
+		while (Date.now() < deadline) {
+			const health = await this.healthCheck.check(port);
+			if (health.healthy && health.serviceName === this.serviceName) return { healthy: true };
+			lastError = health.error || `Unexpected service on port ${port}`;
+			await new Promise((resolve) => setTimeout(resolve, HEALTH_CHECK_POLL_INTERVAL_MS));
+		}
+		return {
+			healthy: false,
+			error: lastError
+		};
+	}
+	async ensureRunning(port = DEFAULT_HTTP_PORT) {
+		try {
+			const healthyPort = await this.findHealthyServicePort(port);
+			if (healthyPort !== null) {
+				const healthyPid = (await this.listListeningProcesses(healthyPort))[0]?.pid;
+				await this.registerService(healthyPort, healthyPid ?? process.pid);
+				return this.createEmptyStatus({
+					running: true,
+					port: healthyPort,
+					pid: healthyPid
+				});
+			}
+			const existing = await this.getRegistration();
+			if (existing) {
+				const health$1 = await this.healthCheck.check(existing.port);
+				if (health$1.healthy && health$1.serviceName === this.serviceName) return this.createEmptyStatus({
+					running: true,
+					port: existing.port,
+					pid: existing.pid
+				});
+				if (existing.pid) await this.killProcess(existing.pid);
+				await this.clearPortListeners(existing.port, existing.pid);
+				await this.releaseService(existing.pid);
+			}
+			await this.clearPortListeners(port);
+			const availablePort = await this.findAvailablePort(port);
+			const pid = await this.startHttpServer(availablePort);
+			const health = await this.waitForHealthy(availablePort);
+			if (!health.healthy) {
+				await this.killProcess(pid);
+				await this.clearPortListeners(availablePort, pid);
+				await this.releaseService(pid);
+				return this.createEmptyStatus({ error: health.error || "Server failed health check after startup" });
+			}
+			await this.registerService(availablePort, pid);
+			return this.createEmptyStatus({
+				running: true,
+				port: availablePort,
+				pid
+			});
+		} catch (error) {
+			return this.createEmptyStatus({ error: error instanceof Error ? error.message : String(error) });
+		}
+	}
+	async stop() {
+		const registration = await this.getRegistration();
+		let stopped = false;
+		if (registration?.pid) {
+			await this.killProcess(registration.pid);
+			stopped = true;
+		}
+		if (registration) {
+			await this.clearPortListeners(registration.port, registration.pid);
+			await this.releaseService(registration.pid);
+		}
+		const healthyPort = await this.findHealthyServicePort(DEFAULT_HTTP_PORT);
+		if (healthyPort !== null) {
+			const listeners = await this.listListeningProcesses(healthyPort);
+			for (const listener of listeners) {
+				await this.killProcess(listener.pid);
+				stopped = true;
+			}
+			await this.releaseService();
+		}
+		return stopped;
+	}
+	async getStatus() {
+		const registration = await this.getRegistration();
+		if (registration) {
+			if ((await this.healthCheck.check(registration.port)).healthy) return this.createEmptyStatus({
+				running: true,
+				port: registration.port,
+				pid: registration.pid
+			});
+		}
+		const healthyPort = await this.findHealthyServicePort(DEFAULT_HTTP_PORT);
+		if (healthyPort !== null) {
+			const pid = (await this.listListeningProcesses(healthyPort))[0]?.pid;
+			if (pid) await this.registerService(healthyPort, pid);
+			return this.createEmptyStatus({
+				running: true,
+				port: healthyPort,
+				pid
+			});
+		}
+		return this.createEmptyStatus({ error: registration ? "Registered server is unhealthy" : "No HTTP server registered" });
+	}
+};
+
+//#endregion
+//#region src/commands/claude.ts
+const CLAUDE_BINARY = "claude";
+const DEFAULT_SCOPE$2 = "default";
+const SESSIONS_DIRECTORY_NAME = ".claude-sessions";
+const RANDOM_SCOPE_PREFIX = "scope";
+const RANDOM_SCOPE_BYTES = 3;
+const TEXT_ENCODING = "utf8";
+const STDIO_INHERIT = "inherit";
+const DECIMAL_RADIX = 10;
+const LOG_PREFIX = "[model-proxy-mcp]";
+const RECOVERY_MESSAGE = `Recovery: verify HOME, proxy port, and that \`${CLAUDE_BINARY}\` is on PATH.`;
+const ARG_RESUME = "--resume";
+const ARG_SESSION_ID = "--session-id";
+const ARG_SKIP_PERMISSIONS = "--dangerously-skip-permissions";
+const MODEL_ALIAS_OPUS = "ccproxy-opus";
+const MODEL_ALIAS_SONNET = "ccproxy-sonnet";
+const MODEL_ALIAS_HAIKU = "ccproxy-haiku";
+const MODEL_ALIAS_SUBAGENT = "ccproxy-subagent";
+const DEFAULT_SCOPE_SEED_FILE = "model-proxy-mcp.yaml";
+const MODEL_PROXY_SCOPE_ENV$1 = "MODEL_PROXY_MCP_SCOPE";
+const MODEL_PROXY_SLOT_ENV = "MODEL_PROXY_MCP_SLOT";
+const DEFAULT_MODEL_PROXY_SLOT = "default";
+var ClaudeCommandError = class extends Error {
+	constructor(message, code, options) {
+		super(message, options);
+		this.code = code;
+		this.name = "ClaudeCommandError";
+	}
+};
+var ClaudeCommandConfigError = class extends ClaudeCommandError {
+	constructor(message, options) {
+		super(message, "CLAUDE_COMMAND_CONFIG_ERROR", options);
+		this.name = "ClaudeCommandConfigError";
+	}
+};
+var ClaudeCommandValidationError = class extends ClaudeCommandError {
+	constructor(message, options) {
+		super(message, "CLAUDE_COMMAND_VALIDATION_ERROR", options);
+		this.name = "ClaudeCommandValidationError";
+	}
+};
+var ClaudeCommandLaunchError = class extends ClaudeCommandError {
+	constructor(message, options) {
+		super(message, "CLAUDE_COMMAND_LAUNCH_ERROR", options);
+		this.name = "ClaudeCommandLaunchError";
+	}
+};
+function sanitizeScope(scope) {
+	return scope.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || DEFAULT_SCOPE$2;
+}
+function generateScopeName() {
+	return `${RANDOM_SCOPE_PREFIX}-${randomBytes(RANDOM_SCOPE_BYTES).toString("hex")}`;
+}
+function buildClaudeEnvironment(port, scope, baseEnvironment = process.env) {
+	return {
+		...baseEnvironment,
+		ANTHROPIC_BASE_URL: `http://127.0.0.1:${port}/scopes/${scope}`,
+		ANTHROPIC_DEFAULT_OPUS_MODEL: baseEnvironment.ANTHROPIC_DEFAULT_OPUS_MODEL || MODEL_ALIAS_OPUS,
+		ANTHROPIC_DEFAULT_SONNET_MODEL: baseEnvironment.ANTHROPIC_DEFAULT_SONNET_MODEL || MODEL_ALIAS_SONNET,
+		ANTHROPIC_DEFAULT_HAIKU_MODEL: baseEnvironment.ANTHROPIC_DEFAULT_HAIKU_MODEL || MODEL_ALIAS_HAIKU,
+		CLAUDE_CODE_SUBAGENT_MODEL: baseEnvironment.CLAUDE_CODE_SUBAGENT_MODEL || MODEL_ALIAS_SUBAGENT,
+		MODEL_PROXY_MCP_SCOPE: baseEnvironment[MODEL_PROXY_SCOPE_ENV$1] || scope,
+		MODEL_PROXY_MCP_SLOT: baseEnvironment[MODEL_PROXY_SLOT_ENV] || DEFAULT_MODEL_PROXY_SLOT
+	};
+}
+async function resolveScopeSeedConfigPath(configFile, workingDirectory = process.cwd()) {
+	const candidate = configFile ? path.resolve(workingDirectory, configFile) : path.join(workingDirectory, DEFAULT_SCOPE_SEED_FILE);
+	try {
+		if (!(await fs$1.stat(candidate)).isFile()) {
+			if (configFile) throw new ClaudeCommandConfigError(`Scope seed config path is not a file: ${candidate}`);
+			return;
+		}
+		return candidate;
+	} catch (error) {
+		if (error.code === "ENOENT") {
+			if (configFile) throw new ClaudeCommandConfigError(`Scope seed config file not found: ${candidate}`, { cause: error });
+			return;
+		}
+		if (error instanceof ClaudeCommandConfigError) throw error;
+		throw new ClaudeCommandConfigError(`Failed to read scope seed config file: ${candidate}`, { cause: error });
+	}
+}
+function getSessionsDirectory() {
+	const homeDirectory = process.env.HOME || process.env.USERPROFILE;
+	if (!homeDirectory) throw new ClaudeCommandConfigError("HOME or USERPROFILE is not set");
+	return path.join(homeDirectory, SESSIONS_DIRECTORY_NAME);
+}
+async function ensureSessionsDirectory() {
+	const sessionsDirectory = getSessionsDirectory();
+	await fs$1.mkdir(sessionsDirectory, { recursive: true });
+	return sessionsDirectory;
+}
+async function readSessionId(sessionFile) {
+	try {
+		return (await fs$1.readFile(sessionFile, TEXT_ENCODING)).trim() || null;
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw new ClaudeCommandConfigError(`Failed to read Claude session file: ${sessionFile}`, { cause: error });
+	}
+}
+async function resolveSessionId(scope, clearSession) {
+	const sessionsDirectory = await ensureSessionsDirectory();
+	const sessionFile = path.join(sessionsDirectory, scope);
+	if (clearSession) try {
+		await fs$1.rm(sessionFile, { force: true });
+	} catch (error) {
+		throw new ClaudeCommandConfigError(`Failed to clear Claude session file: ${sessionFile}`, { cause: error });
+	}
+	const existingSessionId = await readSessionId(sessionFile);
+	if (existingSessionId) return {
+		sessionId: existingSessionId,
+		resume: true
+	};
+	const sessionId = randomUUID().toLowerCase();
+	try {
+		await fs$1.writeFile(sessionFile, `${sessionId}\n`, TEXT_ENCODING);
+	} catch (error) {
+		throw new ClaudeCommandConfigError(`Failed to write Claude session file: ${sessionFile}`, { cause: error });
+	}
+	return {
+		sessionId,
+		resume: false
+	};
+}
+async function launchClaude(scope, port, clearSession, claudeArgs, configFile) {
+	const scopeSeedConfigPath = await resolveScopeSeedConfigPath(configFile);
+	await new ProfileStore().ensureConfig(scope, scopeSeedConfigPath);
+	const status = await new HttpServerManager().ensureRunning(port);
+	if (!status.running || !status.port) throw new ClaudeCommandLaunchError(status.error || "Failed to start model proxy HTTP server");
+	const { sessionId, resume } = await resolveSessionId(scope, clearSession);
+	const env = buildClaudeEnvironment(status.port, scope);
+	const args = [
+		ARG_SKIP_PERMISSIONS,
+		...resume ? [ARG_RESUME, sessionId] : [ARG_SESSION_ID, sessionId],
+		...claudeArgs
+	];
+	console.log(`${LOG_PREFIX} Scope: ${scope}`);
+	console.log(`${LOG_PREFIX} Proxy: ${env.ANTHROPIC_BASE_URL}`);
+	console.log(`${LOG_PREFIX} Session: ${sessionId}${resume ? " (resume)" : " (new)"}`);
+	if (scopeSeedConfigPath) console.log(`${LOG_PREFIX} Scope config seed: ${scopeSeedConfigPath}`);
+	return new Promise((resolve, reject) => {
+		const child = spawn(CLAUDE_BINARY, args, {
+			stdio: STDIO_INHERIT,
+			env
+		});
+		child.on("error", (error) => {
+			reject(new ClaudeCommandLaunchError(`Failed to launch ${CLAUDE_BINARY}`, { cause: error }));
+		});
+		child.on("exit", (code, signal) => {
+			if (signal) {
+				reject(new ClaudeCommandLaunchError(`${CLAUDE_BINARY} exited with signal ${signal}`));
+				return;
+			}
+			resolve(code ?? 0);
+		});
+	});
+}
+const claudeCommand = new Command("claude").description("Launch Claude Code through the model proxy").option("-s, --scope <scope>", "Proxy scope to use").option("-p, --port <port>", "Preferred HTTP port for the proxy", String(DEFAULT_HTTP_PORT)).option("-c, --config-file <path>", "Seed a new scope from the specified scope config file").option("--config <path>", "Alias for --config-file").option("--clear-session", "Start with a fresh Claude session for the selected scope", false).allowUnknownOption(true).allowExcessArguments(true).argument("[claudeArgs...]").action(async (claudeArgs, options) => {
+	try {
+		const resolvedScope = sanitizeScope(options.scope || generateScopeName());
+		const port = Number.parseInt(options.port, DECIMAL_RADIX);
+		if (!Number.isInteger(port) || port <= 0) throw new ClaudeCommandValidationError(`Invalid port: ${options.port}`);
+		const exitCode = await launchClaude(resolvedScope, port, options.clearSession, claudeArgs, options.configFile ?? options.config);
+		process.exit(exitCode);
+	} catch (error) {
+		const commandError = error instanceof ClaudeCommandError ? error : new ClaudeCommandLaunchError("Failed to launch Claude", { cause: error });
+		console.error(`${LOG_PREFIX} ${commandError.code}: ${commandError.message}`);
+		console.error(`${LOG_PREFIX} ${RECOVERY_MESSAGE}`);
+		if (commandError.cause) console.error(`${LOG_PREFIX} Cause:`, commandError.cause);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/commands/http-serve.ts
+const LOCAL_HOST = "127.0.0.1";
+const httpServeCommand = new Command("http-serve").description("Start the Claude-compatible HTTP model proxy server").option("-p, --port <port>", "Port to listen on", String(DEFAULT_HTTP_PORT)).action(async (options) => {
+	try {
+		const port = Number.parseInt(options.port, 10);
+		if (!Number.isInteger(port) || port <= 0) throw new Error(`Invalid port: ${options.port}`);
+		const gatewayService = new GatewayService();
+		await gatewayService.ensureConfig();
+		const server = serve({
+			fetch: createHttpServer(gatewayService).fetch,
+			port,
+			hostname: LOCAL_HOST
+		});
+		console.log(`model-proxy-mcp listening on http://${LOCAL_HOST}:${port}`);
+		console.log(`Claude base URL: http://${LOCAL_HOST}:${port}`);
+		const shutdown = (signal) => {
+			console.log(`\n${signal} received. Shutting down...`);
+			server.close();
+			process.exit(0);
+		};
+		process.once("SIGINT", () => shutdown("SIGINT"));
+		process.once("SIGTERM", () => shutdown("SIGTERM"));
+	} catch (error) {
+		console.error("Failed to start HTTP server:", error);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/commands/mcp-serve.ts
+const DEFAULT_SCOPE$1 = "default";
+const MODEL_PROXY_SCOPE_ENV = "MODEL_PROXY_MCP_SCOPE";
+const mcpServeCommand = new Command("mcp-serve").description("Start MCP server with stdio transport").option("--cleanup", "Stop HTTP server on shutdown", false).option("-p, --port <port>", "Port for HTTP server", String(DEFAULT_HTTP_PORT)).action(async (options) => {
+	try {
+		const port = Number.parseInt(options.port, 10);
+		if (!Number.isInteger(port) || port <= 0) throw new Error(`Invalid port: ${options.port}`);
+		const gatewayService = new GatewayService();
+		await gatewayService.ensureConfig(process.env[MODEL_PROXY_SCOPE_ENV] || DEFAULT_SCOPE$1);
+		const manager = new HttpServerManager();
+		const httpStatus = await manager.ensureRunning(port);
+		if (!httpStatus.running) console.error(`Warning: HTTP server failed to start: ${httpStatus.error}`);
+		const handler = new StdioTransportHandler(createServer(gatewayService));
+		const shutdown = async (signal) => {
+			console.error(`\nReceived ${signal}, shutting down gracefully...`);
+			await handler.stop();
+			if (options.cleanup && httpStatus.running) await manager.stop();
+			process.exit(0);
+		};
+		process.once("SIGINT", () => void shutdown("SIGINT").catch((error) => {
+			console.error("Failed to shut down after SIGINT:", error);
+			process.exit(1);
+		}));
+		process.once("SIGTERM", () => void shutdown("SIGTERM").catch((error) => {
+			console.error("Failed to shut down after SIGTERM:", error);
+			process.exit(1);
+		}));
+		await handler.start();
+	} catch (error) {
+		console.error("Failed to start MCP server:", error);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/commands/start.ts
+const startCommand = new Command("start").description("Start HTTP and/or MCP server for the model proxy").option("--mcp-only", "Start only the MCP server", false).option("--http-only", "Start only the HTTP server", false).option("-p, --port <port>", "Port for HTTP server", String(DEFAULT_HTTP_PORT)).action(async (options) => {
+	try {
+		const httpServerManager = new HttpServerManager();
+		const port = Number.parseInt(options.port, 10);
+		const startHttp = !options.mcpOnly;
+		const startMcp = !options.httpOnly;
+		if (startHttp) {
+			const status = await httpServerManager.ensureRunning(port);
+			if (!status.running) {
+				console.error(`HTTP server failed to start: ${status.error}`);
+				process.exit(1);
+			}
+			console.log(`HTTP server running on http://127.0.0.1:${status.port}`);
+		}
+		if (startMcp) {
+			const handler = new StdioTransportHandler(createServer());
+			await handler.start();
+			const shutdown = async (signal) => {
+				console.error(`\n${signal} received. Shutting down...`);
+				await handler.stop();
+				process.exit(0);
+			};
+			process.on("SIGINT", () => shutdown("SIGINT"));
+			process.on("SIGTERM", () => shutdown("SIGTERM"));
+		} else process.exit(0);
+	} catch (error) {
+		console.error("Failed to start services:", error);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/commands/status.ts
+const DEFAULT_SCOPE = "default";
+const STATUS_COMMAND_NAME = "status";
+const STATUS_COMMAND_DESCRIPTION = "Show proxy server and profile status";
+const STATUS_ERROR_MESSAGE = "Failed to read status";
+var StatusCommandError = class extends Error {
+	code = "STATUS_CHECK_FAILED";
+	constructor(cause) {
+		super(STATUS_ERROR_MESSAGE, { cause: cause instanceof Error ? cause : new Error(String(cause)) });
+		this.name = "StatusCommandError";
+	}
+};
+const statusCommand = new Command(STATUS_COMMAND_NAME).description(STATUS_COMMAND_DESCRIPTION).option("-s, --scope <scope>", "Configuration scope", DEFAULT_SCOPE).action(async (options) => {
+	try {
+		const serverStatus = await new HttpServerManager().getStatus();
+		const status = await new GatewayService().getStatus(options.scope, serverStatus.port, serverStatus.pid);
+		status.running = serverStatus.running;
+		status.error = serverStatus.error;
+		consoleLogger.info(JSON.stringify(status, null, 2));
+		process.exit(0);
+	} catch (error) {
+		const statusError = new StatusCommandError(error);
+		consoleLogger.error(STATUS_ERROR_MESSAGE, {
+			command: STATUS_COMMAND_NAME,
+			code: statusError.code,
+			scope: options.scope,
+			cause: statusError.cause
+		});
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/commands/stop.ts
+const stopCommand = new Command("stop").description("Stop the background HTTP server").action(async () => {
+	try {
+		const stopped = await new HttpServerManager().stop();
+		console.log(stopped ? "HTTP server stopped" : "No HTTP server running");
+		process.exit(0);
+	} catch (error) {
+		console.error("Failed to stop HTTP server:", error);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/cli.ts
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageJson = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
+async function main() {
+	const program = new Command();
+	program.name("model-proxy-mcp").description("Claude-compatible model proxy MCP").version(packageJson.version);
+	program.addCommand(startCommand);
+	program.addCommand(stopCommand);
+	program.addCommand(statusCommand);
+	program.addCommand(claudeCommand);
+	program.addCommand(httpServeCommand);
+	program.addCommand(mcpServeCommand);
+	await program.parseAsync(process.argv);
+}
+main();
+
+//#endregion
+export {  };