copilot-api-plus 1.0.5 → 1.0.7

package/dist/main.js

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
-import { PATHS, cacheModels, cacheVSCodeVersion, clearGithubToken, ensurePaths, isNullish, setupCopilotToken, setupGitHubToken, sleep } from "./token-CRn8c1A7.js";
-import { GITHUB_API_BASE_URL, copilotBaseUrl, copilotHeaders, githubHeaders, state } from "./get-user-DalX7epg.js";
-import { HTTPError, forwardError } from "./error-Cmeg4mmB.js";
+import { PATHS, ensurePaths } from "./paths-Ch0ixSo2.js";
+import { state } from "./state-DAw5jMjc.js";
+import { GITHUB_API_BASE_URL, copilotBaseUrl, copilotHeaders, githubHeaders } from "./get-user-DgPgvnrS.js";
+import { HTTPError, forwardError } from "./error-CvU5otz-.js";
+import { cacheModels, cacheVSCodeVersion, clearGithubToken, isNullish, setupCopilotToken, setupGitHubToken, sleep } from "./token-DYeOMeid.js";
+import { clearZenAuth, getZenAuthPath } from "./auth-C5zV8JbW.js";
 import { defineCommand, runMain } from "citty";
 import consola from "consola";
 import fs from "node:fs/promises";
@@ -177,19 +180,68 @@ const debug = defineCommand({
 
 //#endregion
 //#region src/logout.ts
-async function runLogout() {
+async function runLogout(options) {
 	await ensurePaths();
-	await clearGithubToken();
-	consola.success("Logged out successfully");
-	consola.info(`Token file location: ${PATHS.GITHUB_TOKEN_PATH}`);
+	if (options.all) {
+		await clearGithubToken();
+		await clearZenAuth();
+		consola.success("Logged out from all services");
+		consola.info(`GitHub token: ${PATHS.GITHUB_TOKEN_PATH}`);
+		consola.info(`Zen API key: ${getZenAuthPath()}`);
+		return;
+	}
+	if (options.zen) {
+		await clearZenAuth();
+		consola.success("Logged out from OpenCode Zen");
+		consola.info(`Zen API key location: ${getZenAuthPath()}`);
+		return;
+	}
+	const choice = await consola.prompt("Which credentials do you want to clear?", {
+		type: "select",
+		options: [
+			"GitHub Copilot token",
+			"OpenCode Zen API key",
+			"Both (all credentials)"
+		]
+	});
+	if (choice === "GitHub Copilot token") {
+		await clearGithubToken();
+		consola.success("Logged out from GitHub Copilot");
+		consola.info(`Token file location: ${PATHS.GITHUB_TOKEN_PATH}`);
+	} else if (choice === "OpenCode Zen API key") {
+		await clearZenAuth();
+		consola.success("Logged out from OpenCode Zen");
+		consola.info(`Zen API key location: ${getZenAuthPath()}`);
+	} else if (choice === "Both (all credentials)") {
+		await clearGithubToken();
+		await clearZenAuth();
+		consola.success("Logged out from all services");
+	}
 }
 const logout = defineCommand({
 	meta: {
 		name: "logout",
-		description: "Clear stored GitHub token and logout"
+		description: "Clear stored credentials and logout"
 	},
-	run() {
-		return runLogout();
+	args: {
+		zen: {
+			alias: "z",
+			type: "boolean",
+			default: false,
+			description: "Clear only OpenCode Zen API key"
+		},
+		all: {
+			alias: "a",
+			type: "boolean",
+			default: false,
+			description: "Clear all credentials (GitHub and Zen)"
+		}
+	},
+	run({ args }) {
+		return runLogout({
+			zen: args.zen,
+			all: args.all
+		});
 	}
 });
 
@@ -688,6 +740,14 @@ function translateModelName(model) {
 	if (supportedModels.includes(modelWithDot)) return modelWithDot;
 	const modelWithDash = model.replace(/(\d+)\.(\d+)/, "$1-$2");
 	if (supportedModels.includes(modelWithDash)) return modelWithDash;
+	for (const [oldFormat, newFormat] of Object.entries({
+		"claude-3-5-sonnet": "claude-sonnet-4.5",
+		"claude-3-sonnet": "claude-sonnet-4",
+		"claude-3-5-opus": "claude-opus-4.5",
+		"claude-3-opus": "claude-opus-4.5",
+		"claude-3-5-haiku": "claude-haiku-4.5",
+		"claude-3-haiku": "claude-haiku-4.5"
+	})) if (modelBase.startsWith(oldFormat) && supportedModels.includes(newFormat)) return newFormat;
 	const modelFamily = model.includes("opus") ? "opus" : model.includes("sonnet") ? "sonnet" : model.includes("haiku") ? "haiku" : null;
 	if (modelFamily) {
 		const familyModel = supportedModels.find((m) => m.includes(modelFamily));
@@ -1021,11 +1081,8 @@ function translateChunkToAnthropicEvents(chunk, state$1) {
 async function handleCompletion(c) {
 	await checkRateLimit(state);
 	const anthropicPayload = await c.req.json();
-	consola.info(`[Messages] Received model: "${anthropicPayload.model}"`);
 	consola.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
 	const openAIPayload = translateToOpenAI(anthropicPayload);
-	consola.info(`[Messages] Translated to: "${openAIPayload.model}"`);
-	consola.info(`[Messages] Available models: ${state.models?.data.map((m) => m.id).join(", ") ?? "none"}`);
 	consola.debug("Translated OpenAI request payload:", JSON.stringify(openAIPayload));
 	if (state.manualApprove) await awaitApproval();
 	const response = await createChatCompletions(openAIPayload);
@@ -1132,6 +1189,142 @@ usageRoute.get("/", async (c) => {
 	}
 });
 
+//#endregion
+//#region src/services/zen/create-chat-completions.ts
+/**
+* Create chat completions via OpenCode Zen
+*/
+async function createZenChatCompletions(request, signal) {
+	const apiKey = state.zenApiKey;
+	if (!apiKey) throw new Error("Zen API key not configured");
+	consola.debug(`Zen chat completions request for model: ${request.model}`);
+	const response = await fetch("https://opencode.ai/zen/v1/chat/completions", {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${apiKey}`
+		},
+		body: JSON.stringify(request),
+		signal
+	});
+	if (!response.ok) {
+		const errorText = await response.text();
+		consola.error(`Zen API error: ${response.status} ${errorText}`);
+		throw new Error(`Zen API error: ${response.status} ${errorText}`);
+	}
+	return response;
+}
+
+//#endregion
+//#region src/routes/zen/chat-completions/route.ts
+const zenCompletionRoutes = new Hono();
+zenCompletionRoutes.post("/", async (c) => {
+	if (!state.zenMode || !state.zenApiKey) return c.json({ error: "Zen mode is not enabled. Start with --zen flag." }, 400);
+	try {
+		const body = await c.req.json();
+		consola.debug("Zen chat completion request:", body.model);
+		const response = await createZenChatCompletions(body);
+		if (body.stream) {
+			const headers = new Headers();
+			headers.set("Content-Type", "text/event-stream");
+			headers.set("Cache-Control", "no-cache");
+			headers.set("Connection", "keep-alive");
+			return new Response(response.body, {
+				status: response.status,
+				headers
+			});
+		}
+		const data = await response.json();
+		return c.json(data);
+	} catch (error) {
+		consola.error("Zen chat completion error:", error);
+		return c.json({ error: {
+			message: error instanceof Error ? error.message : "Unknown error",
+			type: "zen_error"
+		} }, 500);
+	}
+});
+
+//#endregion
+//#region src/services/zen/create-messages.ts
+/**
+* Create messages via OpenCode Zen (Anthropic format)
+*/
+async function createZenMessages(request, signal) {
+	const apiKey = state.zenApiKey;
+	if (!apiKey) throw new Error("Zen API key not configured");
+	consola.debug(`Zen messages request for model: ${request.model}`);
+	const response = await fetch("https://opencode.ai/zen/v1/messages", {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			"x-api-key": apiKey,
+			"anthropic-version": "2023-06-01"
+		},
+		body: JSON.stringify(request),
+		signal
+	});
+	if (!response.ok) {
+		const errorText = await response.text();
+		consola.error(`Zen Messages API error: ${response.status} ${errorText}`);
+		throw new Error(`Zen Messages API error: ${response.status} ${errorText}`);
+	}
+	return response;
+}
+
+//#endregion
+//#region src/routes/zen/messages/route.ts
+const zenMessageRoutes = new Hono();
+zenMessageRoutes.post("/", async (c) => {
+	if (!state.zenMode || !state.zenApiKey) return c.json({ error: "Zen mode is not enabled. Start with --zen flag." }, 400);
+	try {
+		const body = await c.req.json();
+		consola.debug("Zen message request:", body.model);
+		const response = await createZenMessages(body);
+		if (body.stream) {
+			const headers = new Headers();
+			headers.set("Content-Type", "text/event-stream");
+			headers.set("Cache-Control", "no-cache");
+			headers.set("Connection", "keep-alive");
+			return new Response(response.body, {
+				status: response.status,
+				headers
+			});
+		}
+		const data = await response.json();
+		return c.json(data);
+	} catch (error) {
+		consola.error("Zen message error:", error);
+		return c.json({
+			type: "error",
+			error: {
+				type: "zen_error",
+				message: error instanceof Error ? error.message : "Unknown error"
+			}
+		}, 500);
+	}
+});
+
+//#endregion
+//#region src/routes/zen/models/route.ts
+const zenModelRoutes = new Hono();
+zenModelRoutes.get("/", async (c) => {
+	if (!state.zenMode || !state.zenApiKey) return c.json({ error: "Zen mode is not enabled. Start with --zen flag." }, 400);
+	try {
+		if (state.zenModels) return c.json(state.zenModels);
+		const { getZenModels } = await import("./get-models-Hlxa1hWY.js");
+		const models = await getZenModels();
+		state.zenModels = models;
+		return c.json(models);
+	} catch (error) {
+		consola.error("Zen models error:", error);
+		return c.json({ error: {
+			message: error instanceof Error ? error.message : "Unknown error",
+			type: "zen_error"
+		} }, 500);
+	}
+});
+
 //#endregion
 //#region src/server.ts
 const server = new Hono();
@@ -1139,15 +1332,33 @@ server.use(logger());
 server.use(cors());
 server.use(apiKeyAuthMiddleware);
 server.get("/", (c) => c.text("Server running"));
-server.route("/chat/completions", completionRoutes);
-server.route("/models", modelRoutes);
+server.route("/chat/completions", new Hono().all("/*", async (c, next) => {
+	if (state.zenMode) return zenCompletionRoutes.fetch(c.req.raw, c.env);
+	return completionRoutes.fetch(c.req.raw, c.env);
+}));
+server.route("/models", new Hono().all("/*", async (c, next) => {
+	if (state.zenMode) return zenModelRoutes.fetch(c.req.raw, c.env);
+	return modelRoutes.fetch(c.req.raw, c.env);
+}));
 server.route("/embeddings", embeddingRoutes);
 server.route("/usage", usageRoute);
 server.route("/token", tokenRoute);
-server.route("/v1/chat/completions", completionRoutes);
-server.route("/v1/models", modelRoutes);
+server.route("/v1/chat/completions", new Hono().all("/*", async (c, next) => {
+	if (state.zenMode) return zenCompletionRoutes.fetch(c.req.raw, c.env);
+	return completionRoutes.fetch(c.req.raw, c.env);
+}));
+server.route("/v1/models", new Hono().all("/*", async (c, next) => {
+	if (state.zenMode) return zenModelRoutes.fetch(c.req.raw, c.env);
+	return modelRoutes.fetch(c.req.raw, c.env);
+}));
 server.route("/v1/embeddings", embeddingRoutes);
-server.route("/v1/messages", messageRoutes);
+server.route("/v1/messages", new Hono().all("/*", async (c, next) => {
+	if (state.zenMode) return zenMessageRoutes.fetch(c.req.raw, c.env);
+	return messageRoutes.fetch(c.req.raw, c.env);
+}));
+server.route("/zen/v1/chat/completions", zenCompletionRoutes);
+server.route("/zen/v1/models", zenModelRoutes);
+server.route("/zen/v1/messages", zenMessageRoutes);
 
 //#endregion
 //#region src/start.ts
@@ -1171,6 +1382,8 @@ server.route("/v1/messages", messageRoutes);
 *   - showToken: Expose GitHub/Copilot tokens in responses for debugging
 *   - proxyEnv: Initialize proxy settings from environment variables
 *   - apiKeys: Optional list of API keys to enable API key authentication
+*   - zen: Enable OpenCode Zen mode (proxy to Zen instead of GitHub Copilot)
+*   - zenApiKey: OpenCode Zen API key (optional; if omitted will prompt for setup)
 */
 async function runServer(options) {
 	if (options.proxyEnv) initProxyFromEnv();
@@ -1187,43 +1400,63 @@ async function runServer(options) {
 	state.apiKeys = options.apiKeys;
 	if (state.apiKeys && state.apiKeys.length > 0) consola.info(`API key authentication enabled with ${state.apiKeys.length} key(s)`);
 	await ensurePaths();
-	await cacheVSCodeVersion();
-	if (options.githubToken) {
-		state.githubToken = options.githubToken;
-		consola.info("Using provided GitHub token");
+	if (options.zen) {
+		consola.info("OpenCode Zen mode enabled");
+		state.zenMode = true;
+		if (options.zenApiKey) {
+			state.zenApiKey = options.zenApiKey;
+			consola.info("Using provided Zen API key");
+		} else {
+			const { setupZenApiKey, loadZenAuth } = await import("./auth-KlL1W4gV.js");
+			const existingAuth = await loadZenAuth();
+			if (existingAuth) {
+				state.zenApiKey = existingAuth.apiKey;
+				consola.info("Using existing Zen API key");
+			} else state.zenApiKey = await setupZenApiKey();
+		}
+		const { cacheZenModels } = await import("./get-models-Hlxa1hWY.js");
+		await cacheZenModels();
+		consola.info(`Available Zen models: \n${state.zenModels?.data.map((model) => `- ${model.id}`).join("\n")}`);
+	} else {
+		await cacheVSCodeVersion();
+		if (options.githubToken) {
+			state.githubToken = options.githubToken;
+			consola.info("Using provided GitHub token");
+			try {
+				const { getGitHubUser } = await import("./get-user-M3sQS0U8.js");
+				const user = await getGitHubUser();
+				consola.info(`Logged in as ${user.login}`);
+			} catch (error) {
+				consola.error("Provided GitHub token is invalid");
+				throw error;
+			}
+		} else await setupGitHubToken();
 		try {
-			const { getGitHubUser } = await import("./get-user-BQgLIPYd.js");
-			const user = await getGitHubUser();
-			consola.info(`Logged in as ${user.login}`);
+			await setupCopilotToken();
 		} catch (error) {
-			consola.error("Provided GitHub token is invalid");
+			const { HTTPError: HTTPError$1 } = await import("./error-CsShqJjE.js");
+			if (error instanceof HTTPError$1 && error.response.status === 401) {
+				consola.error("Failed to get Copilot token - GitHub token may be invalid or Copilot access revoked");
+				const { clearGithubToken: clearGithubToken$1 } = await import("./token-BssxOyqn.js");
+				await clearGithubToken$1();
+				consola.info("Please restart to re-authenticate");
+			}
 			throw error;
 		}
-	} else await setupGitHubToken();
-	try {
-		await setupCopilotToken();
-	} catch (error) {
-		const { HTTPError: HTTPError$1 } = await import("./error-Ba4dbGYj.js");
-		if (error instanceof HTTPError$1 && error.response.status === 401) {
-			consola.error("Failed to get Copilot token - GitHub token may be invalid or Copilot access revoked");
-			const { clearGithubToken: clearGithubToken$1 } = await import("./token-DP4tvNfm.js");
-			await clearGithubToken$1();
-			consola.info("Please restart to re-authenticate");
-		}
-		throw error;
+		await cacheModels();
+		consola.info(`Available models: \n${state.models?.data.map((model) => `- ${model.id}`).join("\n")}`);
 	}
-	await cacheModels();
-	consola.info(`Available models: \n${state.models?.data.map((model) => `- ${model.id}`).join("\n")}`);
 	const serverUrl = `http://localhost:${options.port}`;
 	if (options.claudeCode) {
-		invariant(state.models, "Models should be loaded by now");
+		const models = state.zenMode ? state.zenModels : state.models;
+		invariant(models, "Models should be loaded by now");
 		const selectedModel = await consola.prompt("Select a model to use with Claude Code", {
 			type: "select",
-			options: state.models.data.map((model) => model.id)
+			options: models.data.map((model) => model.id)
 		});
 		const selectedSmallModel = await consola.prompt("Select a small model to use with Claude Code", {
 			type: "select",
-			options: state.models.data.map((model) => model.id)
+			options: models.data.map((model) => model.id)
 		});
 		const command = generateEnvScript({
 			ANTHROPIC_BASE_URL: serverUrl,
@@ -1313,6 +1546,16 @@ const start = defineCommand({
 		"api-key": {
 			type: "string",
 			description: "API keys for authentication"
+		},
+		zen: {
+			alias: "z",
+			type: "boolean",
+			default: false,
+			description: "Enable OpenCode Zen mode (proxy to Zen instead of GitHub Copilot)"
+		},
+		"zen-api-key": {
+			type: "string",
+			description: "OpenCode Zen API key (get from https://opencode.ai/zen)"
 		}
 	},
 	run({ args }) {
@@ -1332,7 +1575,9 @@ const start = defineCommand({
 			claudeCode: args["claude-code"],
 			showToken: args["show-token"],
 			proxyEnv: args["proxy-env"],
-			apiKeys
+			apiKeys,
+			zen: args.zen,
+			zenApiKey: args["zen-api-key"]
 		});
 	}
 });