opencode-openai-account-switcher 0.1.0

package/scripts/sync-codex-upstream.mjs

@@ -0,0 +1,348 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises"
+import path from "node:path"
+import process from "node:process"
+
+const defaultOutput = path.resolve("src/upstream/codex-plugin.snapshot.ts")
+const upstreamRepo = process.env.OPENCODE_SYNC_UPSTREAM_REPO ?? "anomalyco/opencode"
+const upstreamBranch = process.env.OPENCODE_SYNC_UPSTREAM_BRANCH ?? "dev"
+const upstreamPath = "packages/opencode/src/plugin/codex.ts"
+const rawBaseUrl = (process.env.OPENCODE_SYNC_RAW_BASE_URL ?? "https://raw.githubusercontent.com").replace(/\/$/, "")
+const defaultSourceUrl = `${rawBaseUrl}/${upstreamRepo}/${upstreamBranch}/${upstreamPath}`
+const canonicalRepositoryUrl = `https://github.com/${upstreamRepo}`
+
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error)
+}
+
+function createSnapshotDriftError(message) {
+  const error = new Error(`snapshot drift detected\n${message}`)
+  error.code = "SNAPSHOT_DRIFT_DETECTED"
+  return error
+}
+
+function parseArgs(argv) {
+  const result = {
+    check: false,
+    output: defaultOutput,
+  }
+
+  function requireValue(flag, index) {
+    const next = argv[index + 1]
+    if (!next || next.startsWith("--")) {
+      throw new Error(`Missing value for ${flag}`)
+    }
+    return next
+  }
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i]
+    if (arg === "--check") {
+      result.check = true
+      continue
+    }
+    if (arg === "--source") {
+      result.source = requireValue(arg, i)
+      i += 1
+      continue
+    }
+    if (arg === "--output") {
+      result.output = path.resolve(requireValue(arg, i))
+      i += 1
+      continue
+    }
+    if (arg === "--upstream-commit") {
+      result.upstreamCommit = requireValue(arg, i)
+      i += 1
+      continue
+    }
+    if (arg === "--sync-date") {
+      result.syncDate = requireValue(arg, i)
+      i += 1
+      continue
+    }
+
+    throw new Error(`Unknown argument: ${arg}`)
+  }
+
+  return result
+}
+
+async function readText(source) {
+  if (/^https?:\/\//.test(source)) {
+    const response = await fetch(source)
+    if (!response.ok) {
+      throw new Error(`Failed to fetch source: ${response.status}`)
+    }
+    return response.text()
+  }
+
+  return readFile(path.resolve(source), "utf8")
+}
+
+function normalize(text) {
+  return text.replace(/\r\n/g, "\n")
+}
+
+function ensureSingleMatch(text, pattern, label) {
+  const count = [...text.matchAll(pattern)].length
+  if (count !== 1) {
+    throw new Error(`Expected exactly one ${label} anchor, found ${count}`)
+  }
+}
+
+function stripImports(source) {
+  const match = source.match(/^(?:import[^\n]*\n)+\n?/)
+  if (!match) throw new Error("Unable to locate import block in upstream source")
+  return source.slice(match[0].length).trimStart()
+}
+
+function buildHeader(meta) {
+  return `// @ts-nocheck
+import { AsyncLocalStorage } from "node:async_hooks"
+import { createServer } from "node:http"
+import os from "node:os"
+
+/*
+ * Upstream snapshot source:
+ * - Repository: ${meta.repositoryUrl}
+ * - Original path: ${upstreamPath}
+ * - Sync date: ${meta.syncDate}
+ * - Upstream commit: ${meta.upstreamCommit}
+ *
+ * Generated by scripts/sync-codex-upstream.mjs.
+ * Do not edit this file directly; update the sync script and regenerate it.
+ */`
+}
+
+function buildShimBlock() {
+  return `/* LOCAL_SHIMS_START */
+type RequestInfo = Request | URL | string
+
+type Hooks = any
+type PluginInput = any
+const officialCodexExportBridgeStorage = new AsyncLocalStorage<{
+  fetchImpl: typeof globalThis.fetch
+  version: string
+}>()
+
+const officialCodexExportBridge = {
+  version: "snapshot",
+  fetchImpl(request: RequestInfo | URL, init?: RequestInit) {
+    return globalThis.fetch(request, init)
+  },
+  async run(options: { fetchImpl?: typeof globalThis.fetch; version?: string } = {}, fn: () => Promise<any>) {
+    return officialCodexExportBridgeStorage.run(
+      {
+        fetchImpl: options.fetchImpl ?? this.fetchImpl,
+        version: options.version ?? this.version,
+      },
+      fn,
+    )
+  },
+}
+
+const Installation = {
+  get VERSION() {
+    return officialCodexExportBridgeStorage.getStore()?.version ?? officialCodexExportBridge.version
+  },
+  set VERSION(value) {
+    officialCodexExportBridge.version = value
+  },
+}
+
+const OAUTH_DUMMY_KEY = "official-codex-oauth"
+
+function fetch(request: RequestInfo | URL, init?: RequestInit) {
+  return (officialCodexExportBridgeStorage.getStore()?.fetchImpl ?? officialCodexExportBridge.fetchImpl)(request, init)
+}
+
+function sleep(ms: number) {
+  return Bun.sleep(ms)
+}
+
+const Bun = {
+  serve(options: { port: number; fetch: (request: Request) => Response | Promise<Response> }) {
+    let closed = false
+    let listening = false
+    let closePromise: Promise<void> | undefined
+    let resolveReady: (() => void) | undefined
+    let rejectReady: ((error: Error) => void) | undefined
+    const ready = new Promise<void>((resolve, reject) => {
+      resolveReady = resolve
+      rejectReady = reject
+    })
+
+    const server = createServer((req, res) => {
+      const chunks: Buffer[] = []
+
+      req.on("data", (chunk) => {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk))
+      })
+
+      req.on("error", (error) => {
+        res.statusCode = 500
+        res.end(String(error))
+      })
+
+      req.on("end", () => {
+        const body = chunks.length > 0 ? Buffer.concat(chunks) : undefined
+        const request = new Request("http://127.0.0.1:" + options.port + (req.url ?? "/"), {
+          method: req.method,
+          headers: req.headers,
+          body,
+          duplex: "half",
+        })
+
+        Promise.resolve(options.fetch(request))
+          .then(async (response) => {
+            res.statusCode = response.status
+            response.headers.forEach((value, key) => res.setHeader(key, value))
+            const payload = Buffer.from(await response.arrayBuffer())
+            res.end(payload)
+          })
+          .catch((error) => {
+            res.statusCode = 500
+            res.end(String(error))
+          })
+      })
+    })
+
+    server.once("listening", () => {
+      listening = true
+      resolveReady?.()
+      resolveReady = undefined
+      rejectReady = undefined
+    })
+    server.once("error", (error: Error) => {
+      if (!listening) {
+        rejectReady?.(error)
+        resolveReady = undefined
+        rejectReady = undefined
+      }
+    })
+
+    server.listen(options.port)
+
+    return {
+      ready,
+      stop() {
+        if (closePromise) return closePromise
+        closePromise = new Promise((resolve, reject) => {
+          if (closed) {
+            resolve()
+            return
+          }
+          server.close((error) => {
+            if (error) {
+              reject(error)
+              return
+            }
+            closed = true
+            resolve()
+          })
+        })
+        return closePromise
+      },
+    }
+  },
+  sleep(ms: number) {
+    return new Promise((resolve) => setTimeout(resolve, ms))
+  },
+}
+
+const Log = {
+  create() {
+    return {
+      info() {},
+      warn() {},
+      error() {},
+    }
+  },
+}
+/* LOCAL_SHIMS_END */`
+}
+
+function buildExportBridgeBlock() {
+  return `/* GENERATED_EXPORT_BRIDGE_START */
+export { officialCodexExportBridge }
+/* GENERATED_EXPORT_BRIDGE_END */`
+}
+
+function validateSnapshotMarkers(source) {
+  const shimsStart = [...source.matchAll(/\/\* LOCAL_SHIMS_START \*\//g)].length
+  const shimsEnd = [...source.matchAll(/\/\* LOCAL_SHIMS_END \*\//g)].length
+  const bridgeStart = [...source.matchAll(/\/\* GENERATED_EXPORT_BRIDGE_START \*\//g)].length
+  const bridgeEnd = [...source.matchAll(/\/\* GENERATED_EXPORT_BRIDGE_END \*\//g)].length
+  if (shimsStart !== 1 || shimsEnd !== 1) {
+    throw new Error("Invalid LOCAL_SHIMS markers in snapshot")
+  }
+  if (bridgeStart !== 1 || bridgeEnd !== 1) {
+    throw new Error("Invalid GENERATED_EXPORT_BRIDGE markers in snapshot")
+  }
+}
+
+function buildSnapshot(source, meta) {
+  const normalized = normalize(source).trim() + "\n"
+  ensureSingleMatch(normalized, /export\s+async\s+function\s+CodexAuthPlugin\s*\(/gm, "CodexAuthPlugin")
+  ensureSingleMatch(normalized, /async\s+loader\s*\(/g, "auth.loader")
+  ensureSingleMatch(normalized, /methods\s*:\s*\[/g, "auth.methods")
+  ensureSingleMatch(normalized, /"chat\.headers"\s*:\s*async\s*\(/g, "chat.headers")
+  const stripped = stripImports(normalized)
+
+  return `${buildHeader(meta)}\n\n${buildShimBlock()}\n\n${stripped.trimEnd()}\n\n${buildExportBridgeBlock()}\n`
+}
+
+function summarizeMismatch(expected, actual) {
+  const expectedLines = expected.split("\n")
+  const actualLines = actual.split("\n")
+  const limit = Math.max(expectedLines.length, actualLines.length)
+
+  for (let index = 0; index < limit; index += 1) {
+    if (expectedLines[index] === actualLines[index]) continue
+    return [
+      `first difference at line ${index + 1}`,
+      `expected: ${expectedLines[index] ?? "<eof>"}`,
+      `actual:   ${actualLines[index] ?? "<eof>"}`,
+    ].join("\n")
+  }
+
+  return "files differ"
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2))
+  const source = args.source ?? defaultSourceUrl
+  const currentBuffer = await readFile(args.output).catch(() => Buffer.alloc(0))
+  const current = currentBuffer.toString("utf8")
+  const normalizedCurrent = normalize(current)
+  if (current && (current.includes("LOCAL_SHIMS_START") || current.includes("GENERATED_EXPORT_BRIDGE_START"))) {
+    validateSnapshotMarkers(normalizedCurrent)
+  }
+
+  const generated = buildSnapshot(await readText(source), {
+    repositoryUrl: canonicalRepositoryUrl,
+    upstreamCommit: args.upstreamCommit ?? "unknown",
+    syncDate: args.syncDate ?? new Date().toISOString().slice(0, 10),
+  })
+
+  if (args.check) {
+    if (currentBuffer.equals(Buffer.from(generated, "utf8"))) {
+      process.stdout.write("in-sync\n")
+      return
+    }
+    process.stdout.write(`${createSnapshotDriftError(summarizeMismatch(generated, current)).message}\n`)
+    process.exitCode = 1
+    return
+  }
+
+  await mkdir(path.dirname(args.output), { recursive: true })
+  await writeFile(args.output, generated, "utf8")
+  process.stdout.write(`wrote ${args.output}\n`)
+}
+
+try {
+  await main()
+} catch (error) {
+  process.stderr.write(`${formatError(error)}\n`)
+  process.exitCode = 1
+}