UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

225 lines (211 loc) • 12.7 kB
/** * Antigravity desktop app (2.15+): ~/.antigravity/settings.json "gateway" block. * Field facts and the stash-and-restore idea follow Magpie (MIT, (c) yetone), internal/agent/antigravity.go. */ import { join } from "node:path"; import { GATEWAY_PLACEHOLDER_KEY, adminGatewayOverride, dropStash, envGatewayOverride, mkdirTracked, normalizeUrl, assertClientSize, checkedClientDestination, clientRefusal, inspectClientFile, inspectStashPresence, isRestoreFile, mutateClient, readClientFile, readStash, removeCreatedClientFile, rmdirsIfEmpty, sha256, writeClientFile, writeStash, } from "./io"; import { GATEWAY_NOTE_TEXT, gatewayNote, type GatewayClientConnector, type GatewayClientContext, type GatewayClientResult, type GatewayClientStatus, type GatewayNoteCode, type GatewayTarget } from "./types"; type Json = Record<string, unknown>; interface Prior { present: boolean; value?: unknown } interface Written { written: { gateway: unknown; defaultModelId: string | null }; writtenSha256: string } /** * `written`/`writtenSha256` is the last state known to be on disk; `pending` is a write that may or may not * have landed, journaled before it starts so an interrupted or failed write still leaves both recognisable. * `pathWiseOnly`: the user edited the file while connected, so disconnect never restores the old bytes. */ interface Stash extends Written { version: 1; path: string; resolvedPath?: string; originalBytes: string | null; createdDirs: string[]; prior: { gateway: Prior; defaultModelId: Prior; list: Prior; modelsPresent: boolean }; pending?: Written; pathWiseOnly?: true; } const statesOf = (stash: Stash): Written[] => [stash, ...(stash.pending ? [stash.pending] : [])]; const ID = "antigravity"; const BOM = String.fromCharCode(0xfeff); const settingsPath = (ctx: GatewayClientContext) => join(ctx.home, ".antigravity", "settings.json"); const isObj = (v: unknown): v is Json => !!v && typeof v === "object" && !Array.isArray(v); const same = (a: unknown, b: unknown) => Bun.deepEquals(a, b, true); const prior = (o: Json | undefined, k: string): Prior => o && k in o ? { present: true, value: o[k] } : { present: false }; interface Parsed { doc: Json; indent: string | number | undefined; eol: string; trailing: boolean; bom: boolean } /** A note code instead of a parse when the file cannot be round-tripped. */ function parseSettings(bytes: Buffer | null): Parsed | GatewayNoteCode { if (!bytes) return { doc: {}, indent: 2, eol: "\n", trailing: true, bom: false }; let text = bytes.toString("utf8"); const bom = text.startsWith(BOM); if (bom) text = text.slice(1); const eol = text.includes("\r\n") ? "\r\n" : "\n"; let doc: unknown = {}; if (text.trim() !== "") { try { doc = JSON.parse(text); } catch { return "settings-not-json"; } } if (!isObj(doc)) return "settings-not-object"; const m = /\n([ \t]+)\S/.exec(text); const indent = m ? m[1] : text.trim().includes("\n") || text.trim().length <= 2 ? 2 : undefined; return { doc, indent, eol, trailing: text === "" || /\n\s*$/.test(text), bom }; } function serialize(p: Parsed): Buffer { let text = JSON.stringify(p.doc, null, p.indent); if (p.eol === "\r\n") text = text.replace(/\n/g, "\r\n"); return Buffer.from((p.bom ? BOM : "") + text + (p.trailing ? p.eol : "")); } function ours(gw: unknown, target?: GatewayTarget): "match" | "other-url" | "no" { if (!isObj(gw) || gw.enabled !== true) return "no"; if (target && normalizeUrl(gw.url) === normalizeUrl(target.url)) return "match"; if (!target) return gw.apiKey === GATEWAY_PLACEHOLDER_KEY ? "match" : "no"; return gw.apiKey === GATEWAY_PLACEHOLDER_KEY ? "other-url" : "no"; } function status(ctx: GatewayClientContext, target?: GatewayTarget): GatewayClientStatus { const path = settingsPath(ctx); const file = inspectClientFile(ctx, path); const parsed = parseSettings(file?.bytes ?? null); const gw = typeof parsed === "string" ? undefined : parsed.doc.gateway; const hasRecord = inspectStashPresence(ctx, ID); const match = ours(gw, target) === "match"; const state = match ? "connected" : hasRecord || file === undefined ? "drifted" : "disconnected"; const overrides: GatewayClientStatus["overrides"] = []; const admin = adminGatewayOverride(ctx); if (admin) overrides.push(admin); const env = envGatewayOverride(ctx, target?.url); if (env) overrides.push(env); const notes = (["restart-app", "no-google-sign-in", "agy-follows-app"] as GatewayNoteCode[]).map(gatewayNote); if (typeof parsed === "string") notes.push(gatewayNote(parsed)); if (match && !hasRecord) notes.push(gatewayNote("no-restore-record")); const models = typeof parsed === "string" || !isObj(parsed.doc.models) ? undefined : parsed.doc.models; const defaultModel = typeof models?.defaultModelId === "string" ? models.defaultModelId : undefined; return { id: ID, label: "Antigravity", state, files: [{ path, role: "user settings", exists: file !== null }], overrides, notes, ...(defaultModel ? { defaultModel } : {}) }; } function checkedStash(ctx: GatewayClientContext, path: string): Stash | null { const stash = readStash<Stash>(ctx, ID); if (stash && (stash.path !== path || !isRestoreFile(ctx.home, path, stash))) { throw new Error("Antigravity restore record does not name the expected settings file"); } return stash; } function assertSameTarget(stash: Stash | null, target: string | undefined): void { if (target && stash?.resolvedPath && stash.resolvedPath !== target) { throw new Error("Antigravity settings now resolve to a different file"); } } function connect(ctx: GatewayClientContext, target: GatewayTarget): GatewayClientResult { const path = settingsPath(ctx); const file = readClientFile(ctx, path); const bytes = file?.bytes ?? null; const parsed = parseSettings(bytes); if (typeof parsed === "string") return clientRefusal(GATEWAY_NOTE_TEXT[parsed], "unsupported-file"); const { doc } = parsed; let stash = checkedStash(ctx, path); assertSameTarget(stash, file?.target); const keep = stash !== null && ours(doc.gateway, undefined) === "match"; const onDisk = keep && file ? statesOf(stash!).find(st => st.writtenSha256 === file.hash) : undefined; const models = isObj(doc.models) ? doc.models : undefined; const dir = join(ctx.home, ".antigravity"); const resolvedPath = checkedClientDestination(ctx, path, file); assertSameTarget(stash, resolvedPath); const newDirs = mkdirTracked(dir); if (!keep) { stash = { version: 1, path, resolvedPath, originalBytes: bytes ? bytes.toString("base64") : null, createdDirs: [...(stash?.createdDirs ?? []), ...newDirs], prior: { gateway: prior(doc, "gateway"), defaultModelId: prior(models, "defaultModelId"), list: prior(models, "list"), modelsPresent: models !== undefined }, // Until the new bytes land, the file on disk is the original; exact restoration of it is a no-op. written: { gateway: null, defaultModelId: null }, writtenSha256: file?.hash ?? "", }; } else { // A file that matches neither the applied nor the pending write was edited by the user. const base = onDisk ?? stash!; const pending = onDisk ? undefined : stash!.pending?.written; const written = { gateway: pending && same(doc.gateway, pending.gateway) ? pending.gateway : base.written.gateway, defaultModelId: pending && models?.defaultModelId === pending.defaultModelId ? pending.defaultModelId : base.written.defaultModelId, }; stash = { ...stash!, resolvedPath, written, writtenSha256: base.writtenSha256, ...(stash!.pathWiseOnly || !onDisk ? { pathWiseOnly: true as const } : {}) }; delete stash.pending; } const gateway = { enabled: true, url: target.url, apiKey: target.apiKey, wireProtocol: "openai" }; doc.gateway = gateway; if (target.defaultModel || models?.list !== undefined) { const m: Json = models ?? {}; if (target.defaultModel) m.defaultModelId = target.defaultModel; delete m.list; doc.models = m; } const out = serialize(parsed); const outSha = sha256(out); const next = stash as Stash; const applied: Written = { written: { gateway, defaultModelId: target.defaultModel ?? (keep ? next.written.defaultModelId : null) }, writtenSha256: outSha }; assertClientSize(out); writeStash(ctx, ID, { ...next, pending: applied }); writeClientFile(ctx, path, file, out); // The settings are applied; if this promotion fails, the journaled pending state still describes them. try { writeStash(ctx, ID, { ...next, ...applied }); } catch { /* pending stays recognisable */ } const unchanged = file?.hash === outSha; return { ok: true, changed: !unchanged, changedFiles: unchanged ? [] : [path], message: "Antigravity now uses the OpenCodex gateway. Restart Antigravity to apply it.", notes: status(ctx, target).notes }; } function disconnect(ctx: GatewayClientContext): GatewayClientResult { const path = settingsPath(ctx); const stash = checkedStash(ctx, path); if (!stash) return { ok: true, changed: false, changedFiles: [], restore: "none", message: "Not connected by OpenCodex; nothing was changed.", notes: [] }; const file = readClientFile(ctx, path); assertSameTarget(stash, file?.target); const done = (restore: "exact" | "path-wise" | "none", message: string, files: string[]): GatewayClientResult => { try { dropStash(ctx, ID); } catch (error) { return clientRefusal(`Could not remove the Antigravity restore record: ${(error as Error).message}`, "io-error", files); } return { ok: true, changed: files.length > 0, changedFiles: files, restore, message, notes: [gatewayNote("restart-app")] }; }; const states = statesOf(stash); if (file && !stash.pathWiseOnly && states.some(st => st.writtenSha256 === file.hash)) { if (stash.originalBytes === null) { removeCreatedClientFile(ctx, path, file); rmdirsIfEmpty(ctx, stash.createdDirs); } else writeClientFile(ctx, path, file, Buffer.from(stash.originalBytes, "base64")); return done("exact", "Antigravity settings restored byte for byte.", [path]); } if (!file) return done("none", "The settings file is already gone; the restore record was cleared.", []); const parsed = parseSettings(file.bytes); if (typeof parsed === "string") return clientRefusal(`${GATEWAY_NOTE_TEXT[parsed]} The restore record was kept.`, "unsupported-file"); const { doc } = parsed; const models = isObj(doc.models) ? doc.models : undefined; const saved = stash.prior; const writtenModels = states.map(st => st.written.defaultModelId).filter((id): id is string => id !== null); const gatewayMatches = states.some(st => st.written.gateway !== null && same(doc.gateway, st.written.gateway)); const defaultMatches = writtenModels.some(id => models?.defaultModelId === id); const listWasRemoved = saved.list.present && (models !== undefined || doc.models === undefined) && models?.list === undefined; // A prior value may already be in place if a previous restore could not remove the record. const conflicts: string[] = []; if (!gatewayMatches && !same(doc.gateway, saved.gateway.value)) conflicts.push("gateway"); if (writtenModels.length > 0 && !defaultMatches && !same(models?.defaultModelId, saved.defaultModelId.value)) { conflicts.push("models.defaultModelId"); } if (saved.list.present && !listWasRemoved && !same(models?.list, saved.list.value)) conflicts.push("models.list"); if (conflicts.length) { return clientRefusal(`Antigravity settings changed at ${conflicts.join(", ")}. The restore record was kept.`, "unsupported-file"); } if (gatewayMatches) { if (saved.gateway.present) doc.gateway = saved.gateway.value; else delete doc.gateway; } if (models && defaultMatches) { if (saved.defaultModelId.present) models.defaultModelId = saved.defaultModelId.value; else delete models.defaultModelId; } if (listWasRemoved) { const m: Json = models ?? {}; m.list = saved.list.value; doc.models = m; } const finalModels = isObj(doc.models) ? doc.models : undefined; if (finalModels && Object.keys(finalModels).length === 0 && !stash.prior.modelsPresent) delete doc.models; writeClientFile(ctx, path, file, serialize(parsed)); return done("path-wise", `The file changed after OpenCodex wrote it, so only the gateway, models.defaultModelId and models.list entries were restored; your other edits were kept.`, [path]); } export const ANTIGRAVITY_CONNECTOR: GatewayClientConnector = { id: ID, label: "Antigravity", status, connect: (ctx, target) => mutateClient(ctx, () => connect(ctx, target)), disconnect: ctx => mutateClient(ctx, () => disconnect(ctx)), };