saeeol 1.1.0 → 1.1.1

package/src/saeeol/claw/sidebar.tsx

@@ -0,0 +1,215 @@
+
+/**
+ * SaeeolClaw status sidebar
+ *
+ * Mirrors the session sidebar (routes/session/sidebar.tsx): bold
+ * conversation title at the top, then context-window usage, then
+ * instance/bot/details sections.
+ */
+
+import { Show } from "solid-js"
+import { useTheme } from "@tui/context/theme"
+import type { ClawStatus, ConversationListItem, ConversationStatusRecord } from "./types"
+
+function dot(status: string | null | undefined, theme: any): string {
+  if (!status) return theme.textMuted
+  if (status === "running") return theme.success
+  if (status === "starting" || status === "restarting") return theme.warning
+  if (status === "destroying") return theme.error
+  return theme.textMuted
+}
+
+function uptime(started: string | null | undefined): string {
+  if (!started) return "—"
+  const ms = Date.now() - new Date(started).getTime()
+  if (ms < 0) return "—"
+  const seconds = Math.floor(ms / 1000)
+  const minutes = Math.floor(seconds / 60)
+  const hours = Math.floor(minutes / 60)
+  const days = Math.floor(hours / 24)
+  if (days > 0) return `${days}d ${hours % 24}h`
+  if (hours > 0) return `${hours}h ${minutes % 60}m`
+  if (minutes > 0) return `${minutes}m`
+  return `${seconds}s`
+}
+
+function formatTokens(n: number): string {
+  if (n < 1000) return String(n)
+  if (n < 1_000_000) return `${(n / 1000).toFixed(n < 10_000 ? 1 : 0)}k`
+  return `${(n / 1_000_000).toFixed(1)}M`
+}
+
+export function ClawSidebar(props: {
+  status: ClawStatus | null
+  loading: boolean
+  error: string | null
+  online: boolean
+  connected: boolean
+  chatLoading: boolean
+  chatError: string | null
+  conversations: ConversationListItem[]
+  activeConversationId: string | null
+  conversationStatus: ConversationStatusRecord | null
+}) {
+  const { theme } = useTheme()
+
+  const conversationTitle = () => {
+    const id = props.activeConversationId
+    if (!id) return "New conversation"
+    const conv = props.conversations.find((c) => c.conversationId === id)
+    return conv?.title ?? "Untitled"
+  }
+
+  return (
+    <box
+      backgroundColor={theme.backgroundPanel}
+      width={42}
+      height="100%"
+      paddingTop={1}
+      paddingBottom={1}
+      paddingLeft={2}
+      paddingRight={2}
+    >
+      <scrollbox flexGrow={1}>
+        <box flexShrink={0} gap={1} paddingRight={1}>
+          {/* Conversation title (top, like session title) */}
+          <Show when={props.connected}>
+            <box paddingRight={1}>
+              <text fg={theme.text} wrapMode="word">
+                <b>{conversationTitle()}</b>
+              </text>
+            </box>
+          </Show>
+
+          {/* Bot status — same section pattern as Instance/Details */}
+          <Show when={props.connected || props.chatLoading || props.chatError}>
+            <box>
+              <text fg={theme.text}>
+                <b>Bot Status</b>
+              </text>
+              <Show when={props.chatError}>
+                <text fg={theme.error}>{props.chatError}</text>
+              </Show>
+              <Show when={!props.chatError && props.chatLoading}>
+                <text fg={theme.textMuted}>Connecting...</text>
+              </Show>
+              <Show when={!props.chatError && !props.chatLoading && props.connected}>
+                <box flexDirection="row" gap={1}>
+                  <text flexShrink={0} style={{ fg: props.online ? theme.success : theme.textMuted }}>
+                    •
+                  </text>
+                  <text fg={theme.text}>{props.online ? "Online" : "Offline"}</text>
+                </box>
+              </Show>
+              <Show when={!props.chatError && !props.chatLoading && !props.connected}>
+                <text fg={theme.textMuted}>Unavailable</text>
+              </Show>
+            </box>
+          </Show>
+
+          {/* Context window usage */}
+          <Show when={props.connected && props.conversationStatus}>
+            {(s) => (
+              <box>
+                <text fg={theme.text}>
+                  <b>Context</b>
+                </text>
+                <Show when={s().contextWindow > 0}>
+                  <box flexDirection="row" justifyContent="space-between">
+                    <text fg={theme.textMuted}>Used</text>
+                    <text fg={theme.text}>
+                      {Math.min(100, Math.round((s().contextTokens / s().contextWindow) * 100))}%
+                    </text>
+                  </box>
+                </Show>
+                <box flexDirection="row" justifyContent="space-between">
+                  <text fg={theme.textMuted}>Tokens</text>
+                  <text fg={theme.text}>
+                    {formatTokens(s().contextTokens)} / {formatTokens(s().contextWindow)}
+                  </text>
+                </box>
+                <Show when={s().model}>
+                  <box flexDirection="row" justifyContent="space-between">
+                    <text fg={theme.textMuted}>Model</text>
+                    <text fg={theme.text} wrapMode="none">
+                      {s().model}
+                    </text>
+                  </box>
+                </Show>
+                <Show when={s().provider}>
+                  <box flexDirection="row" justifyContent="space-between">
+                    <text fg={theme.textMuted}>Provider</text>
+                    <text fg={theme.text} wrapMode="none">
+                      {s().provider}
+                    </text>
+                  </box>
+                </Show>
+              </box>
+            )}
+          </Show>
+
+          <Show when={props.loading}>
+            <text fg={theme.textMuted}>Loading...</text>
+          </Show>
+
+          <Show when={props.error}>
+            <text fg={theme.error}>{props.error}</text>
+          </Show>
+
+          <Show when={!props.loading && !props.error && props.status}>
+            <box>
+              <text fg={theme.text}>
+                <b>Instance</b>
+              </text>
+              <box flexDirection="row" gap={1}>
+                <text flexShrink={0} style={{ fg: dot(props.status!.status, theme) }}>
+                  •
+                </text>
+                <text fg={theme.text}>
+                  {(props.status!.status ?? "unknown").replace(/^./, (c) => c.toUpperCase())}{" "}
+                  <span style={{ fg: theme.textMuted }}>
+                    {props.status!.status === "running" ? uptime(props.status!.lastStartedAt) : ""}
+                  </span>
+                </text>
+              </box>
+            </box>
+
+            <box>
+              <text fg={theme.text}>
+                <b>Details</b>
+              </text>
+              <box flexDirection="row" justifyContent="space-between">
+                <text fg={theme.textMuted}>Region</text>
+                <text fg={theme.text}>{props.status!.flyRegion?.toUpperCase() ?? "—"}</text>
+              </box>
+              <box flexDirection="row" justifyContent="space-between">
+                <text fg={theme.textMuted}>Version</text>
+                <text fg={theme.text}>{props.status!.openclawVersion ?? "—"}</text>
+              </box>
+              <Show when={props.status!.channelCount != null && props.status!.channelCount >= 1}>
+                <box flexDirection="row" justifyContent="space-between">
+                  <text fg={theme.textMuted}>Channels</text>
+                  <text fg={theme.text}>{props.status!.channelCount}</text>
+                </box>
+              </Show>
+            </box>
+          </Show>
+
+          <Show when={!props.loading && !props.error && !props.status}>
+            <box>
+              <text fg={theme.textMuted}>No instance found.</text>
+              <text fg={theme.textMuted}>Visit saeeol.ai/claw</text>
+              <text fg={theme.textMuted}>to set one up.</text>
+            </box>
+          </Show>
+        </box>
+      </scrollbox>
+
+      <box flexShrink={0} paddingTop={1}>
+        <text fg={theme.textMuted}>
+          <span style={{ fg: theme.text }}>Esc</span> back
+        </text>
+      </box>
+    </box>
+  )
+}

package/src/saeeol/claw/types.ts

@@ -0,0 +1,214 @@
+
+/**
+ * SaeeolClaw TUI types — Saeeol Chat protocol.
+ *
+ * Mirrors `@saeeol/saeeol-chat` from the cloud monorepo. We carry our own
+ * copy here so the CLI can be built without an external dependency.
+ */
+
+export type ClawStatus = {
+  // `recovering` and `restoring` are transitional states the worker reports
+  // while bringing an instance back from an unexpected stop or snapshot
+  // restore (cloud: `services/saeeolclaw/src/index.ts`).
+  status:
+    | "provisioned"
+    | "starting"
+    | "restarting"
+    | "recovering"
+    | "running"
+    | "stopped"
+    | "destroying"
+    | "restoring"
+    | null
+  sandboxId?: string
+  flyRegion?: string
+  machineSize?: { cpus: number; memory_mb: number }
+  openclawVersion?: string | null
+  lastStartedAt?: string | null
+  lastStoppedAt?: string | null
+  channelCount?: number
+  secretCount?: number
+  userId?: string
+  // User-chosen name for the SaeeolClaw bot, set during onboarding via the
+  // `patchBotIdentity` mutation. May be null for fresh instances that
+  // skipped the bot-identity step. The chat UI should fall back to the
+  // literal string "SaeeolClaw" when null.
+  botName?: string | null
+}
+
+// ── Saeeol Chat token envelope (gateway response) ─────────────────────
+
+export type ChatToken = {
+  token: string
+  expiresAt: string // ISO timestamp
+  saeeolChatUrl: string
+  eventServiceUrl: string
+}
+
+// ── Content blocks ──────────────────────────────────────────────────
+
+export type ExecApprovalDecision = "allow-once" | "allow-always" | "deny"
+
+export type TextBlock = { type: "text"; text: string }
+
+export type ActionItem = {
+  label: string
+  style: "primary" | "danger" | "secondary"
+  value: ExecApprovalDecision
+}
+
+export type ActionsBlock = {
+  type: "actions"
+  groupId: string
+  actions: ActionItem[]
+  resolved?: {
+    value: ExecApprovalDecision
+    resolvedBy: string
+    resolvedAt: number
+  }
+}
+
+export type ContentBlock = TextBlock | ActionsBlock
+
+// ── Reactions ───────────────────────────────────────────────────────
+
+export type ReactionSummary = {
+  emoji: string
+  count: number
+  memberIds: string[]
+}
+
+// ── Messages ────────────────────────────────────────────────────────
+
+export type Message = {
+  id: string
+  senderId: string
+  content: ContentBlock[]
+  inReplyToMessageId: string | null
+  updatedAt: number | null
+  clientUpdatedAt: number | null
+  deleted: boolean
+  deliveryFailed: boolean
+  reactions: ReactionSummary[]
+}
+
+// ── Conversations ───────────────────────────────────────────────────
+
+export type ConversationListItem = {
+  conversationId: string
+  title: string | null
+  lastActivityAt: number | null
+  lastReadAt: number | null
+  joinedAt: number
+}
+
+// ── Bot / conversation status ───────────────────────────────────────
+
+export type BotStatusRecord = {
+  online: boolean
+  at: number
+  updatedAt: number
+}
+
+export type ConversationStatusRecord = {
+  conversationId: string
+  contextTokens: number
+  contextWindow: number
+  model: string | null
+  provider: string | null
+  at: number
+  updatedAt: number
+}
+
+// ── Events ──────────────────────────────────────────────────────────
+
+/**
+ * Snapshot of the message that was replied to. Server includes this on
+ * `message.created` so clients can render a reply preview without a follow-up
+ * fetch. `deleted` mirrors the soft-deletion state at the time of replying.
+ */
+export type ReplyToSnapshot = {
+  messageId: string
+  senderId: string
+  content: ContentBlock[]
+  deleted?: boolean
+}
+
+export type MessageCreatedEvent = {
+  messageId: string
+  senderId: string
+  content: ContentBlock[]
+  inReplyToMessageId: string | null
+  clientId?: string
+  replyTo?: ReplyToSnapshot | null
+}
+
+export type MessageUpdatedEvent = {
+  messageId: string
+  content: ContentBlock[]
+  clientUpdatedAt: number | null
+}
+
+export type MessageDeletedEvent = { messageId: string }
+export type MessageDeliveryFailedEvent = { messageId: string }
+export type TypingEvent = { memberId: string }
+
+export type TypingMember = { memberId: string; at: number }
+export type ReactionAddedEvent = { messageId: string; memberId: string; emoji: string; operationId?: string }
+export type ReactionRemovedEvent = { messageId: string; memberId: string; emoji: string; operationId?: string }
+/**
+ * Server fans out the full conversation snapshot on `conversation.created` so
+ * clients can append to their list without a follow-up fetch.
+ */
+export type ConversationCreatedEvent = {
+  conversationId: string
+  conversation?: ConversationListItem
+}
+export type ConversationRenamedEvent = { conversationId: string; title: string }
+export type ConversationLeftEvent = { conversationId: string }
+export type ConversationActivityEvent = { conversationId: string; lastActivityAt: number }
+export type ActionDeliveryFailedEvent = { conversationId: string; messageId: string; groupId: string }
+export type BotStatusEvent = { sandboxId: string; online: boolean; at: number }
+export type ConversationStatusEvent = {
+  conversationId: string
+  contextTokens: number
+  contextWindow: number
+  model: string | null
+  provider: string | null
+  at: number
+}
+
+export type SaeeolChatEventMap = {
+  "message.created": MessageCreatedEvent
+  "message.updated": MessageUpdatedEvent
+  "message.deleted": MessageDeletedEvent
+  "message.delivery_failed": MessageDeliveryFailedEvent
+  typing: TypingEvent
+  "typing.stop": TypingEvent
+  "reaction.added": ReactionAddedEvent
+  "reaction.removed": ReactionRemovedEvent
+  "conversation.created": ConversationCreatedEvent
+  "conversation.renamed": ConversationRenamedEvent
+  "conversation.left": ConversationLeftEvent
+  "conversation.activity": ConversationActivityEvent
+  "action.delivery_failed": ActionDeliveryFailedEvent
+  "bot.status": BotStatusEvent
+  "conversation.status": ConversationStatusEvent
+}
+
+export type SaeeolChatEventName = keyof SaeeolChatEventMap
+
+// ── Legacy display message (for CLI rendering) ──────────────────────
+
+/**
+ * Lightweight chat-message shape used by the existing CLI rendering layer.
+ * We keep this for backwards compatibility with components that already
+ * render text + bot flag. New code should prefer `Message`.
+ */
+export type ChatMessage = {
+  id: string
+  text: string
+  user: string
+  created: Date
+  bot: boolean
+}

package/src/saeeol/claw/view.tsx

@@ -0,0 +1,152 @@
+
+/**
+ * SaeeolClaw full-screen view
+ *
+ * Main layout component for the /saeeolclaw route.
+ * Renders a chat panel on the left and a status sidebar on the right.
+ * Escape navigates back to the previous route.
+ */
+
+import { createMemo } from "solid-js"
+import { useKeyboard } from "@opentui/solid"
+import { useRoute } from "@tui/context/route"
+import { useSDK } from "@tui/context/sdk"
+import { useDialog } from "@tui/ui/dialog"
+import { useCommandDialog, type CommandOption } from "@tui/component/dialog-command"
+import { Toast } from "@tui/ui/toast"
+import { ClawChat } from "./chat"
+import { ClawSidebar } from "./sidebar"
+import { createClawStatus, createClawChat } from "./hooks"
+import { DialogConversationList } from "./dialog-conversation-list"
+import type { ClawSlashOption } from "./autocomplete"
+
+export function SaeeolClawView() {
+  const route = useRoute()
+  const sdk = useSDK()
+  const command = useCommandDialog()
+  const dialog = useDialog()
+
+  // Poll instance status
+  const { status, error: statusError, loading: statusLoading } = createClawStatus(sdk)
+
+  // Connect to chat
+  const chat = createClawChat(sdk)
+
+  // Determine if chat input should be disabled
+  const disabled = createMemo(() => {
+    const s = status()
+    return !s || s.status !== "running"
+  })
+
+  // Bot display name — sourced from the SaeeolClaw platform status (set by the
+  // user during onboarding via patchBotIdentity). Falls back to the literal
+  // "SaeeolClaw" while loading or for instances that skipped onboarding,
+  // matching the web UI's fallback chain.
+  const botName = createMemo(() => status()?.botName ?? "SaeeolClaw")
+
+  // Register escape to navigate back
+  useKeyboard((evt) => {
+    if (evt.name === "escape") {
+      route.back()
+      evt.preventDefault()
+      evt.stopPropagation()
+    }
+  })
+
+  // SaeeolClaw view commands — single source of truth for both the global
+  // command palette / keybinds and the in-chat slash autocomplete.
+  // The list is reactive on `chat.connected` so the slash menu only
+  // exposes `/new` and `/conversations` once we're connected to saeeol-chat.
+  const saeeolCommands = createMemo<CommandOption[]>(() => {
+    const ready = chat.connected()
+    return [
+      {
+        value: "saeeolclaw.back",
+        title: "Back",
+        description: "Return to the previous view",
+        category: "SaeeolClaw",
+        slash: { name: "back" },
+        keybind: "escape" as any,
+        onSelect: () => {
+          dialog.clear()
+          route.back()
+        },
+      },
+      {
+        value: "saeeolclaw.new",
+        title: "New conversation",
+        description: "Start a new SaeeolClaw conversation",
+        category: "SaeeolClaw",
+        slash: { name: "new" },
+        enabled: ready,
+        hidden: !ready,
+        onSelect: async () => {
+          dialog.clear()
+          await chat.newConversation()
+        },
+      },
+      {
+        value: "saeeolclaw.conversations",
+        title: "Conversations",
+        description: "Browse, rename, and delete SaeeolClaw conversations",
+        category: "SaeeolClaw",
+        slash: { name: "conversations", aliases: ["chats"] },
+        enabled: ready,
+        hidden: !ready,
+        onSelect: () => {
+          dialog.replace(() => <DialogConversationList chat={chat} />)
+        },
+      },
+    ]
+  })
+
+  command.register(() => saeeolCommands())
+
+  // Slashes for the in-chat autocomplete — derived from the same list so
+  // renames flow through automatically. We pad displays to a common width
+  // so the descriptions line up like in the main prompt's autocomplete.
+  const clawSlashes = createMemo<ClawSlashOption[]>(() => {
+    const visible = saeeolCommands().filter((c) => c.enabled !== false && !c.hidden && c.slash)
+    const items = visible.map((c) => ({
+      display: "/" + c.slash!.name,
+      description: c.description ?? c.title,
+      aliases: c.slash!.aliases?.map((a) => "/" + a),
+      onSelect: () => c.onSelect?.(dialog),
+    }))
+    const max = items.reduce((m, i) => Math.max(m, i.display.length), 0)
+    if (!max) return items
+    return items.map((i) => ({ ...i, display: i.display.padEnd(max + 2) }))
+  })
+
+  return (
+    <box flexDirection="row" flexGrow={1} paddingLeft={2} gap={1}>
+      <box flexGrow={1} flexDirection="column">
+        <ClawChat
+          messages={chat.messages()}
+          online={chat.online()}
+          connected={chat.connected()}
+          loading={chat.loading()}
+          error={chat.error()}
+          disabled={disabled()}
+          typingMembers={chat.typingMembers()}
+          slashes={clawSlashes}
+          botName={botName()}
+          onSend={chat.send}
+        />
+        <Toast />
+      </box>
+      <ClawSidebar
+        status={status()}
+        loading={statusLoading()}
+        error={statusError()}
+        online={chat.online()}
+        connected={chat.connected()}
+        chatLoading={chat.loading()}
+        chatError={chat.error()}
+        conversations={chat.conversations()}
+        activeConversationId={chat.activeConversationId()}
+        conversationStatus={chat.conversationStatus()}
+      />
+    </box>
+  )
+}

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

@@ -0,0 +1,82 @@
+import { random as randomId } from "@saeeol/boxes/uid"
+import { Provider } from "../../../provider/provider"
+import { ProviderTransform } from "../../../provider/transform"
+import { generateText } from "ai"
+
+export interface Result {
+  model: string
+  access: boolean
+  snippet: string
+  latency: number | null
+  errorType: string | null
+  errorMessage: string | null
+}
+
+export async function call(
+  model: Provider.Model,
+  prompt: string,
+  timeout: number,
+  start: number,
+): Promise<Omit<Result, "model">> {
+  try {
+    const language = await Provider.getLanguage(model)
+    const sessionID = randomId()
+    const options = ProviderTransform.options({ model, sessionID })
+    const providerOptions = ProviderTransform.providerOptions(model, options)
+    const maxOutputTokens = ProviderTransform.maxOutputTokens(model)
+    const temperature = ProviderTransform.temperature(model)
+    const topP = ProviderTransform.topP(model)
+    const topK = ProviderTransform.topK(model)
+    const messages: Parameters<typeof generateText>[0]["messages"] = [{ role: "user", content: prompt }]
+    const transformed = ProviderTransform.message(messages, model, options)
+    const result = await generateText({
+      model: language,
+      messages: transformed,
+      abortSignal: AbortSignal.timeout(timeout),
+      maxOutputTokens,
+      temperature,
+      topP,
+      topK,
+      providerOptions,
+    })
+
+    return {
+      access: true,
+      snippet: result.text.replace(/\n/g, " "),
+      latency: Date.now() - start,
+      errorType: null,
+      errorMessage: null,
+    }
+  } catch (cause) {
+    const err = classifyError(cause)
+    return {
+      access: false,
+      snippet: "",
+      latency: Date.now() - start,
+      errorType: err.type,
+      errorMessage: err.message,
+    }
+  }
+}
+
+function classifyError(cause: unknown) {
+  if (
+    cause instanceof Error &&
+    (cause.name === "AbortError" || cause.message.includes("abort") || cause.message.includes("timeout"))
+  ) {
+    return { type: "timeout", message: "The operation timed out." }
+  }
+
+  if (typeof cause === "object" && cause && "error" in cause) {
+    const data = cause.error as { type?: unknown; message?: unknown }
+    if (typeof data.type === "string" || typeof data.message === "string") {
+      return {
+        type: typeof data.type === "string" ? data.type : "api_error",
+        message: typeof data.message === "string" ? data.message : cause instanceof Error ? cause.message : "API error",
+      }
+    }
+  }
+
+  if (cause instanceof Error) return { type: "unknown", message: cause.message }
+  return { type: "unknown", message: "An unknown error occurred" }
+}