@ashsec/copilot-api 0.7.0 → 0.7.2

package/dist/main.js

@@ -22,10 +22,12 @@ import { streamSSE } from "hono/streaming";
 const APP_DIR = path.join(os.homedir(), ".local", "share", "copilot-api");
 const GITHUB_TOKEN_PATH = path.join(APP_DIR, "github_token");
 const AZURE_OPENAI_CONFIG_PATH = path.join(APP_DIR, "azure_openai_config");
+const REPLACEMENTS_CONFIG_PATH = path.join(APP_DIR, "replacements.json");
 const PATHS = {
 	APP_DIR,
 	GITHUB_TOKEN_PATH,
-	AZURE_OPENAI_CONFIG_PATH
+	AZURE_OPENAI_CONFIG_PATH,
+	REPLACEMENTS_CONFIG_PATH
 };
 async function ensurePaths() {
 	await fs.mkdir(PATHS.APP_DIR, { recursive: true });
@@ -164,15 +166,15 @@ async function loadAzureOpenAIConfig() {
 		const content = await fs.readFile(PATHS.AZURE_OPENAI_CONFIG_PATH, "utf8");
 		if (!content.trim()) return null;
 		const decoded = Buffer.from(content.trim(), "base64").toString("utf8");
-		const config = JSON.parse(decoded);
-		if (!config.endpoint || !config.apiKey) return null;
-		return config;
+		const config$1 = JSON.parse(decoded);
+		if (!config$1.endpoint || !config$1.apiKey) return null;
+		return config$1;
 	} catch {
 		return null;
 	}
 }
-async function saveAzureOpenAIConfig(config) {
-	const encoded = Buffer.from(JSON.stringify(config)).toString("base64");
+async function saveAzureOpenAIConfig(config$1) {
+	const encoded = Buffer.from(JSON.stringify(config$1)).toString("base64");
 	await fs.writeFile(PATHS.AZURE_OPENAI_CONFIG_PATH, encoded, "utf8");
 	await fs.chmod(PATHS.AZURE_OPENAI_CONFIG_PATH, 384);
 	consola.success("Azure OpenAI configuration saved");
@@ -192,12 +194,12 @@ async function promptAzureOpenAISetup() {
 		consola.warn("No API key provided, skipping Azure OpenAI setup");
 		return null;
 	}
-	const config = {
+	const config$1 = {
 		endpoint: endpoint.trim().replace(/\/$/, ""),
 		apiKey: apiKey.trim()
 	};
-	await saveAzureOpenAIConfig(config);
-	return config;
+	await saveAzureOpenAIConfig(config$1);
+	return config$1;
 }
 function isAzureOpenAIModel(modelId) {
 	return modelId.startsWith(AZURE_OPENAI_MODEL_PREFIX);
@@ -209,7 +211,7 @@ function getAzureDeploymentName(modelId) {
 //#endregion
 //#region src/services/azure-openai/create-chat-completions.ts
 const AZURE_API_VERSION = "2024-10-21";
-async function createAzureOpenAIChatCompletions(config, payload) {
+async function createAzureOpenAIChatCompletions(config$1, payload) {
 	const deploymentName = getAzureDeploymentName(payload.model);
 	const { max_tokens,...restPayload } = payload;
 	const azurePayload = {
@@ -217,10 +219,10 @@ async function createAzureOpenAIChatCompletions(config, payload) {
 		model: deploymentName,
 		...max_tokens != null && { max_completion_tokens: max_tokens }
 	};
-	const response = await fetch(`${config.endpoint}/openai/deployments/${deploymentName}/chat/completions?api-version=${AZURE_API_VERSION}`, {
+	const response = await fetch(`${config$1.endpoint}/openai/deployments/${deploymentName}/chat/completions?api-version=${AZURE_API_VERSION}`, {
 		method: "POST",
 		headers: {
-			"api-key": config.apiKey,
+			"api-key": config$1.apiKey,
 			"Content-Type": "application/json"
 		},
 		body: JSON.stringify(azurePayload)
@@ -236,10 +238,10 @@ async function createAzureOpenAIChatCompletions(config, payload) {
 //#endregion
 //#region src/services/azure-openai/get-models.ts
 const AZURE_DEPLOYMENTS_API_VERSION = "2022-12-01";
-async function getAzureOpenAIDeployments(config) {
+async function getAzureOpenAIDeployments(config$1) {
 	try {
-		const response = await fetch(`${config.endpoint}/openai/deployments?api-version=${AZURE_DEPLOYMENTS_API_VERSION}`, { headers: {
-			"api-key": config.apiKey,
+		const response = await fetch(`${config$1.endpoint}/openai/deployments?api-version=${AZURE_DEPLOYMENTS_API_VERSION}`, { headers: {
+			"api-key": config$1.apiKey,
 			"Content-Type": "application/json"
 		} });
 		if (!response.ok) {
@@ -265,8 +267,20 @@ async function getAzureOpenAIDeployments(config) {
 //#endregion
 //#region src/services/copilot/get-models.ts
 const getModels = async () => {
-	const response = await fetch(`${copilotBaseUrl(state)}/models`, { headers: copilotHeaders(state) });
-	if (!response.ok) throw new HTTPError("Failed to get models", response);
+	const url = `${copilotBaseUrl(state)}/models`;
+	const response = await fetch(url, { headers: copilotHeaders(state) });
+	if (!response.ok) {
+		const errorBody = await response.text();
+		let errorDetails;
+		try {
+			const parsed = JSON.parse(errorBody);
+			errorDetails = JSON.stringify(parsed, null, 2);
+		} catch {
+			errorDetails = errorBody || "(empty response)";
+		}
+		consola.error(`Failed to get models from ${url}\nStatus: ${response.status} ${response.statusText}\nResponse: ${errorDetails}`);
+		throw new HTTPError(`Failed to get models: ${response.status} ${response.statusText}`, response);
+	}
 	return await response.json();
 };
 
@@ -297,7 +311,16 @@ const sleep = (ms) => new Promise((resolve) => {
 });
 const isNullish = (value) => value === null || value === void 0;
 async function cacheModels() {
-	state.models = await getModels();
+	try {
+		state.models = await getModels();
+	} catch (error) {
+		consola.error("Failed to fetch and cache models. This could be due to:");
+		consola.error("  - Invalid or expired Copilot token");
+		consola.error("  - Network connectivity issues");
+		consola.error("  - GitHub Copilot service unavailable");
+		consola.error("  - Account type mismatch (try --account-type=individual or --account-type=business)");
+		throw error;
+	}
 }
 const cacheVSCodeVersion = async () => {
 	const response = await getVSCodeVersion();
@@ -305,16 +328,16 @@ const cacheVSCodeVersion = async () => {
 	consola.info(`Using VSCode version: ${response}`);
 };
 async function setupAzureOpenAI() {
-	let config = await loadAzureOpenAIConfig();
-	if (!config) config = await promptAzureOpenAISetup();
-	if (!config) {
+	let config$1 = await loadAzureOpenAIConfig();
+	if (!config$1) config$1 = await promptAzureOpenAISetup();
+	if (!config$1) {
 		consola.info("Azure OpenAI not configured");
 		return;
 	}
-	state.azureOpenAIConfig = config;
+	state.azureOpenAIConfig = config$1;
 	consola.info("Azure OpenAI configuration loaded");
 	try {
-		const deployments = await getAzureOpenAIDeployments(config);
+		const deployments = await getAzureOpenAIDeployments(config$1);
 		state.azureOpenAIDeployments = deployments;
 		if (deployments.length > 0) consola.info(`Loaded ${deployments.length} Azure OpenAI deployment(s):\n${deployments.map((d) => `- ${d.id} (${d.model})`).join("\n")}`);
 		else consola.warn("No Azure OpenAI deployments found");
@@ -488,6 +511,377 @@ const checkUsage = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/lib/auto-replace.ts
+const SYSTEM_REPLACEMENTS = [{
+	id: "system-anthropic-billing",
+	pattern: "x-anthropic-billing-header:[^\n]*\n?",
+	replacement: "",
+	isRegex: true,
+	enabled: true,
+	isSystem: true
+}];
+let userReplacements = [];
+let isLoaded = false;
+/**
+* Load user replacements from disk
+*/
+async function loadReplacements() {
+	try {
+		const data = await fs.readFile(PATHS.REPLACEMENTS_CONFIG_PATH);
+		userReplacements = JSON.parse(data).filter((r) => !r.isSystem);
+		isLoaded = true;
+		consola.debug(`Loaded ${userReplacements.length} user replacement rules`);
+	} catch {
+		userReplacements = [];
+		isLoaded = true;
+	}
+}
+/**
+* Save user replacements to disk
+*/
+async function saveReplacements() {
+	try {
+		await fs.writeFile(PATHS.REPLACEMENTS_CONFIG_PATH, JSON.stringify(userReplacements, null, 2), "utf8");
+		consola.debug(`Saved ${userReplacements.length} user replacement rules`);
+	} catch (error) {
+		consola.error("Failed to save replacement rules:", error);
+		throw error;
+	}
+}
+/**
+* Ensure replacements are loaded before accessing
+*/
+async function ensureLoaded() {
+	if (!isLoaded) await loadReplacements();
+}
+/**
+* Get all replacement rules (system + user)
+*/
+async function getAllReplacements() {
+	await ensureLoaded();
+	return [...SYSTEM_REPLACEMENTS, ...userReplacements];
+}
+/**
+* Get only user-configurable replacements
+*/
+async function getUserReplacements() {
+	await ensureLoaded();
+	return userReplacements;
+}
+/**
+* Add a new user replacement rule
+*/
+async function addReplacement(pattern, replacement, isRegex = false) {
+	await ensureLoaded();
+	const rule = {
+		id: `user-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+		pattern,
+		replacement,
+		isRegex,
+		enabled: true,
+		isSystem: false
+	};
+	userReplacements.push(rule);
+	await saveReplacements();
+	consola.info(`Added replacement rule: "${pattern}" -> "${replacement}"`);
+	return rule;
+}
+/**
+* Remove a user replacement rule by ID
+*/
+async function removeReplacement(id) {
+	await ensureLoaded();
+	const rule = userReplacements.find((r) => r.id === id);
+	if (!rule) return false;
+	if (rule.isSystem) {
+		consola.warn("Cannot remove system replacement rule");
+		return false;
+	}
+	userReplacements = userReplacements.filter((r) => r.id !== id);
+	await saveReplacements();
+	consola.info(`Removed replacement rule: ${id}`);
+	return true;
+}
+/**
+* Toggle a replacement rule on/off
+*/
+async function toggleReplacement(id) {
+	await ensureLoaded();
+	const userRule = userReplacements.find((r) => r.id === id);
+	if (userRule) {
+		userRule.enabled = !userRule.enabled;
+		await saveReplacements();
+		consola.info(`Toggled replacement rule ${id}: ${userRule.enabled ? "enabled" : "disabled"}`);
+		return userRule;
+	}
+	if (SYSTEM_REPLACEMENTS.find((r) => r.id === id)) {
+		consola.warn("Cannot toggle system replacement rule");
+		return null;
+	}
+	return null;
+}
+/**
+* Clear all user replacements
+*/
+async function clearUserReplacements() {
+	userReplacements = [];
+	await saveReplacements();
+	consola.info("Cleared all user replacement rules");
+}
+/**
+* Apply a single replacement rule to text
+*/
+function applyRule(text, rule) {
+	if (!rule.enabled) return text;
+	if (rule.isRegex) try {
+		const regex = new RegExp(rule.pattern, "g");
+		return text.replace(regex, rule.replacement);
+	} catch {
+		consola.warn(`Invalid regex pattern in rule ${rule.id}: ${rule.pattern}`);
+		return text;
+	}
+	return text.split(rule.pattern).join(rule.replacement);
+}
+/**
+* Apply all replacement rules to text
+*/
+async function applyReplacements(text) {
+	let result = text;
+	const allRules = await getAllReplacements();
+	for (const rule of allRules) {
+		const before = result;
+		result = applyRule(result, rule);
+		if (before !== result) consola.debug(`Applied replacement rule: ${rule.id}`);
+	}
+	return result;
+}
+/**
+* Apply replacements to a chat completions payload
+* This modifies message content in place
+*/
+async function applyReplacementsToPayload(payload) {
+	const processedMessages = await Promise.all(payload.messages.map(async (message) => {
+		if (typeof message.content === "string") return {
+			...message,
+			content: await applyReplacements(message.content)
+		};
+		if (Array.isArray(message.content)) return {
+			...message,
+			content: await Promise.all(message.content.map(async (part) => {
+				if (typeof part === "object" && part.type === "text" && part.text) return {
+					...part,
+					text: await applyReplacements(part.text)
+				};
+				return part;
+			}))
+		};
+		return message;
+	}));
+	return {
+		...payload,
+		messages: processedMessages
+	};
+}
+
+//#endregion
+//#region src/config.ts
+function formatRule(rule, index) {
+	const status = rule.enabled ? "✓" : "✗";
+	const type = rule.isRegex ? "regex" : "string";
+	const system = rule.isSystem ? " [system]" : "";
+	const replacement = rule.replacement || "(empty)";
+	return `${index + 1}. [${status}] (${type})${system} "${rule.pattern}" → "${replacement}"`;
+}
+async function listReplacements() {
+	const all = await getAllReplacements();
+	if (all.length === 0) {
+		consola.info("No replacement rules configured.");
+		return;
+	}
+	consola.info("\n📋 Replacement Rules:\n");
+	for (const [i, element] of all.entries()) console.log(formatRule(element, i));
+	console.log();
+}
+async function addNewReplacement() {
+	const matchType = await consola.prompt("Match type:", {
+		type: "select",
+		options: [{
+			label: "String (exact match)",
+			value: "string"
+		}, {
+			label: "Regex (regular expression)",
+			value: "regex"
+		}]
+	});
+	if (typeof matchType === "symbol") {
+		consola.info("Cancelled.");
+		return;
+	}
+	const pattern = await consola.prompt("Pattern to match:", { type: "text" });
+	if (typeof pattern === "symbol" || !pattern) {
+		consola.info("Cancelled.");
+		return;
+	}
+	if (matchType === "regex") try {
+		new RegExp(pattern);
+	} catch {
+		consola.error(`Invalid regex pattern: ${pattern}`);
+		return;
+	}
+	const replacement = await consola.prompt("Replacement text (leave empty to delete matches):", {
+		type: "text",
+		default: ""
+	});
+	if (typeof replacement === "symbol") {
+		consola.info("Cancelled.");
+		return;
+	}
+	const rule = await addReplacement(pattern, replacement, matchType === "regex");
+	consola.success(`Added rule: ${rule.id}`);
+}
+async function removeExistingReplacement() {
+	const userRules = await getUserReplacements();
+	if (userRules.length === 0) {
+		consola.info("No user rules to remove.");
+		return;
+	}
+	const options = userRules.map((rule, i) => ({
+		label: formatRule(rule, i),
+		value: rule.id
+	}));
+	const selected = await consola.prompt("Select rule to remove:", {
+		type: "select",
+		options
+	});
+	if (typeof selected === "symbol") {
+		consola.info("Cancelled.");
+		return;
+	}
+	if (await removeReplacement(selected)) consola.success("Rule removed.");
+	else consola.error("Failed to remove rule.");
+}
+async function toggleExistingReplacement() {
+	const userRules = await getUserReplacements();
+	if (userRules.length === 0) {
+		consola.info("No user rules to toggle.");
+		return;
+	}
+	const options = userRules.map((rule$1, i) => ({
+		label: formatRule(rule$1, i),
+		value: rule$1.id
+	}));
+	const selected = await consola.prompt("Select rule to toggle:", {
+		type: "select",
+		options
+	});
+	if (typeof selected === "symbol") {
+		consola.info("Cancelled.");
+		return;
+	}
+	const rule = await toggleReplacement(selected);
+	if (rule) consola.success(`Rule ${rule.enabled ? "enabled" : "disabled"}.`);
+	else consola.error("Failed to toggle rule.");
+}
+async function testReplacements() {
+	const testText = await consola.prompt("Enter text to test replacements:", { type: "text" });
+	if (typeof testText === "symbol" || !testText) {
+		consola.info("Cancelled.");
+		return;
+	}
+	const result = await applyReplacements(testText);
+	consola.info("\n📝 Original:");
+	console.log(testText);
+	consola.info("\n✨ After replacements:");
+	console.log(result);
+	console.log();
+}
+async function clearAllReplacements() {
+	if (await consola.prompt("Are you sure you want to clear all user replacements?", {
+		type: "confirm",
+		initial: false
+	})) {
+		await clearUserReplacements();
+		consola.success("All user replacements cleared.");
+	} else consola.info("Cancelled.");
+}
+async function mainMenu() {
+	consola.info(`\n🔧 Copilot API - Replacement Configuration`);
+	consola.info(`Config file: ${PATHS.REPLACEMENTS_CONFIG_PATH}\n`);
+	let running = true;
+	while (running) {
+		const action = await consola.prompt("What would you like to do?", {
+			type: "select",
+			options: [
+				{
+					label: "📋 List all rules",
+					value: "list"
+				},
+				{
+					label: "➕ Add new rule",
+					value: "add"
+				},
+				{
+					label: "➖ Remove rule",
+					value: "remove"
+				},
+				{
+					label: "🔄 Toggle rule on/off",
+					value: "toggle"
+				},
+				{
+					label: "🧪 Test replacements",
+					value: "test"
+				},
+				{
+					label: "🗑️  Clear all user rules",
+					value: "clear"
+				},
+				{
+					label: "🚪 Exit",
+					value: "exit"
+				}
+			]
+		});
+		if (typeof action === "symbol") break;
+		switch (action) {
+			case "list":
+				await listReplacements();
+				break;
+			case "add":
+				await addNewReplacement();
+				break;
+			case "remove":
+				await removeExistingReplacement();
+				break;
+			case "toggle":
+				await toggleExistingReplacement();
+				break;
+			case "test":
+				await testReplacements();
+				break;
+			case "clear":
+				await clearAllReplacements();
+				break;
+			case "exit":
+				running = false;
+				break;
+			default: break;
+		}
+	}
+	consola.info("Goodbye! 👋");
+}
+const config = defineCommand({
+	meta: {
+		name: "config",
+		description: "Configure replacement rules interactively"
+	},
+	run: async () => {
+		await ensurePaths();
+		await mainMenu();
+	}
+});
+
 //#endregion
 //#region src/debug.ts
 async function getPackageVersion() {
@@ -917,7 +1311,8 @@ const createChatCompletions = async (payload) => {
 //#region src/routes/chat-completions/handler.ts
 async function handleCompletion$1(c) {
 	await checkRateLimit(state);
-	let payload = await c.req.json();
+	const rawPayload = await c.req.json();
+	let payload = await applyReplacementsToPayload(rawPayload);
 	consola.debug("Request payload:", JSON.stringify(payload).slice(-400));
 	if (isAzureOpenAIModel(payload.model)) {
 		if (!state.azureOpenAIConfig) return c.json({ error: "Azure OpenAI not configured" }, 500);
@@ -1366,7 +1761,8 @@ async function handleCompletion(c) {
 	await checkRateLimit(state);
 	const anthropicPayload = await c.req.json();
 	consola.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
-	const openAIPayload = translateToOpenAI(anthropicPayload);
+	const translatedPayload = translateToOpenAI(anthropicPayload);
+	const openAIPayload = await applyReplacementsToPayload(translatedPayload);
 	consola.debug("Translated OpenAI request payload:", JSON.stringify(openAIPayload));
 	if (state.manualApprove) await awaitApproval();
 	if (isAzureOpenAIModel(openAIPayload.model)) {
@@ -1490,6 +1886,37 @@ modelRoutes.get("/", async (c) => {
 	}
 });
 
+//#endregion
+//#region src/routes/replacements/route.ts
+const replacementsRoute = new Hono();
+replacementsRoute.get("/", async (c) => {
+	return c.json({
+		all: await getAllReplacements(),
+		user: await getUserReplacements()
+	});
+});
+replacementsRoute.post("/", async (c) => {
+	const body = await c.req.json();
+	if (!body.pattern) return c.json({ error: "Pattern is required" }, 400);
+	const rule = await addReplacement(body.pattern, body.replacement ?? "", body.isRegex ?? false);
+	return c.json(rule, 201);
+});
+replacementsRoute.delete("/:id", async (c) => {
+	const id = c.req.param("id");
+	if (!await removeReplacement(id)) return c.json({ error: "Replacement not found or is a system rule" }, 404);
+	return c.json({ success: true });
+});
+replacementsRoute.patch("/:id/toggle", async (c) => {
+	const id = c.req.param("id");
+	const rule = await toggleReplacement(id);
+	if (!rule) return c.json({ error: "Replacement not found or is a system rule" }, 404);
+	return c.json(rule);
+});
+replacementsRoute.delete("/", async (c) => {
+	await clearUserReplacements();
+	return c.json({ success: true });
+});
+
 //#endregion
 //#region src/routes/token/route.ts
 const tokenRoute = new Hono();
@@ -1529,6 +1956,7 @@ server.route("/models", modelRoutes);
 server.route("/embeddings", embeddingRoutes);
 server.route("/usage", usageRoute);
 server.route("/token", tokenRoute);
+server.route("/replacements", replacementsRoute);
 server.route("/v1/chat/completions", completionRoutes);
 server.route("/v1/models", modelRoutes);
 server.route("/v1/embeddings", embeddingRoutes);
@@ -1537,6 +1965,10 @@ server.route("/v1/messages", messageRoutes);
 //#endregion
 //#region src/start.ts
 async function runServer(options) {
+	if (options.insecure) {
+		process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+		consola.warn("SSL certificate verification disabled (insecure mode)");
+	}
 	if (options.proxyEnv) initProxyFromEnv();
 	if (options.verbose) {
 		consola.level = 5;
@@ -1656,6 +2088,11 @@ const start = defineCommand({
 			type: "boolean",
 			default: false,
 			description: "Initialize proxy from environment variables"
+		},
+		insecure: {
+			type: "boolean",
+			default: false,
+			description: "Disable SSL certificate verification (for corporate proxies with self-signed certs)"
 		}
 	},
 	run({ args }) {
@@ -1671,7 +2108,8 @@ const start = defineCommand({
 			githubToken: args["github-token"],
 			claudeCode: args["claude-code"],
 			showToken: args["show-token"],
-			proxyEnv: args["proxy-env"]
+			proxyEnv: args["proxy-env"],
+			insecure: args.insecure
 		});
 	}
 });
@@ -1687,7 +2125,8 @@ const main = defineCommand({
 		auth,
 		start,
 		"check-usage": checkUsage,
-		debug
+		debug,
+		config
 	}
 });
 await runMain(main);