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

package/dist/tui.js

@@ -0,0 +1,922 @@
+// @bun
+// src/tui.tsx
+import { createComponent as _$createComponent2 } from "@opentui/solid";
+import { insertNode as _$insertNode2 } from "@opentui/solid";
+import { insert as _$insert2 } from "@opentui/solid";
+import { setProp as _$setProp2 } from "@opentui/solid";
+import { createElement as _$createElement2 } from "@opentui/solid";
+
+// src/format.ts
+function short(id) {
+  if (!id)
+    return;
+  if (id.length <= 12)
+    return id;
+  return `${id.slice(0, 6)}...${id.slice(-4)}`;
+}
+function accountTitle(account) {
+  return account.email || account.accountId || account.id;
+}
+function accountDescription(account, current) {
+  return short(account.accountId);
+}
+function accountFooter(current) {
+  return current ? "Current" : undefined;
+}
+function loginTitle() {
+  return "login";
+}
+function logoutTitle(has) {
+  return has ? "logout" : "logout unavailable";
+}
+
+// src/login.tsx
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { effect as _$effect } from "@opentui/solid";
+import { createTextNode as _$createTextNode } from "@opentui/solid";
+import { insertNode as _$insertNode } from "@opentui/solid";
+import { insert as _$insert } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+import { TextAttributes } from "@opentui/core";
+import { useKeyboard } from "@opentui/solid";
+
+// src/login-helpers.ts
+async function clip(text) {
+  let copied = false;
+  if (process.stdout.isTTY) {
+    const base64 = Buffer.from(text).toString("base64");
+    const osc52 = `\x1B]52;c;${base64}\x07`;
+    const seq = process.env.TMUX || process.env.STY ? `\x1BPtmux;\x1B${osc52}\x1B\\` : osc52;
+    process.stdout.write(seq);
+    copied = true;
+  }
+  const cmds = process.platform === "darwin" ? [["pbcopy"]] : process.platform === "win32" ? [["clip"]] : [["wl-copy"], ["xclip", "-selection", "clipboard"], ["xsel", "--clipboard", "--input"]];
+  try {
+    await Promise.any(cmds.map(async (cmd) => {
+      const proc = Bun.spawn({
+        cmd,
+        stdin: "pipe",
+        stdout: "ignore",
+        stderr: "ignore"
+      });
+      await proc.stdin.write(new TextEncoder().encode(text));
+      proc.stdin.end();
+      const code = await proc.exited;
+      if (code !== 0)
+        throw new Error("copy failed");
+    }));
+    return true;
+  } catch {
+    return copied;
+  }
+}
+function target(authz) {
+  return authz.instructions.match(/[A-Z0-9]{4}-[A-Z0-9]{4,5}/)?.[0] ?? authz.url;
+}
+async function runOAuthCallback(callback, input) {
+  try {
+    const res = await callback(input);
+    return !res.error;
+  } catch {
+    return false;
+  }
+}
+
+// src/store.ts
+import fs from "fs/promises";
+import path2 from "path";
+
+// src/paths.ts
+import os from "os";
+import path from "path";
+function dataPath() {
+  if (process.env.OPENCODE_TEST_HOME) {
+    return path.join(process.env.OPENCODE_TEST_HOME, ".local", "share", "opencode");
+  }
+  if (process.env.XDG_DATA_HOME)
+    return path.join(process.env.XDG_DATA_HOME, "opencode");
+  if (process.platform === "darwin")
+    return path.join(os.homedir(), "Library", "Application Support", "opencode");
+  if (process.platform === "win32") {
+    const root = process.env.LOCALAPPDATA || process.env.APPDATA;
+    if (root)
+      return path.join(root, "opencode");
+  }
+  return path.join(os.homedir(), ".local", "share", "opencode");
+}
+function authPath() {
+  return path.join(dataPath(), "auth.json");
+}
+function storeDir() {
+  return path.join(dataPath(), "auth-switch");
+}
+function storePath() {
+  return path.join(storeDir(), "accounts.json");
+}
+
+// src/parse.ts
+import { createHash } from "crypto";
+function text(v) {
+  return typeof v === "string" && v.trim() ? v : undefined;
+}
+function obj(v) {
+  return v && typeof v === "object" ? v : undefined;
+}
+function parseJwtClaims(token) {
+  const part = token.split(".")[1];
+  if (!part)
+    return {};
+  try {
+    return JSON.parse(Buffer.from(part, "base64url").toString("utf8"));
+  } catch {
+    return {};
+  }
+}
+function extractEmail(auth) {
+  const claims = parseJwtClaims(auth.access);
+  const direct = text(claims["https://api.openai.com/profile.email"]);
+  if (direct)
+    return direct;
+  return text(obj(claims["https://api.openai.com/profile"])?.email);
+}
+function extractPlan(auth) {
+  return text(parseJwtClaims(auth.access)["https://api.openai.com/auth.chatgpt_plan_type"]);
+}
+function extractAccountId(auth) {
+  if (text(auth.accountId))
+    return text(auth.accountId);
+  const claims = parseJwtClaims(auth.access);
+  const direct = text(claims.chatgpt_account_id);
+  if (direct)
+    return direct;
+  const namespaced = text(claims["https://api.openai.com/auth.chatgpt_account_id"]);
+  if (namespaced)
+    return namespaced;
+  const orgs = claims.organizations;
+  if (!Array.isArray(orgs) || !orgs.length)
+    return;
+  return text(obj(orgs[0])?.id);
+}
+function fallback(refresh) {
+  return `fallback:${createHash("sha256").update(refresh).digest("hex").slice(0, 16)}`;
+}
+function key(auth) {
+  return fallback(auth.refresh);
+}
+function entryFromAuth(auth, now = Date.now()) {
+  return {
+    key: key(auth),
+    email: extractEmail(auth),
+    accountId: extractAccountId(auth),
+    plan: extractPlan(auth),
+    savedAt: now,
+    auth: clean(auth)
+  };
+}
+function clean(auth) {
+  return {
+    type: "oauth",
+    refresh: auth.refresh,
+    access: auth.access,
+    expires: auth.expires,
+    ...text(auth.accountId) ? { accountId: auth.accountId } : {},
+    ...text(auth.enterpriseUrl) ? { enterpriseUrl: auth.enterpriseUrl } : {}
+  };
+}
+
+// src/store.ts
+function obj2(v) {
+  return v && typeof v === "object" ? v : undefined;
+}
+function text2(v) {
+  return typeof v === "string" && v.trim() ? v : undefined;
+}
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : undefined;
+}
+function validAuth(v) {
+  const item = obj2(v);
+  if (!item)
+    return false;
+  if (item.type !== "oauth")
+    return false;
+  if (!text2(item.refresh) || !text2(item.access) || num(item.expires) === undefined)
+    return false;
+  if (item.accountId !== undefined && !text2(item.accountId))
+    return false;
+  if (item.enterpriseUrl !== undefined && !text2(item.enterpriseUrl))
+    return false;
+  return true;
+}
+function validEntry(id, v) {
+  const item = obj2(v);
+  if (!item || item.key !== id)
+    return false;
+  if (item.email !== undefined && !text2(item.email))
+    return false;
+  if (item.accountId !== undefined && !text2(item.accountId))
+    return false;
+  if (item.plan !== undefined && !text2(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) {
+  const data = Bun.file(file);
+  if (!await data.exists())
+    return;
+  const raw = (await data.text()).trim();
+  if (!raw)
+    return;
+  return JSON.parse(raw);
+}
+async function writeJson(file, value) {
+  await fs.mkdir(storeDir(), { recursive: true });
+  await Bun.write(file, `${JSON.stringify(value, null, 2)}
+`);
+}
+function hydrateAccount(id, item) {
+  return {
+    ...item,
+    id,
+    email: item.email || extractEmail(item.auth),
+    accountId: item.accountId || extractAccountId(item.auth)
+  };
+}
+function normalizeEntries(entries) {
+  const normalized = {};
+  let changed = false;
+  for (const [id, value] of Object.entries(entries)) {
+    if (!validEntry(id, value)) {
+      const item = obj2(value);
+      if (!item || !validAuth(item.auth)) {
+        changed = true;
+        continue;
+      }
+      const auth = clean(item.auth);
+      const nextKey2 = fallback(auth.refresh);
+      normalized[nextKey2] = {
+        key: nextKey2,
+        email: text2(item.email) || extractEmail(auth),
+        accountId: text2(item.accountId) || extractAccountId(auth),
+        plan: text2(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 };
+}
+async function readCurrentAuth() {
+  const raw = await readJson(authPath());
+  const data = obj2(raw);
+  if (!data)
+    return;
+  const auth = data.openai;
+  if (!validAuth(auth))
+    return;
+  return clean(auth);
+}
+async function writeCurrentOpenAI(auth) {
+  const raw = await readJson(authPath()) ?? {};
+  const next = obj2(raw) ?? {};
+  next.openai = clean(auth);
+  await fs.mkdir(path2.dirname(authPath()), { recursive: true });
+  await Bun.write(authPath(), `${JSON.stringify(next, null, 2)}
+`);
+}
+async function readStore() {
+  let raw;
+  try {
+    raw = await readJson(storePath());
+  } catch {
+    return { ok: false, reason: "malformed" };
+  }
+  if (raw === undefined)
+    return { ok: false, reason: "missing" };
+  const root = obj2(raw);
+  const map = obj2(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
+    }
+  };
+}
+async function writeStore(store) {
+  await writeJson(storePath(), store);
+}
+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,
+    accounts: Object.entries(next).map(([id, item]) => hydrateAccount(id, item))
+  };
+}
+function match(list, auth) {
+  return list.find((item) => {
+    if (item.auth.refresh === auth.refresh)
+      return true;
+    return item.id === fallback(auth.refresh);
+  })?.id;
+}
+async function upsertSavedAccount(auth) {
+  const base = entryFromAuth(auth);
+  const load = await readStore();
+  if (!load.ok && load.reason === "malformed") {
+    throw new Error("account store malformed");
+  }
+  const store = load.ok ? load.store : { version: 1, openai: {} };
+  const list = Object.entries(store.openai);
+  const match2 = list.find(([id, item]) => {
+    if (!validEntry(id, item))
+      return false;
+    return item.auth.refresh === auth.refresh || id === base.key;
+  });
+  const prev = match2?.[1];
+  const next = {
+    ...base,
+    savedAt: prev?.savedAt ?? base.savedAt,
+    lastUsedAt: prev?.lastUsedAt
+  };
+  const out = Object.fromEntries(list.filter(([id]) => id !== match2?.[0]).filter(([id, item]) => validEntry(id, item)));
+  out[next.key] = next;
+  await writeStore({ version: 1, openai: out });
+  return { ...next, id: next.key };
+}
+function sort(list, cur) {
+  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);
+  });
+}
+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, accounts: sort(load.accounts, cur), current: cur };
+}
+async function switchAccount(id) {
+  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()
+      }
+    }
+  });
+}
+async function deleteSavedAccount(id) {
+  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 });
+}
+
+// src/login.tsx
+function visible(prompt, values) {
+  if (!prompt.when)
+    return true;
+  const cur = values[prompt.when.key];
+  if (prompt.when.op === "eq")
+    return cur === prompt.when.value;
+  return cur !== prompt.when.value;
+}
+function same(prev, next) {
+  if (!prev || !next)
+    return false;
+  return prev.refresh === next.refresh;
+}
+function bind(api, authz) {
+  useKeyboard((evt) => {
+    if (evt.name !== "c" || evt.ctrl || evt.meta)
+      return;
+    evt.preventDefault();
+    evt.stopPropagation();
+    clip(target(authz)).then((ok) => api.ui.toast({
+      variant: ok ? "info" : "warning",
+      message: ok ? "Copied to clipboard" : "Failed to copy to clipboard"
+    }));
+  });
+}
+function WaitView(props) {
+  bind(props.api, props.authz);
+  return (() => {
+    var _el$ = _$createElement("box"), _el$2 = _$createElement("text"), _el$3 = _$createElement("text"), _el$4 = _$createElement("text"), _el$5 = _$createElement("text"), _el$7 = _$createElement("text");
+    _$insertNode(_el$, _el$2);
+    _$insertNode(_el$, _el$3);
+    _$insertNode(_el$, _el$4);
+    _$insertNode(_el$, _el$5);
+    _$insertNode(_el$, _el$7);
+    _$setProp(_el$, "paddingLeft", 2);
+    _$setProp(_el$, "paddingRight", 2);
+    _$setProp(_el$, "gap", 1);
+    _$setProp(_el$, "paddingBottom", 1);
+    _$insert(_el$2, () => props.title);
+    _$insert(_el$3, () => props.authz.instructions);
+    _$insert(_el$4, () => props.authz.url);
+    _$insertNode(_el$5, _$createTextNode(`Waiting for authorization...`));
+    _$insertNode(_el$7, _$createTextNode(`Press c to copy the link`));
+    _$effect((_$p) => _$setProp(_el$2, "attributes", TextAttributes.BOLD, _$p));
+    return _el$;
+  })();
+}
+function CodePrompt(props) {
+  bind(props.api, props.authz);
+  return _$createComponent(props.api.ui.DialogPrompt, {
+    get title() {
+      return props.title;
+    },
+    placeholder: "Authorization code",
+    get onConfirm() {
+      return props.onConfirm;
+    },
+    get onCancel() {
+      return props.onCancel;
+    },
+    description: () => (() => {
+      var _el$9 = _$createElement("box"), _el$0 = _$createElement("text"), _el$1 = _$createElement("text"), _el$10 = _$createElement("text");
+      _$insertNode(_el$9, _el$0);
+      _$insertNode(_el$9, _el$1);
+      _$insertNode(_el$9, _el$10);
+      _$setProp(_el$9, "gap", 1);
+      _$insert(_el$0, () => props.authz.instructions);
+      _$insert(_el$1, () => props.authz.url);
+      _$insertNode(_el$10, _$createTextNode(`Press c to copy the code`));
+      return _el$9;
+    })()
+  });
+}
+function wait(api, title, authz, run) {
+  api.ui.dialog.replace(() => _$createComponent(WaitView, {
+    api,
+    title,
+    authz
+  }));
+  run();
+}
+async function choose(api, methods) {
+  if (methods.length === 1)
+    return 0;
+  return await new Promise((resolve) => {
+    api.ui.dialog.replace(() => _$createComponent(api.ui.DialogSelect, {
+      title: "Select auth method",
+      get options() {
+        return methods.map((item, index) => ({
+          title: item.method.label,
+          value: index
+        }));
+      },
+      onSelect: (item) => resolve(item.value)
+    }), () => resolve(null));
+  });
+}
+async function ask(api, title, prompt) {
+  if (prompt.type === "text") {
+    return await new Promise((resolve) => {
+      api.ui.dialog.replace(() => (() => {
+        var _el$12 = _$createElement("box");
+        _$setProp(_el$12, "paddingLeft", 2);
+        _$setProp(_el$12, "paddingRight", 2);
+        _$setProp(_el$12, "paddingTop", 2);
+        _$setProp(_el$12, "paddingBottom", 2);
+        _$insert(_el$12, _$createComponent(api.ui.DialogPrompt, {
+          title,
+          get placeholder() {
+            return prompt.placeholder;
+          },
+          onConfirm: (value) => resolve(value),
+          onCancel: () => resolve(null),
+          description: () => (() => {
+            var _el$13 = _$createElement("text");
+            _$insert(_el$13, () => prompt.message);
+            return _el$13;
+          })()
+        }));
+        return _el$12;
+      })(), () => resolve(null));
+    });
+  }
+  return await new Promise((resolve) => {
+    api.ui.dialog.replace(() => (() => {
+      var _el$14 = _$createElement("box");
+      _$setProp(_el$14, "paddingLeft", 2);
+      _$setProp(_el$14, "paddingRight", 2);
+      _$setProp(_el$14, "paddingTop", 2);
+      _$setProp(_el$14, "paddingBottom", 2);
+      _$insert(_el$14, _$createComponent(api.ui.DialogSelect, {
+        get title() {
+          return prompt.message;
+        },
+        get options() {
+          return (prompt.options ?? []).map((item) => ({
+            title: item.label,
+            value: item.value,
+            description: item.hint
+          }));
+        },
+        onSelect: (item) => resolve(item.value)
+      }));
+      return _el$14;
+    })(), () => resolve(null));
+  });
+}
+async function prompts(api, title, method) {
+  const values = {};
+  for (const prompt of method.prompts ?? []) {
+    if (!visible(prompt, values))
+      continue;
+    const value = await ask(api, title, prompt);
+    if (value == null)
+      return;
+    values[prompt.key] = value;
+  }
+  return values;
+}
+async function save(api, prev) {
+  let activeUpdated = false;
+  try {
+    const client = api.client;
+    if (typeof api.client.instance.dispose === "function") {
+      await api.client.instance.dispose();
+    }
+    if (typeof client.sync?.bootstrap === "function") {
+      await client.sync.bootstrap();
+    }
+    const auth = await readCurrentAuth();
+    if (!auth) {
+      api.ui.toast({
+        variant: "error",
+        message: "Login completed, but saved account could not be loaded"
+      });
+      return false;
+    }
+    activeUpdated = true;
+    if (same(prev, auth)) {
+      api.ui.toast({
+        variant: "warning",
+        message: "Login completed, but OpenAI account did not change"
+      });
+      return false;
+    }
+    await upsertSavedAccount(auth);
+    return true;
+  } catch {
+    api.ui.toast({
+      variant: "error",
+      message: activeUpdated ? "Login completed, but saving the account failed" : "Login completed, but account sync failed"
+    });
+    return false;
+  }
+}
+async function code(api, index, method, authz) {
+  const prev = await readCurrentAuth();
+  const ok = await new Promise((resolve) => {
+    api.ui.dialog.replace(() => _$createComponent(CodePrompt, {
+      api,
+      get title() {
+        return method.label;
+      },
+      authz,
+      onConfirm: async (value) => {
+        resolve(await runOAuthCallback(api.client.provider.oauth.callback, {
+          providerID: "openai",
+          method: index,
+          code: value
+        }));
+      },
+      onCancel: () => resolve(false)
+    }), () => resolve(false));
+  });
+  if (!ok) {
+    api.ui.toast({
+      variant: "error",
+      message: "Login failed"
+    });
+    return false;
+  }
+  return save(api, prev);
+}
+async function auto(api, index, method, authz) {
+  const prev = await readCurrentAuth();
+  const ok = await new Promise((resolve) => {
+    wait(api, method.label, authz, async () => {
+      resolve(await runOAuthCallback(api.client.provider.oauth.callback, {
+        providerID: "openai",
+        method: index
+      }));
+    });
+  });
+  if (!ok) {
+    api.ui.toast({
+      variant: "error",
+      message: "Login failed"
+    });
+    return false;
+  }
+  return save(api, prev);
+}
+async function hasLogin(api) {
+  try {
+    const res = await api.client.provider.auth();
+    const methods = res.data?.openai ?? [];
+    return methods.some((item) => item.type === "oauth");
+  } catch {
+    return false;
+  }
+}
+async function loginOpenAI(api) {
+  try {
+    const auth = await api.client.provider.auth();
+    const methods = (auth.data?.openai ?? []).map((method2, index2) => ({
+      method: method2,
+      index: index2
+    })).filter((item) => item.method.type === "oauth");
+    if (!methods.length) {
+      api.ui.toast({
+        variant: "error",
+        message: "OpenAI OAuth login unavailable"
+      });
+      return false;
+    }
+    const index = await choose(api, methods);
+    if (index == null)
+      return false;
+    const picked = methods[index];
+    const method = picked.method;
+    const inputs = await prompts(api, method.label, method);
+    if (method.prompts?.length && !inputs)
+      return false;
+    const authz = await api.client.provider.oauth.authorize({
+      providerID: "openai",
+      method: picked.index,
+      inputs
+    });
+    if (authz.error || !authz.data) {
+      api.ui.toast({
+        variant: "error",
+        message: "Login failed"
+      });
+      return false;
+    }
+    if (authz.data.method === "code")
+      return code(api, picked.index, method, authz.data);
+    if (authz.data.method === "auto")
+      return auto(api, picked.index, method, authz.data);
+    api.ui.toast({
+      variant: "error",
+      message: "Unsupported auth method"
+    });
+    return false;
+  } catch {
+    api.ui.toast({
+      variant: "error",
+      message: "Login failed"
+    });
+    return false;
+  }
+}
+
+// src/tui.tsx
+var seq = 0;
+function frame(text3) {
+  return (() => {
+    var _el$ = _$createElement2("box"), _el$2 = _$createElement2("text");
+    _$insertNode2(_el$, _el$2);
+    _$setProp2(_el$, "paddingLeft", 2);
+    _$setProp2(_el$, "paddingRight", 2);
+    _$setProp2(_el$, "paddingTop", 2);
+    _$setProp2(_el$, "paddingBottom", 2);
+    _$insert2(_el$2, text3);
+    return _el$;
+  })();
+}
+async function pick(api, list) {
+  return await new Promise((resolve) => {
+    api.ui.dialog.replace(() => _$createComponent2(api.ui.DialogSelect, {
+      title: "Remove saved account",
+      get options() {
+        return list.map((item) => ({
+          title: accountTitle(item),
+          value: item.id,
+          category: accountDescription(item, false)
+        }));
+      },
+      onSelect: (item) => resolve(item.value)
+    }), () => resolve(null));
+  });
+}
+async function confirm(api, title, message) {
+  return await new Promise((resolve) => {
+    api.ui.dialog.replace(() => _$createComponent2(api.ui.DialogConfirm, {
+      title,
+      message,
+      onConfirm: () => resolve(true),
+      onCancel: () => resolve(false)
+    }), () => resolve(false));
+  });
+}
+async function remove(api, list) {
+  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, current, canLogin) {
+  const rows = list.map((item) => ({
+    title: accountTitle(item),
+    value: {
+      type: "account",
+      id: item.id
+    },
+    description: accountDescription(item, item.id === current),
+    footer: accountFooter(item.id === current),
+    category: "Accounts"
+  }));
+  return [...canLogin ? [{
+    title: loginTitle(),
+    value: {
+      type: "login"
+    }
+  }] : [], ...rows, ...list.length ? [{
+    title: logoutTitle(true),
+    value: {
+      type: "logout"
+    },
+    description: "Remove a saved account",
+    category: "Actions"
+  }] : []];
+}
+async function open(api) {
+  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(() => _$createComponent2(api.ui.DialogSelect, {
+      title: "Switch OpenAI account",
+      options: rows,
+      placeholder: "Search",
+      onSelect: (item) => void act(api, item.value, accounts)
+    }));
+    return;
+  }
+  api.ui.dialog.replace(() => _$createComponent2(api.ui.DialogSelect, {
+    title: "Switch OpenAI account",
+    options: rows,
+    placeholder: "Search",
+    current: current ? {
+      type: "account",
+      id: current
+    } : undefined,
+    onSelect: (item) => void act(api, item.value, accounts)
+  }));
+}
+async function act(api, action, list) {
+  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;
+    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. Restart OpenCode to apply it."
+    });
+  }
+}
+var tui = async (api) => {
+  api.command.register(() => [{
+    title: "Switch OpenAI account",
+    value: "openai.switch",
+    description: "Login, switch, or remove saved OpenAI accounts",
+    slash: {
+      name: "switch"
+    },
+    onSelect: () => {
+      open(api);
+    }
+  }]);
+};
+var tui_default = {
+  id: "harars.switch-auth",
+  tui
+};
+export {
+  tui_default as default
+};