@jer-y/copilot-proxy 0.1.5 → 0.2.0

package/dist/main.js

@@ -1,44 +1,28 @@
 #!/usr/bin/env node
+import { PATHS, ensurePaths } from "./paths-CA6OZ0WA.js";
+import { loadDaemonConfig } from "./config-D1kMGXKU.js";
+import { isDaemonRunning, isProcessRunning, readPid, removePidFile } from "./pid-uKNpN4v-.js";
+import { daemonStart } from "./start-Dcv2sypx.js";
 import { defineCommand, runMain } from "citty";
 import consola from "consola";
 import fs from "node:fs/promises";
 import os from "node:os";
-import path from "node:path";
 import { randomUUID } from "node:crypto";
 import process from "node:process";
+import fs$1 from "node:fs";
+import { Buffer } from "node:buffer";
+import { execSync } from "node:child_process";
 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 { execSync } from "node:child_process";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
 import { streamSSE } from "hono/streaming";
 import { events } from "fetch-event-stream";
 
-//#region src/lib/paths.ts
-const APP_DIR = path.join(os.homedir(), ".local", "share", "copilot-proxy");
-const GITHUB_TOKEN_PATH = path.join(APP_DIR, "github_token");
-const PATHS = {
-	APP_DIR,
-	GITHUB_TOKEN_PATH
-};
-async function ensurePaths() {
-	await fs.mkdir(PATHS.APP_DIR, { recursive: true });
-	await ensureFile(PATHS.GITHUB_TOKEN_PATH);
-}
-async function ensureFile(filePath) {
-	try {
-		await fs.access(filePath, fs.constants.W_OK);
-	} catch {
-		await fs.writeFile(filePath, "");
-		await fs.chmod(filePath, 384);
-	}
-}
-
-//#endregion
 //#region src/lib/state.ts
 const state = {
 	accountType: "individual",
@@ -163,20 +147,21 @@ async function getGitHubUser() {
 //#endregion
 //#region src/services/copilot/get-models.ts
 async function getModels() {
+	const headers = copilotHeaders(state);
+	const response = await fetch(`${copilotBaseUrl(state)}/models`, { headers });
+	if (response.ok) return await response.json();
+	consola.warn(`vscode-chat models request failed (${response.status} ${response.statusText}), falling back to copilot-developer-cli`);
 	if (state.githubToken) try {
 		const cliHeaders = copilotHeaders(state);
 		cliHeaders.Authorization = `Bearer ${state.githubToken}`;
 		cliHeaders["copilot-integration-id"] = "copilot-developer-cli";
-		const response$1 = await fetch(`${copilotBaseUrl(state)}/models`, { headers: cliHeaders });
-		if (response$1.ok) return await response$1.json();
-		consola.warn(`copilot-developer-cli models request failed (${response$1.status} ${response$1.statusText}), falling back to standard auth`);
+		const cliResponse = await fetch(`${copilotBaseUrl(state)}/models`, { headers: cliHeaders });
+		if (cliResponse.ok) return await cliResponse.json();
+		consola.warn(`copilot-developer-cli fallback also failed (${cliResponse.status} ${cliResponse.statusText})`);
 	} catch (e) {
-		consola.warn("copilot-developer-cli models request error, falling back:", e);
+		consola.warn("copilot-developer-cli fallback error:", e);
 	}
-	const headers = copilotHeaders(state);
-	const response = await fetch(`${copilotBaseUrl(state)}/models`, { headers });
-	if (!response.ok) throw new HTTPError("Failed to get models", response);
-	return await response.json();
+	throw new HTTPError("Failed to get models", response);
 }
 
 //#endregion
@@ -259,7 +244,8 @@ async function setupCopilotToken() {
 	state.copilotToken = token;
 	consola.debug("GitHub Copilot Token fetched successfully!");
 	if (state.showToken) consola.info("Copilot token:", token);
-	const refreshInterval = (refresh_in - 60) * 1e3;
+	const rawInterval = (refresh_in - 60) * 1e3;
+	const refreshInterval = Number.isFinite(rawInterval) ? Math.min(Math.max(rawInterval, 6e4), 1440 * 60 * 1e3) : 6e4;
 	setInterval(async () => {
 		consola.debug("Refreshing Copilot token");
 		try {
@@ -268,8 +254,7 @@ async function setupCopilotToken() {
 			consola.debug("Copilot token refreshed");
 			if (state.showToken) consola.info("Refreshed Copilot token:", token$1);
 		} catch (error) {
-			consola.error("Failed to refresh Copilot token:", error);
-			throw error;
+			consola.error("Failed to refresh Copilot token, will retry next cycle:", error);
 		}
 	}, refreshInterval);
 }
@@ -387,6 +372,228 @@ const checkUsage = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/daemon/disable.ts
+const disable = defineCommand({
+	meta: {
+		name: "disable",
+		description: "Remove auto-start service"
+	},
+	async run() {
+		const { platform } = process;
+		let success = true;
+		if (platform === "linux") {
+			const { uninstallAutoStart } = await import("./linux-CX0xETja.js");
+			success = await uninstallAutoStart();
+		} else if (platform === "darwin") {
+			const { uninstallAutoStart } = await import("./darwin-BVmd1DeO.js");
+			success = await uninstallAutoStart();
+		} else if (platform === "win32") {
+			const { uninstallAutoStart } = await import("./win32-D1-MlKl7.js");
+			success = await uninstallAutoStart();
+		} else {
+			consola.error(`Unsupported platform: ${platform}`);
+			process.exit(1);
+		}
+		if (!success) process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/daemon/enable.ts
+const enable = defineCommand({
+	meta: {
+		name: "enable",
+		description: "Register as auto-start service"
+	},
+	async run() {
+		if (!loadDaemonConfig()) {
+			consola.error("No daemon config found. Start the daemon first with `start -d`");
+			process.exit(1);
+		}
+		const execPath = process.argv[0];
+		const args = [
+			process.argv[1],
+			"start",
+			"--_supervisor"
+		];
+		let success = false;
+		const { platform } = process;
+		if (platform === "linux") {
+			const { installAutoStart } = await import("./linux-CX0xETja.js");
+			success = await installAutoStart(execPath, args);
+		} else if (platform === "darwin") {
+			const { installAutoStart } = await import("./darwin-BVmd1DeO.js");
+			success = await installAutoStart(execPath, args);
+		} else if (platform === "win32") {
+			const { installAutoStart } = await import("./win32-D1-MlKl7.js");
+			success = await installAutoStart(execPath, args);
+		} else {
+			consola.error(`Unsupported platform: ${platform}`);
+			process.exit(1);
+		}
+		if (!success) process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/daemon/logs.ts
+const logs = defineCommand({
+	meta: {
+		name: "logs",
+		description: "Show daemon logs"
+	},
+	args: {
+		follow: {
+			alias: "f",
+			type: "boolean",
+			default: false,
+			description: "Follow log output"
+		},
+		lines: {
+			alias: "n",
+			type: "string",
+			default: "50",
+			description: "Number of lines to show"
+		}
+	},
+	run({ args }) {
+		if (!fs$1.existsSync(PATHS.DAEMON_LOG)) {
+			consola.info("No log file found");
+			return;
+		}
+		if (args.follow) followLogsWatch();
+		else {
+			const lines = fs$1.readFileSync(PATHS.DAEMON_LOG, "utf8").split("\n");
+			const count = Number.parseInt(args.lines, 10);
+			const output = lines.slice(-count).join("\n");
+			console.log(output);
+		}
+	}
+});
+function followLogsWatch() {
+	const content = fs$1.readFileSync(PATHS.DAEMON_LOG, "utf8");
+	process.stdout.write(content);
+	let position = Buffer.byteLength(content);
+	let currentIno = 0;
+	try {
+		currentIno = fs$1.statSync(PATHS.DAEMON_LOG).ino;
+	} catch {}
+	setInterval(() => {
+		try {
+			const stat = fs$1.statSync(PATHS.DAEMON_LOG);
+			if (stat.ino !== currentIno) {
+				currentIno = stat.ino;
+				position = 0;
+			}
+			if (stat.size < position) position = 0;
+			if (stat.size > position) {
+				const fd = fs$1.openSync(PATHS.DAEMON_LOG, "r");
+				const buffer = Buffer.alloc(stat.size - position);
+				fs$1.readSync(fd, buffer, 0, buffer.length, position);
+				fs$1.closeSync(fd);
+				process.stdout.write(buffer);
+				position = stat.size;
+			}
+		} catch {}
+	}, 500);
+}
+
+//#endregion
+//#region src/daemon/stop.ts
+/**
+* Attempt to stop the daemon. Returns true if daemon was stopped or
+* was not running. Returns false if the process could not be stopped.
+*/
+function stopDaemon() {
+	const daemon = isDaemonRunning();
+	if (!daemon.running) {
+		consola.info("Daemon is not running");
+		removePidFile();
+		return true;
+	}
+	const { pid } = daemon;
+	consola.info(`Stopping daemon (PID: ${pid})...`);
+	try {
+		process.kill(pid, "SIGTERM");
+	} catch {
+		consola.error("Failed to send SIGTERM");
+		return false;
+	}
+	const deadline = Date.now() + 1e4;
+	while (isProcessRunning(pid) && Date.now() < deadline) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 200);
+	if (isProcessRunning(pid)) {
+		consola.warn("Process did not exit in time, sending SIGKILL");
+		try {
+			process.kill(pid, "SIGKILL");
+		} catch {}
+		const killDeadline = Date.now() + 3e3;
+		while (isProcessRunning(pid) && Date.now() < killDeadline) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
+		if (isProcessRunning(pid)) {
+			consola.error(`Failed to kill process ${pid}`);
+			return false;
+		}
+	}
+	removePidFile();
+	consola.success("Daemon stopped");
+	return true;
+}
+const stop = defineCommand({
+	meta: {
+		name: "stop",
+		description: "Stop the background daemon"
+	},
+	run() {
+		if (!stopDaemon()) process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/daemon/restart.ts
+const restart = defineCommand({
+	meta: {
+		name: "restart",
+		description: "Restart the background daemon"
+	},
+	run() {
+		const config = loadDaemonConfig();
+		if (!config) {
+			consola.error("No daemon config found. Start the daemon first with `start -d`");
+			process.exit(1);
+		}
+		if (isDaemonRunning().running) {
+			if (!stopDaemon()) {
+				consola.error("Cannot restart: failed to stop existing daemon");
+				process.exit(1);
+			}
+		}
+		daemonStart(config);
+	}
+});
+
+//#endregion
+//#region src/daemon/status.ts
+const status = defineCommand({
+	meta: {
+		name: "status",
+		description: "Show daemon status"
+	},
+	run() {
+		const daemon = isDaemonRunning();
+		if (!daemon.running) {
+			consola.info("Daemon is not running");
+			return;
+		}
+		const config = loadDaemonConfig();
+		const info = readPid();
+		const startedAt = info && info.startTime > 0 ? new Date(info.startTime).toLocaleString() : "unknown";
+		consola.info(`Daemon is running`);
+		consola.info(`  PID:     ${daemon.pid}`);
+		consola.info(`  Port:    ${config?.port ?? "unknown"}`);
+		consola.info(`  Started: ${startedAt}`);
+	}
+});
+
 //#endregion
 //#region src/debug.ts
 async function getPackageVersion() {
@@ -996,8 +1203,29 @@ function mapOpenAIStopReasonToAnthropic(finishReason) {
 
 //#endregion
 //#region src/routes/messages/non-stream-translation.ts
-function translateToOpenAI(payload) {
-	const model = translateModelName(payload.model);
+/** Models that support variant suffixes (e.g. -fast, -1m) */
+const MODEL_VARIANTS = { "claude-opus-4.6": new Set(["fast", "1m"]) };
+/** Parse comma-separated anthropic-beta header into a Set of feature names */
+function parseBetaFeatures(anthropicBeta) {
+	if (!anthropicBeta) return /* @__PURE__ */ new Set();
+	return new Set(anthropicBeta.split(",").map((s) => s.trim()).filter(Boolean));
+}
+/** Apply model variant suffix based on speed field and beta header signals */
+function applyModelVariant(model, payload, anthropicBeta) {
+	const normalizedModel = translateModelName(model);
+	const variants = MODEL_VARIANTS[normalizedModel];
+	if (!variants) return normalizedModel;
+	const betaFeatures = parseBetaFeatures(anthropicBeta);
+	if (variants.has("fast")) {
+		if (payload.speed === "fast" || betaFeatures.has("fast-mode-2026-02-01")) return `${normalizedModel}-fast`;
+	}
+	if (variants.has("1m")) {
+		if (betaFeatures.has("context-1m-2025-08-07")) return `${normalizedModel}-1m`;
+	}
+	return normalizedModel;
+}
+function translateToOpenAI(payload, options) {
+	const model = applyModelVariant(payload.model, payload, options?.anthropicBeta);
 	const modelConfig = getModelConfig(model);
 	const enableCacheControl = modelConfig.enableCacheControl === true;
 	const messages = translateAnthropicMessagesToOpenAI(payload.messages, payload.system);
@@ -1207,14 +1435,32 @@ function getAnthropicToolUseBlocks(toolCalls) {
 //#endregion
 //#region src/routes/messages/count-tokens-handler.ts
 /**
+* Find a model in the models list, falling back to the base model
+* when a variant suffix (-fast, -1m) doesn't have its own entry.
+*/
+function findModelWithFallback(modelId, models) {
+	if (!models) return;
+	const exact = models.find((m) => m.id === modelId);
+	if (exact) return exact;
+	const baseModel = modelId.replace(/-(fast|1m)$/, "");
+	if (baseModel !== modelId) return models.find((m) => m.id === baseModel);
+}
+/**
+* Determine if the request is from Claude Code based on anthropic-beta tokens.
+* Order-independent: works regardless of token position in the header.
+*/
+function isClaudeCodeRequest(anthropicBeta) {
+	return [...parseBetaFeatures(anthropicBeta)].some((f) => f.startsWith("claude-code"));
+}
+/**
 * Handles token counting for Anthropic messages
 */
 async function handleCountTokens(c) {
 	try {
 		const anthropicBeta = c.req.header("anthropic-beta");
 		const anthropicPayload = await c.req.json();
-		const openAIPayload = translateToOpenAI(anthropicPayload);
-		const selectedModel = state.models?.data.find((model) => model.id === openAIPayload.model);
+		const openAIPayload = translateToOpenAI(anthropicPayload, { anthropicBeta });
+		const selectedModel = findModelWithFallback(openAIPayload.model, state.models?.data);
 		if (!selectedModel) {
 			consola.warn("Model not found, returning default token count");
 			return c.json({ input_tokens: 1 });
@@ -1222,7 +1468,7 @@ async function handleCountTokens(c) {
 		const tokenCount = await getTokenCount(openAIPayload, selectedModel);
 		if (anthropicPayload.tools && anthropicPayload.tools.length > 0) {
 			let mcpToolExist = false;
-			if (anthropicBeta?.startsWith("claude-code")) mcpToolExist = anthropicPayload.tools.some((tool) => tool.name.startsWith("mcp__"));
+			if (isClaudeCodeRequest(anthropicBeta)) mcpToolExist = anthropicPayload.tools.some((tool) => tool.name.startsWith("mcp__"));
 			if (!mcpToolExist) {
 				if (anthropicPayload.model.startsWith("claude")) tokenCount.input = tokenCount.input + 346;
 				else if (anthropicPayload.model.startsWith("grok")) tokenCount.input = tokenCount.input + 480;
@@ -1367,9 +1613,10 @@ function translateChunkToAnthropicEvents(chunk, state$1) {
 //#region src/routes/messages/handler.ts
 async function handleCompletion(c) {
 	await checkRateLimit(state);
+	const anthropicBeta = c.req.header("anthropic-beta");
 	const anthropicPayload = await c.req.json();
 	consola.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
-	const openAIPayload = translateToOpenAI(anthropicPayload);
+	const openAIPayload = translateToOpenAI(anthropicPayload, { anthropicBeta });
 	consola.debug("Translated OpenAI request payload:", JSON.stringify(openAIPayload));
 	if (state.manualApprove) await awaitApproval();
 	const response = await createChatCompletions(openAIPayload);
@@ -1624,6 +1871,7 @@ async function runServer(options) {
 		fetch: server.fetch,
 		port: options.port
 	});
+	await new Promise(() => {});
 }
 const start = defineCommand({
 	meta: {
@@ -1685,13 +1933,83 @@ const start = defineCommand({
 			type: "boolean",
 			default: false,
 			description: "Initialize proxy from environment variables"
+		},
+		"daemon": {
+			alias: "d",
+			type: "boolean",
+			default: false,
+			description: "Run as a background daemon"
+		},
+		"_supervisor": {
+			type: "boolean",
+			default: false,
+			description: "Internal: run as supervisor (do not use directly)"
 		}
 	},
-	run({ args }) {
+	async run({ args }) {
+		const port = Number.parseInt(args.port, 10);
+		if (Number.isNaN(port) || port <= 0 || port > 65535 || String(port) !== args.port) {
+			consola.error(`Invalid port: ${args.port}`);
+			process.exit(1);
+		}
 		const rateLimitRaw = args["rate-limit"];
 		const rateLimit = rateLimitRaw === void 0 ? void 0 : Number.parseInt(rateLimitRaw, 10);
+		if (rateLimitRaw !== void 0 && (Number.isNaN(rateLimit) || rateLimit <= 0 || rateLimit > 86400 || String(rateLimit) !== rateLimitRaw)) {
+			consola.error(`Invalid rate-limit: ${rateLimitRaw} (must be 1-86400)`);
+			process.exit(1);
+		}
+		const validAccountTypes = [
+			"individual",
+			"business",
+			"enterprise"
+		];
+		if (!validAccountTypes.includes(args["account-type"])) {
+			consola.error(`Invalid account-type: ${args["account-type"]} (must be one of: ${validAccountTypes.join(", ")})`);
+			process.exit(1);
+		}
+		if (args._supervisor) {
+			const { loadDaemonConfig: loadDaemonConfig$1 } = await import("./config-ixm2Pm96.js");
+			const config = loadDaemonConfig$1();
+			if (!config) {
+				consola.error("Supervisor mode: daemon config not found");
+				process.exit(1);
+			}
+			const { runAsSupervisor } = await import("./supervisor-BbH28zwT.js");
+			const options = {
+				port: config.port,
+				verbose: config.verbose,
+				accountType: config.accountType,
+				manual: config.manual,
+				rateLimit: config.rateLimit,
+				rateLimitWait: config.rateLimitWait,
+				githubToken: config.githubToken,
+				claudeCode: false,
+				showToken: config.showToken,
+				proxyEnv: config.proxyEnv
+			};
+			return runAsSupervisor(() => runServer(options));
+		}
+		if (args.daemon) {
+			if (args["claude-code"]) {
+				consola.error("Cannot use --claude-code with --daemon (interactive mode)");
+				process.exit(1);
+			}
+			const { daemonStart: daemonStart$1 } = await import("./start-C-0OcnXB.js");
+			daemonStart$1({
+				port,
+				verbose: args.verbose,
+				accountType: args["account-type"],
+				manual: args.manual,
+				rateLimit,
+				rateLimitWait: args.wait,
+				githubToken: args["github-token"],
+				showToken: args["show-token"],
+				proxyEnv: args["proxy-env"]
+			});
+			return;
+		}
 		return runServer({
-			port: Number.parseInt(args.port, 10),
+			port,
 			verbose: args.verbose,
 			accountType: args["account-type"],
 			manual: args.manual,
@@ -1716,7 +2034,13 @@ const main = defineCommand({
 		auth,
 		start,
 		"check-usage": checkUsage,
-		debug
+		debug,
+		stop,
+		status,
+		logs,
+		restart,
+		enable,
+		disable
 	}
 });
 await runMain(main);