saeeol 1.1.0 → 1.1.1

package/src/saeeol/cli/cmd/roll-call-format.ts

@@ -0,0 +1,55 @@
+import type { Provider } from "../../../provider/provider"
+
+const HEADERS = ["Model", "Access", "Snippet", "Latency"]
+const PADDING = 9
+
+const tty = process.stderr.isTTY ?? false
+
+function color(style: string): string {
+  return tty ? style : ""
+}
+
+function sanitize(text: string): string {
+  return text.replace(/\x1b\[[0-9;]*m/g, "").replace(/[\x00-\x1f\x7f]/g, "")
+}
+
+function truncate(text: string, max: number): string {
+  if (max < 4) return text.substring(0, max)
+  return text.length > max ? text.substring(0, max - 3) + "..." : text
+}
+
+export function formatTable(rows: string[][], width: number): { header: string; separator: string; rows: string[] } {
+  const clean = rows.map((row) => row.map((cell) => sanitize(cell ?? "")))
+  const widths = HEADERS.map((h, i) => Math.max(h.length, ...clean.map((row) => row[i].length)))
+  const total = widths.reduce((sum, item) => sum + item, 0) + PADDING
+  const min = HEADERS[2].length + 3
+
+  if (total > width && widths[2] > min) {
+    const overflow = total - width
+    widths[2] = Math.max(min, widths[2] - overflow)
+  }
+
+  const header = HEADERS.map((h, i) => h.padEnd(widths[i])).join(" | ")
+  const separator = "-".repeat(header.length)
+  const body = clean.map((row) => {
+    const current = [row[0], row[1], row[2] ? truncate(row[2], widths[2]) : row[2], row[3]]
+    return current.map((cell, i) => cell.padEnd(widths[i])).join(" | ")
+  })
+
+  return { header, separator, rows: body }
+}
+
+export function formatMarkdown(rows: string[][]): string {
+  const escaped = rows.map((row) => row.map((cell) => sanitize(cell ?? "").replace(/\|/g, "\\|")))
+  const widths = HEADERS.map((h, i) => Math.max(h.length, ...escaped.map((row) => row[i].length)))
+  const pad = (text: string, i: number) => text.padEnd(widths[i])
+  const header = "| " + HEADERS.map((h, i) => pad(h, i)).join(" | ") + " |"
+  const separator = "| " + widths.map((w) => "-".repeat(w)).join(" | ") + " |"
+  const body = escaped.map((row) => "| " + row.map((cell, i) => pad(cell, i)).join(" | ") + " |")
+
+  return [header, separator, ...body].join("\n")
+}
+
+export function isTextModel(model: Provider.Model): boolean {
+  return model.capabilities.input.text && model.capabilities.output.text
+}

package/src/saeeol/cli/cmd/roll-call.ts

@@ -0,0 +1,218 @@
+import type { Argv } from "yargs"
+import { Instance } from "../../../project/instance"
+import { Provider } from "../../../provider/provider"
+import { cmd } from "../../../cli/cmd/cmd"
+import { UI } from "../../../cli/ui"
+import { formatTable, formatMarkdown, isTextModel } from "./roll-call-format"
+import { call } from "./roll-call-call"
+import type { Result } from "./roll-call-call"
+
+export { formatTable, formatMarkdown, isTextModel } from "./roll-call-format"
+
+export const RollCallCommand = cmd({
+  command: "roll-call <filter>",
+  describe: "batch-test text models matching a filter for connectivity and latency",
+  builder: (yargs: Argv) => {
+    return yargs
+      .positional("filter", {
+        type: "string",
+        describe: "regex to filter models by provider/modelID (required)",
+        demandOption: true,
+      })
+      .option("prompt", {
+        type: "string",
+        default: "Hello",
+        describe: "Prompt to send to each model",
+      })
+      .option("timeout", {
+        type: "number",
+        default: 25000,
+        describe: "Timeout for each model call in milliseconds",
+      })
+      .option("parallel", {
+        type: "number",
+        default: 5,
+        describe: "Number of parallel model calls",
+      })
+      .option("verbose", {
+        type: "boolean",
+        default: false,
+        describe: "Show verbose output",
+      })
+      .option("quiet", {
+        type: "boolean",
+        default: false,
+        describe: "Suppress progress and decoration",
+      })
+      .option("output", {
+        type: "string",
+        choices: ["table", "json", "md"],
+        default: "table",
+        describe: "Output format (table, json, or md)",
+      })
+  },
+  handler: async (args) => {
+    await handle({
+      prompt: args.prompt,
+      timeout: args.timeout,
+      filter: args.filter,
+      parallel: args.parallel,
+      output: args.output === "json" || args.output === "md" ? args.output : "table",
+      verbose: args.verbose,
+      quiet: args.quiet,
+    })
+  },
+})
+
+type ArgumentsCamelCase = {
+  prompt: string
+  timeout: number
+  filter: string
+  parallel: number
+  output: "table" | "json" | "md"
+  verbose: boolean
+  quiet: boolean
+  list?: typeof Provider.list
+}
+
+export async function handle(args: ArgumentsCamelCase) {
+  const list = args.list ?? Provider.list
+
+  if (args.parallel < 1) {
+    UI.error("--parallel must be at least 1")
+    process.exitCode = 1
+    return
+  }
+
+  if (args.timeout < 1) {
+    UI.error("--timeout must be at least 1")
+    process.exitCode = 1
+    return
+  }
+
+  if (!args.filter.trim()) {
+    UI.error("filter is required and cannot be empty")
+    process.exitCode = 1
+    return
+  }
+
+  const json = args.output === "json"
+  const structured = json || args.output === "md"
+  const tty = process.stderr.isTTY ?? false
+  const color = (style: string) => (tty ? style : "")
+
+  if (!args.quiet && !structured) {
+    UI.println(
+      `${color(UI.Style.TEXT_INFO)}Starting roll call for models with prompt: "${args.prompt}"${color(UI.Style.TEXT_NORMAL)}`,
+    )
+    UI.println(
+      `${color(UI.Style.TEXT_INFO)}Timeout per model: ${args.timeout}ms, Parallel calls: ${args.parallel}${color(UI.Style.TEXT_NORMAL)}`,
+    )
+  }
+
+  await Instance.provide({
+    directory: process.cwd(),
+    async fn() {
+      const providers = await list()
+      const regex = (() => {
+        try {
+          return new RegExp(args.filter, "i")
+        } catch (err) {
+          UI.error(`Invalid filter regex: ${args.filter}`)
+          process.exitCode = 1
+          return undefined
+        }
+      })()
+      if (!regex) return
+
+      const models = Object.entries(providers).flatMap(([providerID, provider]) =>
+        Object.entries(provider.models)
+          .filter(([modelID, model]) => regex.test(`${providerID}/${modelID}`) && isTextModel(model))
+          .map(([modelID, model]) => ({ providerID, modelID, model })),
+      )
+
+      if (models.length === 0) {
+        if (!args.quiet && !structured)
+          UI.println(`${color(UI.Style.TEXT_WARNING)}No models to test after filtering.${color(UI.Style.TEXT_NORMAL)}`)
+        if (json) console.log(JSON.stringify([], null, 2))
+        if (args.output === "md") console.log(formatMarkdown([]))
+        if (structured) return
+        process.exitCode = 1
+        return
+      }
+
+      if (!args.quiet && !structured) {
+        UI.println(`${color(UI.Style.TEXT_INFO)}Prompting ${models.length} models...${color(UI.Style.TEXT_NORMAL)}`)
+      }
+
+      const results: Result[] = []
+      const queue = [...models]
+      const active: Promise<void>[] = []
+
+      const run = async (item: (typeof models)[0]) => {
+        const name = `${item.providerID}/${item.modelID}`
+        const start = Date.now()
+        const result = await call(item.model, args.prompt, args.timeout, start)
+
+        results.push({ model: name, ...result })
+
+        if (!args.verbose || args.quiet || structured) return
+        if (result.access) {
+          UI.println(`${color(UI.Style.TEXT_SUCCESS)}✔${color(UI.Style.TEXT_NORMAL)} ${name} - ${result.latency}ms`)
+          return
+        }
+        UI.println(
+          `${color(UI.Style.TEXT_DANGER)}✘${color(UI.Style.TEXT_NORMAL)} ${name} - ${result.errorType}: ${result.errorMessage}`,
+        )
+      }
+
+      while (queue.length > 0 || active.length > 0) {
+        while (queue.length > 0 && active.length < args.parallel) {
+          const item = queue.shift()
+          if (!item) continue
+          const promise = run(item).finally(() => {
+            const index = active.indexOf(promise)
+            if (index > -1) active.splice(index, 1)
+          })
+          active.push(promise)
+        }
+        if (active.length > 0) await Promise.race(active)
+      }
+
+      if (json) {
+        console.log(JSON.stringify(results, null, 2))
+        return
+      }
+
+      const rows = results.map((result) => [
+        result.model,
+        result.access ? "YES" : "NO",
+        result.access ? result.snippet : result.errorMessage ? `(${result.errorMessage})` : "",
+        result.latency !== null ? `${result.latency}ms` : "N/A",
+      ])
+
+      if (args.output === "md") {
+        console.log(formatMarkdown(rows))
+        return
+      }
+
+      const width = parseInt(process.env.COLUMNS || "", 10) || process.stdout.columns || 80
+      const table = formatTable(rows, width)
+
+      UI.println(table.header)
+      UI.println(table.separator)
+      table.rows.forEach((line, index) => {
+        const style = results[index].access ? UI.Style.TEXT_SUCCESS : UI.Style.TEXT_DANGER
+        UI.println(color(style) + line + color(UI.Style.TEXT_NORMAL))
+      })
+
+      if (args.quiet) return
+      const successful = results.filter((result) => result.access).length
+      const failed = results.length - successful
+      UI.println("")
+      UI.println(
+        `${color(UI.Style.TEXT_SUCCESS)}${successful} accessible${color(UI.Style.TEXT_NORMAL)}, ${color(UI.Style.TEXT_DANGER)}${failed} failed${color(UI.Style.TEXT_NORMAL)}`,
+      )
+    },
+  })
+}

package/src/saeeol/cli/cmd/tui/app.tsx

@@ -0,0 +1,190 @@
+/**
+ * Saeeol-specific TUI app customizations.
+ *
+ * Everything in this module is called from the shared upstream `app.tsx`
+ * via thin integration points so the upstream diff stays minimal.
+ */
+
+import { createEffect, on } from "solid-js"
+import { useKeyboard } from "@opentui/solid"
+import { TextAttributes } from "@opentui/core"
+import * as Clipboard from "@tui/util/clipboard"
+import { useCommandDialog } from "@tui/component/dialog-command"
+import { useSDK } from "@tui/context/sdk"
+import { useSync } from "@tui/context/sync"
+import { useDialog } from "@tui/ui/dialog"
+import { useToast } from "@tui/ui/toast"
+import { useTheme } from "@tui/context/theme"
+import { DialogAlert } from "@tui/ui/dialog-alert"
+import { DialogSelect } from "@tui/ui/dialog-select"
+import { Link } from "@tui/ui/link"
+import { isSaeeolError, showSaeeolErrorToast } from "@/saeeol/errors"
+import { registerSaeeolCommands } from "@/saeeol/commands-index"
+import { initializeTUIDependencies } from "@saeeol/gateway/tui"
+
+// Re-export so upstream can render the route without importing directly
+export { SaeeolClawView } from "@/saeeol/claw/view"
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+/** Default terminal window title prefix. */
+export const APP_TITLE = "새얼"
+
+/** Status icons for terminal title. busy uses spinner frames. */
+export const STATUS_ICON: Record<string, string> = {
+  idle: "●",
+  busy: "◐",
+  retry: "↻",
+  offline: "✕",
+}
+
+/** Spinner frames cycled during busy state. */
+export const SPINNER_FRAMES = ["◐", "◓", "◑", "◒"]
+
+/** Interval (ms) between spinner frame updates. */
+export const SPINNER_INTERVAL = 200
+
+/** Public docs URL shown in the command palette. */
+export const DOCS_URL = "https://saeeol.ai/docs"
+
+/** Human-readable product name used in user-facing messages. */
+export const APP_NAME = "SAEEOL"
+
+// ---------------------------------------------------------------------------
+// Utilities
+// ---------------------------------------------------------------------------
+
+export function isAllowEverything(permission: unknown): boolean {
+  if (typeof permission !== "object" || permission === null) return false
+  const wildcard = (permission as Record<string, unknown>)["*"]
+  if (typeof wildcard === "string") return wildcard === "allow"
+  if (typeof wildcard === "object" && wildcard !== null) return (wildcard as Record<string, unknown>)["*"] === "allow"
+  return false
+}
+
+// ---------------------------------------------------------------------------
+// Session effects
+// ---------------------------------------------------------------------------
+
+/**
+ * Reactive effects for session management:
+ * - Notify the server which session the user is viewing (live indicators)
+ * - Evict per-session data from the store when navigating away
+ *
+ * Must be called inside the App component body (needs SolidJS owner).
+ */
+export function useSessionEffects(deps: {
+  route: ReturnType<typeof import("@tui/context/route").useRoute>
+  sdk: ReturnType<typeof useSDK>
+  sync: ReturnType<typeof useSync>
+}) {
+  // Notify server which session the user is viewing
+  createEffect(() => {
+    const sessionID = deps.route.data.type === "session" ? deps.route.data.sessionID : undefined
+    deps.sdk.client.session.viewed({ focused: sessionID ? [sessionID] : [] }).catch(() => {})
+  })
+
+  // Evict per-session data from store when navigating away
+  createEffect(
+    on(
+      () => (deps.route.data.type === "session" ? deps.route.data.sessionID : undefined),
+      (current, prev) => {
+        if (prev && prev !== current) deps.sync.session.evict(prev)
+      },
+    ),
+  )
+}
+
+// ---------------------------------------------------------------------------
+// Terminal title
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns the terminal title for saeeolclaw routes.
+ * Returns undefined for other routes (caller should handle them).
+ */
+export function getTerminalTitle(
+  route: ReturnType<typeof import("@tui/context/route").useRoute>,
+  base: string,
+): string | undefined {
+  if (route.data.type === "saeeolclaw") return `${STATUS_ICON.idle} ${base} | SaeeolClaw`
+  return undefined
+}
+
+// ---------------------------------------------------------------------------
+// Session error handling
+// ---------------------------------------------------------------------------
+
+/**
+ * Intercepts Saeeol-specific errors and shows a warning toast.
+ * Returns `true` if the error was handled, `false` otherwise.
+ */
+export function handleSessionError(error: unknown, toast: ReturnType<typeof useToast>): boolean {
+  if (error && typeof error === "object" && isSaeeolError(error as any)) {
+    showSaeeolErrorToast(error as any, toast)
+    return true
+  }
+  return false
+}
+
+// ---------------------------------------------------------------------------
+// Initialization
+// ---------------------------------------------------------------------------
+
+/**
+ * One-shot initialiser called from the App component body.
+ *
+ * - Injects TUI dependencies into saeeol-gateway
+ * - Registers Saeeol Gateway commands (profile, teams, saeeolclaw, etc.)
+ * - Registers the auto-approve toggle command
+ */
+export function init() {
+  const command = useCommandDialog()
+  const sync = useSync()
+  const sdk = useSDK()
+  const toast = useToast()
+
+  // Inject TUI dependencies for saeeol-gateway
+  initializeTUIDependencies({
+    useCommandDialog,
+    useSync,
+    useDialog,
+    useToast,
+    useTheme,
+    useSDK,
+    DialogAlert,
+    DialogSelect,
+    Link,
+    Clipboard,
+    useKeyboard,
+    TextAttributes,
+  })
+
+  // Register Saeeol Gateway commands (profile, teams, saeeolclaw, remote, etc.)
+  registerSaeeolCommands(useSDK)
+
+  // Register auto-approve toggle
+  command.register(() => [
+    {
+      get title() {
+        return isAllowEverything(sync.data.config.permission) ? "Disable auto-approve mode" : "Enable auto-approve mode"
+      },
+      value: "permission.allow_everything",
+      category: "System",
+      onSelect: async (dialog) => {
+        const enabled = isAllowEverything(sync.data.config.permission)
+        const result = await sdk.client.permission.allowEverything({ enable: !enabled })
+        if (result.error) {
+          toast.show({
+            variant: "error",
+            message: `Failed to ${!enabled ? "enable" : "disable"} auto-approve mode`,
+          })
+          return
+        }
+        dialog.clear()
+      },
+    },
+  ])
+}

package/src/saeeol/cli/cmd/tui/component/dialog-provider.tsx

@@ -0,0 +1,126 @@
+/**
+ * Saeeol-specific overrides for the provider dialog.
+ *
+ * Exports constants and renderers consumed by the shared upstream
+ * `dialog-provider.tsx` so the upstream diff stays minimal.
+ */
+
+import type { JSX } from "solid-js"
+import type { RGBA } from "@opentui/core"
+import type { ProviderAuthAuthorization } from "@saeeol/sdk/v2"
+import { SaeeolAutoMethod } from "@/saeeol/components/dialog-auto-method"
+
+// ---------------------------------------------------------------------------
+// Failed-state gutter/description helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns a red `!` gutter element when the provider is in a failed auth state,
+ * or `undefined` if not failed and not connected (falls through to default check).
+ */
+export function renderGutter(
+  providerID: string,
+  failed: string[],
+  theme: { error: RGBA },
+): (() => JSX.Element) | undefined {
+  if (!failed.includes(providerID)) return undefined
+  return () => <text fg={theme.error}>!</text>
+}
+
+/**
+ * Returns a description suffix when the provider has encountered an error,
+ * or `undefined` to leave the default description unchanged.
+ *
+ * NOTE: The sync state only carries failed provider IDs, not the error kind.
+ * A generic message is used so it remains accurate for auth, network, and
+ * schema failure types alike.
+ */
+export function failedDescription(providerID: string, failed: string[]): string | undefined {
+  if (!failed.includes(providerID)) return undefined
+  return "(connection error — click to reconnect)"
+}
+
+// ---------------------------------------------------------------------------
+// Provider priority (replaces upstream map entirely)
+// ---------------------------------------------------------------------------
+
+export const PROVIDER_PRIORITY: Record<string, number> = {
+  saeeol: -1,
+  anthropic: 0,
+  "github-copilot": 1,
+  openai: 2,
+  google: 3,
+}
+
+// ---------------------------------------------------------------------------
+// Provider descriptions shown next to the name in the selection list
+// ---------------------------------------------------------------------------
+
+export const PROVIDER_DESCRIPTIONS: Record<string, string> = {
+  saeeol: "(Recommended)",
+  anthropic: "(Claude Max or API key)",
+  openai: "(ChatGPT login or API key)",
+}
+
+export const PROVIDER_TITLES: Record<string, string> = {
+  openai: "OpenAI / Codex",
+}
+
+// ---------------------------------------------------------------------------
+// Auto-method renderer
+// ---------------------------------------------------------------------------
+
+/**
+ * If the provider is Saeeol Gateway, renders the custom `SaeeolAutoMethod`
+ * component that handles device-auth + org selection.
+ *
+ * Returns `undefined` for every other provider so the caller can fall
+ * through to the default `AutoMethod`.
+ */
+export function renderAutoMethod(opts: {
+  providerID: string
+  title: string
+  index: number
+  authorization: ProviderAuthAuthorization
+  useSDK: () => any
+  useTheme: () => any
+  DialogModel: any
+}): (() => JSX.Element) | undefined {
+  if (opts.providerID !== "saeeol") return undefined
+  return () => (
+    <SaeeolAutoMethod
+      providerID={opts.providerID}
+      title={opts.title}
+      index={opts.index}
+      authorization={opts.authorization}
+      useSDK={opts.useSDK}
+      useTheme={opts.useTheme}
+      DialogModel={opts.DialogModel}
+    />
+  )
+}
+
+// ---------------------------------------------------------------------------
+// API-key dialog description
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns a custom description element for the API-key dialog when the
+ * provider is Saeeol Gateway. Returns `undefined` otherwise.
+ */
+export function renderApiDescription(
+  providerID: string,
+  theme: { textMuted: RGBA; text: RGBA; primary: RGBA },
+): (() => JSX.Element) | undefined {
+  if (providerID !== "saeeol") return undefined
+  return () => (
+    <box gap={1}>
+      <text fg={theme.textMuted}>
+        Saeeol Gateway gives you access to all the best coding models at the cheapest prices with a single API key.
+      </text>
+      <text fg={theme.text}>
+        Go to <span style={{ fg: theme.primary }}>https://saeeol.ai/gateway</span> to get a key
+      </text>
+    </box>
+  )
+}

package/src/saeeol/cli/cmd/tui/feedback.ts

@@ -0,0 +1,57 @@
+/**
+ * Per-message thumbs up/down feedback for the TUI.
+ *
+ * Wired via the `messages_feedback_up` / `messages_feedback_down` keybinds
+ * in the Session route. Kept out of `routes/session/index.tsx` so the
+ * upstream-shared session route stays free of Saeeol telemetry plumbing.
+ */
+import { Telemetry } from "@saeeol/telemetry"
+import type { AssistantMessage, Message } from "@saeeol/sdk/v2"
+import type { DialogContext } from "@tui/ui/dialog"
+import type { ToastContext } from "@tui/ui/toast"
+
+interface SessionRevert {
+  revert?: { messageID: string }
+}
+
+interface Context {
+  toast: ToastContext
+  session: () => SessionRevert | undefined
+  messages: () => Message[]
+}
+
+export function submitFeedback(rating: "up" | "down", dialog: DialogContext, ctx: Context): void {
+  if (!Telemetry.isEnabled()) {
+    ctx.toast.show({ message: "Feedback disabled: telemetry is off", variant: "info" })
+    dialog.clear()
+    return
+  }
+  const revertID = ctx.session()?.revert?.messageID
+  const lastAssistant = ctx
+    .messages()
+    .findLast((msg): msg is AssistantMessage => msg.role === "assistant" && (!revertID || msg.id < revertID))
+  if (!lastAssistant) {
+    ctx.toast.show({ message: "No assistant messages found", variant: "error" })
+    dialog.clear()
+    return
+  }
+  const providerID = lastAssistant.providerID
+  const payload: Telemetry.FeedbackProperties = {
+    providerID,
+    modelID: lastAssistant.modelID,
+    rating,
+  }
+  const variant = (lastAssistant as AssistantMessage & { variant?: string }).variant
+  if (variant) payload.variant = variant
+  if (providerID === "saeeol") {
+    payload.sessionID = lastAssistant.sessionID
+    payload.messageID = lastAssistant.id
+    payload.parentMessageID = lastAssistant.parentID
+  }
+  Telemetry.trackFeedback(payload)
+  ctx.toast.show({
+    message: rating === "up" ? "Thanks for the feedback!" : "Thanks — we'll use this to improve.",
+    variant: "success",
+  })
+  dialog.clear()
+}

package/src/saeeol/cli/cmd/tui/util/terminal.ts

@@ -0,0 +1,21 @@
+/**
+ * Write escape sequences to disable all mouse tracking modes and reset terminal state.
+ * This is a safety net to ensure the terminal is clean after exit, even if the renderer's
+ * cleanup didn't flush properly (e.g. on Windows).
+ */
+export function resetTerminalState() {
+  const sequences = [
+    "\x1b[?1000l", // disable normal mouse tracking
+    "\x1b[?1002l", // disable button-event mouse tracking
+    "\x1b[?1003l", // disable any-event mouse tracking (all movement)
+    "\x1b[?1006l", // disable SGR extended mouse mode
+    "\x1b[?1015l", // disable RXVT mouse mode
+    "\x1b[<u", // pop/disable Kitty keyboard protocol
+    "\x1b[0m", // reset text attributes
+  ]
+  try {
+    process.stdout.write(sequences.join(""))
+  } catch (err) {
+    console.error("resetTerminalState failed", err)
+  }
+}