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

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

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

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

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

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

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

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

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

@@ -0,0 +1,219 @@
+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 {}
+    })
+}