@gajae-code/ai 0.1.1

package/src/cli.ts

@@ -0,0 +1,262 @@
+#!/usr/bin/env bun
+import * as readline from "node:readline";
+import { AuthStorage, SqliteAuthCredentialStore } from "./auth-storage";
+import { getOAuthProviders } from "./utils/oauth";
+import type { OAuthProvider } from "./utils/oauth/types";
+
+const PROVIDERS = getOAuthProviders();
+
+function prompt(rl: readline.Interface, question: string): Promise<string> {
+	const { promise, resolve, reject } = Promise.withResolvers<string>();
+	const input = process.stdin as NodeJS.ReadStream;
+	const supportsRawMode = input.isTTY && typeof input.setRawMode === "function";
+	const wasRaw = supportsRawMode ? input.isRaw : false;
+	let settled = false;
+
+	const cleanup = () => {
+		rl.off("SIGINT", onSigint);
+		if (supportsRawMode) {
+			input.off("keypress", onKeypress);
+			input.setRawMode?.(wasRaw);
+		}
+	};
+
+	const finish = (result: () => void) => {
+		if (settled) return;
+		settled = true;
+		cleanup();
+		result();
+	};
+
+	const cancel = () => {
+		finish(() => reject(new Error("Login cancelled")));
+	};
+
+	const onSigint = () => {
+		cancel();
+	};
+
+	const onKeypress = (_str: string, key: readline.Key) => {
+		if (key.name === "escape" || (key.ctrl && key.name === "c")) {
+			cancel();
+			rl.close();
+		}
+	};
+
+	if (supportsRawMode) {
+		readline.emitKeypressEvents(input, rl);
+		input.setRawMode(true);
+		input.on("keypress", onKeypress);
+	}
+
+	rl.once("SIGINT", onSigint);
+	rl.question(question, answer => {
+		finish(() => resolve(answer));
+	});
+	return promise;
+}
+
+async function login(provider: OAuthProvider): Promise<void> {
+	const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+	const promptFn = (msg: string) => prompt(rl, `${msg} `);
+	const store = await SqliteAuthCredentialStore.open();
+	const storage = new AuthStorage(store);
+	await storage.reload();
+
+	try {
+		await storage.login(provider, {
+			onAuth(info) {
+				const { url, instructions } = info;
+				console.log(`\nOpen this URL in your browser:\n${url}`);
+				if (instructions) console.log(instructions);
+				console.log();
+			},
+			onProgress(message) {
+				console.log(message);
+			},
+			onPrompt(p) {
+				return promptFn(`${p.message}${p.placeholder ? ` (${p.placeholder})` : ""}:`);
+			},
+		});
+		console.log(`\nCredentials saved to ~/.gjc/agent/agent.db`);
+	} finally {
+		store.close();
+		rl.close();
+	}
+}
+
+async function main(): Promise<void> {
+	const args = process.argv.slice(2);
+	const command = args[0];
+
+	if (!command || command === "help" || command === "--help" || command === "-h") {
+		console.log(`Usage: bunx @gajae-code/ai <command> [provider]
+
+Commands:
+  login [provider]  Login to a provider
+  logout [provider] Logout from a provider
+  status            Show logged-in providers
+  list              List available providers
+
+Providers:
+  anthropic         Anthropic
+  github-copilot    GitHub Copilot
+  google-gemini-cli Google Gemini CLI
+  google-antigravity Antigravity (Gemini 3, Anthropic, GPT-OSS)
+  openai-codex      OpenAI code provider (ChatGPT Plus/Pro)
+  kimi-code         Kimi Code
+  kilo              Kilo Gateway
+  kagi              Kagi
+  tavily            Tavily
+  zai               Z.AI (GLM Coding Plan)
+  deepseek          DeepSeek
+  nanogpt           NanoGPT
+  minimax-code      MiniMax Coding Plan (International)
+  minimax-code-cn   MiniMax Coding Plan (China)
+  cursor            Cursor (Anthropic, GPT, etc.)
+  zenmux            ZenMux
+  ollama-cloud      Ollama Cloud
+
+Examples:
+  bunx @gajae-code/ai login              # interactive provider selection
+  bunx @gajae-code/ai login anthropic    # login to specific provider
+  bunx @gajae-code/ai logout anthropic   # logout from specific provider
+  bunx @gajae-code/ai status             # show logged-in providers
+  bunx @gajae-code/ai list               # list providers
+`);
+		return;
+	}
+
+	if (command === "status") {
+		const storage = await SqliteAuthCredentialStore.open();
+		try {
+			const providers = storage.listProviders();
+			if (providers.length === 0) {
+				console.log("No credentials stored.");
+				console.log(`Use 'bunx @gajae-code/ai login' to authenticate.`);
+			} else {
+				console.log("Logged-in providers:\n");
+				for (const provider of providers) {
+					const oauth = storage.getOAuth(provider);
+					if (oauth) {
+						const expires = new Date(oauth.expires);
+						const expired = Date.now() >= oauth.expires;
+						const status = expired ? "(expired)" : `(expires ${expires.toLocaleString()})`;
+						console.log(`  ${provider.padEnd(20)} ${status}`);
+						continue;
+					}
+					const apiKey = storage.getApiKey(provider);
+					if (apiKey) {
+						console.log(`  ${provider.padEnd(20)} (api key)`);
+					}
+				}
+			}
+		} finally {
+			storage.close();
+		}
+		return;
+	}
+
+	if (command === "list") {
+		console.log("Available providers:\n");
+		for (const p of PROVIDERS) {
+			console.log(`  ${p.id.padEnd(20)} ${p.name}`);
+		}
+		return;
+	}
+
+	if (command === "logout") {
+		let provider = args[1] as OAuthProvider | undefined;
+		const storage = await SqliteAuthCredentialStore.open();
+
+		try {
+			if (!provider) {
+				const providers = storage.listProviders();
+				if (providers.length === 0) {
+					console.log("No credentials stored.");
+					return;
+				}
+
+				const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+				console.log("Select a provider to logout:\n");
+				for (let i = 0; i < providers.length; i++) {
+					console.log(`  ${i + 1}. ${providers[i]}`);
+				}
+				console.log();
+
+				const choice = await prompt(rl, `Enter number (1-${providers.length}): `);
+				rl.close();
+
+				const index = parseInt(choice, 10) - 1;
+				if (index < 0 || index >= providers.length) {
+					console.error("Invalid selection");
+					process.exit(1);
+				}
+				provider = providers[index] as OAuthProvider;
+			}
+			if (!provider) {
+				console.error("No provider selected");
+				process.exit(1);
+			}
+
+			const oauth = storage.getOAuth(provider);
+			const apiKey = storage.getApiKey(provider);
+			if (!oauth && !apiKey) {
+				console.error(`Not logged in to ${provider}`);
+				process.exit(1);
+			}
+
+			storage.deleteProvider(provider);
+			console.log(`Logged out from ${provider}`);
+		} finally {
+			storage.close();
+		}
+		return;
+	}
+
+	if (command === "login") {
+		let provider = args[1] as OAuthProvider | undefined;
+
+		if (!provider) {
+			const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+			console.log("Select a provider:\n");
+			for (let i = 0; i < PROVIDERS.length; i++) {
+				console.log(`  ${i + 1}. ${PROVIDERS[i].name}`);
+			}
+			console.log();
+
+			const choice = await prompt(rl, `Enter number (1-${PROVIDERS.length}): `);
+			rl.close();
+
+			const index = parseInt(choice, 10) - 1;
+			if (index < 0 || index >= PROVIDERS.length) {
+				console.error("Invalid selection");
+				process.exit(1);
+			}
+			provider = PROVIDERS[index].id as OAuthProvider;
+		}
+		if (!provider) {
+			console.error("No provider selected");
+			process.exit(1);
+		}
+
+		if (!PROVIDERS.some(p => p.id === provider)) {
+			console.error(`Unknown provider: ${provider}`);
+			console.error(`Use 'bunx @gajae-code/ai list' to see available providers`);
+			process.exit(1);
+		}
+
+		console.log(`Logging in to ${provider}…`);
+		await login(provider);
+		return;
+	}
+
+	console.error(`Unknown command: ${command}`);
+	console.error(`Use 'bunx @gajae-code/ai --help' for usage`);
+	process.exit(1);
+}
+
+main().catch(err => {
+	console.error("Error:", err.message);
+	process.exit(1);
+});

package/src/index.ts

@@ -0,0 +1,54 @@
+export { type ZodType, z } from "zod/v4";
+export * from "./api-registry";
+export * from "./auth-broker";
+export { type AuthGatewayBootOptions, type ModelResolver, startAuthGateway } from "./auth-gateway/server";
+export * from "./auth-gateway/types";
+export * from "./auth-storage";
+export * from "./model-cache";
+export * from "./model-manager";
+export * from "./model-thinking";
+export * from "./models";
+export * from "./provider-details";
+export * from "./provider-models";
+export * from "./providers/anthropic";
+export * from "./providers/azure-openai-responses";
+export type * from "./providers/cursor";
+export * from "./providers/gitlab-duo";
+export type * from "./providers/google";
+export type * from "./providers/google-gemini-cli";
+export * from "./providers/google-gemini-headers";
+export type * from "./providers/google-vertex";
+export * from "./providers/kimi";
+export * from "./providers/mock";
+export * from "./providers/ollama";
+export * from "./providers/openai-codex-responses";
+export * from "./providers/openai-completions";
+export * from "./providers/openai-responses";
+export * from "./providers/synthetic";
+export * from "./rate-limit-utils";
+export * from "./stream";
+export * from "./types";
+export * from "./usage";
+export * from "./usage/claude";
+export * from "./usage/gemini";
+export * from "./usage/github-copilot";
+export * from "./usage/google-antigravity";
+export * from "./usage/kimi";
+export * from "./usage/minimax-code";
+export * from "./usage/openai-codex";
+export * from "./usage/zai";
+export * from "./utils/anthropic-auth";
+export * from "./utils/discovery";
+export * from "./utils/event-stream";
+export * from "./utils/h2-fetch";
+export * from "./utils/oauth";
+export type {
+	OAuthCredentials,
+	OAuthProvider,
+	OAuthProviderId,
+	OAuthProviderInfo,
+} from "./utils/oauth/types";
+export * from "./utils/overflow";
+export * from "./utils/retry";
+export * from "./utils/schema";
+export * from "./utils/validation";

package/src/model-cache.ts

@@ -0,0 +1,129 @@
+/**
+ * SQLite-backed model cache for atomic cross-process access.
+ * Replaces per-provider JSON files with a single cache.db.
+ */
+import { Database } from "bun:sqlite";
+import { getModelDbPath } from "@gajae-code/utils";
+import type { Api, Model } from "./types";
+
+const CACHE_SCHEMA_VERSION = 3;
+
+interface CacheRow {
+	provider_id: string;
+	version: number;
+	updated_at: number;
+	authoritative: number;
+	static_fingerprint: string;
+	models: string;
+}
+
+interface TableInfoRow {
+	name: string;
+}
+
+interface CacheEntry<TApi extends Api = Api> {
+	models: Model<TApi>[];
+	fresh: boolean;
+	authoritative: boolean;
+	updatedAt: number;
+	/**
+	 * Hash of the static catalog slice that was merged into `models` when this
+	 * row was written. `resolveProviderModels` compares against the current
+	 * static fingerprint and bypasses the static+cache re-merge when they
+	 * match — the cache already incorporates the same static state.
+	 */
+	staticFingerprint: string;
+}
+
+let sharedDb: Database | null = null;
+let sharedDbPath: string | null = null;
+
+function getDb(dbPath?: string): Database {
+	const resolvedPath = dbPath ?? getModelDbPath();
+	if (sharedDb && sharedDbPath === resolvedPath) {
+		return sharedDb;
+	}
+	if (sharedDb) {
+		sharedDb.close();
+	}
+	const db = new Database(resolvedPath, { create: true });
+	db.run("PRAGMA journal_mode = WAL");
+	db.run("PRAGMA busy_timeout = 3000");
+	db.run(`
+		CREATE TABLE IF NOT EXISTS model_cache (
+			provider_id TEXT PRIMARY KEY,
+			version INTEGER NOT NULL,
+			updated_at INTEGER NOT NULL,
+			authoritative INTEGER NOT NULL DEFAULT 0,
+			static_fingerprint TEXT NOT NULL DEFAULT '',
+			models TEXT NOT NULL
+		)
+	`);
+	migrateCacheSchema(db);
+
+	sharedDb = db;
+	sharedDbPath = resolvedPath;
+	return db;
+}
+
+function migrateCacheSchema(db: Database): void {
+	const columns = db.prepare("PRAGMA table_info(model_cache)").all() as TableInfoRow[];
+	if (!columns.some(column => column.name === "static_fingerprint")) {
+		db.run("ALTER TABLE model_cache ADD COLUMN static_fingerprint TEXT NOT NULL DEFAULT ''");
+	}
+	db.run("UPDATE model_cache SET version = ? WHERE version = 2", [CACHE_SCHEMA_VERSION]);
+}
+
+export function readModelCache<TApi extends Api>(
+	providerId: string,
+	ttlMs: number,
+	now: () => number,
+	dbPath?: string,
+): CacheEntry<TApi> | null {
+	try {
+		const db = getDb(dbPath);
+		const row = db.query<CacheRow, [string]>("SELECT * FROM model_cache WHERE provider_id = ?").get(providerId);
+		if (!row || row.version !== CACHE_SCHEMA_VERSION) {
+			return null;
+		}
+		const models = JSON.parse(row.models) as Model<TApi>[];
+		const ageMs = now() - row.updated_at;
+		const fresh = Number.isFinite(ageMs) && ageMs >= 0 && ageMs <= ttlMs;
+		return {
+			models,
+			fresh,
+			authoritative: row.authoritative === 1,
+			updatedAt: row.updated_at,
+			staticFingerprint: row.static_fingerprint ?? "",
+		};
+	} catch {
+		return null;
+	}
+}
+
+export function writeModelCache<TApi extends Api>(
+	providerId: string,
+	updatedAt: number,
+	models: Model<TApi>[],
+	authoritative: boolean,
+	staticFingerprint: string,
+	dbPath?: string,
+): void {
+	try {
+		const db = getDb(dbPath);
+		db.run(
+			`INSERT OR REPLACE INTO model_cache (provider_id, version, updated_at, authoritative, static_fingerprint, models)
+			 VALUES (?, ?, ?, ?, ?, ?)`,
+			[
+				providerId,
+				CACHE_SCHEMA_VERSION,
+				updatedAt,
+				authoritative ? 1 : 0,
+				staticFingerprint,
+				JSON.stringify(models),
+			],
+		);
+	} catch {
+		// Cache writes are best-effort; failures should not break model resolution.
+	}
+}