woozlit 2.3.0 → 2.3.1

package/src/config/console-state.ts

@@ -1,16 +0,0 @@
-import { Schema } from "effect"
-import { zod } from "@/util/effect-zod"
-
-export class ConsoleState extends Schema.Class<ConsoleState>("ConsoleState")({
-  consoleManagedProviders: Schema.mutable(Schema.Array(Schema.String)),
-  activeOrgName: Schema.optional(Schema.String),
-  switchableOrgCount: Schema.Number,
-}) {
-  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 "@woozlit/shared/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/history.ts

@@ -1,21 +0,0 @@
-export * as ConfigHistory from "./history"
-
-import { Schema } from "effect"
-
-export const Kind = Schema.Literals([
-  "user_text",
-  "assistant_text",
-  "tool_input",
-  "tool_error",
-  "reasoning",
-  "tool_output",
-])
-
-export const Info = Schema.Struct({
-  kinds: Schema.optional(Schema.Array(Kind)).annotate({
-    description:
-      "Which part kinds the history FTS index should cover. Defaults to text (user/assistant) + tool input + tool errors. Add 'reasoning' or 'tool_output' to grow recall at the cost of database size. Note: enabling 'tool_output' reclassifies completed tools from kind='tool_input' to kind='tool_output' (input remains searchable in the body, but kind:['tool_input'] filter will then only match pending/error tools).",
-  }),
-})
-
-export type Info = Schema.Schema.Type<typeof Info>

package/src/config/index.ts

@@ -1,16 +0,0 @@
-export * as Config from "./config"
-export * as ConfigAgent from "./agent"
-export * as ConfigCommand from "./command"
-export * as ConfigError from "./error"
-export * as ConfigFormatter from "./formatter"
-export * as ConfigLSP from "./lsp"
-export * as ConfigVariable from "./variable"
-export { ConfigManaged } from "./managed"
-export * as ConfigMarkdown from "./markdown"
-export * as ConfigMCP from "./mcp"
-export { ConfigModelID } from "./model-id"
-export * as ConfigParse from "./parse"
-export * as ConfigPermission from "./permission"
-export * as ConfigPaths from "./paths"
-export * as ConfigProvider from "./provider"
-export * as ConfigSkills from "./skills"

package/src/config/keybinds.ts

@@ -1,127 +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+alt+y", "Scroll messages up by one line"),
-  messages_line_down: keybind("ctrl+alt+e", "Scroll messages down by one line"),
-  messages_half_page_up: keybind("ctrl+alt+u", "Scroll messages up by half page"),
-  messages_half_page_down: keybind("ctrl+alt+d", "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_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("up", "Previous history item"),
-  history_next: keybind("down", "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"),
-  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"

package/src/config/lsp.ts

@@ -1,45 +0,0 @@
-export * as ConfigLSP from "./lsp"
-
-import { Schema } from "effect"
-import { zod } from "@/util/effect-zod"
-import { withStatics } from "@/util/schema"
-import * as LSPServer from "../lsp/server"
-
-export const Disabled = Schema.Struct({
-  disabled: Schema.Literal(true),
-}).pipe(withStatics((s) => ({ zod: zod(s) })))
-
-export const Entry = Schema.Union([
-  Disabled,
-  Schema.Struct({
-    command: Schema.mutable(Schema.Array(Schema.String)),
-    extensions: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
-    disabled: Schema.optional(Schema.Boolean),
-    env: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-    initialization: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-  }),
-]).pipe(withStatics((s) => ({ zod: zod(s) })))
-
-/**
- * For custom (non-builtin) LSP server entries, `extensions` is required so the
- * client knows which files the server should attach to. Builtin server IDs and
- * explicitly disabled entries are exempt.
- */
-export const requiresExtensionsForCustomServers = Schema.makeFilter<
-  boolean | Record<string, Schema.Schema.Type<typeof Entry>>
->((data) => {
-  if (typeof data === "boolean") return undefined
-  const serverIds = new Set(Object.values(LSPServer).map((server) => server.id))
-  const ok = Object.entries(data).every(([id, config]) => {
-    if ("disabled" in config && config.disabled) return true
-    if (serverIds.has(id)) return true
-    return "extensions" in config && Boolean(config.extensions)
-  })
-  return ok ? undefined : "For custom LSP servers, 'extensions' array is required."
-})
-
-export const Info = Schema.Union([Schema.Boolean, Schema.Record(Schema.String, Entry)])
-  .check(requiresExtensionsForCustomServers)
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-
-export type Info = Schema.Schema.Type<typeof Info>

package/src/config/managed.ts

@@ -1,70 +0,0 @@
-export * as ConfigManaged from "./managed"
-
-import { existsSync } from "fs"
-import os from "os"
-import path from "path"
-import { Log, Process } from "../util"
-import { warn } from "console"
-
-const log = Log.create({ service: "config" })
-
-const MANAGED_PLIST_DOMAIN = "ai.opencode.managed"
-
-// Keys injected by macOS/MDM into the managed plist that are not OpenCode config
-const PLIST_META = new Set([
-  "PayloadDisplayName",
-  "PayloadIdentifier",
-  "PayloadType",
-  "PayloadUUID",
-  "PayloadVersion",
-  "_manualProfile",
-])
-
-function systemManagedConfigDir(): string {
-  switch (process.platform) {
-    case "darwin":
-      return "/Library/Application Support/opencode"
-    case "win32":
-      return path.join(process.env.ProgramData || "C:\\ProgramData", "opencode")
-    default:
-      return "/etc/opencode"
-  }
-}
-
-export function managedConfigDir() {
-  return process.env.WOOZLIT_CODE_TEST_MANAGED_CONFIG_DIR || systemManagedConfigDir()
-}
-
-export function parseManagedPlist(json: string): string {
-  const raw = JSON.parse(json)
-  for (const key of Object.keys(raw)) {
-    if (PLIST_META.has(key)) delete raw[key]
-  }
-  return JSON.stringify(raw)
-}
-
-export async function readManagedPreferences() {
-  if (process.platform !== "darwin") return
-
-  const user = os.userInfo().username
-  const paths = [
-    path.join("/Library/Managed Preferences", user, `${MANAGED_PLIST_DOMAIN}.plist`),
-    path.join("/Library/Managed Preferences", `${MANAGED_PLIST_DOMAIN}.plist`),
-  ]
-
-  for (const plist of paths) {
-    if (!existsSync(plist)) continue
-    log.info("reading macOS managed preferences", { path: plist })
-    const result = await Process.run(["plutil", "-convert", "json", "-o", "-", plist], { nothrow: true })
-    if (result.code !== 0) {
-      log.warn("failed to convert managed preferences plist", { path: plist })
-      continue
-    }
-    return {
-      source: `mobileconfig:${plist}`,
-      text: parseManagedPlist(result.stdout.toString()),
-    }
-  }
-
-  return
-}

package/src/config/markdown.ts

@@ -1,97 +0,0 @@
-import { NamedError } from "@woozlit/shared/util/error"
-import matter from "gray-matter"
-import { z } from "zod"
-import { Filesystem } from "../util"
-
-export const FILE_REGEX = /(?<![\w`])@(\.?[^\s`,.]*(?:\.[^\s`,.]+)*)/g
-export const SHELL_REGEX = /!`([^`]+)`/g
-
-export function files(template: string) {
-  return Array.from(template.matchAll(FILE_REGEX))
-}
-
-export function shell(template: string) {
-  return Array.from(template.matchAll(SHELL_REGEX))
-}
-
-// other coding agents like claude code allow invalid yaml in their
-// frontmatter, we need to fallback to a more permissive parser for those cases
-export function fallbackSanitization(content: string): string {
-  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/)
-  if (!match) return content
-
-  const frontmatter = match[1]
-  const lines = frontmatter.split(/\r?\n/)
-  const result: string[] = []
-
-  for (const line of lines) {
-    // skip comments and empty lines
-    if (line.trim().startsWith("#") || line.trim() === "") {
-      result.push(line)
-      continue
-    }
-
-    // skip lines that are continuations (indented)
-    if (line.match(/^\s+/)) {
-      result.push(line)
-      continue
-    }
-
-    // match key: value pattern
-    const kvMatch = line.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.*)$/)
-    if (!kvMatch) {
-      result.push(line)
-      continue
-    }
-
-    const key = kvMatch[1]
-    const value = kvMatch[2].trim()
-
-    // skip if value is empty, already quoted, or uses block scalar
-    if (value === "" || value === ">" || value === "|" || value.startsWith('"') || value.startsWith("'")) {
-      result.push(line)
-      continue
-    }
-
-    // if value contains a colon, convert to block scalar
-    if (value.includes(":")) {
-      result.push(`${key}: |-`)
-      result.push(`  ${value}`)
-      continue
-    }
-
-    result.push(line)
-  }
-
-  const processed = result.join("\n")
-  return content.replace(frontmatter, () => processed)
-}
-
-export async function parse(filePath: string) {
-  const template = await Filesystem.readText(filePath)
-
-  try {
-    const md = matter(template)
-    return md
-  } catch {
-    try {
-      return matter(fallbackSanitization(template))
-    } catch (err) {
-      throw new FrontmatterError(
-        {
-          path: filePath,
-          message: `${filePath}: Failed to parse YAML frontmatter: ${err instanceof Error ? err.message : String(err)}`,
-        },
-        { cause: err },
-      )
-    }
-  }
-}
-
-export const FrontmatterError = NamedError.create(
-  "ConfigFrontmatterError",
-  z.object({
-    path: z.string(),
-    message: z.string(),
-  }),
-)

package/src/config/mcp.ts

@@ -1,172 +0,0 @@
-import { Schema } from "effect"
-import { isRecord } from "@/util/record"
-import { zod } from "@/util/effect-zod"
-import { withStatics } from "@/util/schema"
-
-export class Local extends Schema.Class<Local>("McpLocalConfig")({
-  type: Schema.Literal("local").annotate({ description: "Type of MCP server connection" }),
-  command: Schema.mutable(Schema.Array(Schema.String)).annotate({
-    description: "Command and arguments to run the MCP server",
-  }),
-  environment: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({
-    description: "Environment variables to set when running the MCP server",
-  }),
-  enabled: Schema.optional(Schema.Boolean).annotate({
-    description: "Enable or disable the MCP server on startup",
-  }),
-  timeout: Schema.optional(Schema.Number).annotate({
-    description: "Timeout in ms for MCP server requests. Defaults to 5000 (5 seconds) if not specified.",
-  }),
-}) {
-  static readonly zod = zod(this)
-}
-
-export class OAuth extends Schema.Class<OAuth>("McpOAuthConfig")({
-  clientId: Schema.optional(Schema.String).annotate({
-    description: "OAuth client ID. If not provided, dynamic client registration (RFC 7591) will be attempted.",
-  }),
-  clientSecret: Schema.optional(Schema.String).annotate({
-    description: "OAuth client secret (if required by the authorization server)",
-  }),
-  scope: Schema.optional(Schema.String).annotate({ description: "OAuth scopes to request during authorization" }),
-  redirectUri: Schema.optional(Schema.String).annotate({
-    description: "OAuth redirect URI (default: http://127.0.0.1:19876/mcp/oauth/callback).",
-  }),
-}) {
-  static readonly zod = zod(this)
-}
-
-export class Remote extends Schema.Class<Remote>("McpRemoteConfig")({
-  type: Schema.Literal("remote").annotate({ description: "Type of MCP server connection" }),
-  url: Schema.String.annotate({ description: "URL of the remote MCP server" }),
-  enabled: Schema.optional(Schema.Boolean).annotate({
-    description: "Enable or disable the MCP server on startup",
-  }),
-  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({
-    description: "Headers to send with the request",
-  }),
-  oauth: Schema.optional(Schema.Union([OAuth, Schema.Literal(false)])).annotate({
-    description: "OAuth authentication configuration for the MCP server. Set to false to disable OAuth auto-detection.",
-  }),
-  timeout: Schema.optional(Schema.Number).annotate({
-    description: "Timeout in ms for MCP server requests. Defaults to 5000 (5 seconds) if not specified.",
-  }),
-}) {
-  static readonly zod = zod(this)
-}
-
-export const Info = Schema.Union([Local, Remote])
-  .annotate({ discriminator: "type" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type Info = Schema.Schema.Type<typeof Info>
-
-export type Origin = {
-  type: "opencode" | "claude"
-  source: string
-}
-
-const remoteTypes = new Set(["http", "streamable-http", "remote"])
-const localTypes = new Set(["stdio", "local"])
-const sensitive = ["authorization", "token", "api_key", "apikey", "key", "secret", "password", "credential"]
-
-function stringRecord(input: unknown) {
-  if (!isRecord(input)) return undefined
-  return Object.fromEntries(
-    Object.entries(input).filter((entry): entry is [string, string] => typeof entry[1] === "string"),
-  )
-}
-
-function isSensitive(input: string) {
-  return sensitive.some((item) => input.toLowerCase().includes(item))
-}
-
-function oauth(input: unknown) {
-  if (input === false) return false
-  if (!isRecord(input)) return undefined
-  const result = {
-    ...(typeof input.clientId === "string" && { clientId: input.clientId }),
-    ...(typeof input.clientSecret === "string" && { clientSecret: input.clientSecret }),
-    ...(typeof input.scope === "string" && { scope: input.scope }),
-    ...(typeof input.redirectUri === "string" && { redirectUri: input.redirectUri }),
-  }
-  return Object.keys(result).length > 0 ? result : undefined
-}
-
-export function fromClaude(name: string, input: unknown): { config: Info } | { warning: string } {
-  if (!isRecord(input)) return { warning: `skipped Claude Code MCP server "${name}"; server config is not an object.` }
-
-  if (input.type === "sse") {
-    return { warning: `skipped Claude Code MCP server "${name}"; unsupported transport "sse".` }
-  }
-
-  if (input.args !== undefined && !Array.isArray(input.args)) {
-    return { warning: `skipped Claude Code MCP server "${name}"; args is not an array.` }
-  }
-
-  const args = Array.isArray(input.args) ? input.args : []
-  if (!args.every((item) => typeof item === "string")) {
-    return { warning: `skipped Claude Code MCP server "${name}"; args must contain only strings.` }
-  }
-
-  const enabled = input.disabled === true ? false : input.enabled === false ? false : true
-  const environment = stringRecord(input.environment) ?? stringRecord(input.env)
-  const timeout = typeof input.timeout === "number" ? input.timeout : undefined
-  const type = typeof input.type === "string" ? input.type : undefined
-
-  if (typeof input.command === "string" && (!type || localTypes.has(type))) {
-    return {
-      config: {
-        type: "local",
-        command: [input.command, ...args],
-        ...(environment && { environment }),
-        enabled,
-        ...(timeout !== undefined && { timeout }),
-      },
-    }
-  }
-
-  if (input.command !== undefined) {
-    return { warning: `skipped Claude Code MCP server "${name}"; command is not a string.` }
-  }
-
-  if (typeof input.url === "string" && (!type || remoteTypes.has(type))) {
-    const headers = stringRecord(input.headers)
-    const oauthConfig = oauth(input.oauth)
-    return {
-      config: {
-        type: "remote",
-        url: input.url,
-        enabled,
-        ...(headers && { headers }),
-        ...(oauthConfig !== undefined && { oauth: oauthConfig }),
-        ...(timeout !== undefined && { timeout }),
-      },
-    }
-  }
-
-  if (input.url !== undefined) {
-    return { warning: `skipped Claude Code MCP server "${name}"; url is not a string.` }
-  }
-
-  if (type && !localTypes.has(type) && !remoteTypes.has(type)) {
-    return { warning: `skipped Claude Code MCP server "${name}"; unsupported transport "${type}".` }
-  }
-
-  return { warning: `skipped Claude Code MCP server "${name}"; missing command or url.` }
-}
-
-export function redactString(input: string) {
-  return input
-    .replace(/(Bearer\s+)[^\s]+/gi, "$1****")
-    .replace(/([?&][^=\s&]*(?:authorization|token|api[_-]?key|apikey|key|secret|password|credential)[^=\s&]*=)[^&\s]+/gi, "$1****")
-    .replace(/((?:authorization|token|api[_-]?key|apikey|key|secret|password|credential)=)[^\s]+/gi, "$1****")
-}
-
-export function redactCommand(command: string[]) {
-  return command.map((item, index) => {
-    if (index > 0 && isSensitive(command[index - 1])) return "****"
-    return redactString(item)
-  })
-}
-
-export * as ConfigMCP from "./mcp"

package/src/config/model-id.ts

@@ -1,14 +0,0 @@
-import { Schema } from "effect"
-import z from "zod"
-import { zod, ZodOverride } from "@/util/effect-zod"
-import { withStatics } from "@/util/schema"
-
-// The original Zod schema carried an external $ref pointing at the models.dev
-// JSON schema. That external reference is not a named SDK component — it is a
-// literal pointer to an outside schema — so the walker cannot re-derive it
-// from AST metadata. Preserve the exact original Zod via ZodOverride.
-export const ConfigModelID = Schema.String.annotate({
-  [ZodOverride]: z.string().meta({ $ref: "https://models.dev/model-schema.json#/$defs/Model" }),
-}).pipe(withStatics((s) => ({ zod: zod(s) })))
-
-export type ConfigModelID = Schema.Schema.Type<typeof ConfigModelID>