@sleepy-ai/cli 0.1.6 → 0.1.8

package/src/cli/cmd/tui/routes/session/subagent-footer.tsx

@@ -1,143 +0,0 @@
-import { createMemo, createSignal, Show } from "solid-js"
-import { useRouteData, useCurrentAgentID } from "@tui/context/route"
-import { useSync } from "@tui/context/sync"
-import { useTheme } from "@tui/context/theme"
-import { SplitBorder } from "@tui/component/border"
-import type { AssistantMessage } from "@sleepy-ai/sdk/v2"
-import { useCommandDialog } from "@tui/component/dialog-command"
-import { useKeybind } from "../../context/keybind"
-import { Locale } from "@/util"
-import { useTerminalDimensions } from "@opentui/solid"
-
-export function SubagentFooter() {
-  const route = useRouteData("session")
-  const sync = useSync()
-  const currentAgentID = useCurrentAgentID()
-
-  const actors = createMemo(() =>
-    (sync.data.actor[route.sessionID] ?? [])
-      .filter((a) => a.mode === "subagent")
-      .toSorted((a, b) => a.time_created - b.time_created),
-  )
-
-  const subagentInfo = createMemo(() => {
-    const cur = currentAgentID()
-    const list = actors()
-    const idx = list.findIndex((a) => a.actor_id === cur)
-    const entry = idx === -1 ? undefined : list[idx]
-    return {
-      label: entry ? Locale.titlecase(entry.agent) : "Subagent",
-      index: idx + 1,
-      total: list.length,
-      status: entry?.status,
-    }
-  })
-
-  const messages = createMemo(
-    () => sync.data.message[route.sessionID]?.[currentAgentID()] ?? [],
-  )
-
-  const usage = createMemo(() => {
-    const msg = messages()
-    const last = msg.findLast(
-      (item): item is AssistantMessage => item.role === "assistant" && item.tokens.output > 0,
-    )
-    if (!last) return
-    const tokens =
-      last.tokens.input +
-      last.tokens.output +
-      last.tokens.reasoning +
-      last.tokens.cache.read +
-      last.tokens.cache.write
-    if (tokens <= 0) return
-    const model = sync.data.provider.find((item) => item.id === last.providerID)?.models[last.modelID]
-    const pct = model?.limit.context
-      ? `${Math.round((tokens / model.limit.context) * 100)}%`
-      : undefined
-    const cost = msg.reduce(
-      (sum, item) => sum + (item.role === "assistant" ? item.cost : 0),
-      0,
-    )
-    const money = new Intl.NumberFormat("en-US", { style: "currency", currency: "USD" })
-    return {
-      context: pct ? `${Locale.number(tokens)} (${pct})` : Locale.number(tokens),
-      cost: cost > 0 ? money.format(cost) : undefined,
-    }
-  })
-
-  const { theme } = useTheme()
-  const keybind = useKeybind()
-  const command = useCommandDialog()
-  const [hover, setHover] = createSignal<"parent" | "prev" | "next" | null>(null)
-  useTerminalDimensions()
-
-  return (
-    <box flexShrink={0}>
-      <box
-        paddingTop={1}
-        paddingBottom={1}
-        paddingLeft={2}
-        paddingRight={1}
-        {...SplitBorder}
-        border={["left"]}
-        borderColor={theme.border}
-        flexShrink={0}
-        backgroundColor={theme.backgroundPanel}
-      >
-        <box flexDirection="row" justifyContent="space-between" gap={1}>
-          <box flexDirection="row" gap={1}>
-            <text fg={theme.text}>
-              <b>{subagentInfo().label}</b>
-            </text>
-            <Show when={subagentInfo().total > 0}>
-              <text style={{ fg: theme.textMuted }}>
-                ({subagentInfo().index} of {subagentInfo().total})
-                <Show when={subagentInfo().status}>{` · ${subagentInfo().status}`}</Show>
-              </text>
-            </Show>
-            <Show when={usage()}>
-              {(item) => (
-                <text fg={theme.textMuted} wrapMode="none">
-                  {[item().context, item().cost].filter(Boolean).join(" · ")}
-                </text>
-              )}
-            </Show>
-          </box>
-          <box flexDirection="row" gap={2}>
-            <box
-              onMouseOver={() => setHover("parent")}
-              onMouseOut={() => setHover(null)}
-              onMouseUp={() => command.trigger("session.parent")}
-              backgroundColor={hover() === "parent" ? theme.backgroundElement : theme.backgroundPanel}
-            >
-              <text fg={theme.text}>
-                {route.fromWorkflowRunID ? "Workflow" : "Main"}{" "}
-                <span style={{ fg: theme.textMuted }}>{keybind.print("session_parent")}</span>
-              </text>
-            </box>
-            <box
-              onMouseOver={() => setHover("prev")}
-              onMouseOut={() => setHover(null)}
-              onMouseUp={() => command.trigger("session.child.previous")}
-              backgroundColor={hover() === "prev" ? theme.backgroundElement : theme.backgroundPanel}
-            >
-              <text fg={theme.text}>
-                Prev <span style={{ fg: theme.textMuted }}>{keybind.print("session_child_cycle_reverse")}</span>
-              </text>
-            </box>
-            <box
-              onMouseOver={() => setHover("next")}
-              onMouseOut={() => setHover(null)}
-              onMouseUp={() => command.trigger("session.child.next")}
-              backgroundColor={hover() === "next" ? theme.backgroundElement : theme.backgroundPanel}
-            >
-              <text fg={theme.text}>
-                Next <span style={{ fg: theme.textMuted }}>{keybind.print("session_child_cycle")}</span>
-              </text>
-            </box>
-          </box>
-        </box>
-      </box>
-    </box>
-  )
-}

package/src/cli/cmd/tui/thread.ts

@@ -1,324 +0,0 @@
-import { cmd } from "@/cli/cmd/cmd"
-import { tui } from "./app"
-import { Rpc } from "@/util"
-import { type rpc } from "./worker"
-import path from "path"
-import { fileURLToPath } from "url"
-import { UI } from "@/cli/ui"
-import { Log } from "@/util"
-import { errorMessage } from "@/util/error"
-import { withTimeout } from "@/util/timeout"
-import { withNetworkOptions, resolveNetworkOptionsNoConfig } from "@/cli/network"
-import { Filesystem } from "@/util"
-import type { GlobalEvent } from "@sleepy-ai/sdk/v2"
-import type { EventSource } from "./context/sdk"
-import { win32DisableProcessedInput, win32InstallCtrlCGuard } from "./win32"
-import { writeHeapSnapshot } from "v8"
-import { TuiConfig } from "./config/tui"
-import { SLEEPYCODE_PROCESS_ROLE, SLEEPYCODE_RUN_ID, ensureRunID, sanitizedProcessEnv } from "@/util/sleepy-process"
-import { checkTrust, markTrusted } from "@/project/workspace-trust"
-import { t } from "@/cli/i18n"
-
-declare global {
-  const OPENCODE_WORKER_PATH: string
-}
-
-type RpcClient = ReturnType<typeof Rpc.client<typeof rpc>>
-
-function createWorkerFetch(client: RpcClient): typeof fetch {
-  const fn = async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
-    const request = new Request(input, init)
-    const body = request.body ? await request.text() : undefined
-    const result = await client.call("fetch", {
-      url: request.url,
-      method: request.method,
-      headers: Object.fromEntries(request.headers.entries()),
-      body,
-    })
-    return new Response(result.body, {
-      status: result.status,
-      headers: result.headers,
-    })
-  }
-  return fn as typeof fetch
-}
-
-function createEventSource(client: RpcClient): EventSource {
-  return {
-    subscribe: async (handler) => {
-      return client.on<GlobalEvent>("global.event", (e) => {
-        handler(e)
-      })
-    },
-  }
-}
-
-async function target() {
-  if (typeof OPENCODE_WORKER_PATH !== "undefined") return OPENCODE_WORKER_PATH
-  const dist = new URL("./cli/cmd/tui/worker.js", import.meta.url)
-  if (await Filesystem.exists(fileURLToPath(dist))) return dist
-  return new URL("./worker.ts", import.meta.url)
-}
-
-async function input(value?: string) {
-  const piped = process.stdin.isTTY ? undefined : await Bun.stdin.text()
-  if (!value) return piped
-  if (!piped) return value
-  return piped + "\n" + value
-}
-
-async function promptWorkspaceTrust(directory: string, level: "untrusted" | "dangerous"): Promise<boolean> {
-  const prompts = await import("@clack/prompts")
-  const { EOL } = await import("os")
-
-  if (level === "dangerous") {
-    const isRoot = path.parse(directory).root === directory
-    const title = t(isRoot ? "trust.dangerous.title_root" : "trust.dangerous.title_home")
-    const body = t(isRoot ? "trust.dangerous.body_root" : "trust.dangerous.body_home")
-    const advice = t(isRoot ? "trust.dangerous.advice_root" : "trust.dangerous.advice_home")
-    prompts.log.warning(
-      [
-        UI.Style.TEXT_WARNING_BOLD + title + UI.Style.TEXT_NORMAL,
-        "",
-        directory,
-        "",
-        body,
-        "",
-        UI.Style.TEXT_DANGER + t("trust.plugin_warn") + UI.Style.TEXT_NORMAL,
-        "",
-        advice,
-      ].join(EOL),
-    )
-    const result = await prompts.select({
-      message: "",
-      options: [
-        { label: t("trust.dangerous.option.no"), value: false },
-        { label: t("trust.dangerous.option.yes"), value: true },
-      ],
-    })
-    if (prompts.isCancel(result)) return false
-    return result
-  }
-
-  prompts.log.info(
-    [
-      UI.Style.TEXT_HIGHLIGHT_BOLD + t("trust.title") + UI.Style.TEXT_NORMAL,
-      "",
-      directory,
-      "",
-      t("trust.safety_check"),
-      "",
-      t("trust.capabilities"),
-      "",
-      UI.Style.TEXT_DANGER + t("trust.plugin_warn") + UI.Style.TEXT_NORMAL,
-    ].join(EOL),
-  )
-  const result = await prompts.select({
-    message: "",
-    options: [
-      { label: t("trust.option.yes"), value: true },
-      { label: t("trust.option.no"), value: false },
-    ],
-  })
-  if (prompts.isCancel(result)) return false
-  return result
-}
-
-export const TuiThreadCommand = cmd({
-  command: "$0 [project]",
-  describe: "start sleepycode tui",
-  builder: (yargs) =>
-    withNetworkOptions(yargs)
-      .positional("project", {
-        type: "string",
-        describe: "path to start sleepycode in",
-      })
-      .option("model", {
-        type: "string",
-        alias: ["m"],
-        describe: "model to use in the format of provider/model",
-      })
-      .option("continue", {
-        alias: ["c"],
-        describe: "continue the last session",
-        type: "boolean",
-      })
-      .option("session", {
-        alias: ["s"],
-        type: "string",
-        describe: "session id to continue",
-      })
-      .option("fork", {
-        type: "boolean",
-        describe: "fork the session when continuing (use with --continue or --session)",
-      })
-      .option("prompt", {
-        type: "string",
-        describe: "prompt to use",
-      })
-      .option("agent", {
-        type: "string",
-        describe: "agent to use",
-      })
-      .option("never-ask", {
-        type: "boolean",
-        describe:
-          "start in never-ask mode — auto-decide without asking (permissions excluded), toggle at runtime with /never-ask",
-        default: false,
-      })
-      .option("trust", {
-        type: "boolean",
-        describe: "skip workspace trust prompt and trust the directory",
-        default: false,
-      }),
-  handler: async (args) => {
-    // Keep ENABLE_PROCESSED_INPUT cleared even if other code flips it.
-    // (Important when running under `bun run` wrappers on Windows.)
-    const unguard = win32InstallCtrlCGuard()
-    try {
-      // Must be the very first thing — disables CTRL_C_EVENT before any Worker
-      // spawn or async work so the OS cannot kill the process group.
-      win32DisableProcessedInput()
-
-      if (args.fork && !args.continue && !args.session) {
-        UI.error("--fork requires --continue or --session")
-        process.exitCode = 1
-        return
-      }
-
-      // Resolve relative --project paths from PWD, then use the real cwd after
-      // chdir so the thread and worker share the same directory key.
-      const root = Filesystem.resolve(process.env.PWD ?? process.cwd())
-      const next = args.project
-        ? Filesystem.resolve(path.isAbsolute(args.project) ? args.project : path.join(root, args.project))
-        : Filesystem.resolve(process.cwd())
-      const file = await target()
-      try {
-        process.chdir(next)
-      } catch {
-        UI.error("Failed to change directory to " + next)
-        return
-      }
-      const cwd = Filesystem.resolve(process.cwd())
-
-      if (!args.trust) {
-        const trustLevel = await checkTrust(cwd)
-        if (trustLevel !== "trusted") {
-          const accepted = await promptWorkspaceTrust(cwd, trustLevel)
-          if (!accepted) {
-            process.exit(0)
-            return
-          }
-          if (trustLevel === "untrusted") await markTrusted(cwd)
-        }
-      }
-
-      const env = sanitizedProcessEnv({
-        [SLEEPYCODE_PROCESS_ROLE]: "worker",
-        [SLEEPYCODE_RUN_ID]: ensureRunID(),
-      })
-
-      const worker = new Worker(file, {
-        env,
-      })
-      worker.onerror = (e) => {
-        Log.Default.error("thread error", {
-          message: e.message,
-          filename: e.filename,
-          lineno: e.lineno,
-          colno: e.colno,
-          error: e.error,
-        })
-      }
-
-      const client = Rpc.client<typeof rpc>(worker)
-      const error = (e: unknown) => {
-        Log.Default.error("process error", { error: errorMessage(e) })
-      }
-      const reload = () => {
-        client.call("reload", undefined).catch((err) => {
-          Log.Default.warn("worker reload failed", {
-            error: errorMessage(err),
-          })
-        })
-      }
-      process.on("uncaughtException", error)
-      process.on("unhandledRejection", error)
-      process.on("SIGUSR2", reload)
-
-      let stopped = false
-      const stop = async () => {
-        if (stopped) return
-        stopped = true
-        process.off("uncaughtException", error)
-        process.off("unhandledRejection", error)
-        process.off("SIGUSR2", reload)
-        await withTimeout(client.call("shutdown", undefined), 5000).catch((error) => {
-          Log.Default.warn("worker shutdown failed", {
-            error: errorMessage(error),
-          })
-        })
-        worker.terminate()
-      }
-
-      const prompt = await input(args.prompt)
-      const config = await TuiConfig.get()
-
-      const network = resolveNetworkOptionsNoConfig(args)
-      const external =
-        process.argv.includes("--port") ||
-        process.argv.includes("--hostname") ||
-        process.argv.includes("--mdns") ||
-        network.mdns ||
-        network.port !== 0 ||
-        network.hostname !== "127.0.0.1"
-
-      const transport = external
-        ? {
-            url: (await client.call("server", network)).url,
-            fetch: undefined,
-            events: undefined,
-          }
-        : {
-            url: "http://opencode.internal",
-            fetch: createWorkerFetch(client),
-            events: createEventSource(client),
-          }
-
-      // Check for updates on startup and every hour thereafter
-      const checkUpgrade = () => client.call("checkUpgrade", { directory: cwd }).catch(() => {})
-      setTimeout(checkUpgrade, 1000).unref?.()
-      setInterval(checkUpgrade, 60 * 60 * 1000).unref?.()
-
-      try {
-        await tui({
-          url: transport.url,
-          async onSnapshot() {
-            const tui = writeHeapSnapshot("tui.heapsnapshot")
-            const server = await client.call("snapshot", undefined)
-            return [tui, server]
-          },
-          config,
-          directory: cwd,
-          fetch: transport.fetch,
-          events: transport.events,
-          args: {
-            continue: args.continue,
-            sessionID: args.session,
-            agent: args.agent,
-            model: args.model,
-            prompt,
-            fork: args.fork,
-            neverAsk: args["never-ask"],
-          },
-        })
-      } finally {
-        await stop()
-      }
-    } finally {
-      unguard?.()
-    }
-    process.exit(0)
-  },
-})
-// scratch

package/src/cli/cmd/tui/ui/dialog-alert.tsx

@@ -1,61 +0,0 @@
-import { TextAttributes } from "@opentui/core"
-import { useTheme } from "../context/theme"
-import { useDialog, type DialogContext } from "./dialog"
-import { useKeyboard } from "@opentui/solid"
-import { useLanguage } from "@tui/context/language"
-
-export type DialogAlertProps = {
-  title: string
-  message: string
-  onConfirm?: () => void
-}
-
-export function DialogAlert(props: DialogAlertProps) {
-  const dialog = useDialog()
-  const { theme } = useTheme()
-  const t = useLanguage().t
-
-  useKeyboard((evt) => {
-    if (evt.name === "return") {
-      props.onConfirm?.()
-      dialog.clear()
-    }
-  })
-  return (
-    <box paddingLeft={2} paddingRight={2} gap={1}>
-      <box flexDirection="row" justifyContent="space-between">
-        <text attributes={TextAttributes.BOLD} fg={theme.text}>
-          {props.title}
-        </text>
-        <text fg={theme.textMuted} onMouseUp={() => dialog.clear()}>
-          {t("tui.dialog.close_hint")}
-        </text>
-      </box>
-      <box paddingBottom={1}>
-        <text fg={theme.textMuted}>{props.message}</text>
-      </box>
-      <box flexDirection="row" justifyContent="flex-end" paddingBottom={1}>
-        <box
-          paddingLeft={3}
-          paddingRight={3}
-          backgroundColor={theme.primary}
-          onMouseUp={() => {
-            props.onConfirm?.()
-            dialog.clear()
-          }}
-        >
-          <text fg={theme.selectedListItemText}>{t("tui.dialog.ok")}</text>
-        </box>
-      </box>
-    </box>
-  )
-}
-
-DialogAlert.show = (dialog: DialogContext, title: string, message: string) => {
-  return new Promise<void>((resolve) => {
-    dialog.replace(
-      () => <DialogAlert title={title} message={message} onConfirm={() => resolve()} />,
-      () => resolve(),
-    )
-  })
-}

package/src/cli/cmd/tui/ui/dialog-confirm.tsx

@@ -1,95 +0,0 @@
-import { TextAttributes } from "@opentui/core"
-import { useTheme } from "../context/theme"
-import { useDialog, type DialogContext } from "./dialog"
-import { createStore } from "solid-js/store"
-import { For } from "solid-js"
-import { useKeyboard } from "@opentui/solid"
-import { Locale } from "@/util"
-import { useLanguage } from "@tui/context/language"
-
-export type DialogConfirmProps = {
-  title: string
-  message: string
-  onConfirm?: () => void
-  onCancel?: () => void
-  label?: string
-}
-
-export type DialogConfirmResult = boolean | undefined
-
-export function DialogConfirm(props: DialogConfirmProps) {
-  const dialog = useDialog()
-  const { theme } = useTheme()
-  const t = useLanguage().t
-  const [store, setStore] = createStore({
-    active: "confirm" as "confirm" | "cancel",
-  })
-
-  useKeyboard((evt) => {
-    if (evt.name === "return") {
-      if (store.active === "confirm") props.onConfirm?.()
-      if (store.active === "cancel") props.onCancel?.()
-      dialog.clear()
-    }
-
-    if (evt.name === "left" || evt.name === "right") {
-      setStore("active", store.active === "confirm" ? "cancel" : "confirm")
-    }
-  })
-  return (
-    <box paddingLeft={2} paddingRight={2} gap={1}>
-      <box flexDirection="row" justifyContent="space-between">
-        <text attributes={TextAttributes.BOLD} fg={theme.text}>
-          {props.title}
-        </text>
-        <text fg={theme.textMuted} onMouseUp={() => dialog.clear()}>
-          {t("tui.dialog.close_hint")}
-        </text>
-      </box>
-      <box paddingBottom={1}>
-        <text fg={theme.textMuted}>{props.message}</text>
-      </box>
-      <box flexDirection="row" justifyContent="flex-end" paddingBottom={1}>
-        <For each={["cancel", "confirm"] as const}>
-          {(key) => (
-            <box
-              paddingLeft={1}
-              paddingRight={1}
-              backgroundColor={key === store.active ? theme.primary : undefined}
-              onMouseUp={(_evt) => {
-                if (key === "confirm") props.onConfirm?.()
-                if (key === "cancel") props.onCancel?.()
-                dialog.clear()
-              }}
-            >
-              <text fg={key === store.active ? theme.selectedListItemText : theme.textMuted}>
-                {key === "cancel"
-                  ? props.label
-                    ? Locale.titlecase(props.label)
-                    : t("tui.dialog.confirm.cancel")
-                  : t("tui.dialog.confirm.confirm")}
-              </text>
-            </box>
-          )}
-        </For>
-      </box>
-    </box>
-  )
-}
-
-DialogConfirm.show = (dialog: DialogContext, title: string, message: string, label?: string) => {
-  return new Promise<DialogConfirmResult>((resolve) => {
-    dialog.replace(
-      () => (
-        <DialogConfirm
-          title={title}
-          message={message}
-          onConfirm={() => resolve(true)}
-          onCancel={() => resolve(false)}
-          label={label}
-        />
-      ),
-      () => resolve(undefined),
-    )
-  })
-}