@harars/opencode-switch-openai-auth-plugin 0.1.0 → 0.1.2

package/src/store.ts

@@ -1,244 +0,0 @@
-import fs from "node:fs/promises"
-import path from "node:path"
-import type { OpenAIAuth, StoreEntry, StoreFile, StoreLoad, StoredAccount } from "./types"
-import { authPath, storeDir, storePath } from "./paths"
-import { clean, entryFromAuth, extractAccountId, extractEmail, fallback } from "./parse"
-
-function obj(v: unknown) {
-  return v && typeof v === "object" ? (v as Record<string, unknown>) : undefined
-}
-
-function text(v: unknown) {
-  return typeof v === "string" && v.trim() ? v : undefined
-}
-
-function num(v: unknown) {
-  return typeof v === "number" && Number.isFinite(v) ? v : undefined
-}
-
-export function validAuth(v: unknown): v is OpenAIAuth {
-  const item = obj(v)
-  if (!item) return false
-  if (item.type !== "oauth") return false
-  if (!text(item.refresh) || !text(item.access) || num(item.expires) === undefined) return false
-  if (item.accountId !== undefined && !text(item.accountId)) return false
-  if (item.enterpriseUrl !== undefined && !text(item.enterpriseUrl)) return false
-  return true
-}
-
-function validEntry(id: string, v: unknown): v is StoreEntry {
-  const item = obj(v)
-  if (!item || item.key !== id) return false
-  if (item.email !== undefined && !text(item.email)) return false
-  if (item.accountId !== undefined && !text(item.accountId)) return false
-  if (item.plan !== undefined && !text(item.plan)) return false
-  if (num(item.savedAt) === undefined) return false
-  if (item.lastUsedAt !== undefined && num(item.lastUsedAt) === undefined) return false
-  return validAuth(item.auth)
-}
-
-async function readJson(file: string) {
-  const data = Bun.file(file)
-  if (!(await data.exists())) return
-  const raw = (await data.text()).trim()
-  if (!raw) return
-  return JSON.parse(raw) as unknown
-}
-
-async function writeJson(file: string, value: unknown) {
-  await fs.mkdir(storeDir(), { recursive: true })
-  await Bun.write(file, `${JSON.stringify(value, null, 2)}\n`)
-}
-
-function hydrateAccount(id: string, item: StoreEntry): StoredAccount {
-  return {
-    ...item,
-    id,
-    email: item.email || extractEmail(item.auth),
-    accountId: item.accountId || extractAccountId(item.auth),
-  }
-}
-
-function normalizeEntries(entries: Record<string, unknown>) {
-  const normalized: Record<string, StoreEntry> = {}
-  let changed = false
-
-  for (const [id, value] of Object.entries(entries)) {
-    if (!validEntry(id, value)) {
-      const item = obj(value)
-      if (!item || !validAuth(item.auth)) {
-        changed = true
-        continue
-      }
-      const auth = clean(item.auth)
-      const nextKey = fallback(auth.refresh)
-      normalized[nextKey] = {
-        key: nextKey,
-        email: text(item.email) || extractEmail(auth),
-        accountId: text(item.accountId) || extractAccountId(auth),
-        plan: text(item.plan),
-        savedAt: num(item.savedAt) ?? Date.now(),
-        ...(num(item.lastUsedAt) !== undefined ? { lastUsedAt: num(item.lastUsedAt) } : {}),
-        auth,
-      }
-      changed = true
-      continue
-    }
-
-    const nextKey = fallback(value.auth.refresh)
-    if (nextKey !== id || value.key !== nextKey) changed = true
-    normalized[nextKey] = {
-      ...value,
-      key: nextKey,
-      auth: clean(value.auth),
-    }
-  }
-
-  return { normalized, changed }
-}
-
-export async function readCurrentAuth() {
-  const raw = await readJson(authPath())
-  const data = obj(raw)
-  if (!data) return
-  const auth = data.openai
-  if (!validAuth(auth)) return
-  return clean(auth)
-}
-
-export async function writeCurrentOpenAI(auth: OpenAIAuth) {
-  const raw = (await readJson(authPath())) ?? {}
-  const next = obj(raw) ?? {}
-  next.openai = clean(auth)
-  await fs.mkdir(path.dirname(authPath()), { recursive: true })
-  await Bun.write(authPath(), `${JSON.stringify(next, null, 2)}\n`)
-}
-
-export async function readStore(): Promise<StoreLoad> {
-  const raw = await readJson(storePath())
-  if (raw === undefined) return { ok: false, reason: "missing" }
-  const root = obj(raw)
-  const map = obj(root?.openai)
-  if (!root || root.version !== 1 || !map) return { ok: false, reason: "malformed" }
-  const { normalized, changed } = normalizeEntries(map)
-  if (changed) {
-    await writeStore({ version: 1, openai: normalized })
-  }
-  return {
-    ok: true,
-    store: {
-      version: 1,
-      openai: normalized,
-    },
-  }
-}
-
-export async function writeStore(store: StoreFile) {
-  await writeJson(storePath(), store)
-}
-
-export async function readAllAccounts() {
-  const load = await readStore()
-  if (!load.ok) return load
-  return {
-    ok: true as const,
-    accounts: Object.entries(load.store.openai)
-      .filter(([id, item]) => validEntry(id, item))
-      .map(([id, item]) => hydrateAccount(id, item)),
-  }
-}
-
-export async function pruneInvalidAccounts() {
-  const load = await readStore()
-  if (!load.ok) return load
-  const next = Object.fromEntries(Object.entries(load.store.openai).filter(([id, item]) => validEntry(id, item)))
-  if (Object.keys(next).length !== Object.keys(load.store.openai).length) {
-    await writeStore({ version: 1, openai: next })
-  }
-  return {
-    ok: true as const,
-    accounts: Object.entries(next).map(([id, item]) => hydrateAccount(id, item)),
-  }
-}
-
-export async function currentAccountId() {
-  const auth = await readCurrentAuth()
-  if (!auth) return
-  return fallback(auth.refresh)
-}
-
-function match(list: StoredAccount[], auth: OpenAIAuth) {
-  return list.find((item) => {
-    if (item.auth.refresh === auth.refresh) return true
-    return item.id === fallback(auth.refresh)
-  })?.id
-}
-
-export async function upsertSavedAccount(auth: OpenAIAuth) {
-  const base = entryFromAuth(auth)
-  const load = await readStore()
-  const store = load.ok ? load.store : { version: 1 as const, openai: {} }
-  const list = Object.entries(store.openai)
-  const match = list.find(([id, item]) => {
-    if (!validEntry(id, item)) return false
-    return item.auth.refresh === auth.refresh || id === base.key
-  })
-  const prev = match?.[1]
-  const next: StoreEntry = {
-    ...base,
-    savedAt: prev?.savedAt ?? base.savedAt,
-    lastUsedAt: prev?.lastUsedAt,
-  }
-  const out = Object.fromEntries(
-    list.filter(([id]) => id !== match?.[0]).filter(([id, item]) => validEntry(id, item)),
-  ) as Record<string, StoreEntry>
-  out[next.key] = next
-  await writeStore({ version: 1, openai: out })
-  return { ...next, id: next.key }
-}
-
-function sort(list: StoredAccount[], cur?: string) {
-  return [...list].sort((a, b) => {
-    const ac = a.id === cur ? 1 : 0
-    const bc = b.id === cur ? 1 : 0
-    if (ac !== bc) return bc - ac
-    if ((b.lastUsedAt ?? 0) !== (a.lastUsedAt ?? 0)) return (b.lastUsedAt ?? 0) - (a.lastUsedAt ?? 0)
-    if (b.savedAt !== a.savedAt) return b.savedAt - a.savedAt
-    return (a.email || a.accountId || a.id).localeCompare(b.email || b.accountId || b.id)
-  })
-}
-
-export async function listAccounts() {
-  const load = await pruneInvalidAccounts()
-  if (!load.ok) return load
-  const auth = await readCurrentAuth()
-  const cur = auth ? match(load.accounts, auth) ?? fallback(auth.refresh) : undefined
-  return { ok: true as const, accounts: sort(load.accounts, cur), current: cur }
-}
-
-export async function switchAccount(id: string) {
-  const load = await readStore()
-  if (!load.ok) throw new Error("account store unavailable")
-  const item = load.store.openai[id]
-  if (!validEntry(id, item)) throw new Error("saved account not found")
-  await writeCurrentOpenAI(item.auth)
-  await writeStore({
-    version: 1,
-    openai: {
-      ...load.store.openai,
-      [id]: {
-        ...item,
-        lastUsedAt: Date.now(),
-      },
-    },
-  })
-}
-
-export async function deleteSavedAccount(id: string) {
-  const load = await readStore()
-  if (!load.ok) throw new Error("account store unavailable")
-  if (!(id in load.store.openai)) throw new Error("saved account not found")
-  const next = { ...load.store.openai }
-  delete next[id]
-  await writeStore({ version: 1, openai: next })
-}

package/src/tui.tsx

@@ -1,194 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-import type { TuiCommand, TuiPlugin, TuiPluginModule } from "@opencode-ai/plugin/tui"
-import { accountDescription, accountFooter, accountTitle, loginTitle, logoutTitle } from "./format"
-import { hasLogin, loginOpenAI } from "./login"
-import { deleteSavedAccount, listAccounts, switchAccount } from "./store"
-import type { StoredAccount, SwitchAction, SwitchOption } from "./types"
-
-let seq = 0
-
-function frame(text: string) {
-  return (
-    <box paddingLeft={2} paddingRight={2} paddingTop={2} paddingBottom={2}>
-      <text>{text}</text>
-    </box>
-  )
-}
-
-async function pick(api: Parameters<TuiPlugin>[0], list: StoredAccount[]) {
-  return await new Promise<string | null>((resolve) => {
-    api.ui.dialog.replace(
-      () => (
-        <api.ui.DialogSelect
-          title="Remove saved account"
-          options={list.map((item) => ({
-            title: accountTitle(item),
-            value: item.id,
-            category: accountDescription(item, false),
-          }))}
-          onSelect={(item) => resolve(item.value)}
-        />
-      ),
-      () => resolve(null),
-    )
-  })
-}
-
-async function confirm(api: Parameters<TuiPlugin>[0], title: string, message: string) {
-  return await new Promise<boolean>((resolve) => {
-    api.ui.dialog.replace(
-      () => (
-        <api.ui.DialogConfirm
-          title={title}
-          message={message}
-          onConfirm={() => resolve(true)}
-          onCancel={() => resolve(false)}
-        />
-      ),
-      () => resolve(false),
-    )
-  })
-}
-
-async function remove(api: Parameters<TuiPlugin>[0], list: StoredAccount[]) {
-  const id = await pick(api, list)
-  if (!id) return
-  const item = list.find((row) => row.id === id)
-  if (!item) return
-  const ok = await confirm(api, "Remove saved account", `Remove ${accountTitle(item)} from saved accounts?`)
-  if (!ok) return
-  try {
-    await deleteSavedAccount(id)
-    api.ui.toast({ variant: "success", message: "Saved account removed" })
-  } catch {
-    api.ui.toast({ variant: "error", message: "Failed to remove saved account" })
-  }
-}
-
-function options(list: StoredAccount[], current: string | undefined, canLogin: boolean): SwitchOption[] {
-  const rows = list.map((item) => ({
-    title: accountTitle(item),
-    value: { type: "account", id: item.id } as SwitchAction,
-    description: accountDescription(item, item.id === current),
-    footer: accountFooter(item.id === current),
-    category: "Accounts",
-  }))
-  return [
-    ...(canLogin ? [{ title: loginTitle(), value: { type: "login" } as SwitchAction }] : []),
-    ...rows,
-    ...(list.length
-      ? [
-          {
-            title: logoutTitle(true),
-            value: { type: "logout" } as SwitchAction,
-            description: "Remove a saved account",
-            category: "Actions",
-          },
-        ]
-      : []),
-  ]
-}
-
-async function open(api: Parameters<TuiPlugin>[0]) {
-  const id = ++seq
-  api.ui.dialog.setSize("large")
-  api.ui.dialog.replace(() => frame("Loading accounts..."))
-
-  const [store, canLogin] = await Promise.all([listAccounts(), hasLogin(api)])
-  if (id !== seq) return
-
-  if (!store.ok && store.reason === "malformed") {
-    api.ui.toast({ variant: "error", message: "Failed to load account store" })
-  }
-
-  const accounts = store.ok ? store.accounts : []
-  const current = store.ok ? store.current : undefined
-  const rows = options(accounts, current, canLogin)
-
-  if (!rows.length) {
-    api.ui.dialog.replace(() => frame("OpenAI login unavailable and no saved accounts found"))
-    return
-  }
-
-  if (!accounts.length && canLogin) {
-    api.ui.dialog.replace(() => (
-      <api.ui.DialogSelect
-        title="Switch OpenAI account"
-        options={rows}
-        placeholder="Search"
-        onSelect={(item) => void act(api, item.value, accounts)}
-      />
-    ))
-    return
-  }
-
-  api.ui.dialog.replace(() => (
-    <api.ui.DialogSelect
-      title="Switch OpenAI account"
-      options={rows}
-      placeholder="Search"
-      current={current ? ({ type: "account", id: current } as SwitchAction) : undefined}
-      onSelect={(item) => void act(api, item.value, accounts)}
-    />
-  ))
-}
-
-async function act(api: Parameters<TuiPlugin>[0], action: SwitchAction, list: StoredAccount[]) {
-  if (action.type === "login") {
-    const ok = await loginOpenAI(api)
-    if (ok) {
-      api.ui.toast({ variant: "success", message: "Account saved" })
-      await open(api)
-    }
-    return
-  }
-  if (action.type === "logout") {
-    await remove(api, list)
-    await open(api)
-    return
-  }
-  try {
-    await switchAccount(action.id)
-  } catch {
-    api.ui.toast({ variant: "error", message: "Failed to switch account" })
-    return
-  }
-
-  try {
-    const client = api.client as typeof api.client & {
-      sync?: { bootstrap?: () => Promise<void> }
-    }
-    if (typeof api.client.instance.dispose === "function") {
-      await api.client.instance.dispose()
-    }
-    if (typeof client.sync?.bootstrap === "function") {
-      await client.sync.bootstrap()
-    }
-    api.ui.toast({ variant: "success", message: "Switched OpenAI account" })
-    api.ui.dialog.clear()
-  } catch {
-    api.ui.toast({
-      variant: "warning",
-      message: "Account file was switched, but session refresh failed",
-    })
-  }
-}
-
-const tui: TuiPlugin = async (api) => {
-  api.command.register(() => [
-    {
-      title: "Switch OpenAI account",
-      value: "openai.switch",
-      description: "Login, switch, or remove saved OpenAI accounts",
-      slash: { name: "switch" },
-      onSelect: () => {
-        void open(api)
-      },
-    } satisfies TuiCommand,
-  ])
-}
-
-export default {
-  id: "harars.switch-auth",
-  tui,
-} satisfies TuiPluginModule & { id: string }

package/src/types.ts

@@ -1,71 +0,0 @@
-export type OpenAIAuth = {
-  type: "oauth"
-  refresh: string
-  access: string
-  expires: number
-  accountId?: string
-  enterpriseUrl?: string
-}
-
-export type StoreEntry = {
-  key: string
-  email?: string
-  accountId?: string
-  plan?: string
-  savedAt: number
-  lastUsedAt?: number
-  auth: OpenAIAuth
-}
-
-export type StoreFile = {
-  version: 1
-  openai: Record<string, StoreEntry>
-}
-
-export type StoredAccount = StoreEntry & {
-  id: string
-}
-
-export type SwitchAction =
-  | { type: "login" }
-  | { type: "account"; id: string }
-  | { type: "logout" }
-
-export type SwitchOption = {
-  title: string
-  value: SwitchAction
-  description?: string
-  category?: string
-  footer?: string
-}
-
-export type Claims = Record<string, unknown>
-
-export type StoreLoad =
-  | { ok: true; store: StoreFile }
-  | { ok: false; reason: "malformed" | "missing" }
-
-export type ProviderPrompt = {
-  type: "text" | "select"
-  key: string
-  message: string
-  placeholder?: string
-  options?: Array<{ label: string; value: string; hint?: string }>
-  when?: {
-    key: string
-    op: "eq" | "neq"
-    value: string
-  }
-}
-
-export type ProviderMethod = {
-  type: "oauth" | "api"
-  label: string
-  prompts?: ProviderPrompt[]
-}
-
-export type OAuthAuthz = {
-  url: string
-  method: "auto" | "code"
-  instructions: string
-}