@sleepy-ai/cli 0.1.6 → 0.1.7

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

@@ -1,269 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,288 +0,0 @@
-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>
-      }
-    />
-  )
-}