tulingcode 0.1.0

package/src/config/console-state.ts

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

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

@@ -0,0 +1,21 @@
+export * as ConfigError from "./error"
+
+import z from "zod"
+import { NamedError } from "@tuling-ai/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

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

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

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

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

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

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

@@ -0,0 +1,70 @@
+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", "tulingcode")
+    default:
+      return "/etc/opencode"
+  }
+}
+
+export function managedConfigDir() {
+  return process.env.tulingcode_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

@@ -0,0 +1,97 @@
+import { NamedError } from "@tuling-ai/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

@@ -0,0 +1,172 @@
+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: "tulingcode" | "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

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