bonecode 1.0.0

package/src/engine/config/console-state.ts

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

package/src/engine/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/engine/config/error.ts

@@ -0,0 +1,23 @@
+export * as ConfigError from "./error"
+
+import { NamedError } from "@opencode-ai/core/util/error"
+import { Schema } from "effect"
+
+const Issue = Schema.StructWithRest(
+  Schema.Struct({
+    message: Schema.String,
+    path: Schema.Array(Schema.String),
+  }),
+  [Schema.Record(Schema.String, Schema.Unknown)],
+)
+
+export const JsonError = NamedError.create("ConfigJsonError", {
+  path: Schema.String,
+  message: Schema.optional(Schema.String),
+})
+
+export const InvalidError = NamedError.create("ConfigInvalidError", {
+  path: Schema.String,
+  issues: Schema.optional(Schema.Array(Issue)),
+  message: Schema.optional(Schema.String),
+})

package/src/engine/config/formatter.ts

@@ -0,0 +1,13 @@
+export * as ConfigFormatter from "./formatter"
+
+import { Schema } from "effect"
+
+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))),
+})
+
+export const Info = Schema.Union([Schema.Boolean, Schema.Record(Schema.String, Entry)])
+export type Info = Schema.Schema.Type<typeof Info>

package/src/engine/config/layout.ts

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

package/src/engine/config/lsp.ts

@@ -0,0 +1,43 @@
+export * as ConfigLSP from "./lsp"
+
+import { Schema } from "effect"
+import * as LSPServer from "../lsp/server"
+
+export const Disabled = Schema.Struct({
+  disabled: Schema.Literal(true),
+}).pipe((schema) => schema)
+
+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((schema) => schema)
+
+/**
+ * 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((schema) => schema)
+
+export type Info = Schema.Schema.Type<typeof Info>

package/src/engine/config/managed.ts

@@ -0,0 +1,71 @@
+export * as ConfigManaged from "./managed"
+
+import { existsSync } from "fs"
+import os from "os"
+import path from "path"
+import * as Log from "@opencode-ai/core/util/log"
+import { Process } from "@/util/process"
+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.OPENCODE_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/engine/config/markdown.ts

@@ -0,0 +1,96 @@
+import { NamedError } from "@opencode-ai/core/util/error"
+import matter from "gray-matter"
+import { Schema } from "effect"
+import { Filesystem } from "@/util/filesystem"
+
+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", {
+  path: Schema.String,
+  message: Schema.String,
+})
+
+export * as ConfigMarkdown from "./markdown"

package/src/engine/config/mcp.ts

@@ -0,0 +1,56 @@
+import { Schema } from "effect"
+import { PositiveInt } from "@opencode-ai/core/schema"
+
+export const Local = Schema.Struct({
+  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(PositiveInt).annotate({
+    description: "Timeout in ms for MCP server requests. Defaults to 5000 (5 seconds) if not specified.",
+  }),
+}).annotate({ identifier: "McpLocalConfig" })
+export type Local = Schema.Schema.Type<typeof Local>
+
+export const OAuth = Schema.Struct({
+  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).",
+  }),
+}).annotate({ identifier: "McpOAuthConfig" })
+export type OAuth = Schema.Schema.Type<typeof OAuth>
+
+export const Remote = Schema.Struct({
+  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(PositiveInt).annotate({
+    description: "Timeout in ms for MCP server requests. Defaults to 5000 (5 seconds) if not specified.",
+  }),
+}).annotate({ identifier: "McpRemoteConfig" })
+export type Remote = Schema.Schema.Type<typeof Remote>
+
+export const Info = Schema.Union([Local, Remote]).annotate({ discriminator: "type" })
+export type Info = Schema.Schema.Type<typeof Info>
+
+export * as ConfigMCP from "./mcp"

package/src/engine/config/model-id.ts

@@ -0,0 +1,5 @@
+import { Schema } from "effect"
+
+export const ConfigModelID = Schema.String
+
+export type ConfigModelID = Schema.Schema.Type<typeof ConfigModelID>

package/src/engine/config/parse.ts

@@ -0,0 +1,79 @@
+export * as ConfigParse from "./parse"
+
+import { type ParseError as JsoncParseError, parse as parseJsoncImpl, printParseErrorCode } from "jsonc-parser"
+import { Cause, Exit, Schema as EffectSchema, SchemaIssue } from "effect"
+import type { DeepMutable } from "@opencode-ai/core/schema"
+import { InvalidError, JsonError } from "./error"
+
+export function jsonc(text: string, filepath: string): unknown {
+  const errors: JsoncParseError[] = []
+  const data = parseJsoncImpl(text, errors, { allowTrailingComma: true })
+  if (errors.length) {
+    const lines = text.split("\n")
+    const issues = errors
+      .map((e) => {
+        const beforeOffset = text.substring(0, e.offset).split("\n")
+        const line = beforeOffset.length
+        const column = beforeOffset[beforeOffset.length - 1].length + 1
+        const problemLine = lines[line - 1]
+
+        const error = `${printParseErrorCode(e.error)} at line ${line}, column ${column}`
+        if (!problemLine) return error
+
+        return `${error}\n   Line ${line}: ${problemLine}\n${"".padStart(column + 9)}^`
+      })
+      .join("\n")
+    throw new JsonError({
+      path: filepath,
+      message: `\n--- JSONC Input ---\n${text}\n--- Errors ---\n${issues}\n--- End ---`,
+    })
+  }
+
+  return data
+}
+
+export function schema<S extends EffectSchema.Decoder<unknown, never>>(
+  schema: S,
+  data: unknown,
+  source: string,
+): DeepMutable<S["Type"]> {
+  const extra = topLevelExtraKeys(schema, data)
+  if (extra.length) {
+    throw new InvalidError({
+      path: source,
+      issues: [
+        {
+          code: "unrecognized_keys",
+          keys: extra,
+          path: [],
+          message: `Unrecognized key${extra.length === 1 ? "" : "s"}: ${extra.join(", ")}`,
+        },
+      ],
+    })
+  }
+
+  const decoded = EffectSchema.decodeUnknownExit(schema)(data, { errors: "all", propertyOrder: "original" })
+  if (Exit.isSuccess(decoded)) return decoded.value as DeepMutable<S["Type"]>
+  const error = Cause.squash(decoded.cause)
+
+  throw new InvalidError(
+    {
+      path: source,
+      issues: EffectSchema.isSchemaError(error)
+        ? SchemaIssue.makeFormatterStandardSchemaV1()(error.issue).issues.map((issue) => ({
+            ...issue,
+            message: issue.message,
+            path: issue.path?.map(String) ?? [],
+          }))
+        : [{ message: String(error), path: [] }],
+    },
+    { cause: error },
+  )
+}
+
+function topLevelExtraKeys(schema: EffectSchema.Top, data: unknown) {
+  if (typeof data !== "object" || data === null || Array.isArray(data)) return []
+  if (schema.ast._tag !== "Objects" || schema.ast.indexSignatures.length > 0) return []
+  const known = new Set(schema.ast.propertySignatures.map((item) => String(item.name)))
+  return Object.keys(data).filter((key) => !known.has(key))
+}

package/src/engine/config/paths.ts

@@ -0,0 +1,45 @@
+export * as ConfigPaths from "./paths"
+
+import path from "path"
+import { Flag } from "@opencode-ai/core/flag/flag"
+import { Global } from "@opencode-ai/core/global"
+import { unique } from "remeda"
+import * as Effect from "effect/Effect"
+import { AppFileSystem } from "@opencode-ai/core/filesystem"
+
+export const files = Effect.fn("ConfigPaths.projectFiles")(function* (
+  name: string,
+  directory: string,
+  worktree?: string,
+) {
+  const afs = yield* AppFileSystem.Service
+  return (yield* afs.up({
+    targets: [`${name}.jsonc`, `${name}.json`],
+    start: directory,
+    stop: worktree,
+  })).toReversed()
+})
+
+export const directories = Effect.fn("ConfigPaths.directories")(function* (directory: string, worktree?: string) {
+  const afs = yield* AppFileSystem.Service
+  return unique([
+    Global.Path.config,
+    ...(!Flag.OPENCODE_DISABLE_PROJECT_CONFIG
+      ? yield* afs.up({
+          targets: [".opencode"],
+          start: directory,
+          stop: worktree,
+        })
+      : []),
+    ...(yield* afs.up({
+      targets: [".opencode"],
+      start: Global.Path.home,
+      stop: Global.Path.home,
+    })),
+    ...(Flag.OPENCODE_CONFIG_DIR ? [Flag.OPENCODE_CONFIG_DIR] : []),
+  ])
+})
+
+export function fileInDirectory(dir: string, name: string) {
+  return [path.join(dir, `${name}.json`), path.join(dir, `${name}.jsonc`)]
+}

package/src/engine/config/permission.ts

@@ -0,0 +1,58 @@
+export * as ConfigPermission from "./permission"
+import { Schema, SchemaGetter } from "effect"
+
+export const Action = Schema.Literals(["ask", "allow", "deny"]).annotate({ identifier: "PermissionActionConfig" })
+export type Action = Schema.Schema.Type<typeof Action>
+
+export const Object = Schema.Record(Schema.String, Action).annotate({ identifier: "PermissionObjectConfig" })
+export type Object = Schema.Schema.Type<typeof Object>
+
+export const Rule = Schema.Union([Action, Object]).annotate({ identifier: "PermissionRuleConfig" })
+export type Rule = Schema.Schema.Type<typeof Rule>
+
+// Known permission keys get explicit types in the Effect schema for generated
+// docs/types. Runtime config parsing uses Effect's `propertyOrder: "original"`
+// parse option so user key order is preserved for permission precedence.
+const InputObject = Schema.StructWithRest(
+  Schema.Struct({
+    read: Schema.optional(Rule),
+    edit: Schema.optional(Rule),
+    glob: Schema.optional(Rule),
+    grep: Schema.optional(Rule),
+    list: Schema.optional(Rule),
+    bash: Schema.optional(Rule),
+    task: Schema.optional(Rule),
+    external_directory: Schema.optional(Rule),
+    todowrite: Schema.optional(Action),
+    question: Schema.optional(Action),
+    webfetch: Schema.optional(Action),
+    websearch: Schema.optional(Action),
+    repo_clone: Schema.optional(Rule),
+    repo_overview: Schema.optional(Rule),
+    lsp: Schema.optional(Rule),
+    doom_loop: Schema.optional(Action),
+    skill: Schema.optional(Rule),
+  }),
+  [Schema.Record(Schema.String, Rule)],
+)
+
+// Input the user writes in config: either a single Action (shorthand for "*")
+// or an object of per-target rules.
+const InputSchema = Schema.Union([Action, InputObject])
+
+// Normalise the Action shorthand into `{ "*": action }`. Object inputs pass
+// through untouched.
+const normalizeInput = (input: Schema.Schema.Type<typeof InputSchema>): Schema.Schema.Type<typeof InputObject> =>
+  typeof input === "string" ? { "*": input } : input
+
+export const Info = InputSchema.pipe(
+  Schema.decodeTo(InputObject, {
+    decode: SchemaGetter.transform(normalizeInput),
+    // Not perfectly invertible (we lose whether the user originally typed an
+    // Action shorthand), but the object form is always a valid representation
+    // of the same rules.
+    encode: SchemaGetter.passthrough({ strict: false }),
+  }),
+).annotate({ identifier: "PermissionConfig" })
+type _Info = Schema.Schema.Type<typeof InputObject>
+export type Info = { -readonly [K in keyof _Info]: _Info[K] }

package/src/engine/config/plugin.ts

@@ -0,0 +1,84 @@
+import { Glob } from "@opencode-ai/core/util/glob"
+import { Schema } from "effect"
+import { pathToFileURL } from "url"
+import { isPathPluginSpec, parsePluginSpecifier, resolvePathPluginTarget } from "@/plugin/shared"
+import path from "path"
+
+export const Options = Schema.Record(Schema.String, Schema.Unknown)
+export type Options = Schema.Schema.Type<typeof Options>
+
+// Spec is the user-config value: either just a plugin identifier, or the identifier plus inline options.
+// It answers "what should we load?" but says nothing about where that value came from.
+export const Spec = Schema.Union([Schema.String, Schema.mutable(Schema.Tuple([Schema.String, Options]))])
+export type Spec = Schema.Schema.Type<typeof Spec>
+
+export type Scope = "global" | "local"
+
+// Origin keeps the original config provenance attached to a spec.
+// After multiple config files are merged, callers still need to know which file declared the plugin
+// and whether it should behave like a global or project-local plugin.
+export type Origin = {
+  spec: Spec
+  source: string
+  scope: Scope
+}
+
+export async function load(dir: string) {
+  const plugins: Spec[] = []
+
+  for (const item of await Glob.scan("{plugin,plugins}/*.{ts,js}", {
+    cwd: dir,
+    absolute: true,
+    dot: true,
+    symlink: true,
+  })) {
+    plugins.push(pathToFileURL(item).href)
+  }
+  return plugins
+}
+
+export function pluginSpecifier(plugin: Spec): string {
+  return Array.isArray(plugin) ? plugin[0] : plugin
+}
+
+export function pluginOptions(plugin: Spec): Options | undefined {
+  return Array.isArray(plugin) ? plugin[1] : undefined
+}
+
+// Path-like specs are resolved relative to the config file that declared them so merges later on do not
+// accidentally reinterpret `./plugin.ts` relative to some other directory.
+export async function resolvePluginSpec(plugin: Spec, configFilepath: string): Promise<Spec> {
+  const spec = pluginSpecifier(plugin)
+  if (!isPathPluginSpec(spec)) return plugin
+
+  const base = path.dirname(configFilepath)
+  const file = (() => {
+    if (spec.startsWith("file://")) return spec
+    if (path.isAbsolute(spec) || /^[A-Za-z]:[\\/]/.test(spec)) return pathToFileURL(spec).href
+    return pathToFileURL(path.resolve(base, spec)).href
+  })()
+
+  const resolved = await resolvePathPluginTarget(file).catch(() => file)
+
+  if (Array.isArray(plugin)) return [resolved, plugin[1]]
+  return resolved
+}
+
+// Dedupe on the load identity (package name for npm specs, exact file URL for local specs), but keep the
+// full Origin so downstream code still knows which config file won and where follow-up writes should go.
+export function deduplicatePluginOrigins(plugins: Origin[]): Origin[] {
+  const seen = new Set<string>()
+  const list: Origin[] = []
+
+  for (const plugin of plugins.toReversed()) {
+    const spec = pluginSpecifier(plugin.spec)
+    const name = spec.startsWith("file://") ? spec : parsePluginSpecifier(spec).pkg
+    if (seen.has(name)) continue
+    seen.add(name)
+    list.push(plugin)
+  }
+
+  return list.toReversed()
+}
+
+export * as ConfigPlugin from "./plugin"