xc-copilot-api 1.1.3 → 1.2.1

package/README.md

@@ -35,7 +35,7 @@ A reverse-engineered proxy for the GitHub Copilot API that exposes it as an Open
 ## Features
 
 - **OpenAI & Anthropic Compatibility**: Exposes GitHub Copilot as an OpenAI-compatible (`/v1/chat/completions`, `/v1/models`, `/v1/embeddings`) and Anthropic-compatible (`/v1/messages`) API.
-- **Claude Code Integration**: Easily configure and launch [Claude Code](https://docs.anthropic.com/en/docs/claude-code/overview) to use Copilot as its backend with a simple command-line flag (`--claude-code`).
+- **Claude Code & Codex CLI Integration**: Configure [Claude Code](https://docs.anthropic.com/en/docs/claude-code/overview) or Codex CLI to use Copilot as backend with `config --claude` or `config --codex`.
 - **Usage Dashboard**: A web-based dashboard to monitor your Copilot API usage, view quotas, and see detailed statistics.
 - **Rate Limit Control**: Manage API usage with rate-limiting options (`--rate-limit`) and a waiting mechanism (`--wait`) to prevent errors from rapid requests.
 - **Manual Request Approval**: Manually approve or deny each API request for fine-grained control over usage (`--manual`).
@@ -188,10 +188,28 @@ Copilot API now uses a subcommand structure with these main commands:
 
 - `start`: Start the Copilot API server. This command will also handle authentication if needed.
 - `auth`: Run GitHub authentication flow without starting the server. This is typically used if you need to generate a token for use with the `--github-token` option, especially in non-interactive environments.
+- `config`: Configure external AI tools (Claude Code, Codex CLI) to use Copilot API.
 - `check-usage`: Show your current GitHub Copilot usage and quota information directly in the terminal (no server required).
 - `debug`: Display diagnostic information including version, runtime details, file paths, and authentication status. Useful for troubleshooting and support.
 
-A separate **[`xc-copilot-api-daemon`](docs/daemon.md)** CLI is available for managing the server as a background daemon (install, status, restart, stop, uninstall, logs) on macOS, Linux, and Windows.
+### Running as a Background Service
+
+Use [easy-service](https://github.com/billxc/easy-service) to run as a background service on macOS, Linux, and Windows:
+
+```bash
+# Install easy-service
+uv tool install git+https://github.com/billxc/easy-service.git
+
+# Install and start the service
+easy-service install copilot-api -- npx -y xc-copilot-api@latest start
+
+# Manage the service
+easy-service status copilot-api
+easy-service logs copilot-api -f
+easy-service restart copilot-api
+easy-service stop copilot-api
+easy-service uninstall copilot-api
+```
 
 ## Command Line Options
 
@@ -208,10 +226,16 @@ The following command line options are available for the `start` command:
 | --rate-limit   | Rate limit in seconds between requests                                        | none       | -r    |
 | --wait         | Wait instead of error when rate limit is hit                                  | false      | -w    |
 | --github-token | Provide GitHub token directly (must be generated using the `auth` subcommand) | none       | -g    |
-| --claude-code  | Generate a command to launch Claude Code with Copilot API config              | false      | -c    |
 | --show-token   | Show GitHub and Copilot tokens on fetch and refresh                           | false      | none  |
 | --proxy-env    | Initialize proxy from environment variables                                   | false      | none  |
 
+### Config Command Options
+
+| Option  | Description                                       | Default | Alias |
+| ------- | ------------------------------------------------- | ------- | ----- |
+| --claude | Configure Claude Code (`~/.claude/settings.json`) | false   | -c    |
+| --codex  | Configure Codex CLI (`~/.codex/config.toml`)      | false   | -x    |
+
 ### Auth Command Options
 
 | Option       | Description               | Default | Alias |
@@ -328,44 +352,29 @@ The dashboard provides a user-friendly interface to view your Copilot usage data
 
 ## Using with Claude Code
 
-This proxy can be used to power [Claude Code](https://docs.anthropic.com/en/claude-code), an experimental conversational AI assistant for developers from Anthropic.
-
-There are two ways to configure Claude Code to use this proxy:
-
-### Interactive Setup with `--claude-code` flag
+This proxy can be used to power [Claude Code](https://docs.anthropic.com/en/claude-code).
 
-To get started, run the `start` command with the `--claude-code` flag:
+The quickest way to get started:
 
 ```sh
-npx xc-copilot-api@latest start --claude-code
-```
-
-You will be prompted to select a primary model and a "small, fast" model for background tasks. After selecting the models, a command will be copied to your clipboard. This command sets the necessary environment variables for Claude Code to use the proxy.
+# Start the server
+npx xc-copilot-api@latest start
 
-Paste and run this command in a new terminal to launch Claude Code.
+# Configure Claude Code (writes to ~/.claude/settings.json)
+npx xc-copilot-api@latest config --claude
+```
 
-### Manual Configuration with `settings.json`
+This merges the required `ANTHROPIC_BASE_URL` and `ANTHROPIC_AUTH_TOKEN` into your existing settings without overwriting other configuration. A backup of your original config is saved as `settings.json.bak`.
 
-Alternatively, you can configure Claude Code by creating a `.claude/settings.json` file in your project's root directory. This file should contain the environment variables needed by Claude Code. This way you don't need to run the interactive setup every time.
+> **Note:** Copilot API natively understands Claude model names (e.g. `claude-sonnet-4.5`, `opus[1m]`), so you don't need to set `ANTHROPIC_MODEL` or other model environment variables — they just work.
 
-Here is an example `.claude/settings.json` file:
+If you prefer manual configuration, add the following to your `~/.claude/settings.json`:
 
 ```json
 {
   "env": {
     "ANTHROPIC_BASE_URL": "http://localhost:4141",
-    "ANTHROPIC_AUTH_TOKEN": "dummy",
-    "ANTHROPIC_MODEL": "gpt-4.1",
-    "ANTHROPIC_DEFAULT_SONNET_MODEL": "gpt-4.1",
-    "ANTHROPIC_SMALL_FAST_MODEL": "gpt-4.1",
-    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "gpt-4.1",
-    "DISABLE_NON_ESSENTIAL_MODEL_CALLS": "1",
-    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1"
-  },
-  "permissions": {
-    "deny": [
-      "WebSearch"
-    ]
+    "ANTHROPIC_AUTH_TOKEN": "Powered by xc copilot"
   }
 }
 ```
@@ -374,6 +383,30 @@ You can find more options here: [Claude Code settings](https://docs.anthropic.co
 
 You can also read more about IDE integration here: [Add Claude Code to your IDE](https://docs.anthropic.com/en/docs/claude-code/ide-integrations)
 
+## Using with Codex CLI
+
+```sh
+# Start the server
+npx xc-copilot-api@latest start
+
+# Configure Codex CLI (writes to ~/.codex/config.toml)
+npx xc-copilot-api@latest config --codex
+```
+
+A backup of your original config is saved as `config.toml.bak`.
+
+If you prefer manual configuration, add the following to your `~/.codex/config.toml`:
+
+```toml
+model = "gpt-5.4"
+model_provider = "copilot-api"
+
+[model_providers.copilot-api]
+name = "copilot-api"
+base_url = "http://localhost:4141/v1"
+wire_api = "responses"
+```
+
 ## Running from Source
 
 The project can be run from source in several ways:

package/dist/main.js

@@ -1,17 +1,13 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from "citty";
-import { execSync } from "node:child_process";
-import os from "node:os";
-import path from "node:path";
 import consola from "consola";
-import fs from "node:fs/promises";
+import fs, { copyFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import os, { homedir } from "node:os";
+import path, { join } from "node:path";
 import { randomUUID } from "node:crypto";
-import clipboard from "clipboardy";
 import { serve } from "srvx";
-import invariant from "tiny-invariant";
 import { getProxyForUrl } from "proxy-from-env";
 import { Agent, ProxyAgent, setGlobalDispatcher } from "undici";
-import process$1 from "node:process";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { streamSSE } from "hono/streaming";
@@ -21,7 +17,7 @@ import "hono/logger";
 
 //#region package.json
 var name = "xc-copilot-api";
-var version = "1.1.3";
+var version = "1.2.1";
 var description = "Turn GitHub Copilot into OpenAI/Anthropic API compatible server. Usable with Claude Code and Codex";
 var keywords = [
 	"proxy",
@@ -36,10 +32,7 @@ var repository = {
 };
 var author = "Xiaochen <wxc9312@gmail.com>";
 var type = "module";
-var bin = {
-	"xc-copilot-api": "./dist/main.js",
-	"xc-copilot-api-daemon": "./dist/daemon-main.js"
-};
+var bin = { "xc-copilot-api": "./dist/main.js" };
 var files = ["dist"];
 var scripts = {
 	"build": "tsdown",
@@ -57,14 +50,12 @@ var simple_git_hooks = {};
 var lint_staged = {};
 var dependencies = {
 	"citty": "^0.1.6",
-	"clipboardy": "^5.0.0",
 	"consola": "^3.4.2",
 	"fetch-event-stream": "^0.1.5",
 	"gpt-tokenizer": "^3.0.1",
 	"hono": "^4.9.9",
 	"proxy-from-env": "^1.1.0",
 	"srvx": "^0.8.9",
-	"tiny-invariant": "^1.3.3",
 	"undici": "^7.16.0",
 	"zod": "^4.1.11"
 };
@@ -469,6 +460,123 @@ const checkUsage = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/config.ts
+async function backupFile(filePath) {
+	try {
+		const backupPath = `${filePath}.bak`;
+		await copyFile(filePath, backupPath);
+		consola.info(`Backup saved: ${backupPath}`);
+	} catch {}
+}
+async function configureClaude(port) {
+	const configDir = join(homedir(), ".claude");
+	const configPath = join(configDir, "settings.json");
+	await mkdir(configDir, { recursive: true });
+	let existing = {};
+	try {
+		const raw = await readFile(configPath, "utf-8");
+		existing = JSON.parse(raw);
+	} catch (error) {
+		if (error.code !== "ENOENT") {
+			consola.error(`Failed to parse ${configPath}. Please fix it manually.`);
+			process.exit(1);
+		}
+	}
+	const existingEnv = typeof existing.env === "object" && existing.env !== null ? existing.env : {};
+	const merged = {
+		...existing,
+		env: {
+			...existingEnv,
+			ANTHROPIC_BASE_URL: `http://localhost:${port}`,
+			ANTHROPIC_AUTH_TOKEN: "Powered by xc copilot"
+		},
+		model: "opus[1m]"
+	};
+	await backupFile(configPath);
+	await writeFile(configPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+	consola.success(`Claude Code configured: ${configPath}`);
+}
+/**
+* Set or replace a top-level key in a TOML string.
+* If the key exists, its value is updated in place. Otherwise appended after
+* the last existing top-level key (before the first [section]).
+*/
+function setTomlTopLevelKey(content, key, value) {
+	const pattern = new RegExp(`^${key}\\s*=.*$`, "m");
+	const line = `${key} = ${JSON.stringify(value)}`;
+	if (pattern.test(content)) return content.replace(pattern, line);
+	const sectionMatch = content.match(/^\[/m);
+	if (sectionMatch?.index !== void 0) return content.slice(0, sectionMatch.index) + line + "\n" + content.slice(sectionMatch.index);
+	return content.trimEnd() + "\n" + line + "\n";
+}
+/**
+* Set or replace an entire [section] block in a TOML string.
+* Replaces everything from the header to the next section (or EOF).
+*/
+function setTomlSection(content, header, body) {
+	const escaped = header.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const pattern = new RegExp(`^\\[${escaped}\\]\\n[^[]*`, "m");
+	const block = `[${header}]\n${body}\n\n`;
+	if (pattern.test(content)) return content.replace(pattern, block);
+	return content.trimEnd() + "\n\n" + block;
+}
+async function configureCodex(port) {
+	const configDir = join(homedir(), ".codex");
+	const configPath = join(configDir, "config.toml");
+	await mkdir(configDir, { recursive: true });
+	let content = "";
+	try {
+		content = await readFile(configPath, "utf-8");
+	} catch (error) {
+		if (error.code !== "ENOENT") {
+			consola.error(`Failed to read ${configPath}. Please fix it manually.`);
+			process.exit(1);
+		}
+	}
+	content = setTomlTopLevelKey(content, "model", "gpt-5.4");
+	content = setTomlTopLevelKey(content, "model_provider", "copilot-api");
+	content = setTomlSection(content, "model_providers.copilot-api", `name = "copilot-api"\nbase_url = "http://localhost:${port}/v1"\nwire_api = "responses"`);
+	await backupFile(configPath);
+	await writeFile(configPath, content, "utf-8");
+	consola.success(`Codex CLI configured: ${configPath}`);
+}
+const config = defineCommand({
+	meta: {
+		name: "config",
+		description: "Configure external AI tools (Claude Code, Codex CLI) to use Copilot API"
+	},
+	args: {
+		claude: {
+			alias: "c",
+			type: "boolean",
+			default: false,
+			description: "Configure Claude Code (~/.claude/settings.json)"
+		},
+		codex: {
+			alias: "x",
+			type: "boolean",
+			default: false,
+			description: "Configure Codex CLI (~/.codex/config.toml)"
+		},
+		port: {
+			alias: "p",
+			type: "string",
+			default: "4141",
+			description: "Port the Copilot API server listens on"
+		}
+	},
+	async run({ args }) {
+		if (!args.claude && !args.codex) {
+			consola.error("Specify at least one: --claude or --codex");
+			process.exit(1);
+		}
+		const port = Number.parseInt(args.port, 10);
+		if (args.claude) await configureClaude(port);
+		if (args.codex) await configureCodex(port);
+	}
+});
+
 //#endregion
 //#region src/debug.ts
 async function getPackageVersion() {
@@ -589,59 +697,6 @@ function initProxyFromEnv() {
 	}
 }
 
-//#endregion
-//#region src/lib/shell.ts
-function getShell() {
-	const { platform, ppid, env } = process$1;
-	if (platform === "win32") {
-		try {
-			const command = `wmic process get ParentProcessId,Name | findstr "${ppid}"`;
-			if (execSync(command, { stdio: "pipe" }).toString().toLowerCase().includes("powershell.exe")) return "powershell";
-		} catch {
-			return "cmd";
-		}
-		return "cmd";
-	} else {
-		const shellPath = env.SHELL;
-		if (shellPath) {
-			if (shellPath.endsWith("zsh")) return "zsh";
-			if (shellPath.endsWith("fish")) return "fish";
-			if (shellPath.endsWith("bash")) return "bash";
-		}
-		return "sh";
-	}
-}
-/**
-* Generates a copy-pasteable script to set multiple environment variables
-* and run a subsequent command.
-* @param {EnvVars} envVars - An object of environment variables to set.
-* @param {string} commandToRun - The command to run after setting the variables.
-* @returns {string} The formatted script string.
-*/
-function generateEnvScript(envVars, commandToRun = "") {
-	const shell = getShell();
-	const filteredEnvVars = Object.entries(envVars).filter(([, value]) => value !== void 0);
-	let commandBlock;
-	switch (shell) {
-		case "powershell":
-			commandBlock = filteredEnvVars.map(([key, value]) => `$env:${key} = ${value}`).join("; ");
-			break;
-		case "cmd":
-			commandBlock = filteredEnvVars.map(([key, value]) => `set ${key}=${value}`).join(" & ");
-			break;
-		case "fish":
-			commandBlock = filteredEnvVars.map(([key, value]) => `set -gx ${key} ${value}`).join("; ");
-			break;
-		default: {
-			const assignments = filteredEnvVars.map(([key, value]) => `${key}=${value}`).join(" ");
-			commandBlock = filteredEnvVars.length > 0 ? `export ${assignments}` : "";
-			break;
-		}
-	}
-	if (commandBlock && commandToRun) return `${commandBlock}${shell === "cmd" ? " & " : " && "}${commandToRun}`;
-	return commandBlock || commandToRun;
-}
-
 //#endregion
 //#region src/lib/logger.ts
 function nowIso() {
@@ -1951,34 +2006,6 @@ async function runServer(options) {
 	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 selectedModel = await consola.prompt("Select a model to use with Claude Code", {
-			type: "select",
-			options: state.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)
-		});
-		const command = generateEnvScript({
-			ANTHROPIC_BASE_URL: serverUrl,
-			ANTHROPIC_AUTH_TOKEN: "dummy",
-			ANTHROPIC_MODEL: selectedModel,
-			ANTHROPIC_DEFAULT_SONNET_MODEL: selectedModel,
-			ANTHROPIC_SMALL_FAST_MODEL: selectedSmallModel,
-			ANTHROPIC_DEFAULT_HAIKU_MODEL: selectedSmallModel,
-			DISABLE_NON_ESSENTIAL_MODEL_CALLS: "1",
-			CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1"
-		}, "claude");
-		try {
-			clipboard.writeSync(command);
-			consola.success("Copied Claude Code command to clipboard!");
-		} catch {
-			consola.warn("Failed to copy to clipboard. Here is the Claude Code command:");
-			consola.log(command);
-		}
-	}
 	consola.box(`🌐 Usage Viewer: https://billxc.github.io/copilot-api?endpoint=${serverUrl}/usage`);
 	serve({
 		fetch: server.fetch,
@@ -2030,12 +2057,6 @@ const start = defineCommand({
 			type: "string",
 			description: "Provide GitHub token directly (must be generated using the `auth` subcommand)"
 		},
-		"claude-code": {
-			alias: "c",
-			type: "boolean",
-			default: false,
-			description: "Generate a command to launch Claude Code with Copilot API config"
-		},
 		"show-token": {
 			type: "boolean",
 			default: false,
@@ -2058,7 +2079,6 @@ const start = defineCommand({
 			rateLimit,
 			rateLimitWait: args.wait,
 			githubToken: args["github-token"],
-			claudeCode: args["claude-code"],
 			showToken: args["show-token"],
 			proxyEnv: args["proxy-env"]
 		});
@@ -2087,6 +2107,7 @@ const main = defineCommand({
 	subCommands: {
 		auth,
 		start,
+		config,
 		"check-usage": checkUsage,
 		debug
 	}