opencode-auth-load-balancer 0.6.0 → 0.7.0

package/dist/v2-rpc.d.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+/** Display and management API; its status output never contains credentials. */
+export declare const loadBalancerRpc: {
+    readonly id: 'auth-load-balancer';
+    readonly methods: {
+        readonly status: {
+            readonly input: z.ZodObject<{
+                sessionID: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            readonly output: z.ZodArray<z.ZodObject<{
+                providerID: z.ZodString;
+                accounts: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    weeklyUtil: z.ZodNullable<z.ZodNumber>;
+                    hourlyUtil: z.ZodNullable<z.ZodNumber>;
+                    weeklyResetAt: z.ZodNumber;
+                    available: z.ZodBoolean;
+                    cooldownUntil: z.ZodNumber;
+                    modelCooldownsUntil: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                    disabledReason: z.ZodNullable<z.ZodString>;
+                    login: z.ZodString;
+                    warnings: z.ZodArray<z.ZodString>;
+                    lostNotes: z.ZodArray<z.ZodString>;
+                    current: z.ZodBoolean;
+                    rank: z.ZodNumber;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        };
+        readonly manage: {
+            readonly input: z.ZodObject<{
+                account: z.ZodString;
+                action: z.ZodEnum<{
+                    "clear-relogin": "clear-relogin";
+                    delete: "delete";
+                    disable: "disable";
+                    enable: "enable";
+                    relogin: "relogin";
+                    rename: "rename";
+                }>;
+                name: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            readonly output: z.ZodString;
+        };
+    };
+    readonly events: {
+        readonly toast: {
+            readonly schema: z.ZodObject<{
+                title: z.ZodOptional<z.ZodString>;
+                message: z.ZodString;
+                variant: z.ZodEnum<{
+                    error: "error";
+                    info: "info";
+                    success: "success";
+                    warning: "warning";
+                }>;
+                duration: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>;
+        };
+    };
+};
+export type ProviderStatus = z.infer<typeof loadBalancerRpc.methods.status.output>[number];

package/dist/v2.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from '@opencode/plugin';
+export declare function setupV2(ctx: Plugin.Context): Promise<Plugin.Cleanup>;

package/index.js

@@ -0,0 +1,2 @@
+// OpenCode V2 resolves local plugin directories through their root index file.
+export { default } from './dist/index.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-auth-load-balancer",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Load-balance opencode requests across multiple Anthropic (Claude) and OpenAI (Codex) OAuth accounts and Kimi Code subscriptions, weighted primarily by weekly usage with drain-before-reset scheduling.",
   "type": "module",
   "license": "MIT",
@@ -20,16 +20,25 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
-    }
+    },
+    "./v1": {
+      "types": "./dist/v1.d.ts",
+      "default": "./dist/v1.js"
+    },
+    "./server": "./dist/index.js",
+    "./tui": "./tui.ts",
+    "./tui-v1": "./tui/auth-load-balancer-tui.ts"
   },
   "files": [
+    "index.js",
+    "tui.ts",
     "dist",
     "tui"
   ],
   "scripts": {
-    "sync:tui": "bun -e \"await Bun.write('tui/auth-load-balancer-scoring.ts', Bun.file('src/scheduler/score-core.ts'))\"",
-    "build": "bun run sync:tui && bun build ./src/index.ts --outdir dist --target node --format esm && tsc -p tsconfig.build.json",
-    "dev": "bun build ./src/index.ts --outdir dist --target node --format esm --watch",
+    "sync:tui": "bun -e \"await Bun.write('tui/auth-load-balancer-scoring.ts', Bun.file('src/scheduler/score-core.ts')); await Bun.write('tui/auth-load-balancer-rpc.ts', Bun.file('src/v2-rpc.ts'))\"",
+    "build": "bun run sync:tui && bun build ./src/index.ts ./src/v1.ts --outdir dist --target node --format esm --external @opencode/plugin --external effect --external 'effect/*' && tsc -p tsconfig.build.json",
+    "dev": "bun build ./src/index.ts ./src/v1.ts --outdir dist --target node --format esm --external @opencode/plugin --external effect --external 'effect/*' --watch",
     "typecheck": "tsc --noEmit && tsc -p tsconfig.tui.json --noEmit",
     "typecheck:tui": "tsc -p tsconfig.tui.json --noEmit",
     "lint": "oxlint",
@@ -41,12 +50,35 @@
     "prepare": "husky"
   },
   "peerDependencies": {
-    "@opencode-ai/plugin": ">=1.18.26"
+    "@opencode-ai/plugin": ">=1.18.26 <2",
+    "@opencode/plugin": "^2.0.27",
+    "@opentui/core": ">=0.5.17",
+    "@opentui/solid": ">=0.5.17",
+    "solid-js": ">=1.9.0"
+  },
+  "peerDependenciesMeta": {
+    "@opencode-ai/plugin": {
+      "optional": true
+    },
+    "@opencode/plugin": {
+      "optional": true
+    },
+    "@opentui/core": {
+      "optional": true
+    },
+    "@opentui/solid": {
+      "optional": true
+    },
+    "solid-js": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@opencode-ai/plugin": "^1.18.26",
-    "@opentui/core": "0.5.10",
-    "@opentui/solid": "0.5.10",
+    "@opencode/plugin": "2.0.27",
+    "@opencode/theme": "2.0.27",
+    "@opentui/core": "0.5.17",
+    "@opentui/solid": "0.5.17",
     "@types/bun": "^1.4.0",
     "@types/node": "^26.4.1",
     "eslint-plugin-devup": "^2.1.0",
@@ -73,5 +105,11 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "3.0.129",
+    "@ai-sdk/openai": "3.0.125",
+    "@ai-sdk/openai-compatible": "2.0.81",
+    "zod": "^4.3"
   }
 }

package/tui/auth-load-balancer-rpc.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod'
+
+const accountStatus = z.object({
+  id: z.string(),
+  label: z.string(),
+  weeklyUtil: z.number().nullable(),
+  hourlyUtil: z.number().nullable(),
+  weeklyResetAt: z.number(),
+  available: z.boolean(),
+  cooldownUntil: z.number(),
+  modelCooldownsUntil: z.record(z.string(), z.number()),
+  disabledReason: z.string().nullable(),
+  login: z.string(),
+  warnings: z.array(z.string()),
+  lostNotes: z.array(z.string()),
+  current: z.boolean(),
+  rank: z.number(),
+})
+
+/** Display and management API; its status output never contains credentials. */
+export const loadBalancerRpc = {
+  id: 'auth-load-balancer',
+  methods: {
+    status: {
+      input: z.object({ sessionID: z.string().optional() }),
+      output: z.array(
+        z.object({ providerID: z.string(), accounts: z.array(accountStatus) }),
+      ),
+    },
+    manage: {
+      input: z.object({
+        account: z.string(),
+        action: z.enum([
+          'rename',
+          'disable',
+          'enable',
+          'delete',
+          'relogin',
+          'clear-relogin',
+        ]),
+        name: z.string().optional(),
+      }),
+      output: z.string(),
+    },
+  },
+  events: {
+    toast: {
+      schema: z.object({
+        title: z.string().optional(),
+        message: z.string(),
+        variant: z.enum(['info', 'success', 'warning', 'error']),
+        duration: z.number().optional(),
+      }),
+    },
+  },
+} as const
+
+export type ProviderStatus = z.infer<
+  typeof loadBalancerRpc.methods.status.output
+>[number]

package/tui/auth-load-balancer-v2.ts

@@ -0,0 +1,10 @@
+import type { Plugin } from '@opencode/plugin/tui'
+
+export default {
+  id: 'auth-load-balancer-tui',
+  async setup(ctx: Plugin.Context) {
+    // The host installs its Solid transform before evaluating this view.
+    const { registerV2Slots } = await import('./auth-load-balancer-v2.view.tsx')
+    return registerV2Slots(ctx)
+  },
+}

package/tui/auth-load-balancer-v2.view.tsx

@@ -0,0 +1,242 @@
+/** @jsxImportSource @opentui/solid */
+import type { Plugin } from '@opencode/plugin/tui'
+import { createSignal, For, onCleanup, Show } from 'solid-js'
+
+import { loadBalancerRpc, type ProviderStatus } from './auth-load-balancer-rpc'
+
+const names: Record<string, string> = {
+  anthropic: 'Claude',
+  openai: 'Codex',
+  'kimi-code-plan-cn': 'Kimi',
+  'kimi-code-plan-global': 'Kimi (kimi.ai)',
+}
+const pct = (value: number | null) =>
+  value === null ? '?' : `${Math.round(value * 100)}%`
+
+function StatusView(props: {
+  ctx: Plugin.Context
+  sessionID?: string
+  compact?: boolean
+}) {
+  const rpc = props.ctx.client.rpc(loadBalancerRpc)
+  const [providers, setProviders] = createSignal<ProviderStatus[]>([])
+  const [error, setError] = createSignal('')
+  let disposed = false
+  const [refreshing, setRefreshing] = createSignal(false)
+  const refresh = async () => {
+    if (refreshing()) return
+    setRefreshing(true)
+    try {
+      const result = await rpc.status(
+        { sessionID: props.sessionID },
+        { location: props.ctx.location },
+      )
+      if (!disposed) {
+        setProviders(result)
+        setError('')
+      }
+    } catch {
+      if (!disposed) setError('Auth Load Balancer unavailable')
+    } finally {
+      setRefreshing(false)
+    }
+  }
+  const timer = setInterval(() => void refresh(), 3000)
+  onCleanup(() => {
+    disposed = true
+    clearInterval(timer)
+  })
+  void refresh()
+
+  const login = async (
+    provider: ProviderStatus,
+    account: ProviderStatus['accounts'][number],
+  ) => {
+    const result = await props.ctx.client.integration.get({
+      integrationID: provider.providerID,
+      location: props.ctx.location,
+    })
+    const methods = result.data.methods.flatMap((method) =>
+      method.type === 'oauth' && method.id.startsWith('auth-lb-')
+        ? [method]
+        : [],
+    )
+    const methodID = await props.ctx.ui.dialog.select({
+      title: `Sign in to ${names[provider.providerID] ?? provider.providerID}`,
+      options: methods.map((method) => ({
+        title: method.label,
+        value: method.id,
+      })),
+    })
+    if (!methodID) return
+    await rpc.manage(
+      { account: account.id, action: 'relogin' },
+      { location: props.ctx.location },
+    )
+    let attemptID: string | undefined
+    try {
+      const { data } = await props.ctx.client.integration.oauth.connect({
+        integrationID: provider.providerID,
+        methodID,
+        location: props.ctx.location,
+      })
+      attemptID = data.attemptID
+      const code =
+        data.mode === 'code'
+          ? await props.ctx.ui.dialog.prompt({
+              title: 'Authorize account',
+              description: `${data.url}\n${data.instructions}`,
+            })
+          : await props.ctx.ui.dialog.confirm({
+              title: 'Authorize account',
+              message: `${data.url}\n${data.instructions}\nContinue after approving in your browser.`,
+            })
+      if (code === undefined || code === false) return
+      await props.ctx.client.integration.oauth.complete({
+        integrationID: provider.providerID,
+        attemptID,
+        ...(typeof code === 'string' ? { code } : {}),
+        location: props.ctx.location,
+      })
+      attemptID = undefined
+      props.ctx.ui.toast.show({
+        message: 'Account added to load balancer',
+        variant: 'success',
+      })
+    } finally {
+      if (attemptID)
+        await props.ctx.client.integration.oauth
+          .cancel({
+            integrationID: provider.providerID,
+            attemptID,
+            location: props.ctx.location,
+          })
+          .catch(() => {})
+      await rpc
+        .manage(
+          { account: account.id, action: 'clear-relogin' },
+          { location: props.ctx.location },
+        )
+        .catch(() => {})
+    }
+  }
+  const manage = async (
+    provider: ProviderStatus,
+    account: ProviderStatus['accounts'][number],
+  ) => {
+    try {
+      const disabled = account.disabledReason === 'manually disabled'
+      const action = await props.ctx.ui.dialog.select({
+        title: account.label,
+        options: [
+          { title: 'Rename', value: 'rename' as const },
+          {
+            title: disabled ? 'Enable' : 'Disable',
+            value: disabled ? ('enable' as const) : ('disable' as const),
+          },
+          { title: 'Re-login / pair credential', value: 'relogin' as const },
+          { title: 'Delete', value: 'delete' as const },
+        ],
+      })
+      if (!action) return
+      if (action === 'relogin') {
+        await login(provider, account)
+        return
+      }
+      const name =
+        action === 'rename'
+          ? await props.ctx.ui.dialog.prompt({
+              title: 'Rename account',
+              value: account.label,
+            })
+          : undefined
+      if (action === 'rename' && name === undefined) return
+      if (
+        action === 'delete' &&
+        !(await props.ctx.ui.dialog.confirm({
+          title: 'Delete account',
+          message: `Remove ${account.label} from the pool?`,
+        }))
+      )
+        return
+      await rpc.manage(
+        { account: account.id, action, name },
+        { location: props.ctx.location },
+      )
+    } catch (cause) {
+      props.ctx.ui.toast.show({
+        message:
+          cause instanceof Error ? cause.message : 'Account update failed',
+        variant: 'error',
+      })
+    } finally {
+      await refresh()
+    }
+  }
+
+  return (
+    <box flexDirection={props.compact ? 'row' : 'column'} gap={1}>
+      <Show when={error()}>
+        <text fg={props.ctx.theme.text.muted}>{error()}</text>
+      </Show>
+      <For each={providers()}>
+        {(provider) => (
+          <box flexDirection="column">
+            <Show when={!props.compact}>
+              <text fg={props.ctx.theme.text.base}>
+                <b>{names[provider.providerID] ?? provider.providerID}</b>
+              </text>
+            </Show>
+            <For
+              each={
+                props.compact
+                  ? provider.accounts.filter((account) => account.current)
+                  : provider.accounts
+              }
+            >
+              {(account) => (
+                <box
+                  flexDirection="column"
+                  onMouseDown={() => void manage(provider, account)}
+                >
+                  <text fg={props.ctx.theme.text.base} wrapMode="word">
+                    {`${account.current ? '●' : `#${account.rank}`} ${props.compact ? `${names[provider.providerID] ?? provider.providerID}: ` : ''}${account.label} · weekly ${pct(account.weeklyUtil)} · 5h ${pct(account.hourlyUtil)}${account.disabledReason ? ' · disabled' : account.available ? '' : ' · waiting'}`}
+                  </text>
+                  <Show when={!props.compact && account.warnings.length > 0}>
+                    <text fg={props.ctx.theme.text.muted}>
+                      {account.warnings.join(' · ')}
+                    </text>
+                  </Show>
+                </box>
+              )}
+            </For>
+          </box>
+        )}
+      </For>
+    </box>
+  )
+}
+
+export function registerV2Slots(ctx: Plugin.Context): () => void {
+  const stopToast = ctx.client
+    .rpc(loadBalancerRpc)
+    .events.on('toast', (event) => {
+      if (event.location?.directory === ctx.location?.directory)
+        ctx.ui.toast.show(event.data)
+    })
+  const stopFooter = ctx.ui.slot({
+    after: 'prompt.footer',
+    render: (props) => (
+      <StatusView compact ctx={ctx} sessionID={props.sessionID} />
+    ),
+  })
+  const stopSidebar = ctx.ui.slot({
+    append: 'sidebar.content',
+    render: (props) => <StatusView ctx={ctx} sessionID={props.sessionID} />,
+  })
+  return () => {
+    stopToast()
+    stopFooter()
+    stopSidebar()
+  }
+}

package/tui.ts

@@ -0,0 +1,2 @@
+// Local directory discovery and the published ./tui export share this entry.
+export { default } from './tui/auth-load-balancer-v2'