opencode-codex-multi-account 0.1.1 → 0.2.0

package/README.md

@@ -26,8 +26,6 @@ Add to `opencode.json`:
 opencode-codex-multi-account  ← you are here
         │
 opencode-multi-account-core
-        │
-opencode-oauth-adapters
 ```
 
 See the [root README](../../README.md) for full documentation.

package/dist/account-manager.d.ts

@@ -0,0 +1,2 @@
+export declare const AccountManager: import("opencode-multi-account-core").AccountManagerClass;
+export type AccountManager = InstanceType<typeof AccountManager>;

package/dist/account-store.d.ts

@@ -0,0 +1,2 @@
+import { AccountStore, type DiskCredentials } from "opencode-multi-account-core";
+export { AccountStore, type DiskCredentials, };

package/dist/auth-handler.d.ts

@@ -0,0 +1,20 @@
+import { AccountManager } from "./account-manager";
+import type { PluginClient } from "./types";
+type OAuthCallbackResponse = ({
+    type: "success";
+} & {
+    refresh: string;
+    access: string;
+    expires: number;
+    accountId?: string;
+}) | {
+    type: "failed";
+};
+export interface OAuthFlowResult {
+    url: string;
+    instructions: string;
+    method: "auto";
+    callback(): Promise<OAuthCallbackResponse>;
+}
+export declare function handleAuthorize(manager: AccountManager | null, inputs?: Record<string, string>, client?: PluginClient): Promise<OAuthFlowResult>;
+export {};

package/dist/claims.d.ts

@@ -0,0 +1 @@
+export { isClaimedByOther, readClaims, releaseClaim, writeClaim, type ClaimsMap, } from "opencode-multi-account-core";

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+import { getConfig, loadConfig, resetConfigCache, updateConfigField } from "opencode-multi-account-core";
+export { getConfig, loadConfig, resetConfigCache, updateConfigField, };

package/dist/constants.d.ts

@@ -0,0 +1,32 @@
+/** OpenAI OAuth adapter config */
+export declare const OPENAI_OAUTH_ADAPTER: import("opencode-multi-account-core").OAuthAdapter;
+/** OpenAI OAuth Client ID */
+export declare const OPENAI_CLIENT_ID: string;
+/** Token exchange / refresh endpoint */
+export declare const OPENAI_TOKEN_ENDPOINT: string;
+/** OAuth usage stats endpoint */
+export declare const OPENAI_USAGE_ENDPOINT: string;
+/** OAuth profile endpoint */
+export declare const OPENAI_PROFILE_ENDPOINT: string;
+/** Codex upstream endpoint used by OpenCode */
+export declare const CODEX_API_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
+/** Codex usage/quota endpoint (WHAM API) */
+export declare const CODEX_USAGE_ENDPOINT = "https://chatgpt.com/backend-api/wham/usage";
+/** OpenAI OAuth issuer */
+export declare const OAUTH_ISSUER = "https://auth.openai.com";
+/** Local callback port for browser OAuth */
+export declare const OAUTH_PORT = 1455;
+/** Required beta header for OAuth requests */
+export declare const OPENAI_BETA_HEADER: string;
+/** User-Agent header */
+export declare const OPENAI_CLI_USER_AGENT: string;
+/** Tool name prefix */
+export declare const TOOL_PREFIX: string;
+/** Account storage filename */
+export declare const ACCOUNTS_FILENAME: string;
+/** Plan display labels derived from adapter */
+export declare const PLAN_LABELS: import("opencode-multi-account-core").OAuthAdapterPlanLabels;
+/** Access token expiry buffer (refresh 60s before expiry) */
+export declare const TOKEN_EXPIRY_BUFFER_MS = 60000;
+/** Maximum time to wait for a token refresh HTTP request */
+export declare const TOKEN_REFRESH_TIMEOUT_MS = 30000;

package/dist/executor.d.ts

@@ -0,0 +1,2 @@
+declare const executeWithAccountRotation: (manager: import("opencode-multi-account-core").ExecutorAccountManager, runtimeFactory: import("opencode-multi-account-core").ExecutorRuntimeFactory, client: import("opencode-multi-account-core").PluginClient, input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export { executeWithAccountRotation };

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+import { OPENAI_OAUTH_ADAPTER } from "./constants";
+export declare const CodexMultiAuthPlugin: (ctx: unknown) => Promise<{
+    tool: {
+        [OPENAI_OAUTH_ADAPTER.statusToolName]: {
+            description: string;
+            args: {};
+            execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+        };
+    };
+    auth: {
+        provider: string;
+        methods: ({
+            label: string;
+            type: "oauth";
+            authorize(): Promise<import("./auth-handler").OAuthFlowResult>;
+        } | {
+            type: "api";
+            label: string;
+            authorize?: undefined;
+        })[];
+        loader(getAuth: () => Promise<unknown>, provider: Record<string, unknown>): Promise<{
+            apiKey: string;
+            fetch: typeof fetch;
+        }>;
+    };
+}>;

package/dist/index.js

@@ -1739,7 +1739,7 @@ async function confirm(message, defaultYes = false) {
   return result ?? false;
 }
 
-// ../oauth-adapters/src/openai.ts
+// ../multi-account-core/src/adapters/openai.ts
 var ISSUER = "https://auth.openai.com";
 var openAIOAuthAdapter = {
   id: "openai",

package/dist/oauth.d.ts

@@ -0,0 +1,37 @@
+import type { TokenResponse } from "./types";
+type PKCE = {
+    verifier: string;
+    challenge: string;
+};
+export declare function generatePKCE(): Promise<{
+    verifier: string;
+    challenge: string;
+}>;
+export declare function generateState(): string;
+export declare function exchangeCodeForTokens(code: string, redirectUri: string, pkce: PKCE): Promise<TokenResponse>;
+export declare function refreshAccessToken(refreshToken: string): Promise<TokenResponse>;
+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 extractAccountId(tokens: {
+    id_token?: string;
+    access_token: string;
+}): string | undefined;
+export declare function startOAuthServer(): Promise<{
+    port: number;
+    redirectUri: string;
+}>;
+export declare function stopOAuthServer(): void;
+export declare function waitForOAuthCallback(pkce: PKCE, state: string): Promise<TokenResponse>;
+export declare function buildAuthorizeUrl(redirectUri: string, pkce: {
+    challenge: string;
+}, state: string): string;
+export {};

package/dist/proactive-refresh.d.ts

@@ -0,0 +1,2 @@
+export declare const ProactiveRefreshQueue: import("opencode-multi-account-core").ProactiveRefreshQueueClass;
+export type ProactiveRefreshQueue = InstanceType<typeof ProactiveRefreshQueue>;

package/dist/rate-limit.d.ts

@@ -0,0 +1,2 @@
+declare const fetchUsageLimits: (accessToken: string, accountId?: string) => Promise<import("opencode-multi-account-core").UsageLimits | null>, getResetMsFromUsage: (account: import("opencode-multi-account-core").ManagedAccount) => number | null, handleRateLimitResponse: (manager: import("opencode-multi-account-core").RateLimitAccountManager, client: import("opencode-multi-account-core").PluginClient, account: import("opencode-multi-account-core").ManagedAccount, response: Response) => Promise<void>, retryAfterMsFromResponse: (response: Response) => number;
+export { fetchUsageLimits, getResetMsFromUsage, handleRateLimitResponse, retryAfterMsFromResponse, };

package/dist/request-transform.d.ts

@@ -0,0 +1,2 @@
+export declare function buildRequestHeaders(input: RequestInfo | URL, init: RequestInit | undefined, accessToken: string, accountId?: string): Headers;
+export declare function transformRequestUrl(input: RequestInfo | URL): RequestInfo | URL;

package/dist/runtime-factory.d.ts

@@ -0,0 +1,18 @@
+import { AccountStore } from "./account-store";
+import type { PluginClient } from "./types";
+type BaseFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+interface AccountRuntime {
+    fetch: BaseFetch;
+}
+export declare class AccountRuntimeFactory {
+    private readonly store;
+    private readonly client;
+    private runtimes;
+    private initLocks;
+    constructor(store: AccountStore, client: PluginClient);
+    getRuntime(uuid: string): Promise<AccountRuntime>;
+    invalidate(uuid: string): void;
+    invalidateAll(): void;
+    private createRuntime;
+}
+export {};

package/dist/storage.d.ts

@@ -0,0 +1 @@
+export { deduplicateAccounts, loadAccounts, readStorageFromDisk, } from "opencode-multi-account-core";

package/dist/token.d.ts

@@ -0,0 +1,4 @@
+import { type ManagedAccount, type PluginClient, type TokenRefreshResult } from "./types";
+export declare function isTokenExpired(account: Pick<ManagedAccount, "accessToken" | "expiresAt">): boolean;
+export declare function refreshToken(currentRefreshToken: string, accountId: string, client: PluginClient): Promise<TokenRefreshResult>;
+export declare function clearRefreshMutex(accountId?: string): void;

package/dist/types.d.ts

@@ -0,0 +1,216 @@
+import * as v from "valibot";
+export declare const OAuthCredentialsSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"oauth", undefined>;
+    readonly refresh: v.StringSchema<undefined>;
+    readonly access: v.StringSchema<undefined>;
+    readonly expires: v.NumberSchema<undefined>;
+}, undefined>;
+export declare const UsageLimitEntrySchema: v.ObjectSchema<{
+    readonly utilization: v.NumberSchema<undefined>;
+    readonly resets_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export declare const UsageLimitsSchema: v.ObjectSchema<{
+    readonly five_hour: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
+        readonly utilization: v.NumberSchema<undefined>;
+        readonly resets_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>, null>;
+    readonly seven_day: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
+        readonly utilization: v.NumberSchema<undefined>;
+        readonly resets_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>, null>;
+    readonly seven_day_sonnet: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
+        readonly utilization: v.NumberSchema<undefined>;
+        readonly resets_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>, null>;
+}, undefined>;
+export declare const CredentialRefreshPatchSchema: v.ObjectSchema<{
+    readonly accessToken: v.StringSchema<undefined>;
+    readonly expiresAt: v.NumberSchema<undefined>;
+    readonly refreshToken: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly uuid: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly accountId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly email: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export declare const StoredAccountSchema: v.ObjectSchema<{
+    readonly uuid: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly accountId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly email: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly planTier: v.OptionalSchema<v.StringSchema<undefined>, "">;
+    readonly refreshToken: v.StringSchema<undefined>;
+    readonly accessToken: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly expiresAt: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    readonly addedAt: v.NumberSchema<undefined>;
+    readonly lastUsed: v.NumberSchema<undefined>;
+    readonly enabled: v.OptionalSchema<v.BooleanSchema<undefined>, true>;
+    readonly rateLimitResetAt: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    readonly cachedUsage: v.OptionalSchema<v.ObjectSchema<{
+        readonly five_hour: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
+            readonly utilization: v.NumberSchema<undefined>;
+            readonly resets_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>, null>;
+        readonly seven_day: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
+            readonly utilization: v.NumberSchema<undefined>;
+            readonly resets_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>, null>;
+        readonly seven_day_sonnet: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
+            readonly utilization: v.NumberSchema<undefined>;
+            readonly resets_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>, null>;
+    }, undefined>, undefined>;
+    readonly cachedUsageAt: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    readonly consecutiveAuthFailures: v.OptionalSchema<v.NumberSchema<undefined>, 0>;
+    readonly isAuthDisabled: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
+    readonly authDisabledReason: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export declare const AccountStorageSchema: v.ObjectSchema<{
+    readonly version: v.LiteralSchema<1, undefined>;
+    readonly accounts: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+        readonly uuid: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly accountId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly email: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly planTier: v.OptionalSchema<v.StringSchema<undefined>, "">;
+        readonly refreshToken: v.StringSchema<undefined>;
+        readonly accessToken: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly expiresAt: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        readonly addedAt: v.NumberSchema<undefined>;
+        readonly lastUsed: v.NumberSchema<undefined>;
+        readonly enabled: v.OptionalSchema<v.BooleanSchema<undefined>, true>;
+        readonly rateLimitResetAt: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        readonly cachedUsage: v.OptionalSchema<v.ObjectSchema<{
+            readonly five_hour: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
+                readonly utilization: v.NumberSchema<undefined>;
+                readonly resets_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>, null>;
+            readonly seven_day: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
+                readonly utilization: v.NumberSchema<undefined>;
+                readonly resets_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>, null>;
+            readonly seven_day_sonnet: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
+                readonly utilization: v.NumberSchema<undefined>;
+                readonly resets_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>, null>;
+        }, undefined>, undefined>;
+        readonly cachedUsageAt: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        readonly consecutiveAuthFailures: v.OptionalSchema<v.NumberSchema<undefined>, 0>;
+        readonly isAuthDisabled: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
+        readonly authDisabledReason: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>, readonly []>;
+    readonly activeAccountUuid: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+/** OpenAI /oauth/token response */
+export declare const TokenResponseSchema: v.ObjectSchema<{
+    readonly id_token: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly access_token: v.StringSchema<undefined>;
+    readonly refresh_token: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly expires_in: v.NumberSchema<undefined>;
+}, undefined>;
+export type OAuthCredentials = v.InferOutput<typeof OAuthCredentialsSchema>;
+export type UsageLimitEntry = v.InferOutput<typeof UsageLimitEntrySchema>;
+export type UsageLimits = v.InferOutput<typeof UsageLimitsSchema>;
+export type CredentialRefreshPatch = v.InferOutput<typeof CredentialRefreshPatchSchema>;
+export type StoredAccount = v.InferOutput<typeof StoredAccountSchema>;
+export type AccountStorage = v.InferOutput<typeof AccountStorageSchema>;
+export type TokenResponse = v.InferOutput<typeof TokenResponseSchema>;
+export declare const AccountSelectionStrategySchema: v.PicklistSchema<["sticky", "round-robin", "hybrid"], undefined>;
+export type AccountSelectionStrategy = v.InferOutput<typeof AccountSelectionStrategySchema>;
+export declare const PluginConfigSchema: v.ObjectSchema<{
+    /** sticky: same account until failure, round-robin: rotate every request, hybrid: health+usage scoring */
+    readonly account_selection_strategy: v.OptionalSchema<v.PicklistSchema<["sticky", "round-robin", "hybrid"], undefined>, "sticky">;
+    /** Use cross-process claim file to distribute parallel sessions across accounts */
+    readonly cross_process_claims: v.OptionalSchema<v.BooleanSchema<undefined>, true>;
+    /** Skip account when any usage tier utilization >= this % (100 = disabled) */
+    readonly soft_quota_threshold_percent: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 100, undefined>]>, 100>;
+    /** Minimum backoff after rate limit (ms) */
+    readonly rate_limit_min_backoff_ms: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>, 30000>;
+    /** Default retry-after when header is missing (ms) */
+    readonly default_retry_after_ms: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>, 60000>;
+    /** Consecutive auth failures before disabling account */
+    readonly max_consecutive_auth_failures: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, 3>;
+    /** Backoff after token refresh failure (ms) */
+    readonly token_failure_backoff_ms: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>, 30000>;
+    /** Enable proactive background token refresh */
+    readonly proactive_refresh: v.OptionalSchema<v.BooleanSchema<undefined>, true>;
+    /** Seconds before expiry to trigger proactive refresh (default 30 min) */
+    readonly proactive_refresh_buffer_seconds: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 60, undefined>]>, 1800>;
+    /** Interval between background refresh checks in seconds (default 5 min) */
+    readonly proactive_refresh_interval_seconds: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 30, undefined>]>, 300>;
+    /** Suppress toast notifications */
+    readonly quiet_mode: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
+    /** Enable debug logging */
+    readonly debug: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
+}, undefined>;
+export type PluginConfig = v.InferOutput<typeof PluginConfigSchema>;
+export interface OriginalAuthHook {
+    methods?: Array<{
+        authorize?: (inputs?: Record<string, string>) => Promise<unknown>;
+    }>;
+    loader: (getAuth: () => Promise<unknown>, provider: unknown) => Promise<{
+        apiKey: string;
+        fetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+    }>;
+}
+export type TokenRefreshResult = {
+    ok: true;
+    patch: CredentialRefreshPatch;
+} | {
+    ok: false;
+    permanent: boolean;
+    status?: number;
+};
+export interface ManagedAccount {
+    index: number;
+    uuid?: string;
+    accountId?: string;
+    label?: string;
+    email?: string;
+    planTier?: string;
+    refreshToken: string;
+    accessToken?: string;
+    expiresAt?: number;
+    addedAt: number;
+    lastUsed: number;
+    enabled: boolean;
+    rateLimitResetAt?: number;
+    last429At?: number;
+    cachedUsage?: UsageLimits;
+    cachedUsageAt?: number;
+    consecutiveAuthFailures: number;
+    isAuthDisabled: boolean;
+    authDisabledReason?: string;
+}
+export interface PluginClient {
+    auth: {
+        set: (params: {
+            path: {
+                id: string;
+            };
+            body: {
+                type: string;
+                refresh: string;
+                access: string;
+                expires: number;
+            };
+        }) => Promise<void>;
+    };
+    tui: {
+        showToast: (params: {
+            body: {
+                title?: string;
+                message: string;
+                variant: "info" | "warning" | "success" | "error";
+            };
+        }) => Promise<void>;
+    };
+    app: {
+        log: (params: {
+            body: {
+                service: string;
+                level: "debug" | "info" | "warn" | "error";
+                message: string;
+                extra?: Record<string, unknown>;
+            };
+        }) => Promise<void>;
+    };
+}

package/dist/ui/ansi.d.ts

@@ -0,0 +1 @@
+export { ANSI, isTTY, parseKey, type KeyAction, } from "opencode-multi-account-core";

package/dist/ui/auth-menu.d.ts

@@ -0,0 +1,25 @@
+import type { AccountSelectionStrategy, ManagedAccount, UsageLimits } from "../types";
+export type AuthMenuAction = {
+    type: "add";
+} | {
+    type: "check-quotas";
+} | {
+    type: "manage";
+} | {
+    type: "load-balancing";
+} | {
+    type: "delete-all";
+} | {
+    type: "cancel";
+};
+export type AccountAction = "back" | "toggle" | "delete" | "retry-auth" | "cancel";
+export declare function showAuthMenu(accounts: ManagedAccount[]): Promise<AuthMenuAction>;
+export declare function showManageAccounts(accounts: ManagedAccount[]): Promise<{
+    action: AccountAction;
+    account?: ManagedAccount;
+}>;
+export declare function printQuotaReport(account: ManagedAccount, usage: UsageLimits): void;
+export declare function showStrategySelect(current: AccountSelectionStrategy): Promise<AccountSelectionStrategy | null>;
+export type AuthMethod = "browser" | "headless";
+export declare function showMethodSelect(): Promise<AuthMethod | null>;
+export declare function printQuotaError(account: ManagedAccount, error: string): void;

package/dist/ui/confirm.d.ts

@@ -0,0 +1 @@
+export { confirm } from "opencode-multi-account-core";

package/dist/ui/select.d.ts

@@ -0,0 +1 @@
+export { select, type MenuItem, type SelectOptions, } from "opencode-multi-account-core";

package/dist/usage.d.ts

@@ -0,0 +1,25 @@
+import type { ManagedAccount, UsageLimits } from "./types";
+export type ProfileData = {
+    email?: string;
+    planTier: string;
+};
+export type FetchUsageResult = {
+    ok: true;
+    data: UsageLimits;
+    planType?: string;
+} | {
+    ok: false;
+    reason: string;
+};
+export type FetchProfileResult = {
+    ok: true;
+    data: ProfileData;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function fetchUsage(accessToken: string, accountId?: string): Promise<FetchUsageResult>;
+export declare function derivePlanTier(planType: string): string;
+export declare function fetchProfile(accessToken: string): FetchProfileResult;
+export declare function getUsageSummary(account: ManagedAccount): string;
+export declare function getPlanLabel(account: ManagedAccount): string;

package/dist/utils.d.ts

@@ -0,0 +1 @@
+export { createMinimalClient, debugLog, formatWaitTime, getAccountLabel, getConfigDir, getErrorCode, showToast, sleep, } from "opencode-multi-account-core";

package/package.json

@@ -1,16 +1,21 @@
 {
   "name": "opencode-codex-multi-account",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "OpenCode plugin for Codex (OpenAI) multi-account management with automatic rate limit switching",
-  "main": "./src/index.ts",
+  "main": "./dist/index.js",
   "type": "module",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
   },
   "scripts": {
-    "build": "esbuild src/index.ts --bundle --outdir=dist --platform=node --format=esm --packages=external",
+    "build": "esbuild src/index.ts --bundle --outdir=dist --platform=node --format=esm --packages=external && tsc -p tsconfig.build.json --emitDeclarationOnly",
     "typecheck": "tsc --noEmit",
-    "test": "vitest run",
+    "test": "for f in tests/*.test.ts; do bun test \"$f\" || exit 1; done",
     "prepack": "bun run build",
     "dev": "bun run build --watch"
   },
@@ -35,27 +40,17 @@
     "directory": "packages/codex-multi-account"
   },
   "dependencies": {
-    "opencode-multi-account-core": "^0.1.1",
-    "opencode-oauth-adapters": "^0.1.1",
-    "proper-lockfile": "^4.1.2",
+    "opencode-multi-account-core": "^0.2.0",
     "valibot": "^1.2.0"
   },
   "devDependencies": {
     "@opencode-ai/plugin": "^0.15.30",
     "@types/node": "^25.2.2",
-    "@types/proper-lockfile": "^4.1.4",
     "typescript": "^5.8.0"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
-    "access": "public",
-    "main": "./dist/index.js",
-    "exports": {
-      ".": {
-        "import": "./dist/index.js",
-        "default": "./dist/index.js"
-      }
-    }
+    "access": "public"
   },
   "files": [
     "dist",