btca-server 1.0.71 → 1.0.80

package/src/index.ts

@@ -28,7 +28,6 @@ import { VirtualFs } from './vfs/virtual-fs.ts';
  * GET  /resources         - Lists all configured resources
  * POST /question          - Ask a question (non-streaming)
  * POST /question/stream   - Ask a question (streaming SSE response)
- * POST /opencode          - Get OpenCode instance URL for a collection
  */
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -82,17 +81,6 @@ const QuestionRequestSchema = z.object({
 	quiet: z.boolean().optional()
 });
 
-const OpencodeRequestSchema = z.object({
-	resources: z
-		.array(ResourceNameField)
-		.max(
-			LIMITS.MAX_RESOURCES_PER_REQUEST,
-			`Too many resources (max ${LIMITS.MAX_RESOURCES_PER_REQUEST})`
-		)
-		.optional(),
-	quiet: z.boolean().optional()
-});
-
 const UpdateModelRequestSchema = z.object({
 	provider: z
 		.string()
@@ -120,10 +108,30 @@ const AddGitResourceRequestSchema = z.object({
 	specialNotes: GitResourceSchema.shape.specialNotes
 });
 
+const isWsl = () =>
+	process.platform === 'linux' &&
+	(Boolean(process.env.WSL_DISTRO_NAME) ||
+		Boolean(process.env.WSL_INTEROP) ||
+		Boolean(process.env.WSLENV));
+
+const normalizeWslPath = (value: string) => {
+	if (!isWsl()) return value;
+	const match = value.match(/^([a-zA-Z]):\\(.*)$/);
+	if (!match) return value;
+	const drive = match[1]!.toLowerCase();
+	const rest = match[2]!.replace(/\\/g, '/');
+	return `/mnt/${drive}/${rest}`;
+};
+
+const LocalPathRequestSchema = z.preprocess(
+	(value) => (typeof value === 'string' ? normalizeWslPath(value) : value),
+	LocalResourceSchema.shape.path
+) as z.ZodType<string>;
+
 const AddLocalResourceRequestSchema = z.object({
 	type: z.literal('local'),
 	name: LocalResourceSchema.shape.name,
-	path: LocalResourceSchema.shape.path,
+	path: LocalPathRequestSchema,
 	specialNotes: LocalResourceSchema.shape.specialNotes
 });
 
@@ -361,58 +369,6 @@ const createApp = (deps: {
 			});
 		})
 
-		// POST /opencode - Get OpenCode instance URL for a collection
-		.post('/opencode', async (c: HonoContext) => {
-			const decoded = await decodeJson(c.req.raw, OpencodeRequestSchema);
-			const resourceNames =
-				decoded.resources && decoded.resources.length > 0
-					? decoded.resources
-					: config.resources.map((r) => r.name);
-
-			const collectionKey = getCollectionKey(resourceNames);
-			Metrics.info('opencode.requested', {
-				quiet: decoded.quiet ?? false,
-				resources: resourceNames,
-				collectionKey
-			});
-
-			const collection = await collections.load({ resourceNames, quiet: decoded.quiet });
-			Metrics.info('collection.ready', { collectionKey, path: collection.path });
-
-			const { url, model, instanceId } = await agent.getOpencodeInstance({ collection });
-			Metrics.info('opencode.ready', { collectionKey, url, instanceId });
-
-			return c.json({
-				url,
-				model,
-				instanceId,
-				resources: resourceNames,
-				collection: { key: collectionKey, path: collection.path }
-			});
-		})
-
-		// GET /opencode/instances - List all active OpenCode instances
-		.get('/opencode/instances', (c: HonoContext) => {
-			const instances = agent.listInstances();
-			return c.json({ instances, count: instances.length });
-		})
-
-		// DELETE /opencode/instances - Close all OpenCode instances
-		.delete('/opencode/instances', async (c: HonoContext) => {
-			const result = await agent.closeAllInstances();
-			return c.json(result);
-		})
-
-		// DELETE /opencode/:id - Close a specific OpenCode instance
-		.delete('/opencode/:id', async (c: HonoContext) => {
-			const instanceId = c.req.param('id');
-			const result = await agent.closeInstance(instanceId);
-			if (!result.closed) {
-				return c.json({ error: 'Instance not found', instanceId }, 404);
-			}
-			return c.json({ closed: true, instanceId });
-		})
-
 		// PUT /config/model - Update model configuration
 		.put('/config/model', async (c: HonoContext) => {
 			const decoded = await decodeJson(c.req.raw, UpdateModelRequestSchema);
@@ -529,7 +485,6 @@ export const startServer = async (options: StartServerOptions = {}): Promise<Ser
 		port: actualPort,
 		url: `http://localhost:${actualPort}`,
 		stop: () => {
-			void agent.closeAllInstances();
 			VirtualFs.disposeAll();
 			clearAllVirtualCollectionMetadata();
 			server.stop();

package/src/providers/auth.ts

@@ -13,9 +13,30 @@ import { z } from 'zod';
 import { Result } from 'better-result';
 
 export namespace Auth {
-	const getOpenRouterApiKey = () => {
-		const apiKey = process.env.OPENROUTER_API_KEY;
-		return apiKey && apiKey.trim().length > 0 ? apiKey.trim() : undefined;
+	export type AuthType = 'api' | 'oauth' | 'wellknown';
+
+	export type AuthStatus =
+		| { status: 'ok'; authType: AuthType; apiKey?: string; accountId?: string }
+		| { status: 'missing' }
+		| { status: 'invalid'; authType: AuthType };
+
+	const PROVIDER_AUTH_TYPES: Record<string, readonly AuthType[]> = {
+		opencode: ['api'],
+		openrouter: ['api'],
+		openai: ['oauth'],
+		anthropic: ['api'],
+		google: ['api', 'oauth']
+	};
+
+	const readEnv = (key: string) => {
+		const value = process.env[key];
+		return value && value.trim().length > 0 ? value.trim() : undefined;
+	};
+
+	const getEnvApiKey = (providerId: string) => {
+		if (providerId === 'openrouter') return readEnv('OPENROUTER_API_KEY');
+		if (providerId === 'opencode') return readEnv('OPENCODE_API_KEY');
+		return undefined;
 	};
 
 	// Auth schema matching OpenCode's format
@@ -28,7 +49,8 @@ export namespace Auth {
 		type: z.literal('oauth'),
 		access: z.string(),
 		refresh: z.string(),
-		expires: z.number()
+		expires: z.number(),
+		accountId: z.string().optional()
 	});
 
 	const WellKnownAuthSchema = z.object({
@@ -106,13 +128,52 @@ export namespace Auth {
 		return authData[providerId];
 	}
 
+	export async function getAuthStatus(providerId: string): Promise<AuthStatus> {
+		const allowedTypes = PROVIDER_AUTH_TYPES[providerId];
+		if (!allowedTypes) return { status: 'missing' };
+
+		const envKey = getEnvApiKey(providerId);
+		if (envKey) {
+			return allowedTypes.includes('api')
+				? { status: 'ok', authType: 'api', apiKey: envKey }
+				: { status: 'invalid', authType: 'api' };
+		}
+
+		const auth = await getCredentials(providerId);
+		if (!auth) return { status: 'missing' };
+
+		if (!allowedTypes.includes(auth.type)) {
+			return { status: 'invalid', authType: auth.type };
+		}
+
+		const apiKey = auth.type === 'api' ? auth.key : auth.type === 'oauth' ? auth.access : undefined;
+		const accountId = auth.type === 'oauth' ? auth.accountId : undefined;
+		return { status: 'ok', authType: auth.type, apiKey, accountId };
+	}
+
+	export const getProviderAuthHint = (providerId: string) => {
+		switch (providerId) {
+			case 'openai':
+				return 'Run "opencode auth --provider openai" and complete OAuth.';
+			case 'anthropic':
+				return 'Run "opencode auth --provider anthropic" and enter an API key.';
+			case 'google':
+				return 'Run "opencode auth --provider google" and enter an API key or OAuth.';
+			case 'openrouter':
+				return 'Set OPENROUTER_API_KEY or run "opencode auth --provider openrouter".';
+			case 'opencode':
+				return 'Set OPENCODE_API_KEY or run "opencode auth --provider opencode".';
+			default:
+				return 'Run "opencode auth --provider <provider>" to configure credentials.';
+		}
+	};
+
 	/**
 	 * Check if a provider is authenticated
 	 */
 	export async function isAuthenticated(providerId: string): Promise<boolean> {
-		if (providerId === 'openrouter' && getOpenRouterApiKey()) return true;
-		const auth = await getCredentials(providerId);
-		return auth !== undefined;
+		const status = await getAuthStatus(providerId);
+		return status.status === 'ok';
 	}
 
 	/**
@@ -120,24 +181,9 @@ export namespace Auth {
 	 * Returns undefined if not authenticated or no key available
 	 */
 	export async function getApiKey(providerId: string): Promise<string | undefined> {
-		if (providerId === 'openrouter') {
-			const envKey = getOpenRouterApiKey();
-			if (envKey) return envKey;
-		}
-
-		const auth = await getCredentials(providerId);
-		if (!auth) return undefined;
-
-		if (auth.type === 'api') {
-			return auth.key;
-		}
-
-		if (auth.type === 'oauth') {
-			return auth.access;
-		}
-
-		// wellknown auth doesn't have an API key
-		return undefined;
+		const status = await getAuthStatus(providerId);
+		if (status.status !== 'ok') return undefined;
+		return status.apiKey;
 	}
 
 	/**
@@ -147,20 +193,22 @@ export namespace Auth {
 		return readAuthFile();
 	}
 
+	/**
+	 * Update stored credentials for a provider
+	 */
+	export async function setCredentials(providerId: string, info: AuthInfo): Promise<void> {
+		const filepath = getAuthFilePath();
+		const existing = await readAuthFile();
+		const next = { ...existing, [providerId]: info };
+		await Bun.write(filepath, JSON.stringify(next, null, 2), { mode: 0o600 });
+	}
+
 	/**
 	 * Get the list of all authenticated provider IDs
 	 */
 	export async function getAuthenticatedProviders(): Promise<string[]> {
-		const authData = await readAuthFile();
-		const providers = new Set(Object.keys(authData));
-
-		if (getOpenRouterApiKey()) {
-			providers.add('openrouter');
-		}
-		if (authData['openrouter.ai'] || authData['openrouter-ai']) {
-			providers.add('openrouter');
-		}
-
-		return Array.from(providers);
+		const providers = Object.keys(PROVIDER_AUTH_TYPES);
+		const statuses = await Promise.all(providers.map((provider) => getAuthStatus(provider)));
+		return providers.filter((_, index) => statuses[index]?.status === 'ok');
 	}
 }

package/src/providers/index.ts

@@ -6,7 +6,6 @@ export { Auth } from './auth.ts';
 export { Model } from './model.ts';
 export {
 	PROVIDER_REGISTRY,
-	PROVIDER_ALIASES,
 	isProviderSupported,
 	normalizeProviderId,
 	getProviderFactory,

package/src/providers/model.ts

@@ -16,24 +16,39 @@ export namespace Model {
 	export class ProviderNotFoundError extends Error {
 		readonly _tag = 'ProviderNotFoundError';
 		readonly providerId: string;
+		readonly hint: string;
 
 		constructor(providerId: string) {
 			super(`Provider "${providerId}" is not supported`);
 			this.providerId = providerId;
+			this.hint =
+				'Open an issue to request this provider: https://github.com/davis7dotsh/better-context/issues.';
 		}
 	}
 
 	export class ProviderNotAuthenticatedError extends Error {
 		readonly _tag = 'ProviderNotAuthenticatedError';
 		readonly providerId: string;
+		readonly hint: string;
 
 		constructor(providerId: string) {
-			super(
-				providerId === 'openrouter'
-					? `Provider "${providerId}" is not authenticated. Set OPENROUTER_API_KEY to authenticate.`
-					: `Provider "${providerId}" is not authenticated. Run 'opencode auth login' to authenticate.`
-			);
+			super(`Provider "${providerId}" is not authenticated.`);
 			this.providerId = providerId;
+			this.hint = Auth.getProviderAuthHint(providerId);
+		}
+	}
+
+	export class ProviderAuthTypeError extends Error {
+		readonly _tag = 'ProviderAuthTypeError';
+		readonly providerId: string;
+		readonly authType: string;
+		readonly hint: string;
+
+		constructor(args: { providerId: string; authType: string }) {
+			super(`Provider "${args.providerId}" does not support "${args.authType}" auth.`);
+			this.providerId = args.providerId;
+			this.authType = args.authType;
+			this.hint = Auth.getProviderAuthHint(args.providerId);
 		}
 	}
 
@@ -72,22 +87,24 @@ export namespace Model {
 
 		// Get authentication
 		let apiKey: string | undefined;
+		let accountId: string | undefined;
 
 		if (!options.skipAuth) {
-			// Special handling for 'opencode' provider - check env var first
-			if (normalizedProviderId === 'opencode') {
-				apiKey = process.env.OPENCODE_API_KEY || (await Auth.getApiKey(normalizedProviderId));
-			} else {
-				apiKey = await Auth.getApiKey(normalizedProviderId);
-				if (!apiKey) {
-					throw new ProviderNotAuthenticatedError(providerId);
-				}
+			const status = await Auth.getAuthStatus(normalizedProviderId);
+			if (status.status === 'missing') {
+				throw new ProviderNotAuthenticatedError(providerId);
 			}
+			if (status.status === 'invalid') {
+				throw new ProviderAuthTypeError({ providerId, authType: status.authType });
+			}
+			apiKey = status.apiKey;
+			accountId = status.accountId;
 		}
 
 		// Build provider options
 		const providerOptions: ProviderOptions = {
-			...options.providerOptions
+			...options.providerOptions,
+			...(accountId ? { accountId } : {})
 		};
 
 		if (apiKey) {
@@ -111,11 +128,6 @@ export namespace Model {
 			return false;
 		}
 
-		// Special case: opencode gateway is always available
-		if (normalizedProviderId === 'opencode') {
-			return true;
-		}
-
 		return Auth.isAuthenticated(normalizedProviderId);
 	}
 

package/src/providers/openai.ts

@@ -0,0 +1,220 @@
+import { createOpenAI } from '@ai-sdk/openai';
+import * as os from 'node:os';
+import { Auth } from './auth.ts';
+
+const CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann';
+const ISSUER = 'https://auth.openai.com';
+const CODEX_API_ENDPOINT = 'https://chatgpt.com/backend-api/codex/responses';
+const USER_AGENT = `btca/${process.env.npm_package_version ?? 'dev'} (${os.platform()} ${os.release()}; ${os.arch()})`;
+
+type TokenResponse = {
+	id_token?: string;
+	access_token: string;
+	refresh_token?: string;
+	expires_in?: number;
+};
+
+type IdTokenClaims = {
+	chatgpt_account_id?: string;
+	organizations?: Array<{ id: string }>;
+	email?: string;
+	'https://api.openai.com/auth'?: {
+		chatgpt_account_id?: string;
+	};
+};
+
+const parseJwtClaims = (token: string): IdTokenClaims | undefined => {
+	const parts = token.split('.');
+	if (parts.length !== 3 || !parts[1]) return undefined;
+	try {
+		return JSON.parse(Buffer.from(parts[1], 'base64url').toString()) as IdTokenClaims;
+	} catch {
+		return undefined;
+	}
+};
+
+const extractAccountIdFromClaims = (claims: IdTokenClaims): string | undefined =>
+	claims.chatgpt_account_id ||
+	claims['https://api.openai.com/auth']?.chatgpt_account_id ||
+	claims.organizations?.[0]?.id;
+
+const extractAccountId = (tokens: TokenResponse): string | undefined => {
+	if (tokens.id_token) {
+		const claims = parseJwtClaims(tokens.id_token);
+		const accountId = claims && extractAccountIdFromClaims(claims);
+		if (accountId) return accountId;
+	}
+	if (tokens.access_token) {
+		const claims = parseJwtClaims(tokens.access_token);
+		return claims ? extractAccountIdFromClaims(claims) : undefined;
+	}
+	return undefined;
+};
+
+const refreshAccessToken = async (refreshToken: string): Promise<TokenResponse> => {
+	const response = await fetch(`${ISSUER}/oauth/token`, {
+		method: 'POST',
+		headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+		body: new URLSearchParams({
+			grant_type: 'refresh_token',
+			refresh_token: refreshToken,
+			client_id: CLIENT_ID
+		}).toString()
+	});
+	if (!response.ok) {
+		throw new Error(`Token refresh failed: ${response.status}`);
+	}
+	return response.json() as Promise<TokenResponse>;
+};
+
+const buildHeaders = (initHeaders: unknown, accountId?: string): Headers => {
+	const headers = new Headers();
+
+	if (initHeaders instanceof Headers) {
+		initHeaders.forEach((value, key) => headers.set(key, value));
+	} else if (Array.isArray(initHeaders)) {
+		for (const [key, value] of initHeaders) {
+			if (value !== undefined) headers.set(key, String(value));
+		}
+	} else if (initHeaders && typeof initHeaders === 'object') {
+		for (const [key, value] of Object.entries(initHeaders as Record<string, unknown>)) {
+			if (value !== undefined) headers.set(key, String(value));
+		}
+	}
+
+	if (accountId) {
+		headers.set('ChatGPT-Account-Id', accountId);
+	}
+
+	return headers;
+};
+
+const rewriteUrl = (requestInput: unknown) => {
+	const parsed =
+		requestInput instanceof URL
+			? requestInput
+			: new URL(
+					typeof requestInput === 'string'
+						? requestInput
+						: requestInput instanceof Request
+							? requestInput.url
+							: String(requestInput)
+				);
+
+	return parsed.pathname.includes('/v1/responses') || parsed.pathname.includes('/chat/completions')
+		? new URL(CODEX_API_ENDPOINT)
+		: parsed;
+};
+
+const normalizeBody = (body: unknown): string | undefined => {
+	if (typeof body === 'string') return body;
+	if (body instanceof Uint8Array) return new TextDecoder().decode(body);
+	if (body instanceof ArrayBuffer) return new TextDecoder().decode(new Uint8Array(body));
+	return undefined;
+};
+
+const sanitizeCodexPayload = (parsed: Record<string, unknown>) => {
+	parsed.store = false;
+	if ('previous_response_id' in parsed) {
+		delete parsed.previous_response_id;
+	}
+	const input = parsed.input;
+	if (!Array.isArray(input)) return;
+	parsed.input = input
+		.filter(
+			(item) =>
+				!(item && typeof item === 'object' && 'type' in item && item.type === 'item_reference')
+		)
+		.map((item) => {
+			if (!item || typeof item !== 'object') return item;
+			// Strip item IDs to avoid referencing non-persisted items when store=false.
+			const { id: _unused, ...rest } = item as Record<string, unknown>;
+			return rest;
+		});
+};
+
+const injectCodexDefaults = (
+	init: RequestInit | undefined,
+	instructions?: string
+): RequestInit | undefined => {
+	if (!instructions) return init;
+	const bodyText = normalizeBody(init?.body);
+	if (!bodyText) return init;
+
+	try {
+		const parsed = JSON.parse(bodyText) as Record<string, unknown>;
+		if (parsed.instructions == null) {
+			parsed.instructions = instructions;
+		}
+		sanitizeCodexPayload(parsed);
+		return { ...init, body: JSON.stringify(parsed) };
+	} catch {
+		return init;
+	}
+};
+
+export function createOpenAICodex(
+	options: {
+		apiKey?: string;
+		accountId?: string;
+		baseURL?: string;
+		headers?: Record<string, string>;
+		name?: string;
+		instructions?: string;
+		sessionId?: string;
+	} = {}
+) {
+	const customFetch = (async (requestInput, init) => {
+		const storedAuth = await Auth.getCredentials('openai');
+		let accessToken = options.apiKey;
+		let accountId = options.accountId;
+
+		if (storedAuth?.type === 'oauth') {
+			accessToken = storedAuth.access;
+			accountId = storedAuth.accountId ?? accountId;
+
+			if (!storedAuth.access || storedAuth.expires < Date.now()) {
+				const tokens = await refreshAccessToken(storedAuth.refresh);
+				const refreshedAccountId = extractAccountId(tokens) ?? accountId;
+				accessToken = tokens.access_token;
+				accountId = refreshedAccountId;
+				await Auth.setCredentials('openai', {
+					type: 'oauth',
+					refresh: tokens.refresh_token ?? storedAuth.refresh,
+					access: tokens.access_token,
+					expires: Date.now() + (tokens.expires_in ?? 3600) * 1000,
+					...(refreshedAccountId ? { accountId: refreshedAccountId } : {})
+				});
+			}
+		}
+
+		const url = rewriteUrl(requestInput);
+		const headerSource =
+			init?.headers ?? (requestInput instanceof Request ? requestInput.headers : undefined);
+		const headers = buildHeaders(headerSource, accountId);
+		const fallbackInstructions =
+			options.instructions ?? 'You are btca, an expert documentation search agent.';
+		const nextInit = injectCodexDefaults(init, fallbackInstructions);
+		headers.set('originator', 'opencode');
+		headers.set('User-Agent', USER_AGENT);
+		if (options.sessionId) {
+			headers.set('session_id', options.sessionId);
+		}
+		if (accessToken) {
+			headers.set('authorization', `Bearer ${accessToken}`);
+		}
+		return fetch(url, { ...nextInit, headers });
+	}) as typeof fetch;
+
+	if (fetch.preconnect) {
+		customFetch.preconnect = fetch.preconnect.bind(fetch);
+	}
+
+	return createOpenAI({
+		apiKey: options.apiKey,
+		baseURL: options.baseURL,
+		headers: options.headers,
+		name: options.name,
+		fetch: customFetch
+	});
+}