@cortexkit/opencode-anthropic-auth 2.2.1 → 2.2.3

package/src/rpc/notifications.ts

@@ -11,6 +11,25 @@ const TUI_CONNECTED_WINDOW_MS = 3_000
 let queue: RpcNotification[] = []
 let nextId = 1
 const lastDrainAtBySession = new Map<string, number>()
+// Callbacks waiting for a TUI to drain a specific notification, keyed by
+// notification id. See pushNotificationAwaitingPickup.
+const pickupWaiters = new Map<
+  number,
+  { readonly picked: () => void; readonly cancel: () => void }
+>()
+// Sessions whose last pickup wait ended with no TUI taking the dialog, in
+// insertion order so the oldest can be dropped. A drain for the session
+// removes it: a TUI is showing that session again.
+const missedPickupSessions = new Set<string>()
+const MISSED_PICKUP_CAP = 1_000
+
+export interface PickupWaitOptions {
+  /** How long the server waits for a TUI to drain the notification. */
+  readonly timeoutMs: number
+  /** Injected so tests can drive the deadline without real time passing. */
+  readonly setTimeout: typeof globalThis.setTimeout
+  readonly clearTimeout: typeof globalThis.clearTimeout
+}
 
 function assertSessionId(sessionId: string): void {
   if (typeof sessionId !== 'string' || sessionId.length === 0) {
@@ -18,19 +37,73 @@ function assertSessionId(sessionId: string): void {
   }
 }
 
+/** Queue a dialog for the session's TUI and return the notification id. */
 export function pushNotification(
   payload: OpenDialogPayload | CommandDialogPayload,
   sessionId: string,
-): void {
+): number {
   assertSessionId(sessionId)
+  const id = nextId++
   if ('menu' in payload) {
     if (payload.command !== 'claude' || payload.menu.command !== 'claude')
       throw new TypeError('Only the claude menu is supported')
-    queue.push({ id: nextId++, type: 'open-menu', payload, sessionId })
+    queue.push({ id, type: 'open-menu', payload, sessionId })
   } else {
-    queue.push({ id: nextId++, type: 'open-dialog', payload, sessionId })
+    queue.push({ id, type: 'open-dialog', payload, sessionId })
   }
   if (queue.length > QUEUE_CAP) queue = queue.slice(queue.length - QUEUE_CAP)
+  return id
+}
+
+/**
+ * Queue a dialog and wait for a TUI to drain it. Resolves true as soon as a
+ * drain for the session hands the notification out, which only a running TUI
+ * does. Resolves false when the deadline passes first; the notification is
+ * then removed, so a TUI that starts later does not open a stale dialog after
+ * the caller has already answered some other way.
+ */
+export function pushNotificationAwaitingPickup(
+  payload: OpenDialogPayload | CommandDialogPayload,
+  sessionId: string,
+  options: PickupWaitOptions,
+): Promise<boolean> {
+  // The push and the waiter registration happen in the same synchronous
+  // step, so no drain can hand the notification out before it is watched.
+  const id = pushNotification(payload, sessionId)
+  return new Promise((resolve) => {
+    let timer: ReturnType<typeof setTimeout> | undefined
+    pickupWaiters.set(id, {
+      picked() {
+        if (timer !== undefined) options.clearTimeout(timer)
+        resolve(true)
+      },
+      cancel() {
+        if (timer !== undefined) options.clearTimeout(timer)
+        resolve(false)
+      },
+    })
+    // Started after the waiter is registered, so a timer that fires at once
+    // still finds and removes it.
+    timer = options.setTimeout(() => {
+      if (!pickupWaiters.delete(id)) return
+      queue = queue.filter((notification) => notification.id !== id)
+      missedPickupSessions.delete(sessionId)
+      missedPickupSessions.add(sessionId)
+      if (missedPickupSessions.size > MISSED_PICKUP_CAP) {
+        const oldest = missedPickupSessions.values().next().value
+        if (oldest !== undefined) missedPickupSessions.delete(oldest)
+      }
+      resolve(false)
+    }, options.timeoutMs)
+  })
+}
+
+/**
+ * True when the session's last pickup wait found no TUI and no TUI has
+ * polled that session since, so a caller can answer at once without waiting.
+ */
+export function missedTuiPickup(sessionId: string): boolean {
+  return missedPickupSessions.has(sessionId)
 }
 
 export function drainNotifications(
@@ -39,6 +112,7 @@ export function drainNotifications(
 ): RpcNotification[] {
   assertSessionId(sessionId)
   lastDrainAtBySession.set(sessionId, Date.now())
+  missedPickupSessions.delete(sessionId)
   if (lastReceivedId > 0) {
     queue = queue.filter(
       (notification) =>
@@ -46,10 +120,17 @@ export function drainNotifications(
         notification.sessionId !== sessionId,
     )
   }
-  return queue.filter(
+  const pending = queue.filter(
     (notification) =>
       notification.id > lastReceivedId && notification.sessionId === sessionId,
   )
+  for (const notification of pending) {
+    const waiter = pickupWaiters.get(notification.id)
+    if (!waiter) continue
+    pickupWaiters.delete(notification.id)
+    waiter.picked()
+  }
+  return pending
 }
 
 export function isTuiConnected(sessionId: string): boolean {
@@ -62,4 +143,9 @@ export function resetNotificationsForTest(): void {
   queue = []
   nextId = 1
   lastDrainAtBySession.clear()
+  missedPickupSessions.clear()
+  // Cancel outstanding deadlines too: ids restart at 1, so a late deadline
+  // would otherwise withdraw a newer notification that reuses its id.
+  for (const waiter of pickupWaiters.values()) waiter.cancel()
+  pickupWaiters.clear()
 }

package/src/sidebar-state.ts

@@ -132,7 +132,7 @@ import {
   isQuotaStale,
   logger,
   quotaDisplayProjection,
-  quotaTextParts,
+  quotaWindowParts,
 } from '@cortexkit/anthropic-auth-core'
 
 const STATE_FILE_ENV = 'OPENCODE_ANTHROPIC_AUTH_SIDEBAR_STATE_FILE'
@@ -954,38 +954,30 @@ export function formatQuotaRowLabel(name: string, width = 10): string {
 
 /**
  * The short names model-scoped rows read under, in the order of `quota.scoped`:
- * the names common-auth's narrow one-line form gives them (`Fa` for Fable;
- * models whose short names would collide are extended until they differ, as
- * `Fabl` and `Fabr`), so the expanded rows and the collapsed line agree.
- *
- * common-auth exposes that short name only inside the narrow text, and the
- * narrow line shows just one model window (the tightest). So each window's
- * name is read from a narrow line of a copy of the reading in which that
- * window alone is spent: every model window stays in, so collisions resolve
- * exactly as they do in the real line, and the one piece the line shows is
- * `<short name> 0% left`. The figures in the copy are never displayed.
+ * each window part's `short`, the same label common-auth's narrow one-line
+ * form uses (`Fa` for Fable; models whose short names would collide are
+ * extended until they differ, as `Fabl` and `Fabr`), so the expanded rows and
+ * the collapsed line agree. Short names are worked out over every model window
+ * in the reading, so all scoped windows are projected together. A part is
+ * matched to its window by the window's title, which is the name a
+ * model-scoped part carries; a window with no part keeps its title.
  */
 export function scopedQuotaShortNames(
   quota: Pick<AccountQuota, 'scoped'> | null | undefined,
   now = Date.now(),
 ): string[] {
   const scoped = quota?.scoped ?? []
-  return scoped.map((window, index) => {
-    const probe = quotaDisplayProjection(
-      {
-        scoped: scoped.map((other, at) => ({
-          ...other,
-          usedPercent: at === index ? 100 : 0,
-          remainingPercent: at === index ? 0 : 100,
-          checkedAt: now,
-        })),
-      },
-      now,
-    )
-    const piece = quotaTextParts(probe, { now, form: 'narrow' })[0]
-    const name = piece?.replace(/ 0% left$/, '')
-    return name && name !== piece ? name : window.title
-  })
+  if (!scoped.length) return []
+  const { windows } = quotaWindowParts(
+    quotaDisplayProjection({ scoped }, now),
+    { now },
+  )
+  return scoped.map(
+    (window) =>
+      windows.find(
+        (part) => part.kind === 'window' && part.name === window.title,
+      )?.short || window.title,
+  )
 }
 
 /**

package/src/tui/command-dialogs.tsx

@@ -9,6 +9,7 @@ import type {
   MenuAction,
   MenuItem,
   MenuSection,
+  NativeCommandApplyResult,
 } from '@cortexkit/anthropic-auth-core'
 import {
   custodyStatusLabel,
@@ -18,6 +19,7 @@ import type { TuiPluginApi } from '@opencode-ai/plugin/tui'
 import type { AccountDialogAccount } from '../rpc/protocol'
 import type { OpenDialogPayload } from '../rpc/protocol.js'
 import { formatPrimeCost, formatPrimeTime } from '../sidebar-state.js'
+import { SIGN_IN_LINK_TITLE, SignInLink } from './sign-in-link.js'
 
 /** Render menu sections, accounts and action inputs; send changes to the host instead of writing credentials here. */
 export function openNativeMenuDialog(
@@ -128,6 +130,24 @@ export function openNativeMenuDialog(
     ))
   }
 
+  /** The sign-in link stays on screen until the person goes back or closes it. */
+  const showSignIn = (url: string, back: () => void) => {
+    if (!active()) return
+    api.ui.dialog.setSize('xlarge')
+    api.ui.dialog.replace(() => (
+      <box flexDirection='column' paddingTop={1}>
+        <SignInLink url={url} title={SIGN_IN_LINK_TITLE} />
+        <DialogSelect
+          title='Continue'
+          options={[{ title: 'Back', value: '__back' }]}
+          onSelect={() => {
+            if (active()) back()
+          }}
+        />
+      </box>
+    ))
+  }
+
   const collect = (
     section: MenuSection,
     action: MenuAction,
@@ -142,8 +162,12 @@ export function openNativeMenuDialog(
     const submit = async () => {
       if (!active()) return
       inFlight = true
+      // Set after a successful OAuth start: its link is shown in a lasting
+      // dialog instead of a toast, which would vanish before it could be
+      // copied and sit behind the menu.
+      let signInUrl: string | undefined
       try {
-        const result = await apply({
+        const result: NativeCommandApplyResult = await apply({
           command: menu.command,
           sectionId: section.id,
           actionId: action.id,
@@ -153,7 +177,9 @@ export function openNativeMenuDialog(
         })
         if (!isCurrentSession()) return
         menu = result.menu
-        api.ui.toast({ message: result.text })
+        if (typeof result.authorizationUrl === 'string')
+          signInUrl = result.authorizationUrl
+        else api.ui.toast({ message: result.text })
       } catch {
         if (isCurrentSession())
           api.ui.toast({ message: 'Menu apply unavailable; outcome unknown.' })
@@ -164,8 +190,9 @@ export function openNativeMenuDialog(
           const refreshed = menu.sections.find(
             (entry) => entry.id === section.id,
           )
-          if (refreshed) showSection(refreshed)
-          else root()
+          const back = () => (refreshed ? showSection(refreshed) : root())
+          if (signInUrl !== undefined) showSignIn(signInUrl, back)
+          else back()
         }
       }
     }
@@ -1111,43 +1138,50 @@ export function openCommandDialog(
       const DialogSelect = api.ui.DialogSelect<string>
       api.ui.dialog.setSize('xlarge')
       api.ui.dialog.replace(() => (
-        <DialogSelect
-          title='OAuth sign-in'
-          options={[
-            {
-              title: 'Copy URL to clipboard',
-              value: 'copy',
-              description: oauthUrl,
-            },
-            {
-              title: 'Enter sign-in code',
-              value: 'code',
-              description:
-                'Open the URL in your browser, sign in, then paste the callback URL or code',
-            },
-            { title: 'Cancel', value: 'cancel' },
-          ]}
-          onSelect={(option) => {
-            if (option.value === 'cancel') {
-              buildL1()
-              return
-            }
-            if (option.value === 'copy') {
-              const ok = api.renderer.copyToClipboardOSC52(oauthUrl)
-              if (ok) {
-                api.ui.toast({ message: 'URL copied to clipboard' })
-              } else {
-                api.ui.toast({
-                  message:
-                    'Copy unavailable \u2014 select the URL text above to copy',
-                })
+        <box flexDirection='column' paddingTop={1}>
+          {/* The link sits above the options on rows of its own, so it can
+              be selected and copied whole when the copy option fails. */}
+          <SignInLink
+            url={oauthUrl}
+            instructions='Open this link in your browser and sign in, then choose Enter sign-in code and paste the callback URL or code.'
+          />
+          <DialogSelect
+            title='OAuth sign-in'
+            options={[
+              {
+                title: 'Copy URL to clipboard',
+                value: 'copy',
+              },
+              {
+                title: 'Enter sign-in code',
+                value: 'code',
+                description:
+                  'Open the URL in your browser, sign in, then paste the callback URL or code',
+              },
+              { title: 'Cancel', value: 'cancel' },
+            ]}
+            onSelect={(option) => {
+              if (option.value === 'cancel') {
+                buildL1()
+                return
               }
-              openOAuthUrlScreen(oauthUrl)
-              return
-            }
-            openOAuthCodePrompt(oauthUrl)
-          }}
-        />
+              if (option.value === 'copy') {
+                const ok = api.renderer.copyToClipboardOSC52(oauthUrl)
+                if (ok) {
+                  api.ui.toast({ message: 'URL copied to clipboard' })
+                } else {
+                  api.ui.toast({
+                    message:
+                      'Copy unavailable \u2014 select the URL text above to copy',
+                  })
+                }
+                openOAuthUrlScreen(oauthUrl)
+                return
+              }
+              openOAuthCodePrompt(oauthUrl)
+            }}
+          />
+        </box>
       ))
     }
 

package/src/tui/entry.mjs

@@ -48,6 +48,17 @@ async function loadSidebar() {
   return import('../tui-compiled/tui/claude-sidebar.tsx')
 }
 
+// The OAuth sign-in link dialog, loaded the same way as the sidebar.
+async function loadSignInLink() {
+  try {
+    await import(runtimeProbe)
+  } catch (error) {
+    if (!isMissingRuntimeRegistry(error)) throw error
+    return import('./sign-in-link.tsx')
+  }
+  return import('../tui-compiled/tui/sign-in-link.tsx')
+}
+
 let legacyModule
 
 // OpenCode 1 reads id and tui from the default definition; OpenCode 2 reads
@@ -71,6 +82,8 @@ export const setup = async (context) => {
   return setupAnthropicTui(context, {
     mountSidebar: async (ctx, read) =>
       (await loadSidebar()).mountClaudeSidebar(ctx, read),
+    showSignInLink: async (ctx, url, signal) =>
+      (await loadSignInLink()).showSignInLinkDialog(ctx, url, signal),
   })
 }
 

package/src/tui/sign-in-link.tsx

@@ -0,0 +1,109 @@
+/** @jsxImportSource @opentui/solid */
+
+// The OAuth sign-in link dialog, shared by the OpenCode 1 and OpenCode 2 TUIs.
+// The link is drawn as its own text block with nothing beside it, so however
+// narrow the dialog is, the rows it wraps onto hold only link characters and
+// selecting those rows copies the whole link. The dialog stays open until the
+// person closes it.
+
+import type { RGBA } from '@opentui/core'
+import type { JSX } from 'solid-js'
+
+export type SignInLinkColor = RGBA | string
+
+/** Optional text colors; without them the host's default text color is used. */
+export interface SignInLinkColors {
+  readonly text?: SignInLinkColor
+  readonly muted?: SignInLinkColor
+  readonly link?: SignInLinkColor
+}
+
+export const SIGN_IN_LINK_TITLE = 'Claude sign-in'
+export const SIGN_IN_LINK_INSTRUCTIONS =
+  'Open this link in your browser and sign in. Then choose Finish OAuth sign-in in the Accounts menu and paste the code Claude shows you.'
+
+/** The sign-in instructions and the link, without any dialog chrome. */
+export function SignInLink(props: {
+  readonly url: string
+  readonly colors?: SignInLinkColors
+  /** A heading above the instructions; hosts whose dialog has one omit it. */
+  readonly title?: string
+  /** What to do with the link; defaults to the native menu's next step. */
+  readonly instructions?: string
+  /** A line under the link, such as how to close the dialog. */
+  readonly footer?: string
+}): JSX.Element {
+  return (
+    <box flexDirection='column' paddingLeft={2} paddingRight={2}>
+      {props.title ? (
+        <box paddingBottom={1}>
+          <text fg={props.colors?.text}>{props.title}</text>
+        </box>
+      ) : null}
+      <text fg={props.colors?.muted}>
+        {props.instructions ?? SIGN_IN_LINK_INSTRUCTIONS}
+      </text>
+      <box paddingTop={1} paddingBottom={1}>
+        {/* Character wrapping fills every row: a link has no spaces to
+            break at, and a word break would leave a short row. */}
+        <text fg={props.colors?.link} wrapMode='char'>
+          {props.url}
+        </text>
+      </box>
+      {props.footer ? (
+        <text fg={props.colors?.muted}>{props.footer}</text>
+      ) : null}
+    </box>
+  )
+}
+
+// --- OpenCode 2 -------------------------------------------------------------
+
+/** The OpenCode 2 TUI context members the sign-in dialog uses. */
+export interface SignInLinkHost {
+  readonly theme: {
+    readonly text: {
+      readonly base: SignInLinkColor
+      readonly muted: SignInLinkColor
+      readonly action: { readonly primary: { readonly base: SignInLinkColor } }
+    }
+  }
+  readonly ui: {
+    readonly dialog: {
+      show(render: () => JSX.Element, onClose?: () => void): void
+      set(options: { readonly size?: 'medium' | 'large' | 'xlarge' }): void
+    }
+  }
+}
+
+/**
+ * Shows the sign-in link in an OpenCode 2 dialog. The returned promise
+ * settles when the person closes the dialog, or when `signal` aborts.
+ */
+export function showSignInLinkDialog(
+  host: SignInLinkHost,
+  url: string,
+  signal?: AbortSignal,
+): Promise<void> {
+  return new Promise((resolve) => {
+    if (signal?.aborted) return resolve()
+    signal?.addEventListener('abort', () => resolve(), { once: true })
+    host.ui.dialog.show(
+      () => (
+        <SignInLink
+          url={url}
+          title={SIGN_IN_LINK_TITLE}
+          colors={{
+            text: host.theme.text.base,
+            muted: host.theme.text.muted,
+            link: host.theme.text.action.primary.base,
+          }}
+          footer='Press Esc to close.'
+        />
+      ),
+      () => resolve(),
+    )
+    // The widest dialog wraps the link onto the fewest rows.
+    host.ui.dialog.set({ size: 'xlarge' })
+  })
+}

package/src/tui-compiled/sidebar-state.ts

@@ -132,7 +132,7 @@ import {
   isQuotaStale,
   logger,
   quotaDisplayProjection,
-  quotaTextParts,
+  quotaWindowParts,
 } from '@cortexkit/anthropic-auth-core'
 
 const STATE_FILE_ENV = 'OPENCODE_ANTHROPIC_AUTH_SIDEBAR_STATE_FILE'
@@ -954,38 +954,30 @@ export function formatQuotaRowLabel(name: string, width = 10): string {
 
 /**
  * The short names model-scoped rows read under, in the order of `quota.scoped`:
- * the names common-auth's narrow one-line form gives them (`Fa` for Fable;
- * models whose short names would collide are extended until they differ, as
- * `Fabl` and `Fabr`), so the expanded rows and the collapsed line agree.
- *
- * common-auth exposes that short name only inside the narrow text, and the
- * narrow line shows just one model window (the tightest). So each window's
- * name is read from a narrow line of a copy of the reading in which that
- * window alone is spent: every model window stays in, so collisions resolve
- * exactly as they do in the real line, and the one piece the line shows is
- * `<short name> 0% left`. The figures in the copy are never displayed.
+ * each window part's `short`, the same label common-auth's narrow one-line
+ * form uses (`Fa` for Fable; models whose short names would collide are
+ * extended until they differ, as `Fabl` and `Fabr`), so the expanded rows and
+ * the collapsed line agree. Short names are worked out over every model window
+ * in the reading, so all scoped windows are projected together. A part is
+ * matched to its window by the window's title, which is the name a
+ * model-scoped part carries; a window with no part keeps its title.
  */
 export function scopedQuotaShortNames(
   quota: Pick<AccountQuota, 'scoped'> | null | undefined,
   now = Date.now(),
 ): string[] {
   const scoped = quota?.scoped ?? []
-  return scoped.map((window, index) => {
-    const probe = quotaDisplayProjection(
-      {
-        scoped: scoped.map((other, at) => ({
-          ...other,
-          usedPercent: at === index ? 100 : 0,
-          remainingPercent: at === index ? 0 : 100,
-          checkedAt: now,
-        })),
-      },
-      now,
-    )
-    const piece = quotaTextParts(probe, { now, form: 'narrow' })[0]
-    const name = piece?.replace(/ 0% left$/, '')
-    return name && name !== piece ? name : window.title
-  })
+  if (!scoped.length) return []
+  const { windows } = quotaWindowParts(
+    quotaDisplayProjection({ scoped }, now),
+    { now },
+  )
+  return scoped.map(
+    (window) =>
+      windows.find(
+        (part) => part.kind === 'window' && part.name === window.title,
+      )?.short || window.title,
+  )
 }
 
 /**