@sleepy-ai/cli 0.1.6 → 0.1.8

package/src/cli/cmd/tui/component/textarea-keybindings.ts

@@ -1,73 +0,0 @@
-import { createMemo } from "solid-js"
-import type { KeyBinding } from "@opentui/core"
-import { useKeybind } from "../context/keybind"
-import { Keybind } from "@/util"
-
-const TEXTAREA_ACTIONS = [
-  "submit",
-  "newline",
-  "move-left",
-  "move-right",
-  "move-up",
-  "move-down",
-  "select-left",
-  "select-right",
-  "select-up",
-  "select-down",
-  "line-home",
-  "line-end",
-  "select-line-home",
-  "select-line-end",
-  "visual-line-home",
-  "visual-line-end",
-  "select-visual-line-home",
-  "select-visual-line-end",
-  "buffer-home",
-  "buffer-end",
-  "select-buffer-home",
-  "select-buffer-end",
-  "delete-line",
-  "delete-to-line-end",
-  "delete-to-line-start",
-  "backspace",
-  "delete",
-  "undo",
-  "redo",
-  "word-forward",
-  "word-backward",
-  "select-word-forward",
-  "select-word-backward",
-  "delete-word-forward",
-  "delete-word-backward",
-] as const
-
-function mapTextareaKeybindings(
-  keybinds: Record<string, Keybind.Info[]>,
-  action: (typeof TEXTAREA_ACTIONS)[number],
-): KeyBinding[] {
-  const configKey = `input_${action.replace(/-/g, "_")}`
-  const bindings = keybinds[configKey]
-  if (!bindings) return []
-  return bindings.map((binding) => ({
-    name: binding.name,
-    ctrl: binding.ctrl || undefined,
-    meta: binding.meta || undefined,
-    shift: binding.shift || undefined,
-    super: binding.super || undefined,
-    action,
-  }))
-}
-
-export function useTextareaKeybindings() {
-  const keybind = useKeybind()
-
-  return createMemo(() => {
-    const keybinds = keybind.all
-
-    return [
-      { name: "return", action: "submit" },
-      { name: "return", meta: true, action: "newline" },
-      ...TEXTAREA_ACTIONS.flatMap((action) => mapTextareaKeybindings(keybinds, action)),
-    ] satisfies KeyBinding[]
-  })
-}

package/src/cli/cmd/tui/component/todo-item.tsx

@@ -1,32 +0,0 @@
-import { useTheme } from "../context/theme"
-
-export interface TodoItemProps {
-  status: string
-  content: string
-}
-
-export function TodoItem(props: TodoItemProps) {
-  const { theme } = useTheme()
-
-  return (
-    <box flexDirection="row" gap={0}>
-      <text
-        flexShrink={0}
-        style={{
-          fg: props.status === "in_progress" ? theme.warning : theme.textMuted,
-        }}
-      >
-        [{props.status === "completed" ? "✓" : props.status === "in_progress" ? "•" : " "}]{" "}
-      </text>
-      <text
-        flexGrow={1}
-        wrapMode="word"
-        style={{
-          fg: props.status === "in_progress" ? theme.warning : theme.textMuted,
-        }}
-      >
-        {props.content}
-      </text>
-    </box>
-  )
-}

package/src/cli/cmd/tui/component/workflow-tree.tsx

@@ -1,177 +0,0 @@
-import { useTheme } from "@tui/context/theme"
-import { TextAttributes } from "@opentui/core"
-import { For, Show, createSignal } from "solid-js"
-import type { WorkflowNode } from "@tui/context/sync"
-import { SplitBorder } from "@tui/component/border"
-import { Spinner } from "@tui/component/spinner"
-
-type AgentNode = Extract<WorkflowNode, { type: "agent" }>
-type WfNode = Extract<WorkflowNode, { type: "workflow" }>
-type PhaseNode = Extract<WorkflowNode, { type: "phase" }>
-
-function glyph(status: string) {
-  if (status === "succeeded" || status === "completed") return "✓"
-  if (status === "failed" || status === "cancelled") return "✗"
-  return "○"
-}
-
-// One-line meta tag for an agent call's parameters: model · tools · schema ·
-// isolated · duration. Empty parts are dropped.
-function agentMeta(n: AgentNode) {
-  const parts: string[] = []
-  if (n.model) parts.push(n.model)
-  if (n.tools && n.tools.length) parts.push(`${n.tools.length} tools`)
-  if (n.schema) parts.push("schema")
-  if (n.isolation) parts.push("isolated")
-  if (n.durationMs !== undefined) parts.push(`${(n.durationMs / 1000).toFixed(1)}s`)
-  return parts.join(" · ")
-}
-
-// A single agent rendered as a message-style card: a status-colored left spine
-// (the TUI's SplitBorder idiom), a header (spinner/glyph + name + meta + open),
-// the full prompt, and the result (or live activity while running). Click → open
-// that subagent's full conversation.
-function AgentCard(props: {
-  node: AgentNode
-  onOpenAgent?: (actorID: string) => void
-  liveActivity?: (actorID: string) => string | undefined
-}) {
-  const { theme } = useTheme()
-  const [hover, setHover] = createSignal(false)
-  const n = () => props.node
-  const running = () => n().status === "running"
-  const spine = () =>
-    n().status === "succeeded" ? theme.success : n().status === "failed" ? theme.error : theme.warning
-  const clickable = () => Boolean(n().actorID && props.onOpenAgent)
-  const live = () => (running() && n().actorID && props.liveActivity ? props.liveActivity(n().actorID!) : undefined)
-
-  return (
-    <box
-      {...SplitBorder}
-      border={["left"]}
-      borderColor={spine()}
-      marginTop={1}
-      paddingLeft={2}
-      paddingTop={1}
-      paddingBottom={1}
-      gap={1}
-      backgroundColor={hover() && clickable() ? theme.backgroundElement : theme.backgroundPanel}
-      onMouseOver={() => setHover(true)}
-      onMouseOut={() => setHover(false)}
-      onMouseUp={() => {
-        const a = n()
-        if (a.actorID) props.onOpenAgent?.(a.actorID)
-      }}
-    >
-      <box flexDirection="row" gap={1} alignItems="center">
-        <Show when={running()} fallback={<text fg={spine()} attributes={TextAttributes.BOLD}>{glyph(n().status)}</text>}>
-          <Spinner color={spine()} />
-        </Show>
-        <text attributes={TextAttributes.BOLD} fg={theme.text}>
-          {n().label ?? n().agentType}
-        </text>
-        <Show when={agentMeta(n())}>
-          <text fg={theme.textMuted}>{agentMeta(n())}</text>
-        </Show>
-        <box flexGrow={1} />
-        <Show when={clickable()}>
-          <text fg={hover() ? theme.text : theme.markdownLink}>open ↗</text>
-        </Show>
-      </box>
-
-      <box paddingLeft={2}>
-        <text fg={theme.textMuted} wrapMode="word">
-          {n().prompt}
-        </text>
-      </box>
-
-      <Show when={live()}>
-        <box paddingLeft={2} flexDirection="row" gap={1}>
-          <text fg={theme.warning}>↳</text>
-          <text fg={theme.warning} wrapMode="word">
-            {live()}
-          </text>
-        </box>
-      </Show>
-      <Show when={!running() && n().resultSummary}>
-        <box paddingLeft={2} flexDirection="row" gap={1}>
-          <text fg={theme.success}>↳</text>
-          <text fg={theme.text} wrapMode="word">
-            {n().resultSummary}
-          </text>
-        </box>
-      </Show>
-    </box>
-  )
-}
-
-function WorkflowCard(props: { node: WfNode; onOpenChild?: (childRunID: string) => void }) {
-  const { theme } = useTheme()
-  const [hover, setHover] = createSignal(false)
-  const spine = () =>
-    props.node.status === "completed"
-      ? theme.success
-      : props.node.status === "failed" || props.node.status === "cancelled"
-        ? theme.error
-        : theme.warning
-  return (
-    <box
-      {...SplitBorder}
-      border={["left"]}
-      borderColor={spine()}
-      marginTop={1}
-      paddingLeft={2}
-      paddingTop={1}
-      paddingBottom={1}
-      backgroundColor={hover() ? theme.backgroundElement : theme.backgroundPanel}
-      onMouseOver={() => setHover(true)}
-      onMouseOut={() => setHover(false)}
-      onMouseUp={() => props.onOpenChild?.(props.node.childRunID)}
-    >
-      <box flexDirection="row" gap={1}>
-        <text fg={theme.accent} attributes={TextAttributes.BOLD}>
-          ⧉ {props.node.name}
-        </text>
-        <text fg={theme.textMuted}>sub-workflow · {props.node.status}</text>
-        <box flexGrow={1} />
-        <text fg={hover() ? theme.text : theme.markdownLink}>open ↗</text>
-      </box>
-    </box>
-  )
-}
-
-export function WorkflowTree(props: {
-  nodes: WorkflowNode[]
-  onOpenChild?: (childRunID: string) => void
-  onOpenAgent?: (actorID: string) => void
-  liveActivity?: (actorID: string) => string | undefined
-}) {
-  const { theme } = useTheme()
-  return (
-    <box flexDirection="column">
-      <Show when={props.nodes.length === 0}>
-        <text fg={theme.textMuted}>(no activity yet)</text>
-      </Show>
-      <For each={props.nodes}>
-        {(node) => (
-          <>
-            <Show when={node.type === "phase"}>
-              <box marginTop={1} flexDirection="row" gap={1} alignItems="center">
-                <text attributes={TextAttributes.BOLD} fg={theme.accent}>
-                  ◆ {(node as PhaseNode).title}
-                </text>
-                <box flexGrow={1} borderColor={theme.borderSubtle} border={["bottom"]} />
-              </box>
-            </Show>
-            <Show when={node.type === "agent"}>
-              <AgentCard node={node as AgentNode} onOpenAgent={props.onOpenAgent} liveActivity={props.liveActivity} />
-            </Show>
-            <Show when={node.type === "workflow"}>
-              <WorkflowCard node={node as WfNode} onOpenChild={props.onOpenChild} />
-            </Show>
-          </>
-        )}
-      </For>
-    </box>
-  )
-}

package/src/cli/cmd/tui/config/cwd.ts

@@ -1,5 +0,0 @@
-import { Context } from "effect"
-
-export const CurrentWorkingDirectory = Context.Reference<string>("CurrentWorkingDirectory", {
-  defaultValue: () => process.cwd(),
-})

package/src/cli/cmd/tui/config/tui-migrate.ts

@@ -1,151 +0,0 @@
-import path from "path"
-import { type ParseError as JsoncParseError, applyEdits, modify, parse as parseJsonc } from "jsonc-parser"
-import { unique } from "remeda"
-import z from "zod"
-import { TuiInfo, TuiOptions } from "./tui-schema"
-import { Flag } from "@/flag/flag"
-import { Global } from "@/global"
-import { Filesystem, Log } from "@/util"
-import * as ConfigPaths from "@/config/paths"
-
-const log = Log.create({ service: "tui.migrate" })
-
-const TUI_SCHEMA_URL = "https://opencode.ai/tui.json"
-
-const LegacyTheme = TuiInfo.shape.theme.optional()
-const LegacyRecord = z.record(z.string(), z.unknown()).optional()
-
-const TuiLegacy = z
-  .object({
-    scroll_speed: TuiOptions.shape.scroll_speed.catch(undefined),
-    scroll_acceleration: TuiOptions.shape.scroll_acceleration.catch(undefined),
-    diff_style: TuiOptions.shape.diff_style.catch(undefined),
-  })
-  .strip()
-
-interface MigrateInput {
-  cwd: string
-  directories: string[]
-}
-
-/**
- * Migrates tui-specific keys (theme, keybinds, tui) from sleepycode.json files
- * into dedicated tui.json files. Migration is performed per-directory and
- * skips only locations where a tui.json already exists.
- */
-export async function migrateTuiConfig(input: MigrateInput) {
-  const sleepycode = await sleepycodeFiles(input)
-  for (const file of sleepycode) {
-    const source = await Filesystem.readText(file).catch((error) => {
-      log.warn("failed to read config for tui migration", { path: file, error })
-      return undefined
-    })
-    if (!source) continue
-    const errors: JsoncParseError[] = []
-    const data = parseJsonc(source, errors, { allowTrailingComma: true })
-    if (errors.length || !data || typeof data !== "object" || Array.isArray(data)) continue
-
-    const theme = LegacyTheme.safeParse("theme" in data ? data.theme : undefined)
-    const keybinds = LegacyRecord.safeParse("keybinds" in data ? data.keybinds : undefined)
-    const legacyTui = LegacyRecord.safeParse("tui" in data ? data.tui : undefined)
-    const extracted = {
-      theme: theme.success ? theme.data : undefined,
-      keybinds: keybinds.success ? keybinds.data : undefined,
-      tui: legacyTui.success ? legacyTui.data : undefined,
-    }
-    const tui = extracted.tui ? normalizeTui(extracted.tui) : undefined
-    if (extracted.theme === undefined && extracted.keybinds === undefined && !tui) continue
-
-    const target = path.join(path.dirname(file), "tui.json")
-    const targetExists = await Filesystem.exists(target)
-    if (targetExists) continue
-
-    const payload: Record<string, unknown> = {
-      $schema: TUI_SCHEMA_URL,
-    }
-    if (extracted.theme !== undefined) payload.theme = extracted.theme
-    if (extracted.keybinds !== undefined) payload.keybinds = extracted.keybinds
-    if (tui) Object.assign(payload, tui)
-
-    const wrote = await Filesystem.write(target, JSON.stringify(payload, null, 2))
-      .then(() => true)
-      .catch((error) => {
-        log.warn("failed to write tui migration target", { from: file, to: target, error })
-        return false
-      })
-    if (!wrote) continue
-
-    const stripped = await backupAndStripLegacy(file, source)
-    if (!stripped) {
-      log.warn("tui config migrated but source file was not stripped", { from: file, to: target })
-      continue
-    }
-    log.info("migrated tui config", { from: file, to: target })
-  }
-}
-
-function normalizeTui(data: Record<string, unknown>) {
-  const parsed = TuiLegacy.parse(data)
-  if (
-    parsed.scroll_speed === undefined &&
-    parsed.diff_style === undefined &&
-    parsed.scroll_acceleration === undefined
-  ) {
-    return
-  }
-  return parsed
-}
-
-async function backupAndStripLegacy(file: string, source: string) {
-  const backup = file + ".tui-migration.bak"
-  const hasBackup = await Filesystem.exists(backup)
-  const backed = hasBackup
-    ? true
-    : await Filesystem.write(backup, source)
-        .then(() => true)
-        .catch((error) => {
-          log.warn("failed to backup source config during tui migration", { path: file, backup, error })
-          return false
-        })
-  if (!backed) return false
-
-  const text = ["theme", "keybinds", "tui"].reduce((acc, key) => {
-    const edits = modify(acc, [key], undefined, {
-      formattingOptions: {
-        insertSpaces: true,
-        tabSize: 2,
-      },
-    })
-    if (!edits.length) return acc
-    return applyEdits(acc, edits)
-  }, source)
-
-  return Filesystem.write(file, text)
-    .then(() => {
-      log.info("stripped tui keys from server config", { path: file, backup })
-      return true
-    })
-    .catch((error) => {
-      log.warn("failed to strip legacy tui keys from server config", { path: file, backup, error })
-      return false
-    })
-}
-
-async function sleepycodeFiles(input: { directories: string[]; cwd: string }) {
-  const files = [
-    ...ConfigPaths.fileInDirectory(Global.Path.config, "sleepycode"),
-    ...(await Filesystem.findUp(["sleepycode.json", "sleepycode.jsonc"], input.cwd, undefined, { rootFirst: true })),
-  ]
-  for (const dir of unique(input.directories)) {
-    files.push(...ConfigPaths.fileInDirectory(dir, "sleepycode"))
-  }
-  if (Flag.SLEEPYCODE_CONFIG) files.push(Flag.SLEEPYCODE_CONFIG)
-
-  const existing = await Promise.all(
-    unique(files).map(async (file) => {
-      const ok = await Filesystem.exists(file)
-      return ok ? file : undefined
-    }),
-  )
-  return existing.filter((file): file is string => !!file)
-}

package/src/cli/cmd/tui/config/tui-schema.ts

@@ -1,38 +0,0 @@
-import z from "zod"
-import { ConfigPlugin } from "@/config/plugin"
-import { ConfigKeybinds } from "@/config/keybinds"
-
-const KeybindOverride = z
-  .object(
-    Object.fromEntries(Object.keys(ConfigKeybinds.Keybinds.shape).map((key) => [key, z.string().optional()])) as Record<
-      string,
-      z.ZodOptional<z.ZodString>
-    >,
-  )
-  .strict()
-
-export const TuiOptions = z.object({
-  scroll_speed: z.number().min(0.001).optional().describe("TUI scroll speed"),
-  scroll_acceleration: z
-    .object({
-      enabled: z.boolean().describe("Enable scroll acceleration"),
-    })
-    .optional()
-    .describe("Scroll acceleration settings"),
-  diff_style: z
-    .enum(["auto", "stacked"])
-    .optional()
-    .describe("Control diff rendering style: 'auto' adapts to terminal width, 'stacked' always shows single column"),
-  mouse: z.boolean().optional().describe("Enable or disable mouse capture (default: true)"),
-})
-
-export const TuiInfo = z
-  .object({
-    $schema: z.string().optional(),
-    theme: z.string().optional(),
-    keybinds: KeybindOverride.optional(),
-    plugin: ConfigPlugin.Spec.zod.array().optional(),
-    plugin_enabled: z.record(z.string(), z.boolean()).optional(),
-  })
-  .extend(TuiOptions.shape)
-  .strict()

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

@@ -1,219 +0,0 @@
-export * as TuiConfig from "./tui"
-
-import z from "zod"
-import { mergeDeep, unique } from "remeda"
-import { Context, Effect, Fiber, Layer } from "effect"
-import { ConfigParse } from "@/config/parse"
-import * as ConfigPaths from "@/config/paths"
-import { migrateTuiConfig } from "./tui-migrate"
-import { TuiInfo } from "./tui-schema"
-import { Flag } from "@/flag/flag"
-import { isRecord } from "@/util/record"
-import { Global } from "@/global"
-import { AppFileSystem } from "@sleepy-ai/shared/filesystem"
-import { CurrentWorkingDirectory } from "./cwd"
-import { ConfigPlugin } from "@/config/plugin"
-import { ConfigKeybinds } from "@/config/keybinds"
-import { InstallationLocal, InstallationVersion } from "@/installation/version"
-import { makeRuntime } from "@/effect/runtime"
-import { Filesystem, Log } from "@/util"
-import { ConfigVariable } from "@/config/variable"
-import { Npm } from "@/npm"
-
-const log = Log.create({ service: "tui.config" })
-
-export const Info = TuiInfo
-
-type Acc = {
-  result: Info
-}
-
-type State = {
-  config: Info
-  deps: Array<Fiber.Fiber<void, AppFileSystem.Error>>
-}
-
-export type Info = z.output<typeof Info> & {
-  // Internal resolved plugin list used by runtime loading.
-  plugin_origins?: ConfigPlugin.Origin[]
-}
-
-export interface Interface {
-  readonly get: () => Effect.Effect<Info>
-  readonly waitForDependencies: () => Effect.Effect<void>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/TuiConfig") {}
-
-function pluginScope(file: string, ctx: { directory: string }): ConfigPlugin.Scope {
-  if (Filesystem.contains(ctx.directory, file)) return "local"
-  // if (ctx.worktree !== "/" && Filesystem.contains(ctx.worktree, file)) return "local"
-  return "global"
-}
-
-function normalize(raw: Record<string, unknown>) {
-  const data = { ...raw }
-  if (!("tui" in data)) return data
-  if (!isRecord(data.tui)) {
-    delete data.tui
-    return data
-  }
-
-  const tui = data.tui
-  delete data.tui
-  return {
-    ...tui,
-    ...data,
-  }
-}
-
-async function resolvePlugins(config: Info, configFilepath: string) {
-  if (!config.plugin) return config
-  for (let i = 0; i < config.plugin.length; i++) {
-    config.plugin[i] = await ConfigPlugin.resolvePluginSpec(config.plugin[i], configFilepath)
-  }
-  return config
-}
-
-async function mergeFile(acc: Acc, file: string, ctx: { directory: string }) {
-  const data = await loadFile(file)
-  acc.result = mergeDeep(acc.result, data)
-  if (!data.plugin?.length) return
-
-  const scope = pluginScope(file, ctx)
-  const plugins = ConfigPlugin.deduplicatePluginOrigins([
-    ...(acc.result.plugin_origins ?? []),
-    ...data.plugin.map((spec) => ({ spec, scope, source: file })),
-  ])
-  acc.result.plugin = plugins.map((item) => item.spec)
-  acc.result.plugin_origins = plugins
-}
-
-const loadState = Effect.fn("TuiConfig.loadState")(function* (ctx: { directory: string }) {
-  // Every config dir we may read from: global config dir, any `.sleepycode`
-  // folders between cwd and home, and SLEEPYCODE_CONFIG_DIR.
-  const directories = yield* ConfigPaths.directories(ctx.directory)
-  yield* Effect.promise(() => migrateTuiConfig({ directories, cwd: ctx.directory }))
-
-  const projectFiles = Flag.SLEEPYCODE_DISABLE_PROJECT_CONFIG ? [] : yield* ConfigPaths.files("tui", ctx.directory)
-
-  const acc: Acc = {
-    result: {},
-  }
-
-  // 1. Global tui config (lowest precedence).
-  for (const file of ConfigPaths.fileInDirectory(Global.Path.config, "tui")) {
-    yield* Effect.promise(() => mergeFile(acc, file, ctx)).pipe(Effect.orDie)
-  }
-
-  // 2. Explicit SLEEPYCODE_TUI_CONFIG override, if set.
-  if (Flag.SLEEPYCODE_TUI_CONFIG) {
-    const configFile = Flag.SLEEPYCODE_TUI_CONFIG
-    yield* Effect.promise(() => mergeFile(acc, configFile, ctx)).pipe(Effect.orDie)
-    log.debug("loaded custom tui config", { path: configFile })
-  }
-
-  // 3. Project tui files, applied root-first so the closest file wins.
-  for (const file of projectFiles) {
-    yield* Effect.promise(() => mergeFile(acc, file, ctx)).pipe(Effect.orDie)
-  }
-
-  // 4. `.sleepycode` directories (and SLEEPYCODE_CONFIG_DIR) discovered while
-  // walking up the tree. Also returned below so callers can install plugin
-  // dependencies from each location.
-  const dirs = unique(directories).filter((dir) => dir.endsWith(".sleepycode") || dir === Flag.SLEEPYCODE_CONFIG_DIR)
-
-  for (const dir of dirs) {
-    if (!dir.endsWith(".sleepycode") && dir !== Flag.SLEEPYCODE_CONFIG_DIR) continue
-    for (const file of ConfigPaths.fileInDirectory(dir, "tui")) {
-      yield* Effect.promise(() => mergeFile(acc, file, ctx)).pipe(Effect.orDie)
-    }
-  }
-
-  const keybinds = { ...(acc.result.keybinds ?? {}) }
-  if (process.platform === "win32") {
-    // Native Windows terminals do not support POSIX suspend, so prefer prompt undo.
-    keybinds.terminal_suspend = "none"
-    keybinds.input_undo ??= unique([
-      "ctrl+z",
-      ...ConfigKeybinds.Keybinds.shape.input_undo.parse(undefined).split(","),
-    ]).join(",")
-  }
-  acc.result.keybinds = ConfigKeybinds.Keybinds.parse(keybinds)
-
-  return {
-    config: acc.result,
-    dirs: acc.result.plugin?.length ? dirs : [],
-  }
-})
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const directory = yield* CurrentWorkingDirectory
-    const npm = yield* Npm.Service
-    const data = yield* loadState({ directory })
-    const deps = yield* Effect.forEach(
-      data.dirs,
-      (dir) =>
-        npm
-          .install(dir, {
-            add: [
-              {
-                name: "@sleepy-ai/plugin",
-                version: InstallationLocal ? undefined : InstallationVersion,
-              },
-            ],
-          })
-          .pipe(Effect.forkScoped),
-      {
-        concurrency: "unbounded",
-      },
-    )
-
-    const get = Effect.fn("TuiConfig.get")(() => Effect.succeed(data.config))
-
-    const waitForDependencies = Effect.fn("TuiConfig.waitForDependencies")(() =>
-      Effect.forEach(deps, Fiber.join, { concurrency: "unbounded" }).pipe(Effect.ignore(), Effect.asVoid),
-    )
-    return Service.of({ get, waitForDependencies })
-  }).pipe(Effect.withSpan("TuiConfig.layer")),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(Npm.defaultLayer), Layer.provide(AppFileSystem.defaultLayer))
-
-const { runPromise } = makeRuntime(Service, defaultLayer)
-
-export async function waitForDependencies() {
-  await runPromise((svc) => svc.waitForDependencies())
-}
-
-export async function get() {
-  return runPromise((svc) => svc.get())
-}
-
-async function loadFile(filepath: string): Promise<Info> {
-  const text = await ConfigPaths.readFile(filepath)
-  if (!text) return {}
-  return load(text, filepath).catch((error) => {
-    log.warn("failed to load tui config", { path: filepath, error })
-    return {}
-  })
-}
-
-async function load(text: string, configFilepath: string): Promise<Info> {
-  return ConfigVariable.substitute({ text, type: "path", path: configFilepath, missing: "empty" })
-    .then((expanded) => ConfigParse.jsonc(expanded, configFilepath))
-    .then((data) => {
-      if (!isRecord(data)) return {}
-
-      // Flatten a nested "tui" key so users who wrote `{ "tui": { ... } }` inside tui.json
-      // (mirroring the old sleepycode.json shape) still get their settings applied.
-      return ConfigParse.schema(Info, normalize(data), configFilepath)
-    })
-    .then((data) => resolvePlugins(data, configFilepath))
-    .catch((error) => {
-      log.warn("invalid tui config", { path: configFilepath, error })
-      return {}
-    })
-}