opencode-copilot-account-switcher 0.14.26 → 0.14.28

package/dist/plugin.js

@@ -10,6 +10,7 @@ import { brokerStartupDiagnosticsPath, ensureWechatStateLayout } from "./wechat/
 import { createCodexMenuAdapter } from "./providers/codex-menu-adapter.js";
 import { createCopilotMenuAdapter } from "./providers/copilot-menu-adapter.js";
 import { createProviderRegistry } from "./providers/registry.js";
+import { loadOfficialCodexAuthMethods } from "./upstream/codex-loader-adapter.js";
 import { isTTY } from "./ui/ansi.js";
 import { showMenu } from "./ui/menu.js";
 import { select, selectMany } from "./ui/select.js";
@@ -73,6 +74,14 @@ function toSharedRuntimeAction(action) {
         return { type: "provider", name: "toggle-experimental-slash-commands" };
     if (action.type === "toggle-network-retry")
         return { type: "provider", name: "toggle-network-retry" };
+    if (action.type === "toggle-wechat-notifications")
+        return { type: "provider", name: "toggle-wechat-notifications" };
+    if (action.type === "toggle-wechat-question-notify")
+        return { type: "provider", name: "toggle-wechat-question-notify" };
+    if (action.type === "toggle-wechat-permission-notify")
+        return { type: "provider", name: "toggle-wechat-permission-notify" };
+    if (action.type === "toggle-wechat-session-error-notify")
+        return { type: "provider", name: "toggle-wechat-session-error-notify" };
     if (action.type === "wechat-bind")
         return { type: "provider", name: "wechat-bind" };
     if (action.type === "wechat-rebind")
@@ -386,6 +395,13 @@ async function createAccountSwitcherPlugin(input, provider) {
         }
         const adapter = createCodexMenuAdapter({
             client: codexClient,
+            loadOfficialCodexAuthMethods: () => loadOfficialCodexAuthMethods({
+                client: {
+                    auth: {
+                        set: async (value) => client.auth.set(value),
+                    },
+                },
+            }),
             readCommonSettings: readCommonSettingsStore,
             writeCommonSettings: async (settings) => {
                 await writeCommonSettingsStore(settings);

package/dist/providers/codex-menu-adapter.d.ts

@@ -1,5 +1,5 @@
 import { type CodexStatusFetcherResult } from "../codex-status-fetcher.js";
-import { type CodexOAuthAccount } from "../codex-oauth.js";
+import { type OfficialCodexAuthMethod } from "../upstream/codex-loader-adapter.js";
 import { type CodexAccountEntry, type CodexStoreFile } from "../codex-store.js";
 import type { ProviderMenuAdapter } from "../menu-runtime.js";
 import { type AccountEntry } from "../store.js";
@@ -42,7 +42,7 @@ type AdapterDependencies = {
         };
         accountId?: string;
     }) => Promise<CodexStatusFetcherResult>;
-    runCodexOAuth?: () => Promise<CodexOAuthAccount | undefined>;
+    loadOfficialCodexAuthMethods?: () => Promise<OfficialCodexAuthMethod[]>;
     readCommonSettings?: () => Promise<CommonSettingsStore>;
     writeCommonSettings?: (settings: CommonSettingsStore, meta?: WriteMeta) => Promise<void>;
 };

package/dist/providers/codex-menu-adapter.js

@@ -1,13 +1,34 @@
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { fetchCodexStatus } from "../codex-status-fetcher.js";
-import { runCodexOAuth } from "../codex-oauth.js";
+import { loadOfficialCodexAuthMethods, } from "../upstream/codex-loader-adapter.js";
 import { getActiveCodexAccount, readCodexStore, writeCodexStore, } from "../codex-store.js";
 import { recoverInvalidCodexAccount } from "../codex-invalid-account.js";
 import { readAuth } from "../store.js";
 import { readCommonSettingsStore, writeCommonSettingsStore, } from "../common-settings-store.js";
 import { applyCommonSettingsAction } from "../common-settings-actions.js";
-import { runWechatBindFlow } from "../wechat/bind-flow.js";
+function pickOfficialOauthMethodByKind(methods, kind) {
+    return methods.find((method) => {
+        if (method.type !== "oauth")
+            return false;
+        if (typeof method.authorize !== "function")
+            return false;
+        const label = method.label.toLowerCase();
+        if (kind === "browser")
+            return label.includes("browser");
+        return label.includes("headless") || label.includes("device");
+    });
+}
+function parseOfficialOauthSelection(raw) {
+    const value = raw.trim().toLowerCase();
+    if (!value)
+        return "cancel";
+    if (value === "1" || value === "browser" || value === "b")
+        return "browser";
+    if (value === "2" || value === "headless" || value === "h" || value === "device")
+        return "headless";
+    return undefined;
+}
 function pickName(input) {
     const accountId = input.accountId?.trim();
     if (accountId)
@@ -74,7 +95,14 @@ export function createCodexMenuAdapter(inputDeps) {
     });
     const loadAuth = inputDeps.readAuthEntries ?? readAuth;
     const fetchStatus = inputDeps.fetchStatus ?? ((input) => fetchCodexStatus(input));
-    const authorizeOpenAIOAuth = inputDeps.runCodexOAuth ?? runCodexOAuth;
+    const loadOfficialMethods = inputDeps.loadOfficialCodexAuthMethods
+        ?? (() => loadOfficialCodexAuthMethods({
+            client: {
+                auth: {
+                    set: async (value) => inputDeps.client.auth.set(value),
+                },
+            },
+        }));
     const readCommonSettings = inputDeps.readCommonSettings ?? readCommonSettingsStore;
     const writeCommonSettings = async (settings, meta) => {
         if (inputDeps.writeCommonSettings) {
@@ -244,34 +272,46 @@ export function createCodexMenuAdapter(inputDeps) {
             return true;
         },
         authorizeNewAccount: async () => {
-            const oauth = await authorizeOpenAIOAuth();
-            if (!oauth || (!oauth.refresh && !oauth.access))
+            const methods = await loadOfficialMethods();
+            const browserMethod = pickOfficialOauthMethodByKind(methods, "browser");
+            const headlessMethod = pickOfficialOauthMethodByKind(methods, "headless");
+            const selectedKey = parseOfficialOauthSelection(await prompt("Choose Codex auth method (1/browser/b, 2/headless/h/device, Enter to cancel): "));
+            if (selectedKey === "cancel" || !selectedKey)
+                return undefined;
+            const selectedMethod = selectedKey === "browser" ? browserMethod : headlessMethod;
+            if (!selectedMethod || typeof selectedMethod.authorize !== "function")
+                return undefined;
+            const pending = await selectedMethod.authorize();
+            if (pending.method && pending.method !== "auto") {
+                throw new Error(`Unsupported official Codex auth method: ${pending.method}`);
+            }
+            if (typeof pending.callback !== "function")
+                return undefined;
+            const result = await pending.callback();
+            if (result.type !== "success" || (!result.refresh && !result.access))
                 return undefined;
-            const refresh = oauth.refresh ?? oauth.access;
-            const access = oauth.access ?? oauth.refresh;
+            const refresh = result.refresh ?? result.access;
+            const access = result.access ?? result.refresh;
             await inputDeps.client.auth.set({
                 path: { id: "openai" },
                 body: {
                     type: "oauth",
                     refresh,
                     access,
-                    expires: oauth.expires,
-                    accountId: oauth.accountId,
+                    expires: result.expires,
+                    accountId: result.accountId,
                 },
             });
             return {
                 name: pickName({
-                    accountId: oauth.accountId,
-                    email: oauth.email,
+                    accountId: result.accountId,
                     fallback: `openai-${now()}`,
                 }),
                 providerId: "openai",
-                workspaceName: oauth.workspaceName,
                 refresh,
                 access,
-                expires: oauth.expires,
-                accountId: oauth.accountId,
-                email: oauth.email,
+                expires: result.expires,
+                accountId: result.accountId,
                 source: "manual",
                 addedAt: now(),
             };
@@ -384,6 +424,7 @@ export function createCodexMenuAdapter(inputDeps) {
                 return false;
             }
             if (action.name === "wechat-bind" || action.name === "wechat-rebind") {
+                const { runWechatBindFlow } = await import("../wechat/bind-flow.js");
                 await runWechatBindFlow({
                     action: action.name,
                     readCommonSettings,

package/dist/providers/copilot-menu-adapter.js

@@ -5,7 +5,6 @@ import { getGitHubToken, normalizeDomain } from "../copilot-api-helpers.js";
 import { listAssignableAccountsForModel, listKnownCopilotModels, rewriteModelAccountAssignments, } from "../model-account-map.js";
 import { applyMenuAction, persistAccountSwitch } from "../plugin-actions.js";
 import { readCommonSettingsStore, writeCommonSettingsStore, } from "../common-settings-store.js";
-import { runWechatBindFlow } from "../wechat/bind-flow.js";
 import { select, selectMany } from "../ui/select.js";
 import { authPath, readAuth, readStore } from "../store.js";
 const CLIENT_ID = "Ov23li8tweQw6odWQebz";
@@ -742,6 +741,7 @@ export function createCopilotMenuAdapter(inputDeps) {
                 return false;
             }
             if (action.name === "wechat-bind" || action.name === "wechat-rebind") {
+                const { runWechatBindFlow } = await import("../wechat/bind-flow.js");
                 await runWechatBindFlow({
                     action: action.name,
                     readCommonSettings,

package/dist/upstream/codex-loader-adapter.d.ts

@@ -36,6 +36,35 @@ export type OfficialCodexChatHeadersHook = (input: {
 }, output: {
     headers: Record<string, string>;
 }) => Promise<void>;
+type OfficialCodexAuthResult = {
+    type: "success";
+    refresh: string;
+    access: string;
+    expires: number;
+    accountId?: string;
+} | {
+    type: "failed";
+};
+type OfficialCodexAuthorizePending = {
+    url: string;
+    instructions?: string;
+    method?: string;
+    callback?: () => Promise<OfficialCodexAuthResult>;
+};
+export type OfficialCodexAuthMethod = {
+    label: string;
+    type: string;
+    authorize?: () => Promise<OfficialCodexAuthorizePending>;
+};
+export declare function loadOfficialCodexAuthMethods(input?: {
+    client?: {
+        auth?: {
+            set?: (value: unknown) => Promise<unknown>;
+        };
+    };
+    baseFetch?: typeof fetch;
+    version?: string;
+}): Promise<OfficialCodexAuthMethod[]>;
 export declare function loadOfficialCodexConfig(input: {
     getAuth: () => Promise<CodexAuthState | undefined>;
     provider?: CodexProviderConfig;
@@ -67,3 +96,4 @@ export declare function loadOfficialCodexChatHeaders(input?: {
     baseFetch?: typeof fetch;
     version?: string;
 }): Promise<OfficialCodexChatHeadersHook>;
+export {};

package/dist/upstream/codex-loader-adapter.js

@@ -13,6 +13,31 @@ async function loadOfficialHooks(input) {
         return hooks;
     });
 }
+export async function loadOfficialCodexAuthMethods(input = {}) {
+    const hooks = await loadOfficialHooks(input);
+    const methods = hooks.auth?.methods;
+    if (!Array.isArray(methods)) {
+        return [];
+    }
+    return methods.map((method) => {
+        if (typeof method.authorize !== "function") {
+            return method;
+        }
+        return {
+            ...method,
+            authorize: async () => {
+                const pending = await runWithOfficialBridge(input, () => method.authorize());
+                if (!pending || typeof pending.callback !== "function") {
+                    return pending;
+                }
+                return {
+                    ...pending,
+                    callback: () => runWithOfficialBridge(input, () => pending.callback()),
+                };
+            },
+        };
+    });
+}
 export async function loadOfficialCodexConfig(input) {
     const hooks = await loadOfficialHooks({
         client: input.client,

package/dist/upstream/codex-plugin.snapshot.d.ts

@@ -9,5 +9,24 @@ declare const officialCodexExportBridge: {
         version?: string;
     } | undefined, fn: () => Promise<any>): Promise<any>;
 };
+export interface IdTokenClaims {
+    chatgpt_account_id?: string;
+    organizations?: Array<{
+        id: string;
+    }>;
+    email?: string;
+    "https://api.openai.com/auth"?: {
+        chatgpt_account_id?: string;
+    };
+}
+export declare function parseJwtClaims(token: string): IdTokenClaims | undefined;
+export declare function extractAccountIdFromClaims(claims: IdTokenClaims): string | undefined;
+export declare function extractAccountId(tokens: TokenResponse): string | undefined;
+interface TokenResponse {
+    id_token: string;
+    access_token: string;
+    refresh_token: string;
+    expires_in?: number;
+}
 export declare function CodexAuthPlugin(input: PluginInput): Promise<Hooks>;
 export { officialCodexExportBridge };