github-router 0.3.12 → 0.3.13

package/dist/main.js

@@ -6,6 +6,8 @@ import os from "node:os";
 import path from "node:path";
 import { randomBytes, randomUUID } from "node:crypto";
 import process$1 from "node:process";
+import fs$1 from "node:fs";
+import { Writable } from "node:stream";
 import { execFileSync, spawn } from "node:child_process";
 import { serve } from "srvx";
 import { getProxyForUrl } from "proxy-from-env";
@@ -19,9 +21,11 @@ import clipboard from "clipboardy";
 //#region src/lib/paths.ts
 const APP_DIR = path.join(os.homedir(), ".local", "share", "github-router");
 const GITHUB_TOKEN_PATH = path.join(APP_DIR, "github_token");
+const ERROR_LOG_PATH = path.join(APP_DIR, "error.log");
 const PATHS = {
 	APP_DIR,
-	GITHUB_TOKEN_PATH
+	GITHUB_TOKEN_PATH,
+	ERROR_LOG_PATH
 };
 async function ensurePaths() {
 	await fs.mkdir(PATHS.APP_DIR, { recursive: true });
@@ -462,6 +466,100 @@ const checkUsage = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/lib/file-log-reporter.ts
+const MAX_LOG_BYTES = 1024 * 1024;
+const DEDUP_MAX = 1e3;
+const ARG_MAX_LEN = 2048;
+const DEDUP_KEY_MAX_LEN = 200;
+const CREDENTIAL_RE = /\b(eyJ[A-Za-z0-9_-]{20,}(?:\.[A-Za-z0-9_-]+){0,2}|gh[opsu]_[A-Za-z0-9_]{20,}|Bearer\s+\S{20,})\b/g;
+const ALLOWED_TYPES = new Set([
+	"fatal",
+	"error",
+	"warn"
+]);
+function sanitize(line) {
+	return line.replace(CREDENTIAL_RE, "[REDACTED]");
+}
+function serializeArg(arg) {
+	if (typeof arg === "string") return arg;
+	if (arg instanceof Error) {
+		const parts = [arg.message];
+		if (arg.stack) parts.push(arg.stack);
+		return parts.join("\n");
+	}
+	return String(arg);
+}
+function formatLogLine(logObj) {
+	return sanitize(`${logObj.date.toISOString()} [${(logObj.type ?? "error").toUpperCase()}] ${logObj.args.map((a) => {
+		const s = serializeArg(a);
+		return s.length > ARG_MAX_LEN ? s.slice(0, ARG_MAX_LEN) + "…" : s;
+	}).join(" ").replace(/\r\n|\r|\n/g, "\\n")}\n`);
+}
+function makeDedupeKey(logObj) {
+	const firstArg = logObj.args.length > 0 ? serializeArg(logObj.args[0]) : "";
+	const key = `${logObj.type}:${firstArg}`;
+	return key.length > DEDUP_KEY_MAX_LEN ? key.slice(0, DEDUP_KEY_MAX_LEN) : key;
+}
+function rotateIfNeeded(filePath) {
+	let size;
+	try {
+		size = fs$1.statSync(filePath).size;
+	} catch {
+		return;
+	}
+	if (size <= MAX_LOG_BYTES) return;
+	try {
+		fs$1.renameSync(filePath, filePath + ".1");
+	} catch {}
+}
+var FileLogReporter = class {
+	filePath;
+	seen = /* @__PURE__ */ new Set();
+	writing = false;
+	constructor(filePath) {
+		this.filePath = filePath;
+		rotateIfNeeded(filePath);
+	}
+	log(logObj, _ctx) {
+		if (!ALLOWED_TYPES.has(logObj.type)) return;
+		if (this.writing) return;
+		const key = makeDedupeKey(logObj);
+		if (this.seen.has(key)) return;
+		if (this.seen.size >= DEDUP_MAX) this.seen.clear();
+		this.seen.add(key);
+		const line = formatLogLine(logObj);
+		this.writing = true;
+		try {
+			const fd = fs$1.openSync(this.filePath, "a", 384);
+			fs$1.writeSync(fd, line);
+			fs$1.closeSync(fd);
+		} catch {} finally {
+			this.writing = false;
+		}
+	}
+};
+const nullStream = new Writable({ write(_chunk, _encoding, cb) {
+	cb();
+} });
+/**
+* Switch consola to file-only mode for TUI sessions.
+* Removes the terminal reporter and installs a file reporter that
+* persists errors and warnings to disk with dedup and credential scrubbing.
+*
+* Also sinks consola's stdout/stderr streams as belt-and-suspenders:
+* even if a terminal reporter is re-added, it cannot write to the terminal.
+* Crash handlers that call process.stderr.write() directly are unaffected.
+* FileLogReporter uses fs.writeSync() directly and is also unaffected.
+*/
+function enableFileLogging() {
+	const reporter = new FileLogReporter(PATHS.ERROR_LOG_PATH);
+	consola.options.throttle = 0;
+	consola.setReporters([reporter]);
+	consola.options.stdout = nullStream;
+	consola.options.stderr = nullStream;
+}
+
 //#endregion
 //#region src/lib/port.ts
 const DEFAULT_PORT = 8787;
@@ -506,7 +604,9 @@ function launchChild(target, server$1) {
 	const { cmd, env } = buildLaunchCommand(target);
 	const executable = cmd[0];
 	if (!commandExists(executable)) {
-		consola.error(`"${executable}" not found on PATH. Install it first, then try again.`);
+		const msg = `"${executable}" not found on PATH. Install it first, then try again.`;
+		consola.error(msg);
+		process$1.stderr.write(msg + "\n");
 		process$1.exit(1);
 	}
 	let child;
@@ -521,7 +621,9 @@ function launchChild(target, server$1) {
 			stdio: "inherit"
 		});
 	} catch (error) {
-		consola.error(`Failed to launch ${executable}:`, error instanceof Error ? error.message : String(error));
+		const msg = `Failed to launch ${executable}: ${error instanceof Error ? error.message : String(error)}`;
+		consola.error(msg);
+		process$1.stderr.write(msg + "\n");
 		server$1.close(true).catch(() => {});
 		process$1.exit(1);
 	}
@@ -549,10 +651,13 @@ function launchChild(target, server$1) {
 	};
 	process$1.on("SIGINT", onSignal);
 	process$1.on("SIGTERM", onSignal);
-	child.on("exit", (exitCode) => {
-		cleanup().then(() => exit(exitCode ?? 0)).catch(() => exit(1));
+	child.on("exit", (exitCode, signal) => {
+		const code = exitCode ?? (signal ? 128 : 1);
+		cleanup().then(() => exit(code)).catch(() => exit(1));
+	});
+	child.on("error", () => {
+		cleanup().then(() => exit(1)).catch(() => exit(1));
 	});
-	child.on("error", () => exit(1));
 }
 
 //#endregion
@@ -1776,31 +1881,99 @@ function extractUserQuery(input) {
 		}
 	}
 }
+/**
+* Compaction prompt used when GitHub Copilot API does not support
+* /responses/compact natively. Matches the prompt Codex CLI uses for
+* local (non-OpenAI) compaction.
+*/
+const COMPACTION_PROMPT = `You are performing a CONTEXT CHECKPOINT COMPACTION. Create a handoff summary for another LLM that will resume the task.
+
+Include:
+- Current progress and key decisions made
+- Important context, constraints, or user preferences
+- What remains to be done (clear next steps)
+- Any critical data, examples, or references needed to continue
+
+Be concise, structured, and focused on helping the next LLM seamlessly continue the work.`;
 async function handleResponsesCompact(c) {
 	const startTime = Date.now();
 	await checkRateLimit(state);
 	if (!state.copilotToken) throw new Error("Copilot token not found");
 	if (state.manualApprove) await awaitApproval();
-	const body = await c.req.text();
+	const body = await c.req.json();
 	const response = await fetch(`${copilotBaseUrl(state)}/responses/compact`, {
 		method: "POST",
 		headers: copilotHeaders(state),
-		body
+		body: JSON.stringify(body)
 	});
-	if (!response.ok) {
+	if (response.ok) {
 		logRequest({
 			method: "POST",
 			path: c.req.path,
-			status: response.status
+			status: 200
+		}, void 0, startTime);
+		return c.json(await response.json());
+	}
+	if (response.status === 404) {
+		consola.debug("Copilot API does not support /responses/compact, using synthetic compaction");
+		return await syntheticCompact(c, body, startTime);
+	}
+	logRequest({
+		method: "POST",
+		path: c.req.path,
+		status: response.status
+	}, void 0, startTime);
+	throw new HTTPError("Copilot responses/compact request failed", response);
+}
+/**
+* Synthetic compaction: sends the conversation history to Copilot's
+* regular /responses endpoint with a compaction prompt appended,
+* then returns the model's summary in the compact response format.
+*/
+async function syntheticCompact(c, body, startTime) {
+	const input = Array.isArray(body.input) ? [...body.input] : [];
+	input.push({
+		type: "message",
+		role: "user",
+		content: [{
+			type: "input_text",
+			text: COMPACTION_PROMPT
+		}]
+	});
+	const payload = {
+		model: body.model,
+		input,
+		instructions: body.instructions,
+		stream: false,
+		store: false
+	};
+	let result;
+	try {
+		result = await createResponses(payload);
+	} catch (error) {
+		if (error instanceof HTTPError) logRequest({
+			method: "POST",
+			path: c.req.path,
+			status: error.response.status
 		}, void 0, startTime);
-		throw new HTTPError("Copilot responses/compact request failed", response);
+		throw error;
 	}
 	logRequest({
 		method: "POST",
 		path: c.req.path,
 		status: 200
 	}, void 0, startTime);
-	return c.json(await response.json());
+	return c.json({
+		id: `resp_compact_${randomUUID().replace(/-/g, "").slice(0, 24)}`,
+		object: "response.compaction",
+		created_at: Math.floor(Date.now() / 1e3),
+		output: result.output,
+		usage: result.usage ?? {
+			input_tokens: 0,
+			output_tokens: 0,
+			total_tokens: 0
+		}
+	});
 }
 
 //#endregion
@@ -2081,6 +2254,7 @@ const claude = defineCommand({
 			consola.error("Failed to start server:", error instanceof Error ? error.message : error);
 			process$1.exit(1);
 		}
+		enableFileLogging();
 		let resolvedModel;
 		if (args.model) {
 			resolvedModel = resolveModel(args.model);
@@ -2090,8 +2264,7 @@ const claude = defineCommand({
 				consola.warn(`Model "${resolvedModel}" not found. Available claude models: ${available.join(", ")}`);
 			}
 		}
-		consola.success(`Server ready on ${serverUrl}, launching Claude Code...`);
-		consola.level = 1;
+		process$1.stderr.write(`Server ready on ${serverUrl}, launching Claude Code...\n`);
 		launchChild({
 			kind: "claude-code",
 			envVars: getClaudeCodeEnvVars(serverUrl, resolvedModel ?? args.model),
@@ -2137,6 +2310,7 @@ const codex = defineCommand({
 			process$1.exit(1);
 		}
 		const requestedModel = args.model ?? DEFAULT_CODEX_MODEL;
+		enableFileLogging();
 		const codexModel = resolveCodexModel(requestedModel);
 		if (codexModel !== requestedModel) consola.info(`Model "${requestedModel}" resolved to "${codexModel}"`);
 		const modelEntry = state.models?.data.find((m) => m.id === codexModel);
@@ -2147,8 +2321,7 @@ const codex = defineCommand({
 			const ctx = modelEntry.capabilities?.limits?.max_context_window_tokens;
 			if (ctx) consola.info(`Model context window: ${ctx.toLocaleString()} tokens`);
 		}
-		consola.success(`Server ready on ${serverUrl}, launching Codex CLI (${codexModel})...`);
-		consola.level = 1;
+		process$1.stderr.write(`Server ready on ${serverUrl}, launching Codex CLI (${codexModel})...\n`);
 		launchChild({
 			kind: "codex",
 			envVars: getCodexEnvVars(serverUrl),