saeeol 1.1.0 → 1.1.1

package/src/saeeol/claw/client-helpers.ts

@@ -0,0 +1,182 @@
+import type {
+  ChatMessage,
+  ChatToken,
+  ContentBlock,
+  ConversationListItem,
+  ConversationStatusRecord,
+  Message,
+  MessageCreatedEvent,
+  MessageUpdatedEvent,
+  TypingMember,
+} from "./types"
+
+export type ConversationStatusListener = (status: ConversationStatusRecord | null) => void
+export type ConversationsListener = (conversations: ConversationListItem[]) => void
+export type ActiveConversationListener = (id: string | null) => void
+export type TypingMembersListener = (members: TypingMember[]) => void
+
+export type ClawChatClient = {
+  disconnect: () => Promise<void>
+  listConversations: () => ConversationListItem[]
+  activeConversationId: () => string | null
+  selectConversation: (
+    conversationId: string,
+  ) => Promise<{ messages: ChatMessage[]; status: ConversationStatusRecord | null }>
+  createConversation: (title?: string) => Promise<string>
+  renameConversation: (conversationId: string, title: string) => Promise<void>
+  deleteConversation: (conversationId: string) => Promise<void>
+  refreshConversations: () => Promise<ConversationListItem[]>
+  send: (text: string) => Promise<void>
+  loadHistory: (conversationId?: string) => Promise<ChatMessage[]>
+  initialBotOnline: () => boolean
+  conversationStatus: () => ConversationStatusRecord | null
+  typingMembers: () => TypingMember[]
+  onMessage: (cb: (msg: ChatMessage) => void) => () => void
+  onMessageUpdated: (cb: (msg: ChatMessage) => void) => () => void
+  onPresence: (cb: (online: boolean) => void) => () => void
+  onConversations: (cb: ConversationsListener) => () => void
+  onActiveConversation: (cb: ActiveConversationListener) => () => void
+  onConversationStatus: (cb: ConversationStatusListener) => () => void
+  onTypingMembers: (cb: TypingMembersListener) => () => void
+}
+
+export type ConnectInput = {
+  envelope: ChatToken
+  sandboxId: string
+  currentUserId: string
+}
+
+export function emitSet<T>(set: Set<(v: T) => void>, value: T): void {
+  for (const cb of set) cb(value)
+}
+
+export function onAdd<T>(set: Set<(v: T) => void>, cb: (v: T) => void): () => void {
+  set.add(cb)
+  return () => set.delete(cb)
+}
+
+export function blocksToText(content: ContentBlock[]): string {
+  let out = ""
+  for (const b of content) {
+    if (b.type === "text") out += b.text
+  }
+  return out
+}
+
+const ULID_TIME_LEN = 10
+const ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"
+
+export function ulidToTimestamp(id: string): number {
+  if (!id || id.length < ULID_TIME_LEN) return Date.now()
+  const time = id.slice(0, ULID_TIME_LEN).toUpperCase()
+  let ts = 0
+  for (const ch of time) {
+    const idx = ENCODING.indexOf(ch)
+    if (idx === -1) return Date.now()
+    ts = ts * ENCODING.length + idx
+  }
+  return ts
+}
+
+export function toChatMessage(m: Message, currentUserId: string): ChatMessage {
+  return {
+    id: m.id,
+    text: m.deleted ? "[deleted message]" : blocksToText(m.content),
+    user: m.senderId,
+    created: new Date(ulidToTimestamp(m.id)),
+    bot: m.senderId.startsWith("bot:") || m.senderId !== currentUserId,
+  }
+}
+
+export function toChatMessageFromCreated(e: MessageCreatedEvent, currentUserId: string): ChatMessage {
+  return {
+    id: e.messageId,
+    text: blocksToText(e.content),
+    user: e.senderId,
+    created: new Date(ulidToTimestamp(e.messageId)),
+    bot: e.senderId.startsWith("bot:") || e.senderId !== currentUserId,
+  }
+}
+
+export function toChatMessageFromUpdated(
+  e: MessageUpdatedEvent,
+  currentUserId: string,
+  senderHint: string | null,
+): ChatMessage {
+  const sender = senderHint ?? "bot"
+  return {
+    id: e.messageId,
+    text: blocksToText(e.content),
+    user: sender,
+    created: new Date(ulidToTimestamp(e.messageId)),
+    bot: sender.startsWith("bot:") || sender !== currentUserId,
+  }
+}
+
+const TYPING_TIMEOUT_MS = 5_000
+
+export type TypingTracker = {
+  start: (memberId: string) => void
+  stop: (memberId: string) => void
+  clear: () => void
+  snapshot: () => TypingMember[]
+  dispose: () => void
+}
+
+export function createTypingTracker(onChange: (members: TypingMember[]) => void): TypingTracker {
+  const entries = new Map<string, number>()
+  let timer: ReturnType<typeof setInterval> | null = null
+
+  function snapshot(): TypingMember[] {
+    const out: TypingMember[] = []
+    for (const [memberId, expiresAt] of entries) {
+      out.push({ memberId, at: expiresAt - TYPING_TIMEOUT_MS })
+    }
+    return out
+  }
+
+  function prune(): void {
+    const now = Date.now()
+    let removed = false
+    for (const [memberId, expiresAt] of entries) {
+      if (expiresAt <= now) {
+        entries.delete(memberId)
+        removed = true
+      }
+    }
+    if (removed) onChange(snapshot())
+    if (entries.size === 0 && timer !== null) {
+      clearInterval(timer)
+      timer = null
+    }
+  }
+
+  return {
+    start(memberId: string): void {
+      entries.set(memberId, Date.now() + TYPING_TIMEOUT_MS)
+      if (timer === null) timer = setInterval(prune, 1_000)
+      onChange(snapshot())
+    },
+    stop(memberId: string): void {
+      if (!entries.delete(memberId)) return
+      onChange(snapshot())
+      if (entries.size === 0 && timer !== null) {
+        clearInterval(timer)
+        timer = null
+      }
+    },
+    clear(): void {
+      if (entries.size === 0) return
+      entries.clear()
+      onChange(snapshot())
+    },
+    snapshot,
+    dispose(): void {
+      if (timer !== null) {
+        clearInterval(timer)
+        timer = null
+      }
+      entries.clear()
+    },
+  }
+}

package/src/saeeol/claw/client.ts

@@ -0,0 +1,225 @@
+import type {
+  ChatMessage,
+  ConversationListItem,
+  ConversationStatusRecord,
+} from "./types"
+import { SaeeolChatClient } from "./chat-client"
+import { EventServiceClient } from "./event-service-client"
+import * as Log from "@saeeol/core/util/log"
+import {
+  type ClawChatClient,
+  type ConnectInput,
+  type ConversationStatusListener,
+  type ConversationsListener,
+  type ActiveConversationListener,
+  type TypingMembersListener,
+  createTypingTracker,
+  toChatMessage,
+  emitSet,
+  onAdd,
+} from "./client-helpers"
+import { setupEvents, trackLastSeen } from "./client-events"
+
+export type {
+  ConversationStatusListener,
+  ConversationsListener,
+  ActiveConversationListener,
+  TypingMembersListener,
+  ClawChatClient,
+  ConnectInput,
+} from "./client-helpers"
+
+const log = Log.create({ service: "claw-chat" })
+
+export async function connect(input: ConnectInput): Promise<ClawChatClient> {
+  const events = new EventServiceClient({
+    url: input.envelope.eventServiceUrl,
+    getToken: async () => input.envelope.token,
+  })
+  const chat = new SaeeolChatClient({
+    baseUrl: input.envelope.saeeolChatUrl,
+    getToken: async () => input.envelope.token,
+  })
+
+  log.info("connecting to event-service")
+  await events.connect()
+
+  const sandboxCtx = `/saeeolclaw/${input.sandboxId}`
+  events.subscribe([sandboxCtx])
+
+  const senderCache = new Map<string, string>()
+  let conversations: ConversationListItem[] = []
+  let activeId: string | null = null
+  let activeStatus: ConversationStatusRecord | null = null
+  let activeCtx: string | null = null
+
+  const typing = createTypingTracker((members) => emitSet(typingListeners, members))
+
+  const messageListeners = new Set<(msg: ChatMessage) => void>()
+  const messageUpdatedListeners = new Set<(msg: ChatMessage) => void>()
+  const presenceListeners = new Set<(online: boolean) => void>()
+  const conversationsListeners = new Set<ConversationsListener>()
+  const activeListeners = new Set<ActiveConversationListener>()
+  const statusListeners = new Set<ConversationStatusListener>()
+  const typingListeners = new Set<TypingMembersListener>()
+
+  async function loadConversations(): Promise<ConversationListItem[]> {
+    const res = await chat.listConversations({ sandboxId: input.sandboxId, limit: 50 })
+    conversations = res.conversations
+    emitSet(conversationsListeners, conversations)
+    return conversations
+  }
+
+  function setActive(id: string | null): void {
+    if (activeId === id) return
+    if (activeCtx) {
+      events.unsubscribe([activeCtx])
+      activeCtx = null
+    }
+    activeId = id
+    activeStatus = null
+    typing.clear()
+    if (id) {
+      activeCtx = `/saeeolclaw/${input.sandboxId}/${id}`
+      events.subscribe([activeCtx])
+    }
+    emitSet(activeListeners, activeId)
+    emitSet(statusListeners, activeStatus)
+  }
+
+  const initialOnline = await chat
+    .getBotStatus(input.sandboxId)
+    .then((s) => s.status?.online ?? false)
+    .catch((err) => {
+      log.warn("getBotStatus failed", { error: (err as Error)?.message ?? String(err) })
+      return false
+    })
+
+  await loadConversations().catch((err) => {
+    log.warn("listConversations failed", { error: (err as Error)?.message ?? String(err) })
+  })
+
+  const lastSeenByConv = new Map<string, string>()
+
+  setupEvents({
+    events,
+    sandboxCtx,
+    sandboxId: input.sandboxId,
+    currentUserId: input.currentUserId,
+    getActiveCtx: () => activeCtx,
+    getActiveId: () => activeId,
+    senderCache,
+    lastSeenByConv,
+    getConversations: () => conversations,
+    setConversations: (c) => { conversations = c },
+    setActiveStatus: (s) => { activeStatus = s },
+    loadConversations,
+    setActive,
+    typing,
+    messageListeners,
+    messageUpdatedListeners,
+    presenceListeners,
+    conversationsListeners,
+    statusListeners,
+  })
+
+  async function loadHistory(conversationId?: string): Promise<ChatMessage[]> {
+    const id = conversationId ?? activeId
+    if (!id) return []
+    const res = await chat.listMessages(id, { limit: 50 })
+    const ascending = [...res.messages].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
+    for (const m of ascending) {
+      senderCache.set(m.id, m.senderId)
+      trackLastSeen({ lastSeenByConv }, id, m.id)
+    }
+    return ascending.map((m) => toChatMessage(m, input.currentUserId))
+  }
+
+  async function selectConversation(conversationId: string) {
+    setActive(conversationId)
+    const msgs = await loadHistory(conversationId)
+    const status = await chat.getConversationStatus(conversationId).then(
+      (res) => res.status ?? null,
+      (err) => {
+        log.warn("getConversationStatus failed", { error: (err as Error)?.message ?? String(err) })
+        return null
+      },
+    )
+    if (activeId === conversationId) {
+      activeStatus = status
+      emitSet(statusListeners, activeStatus)
+    }
+    const lastSeen = lastSeenByConv.get(conversationId)
+    if (lastSeen) {
+      await chat.markConversationRead(conversationId, { lastSeenMessageId: lastSeen }).catch((err) => {
+        log.warn("markConversationRead failed", { error: (err as Error)?.message ?? String(err) })
+      })
+    }
+    return { messages: msgs, status }
+  }
+
+  async function createConversation(title?: string): Promise<string> {
+    const res = await chat.createConversation({ sandboxId: input.sandboxId, title })
+    await loadConversations()
+    return res.conversationId
+  }
+
+  return {
+    async disconnect() {
+      typing.dispose()
+      events.disconnect()
+    },
+    listConversations() {
+      return conversations
+    },
+    activeConversationId() {
+      return activeId
+    },
+    typingMembers() {
+      return typing.snapshot()
+    },
+    async refreshConversations() {
+      return await loadConversations()
+    },
+    selectConversation,
+    createConversation,
+    async renameConversation(conversationId, title) {
+      conversations = conversations.map((c) => (c.conversationId === conversationId ? { ...c, title } : c))
+      emitSet(conversationsListeners, conversations)
+      await chat.renameConversation(conversationId, title)
+    },
+    async deleteConversation(conversationId) {
+      await chat.leaveConversation(conversationId)
+      conversations = conversations.filter((c) => c.conversationId !== conversationId)
+      emitSet(conversationsListeners, conversations)
+      if (activeId === conversationId) setActive(null)
+    },
+    async send(text: string) {
+      const trimmed = text.trim()
+      if (!trimmed) return
+      if (!activeId) {
+        const id = await createConversation()
+        await selectConversation(id)
+      }
+      if (!activeId) return
+      await chat.sendMessage({
+        conversationId: activeId,
+        content: [{ type: "text", text: trimmed }],
+      })
+    },
+    loadHistory,
+    initialBotOnline() {
+      return initialOnline
+    },
+    conversationStatus() {
+      return activeStatus
+    },
+    onMessage: (cb) => onAdd(messageListeners, cb),
+    onMessageUpdated: (cb) => onAdd(messageUpdatedListeners, cb),
+    onPresence: (cb) => onAdd(presenceListeners, cb),
+    onConversations: (cb) => onAdd(conversationsListeners, cb),
+    onActiveConversation: (cb) => onAdd(activeListeners, cb),
+    onConversationStatus: (cb) => onAdd(statusListeners, cb),
+    onTypingMembers: (cb) => onAdd(typingListeners, cb),
+  }
+}

package/src/saeeol/claw/dialog-conversation-list.tsx

@@ -0,0 +1,129 @@
+
+/**
+ * Conversation selector for the SaeeolClaw chat.
+ *
+ * Mirrors the session-list dialog (`cli/cmd/tui/component/dialog-session-list.tsx`):
+ *   - DialogSelect-backed list, grouped by date bucket
+ *   - "current" marker on the active conversation
+ *   - inline rename via DialogPrompt (replace pattern)
+ *   - two-press delete confirmation with `theme.error` background
+ */
+
+import { DialogSelect } from "@tui/ui/dialog-select"
+import { DialogPrompt } from "@tui/ui/dialog-prompt"
+import { useDialog } from "@tui/ui/dialog"
+import { useKeybind } from "@tui/context/keybind"
+import { useTheme } from "@tui/context/theme"
+import { useToast } from "@tui/ui/toast"
+import { Locale } from "@/util/locale"
+import { Keybind } from "@/util/keybind"
+import { createMemo, createSignal, onMount } from "solid-js"
+import type { ClawChat } from "./hooks"
+
+type Props = {
+  chat: ClawChat
+}
+
+export function DialogConversationList(props: Props) {
+  const dialog = useDialog()
+  const keybind = useKeybind()
+  const { theme } = useTheme()
+  const toast = useToast()
+  const [toDelete, setToDelete] = createSignal<string>()
+
+  const options = createMemo(() => {
+    const today = new Date().toDateString()
+    const list = [...props.chat.conversations()]
+    list.sort((a, b) => {
+      const ax = a.lastActivityAt ?? a.joinedAt
+      const bx = b.lastActivityAt ?? b.joinedAt
+      return bx - ax
+    })
+    return list.map((c) => {
+      const ts = c.lastActivityAt ?? c.joinedAt
+      const date = new Date(ts)
+      let category = date.toDateString()
+      if (category === today) category = "Today"
+      const isDeleting = toDelete() === c.conversationId
+      return {
+        title: isDeleting ? `Press ${keybind.print("session_delete")} again to confirm` : (c.title ?? "Untitled"),
+        bg: isDeleting ? theme.error : undefined,
+        value: c.conversationId,
+        category,
+        footer: Locale.time(ts),
+      }
+    })
+  })
+
+  onMount(() => {
+    dialog.setSize("large")
+  })
+
+  return (
+    <DialogSelect
+      title="SaeeolClaw Conversations"
+      options={options()}
+      current={props.chat.activeConversationId() ?? undefined}
+      onMove={() => setToDelete(undefined)}
+      onSelect={async (option) => {
+        await props.chat.selectConversation(option.value)
+        dialog.clear()
+      }}
+      keybind={[
+        {
+          keybind: keybind.all.session_delete?.[0],
+          title: "delete",
+          onTrigger: async (option) => {
+            if (toDelete() === option.value) {
+              // `deleteConversation` already catches internally and returns
+              // a boolean; its outer promise never rejects here.
+              const ok = await props.chat.deleteConversation(option.value)
+              if (!ok) {
+                toast.show({
+                  variant: "error",
+                  title: "Failed to delete conversation",
+                  message: "Please try again.",
+                })
+              }
+              setToDelete(undefined)
+              return
+            }
+            setToDelete(option.value)
+          },
+        },
+        {
+          keybind: keybind.all.session_rename?.[0],
+          title: "rename",
+          onTrigger: async (option) => {
+            const item = props.chat.conversations().find((c) => c.conversationId === option.value)
+            const list = () => dialog.replace(() => <DialogConversationList chat={props.chat} />)
+            dialog.replace(() => (
+              <DialogPrompt
+                title="Rename Conversation"
+                value={item?.title ?? ""}
+                placeholder="Enter a title"
+                onConfirm={async (value) => {
+                  const trimmed = value.trim()
+                  if (trimmed) {
+                    await props.chat.renameConversation(option.value, trimmed)
+                  }
+                  list()
+                }}
+                onCancel={list}
+              />
+            ))
+          },
+        },
+        {
+          keybind: Keybind.parse("ctrl+n")[0],
+          title: "new",
+          side: "right",
+          onTrigger: async () => {
+            await props.chat.newConversation()
+            dialog.clear()
+          },
+        },
+      ]}
+    />
+  )
+}

package/src/saeeol/claw/event-service-client-core.ts

@@ -0,0 +1,104 @@
+import type { SaeeolChatEventMap, SaeeolChatEventName } from "./types"
+
+export const WS_SUBPROTOCOL = "saeeol.events.v1"
+export const HANDSHAKE_TIMEOUT_MS = 10_000
+export const PING_INTERVAL_MS = 15_000
+export const TICKET_FETCH_TIMEOUT_MS = 10_000
+
+export class WebSocketAuthError extends Error {
+  constructor(message = "WebSocket authentication failed") {
+    super(message)
+    this.name = "WebSocketAuthError"
+  }
+}
+
+export class WebSocketConnectError extends Error {
+  constructor(
+    message: string,
+    public readonly code: number,
+  ) {
+    super(message)
+    this.name = "WebSocketConnectError"
+  }
+}
+
+export class HandshakeTimeoutError extends Error {
+  constructor() {
+    super("WebSocket handshake timed out")
+    this.name = "HandshakeTimeoutError"
+  }
+}
+
+export function isAuthCloseCode(code: number): boolean {
+  if (code === 1008) return true
+  if (code === 4401 || code === 4403) return true
+  return false
+}
+
+export type EventHandler = (context: string, payload: unknown) => void
+
+export type EventServiceConfig = {
+  url: string
+  getToken: () => Promise<string>
+  onUnauthorized?: () => void
+}
+
+export function toHttpBase(wsBase: string): string {
+  const trimmed = wsBase.replace(/\/$/, "")
+  if (trimmed.startsWith("wss://")) return "https://" + trimmed.slice(6)
+  if (trimmed.startsWith("ws://")) return "http://" + trimmed.slice(5)
+  return trimmed
+}
+
+export async function fetchTicket(wsBaseUrl: string, token: string): Promise<string> {
+  const ctrl = new AbortController()
+  const timer = setTimeout(() => ctrl.abort(), TICKET_FETCH_TIMEOUT_MS)
+  try {
+    const res = await fetch(toHttpBase(wsBaseUrl) + "/connect-ticket", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${token}` },
+      signal: ctrl.signal,
+    })
+    if (res.status === 401 || res.status === 403) {
+      throw new WebSocketAuthError(`Event-service rejected ticket request: ${res.status}`)
+    }
+    if (!res.ok) {
+      throw new WebSocketConnectError(`Failed to mint event-service ticket: ${res.status}`, res.status)
+    }
+    const body = (await res.json().catch(() => null)) as { ticket?: unknown } | null
+    if (!body || typeof body.ticket !== "string" || !body.ticket) {
+      throw new WebSocketConnectError("Malformed event-service ticket response", 0)
+    }
+    return body.ticket
+  } catch (err) {
+    if (err instanceof WebSocketAuthError || err instanceof WebSocketConnectError) throw err
+    if ((err as { name?: string })?.name === "AbortError") {
+      throw new HandshakeTimeoutError()
+    }
+    throw new WebSocketConnectError(`Event-service ticket request failed: ${(err as Error)?.message ?? err}`, 0)
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+export function parseMessage(data: string, handlers: Map<string, Set<EventHandler>>): void {
+  if (data === "pong") return
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(data)
+  } catch {
+    return
+  }
+  if (!parsed || typeof parsed !== "object") return
+  const m = parsed as Record<string, unknown>
+  if (m.type === "event" && typeof m.context === "string" && typeof m.event === "string") {
+    const h = handlers.get(m.event)
+    if (h) {
+      for (const handler of h) handler(m.context, m.payload)
+    }
+    return
+  }
+  if (m.type === "error") {
+    console.warn("[Saeeol] event-service server error", m)
+  }
+}