opencode-anthropic-multi-account 0.1.2 → 0.2.1

package/README.md

@@ -26,8 +26,6 @@ Add to `opencode.json`:
 opencode-anthropic-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,19 @@
+import { AccountManager } from "./account-manager";
+import type { OriginalAuthHook, PluginClient } from "./types";
+type OAuthCallbackResponse = ({
+    type: "success";
+} & {
+    refresh: string;
+    access: string;
+    expires: number;
+}) | {
+    type: "failed";
+};
+export interface OAuthFlowResult {
+    url: string;
+    instructions: string;
+    method: "auto";
+    callback(code?: string): Promise<OAuthCallbackResponse>;
+}
+export declare function handleAuthorize(originalAuth: OriginalAuthHook, 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,24 @@
+/** Anthropic OAuth adapter config */
+export declare const ANTHROPIC_OAUTH_ADAPTER: import("opencode-multi-account-core").OAuthAdapter;
+/** Anthropic OAuth Client ID (same as builtin opencode-anthropic-auth) */
+export declare const ANTHROPIC_CLIENT_ID: string;
+/** Token exchange / refresh endpoint */
+export declare const ANTHROPIC_TOKEN_ENDPOINT: string;
+/** OAuth usage stats endpoint */
+export declare const ANTHROPIC_USAGE_ENDPOINT: string;
+/** OAuth profile endpoint for email/plan info */
+export declare const ANTHROPIC_PROFILE_ENDPOINT: string;
+/** Required beta header for OAuth requests */
+export declare const ANTHROPIC_BETA_HEADER: string;
+/** User-Agent header to mimic Claude CLI */
+export declare const CLAUDE_CLI_USER_AGENT: string;
+/** Tool name prefix required by Anthropic servers */
+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,2 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const ClaudeMultiAuthPlugin: Plugin;

package/dist/index.js

@@ -1740,7 +1740,7 @@ async function confirm(message, defaultYes = false) {
   return result ?? false;
 }
 
-// ../oauth-adapters/src/anthropic.ts
+// ../multi-account-core/src/adapters/anthropic.ts
 var anthropicOAuthAdapter = {
   id: "anthropic",
   authProviderId: "anthropic",
@@ -2019,11 +2019,11 @@ function getUsageSummary(account) {
   const parts = [];
   const { five_hour, seven_day } = account.cachedUsage;
   if (five_hour) {
-    const reset = five_hour.resets_at ? ` (resets ${formatTimeRemaining(five_hour.resets_at)})` : "";
+    const reset = five_hour.utilization >= 100 && five_hour.resets_at ? ` (resets ${formatTimeRemaining(five_hour.resets_at)})` : "";
     parts.push(`5h: ${five_hour.utilization.toFixed(0)}%${reset}`);
   }
   if (seven_day) {
-    const reset = seven_day.resets_at ? ` (resets ${formatTimeRemaining(seven_day.resets_at)})` : "";
+    const reset = seven_day.utilization >= 100 && seven_day.resets_at ? ` (resets ${formatTimeRemaining(seven_day.resets_at)})` : "";
     parts.push(`7d: ${seven_day.utilization.toFixed(0)}%${reset}`);
   }
   return parts.length > 0 ? parts.join(", ") : "no data";
@@ -2079,6 +2079,16 @@ function getAccountStatus(account) {
   if (account.isAuthDisabled) return "auth-disabled";
   if (!account.enabled) return "disabled";
   if (account.rateLimitResetAt && account.rateLimitResetAt > Date.now()) return "rate-limited";
+  if (account.cachedUsage) {
+    const now = Date.now();
+    const usage = account.cachedUsage;
+    const exhaustedTiers = [usage.five_hour, usage.seven_day].filter(
+      (tier) => tier && tier.utilization >= 100 && tier.resets_at != null && Date.parse(tier.resets_at) > now
+    );
+    if (exhaustedTiers.length > 0) {
+      return "rate-limited";
+    }
+  }
   return "active";
 }
 var STATUS_BADGE = {
@@ -2198,7 +2208,7 @@ function printUsageEntry(name, entry, isLast) {
     return;
   }
   const bar = createProgressBar(entry.utilization);
-  const reset = formatResetTime(entry.resets_at);
+  const reset = entry.utilization >= 100 && entry.resets_at ? formatResetTime(entry.resets_at) : "";
   console.log(`     ${connector} ${name.padEnd(16)} ${bar}${reset}`);
 }
 function printQuotaReport(account, usage) {
@@ -2725,6 +2735,16 @@ var ClaudeMultiAuthPlugin = async (ctx) => {
               const remaining = formatWaitTime(account.rateLimitResetAt - Date.now());
               statusParts.push(`RATE LIMITED (resets in ${remaining})`);
             }
+            if (account.cachedUsage) {
+              const now = Date.now();
+              const usage2 = account.cachedUsage;
+              const exhaustedTiers = [usage2.five_hour, usage2.seven_day].filter(
+                (tier) => tier && tier.utilization >= 100 && tier.resets_at != null && Date.parse(tier.resets_at) > now
+              );
+              if (exhaustedTiers.length > 0) {
+                statusParts.push("USAGE EXHAUSTED");
+              }
+            }
             lines.push(
               `- **${label}**${planBadge}${marker}: ${statusParts.join(" | ")} | ${usage}`
             );

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,4 @@
+export declare function buildRequestHeaders(input: RequestInfo | URL, init: RequestInit | undefined, accessToken: string): Headers;
+export declare function transformRequestBody(body: string | undefined): string | undefined;
+export declare function transformRequestUrl(input: RequestInfo | URL): RequestInfo | URL;
+export declare function createResponseStreamTransform(response: Response): Response;

package/dist/runtime-factory.d.ts

@@ -0,0 +1,23 @@
+import { AccountStore } from "./account-store";
+import type { PluginClient } from "./types";
+type BaseFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+interface AccountRuntime {
+    fetch: BaseFetch;
+}
+/** Per-account base plugin instances — delegates all auth mechanics to AnthropicAuthPlugin. */
+export declare class AccountRuntimeFactory {
+    private readonly pluginCtx;
+    private readonly store;
+    private readonly client;
+    private readonly provider;
+    private runtimes;
+    private initLocks;
+    constructor(pluginCtx: Record<string, unknown>, store: AccountStore, client: PluginClient, provider: unknown);
+    getRuntime(uuid: string): Promise<AccountRuntime>;
+    invalidate(uuid: string): void;
+    invalidateAll(): void;
+    private createRuntime;
+    private createScopedGetAuth;
+    private createScopedClient;
+}
+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,214 @@
+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 email: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export declare const StoredAccountSchema: v.ObjectSchema<{
+    readonly uuid: 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 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>;
+/** Anthropic /v1/oauth/token response */
+export declare const TokenResponseSchema: v.ObjectSchema<{
+    readonly access_token: v.StringSchema<undefined>;
+    readonly refresh_token: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly expires_in: v.NumberSchema<undefined>;
+    readonly account: v.OptionalSchema<v.ObjectSchema<{
+        readonly uuid: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly email_address: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, 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;
+};
+export interface ManagedAccount {
+    index: number;
+    uuid?: 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,26 @@
+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";
+type AccountStatus = "active" | "rate-limited" | "auth-disabled" | "disabled";
+export declare function getAccountStatus(account: ManagedAccount): AccountStatus;
+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 declare function printQuotaError(account: ManagedAccount, error: string): void;
+export {};

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,23 @@
+import type { ManagedAccount, UsageLimits } from "./types";
+export type ProfileData = {
+    email?: string;
+    planTier: string;
+};
+export type FetchUsageResult = {
+    ok: true;
+    data: UsageLimits;
+} | {
+    ok: false;
+    reason: string;
+};
+export type FetchProfileResult = {
+    ok: true;
+    data: ProfileData;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function fetchUsage(accessToken: string): Promise<FetchUsageResult>;
+export declare function fetchProfile(accessToken: string): Promise<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,20 +1,21 @@
 {
   "name": "opencode-anthropic-multi-account",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "OpenCode plugin for Anthropic multi-account management with automatic rate limit switching",
-  "main": "./src/index.ts",
+  "main": "./dist/index.js",
   "type": "module",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "source": "./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"
   },
@@ -38,16 +39,13 @@
     "directory": "packages/anthropic-multi-account"
   },
   "dependencies": {
-    "opencode-multi-account-core": "^0.1.2",
-    "opencode-oauth-adapters": "^0.1.2",
+    "opencode-multi-account-core": "^0.2.1",
     "opencode-anthropic-auth": "^0.0.13",
-    "proper-lockfile": "^4.1.2",
     "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": {