dsh-code 1.0.7 → 1.3.0

package/src/approval.ts

@@ -1,166 +1,166 @@
-/**
- * The terminal approval answerer: one `approval/request` waterfall listener
- * that renders the pending question as a y/n bar and resolves the decision
- * back into the waterfall. Mirrors the web host's composer takeover — the
- * service (audit pair, policy gate, fail-closed defaults) all live in
- * dsh-base; this module only answers for agents this TUI owns.
- *
- * Vocabulary note: a client answerer may only ever resolve `'allowed-once'`
- * or `'rejected'`; `'cancelled'` belongs to the request signal and
- * `'unavailable'` to the fail-closed waterfall default.
- *
- * @module @deepseek-ai/dsh-code/approval
- */
-
-import type { Context } from '@deepseek-ai/cordis'
-import type { Agent } from '@deepseek-ai/dsh-agent'
-import type { ApprovalOutcome, ApprovalRequest } from '@deepseek-ai/dsh-user-approval'
-
-/** The answer values a client answerer may resolve with. */
-export type ApprovalAnswer = 'allowed-once' | 'rejected'
-
-/** One pending approval question, derived from the request for rendering. */
-export interface PendingApproval {
-  /** The asker's human-readable explanation, or a generic fallback. */
-  headline: string
-  /** The tool the question is about. */
-  toolName: string
-  /** Command-line preview resolved from the paired streaming tool call. */
-  command: string
-  /** Resolve the ask; calling twice is inert (one-shot latch). */
-  answer(outcome: ApprovalAnswer): void
-}
-
-/** The pending-question snapshot the renderer subscribes to. */
-export interface ApprovalSnapshot {
-  /** The question on screen (queue head), or undefined when none is asked. */
-  pending: PendingApproval | undefined
-  /** Presentational: an answer was submitted, the ask has not settled yet. */
-  answered: boolean
-  /** Further asks waiting behind the on-screen one (FIFO, Codex-style). */
-  queued: number
-}
-
-/** Store the pending question lands in; the renderer reads, the answerer writes. */
-export interface ApprovalStore {
-  /** Subscribe to pending-state changes; returns the unsubscribe function. */
-  subscribe(listener: () => void): () => void
-  /** Read the current snapshot (identity-stable between changes). */
-  getSnapshot(): ApprovalSnapshot
-}
-
-/**
- * Create the approval store and mount the answerer listener on the context.
- * The listener claims only requests for `owns`-owned agents and defers every
- * other request back into the waterfall (`next()`), so sibling answerers stay
- * usable. An aborted ask never reaches the human. Plugin teardown removes the
- * listener; the service then fails its own question closed.
- * @param ctx - plugin context whose event bus carries `approval/request`.
- * @param owns - agents this terminal answers for.
- * @param preview - resolves a tool-call preview for a pending request (the
- * request contract carries no arguments; the UI self-serves from the
- * transcript projection via `callId`).
- * @returns the store the renderer subscribes to.
- */
-export function mountApprovalAnswerer(
-  ctx: Context,
-  owns: (agent: Agent) => boolean,
-  preview: (request: ApprovalRequest) => string,
-): ApprovalStore {
-  /** One live ask: its pending view plus the one-shot settle plumbing. */
-  interface Slot {
-    readonly pending: PendingApproval
-    answered: boolean
-  }
-  const queue: Slot[] = []
-  let snapshot: ApprovalSnapshot = { pending: undefined, answered: false, queued: 0 }
-  const listeners = new Set<() => void>()
-  const publish = (): void => {
-    const head = queue[0]
-    snapshot = {
-      pending: head === undefined ? undefined : head.pending,
-      answered: head !== undefined && head.answered,
-      queued: Math.max(0, queue.length - 1),
-    }
-    for (const listener of listeners) listener()
-  }
-  const removeSlot = (slot: Slot): void => {
-    const at = queue.indexOf(slot)
-    if (at !== -1) queue.splice(at, 1)
-  }
-
-  ctx.on('approval/request', (request: ApprovalRequest, next: () => Promise<ApprovalOutcome>) => {
-    if (!owns(request.agent)) return next()
-    // An already-aborted ask never reaches the human (mirrors the host bridge).
-    if (request.signal?.aborted === true) return Promise.resolve<ApprovalOutcome>('cancelled')
-
-    let resolved = false
-    let settle!: (outcome: ApprovalOutcome) => void
-    // Established BEFORE the abort listener mounts: a synchronous throw
-    // between the listener registration and a later construction site would
-    // otherwise leave a subsequent abort invoking an unassigned settle from
-    // inside the AbortSignal listener (an uncaughtException).
-    const settled = new Promise<ApprovalOutcome>((resolve) => {
-      settle = resolve
-    })
-    const signal = request.signal
-    const onAbort = (): void => withdraw()
-    // Detach on every settle so an answered ask never retains a listener on
-    // the tool call's signal (long turns ask many times; each ask must let go).
-    const detachAbort = (): void => {
-      if (signal !== undefined) signal.removeEventListener('abort', onAbort)
-    }
-    const withdraw = (): void => {
-      if (resolved) return
-      resolved = true
-      detachAbort()
-      removeSlot(slot)
-      publish()
-      // The service's signal race would conclude 'cancelled' anyway; settle
-      // the same way so this listener never dangles a pending promise.
-      settle('cancelled')
-    }
-    if (signal !== undefined) {
-      signal.addEventListener('abort', onAbort, { once: true })
-    }
-    const slot: Slot = {
-      answered: false,
-      pending: {
-        headline: request.reason ?? `tool ${request.toolName} asks for your approval`,
-        toolName: request.toolName,
-        command: preview(request),
-        answer: (outcome: ApprovalAnswer): void => {
-          // One-shot latch: a second keypress after submission is inert.
-          if (resolved) return
-          resolved = true
-          detachAbort()
-          slot.answered = true
-          publish()
-          settle(outcome)
-        },
-      },
-    }
-    queue.push(slot)
-    publish()
-
-    return settled.then((outcome) => {
-      if (outcome !== 'cancelled') {
-        removeSlot(slot)
-        publish()
-      }
-      return outcome
-    })
-  })
-
-  return {
-    subscribe(listener: () => void): () => void {
-      listeners.add(listener)
-      return () => {
-        listeners.delete(listener)
-      }
-    },
-    getSnapshot(): ApprovalSnapshot {
-      return snapshot
-    },
-  }
-}
+/**
+ * The terminal approval answerer: one `approval/request` waterfall listener
+ * that renders the pending question as a y/n bar and resolves the decision
+ * back into the waterfall. Mirrors the web host's composer takeover — the
+ * service (audit pair, policy gate, fail-closed defaults) all live in
+ * dsh-base; this module only answers for agents this TUI owns.
+ *
+ * Vocabulary note: a client answerer may only ever resolve `'allowed-once'`
+ * or `'rejected'`; `'cancelled'` belongs to the request signal and
+ * `'unavailable'` to the fail-closed waterfall default.
+ *
+ * @module @deepseek-ai/dsh-code/approval
+ */
+
+import type { Context } from '@deepseek-ai/cordis'
+import type { Agent } from '@deepseek-ai/dsh-agent'
+import type { ApprovalOutcome, ApprovalRequest } from '@deepseek-ai/dsh-user-approval'
+
+/** The answer values a client answerer may resolve with. */
+export type ApprovalAnswer = 'allowed-once' | 'rejected'
+
+/** One pending approval question, derived from the request for rendering. */
+export interface PendingApproval {
+  /** The asker's human-readable explanation, or a generic fallback. */
+  headline: string
+  /** The tool the question is about. */
+  toolName: string
+  /** Command-line preview resolved from the paired streaming tool call. */
+  command: string
+  /** Resolve the ask; calling twice is inert (one-shot latch). */
+  answer(outcome: ApprovalAnswer): void
+}
+
+/** The pending-question snapshot the renderer subscribes to. */
+export interface ApprovalSnapshot {
+  /** The question on screen (queue head), or undefined when none is asked. */
+  pending: PendingApproval | undefined
+  /** Presentational: an answer was submitted, the ask has not settled yet. */
+  answered: boolean
+  /** Further asks waiting behind the on-screen one (FIFO, Codex-style). */
+  queued: number
+}
+
+/** Store the pending question lands in; the renderer reads, the answerer writes. */
+export interface ApprovalStore {
+  /** Subscribe to pending-state changes; returns the unsubscribe function. */
+  subscribe(listener: () => void): () => void
+  /** Read the current snapshot (identity-stable between changes). */
+  getSnapshot(): ApprovalSnapshot
+}
+
+/**
+ * Create the approval store and mount the answerer listener on the context.
+ * The listener claims only requests for `owns`-owned agents and defers every
+ * other request back into the waterfall (`next()`), so sibling answerers stay
+ * usable. An aborted ask never reaches the human. Plugin teardown removes the
+ * listener; the service then fails its own question closed.
+ * @param ctx - plugin context whose event bus carries `approval/request`.
+ * @param owns - agents this terminal answers for.
+ * @param preview - resolves a tool-call preview for a pending request (the
+ * request contract carries no arguments; the UI self-serves from the
+ * transcript projection via `callId`).
+ * @returns the store the renderer subscribes to.
+ */
+export function mountApprovalAnswerer(
+  ctx: Context,
+  owns: (agent: Agent) => boolean,
+  preview: (request: ApprovalRequest) => string,
+): ApprovalStore {
+  /** One live ask: its pending view plus the one-shot settle plumbing. */
+  interface Slot {
+    readonly pending: PendingApproval
+    answered: boolean
+  }
+  const queue: Slot[] = []
+  let snapshot: ApprovalSnapshot = { pending: undefined, answered: false, queued: 0 }
+  const listeners = new Set<() => void>()
+  const publish = (): void => {
+    const head = queue[0]
+    snapshot = {
+      pending: head === undefined ? undefined : head.pending,
+      answered: head !== undefined && head.answered,
+      queued: Math.max(0, queue.length - 1),
+    }
+    for (const listener of listeners) listener()
+  }
+  const removeSlot = (slot: Slot): void => {
+    const at = queue.indexOf(slot)
+    if (at !== -1) queue.splice(at, 1)
+  }
+
+  ctx.on('approval/request', (request: ApprovalRequest, next: () => Promise<ApprovalOutcome>) => {
+    if (!owns(request.agent)) return next()
+    // An already-aborted ask never reaches the human (mirrors the host bridge).
+    if (request.signal?.aborted === true) return Promise.resolve<ApprovalOutcome>('cancelled')
+
+    let resolved = false
+    let settle!: (outcome: ApprovalOutcome) => void
+    // Established BEFORE the abort listener mounts: a synchronous throw
+    // between the listener registration and a later construction site would
+    // otherwise leave a subsequent abort invoking an unassigned settle from
+    // inside the AbortSignal listener (an uncaughtException).
+    const settled = new Promise<ApprovalOutcome>((resolve) => {
+      settle = resolve
+    })
+    const signal = request.signal
+    const onAbort = (): void => withdraw()
+    // Detach on every settle so an answered ask never retains a listener on
+    // the tool call's signal (long turns ask many times; each ask must let go).
+    const detachAbort = (): void => {
+      if (signal !== undefined) signal.removeEventListener('abort', onAbort)
+    }
+    const withdraw = (): void => {
+      if (resolved) return
+      resolved = true
+      detachAbort()
+      removeSlot(slot)
+      publish()
+      // The service's signal race would conclude 'cancelled' anyway; settle
+      // the same way so this listener never dangles a pending promise.
+      settle('cancelled')
+    }
+    if (signal !== undefined) {
+      signal.addEventListener('abort', onAbort, { once: true })
+    }
+    const slot: Slot = {
+      answered: false,
+      pending: {
+        headline: request.reason ?? `tool ${request.toolName} asks for your approval`,
+        toolName: request.toolName,
+        command: preview(request),
+        answer: (outcome: ApprovalAnswer): void => {
+          // One-shot latch: a second keypress after submission is inert.
+          if (resolved) return
+          resolved = true
+          detachAbort()
+          slot.answered = true
+          publish()
+          settle(outcome)
+        },
+      },
+    }
+    queue.push(slot)
+    publish()
+
+    return settled.then((outcome) => {
+      if (outcome !== 'cancelled') {
+        removeSlot(slot)
+        publish()
+      }
+      return outcome
+    })
+  })
+
+  return {
+    subscribe(listener: () => void): () => void {
+      listeners.add(listener)
+      return () => {
+        listeners.delete(listener)
+      }
+    },
+    getSnapshot(): ApprovalSnapshot {
+      return snapshot
+    },
+  }
+}

package/src/attachments.ts

@@ -52,17 +52,41 @@ export function looksLikeImagePath(path: string): boolean {
   return IMAGE_EXTENSIONS.has(extname(path).toLowerCase())
 }
 
+/** Strip one layer of ASCII or Unicode quotes and shell-escaped spaces. */
+export function unwrapDroppedPath(token: string): string {
+  const trimmed = token.trim()
+  const wrapped = /^[\u2018\u201C"'](.+)[\u2019\u201D"']$/u.exec(trimmed)
+  return (wrapped?.[1] ?? trimmed).replace(/\\ /gu, ' ')
+}
+
+/** Absolute/relative drop with a dotted leaf — including unquoted spaces. */
+export function looksLikeFilesystemDrop(path: string): boolean {
+  if (path.startsWith('file://')) return true
+  if (!/^(?:\/|[A-Za-z]:[\\/]|\\\\|\.\.?\/)/u.test(path)) return false
+  return looksLikeImagePath(path) || /\.[A-Za-z0-9]{1,16}$/u.test(path)
+}
+
 /**
- * Parse a paste/drop into its image and file paths: image-suffixed tokens
- * stay images, other path-shaped tokens ride as file attachments (0.1.5
- * file blocks), and anything that is neither leaves both empty — the caller
- * then treats the paste as plain text.
+ * A composer draft that is a filesystem path, not a slash command.
+ * `/usage` stays a command; `/Users/foo.png` and `C:\temp\a.png` are drops.
+ */
+export function looksLikePathDraft(value: string): boolean {
+  const path = unwrapDroppedPath(value)
+  if (looksLikeFilesystemDrop(path)) return true
+  return /^\/(?:Users|home|tmp|var|etc|opt|mnt|Volumes)\//u.test(path)
+}
+
+/**
+ * Parse a paste or file-drop into image and file paths: image-suffixed
+ * tokens stay images, other path-shaped tokens ride as file attachments
+ * (0.1.5 file blocks), and anything that is neither leaves both empty —
+ * the caller then treats the paste as plain text.
  *
  * File tokens are held to an absolute-path-with-shape bar (drive/backslash
- * or a dot-suffixed leaf after a separator): a dropped terminal path always
+ * or a dotted leaf after a separator): a dropped terminal path always
  * carries one of those, while prose, slash commands, and option flags never
- * do. A POSIX absolute path without any dot-suffixed leaf falls through as
- * text — the @ mention route still attaches such files deliberately.
+ * do. A POSIX absolute path without a dotted leaf falls through as text —
+ * the @ mention route still attaches such files deliberately.
  */
 export function parsePastedAttachmentPaths(input: string): { readonly images: readonly string[]; readonly files: readonly string[] } {
   const text = input.trim()
@@ -73,27 +97,49 @@ export function parsePastedAttachmentPaths(input: string): { readonly images: re
     /^[A-Za-z]:[\\/]/u.test(path)
     || /^\\\\/u.test(path)
     || (/^\/|^\.\.?\//u.test(path) && /\.[A-Za-z0-9]{1,16}$/u.test(path))
-  const matcher = /"([^"]+)"|'([^']+)'|(\S+)/gu
-  for (const match of text.matchAll(matcher)) {
-    const token = match[1] ?? match[2] ?? match[3]
-    if (token === undefined) continue
-    let path = token
+  const classify = (raw: string): 'image' | 'file' | 'reject' => {
+    let path = unwrapDroppedPath(raw)
     if (path.startsWith('file://')) {
       try {
         path = fileURLToPath(path)
       } catch {
-        return { images: [], files: [] }
+        return 'reject'
+      }
+    } else if (/%[0-9A-Fa-f]{2}/u.test(path)) {
+      try {
+        path = decodeURIComponent(path)
+      } catch {
+        // Keep the raw token when it is not a valid percent-encoding.
       }
-      if (looksLikeImagePath(path)) images.push(path)
-      else files.push(path)
-      continue
     }
     if (looksLikeImagePath(path)) {
       images.push(path)
-      continue
+      return 'image'
+    }
+    if (looksLikeDroppedFile(path) || looksLikeFilesystemDrop(path)) {
+      files.push(path)
+      return 'file'
     }
-    if (!looksLikeDroppedFile(path)) return { images: [], files: [] }
-    files.push(path)
+    return 'reject'
+  }
+  // A single dropped path with spaces often arrives unquoted (macOS, Windows
+  // Explorer, VS Code sendText). Use the whole paste only when there is one
+  // path start and the text actually contains spaces (or wrapping quotes) —
+  // two unquoted `C:\a.png D:\b.txt` tokens must still split.
+  const whole = unwrapDroppedPath(text)
+  const pathStarts = text.match(/(?:^|[\s"'])(?:\/|[A-Za-z]:[\\/]|\\\\|\.\.?\/|file:\/\/)/gu) ?? []
+  const spacedSingleton = pathStarts.length <= 1
+    && looksLikeFilesystemDrop(whole)
+    && (/\s/u.test(whole) || /^[\u2018\u201C"']/u.test(text))
+  if (spacedSingleton) {
+    classify(whole)
+    return { images, files }
+  }
+  const matcher = /"([^"]+)"|'([^']+)'|(\S+)/gu
+  for (const match of text.matchAll(matcher)) {
+    const token = match[1] ?? match[2] ?? match[3]
+    if (token === undefined) continue
+    if (classify(token) === 'reject') return { images: [], files: [] }
   }
   return { images, files }
 }

package/src/authorization-panel.ts

@@ -13,7 +13,9 @@ import type { CredentialKey } from '@deepseek-ai/dsh-credentials'
 import type { ProviderAuthorizationRow } from './authorization.ts'
 import { panelViewport } from './render/inspector.ts'
 import { displayText, singleLineText, truncateColumns } from './render/text.ts'
+import { panelAccent } from './panel-accent.ts'
 import { getPalette, inkColor } from './theme.ts'
+import { t } from './i18n.ts'
 
 interface PromptReply {
   readonly resolve: (value: string) => void
@@ -73,14 +75,17 @@ export function ProviderAuthorizationPanel(props: ProviderAuthorizationPanelProp
     decline()
   }
 
+  const propsRef = useRef(props)
+  propsRef.current = props
+  const rowKey = props.row.key
   useEffect(() => () => {
     controllerRef.current?.abort()
-    props.cancel(props.row.key)
+    propsRef.current.cancel(rowKey)
     const reply = replyRef.current
     replyRef.current = undefined
     reply?.detach()
     reply?.reject(new AuthorizationDeclinedError())
-  }, [props.row.key])
+  }, [rowKey])
 
   const start = (method: string): void => {
     setPhase('running')
@@ -154,7 +159,7 @@ export function ProviderAuthorizationPanel(props: ProviderAuthorizationPanelProp
         setCursor(current => (current + 1) % props.row.methods.length)
         return
       }
-      if (key.return) start(props.row.methods[cursor]?.id ?? props.row.methods[0]!.id)
+      if (key.return) start(props.row.methods[cursor]?.id ?? props.row.methods[0].id)
       return
     }
 
@@ -182,7 +187,7 @@ export function ProviderAuthorizationPanel(props: ProviderAuthorizationPanelProp
         setPromptCursor(current => (current + 1) % prompt.options.length)
         return
       }
-      if (key.return) answer(prompt.options[promptCursor]?.id ?? prompt.options[0]!.id)
+      if (key.return) answer(prompt.options[promptCursor]?.id ?? prompt.options[0].id)
       return
     }
     if (key.backspace || key.delete) {
@@ -197,7 +202,7 @@ export function ProviderAuthorizationPanel(props: ProviderAuthorizationPanelProp
   })
 
   if (viewport.maxHeight === 0 || viewport.compact) {
-    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns('provider login · esc cancel', viewport.contentColumns))
+    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(t('panel.auth.compact'), viewport.contentColumns))
   }
 
   const rows: Array<{ key: string; text: string; color?: string; bold?: boolean }> = []
@@ -229,18 +234,19 @@ export function ProviderAuthorizationPanel(props: ProviderAuthorizationPanelProp
         rows.push({ key: 'draft', text: `  ${shown}▏`, color: inkColor(getPalette().text) })
       }
     } else {
-      rows.push({ key: 'waiting', text: '  waiting for provider…', color: inkColor(getPalette().dim) })
+      rows.push({ key: 'waiting', text: `  ${t('panel.auth.waiting')}`, color: inkColor(getPalette().dim) })
     }
     if (copyState !== undefined) rows.push({ key: 'copy', text: `  ${singleLineText(copyState)}`, color: inkColor(copyState === 'copied' ? getPalette().success : getPalette().error) })
   }
   const visible = rows.slice(Math.max(0, rows.length - viewport.bodyRows))
   const footer = phase === 'methods'
-    ? '↑↓ choose · enter continue · esc/q back'
-    : 'enter answer · c copy URL/code · esc cancel login'
+    ? t('panel.auth.methodsFooter')
+    : t('panel.auth.answerFooter')
+  const accent = panelAccent('auth-login', getPalette().brand)
   return createElement(
     Box,
-    { flexDirection: 'column', width: viewport.outerColumns, paddingX: 1, borderStyle: 'round', borderColor: inkColor(getPalette().brand) },
-    createElement(Text, { color: inkColor(getPalette().brand), bold: true, wrap: 'truncate-end' }, truncateColumns(`/model · login ${displayText(props.row.label)}`, viewport.contentColumns)),
+    { flexDirection: 'column', width: viewport.outerColumns, paddingX: 1, borderStyle: 'round', borderColor: inkColor(accent.border) },
+    createElement(Text, { color: inkColor(accent.title), bold: true, wrap: 'truncate-end' }, truncateColumns(t('panel.auth.title', { provider: displayText(props.row.label) }), viewport.contentColumns)),
     ...visible.map(row => createElement(Text, { key: row.key, color: row.color, bold: row.bold, wrap: 'truncate-end' }, truncateColumns(row.text, viewport.contentColumns))),
     createElement(Text, { color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(footer, viewport.contentColumns)),
   )
@@ -248,9 +254,9 @@ export function ProviderAuthorizationPanel(props: ProviderAuthorizationPanelProp
 
 export function ProviderAuthorizationLogoutPanel({ row, confirm, done, back }: {
   row: ProviderAuthorizationRow
-  confirm(row: ProviderAuthorizationRow): Promise<void>
-  done(): void
-  back(): void
+  confirm: (row: ProviderAuthorizationRow) => Promise<void>
+  done: () => void
+  back: () => void
 }): ReactElement {
   const stdout = useStdout().stdout
   const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30)
@@ -270,14 +276,14 @@ export function ProviderAuthorizationLogoutPanel({ row, confirm, done, back }: {
       setError(reason instanceof Error ? reason.message : String(reason))
     })
   })
-  if (viewport.maxHeight === 0 || viewport.compact) return createElement(Text, { wrap: 'truncate-end' }, truncateColumns('y logout · n/esc back', viewport.contentColumns))
+  if (viewport.maxHeight === 0 || viewport.compact) return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(t('panel.auth.logoutCompact'), viewport.contentColumns))
   return createElement(
     Box,
     { flexDirection: 'column', width: viewport.outerColumns, paddingX: 1, borderStyle: 'round', borderColor: inkColor(getPalette().warn) },
-    createElement(Text, { color: inkColor(getPalette().warn), bold: true, wrap: 'truncate-end' }, truncateColumns('/model · logout provider', viewport.contentColumns)),
-    createElement(Text, { wrap: 'truncate-end' }, truncateColumns(`  remove ${displayText(row.label)} login record`, viewport.contentColumns)),
-    createElement(Text, { color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns('  provider endpoint and model configuration stay unchanged', viewport.contentColumns)),
+    createElement(Text, { color: inkColor(getPalette().warn), bold: true, wrap: 'truncate-end' }, truncateColumns(t('panel.auth.logoutTitle'), viewport.contentColumns)),
+    createElement(Text, { wrap: 'truncate-end' }, truncateColumns(`  ${t('panel.auth.removeRecord', { provider: displayText(row.label) })}`, viewport.contentColumns)),
+    createElement(Text, { color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(`  ${t('panel.auth.unchanged')}`, viewport.contentColumns)),
     error === undefined ? undefined : createElement(Text, { color: inkColor(getPalette().error), wrap: 'truncate-end' }, truncateColumns(`  ${singleLineText(error)}`, viewport.contentColumns)),
-    createElement(Text, { color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(busy ? 'working…' : 'y confirm · n/esc back', viewport.contentColumns)),
+    createElement(Text, { color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(busy ? t('panel.auth.working') : t('panel.auth.logoutFooter'), viewport.contentColumns)),
   )
 }