saeeol 1.4.1 → 1.4.3

package/src/config/config.ts

@@ -1,411 +0,0 @@
-import * as Log from "@saeeol/core/util/log"
-import path from "path"
-import os from "os"
-import { mergeDeep, unique } from "remeda"
-import { Global } from "@saeeol/core/global"
-import { NamedError } from "@saeeol/core/util/error"
-import { Flag } from "@saeeol/core/flag/flag"
-import { Auth } from "../auth"
-import { Env } from "../env"
-import { type InstanceContext } from "../project/instance"
-import { InstanceStore } from "../project/instance-store"
-import { InstallationLocal, InstallationVersion } from "@saeeol/core/installation/version"
-import { existsSync } from "fs"
-import { GlobalBus } from "@/bus/global"
-import { Event } from "../server/event"
-import { Account } from "@/account/account"
-import { containsPath } from "../project/instance-context"
-import type { ConsoleState } from "./console-state"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-import { InstanceState } from "@/effect/instance-state"
-import { Context, Duration, Effect, Exit, Fiber, Layer, Option, Schema } from "effect"
-import { EffectFlock } from "@saeeol/core/util/effect-flock"
-import { Npm } from "@saeeol/core/npm"
-import { SaeeolConfig } from "../overlay/config/config"
-import { SaeeolDefaultPlugins } from "@/saeeol/config/default-plugins"
-import { makeRuntime } from "@/effect/run-service"
-import { ConfigAgent } from "./agent"
-import { ConfigCommand } from "./command"
-import { ConfigManaged } from "./managed"
-import { ConfigPaths } from "./paths"
-import { ConfigPermission } from "./permission"
-import { ConfigPlugin } from "./plugin"
-import { ConfigParse } from "./parse"
-import z from "zod"
-import { Info, Warning, type Layout, Server, Indexing } from "./config-schema"
-export { Info, Warning, Server, Indexing }
-export type { Info as InfoType, Warning as WarningType, Layout as LayoutType }
-import {
-  mergeConfig,
-  mergeConfigConcatArrays,
-  globalConfigFile,
-  patchJsonc,
-  writable,
-  writableGlobal,
-  readConfigFile,
-  loadConfig,
-  loadFile,
-  loadGlobal,
-} from "./config-loader"
-
-const log = Log.create({ service: "config" })
-const { caught: caughtWarning } = SaeeolConfig
-
-export const ConfigDirectoryTypoError = NamedError.create(
-  "ConfigDirectoryTypoError",
-  z.object({ path: z.string(), dir: z.string(), suggestion: z.string() }),
-)
-
-type State = {
-  config: Info
-  directories: string[]
-  deps: Fiber.Fiber<void, never>[]
-  warnings: Warning[]
-  consoleState: ConsoleState
-}
-
-export interface Interface {
-  readonly get: () => Effect.Effect<Info>
-  readonly getGlobal: () => Effect.Effect<Info>
-  readonly getConsoleState: () => Effect.Effect<ConsoleState>
-  readonly update: (config: Info, options?: { dispose?: boolean }) => Effect.Effect<void>
-  readonly updateGlobal: (config: Info, options?: { dispose?: boolean }) => Effect.Effect<Info>
-  readonly invalidate: (wait?: boolean) => Effect.Effect<void>
-  readonly directories: () => Effect.Effect<string[]>
-  readonly waitForDependencies: () => Effect.Effect<void>
-  readonly warnings: () => Effect.Effect<Warning[]>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@saeeol/Config") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const fs = yield* AppFileSystem.Service
-    const authSvc = yield* Auth.Service
-    const accountSvc = yield* Account.Service
-    const env = yield* Env.Service
-    const npmSvc = yield* Npm.Service
-
-    const $read = readConfigFile(fs)
-    const $load = loadConfig(fs, Info)
-    const $loadFile = loadFile(fs, Info)
-
-    const [cachedGlobal, invalidateGlobal] = yield* Effect.cachedInvalidateWithTTL(
-      loadGlobal(fs, Info)().pipe(
-        Effect.tapError((error) =>
-          Effect.sync(() => log.error("failed to load global config, using defaults", { error: String(error) })),
-        ),
-        Effect.orElseSucceed((): Info => ({})),
-      ),
-      Duration.infinity,
-    )
-
-    const getGlobal = Effect.fn("Config.getGlobal")(function* () {
-      return yield* cachedGlobal
-    })
-
-    const ensureGitignore = Effect.fn("Config.ensureGitignore")(function* (dir: string) {
-      const gitignore = path.join(dir, ".gitignore")
-      const hasIgnore = yield* fs.existsSafe(gitignore)
-      if (!hasIgnore) {
-        yield* fs
-          .writeFileString(
-            gitignore,
-            ["node_modules", "package.json", "package-lock.json", "pnpm-lock.yaml", "bun.lock", "yarn.lock", ".gitignore"].join("\n"),
-          )
-          .pipe(Effect.catchIf((e) => e.reason._tag === "PermissionDenied" || e.reason._tag === "NotFound", () => Effect.void))
-      }
-    })
-
-    const loadInstanceState = Effect.fn("Config.loadInstanceState")(function* (ctx: InstanceContext) {
-      const warnings: Warning[] = []
-      const auth = yield* authSvc.all().pipe(Effect.orDie)
-      let result: Info = {}
-
-      const legacy = yield* Effect.promise(() =>
-        SaeeolConfig.loadLegacyConfigs({ projectDir: ctx.directory, merge: mergeConfigConcatArrays }),
-      )
-      result = mergeConfigConcatArrays(result, legacy.config)
-      warnings.push(...legacy.warnings)
-
-      const orgModes = yield* Effect.promise(() => SaeeolConfig.loadOrganizationModes(auth))
-      if (Object.keys(orgModes.agents).length > 0) {
-        result = mergeConfigConcatArrays(result, { agent: orgModes.agents })
-      }
-      warnings.push(...orgModes.warnings)
-
-      const consoleManagedProviders = new Set<string>()
-
-      const pluginScopeForSource = Effect.fnUntraced(function* (source: string) {
-        if (source.startsWith("http://") || source.startsWith("https://")) return "global"
-        if (source === "SAEEOL_CONFIG_CONTENT") return "local"
-        if (containsPath(source, ctx)) return "local"
-        return "global"
-      })
-
-      const mergePluginOrigins = Effect.fnUntraced(function* (
-        source: string, list: ConfigPlugin.Spec[] | undefined, kind?: ConfigPlugin.Scope,
-      ) {
-        if (!list?.length) return
-        const hit = kind ?? (yield* pluginScopeForSource(source))
-        const plugins = ConfigPlugin.deduplicatePluginOrigins([
-          ...(result.plugin_origins ?? []),
-          ...list.map((spec) => ({ spec, source, scope: hit })),
-        ])
-        result.plugin = plugins.map((item) => item.spec)
-        result.plugin_origins = plugins
-      })
-
-      const merge = Effect.fnUntraced(function* (source: string, next: Info, kind?: ConfigPlugin.Scope) {
-        const scope = kind ?? (yield* pluginScopeForSource(source))
-        const scoped = SaeeolConfig.scopeIndexing(next, scope)
-        result = mergeConfigConcatArrays(result, scoped)
-        return yield* mergePluginOrigins(source, scoped.plugin, scope)
-      })
-
-      for (const [key, value] of Object.entries(auth)) {
-        if (value.type === "wellknown") {
-          const url = key.replace(/\/+$/, "")
-          const source = `${url}/.well-known/saeeol`
-          process.env[value.key] = value.token
-          const next = yield* Effect.tryPromise({
-            try: async () => {
-              const response = await fetch(source)
-              if (!response.ok) throw new Error(`failed to fetch remote config from ${url}: ${response.status}`)
-              const wellknown = (await response.json()) as { config?: Record<string, unknown> }
-              const remoteConfig = wellknown.config ?? {}
-              if (!remoteConfig.$schema) remoteConfig.$schema = "https://app.saeeol.ai/config.json"
-              return remoteConfig
-            },
-            catch: (err) => err,
-          }).pipe(
-            Effect.flatMap((remoteConfig) => $load(JSON.stringify(remoteConfig), { dir: path.dirname(source), source })),
-            Effect.catch((err: unknown) => { caughtWarning(warnings, source, err); return Effect.succeed({} as Info) }),
-            Effect.catchDefect((err: unknown) => { caughtWarning(warnings, source, err); return Effect.succeed({} as Info) }),
-          )
-          yield* merge(source, next, "global")
-        }
-      }
-
-      const global = yield* getGlobal().pipe(
-        Effect.catchDefect((err: unknown) => { caughtWarning(warnings, "global config", err); return Effect.succeed({} as Info) }),
-      )
-      yield* merge(Global.Path.config, global, "global")
-
-      if (Flag.SAEEOL_CONFIG) {
-        yield* merge(
-          Flag.SAEEOL_CONFIG,
-          yield* $loadFile(Flag.SAEEOL_CONFIG).pipe(
-            Effect.catchDefect((err: unknown) => { caughtWarning(warnings, Flag.SAEEOL_CONFIG!, err); return Effect.succeed({} as Info) }),
-          ),
-        )
-      }
-
-      if (!Flag.SAEEOL_DISABLE_PROJECT_CONFIG) {
-        for (const name of ["saeeol"] as const) {
-          for (const file of yield* ConfigPaths.files(name, ctx.directory, ctx.worktree).pipe(Effect.orDie)) {
-            yield* merge(file, yield* $loadFile(file).pipe(
-              Effect.catchDefect((err: unknown) => { caughtWarning(warnings, file, err); return Effect.succeed({} as Info) }),
-            ), "local")
-          }
-        }
-      }
-
-      result.agent = result.agent || {}
-      result.mode = result.mode || {}
-      result.plugin = result.plugin || []
-      const directories = yield* ConfigPaths.directories(ctx.directory, ctx.worktree)
-
-      const deps: Fiber.Fiber<void, never>[] = []
-      for (const dir of unique(directories)) {
-        if (SaeeolConfig.isConfigDir(dir, Flag.SAEEOL_CONFIG_DIR)) {
-          for (const file of SaeeolConfig.ALL_CONFIG_FILES) {
-            const source = path.join(dir, file)
-            yield* merge(source, yield* $loadFile(source).pipe(
-              Effect.catchDefect((err: unknown) => { caughtWarning(warnings, source, err); return Effect.succeed({} as Info) }),
-            ))
-            result.agent ??= {}
-            result.mode ??= {}
-            result.plugin ??= []
-          }
-        }
-        yield* ensureGitignore(dir).pipe(Effect.orDie)
-        const dep = yield* npmSvc.install(dir, {
-          add: [{ name: "@saeeol/plugin", version: InstallationLocal ? undefined : InstallationVersion }],
-        }).pipe(Effect.exit, Effect.tap((exit) =>
-          Exit.isFailure(exit) ? Effect.sync(() => log.warn("background dependency install failed", { dir, error: String(exit.cause) })) : Effect.void,
-        ), Effect.asVoid, Effect.forkDetach)
-        deps.push(dep)
-        result.command = mergeDeep(result.command ?? {}, yield* Effect.promise(() => ConfigCommand.load(dir, warnings)))
-        result.agent = mergeDeep(result.agent ?? {}, yield* Effect.promise(() => ConfigAgent.load(dir, warnings)))
-        result.agent = mergeDeep(result.agent ?? {}, yield* Effect.promise(() => ConfigAgent.loadMode(dir, warnings)))
-        const list = yield* Effect.promise(() => ConfigPlugin.load(dir))
-        yield* mergePluginOrigins(dir, list)
-      }
-
-      if (process.env.SAEEOL_CONFIG_CONTENT) {
-        const source = "SAEEOL_CONFIG_CONTENT"
-        yield* merge(source, yield* $load(process.env.SAEEOL_CONFIG_CONTENT, { dir: ctx.directory, source }).pipe(
-          Effect.tap(() => Effect.sync(() => log.debug("loaded custom config from SAEEOL_CONFIG_CONTENT"))),
-          Effect.catchDefect((err: unknown) => { caughtWarning(warnings, source, err); return Effect.succeed({} as Info) }),
-        ), "local")
-      }
-
-      const activeAccount = Option.getOrUndefined(
-        yield* accountSvc.active().pipe(Effect.catch(() => Effect.succeed(Option.none()))),
-      )
-      if (activeAccount?.active_org_id) {
-        yield* Effect.gen(function* () {
-          const [configOpt, tokenOpt] = yield* Effect.all(
-            [accountSvc.config(activeAccount.id, activeAccount.active_org_id!), accountSvc.token(activeAccount.id)],
-            { concurrency: 2 },
-          )
-          if (Option.isSome(tokenOpt)) {
-            process.env["SAEEOL_CONSOLE_TOKEN"] = tokenOpt.value
-            yield* env.set("SAEEOL_CONSOLE_TOKEN", tokenOpt.value)
-          }
-          if (Option.isSome(configOpt)) {
-            const source = `${activeAccount.url}/api/config`
-            const next = yield* $load(JSON.stringify(configOpt.value), { dir: path.dirname(source), source })
-            for (const providerID of Object.keys(next.provider ?? {})) consoleManagedProviders.add(providerID)
-            yield* merge(source, next, "global")
-          }
-        }).pipe(Effect.withSpan("Config.loadActiveOrgConfig"), Effect.catch((err) => {
-          log.debug("failed to fetch remote account config", { error: err instanceof Error ? err.message : String(err) })
-          return Effect.void
-        }))
-      }
-
-      const managedDir = ConfigManaged.managedConfigDir()
-      if (existsSync(managedDir)) {
-        for (const file of SaeeolConfig.ALL_CONFIG_FILES) {
-          yield* merge(path.join(managedDir, file), yield* $loadFile(path.join(managedDir, file)), "global")
-        }
-      }
-      const managed = yield* Effect.promise(() => ConfigManaged.readManagedPreferences())
-      if (managed) {
-        yield* merge(managed.source, yield* $load(managed.text, { dir: path.dirname(managed.source), source: managed.source }), "global")
-      }
-
-      for (const [name, mode] of Object.entries(result.mode ?? {})) {
-        result.agent = mergeDeep(result.agent ?? {}, { [name]: { ...mode, mode: "primary" as const } })
-      }
-      if (Flag.SAEEOL_PERMISSION) {
-        result.permission = mergeDeep(result.permission ?? {}, JSON.parse(Flag.SAEEOL_PERMISSION))
-      }
-      if (result.tools) {
-        const perms: Record<string, ConfigPermission.Action> = {}
-        for (const [tool, enabled] of Object.entries(result.tools)) {
-          const action: ConfigPermission.Action = enabled ? "allow" : "deny"
-          if (tool === "write" || tool === "edit" || tool === "patch") { perms.edit = action; continue }
-          perms[tool] = action
-        }
-        result.permission = mergeDeep(perms, result.permission ?? {})
-      }
-      if (!result.username) result.username = os.userInfo().username
-      if (result.autoshare === true && !result.share) result.share = "auto"
-      if (Flag.SAEEOL_DISABLE_AUTOCOMPACT) result.compaction = { ...result.compaction, auto: false }
-      if (Flag.SAEEOL_DISABLE_PRUNE) result.compaction = { ...result.compaction, prune: false }
-      SaeeolDefaultPlugins.apply(result, { disabled: Flag.SAEEOL_DISABLE_DEFAULT_PLUGINS, log })
-
-      return { config: result, directories, deps, warnings, consoleState: { consoleManagedProviders: Array.from(consoleManagedProviders), activeOrgName: undefined, switchableOrgCount: 0 } }
-    })
-
-    const state = yield* InstanceState.make<State>(
-      Effect.fn("Config.state")(function* (ctx) {
-        return yield* loadInstanceState(ctx).pipe(
-          Effect.provideService(AppFileSystem.Service, fs),
-          Effect.orDie,
-        )
-      }),
-    )
-
-    const get = Effect.fn("Config.get")(function* () { return yield* InstanceState.use(state, (s) => s.config) })
-    const directories = Effect.fn("Config.directories")(function* () { return yield* InstanceState.use(state, (s) => s.directories) })
-    const getConsoleState = Effect.fn("Config.getConsoleState")(function* () { return yield* InstanceState.use(state, (s) => s.consoleState) })
-    const waitForDependencies = Effect.fn("Config.waitForDependencies")(function* () {
-      yield* InstanceState.useEffect(state, (s) =>
-        Effect.forEach(s.deps, Fiber.join, { concurrency: "unbounded" }).pipe(Effect.asVoid),
-      )
-    })
-    const warnings = Effect.fn("Config.warnings")(function* () { return yield* InstanceState.use(state, (s) => s.warnings) })
-
-    const update = Effect.fn("Config.update")(function* (config: Info, options?: { dispose?: boolean }) {
-      const ctx = yield* InstanceState.context
-      yield* SaeeolConfig.updateProjectConfig({
-        fs, directory: ctx.directory, worktree: ctx.worktree, config,
-        read: $read, parse: (input, file) => ConfigParse.schema(Info.zod, ConfigParse.jsonc(input, file), file),
-        patch: (input, p) => patchJsonc(input, p), writable,
-      })
-      if (options?.dispose !== false) {
-        const ctx = yield* InstanceState.context
-        yield* Effect.promise(() => InstanceStore.disposeInstance(ctx))
-      }
-    })
-
-    const invalidate = Effect.fn("Config.invalidate")(function* (wait?: boolean) {
-      yield* invalidateGlobal
-      const task = InstanceStore.disposeAllInstances()
-        .catch(() => undefined)
-        .finally(() => GlobalBus.emit("event", { directory: "global", payload: { type: Event.Disposed.type, properties: {} } }))
-      if (wait) yield* Effect.promise(() => task)
-      else void task
-    })
-
-    const updateGlobal = Effect.fn("Config.updateGlobal")(function* (config: Info, options?: { dispose?: boolean }) {
-      const dispose = options?.dispose ?? true
-      const file = globalConfigFile()
-      const before = (yield* $read(file)) ?? "{}"
-      const patch = writableGlobal(config)
-      let next: Info
-      let changed: boolean
-      if (!file.endsWith(".jsonc")) {
-        const existing = ConfigParse.effectSchema(Info, ConfigParse.jsonc(before, file), file)
-        const merged = SaeeolConfig.mergeConfig(writable(existing), patch)
-        const serialized = JSON.stringify(merged, null, 2)
-        changed = serialized !== before
-        if (changed) yield* fs.writeFileString(file, serialized).pipe(Effect.orDie)
-        next = merged
-      } else {
-        const updated = patchJsonc(before, patch)
-        next = ConfigParse.effectSchema(Info, ConfigParse.jsonc(updated, file), file)
-        changed = updated !== before
-        if (changed) yield* fs.writeFileString(file, updated).pipe(Effect.orDie)
-      }
-      if (!dispose) {
-        yield* invalidateGlobal
-        yield* InstanceState.invalidate(state)
-        yield* Effect.sync(() => GlobalBus.emit("event", { directory: "global", payload: { type: Event.ConfigUpdated.type, properties: {} } }))
-        return next
-      }
-      if (changed) yield* invalidate()
-      return next
-    })
-
-    return Service.of({ get, getGlobal, getConsoleState, update, updateGlobal, invalidate, directories, waitForDependencies, warnings })
-  }),
-)
-
-export const defaultLayer = layer.pipe(
-  Layer.provide(EffectFlock.defaultLayer),
-  Layer.provide(AppFileSystem.defaultLayer),
-  Layer.provide(Env.defaultLayer),
-  Layer.provide(Auth.defaultLayer),
-  Layer.provide(Account.defaultLayer),
-  Layer.provide(Npm.defaultLayer),
-)
-
-const { runPromise } = makeRuntime(Service, defaultLayer)
-
-export async function get() { return runPromise((svc) => svc.get()) }
-export async function getGlobal() { return runPromise((svc) => svc.getGlobal()) }
-export async function getConsoleState() { return runPromise((svc) => svc.getConsoleState()) }
-export async function update(config: Info, options?: { dispose?: boolean }) { return runPromise((svc) => svc.update(config, options)) }
-export async function updateGlobal(config: Info, options?: { dispose?: boolean }) { return runPromise((svc) => svc.updateGlobal(config, options)) }
-export async function invalidate(wait = false) { return runPromise((svc) => svc.invalidate(wait)) }
-export async function directories() { return runPromise((svc) => svc.directories()) }
-export async function waitForDependencies() { return runPromise((svc) => svc.waitForDependencies()) }
-export async function warnings() { return runPromise((svc) => svc.warnings()) }
-
-export * as Config from "./config"

package/src/config/console-state.ts

@@ -1,17 +0,0 @@
-import { Schema } from "effect"
-import { zod } from "@/util/effect-zod"
-import { NonNegativeInt } from "@/util/schema"
-
-export class ConsoleState extends Schema.Class<ConsoleState>("ConsoleState")({
-  consoleManagedProviders: Schema.mutable(Schema.Array(Schema.String)),
-  activeOrgName: Schema.optional(Schema.String),
-  switchableOrgCount: NonNegativeInt,
-}) {
-  static readonly zod = zod(this)
-}
-
-export const emptyConsoleState: ConsoleState = ConsoleState.make({
-  consoleManagedProviders: [],
-  activeOrgName: undefined,
-  switchableOrgCount: 0,
-})

package/src/config/entry-name.ts

@@ -1,16 +0,0 @@
-import path from "path"
-
-function sliceAfterMatch(filePath: string, searchRoots: string[]) {
-  const normalizedPath = filePath.replaceAll("\\", "/")
-  for (const searchRoot of searchRoots) {
-    const index = normalizedPath.indexOf(searchRoot)
-    if (index === -1) continue
-    return normalizedPath.slice(index + searchRoot.length)
-  }
-}
-
-export function configEntryNameFromPath(filePath: string, searchRoots: string[]) {
-  const candidate = sliceAfterMatch(filePath, searchRoots) ?? path.basename(filePath)
-  const ext = path.extname(candidate)
-  return ext.length ? candidate.slice(0, -ext.length) : candidate
-}

package/src/config/error.ts

@@ -1,21 +0,0 @@
-export * as ConfigError from "./error"
-
-import z from "zod"
-import { NamedError } from "@saeeol/core/util/error"
-
-export const JsonError = NamedError.create(
-  "ConfigJsonError",
-  z.object({
-    path: z.string(),
-    message: z.string().optional(),
-  }),
-)
-
-export const InvalidError = NamedError.create(
-  "ConfigInvalidError",
-  z.object({
-    path: z.string(),
-    issues: z.custom<z.core.$ZodIssue[]>().optional(),
-    message: z.string().optional(),
-  }),
-)

package/src/config/formatter.ts

@@ -1,17 +0,0 @@
-export * as ConfigFormatter from "./formatter"
-
-import { Schema } from "effect"
-import { zod } from "@/util/effect-zod"
-import { withStatics } from "@/util/schema"
-
-export const Entry = Schema.Struct({
-  disabled: Schema.optional(Schema.Boolean),
-  command: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
-  environment: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-  extensions: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
-}).pipe(withStatics((s) => ({ zod: zod(s) })))
-
-export const Info = Schema.Union([Schema.Boolean, Schema.Record(Schema.String, Entry)]).pipe(
-  withStatics((s) => ({ zod: zod(s) })),
-)
-export type Info = Schema.Schema.Type<typeof Info>

package/src/config/keybinds.ts

@@ -1,130 +0,0 @@
-export * as ConfigKeybinds from "./keybinds"
-
-import { Effect, Schema } from "effect"
-import type z from "zod"
-import { zod } from "@/util/effect-zod"
-
-// Every keybind field has the same shape: an optional string with a default
-// binding and a human description.  `keybind()` keeps the declaration list
-// below dense and readable.
-const keybind = (value: string, description: string) =>
-  Schema.String.pipe(Schema.optional, Schema.withDecodingDefault(Effect.succeed(value))).annotate({ description })
-
-// Windows prepends ctrl+z to the undo binding because `terminal_suspend`
-// cannot consume ctrl+z on native Windows terminals (no POSIX suspend).
-const inputUndoDefault = process.platform === "win32" ? "ctrl+z,ctrl+-,super+z" : "ctrl+-,super+z"
-
-const KeybindsSchema = Schema.Struct({
-  leader: keybind("ctrl+x", "Leader key for keybind combinations"),
-  app_exit: keybind("ctrl+c,ctrl+d,<leader>q", "Exit the application"),
-  editor_open: keybind("<leader>e", "Open external editor"),
-  theme_list: keybind("<leader>t", "List available themes"),
-  sidebar_toggle: keybind("<leader>b", "Toggle sidebar"),
-  scrollbar_toggle: keybind("none", "Toggle session scrollbar"),
-  username_toggle: keybind("none", "Toggle username visibility"),
-  status_view: keybind("<leader>s", "View status"),
-  session_export: keybind("<leader>x", "Export session to editor"),
-  session_new: keybind("<leader>n", "Create a new session"),
-  session_list: keybind("<leader>l", "List all sessions"),
-  session_timeline: keybind("<leader>g", "Show session timeline"),
-  session_fork: keybind("none", "Fork session from message"),
-  session_rename: keybind("ctrl+r", "Rename session"),
-  session_delete: keybind("ctrl+d", "Delete session"),
-  stash_delete: keybind("ctrl+d", "Delete stash entry"),
-  model_provider_list: keybind("ctrl+a", "Open provider list from model dialog"),
-  model_favorite_toggle: keybind("ctrl+f", "Toggle model favorite status"),
-  session_share: keybind("none", "Share current session"),
-  session_unshare: keybind("none", "Unshare current session"),
-  session_interrupt: keybind("escape", "Interrupt current session"),
-  session_compact: keybind("<leader>c", "Compact the session"),
-  messages_page_up: keybind("pageup,ctrl+alt+b", "Scroll messages up by one page"),
-  messages_page_down: keybind("pagedown,ctrl+alt+f", "Scroll messages down by one page"),
-  messages_line_up: keybind("ctrl+up", "Scroll messages up by one line"),
-  messages_line_down: keybind("ctrl+down", "Scroll messages down by one line"),
-  messages_half_page_up: keybind("ctrl+pageup", "Scroll messages up by half page"),
-  messages_half_page_down: keybind("ctrl+pagedown", "Scroll messages down by half page"),
-  messages_first: keybind("ctrl+g,home", "Navigate to first message"),
-  messages_last: keybind("ctrl+alt+g,end", "Navigate to last message"),
-  messages_next: keybind("none", "Navigate to next message"),
-  messages_previous: keybind("none", "Navigate to previous message"),
-  messages_last_user: keybind("none", "Navigate to last user message"),
-  messages_copy: keybind("<leader>y", "Copy message"),
-  messages_undo: keybind("<leader>u", "Undo message"),
-  messages_redo: keybind("<leader>r", "Redo message"),
-  messages_feedback_up: keybind("<leader>=", "Rate last assistant message helpful"),
-  messages_feedback_down: keybind("<leader>-", "Rate last assistant message not helpful"),
-  messages_toggle_conceal: keybind("<leader>h", "Toggle code block concealment in messages"),
-  tool_details: keybind("none", "Toggle tool details visibility"),
-  model_list: keybind("<leader>m", "List available models"),
-  model_cycle_recent: keybind("f2", "Next recently used model"),
-  model_cycle_recent_reverse: keybind("shift+f2", "Previous recently used model"),
-  model_cycle_favorite: keybind("none", "Next favorite model"),
-  model_cycle_favorite_reverse: keybind("none", "Previous favorite model"),
-  command_list: keybind("ctrl+p", "List available commands"),
-  agent_list: keybind("<leader>a", "List agents"),
-  agent_cycle: keybind("tab", "Next agent"),
-  agent_cycle_reverse: keybind("shift+tab", "Previous agent"),
-  variant_cycle: keybind("ctrl+t", "Cycle model variants"),
-  variant_list: keybind("none", "List model variants"),
-  input_clear: keybind("ctrl+c", "Clear input field"),
-  input_paste: keybind("ctrl+v", "Paste from clipboard"),
-  input_submit: keybind("return", "Submit input"),
-  input_newline: keybind("shift+return,ctrl+return,alt+return,ctrl+j", "Insert newline in input"),
-  input_move_left: keybind("left,ctrl+b", "Move cursor left in input"),
-  input_move_right: keybind("right,ctrl+f", "Move cursor right in input"),
-  input_move_up: keybind("up", "Move cursor up in input"),
-  input_move_down: keybind("down", "Move cursor down in input"),
-  input_select_left: keybind("shift+left", "Select left in input"),
-  input_select_right: keybind("shift+right", "Select right in input"),
-  input_select_up: keybind("shift+up", "Select up in input"),
-  input_select_down: keybind("shift+down", "Select down in input"),
-  input_line_home: keybind("ctrl+a", "Move to start of line in input"),
-  input_line_end: keybind("ctrl+e", "Move to end of line in input"),
-  input_select_line_home: keybind("ctrl+shift+a", "Select to start of line in input"),
-  input_select_line_end: keybind("ctrl+shift+e", "Select to end of line in input"),
-  input_visual_line_home: keybind("alt+a", "Move to start of visual line in input"),
-  input_visual_line_end: keybind("alt+e", "Move to end of visual line in input"),
-  input_select_visual_line_home: keybind("alt+shift+a", "Select to start of visual line in input"),
-  input_select_visual_line_end: keybind("alt+shift+e", "Select to end of visual line in input"),
-  input_buffer_home: keybind("home", "Move to start of buffer in input"),
-  input_buffer_end: keybind("end", "Move to end of buffer in input"),
-  input_select_buffer_home: keybind("shift+home", "Select to start of buffer in input"),
-  input_select_buffer_end: keybind("shift+end", "Select to end of buffer in input"),
-  input_delete_line: keybind("ctrl+shift+d", "Delete line in input"),
-  input_delete_to_line_end: keybind("ctrl+k", "Delete to end of line in input"),
-  input_delete_to_line_start: keybind("ctrl+u", "Delete to start of line in input"),
-  input_backspace: keybind("backspace,shift+backspace", "Backspace in input"),
-  input_delete: keybind("ctrl+d,delete,shift+delete", "Delete character in input"),
-  input_undo: keybind(inputUndoDefault, "Undo in input"),
-  input_redo: keybind("ctrl+.,super+shift+z", "Redo in input"),
-  input_word_forward: keybind("alt+f,alt+right,ctrl+right", "Move word forward in input"),
-  input_word_backward: keybind("alt+b,alt+left,ctrl+left", "Move word backward in input"),
-  input_select_word_forward: keybind("alt+shift+f,alt+shift+right", "Select word forward in input"),
-  input_select_word_backward: keybind("alt+shift+b,alt+shift+left", "Select word backward in input"),
-  input_delete_word_forward: keybind("alt+d,alt+delete,ctrl+delete", "Delete word forward in input"),
-  input_delete_word_backward: keybind("ctrl+w,ctrl+backspace,alt+backspace", "Delete word backward in input"),
-  history_previous: keybind("none", "Previous history item"),
-  history_next: keybind("none", "Next history item"),
-  session_child_first: keybind("<leader>down", "Go to first child session"),
-  session_child_cycle: keybind("right", "Go to next child session"),
-  session_child_cycle_reverse: keybind("left", "Go to previous child session"),
-  session_parent: keybind("up", "Go to parent session"),
-  // `terminal_suspend` was formerly `.default("ctrl+z").transform((v) => win32 ? "none" : v)`,
-  // but `tui.ts` already forces the binding to "none" on win32 before calling
-  // `Keybinds.parse(...)`, so the schema-level transform was redundant.
-  terminal_suspend: keybind("ctrl+z", "Suspend terminal"),
-  terminal_title_toggle: keybind("none", "Toggle terminal title"),
-  tips_toggle: keybind("<leader>h", "Toggle tips on home screen"),
-  news_toggle: keybind("none", "Toggle news on home screen"), 
-  plugin_manager: keybind("none", "Open plugin manager dialog"),
-  display_thinking: keybind("none", "Toggle thinking blocks visibility"),
-}).annotate({ identifier: "KeybindsConfig" })
-
-export type Keybinds = Schema.Schema.Type<typeof KeybindsSchema>
-
-// Consumers access `Keybinds.shape` and `Keybinds.shape.X.parse(undefined)`,
-// which requires the runtime type to be a ZodObject, not just ZodType.  Every
-// field is `string().optional().default(...)` at runtime, so widen to that.
-export const Keybinds = zod(KeybindsSchema) as unknown as z.ZodObject<
-  Record<keyof Keybinds, z.ZodDefault<z.ZodOptional<z.ZodString>>>
->

package/src/config/layout.ts

@@ -1,10 +0,0 @@
-import { Schema } from "effect"
-import { zod } from "@/util/effect-zod"
-import { withStatics } from "@/util/schema"
-
-export const Layout = Schema.Literals(["auto", "stretch"])
-  .annotate({ identifier: "LayoutConfig" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type Layout = Schema.Schema.Type<typeof Layout>
-
-export * as ConfigLayout from "./layout"