saeeol 1.0.9 → 1.1.0

package/src/saeeol/claw/sidebar.tsx

@@ -1,215 +0,0 @@
-
-/**
- * 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

@@ -1,214 +0,0 @@
-
-/**
- * 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

@@ -1,152 +0,0 @@
-
-/**
- * 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

@@ -1,82 +0,0 @@
-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" }
-}