saeeol 1.2.2 → 1.2.3

package/src/cli/cmd/tui/context/prompt.tsx

@@ -1,18 +1 @@
-import { createSimpleContext } from "./helper"
-import type { PromptRef } from "../component/prompt"
-
-export const { use: usePromptRef, provider: PromptRefProvider } = createSimpleContext({
-  name: "PromptRef",
-  init: () => {
-    let current: PromptRef | undefined
-
-    return {
-      get current() {
-        return current
-      },
-      set(ref: PromptRef | undefined) {
-        current = ref
-      },
-    }
-  },
-})
+export * from "./session/prompt"

package/src/cli/cmd/tui/context/route.tsx

@@ -1,67 +1 @@
-import { createStore, reconcile, unwrap } from "solid-js/store" 
-import { createSimpleContext } from "./helper"
-import type { PromptInfo } from "../component/prompt/history"
-
-export type HomeRoute = {
-  type: "home"
-  prompt?: PromptInfo
-}
-
-export type SessionRoute = {
-  type: "session"
-  sessionID: string
-  prompt?: PromptInfo
-}
-export type SaeeolClawRoute = {
-  type: "saeeolclaw"
-}
-
-export type LocalModelsRoute = {
-  type: "local-models"
-}
-
-export type PluginRoute = {
-  type: "plugin"
-  id: string
-  data?: Record<string, unknown>
-}
-
-export type Route = HomeRoute | SessionRoute | PluginRoute | SaeeolClawRoute | LocalModelsRoute 
-
-export const { use: useRoute, provider: RouteProvider } = createSimpleContext({
-  name: "Route",
-  init: (props: { initialRoute?: Route }) => {
-    const [store, setStore] = createStore<Route>(
-      props.initialRoute ??
-        (process.env["SAEEOL_ROUTE"]
-          ? JSON.parse(process.env["SAEEOL_ROUTE"])
-          : {
-              type: "home",
-            }),
-    )
-    let previous: Route | undefined
-
-    return {
-      get data() {
-        return store
-      },
-      navigate(route: Route) {
-        previous = structuredClone(unwrap(store)) 
-        setStore(reconcile(route))
-      },
-      back() {
-        const target = previous ?? ({ type: "home" } as const)
-        previous = undefined
-        console.log("navigate", target)
-        setStore(target)
-      },
-    }
-  },
-})
-
-export type RouteContext = ReturnType<typeof useRoute>
-
-export function useRouteData<T extends Route["type"]>(type: T) {
-  const route = useRoute()
-  return route.data as Extract<Route, { type: typeof type }>
-}
+export * from "./app/route"

package/src/cli/cmd/tui/context/runtime/event.ts

@@ -0,0 +1,45 @@
+import type { Event } from "@saeeol/sdk/v2"
+import { useProject } from "../app/project"
+import { useSDK } from "../app/sdk"
+
+export function useEvent() {
+  const project = useProject()
+  const sdk = useSDK()
+
+  function subscribe(handler: (event: Event) => void) {
+    return sdk.event.on("event", (event) => {
+      if (event.payload.type === "sync") {
+        return
+      }
+
+      // Special hack for truly global events
+      if (event.directory === "global") {
+        handler(event.payload)
+      }
+
+      if (project.workspace.current()) {
+        if (event.workspace === project.workspace.current()) {
+          handler(event.payload)
+        }
+
+        return
+      }
+
+      if (event.directory === project.instance.directory()) {
+        handler(event.payload)
+      }
+    })
+  }
+
+  function on<T extends Event["type"]>(type: T, handler: (event: Extract<Event, { type: T }>) => void) {
+    return subscribe((event) => {
+      if (event.type !== type) return
+      handler(event as Extract<Event, { type: T }>)
+    })
+  }
+
+  return {
+    subscribe,
+    on,
+  }
+}

package/src/cli/cmd/tui/context/runtime/exit.tsx

@@ -0,0 +1,67 @@
+import { useRenderer } from "@opentui/solid"
+import { createSimpleContext } from "../app/helper"
+import { FormatError, FormatUnknownError } from "@/cli/error"
+import { win32FlushInputBuffer } from "../../win32"
+import { resetTerminalState } from "@/saeeol/cli/cmd/tui/util/terminal" 
+type Exit = ((reason?: unknown) => Promise<void>) & {
+  message: {
+    set: (value?: string) => () => void
+    clear: () => void
+    get: () => string | undefined
+  }
+  restart: () => Promise<void>
+}
+
+export const { use: useExit, provider: ExitProvider } = createSimpleContext({
+  name: "Exit",
+  init: (input: { onBeforeExit?: () => Promise<void>; onExit?: () => Promise<void> }) => {
+    const renderer = useRenderer()
+    let message: string | undefined
+    let task: Promise<void> | undefined
+    const store = {
+      set: (value?: string) => {
+        const prev = message
+        message = value
+        return () => {
+          message = prev
+        }
+      },
+      clear: () => {
+        message = undefined
+      },
+      get: () => message,
+    }
+    const exit: Exit = Object.assign(
+      (reason?: unknown) => {
+        if (task) return task
+        task = (async () => {
+          await input.onBeforeExit?.()
+          // Reset window title before destroying renderer
+          renderer.setTerminalTitle("")
+          renderer.destroy()
+          win32FlushInputBuffer()
+          resetTerminalState() 
+          if (reason) {
+            const formatted = FormatError(reason) ?? FormatUnknownError(reason)
+            if (formatted) {
+              process.stderr.write(formatted + "\n")
+            }
+          }
+          const text = store.get()
+          if (text) process.stdout.write(text + "\n")
+          await input.onExit?.()
+        })()
+        return task
+      },
+      {
+        message: store,
+        restart: () => {
+          globalThis.__SAEEOL_RESTART = true
+          return exit()
+        },
+      },
+    )
+    process.on("SIGHUP", () => exit())
+    return exit
+  },
+})

package/src/cli/cmd/tui/context/runtime/keybind.tsx

@@ -0,0 +1,105 @@
+import { createMemo } from "solid-js"
+import { Keybind } from "@/util/keybind"
+import { pipe, mapValues } from "remeda"
+import type { TuiConfig } from "@/cli/cmd/tui/config/tui"
+import type { ParsedKey, Renderable } from "@opentui/core"
+import { createStore } from "solid-js/store"
+import { useKeyboard, useRenderer } from "@opentui/solid"
+import { createSimpleContext } from "../app/helper"
+import { useTuiConfig } from "../app/tui-config"
+
+export type KeybindKey = keyof NonNullable<TuiConfig.Info["keybinds"]> & string
+
+export const { use: useKeybind, provider: KeybindProvider } = createSimpleContext({
+  name: "Keybind",
+  init: () => {
+    const config = useTuiConfig()
+    const keybinds = createMemo<Record<string, Keybind.Info[]>>(() => {
+      return pipe(
+        (config.keybinds ?? {}) as Record<string, string>,
+        mapValues((value) => Keybind.parse(value)),
+      )
+    })
+    const [store, setStore] = createStore({
+      leader: false,
+    })
+    const renderer = useRenderer()
+
+    let focus: Renderable | null
+    let timeout: NodeJS.Timeout
+    function leader(active: boolean) {
+      if (active) {
+        setStore("leader", true)
+        focus = renderer.currentFocusedRenderable
+        focus?.blur()
+        if (timeout) clearTimeout(timeout)
+        timeout = setTimeout(() => {
+          if (!store.leader) return
+          leader(false)
+          if (!focus || focus.isDestroyed) return
+          focus.focus()
+        }, 2000)
+        return
+      }
+
+      if (!active) {
+        if (focus && !renderer.currentFocusedRenderable) {
+          focus.focus()
+        }
+        setStore("leader", false)
+      }
+    }
+
+    useKeyboard(async (evt) => {
+      if (!store.leader && result.match("leader", evt)) {
+        leader(true)
+        return
+      }
+
+      if (store.leader && evt.name) {
+        setImmediate(() => {
+          if (focus && renderer.currentFocusedRenderable === focus) {
+            focus.focus()
+          }
+          leader(false)
+        })
+      }
+    })
+
+    const result = {
+      get all() {
+        return keybinds()
+      },
+      get leader() {
+        return store.leader
+      },
+      parse(evt: ParsedKey): Keybind.Info {
+        // Handle special case for Ctrl+Underscore (represented as \x1F)
+        if (evt.name === "\x1F") {
+          return Keybind.fromParsedKey({ ...evt, name: "_", ctrl: true }, store.leader)
+        }
+        return Keybind.fromParsedKey(evt, store.leader)
+      },
+      match(key: string, evt: ParsedKey) {
+        const list = keybinds()[key] ?? Keybind.parse(key)
+        if (!list.length) return false
+        const parsed: Keybind.Info = result.parse(evt)
+        for (const item of list) {
+          if (Keybind.match(item, parsed)) {
+            return true
+          }
+        }
+        return false
+      },
+      print(key: string) {
+        const first = keybinds()[key]?.at(0) ?? Keybind.parse(key).at(0)
+        if (!first) return ""
+        const text = Keybind.toString(first)
+        const lead = keybinds().leader?.[0]
+        if (!lead) return text
+        return text.replace("<leader>", Keybind.toString(lead))
+      },
+    }
+    return result
+  },
+})

package/src/cli/cmd/tui/context/runtime/kv.tsx

@@ -0,0 +1,76 @@
+import { Global } from "@saeeol/core/global"
+import { Filesystem } from "@/util/filesystem"
+import { Flock } from "@saeeol/core/util/flock"
+import { rename, rm } from "fs/promises"
+import { createSignal, type Setter } from "solid-js"
+import { createStore, unwrap } from "solid-js/store"
+import { createSimpleContext } from "../app/helper"
+import path from "path"
+
+export const { use: useKV, provider: KVProvider } = createSimpleContext({
+  name: "KV",
+  init: () => {
+    const [ready, setReady] = createSignal(false)
+    const [store, setStore] = createStore<Record<string, any>>()
+    const filePath = path.join(Global.Path.state, "kv.json")
+    const lock = `tui-kv:${filePath}`
+    // Queue same-process writes so rapid updates persist in order.
+    let write = Promise.resolve()
+
+    // Write to a temp file first so kv.json is only replaced once the JSON is complete, avoiding partial writes if shutdown interrupts persistence.
+    function writeSnapshot(snapshot: Record<string, any>) {
+      const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`
+      return Filesystem.writeJson(tempPath, snapshot)
+        .then(() => rename(tempPath, filePath))
+        .catch(async (error) => {
+          await rm(tempPath, { force: true }).catch(() => undefined)
+          throw error
+        })
+    }
+
+    // Read under the same lock used for writes because kv.json is shared across processes.
+    Flock.withLock(lock, () => Filesystem.readJson<Record<string, any>>(filePath))
+      .then((x) => {
+        setStore(x)
+      })
+      .catch((error) => {
+        console.error("Failed to read KV state", { filePath, error })
+      })
+      .finally(() => {
+        setReady(true)
+      })
+
+    const result = {
+      get ready() {
+        return ready()
+      },
+      get store() {
+        return store
+      },
+      signal<T>(name: string, defaultValue: T) {
+        if (store[name] === undefined) setStore(name, defaultValue)
+        return [
+          function () {
+            return result.get(name)
+          },
+          function setter(next: Setter<T>) {
+            result.set(name, next)
+          },
+        ] as const
+      },
+      get(key: string, defaultValue?: any) {
+        return store[key] ?? defaultValue
+      },
+      set(key: string, value: any) {
+        setStore(key, value)
+        const snapshot = structuredClone(unwrap(store))
+        write = write
+          .then(() => Flock.withLock(lock, () => writeSnapshot(snapshot)))
+          .catch((error) => {
+            console.error("Failed to write KV state", { filePath, error })
+          })
+      },
+    }
+    return result
+  },
+})