@sleepy-ai/cli 0.0.0-main-202607032053 → 0.1.4

package/src/cli/cmd/tui/component/dialog-session-list.tsx

@@ -0,0 +1,269 @@
+import { useDialog } from "@tui/ui/dialog"
+import { DialogSelect } from "@tui/ui/dialog-select"
+import { useRoute } from "@tui/context/route"
+import { useSync } from "@tui/context/sync"
+import { createMemo, createResource, createSignal, onMount } from "solid-js"
+import { Locale } from "@/util"
+import { useProject } from "@tui/context/project"
+import { useKeybind } from "../context/keybind"
+import { useTheme } from "../context/theme"
+import { useSDK } from "../context/sdk"
+import { useLanguage } from "../context/language"
+import { Flag } from "@/flag/flag"
+import { DialogSessionRename } from "./dialog-session-rename"
+import { Keybind } from "@/util"
+import { createDebouncedSignal } from "../util/signal"
+import { useToast } from "../ui/toast"
+import { DialogWorkspaceCreate, openWorkspaceSession, restoreWorkspaceSession } from "./dialog-workspace-create"
+import { Spinner } from "./spinner"
+import { errorMessage } from "@/util/error"
+import { DialogSessionDeleteFailed } from "./dialog-session-delete-failed"
+
+type WorkspaceStatus = "connected" | "connecting" | "disconnected" | "error"
+
+export function DialogSessionList() {
+  const dialog = useDialog()
+  const route = useRoute()
+  const sync = useSync()
+  const project = useProject()
+  const keybind = useKeybind()
+  const { theme } = useTheme()
+  const sdk = useSDK()
+  const toast = useToast()
+  const { t } = useLanguage()
+  const [toDelete, setToDelete] = createSignal<string>()
+  const [search, setSearch] = createDebouncedSignal("", 150)
+
+  const [searchResults, { refetch }] = createResource(search, async (query) => {
+    if (!query) return undefined
+    const result = await sdk.client.session.list({ search: query, limit: 30 })
+    return result.data ?? []
+  })
+
+  const currentSessionID = createMemo(() => (route.data.type === "session" ? route.data.sessionID : undefined))
+  const sessions = createMemo(() => searchResults() ?? sync.data.session)
+
+  function createWorkspace() {
+    dialog.replace(() => (
+      <DialogWorkspaceCreate
+        onSelect={(workspaceID) =>
+          openWorkspaceSession({
+            dialog,
+            route,
+            sdk,
+            sync,
+            toast,
+            workspaceID,
+          })
+        }
+      />
+    ))
+  }
+
+  function recover(session: NonNullable<ReturnType<typeof sessions>[number]>) {
+    const workspace = project.workspace.get(session.workspaceID!)
+    const list = () => dialog.replace(() => <DialogSessionList />)
+    dialog.replace(() => (
+      <DialogSessionDeleteFailed
+        session={session.title}
+        workspace={workspace?.name ?? session.workspaceID!}
+        onDone={list}
+        onDelete={async () => {
+          const current = currentSessionID()
+          const info = current ? sync.data.session.find((item) => item.id === current) : undefined
+          const result = await sdk.client.experimental.workspace.remove({ id: session.workspaceID! })
+          if (result.error) {
+            toast.show({
+              variant: "error",
+              title: "Failed to delete workspace",
+              message: errorMessage(result.error),
+            })
+            return false
+          }
+          await project.workspace.sync()
+          await sync.session.refresh()
+          if (search()) await refetch()
+          if (info?.workspaceID === session.workspaceID) {
+            route.navigate({ type: "home" })
+          }
+          return true
+        }}
+        onRestore={() => {
+          dialog.replace(() => (
+            <DialogWorkspaceCreate
+              onSelect={(workspaceID) =>
+                restoreWorkspaceSession({
+                  dialog,
+                  sdk,
+                  sync,
+                  project,
+                  toast,
+                  workspaceID,
+                  sessionID: session.id,
+                  done: list,
+                })
+              }
+            />
+          ))
+          return false
+        }}
+      />
+    ))
+  }
+
+  const options = createMemo(() => {
+    const today = new Date().toDateString()
+    const isAutoSession = (x: { title: string }) => x.title === "Auto Dream" || x.title === "Auto Distill"
+    return sessions()
+      .filter((x) => x.parentID === undefined)
+      .toSorted((a, b) => {
+        const updatedDay = new Date(b.time.updated).setHours(0, 0, 0, 0) - new Date(a.time.updated).setHours(0, 0, 0, 0)
+        if (updatedDay !== 0) return updatedDay
+        return b.time.created - a.time.created
+      })
+      .map((x) => {
+        const workspace = x.workspaceID ? project.workspace.get(x.workspaceID) : undefined
+
+        let workspaceStatus: WorkspaceStatus | null = null
+        if (x.workspaceID) {
+          workspaceStatus = project.workspace.status(x.workspaceID) || "error"
+        }
+
+        let footer = ""
+        if (Flag.SLEEPYCODE_EXPERIMENTAL_WORKSPACES) {
+          if (x.workspaceID) {
+            let desc = "unknown"
+            if (workspace) {
+              desc = `${workspace.type}: ${workspace.name}`
+            }
+
+            footer = (
+              <>
+                {desc}{" "}
+                <span
+                  style={{
+                    fg: workspaceStatus === "connected" ? theme.success : theme.error,
+                  }}
+                >
+                  ●
+                </span>
+              </>
+            )
+          }
+        } else {
+          footer = Locale.time(x.time.updated)
+        }
+
+        const date = new Date(x.time.updated)
+        let category = date.toDateString()
+        if (category === today) {
+          category = "Today"
+        }
+        const isDeleting = toDelete() === x.id
+        const status = sync.data.session_status?.[x.id]
+        const isWorking = status?.type === "busy"
+        return {
+          title: isDeleting
+            ? `Press ${keybind.print("session_delete")} again to confirm`
+            : isAutoSession(x)
+              ? `[${t("tui.session.badge.auto")}] ${x.title}`
+              : x.title,
+          bg: isDeleting ? theme.error : undefined,
+          value: x.id,
+          category,
+          footer,
+          gutter: isWorking ? <Spinner /> : undefined,
+        }
+      })
+  })
+
+  onMount(() => {
+    dialog.setSize("large")
+  })
+
+  return (
+    <DialogSelect
+      title="Sessions"
+      options={options()}
+      skipFilter={true}
+      current={currentSessionID()}
+      onFilter={setSearch}
+      onMove={() => {
+        setToDelete(undefined)
+      }}
+      onSelect={(option) => {
+        route.navigate({
+          type: "session",
+          sessionID: option.value,
+        })
+        dialog.clear()
+      }}
+      keybind={[
+        {
+          keybind: keybind.all.session_delete?.[0],
+          title: "delete",
+          onTrigger: async (option) => {
+            if (toDelete() === option.value) {
+              const session = sessions().find((item) => item.id === option.value)
+              const status = session?.workspaceID ? project.workspace.status(session.workspaceID) : undefined
+
+              try {
+                const result = await sdk.client.session.delete({
+                  sessionID: option.value,
+                })
+                if (result.error) {
+                  if (session?.workspaceID) {
+                    recover(session)
+                  } else {
+                    toast.show({
+                      variant: "error",
+                      title: "Failed to delete session",
+                      message: errorMessage(result.error),
+                    })
+                  }
+                  setToDelete(undefined)
+                  return
+                }
+              } catch (err) {
+                if (session?.workspaceID) {
+                  recover(session)
+                } else {
+                  toast.show({
+                    variant: "error",
+                    title: "Failed to delete session",
+                    message: errorMessage(err),
+                  })
+                }
+                setToDelete(undefined)
+                return
+              }
+              if (status && status !== "connected") {
+                await sync.session.refresh()
+              }
+              if (search()) await refetch()
+              setToDelete(undefined)
+              return
+            }
+            setToDelete(option.value)
+          },
+        },
+        {
+          keybind: keybind.all.session_rename?.[0],
+          title: "rename",
+          onTrigger: async (option) => {
+            dialog.replace(() => <DialogSessionRename session={option.value} />)
+          },
+        },
+        {
+          keybind: Keybind.parse("ctrl+w")[0],
+          title: "new workspace",
+          side: "right",
+          disabled: !Flag.SLEEPYCODE_EXPERIMENTAL_WORKSPACES,
+          onTrigger: () => {
+            createWorkspace()
+          },
+        },
+      ]}
+    />
+  )
+}

package/src/cli/cmd/tui/component/dialog-session-rename.tsx

@@ -0,0 +1,31 @@
+import { DialogPrompt } from "@tui/ui/dialog-prompt"
+import { useDialog } from "@tui/ui/dialog"
+import { useSync } from "@tui/context/sync"
+import { createMemo } from "solid-js"
+import { useSDK } from "../context/sdk"
+
+interface DialogSessionRenameProps {
+  session: string
+}
+
+export function DialogSessionRename(props: DialogSessionRenameProps) {
+  const dialog = useDialog()
+  const sync = useSync()
+  const sdk = useSDK()
+  const session = createMemo(() => sync.session.get(props.session))
+
+  return (
+    <DialogPrompt
+      title="Rename Session"
+      value={session()?.title}
+      onConfirm={(value) => {
+        void sdk.client.session.update({
+          sessionID: props.session,
+          title: value,
+        })
+        dialog.clear()
+      }}
+      onCancel={() => dialog.clear()}
+    />
+  )
+}

package/src/cli/cmd/tui/component/dialog-skill.tsx

@@ -0,0 +1,42 @@
+import { DialogSelect, type DialogSelectOption } from "@tui/ui/dialog-select"
+import { createResource, createMemo } from "solid-js"
+import { useDialog } from "@tui/ui/dialog"
+import { useSDK } from "@tui/context/sdk"
+import { useLocal } from "@tui/context/local"
+
+export type DialogSkillProps = {
+  onSelect: (skill: string) => void
+}
+
+export function DialogSkill(props: DialogSkillProps) {
+  const dialog = useDialog()
+  const sdk = useSDK()
+  const local = useLocal()
+  dialog.setSize("large")
+
+  const [skills] = createResource(async () => {
+    const result = await sdk.client.app.skills()
+    return result.data ?? []
+  })
+
+  const options = createMemo<DialogSelectOption<string>[]>(() => {
+    let list = skills() ?? []
+    const isCompose = local.agent.current()?.name === "compose"
+    if (!isCompose) {
+      list = list.filter((s) => !s.name.startsWith("compose:"))
+    }
+    const maxWidth = Math.max(0, ...list.map((s) => s.name.length))
+    return list.map((skill) => ({
+      title: skill.name.padEnd(maxWidth),
+      description: skill.description?.replace(/\s+/g, " ").trim(),
+      value: skill.name,
+      category: "Skills",
+      onSelect: () => {
+        props.onSelect(skill.name)
+        dialog.clear()
+      },
+    }))
+  })
+
+  return <DialogSelect title="Skills" placeholder="Search skills..." options={options()} />
+}

package/src/cli/cmd/tui/component/dialog-sleepy-login.tsx

@@ -0,0 +1,288 @@
+import { createMemo, createSignal, onMount, Show } from "solid-js"
+import { useSDK } from "../context/sdk"
+import { useSync } from "@tui/context/sync"
+import { useLocal } from "@tui/context/local"
+import { useDialog } from "@tui/ui/dialog"
+import { useTheme } from "../context/theme"
+import { useLanguage } from "../context/language"
+import { createDialogProviderOptions } from "./dialog-provider"
+import { DialogSelect } from "@tui/ui/dialog-select"
+import { DialogPrompt } from "../ui/dialog-prompt"
+import { useToast } from "../ui/toast"
+import * as Clipboard from "@tui/util/clipboard"
+import { useRenderer } from "@opentui/solid"
+import { TextAttributes } from "@opentui/core"
+import os from "os"
+import path from "path"
+import {
+  startDeviceFlow,
+  pollDeviceToken,
+  writeConfig,
+  getDashboardUrl,
+  type DeviceCodeResponse,
+} from "../../login"
+import { Global } from "@/global"
+import open from "open"
+
+export function DialogSleepyLogin() {
+  const dialog = useDialog()
+  const sdk = useSDK()
+  const sync = useSync()
+  const local = useLocal()
+  const toast = useToast()
+  const { t } = useLanguage()
+  const providerOptions = createDialogProviderOptions()
+
+  const options = createMemo(() => {
+    const recommended = [
+      {
+        title: "Sleepy Login",
+        value: "sleepy",
+        description: "Authenticate via Sleepy Dashboard (browser or device code)",
+        category: "Recommended",
+        onSelect: async () => {
+          dialog.replace(() => <SleepyDeviceFlow />)
+        },
+      },
+      {
+        title: t("tui.dialog.login.import_claude"),
+        value: "import_claude",
+        category: "Recommended",
+        onSelect: async () => {
+          const claudeDir = path.join(os.homedir(), ".claude")
+          const candidates = ["settings.json", "settings.local.json", "settings_local.json"]
+
+          const resolve = await (async () => {
+            const envs: Record<string, string>[] = []
+            for (const file of candidates) {
+              try {
+                const content = await Bun.file(path.join(claudeDir, file)).json()
+                if (content?.env && typeof content.env === "object") envs.push(content.env)
+              } catch {}
+            }
+            return (name: string) => {
+              for (let i = envs.length - 1; i >= 0; i--) {
+                const v = envs[i][name]
+                if (v && typeof v === "string") return v
+              }
+              return process.env[name]
+            }
+          })()
+
+          const key = resolve("ANTHROPIC_API_KEY")
+          const rawBaseUrl = resolve("ANTHROPIC_BASE_URL")
+          const baseUrl = rawBaseUrl
+            ? rawBaseUrl.replace(/\/+$/, "").replace(/(?<!\/v1)$/, "/v1")
+            : undefined
+          // strip Claude Code context-window suffix e.g. claude-opus-4-6[1m]
+          const preferredModel = (
+            resolve("ANTHROPIC_DEFAULT_OPUS_MODEL") ?? resolve("ANTHROPIC_DEFAULT_SONNET_MODEL")
+          )?.replace(/\[.*\]$/, "")
+
+          if (!key) {
+            toast.show({ message: t("tui.dialog.login.import_claude.no_key"), variant: "error" })
+            dialog.clear()
+            return
+          }
+
+          await sdk.client.auth.set({
+            providerID: "anthropic",
+            auth: { type: "api", key },
+          })
+          await sdk.client.global.config.update({
+            config: {
+              provider: {
+                anthropic: { options: { baseURL: baseUrl || "https://api.anthropic.com/v1" } },
+              },
+            },
+          })
+          await sdk.client.instance.dispose()
+          await sync.bootstrap()
+
+          const anthropic = sync.data.provider.find((p) => p.id === "anthropic")
+          if (anthropic) {
+            if (preferredModel && !(preferredModel in anthropic.models)) {
+              await sdk.client.global.config.update({
+                config: {
+                  provider: {
+                    anthropic: { models: { [preferredModel]: { name: preferredModel } } },
+                  },
+                },
+              })
+              await sdk.client.instance.dispose()
+              await sync.bootstrap()
+            }
+            const models = Object.keys(anthropic.models).sort()
+            const selected = preferredModel
+              || models.find((m) => m === "claude-opus-4-6")
+              || models.findLast((m) => m.includes("opus"))
+              || models.findLast((m) => m.includes("sonnet"))
+              || models[0]
+            if (selected) {
+              local.model.set({ providerID: "anthropic", modelID: selected }, { recent: true })
+            }
+          }
+          toast.show({ message: t("tui.dialog.login.import_claude.success"), variant: "info" })
+          dialog.clear()
+        },
+      },
+    ]
+
+    return [
+      ...recommended,
+      ...providerOptions().filter((option) => option.value !== "sleepy" && option.value !== "xiaomi"),
+    ]
+  })
+
+  return (
+    <DialogSelect
+      title={t("tui.dialog.login.title")}
+      options={options()}
+    />
+  )
+}
+
+function SleepyDeviceFlow() {
+  const dialog = useDialog()
+  const sdk = useSDK()
+  const sync = useSync()
+  const local = useLocal()
+  const { theme } = useTheme()
+  const toast = useToast()
+  const renderer = useRenderer()
+  const [copied, setCopied] = createSignal(false)
+  const [busy, setBusy] = createSignal(false)
+  const [deviceData, setDeviceData] = createSignal<DeviceCodeResponse | null>(null)
+  const [error, setError] = createSignal<string | null>(null)
+
+  function copyUrl() {
+    const url = deviceData()?.verification_uri_complete
+    if (!url) return
+    Clipboard.copy(url)
+      .then(() => {
+        setCopied(true)
+        setTimeout(() => setCopied(false), 2000)
+      })
+      .catch(toast.error)
+  }
+
+  function copyCode() {
+    const code = deviceData()?.user_code
+    if (!code) return
+    Clipboard.copy(code)
+      .then(() => {
+        setCopied(true)
+        setTimeout(() => setCopied(false), 2000)
+      })
+      .catch(toast.error)
+  }
+
+  onMount(async () => {
+    const dashboardUrl = getDashboardUrl()
+
+    let device: DeviceCodeResponse
+    try {
+      device = await startDeviceFlow(dashboardUrl)
+    } catch (err: any) {
+      setError(err?.message ?? "Failed to start device login")
+      return
+    }
+
+    setDeviceData(device)
+
+    try {
+      await open(device.verification_uri_complete)
+    } catch {
+      // Browser may not open in all environments
+    }
+
+    setBusy(true)
+
+    const pollMs = (device.interval ?? 5) * 1000
+
+    while (true) {
+      await new Promise((resolve) => setTimeout(resolve, pollMs))
+
+      try {
+        const tokenData = await pollDeviceToken(dashboardUrl, device.device_code)
+        const configPath = path.join(Global.Path.config, "gateway.json")
+        await writeConfig(configPath, {
+          access_token: tokenData.access_token,
+          endpoint: tokenData.endpoint,
+          tier: tokenData.tier,
+          email: tokenData.email,
+          dashboard_url: dashboardUrl,
+        })
+        await sdk.client.instance.dispose()
+        await sync.bootstrap()
+        local.model.set({ providerID: "sleepy", modelID: "smart" }, { recent: true })
+        toast.show({ message: "Login successful!", variant: "success" })
+        dialog.clear()
+        return
+      } catch (err: any) {
+        if (err.code === "authorization_pending" || err.code === "slow_down") continue
+        if (err.code === "expired_token") {
+          setError("Login expired. Please try again.")
+          return
+        }
+        if (err.code === "access_denied") {
+          setError("Login denied.")
+          return
+        }
+        setError(err?.message ?? "Login failed")
+        return
+      }
+    }
+  })
+
+  return (
+    <DialogPrompt
+      title="Sleepy Device Login"
+      placeholder=""
+      busy={busy()}
+      busyText="Waiting for authorization..."
+      description={
+        <box gap={1}>
+          <Show when={error()}>
+            <text fg={theme.error}>{error()}</text>
+            <text
+              fg={theme.primary}
+              attributes={TextAttributes.UNDERLINE}
+              onMouseUp={() => dialog.replace(() => <SleepyDeviceFlow />)}
+            >
+              Try again
+            </text>
+          </Show>
+          <Show when={!error() && deviceData()}>
+            <text fg={theme.textMuted}>
+              Open the URL below in your browser and enter the code to authenticate.
+              <Show when={copied()}>{" "}<span style={{ fg: theme.primary }}>(Copied!)</span></Show>
+            </text>
+            <text
+              fg={theme.primary}
+              onMouseUp={() => {
+                if (renderer.getSelection()?.getSelectedText()) return
+                copyUrl()
+              }}
+            >
+              {deviceData()!.verification_uri_complete}
+            </text>
+            <box gap={1} alignItems="center">
+              <text fg={theme.textMuted}>Code:</text>
+              <text
+                fg={theme.accent}
+                attributes={TextAttributes.BOLD}
+                onMouseUp={() => {
+                  if (renderer.getSelection()?.getSelectedText()) return
+                  copyCode()
+                }}
+              >
+                {deviceData()!.user_code}
+              </text>
+            </box>
+          </Show>
+        </box>
+      }
+    />
+  )
+}