@100xprompt/brain 0.1.0 → 0.1.2

package/src/gateway/connectors/continue.ts

@@ -0,0 +1,579 @@
+// Gateway connector for Continue (continuedev/continue): its VS Code and JetBrains extensions and its `cn` CLI, which share
+// one settings folder. Checked against the `cn` CLI 1.5.47 (~/.cache/brain-wire/continue, @continuedev/cli, its src/ is
+// shipped in the package) and the VS Code extension 2.0.0 (continue.continue-2.0.0-darwin-arm64, out/extension.js).
+//
+// Where Continue reads its settings:
+//   <dir> = $CONTINUE_GLOBAL_DIR, else ~/.continue                 cli src/env.ts:10-11; extension getContinueGlobalPath
+//   <dir>/config.yaml   the CLI's local config: used whenever it exists, else the CLI loads Continue's hosted default
+//                       config (cli src/configLoader.ts:94-99). The extension uses it too, and creates it with
+//                       `name: Main Config / version: 1.0.0 / schema: v1 / models: []` when neither file exists
+//                       (extension.js getConfigYamlPath ~56261, defaultConfig ~54871).
+//   <dir>/config.json   the older format. The extension still loads it when there is no config.yaml (extension.js
+//                       ~799466-799496: config.yaml if it exists, else loadContinueConfigFromJson); the CLI ignores it.
+// A model is an entry of the `models:` list (config-yaml schema, extension.js ~222352): name, provider, model, apiBase,
+// apiKey, roles, capabilities, defaultCompletionOptions.contextLength, requestOptions.headers (~222227: a string record,
+// sent with every request). provider `openai` speaks Chat Completions at <apiBase>/chat/completions.
+//
+// The key. Continue cannot read a key from a file or a command: apiKey is a string, and `${{ secrets.NAME }}` in it is
+// filled at load time from, in order, <dir>/.env, <workspace>/.continue/.env, <workspace>/.env and the process
+// environment (extension: LocalPlatformClient ~798790-798870, getContinueDotEnv ~56467; CLI: src/CLIPlatformClient.ts:57-87,
+// process environment first; template filling: fillTemplateVariables/renderTemplateData ~223583-223700). config.json does
+// the same with its top-level `"env": ["NAME"]` list, which replaces every "NAME" string in the file with the value from
+// <dir>/.env or the environment (extension.js resolveSerializedConfig ~797703). So brain copies the key to <dir>/.env as
+// BRAIN_GATEWAY_KEY (that file is made 0600, and refreshed on a new sign-in), and the config only names it: config.yaml
+// stays free of the key, as Continue's docs recommend for secrets.
+//
+// What is written:
+//   <dir>/.env          BRAIN_GATEWAY_KEY=<key>
+//   config.yaml         one entry first in `models:`, found again by its apiKey naming BRAIN_GATEWAY_KEY:
+//                         name: 100xprompt Pro, provider: openai, model: <gateway id>, apiBase: <route>/v1,
+//                         apiKey: ${{ secrets.BRAIN_GATEWAY_KEY }}, roles chat/edit/apply/summarize,
+//                         capabilities tool_use and image_input (Continue only guesses tool support for provider openai from
+//                         gpt-/o- model names, toolSupport.ts ~277661, so without it Agent mode would be off),
+//                         contextLength 1048576 (an unknown model gets 32768, ~238017), and the context-edit header.
+//                       First in the list makes it the default: the extension and the CLI take the first chat model unless
+//                       one was picked before (extension rectifySelectedModelsFromGlobalContext ~798703; CLI
+//                       services/ModelService.ts:53-120 and util/modelPersistence.ts, `cliSelectedModel`).
+//                       A config.yaml brain creates also gets name/version/schema, which Continue requires; they are
+//                       removed again only when nothing else is left in it.
+//   config.json         (only when it is the file Continue uses) the same entry with `title`, its apiKey "BRAIN_GATEWAY_KEY",
+//                       and "BRAIN_GATEWAY_KEY" added to the top-level "env" list.
+// The two codecs below edit only that list entry (and the env list item) in place, as text: comments and every other byte
+// stay, and removing the entry gives back the exact bytes, including an empty `models: []` or a list that was not there.
+import { existsSync, readFileSync } from "node:fs"
+import { isAbsolute, join, resolve } from "node:path"
+import { type Codec, type Connector, EDIT_HEADER, type Env, type GatewaySettings, type Json, modelName, readKey, routeUrl, yamlTopLevel } from "../common.ts"
+
+/** The name the key is kept under in the tool's .env, and that its config refers to. */
+export const SECRET = "BRAIN_GATEWAY_KEY"
+/** The `name` of a config.yaml that brain created (Continue requires one). */
+const OWN_CONFIG = "100xprompt gateway"
+/** The codec key of brain's entry in the models list (the entry itself is found by its apiKey, so a model switch keeps it). */
+export const ENTRY_KEY = "models/100xprompt gateway"
+/** Gemini models' context window; Continue assumes 32768 for a model it does not know. */
+const CONTEXT = 1048576
+
+const same = (a: unknown, b: unknown) => JSON.stringify(a) === JSON.stringify(b)
+const isPlainObject = (v: unknown): v is Json => !!v && typeof v === "object" && !Array.isArray(v)
+
+/**
+ * The list keys a codec understands: `<list>/<label>` is the one item of top-level list <list> for which `match` holds.
+ * get returns that item; when there is none, undefined if the list is there and null if it is not (so that removing the
+ * item later, with that value, also removes a list brain added). The YAML codec also returns [] for an empty `models: []`.
+ */
+export interface ListKey {
+  list: string
+  match(item: unknown): boolean
+  /** JSON only: write the list on one line (a list of short strings). */
+  inline?: boolean
+}
+
+// ---- YAML: block lists ------------------------------------------------------------------------------------------------
+
+const YAML11_WORDS = /^(y|yes|n|no|on|off|true|false|null|~)$/i
+const esc = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+
+/** A string as YAML reads it back unchanged: plain when that is safe, else JSON (valid YAML). */
+function yScalar(v: unknown, flow = false): string {
+  if (typeof v === "string") {
+    if (/^[A-Za-z0-9_./@-][A-Za-z0-9_./:@+=-]*$/.test(v) && !YAML11_WORDS.test(v) && !(flow && /[,[\]{}]/.test(v))) {
+      try {
+        if ((Bun.YAML.parse(`k: ${v}`) as Json).k === v) return v
+      } catch {}
+    }
+    return JSON.stringify(v)
+  }
+  if (typeof v === "number" || typeof v === "boolean") return String(v)
+  return JSON.stringify(v ?? null)
+}
+const yKey = (k: string) => (/^[A-Za-z_][A-Za-z0-9_.-]*$/.test(k) && !YAML11_WORDS.test(k) ? k : JSON.stringify(k))
+
+/** An object as block-style YAML lines at `indent` (lists on one line, objects nested). */
+function yBlock(o: Json, indent: string): string[] {
+  const out: string[] = []
+  for (const [k, v] of Object.entries(o)) {
+    if (v === undefined) continue
+    if (Array.isArray(v)) out.push(`${indent}${yKey(k)}: [${v.map((x) => yScalar(x, true)).join(", ")}]`)
+    else if (isPlainObject(v)) {
+      if (!Object.keys(v).length) out.push(`${indent}${yKey(k)}: {}`)
+      else out.push(`${indent}${yKey(k)}:`, ...yBlock(v, `${indent}  `))
+    } else out.push(`${indent}${yKey(k)}: ${yScalar(v)}`)
+  }
+  return out
+}
+/** A list item: `<indent>- first: ...` and the rest under it. */
+function yItem(o: Json, indent: string): string[] {
+  const lines = yBlock(o, `${indent}  `)
+  if (!lines.length) return [`${indent}- {}`]
+  lines[0] = `${indent}- ${lines[0]!.slice(indent.length + 2)}`
+  return lines
+}
+
+/** Where the ` # comment` at the end of a `key: value` line starts (with the spaces before it, outside quotes), or -1. */
+function yCommentAt(line: string): number {
+  let quote: string | undefined
+  for (let i = line.indexOf(":") + 1; i > 0 && i < line.length; i++) {
+    const c = line[i]!
+    if (quote) {
+      if (c === "\\" && quote === '"') i++
+      else if (c === quote) quote = undefined
+    } else if (c === '"' || c === "'") quote = c
+    else if (c === "#" && /[ \t]/.test(line[i - 1]!)) {
+      let j = i
+      while (j > 0 && /[ \t]/.test(line[j - 1]!)) j--
+      return j
+    }
+  }
+  return -1
+}
+
+interface YList {
+  /** The line of `<list>:`, or -1. */
+  at: number
+  /** The key as written (`models`, `"models"`). */
+  key: string
+  /** block: items (or nothing) below the key; empty: `models: []`; other: anything else on the key line. */
+  form: "block" | "empty" | "other"
+  comment: string
+  /** Each item's lines [start, end): from its `-` line to its last content line (trailing blank and comment lines excluded). */
+  items: Array<{ start: number; end: number; indent: string }>
+}
+
+const content = (l: string) => l.trim() !== "" && !/^\s*#/.test(l)
+
+function yLocate(lines: string[], list: string): YList {
+  const head = new RegExp(`^(?:${esc(list)}|"${esc(list)}"|'${esc(list)}')[ \\t]*:(?=[ \\t]|$)`)
+  const at = lines.findIndex((l) => head.test(l))
+  if (at < 0) return { at, key: list, form: "block", comment: "", items: [] }
+  const line = lines[at]!
+  const colon = line.indexOf(":", line.startsWith('"') || line.startsWith("'") ? list.length + 2 : 0)
+  const key = line.slice(0, colon).trimEnd()
+  const j = yCommentAt(line)
+  const comment = j < 0 ? "" : line.slice(j).trimEnd()
+  const value = line.slice(colon + 1, j < 0 ? undefined : j).trim()
+  if (value === "[]") return { at, key, form: "empty", comment, items: [] }
+  if (value !== "") return { at, key, form: "other", comment, items: [] }
+  // The block: indented lines, `-` lines (a list may sit at the key's own indentation), blank lines and comments.
+  let end = at + 1
+  while (end < lines.length && (/^[ \t]/.test(lines[end]!) || lines[end]!.trim() === "" || /^-(\s|$)/.test(lines[end]!) || /^#/.test(lines[end]!))) end++
+  while (end > at + 1 && !content(lines[end - 1]!)) end--
+  const first = lines.slice(at + 1, end).find(content)
+  const m = first === undefined ? null : /^([ \t]*)-(?:[ \t]|$)/.exec(first)
+  if (first !== undefined && !m) return { at, key, form: "other", comment, items: [] }
+  const indent = m?.[1] ?? "  "
+  const starts: number[] = []
+  for (let i = at + 1; i < end; i++) if (new RegExp(`^${esc(indent)}-(?:[ \\t]|$)`).test(lines[i]!)) starts.push(i)
+  const items = starts.map((s, k) => {
+    let e = k + 1 < starts.length ? starts[k + 1]! : end
+    while (e > s + 1 && !content(lines[e - 1]!)) e--
+    return { start: s, end: e, indent }
+  })
+  return { at, key, form: "block", comment, items }
+}
+
+const yParse = (text: string): Json | null => {
+  if (!text.trim()) return null
+  const v = Bun.YAML.parse(text)
+  return isPlainObject(v) ? v : null
+}
+
+/**
+ * Continue's config.yaml: `<list>/<label>` keys (see ListKey) edit one item of a block list, every other key is a top-level
+ * key (yamlTopLevel). Items are added first in the list, at its indentation; nothing else in the file changes.
+ */
+export function yamlListCodec(keys: Record<string, ListKey>): Codec {
+  return {
+    check(text) {
+      const base = yamlTopLevel.check!(text)
+      if (base) return base
+      const doc = yParse(text)
+      if (!doc) return undefined
+      const lines = text.replace(/\n$/, "").split("\n")
+      for (const list of new Set(Object.values(keys).map((k) => k.list))) {
+        if (!(list in doc)) continue
+        const v = doc[list]
+        if (v !== null && !Array.isArray(v)) return `its ${list} is not a list; left as it is`
+        const loc = yLocate(lines, list)
+        if (loc.at < 0 || loc.form === "other") return `its ${list} list is written in a form brain does not edit (only a block list of "- " entries, or []); left as it is`
+        if (loc.form === "block" && loc.items.length !== (v?.length ?? 0)) return `its ${list} list is laid out in a way brain does not edit; left as it is`
+      }
+      return undefined
+    },
+    get(text, key) {
+      const k = keys[key]
+      if (!k) return yamlTopLevel.get(text, key)
+      const doc = yParse(text)
+      if (!doc || !(k.list in doc)) return null
+      const v = doc[k.list]
+      if (!Array.isArray(v)) return undefined
+      const found = v.find((x) => k.match(x))
+      return found !== undefined ? found : v.length ? undefined : []
+    },
+    set(text, key, value) {
+      const k = keys[key]
+      if (!k) return same(yamlTopLevel.get(text, key), value) ? text : yamlTopLevel.set(text, key, value)
+      const lines = text ? text.replace(/\n$/, "").split("\n") : []
+      const doc = yParse(text)
+      const v = doc?.[k.list]
+      const idx = Array.isArray(v) ? v.findIndex((x) => k.match(x)) : -1
+      const loc = yLocate(lines, k.list)
+      if (isPlainObject(value)) {
+        if (idx >= 0) {
+          const it = loc.items[idx]!
+          lines.splice(it.start, it.end - it.start, ...yItem(value, it.indent))
+        } else if (loc.at < 0) lines.push(`${k.list}:`, ...yItem(value, "  "))
+        else if (loc.form === "empty") lines.splice(loc.at, 1, `${loc.key}:${loc.comment}`, ...yItem(value, "  "))
+        else if (loc.items.length) lines.splice(loc.items[0]!.start, 0, ...yItem(value, loc.items[0]!.indent))
+        else lines.splice(loc.at + 1, 0, ...yItem(value, "  "))
+      } else {
+        // undefined: the item goes, the list stays; [] the list goes back to `[]`; null: a list left empty goes too.
+        if (idx >= 0) {
+          const it = loc.items[idx]!
+          lines.splice(it.start, it.end - it.start)
+        }
+        const after = yLocate(lines, k.list)
+        if (after.at >= 0 && after.form === "block" && !after.items.length) {
+          if (value === null) lines.splice(after.at, 1)
+          else if (Array.isArray(value) && !value.length) lines[after.at] = `${after.key}: []${after.comment}`
+        }
+      }
+      return lines.length ? `${lines.join("\n")}\n` : ""
+    },
+  }
+}
+
+// ---- JSON with comments: lists edited as text ---------------------------------------------------------------------------
+
+type JNode =
+  | { kind: "obj"; start: number; end: number; members: Array<{ key: string; start: number; value: JNode; comma: number }> }
+  | { kind: "arr"; start: number; end: number; elems: Array<{ value: JNode; comma: number }> }
+  | { kind: "lit"; start: number; end: number; value: unknown }
+
+/** JSON with // and /* comments and trailing commas, with the position of every value (start, end exclusive) and comma. */
+export function jsoncTree(text: string): JNode {
+  let i = 0
+  const fail = (): never => {
+    throw new Error(`not JSON (at character ${i})`)
+  }
+  const ws = () => {
+    for (;;) {
+      while (i < text.length && /\s/.test(text[i]!)) i++
+      if (text.startsWith("//", i)) {
+        const n = text.indexOf("\n", i)
+        i = n < 0 ? text.length : n + 1
+      } else if (text.startsWith("/*", i)) {
+        const n = text.indexOf("*/", i + 2)
+        if (n < 0) fail()
+        i = n + 2
+      } else return
+    }
+  }
+  const str = (): string => {
+    const s = i++
+    while (i < text.length && text[i] !== '"') {
+      if (text[i] === "\\") i++
+      else if (text[i] === "\n") fail()
+      i++
+    }
+    if (i >= text.length) fail()
+    i++
+    return JSON.parse(text.slice(s, i))
+  }
+  const val = (): JNode => {
+    ws()
+    const s = i
+    const c = text[i]
+    if (c === "{") {
+      i++
+      const members: Array<{ key: string; start: number; value: JNode; comma: number }> = []
+      for (;;) {
+        ws()
+        if (text[i] === "}") break
+        if (text[i] !== '"') fail()
+        const ks = i
+        const key = str()
+        ws()
+        if (text[i] !== ":") fail()
+        i++
+        const value = val()
+        ws()
+        if (text[i] === ",") {
+          members.push({ key, start: ks, value, comma: i++ })
+          continue
+        }
+        members.push({ key, start: ks, value, comma: -1 })
+        if (text[i] !== "}") fail()
+        break
+      }
+      i++
+      return { kind: "obj", start: s, end: i, members }
+    }
+    if (c === "[") {
+      i++
+      const elems: Array<{ value: JNode; comma: number }> = []
+      for (;;) {
+        ws()
+        if (text[i] === "]") break
+        const value = val()
+        ws()
+        if (text[i] === ",") {
+          elems.push({ value, comma: i++ })
+          continue
+        }
+        elems.push({ value, comma: -1 })
+        if (text[i] !== "]") fail()
+        break
+      }
+      i++
+      return { kind: "arr", start: s, end: i, elems }
+    }
+    if (c === '"') {
+      const value = str()
+      return { kind: "lit", start: s, end: i, value }
+    }
+    const re = /-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?|true|false|null/y
+    re.lastIndex = i
+    const m = re.exec(text)
+    if (!m) fail()
+    i += m![0].length
+    return { kind: "lit", start: s, end: i, value: JSON.parse(m![0]) }
+  }
+  const root = val()
+  ws()
+  if (i !== text.length) fail()
+  return root
+}
+
+export function jsonValue(n: JNode): unknown {
+  if (n.kind === "lit") return n.value
+  if (n.kind === "arr") return n.elems.map((e) => jsonValue(e.value))
+  return Object.fromEntries(n.members.map((m) => [m.key, jsonValue(m.value)]))
+}
+
+type JList = Extract<JNode, { kind: "obj" | "arr" }>
+const spans = (n: JList) =>
+  n.kind === "arr" ? n.elems.map((e) => ({ start: e.value.start, end: e.value.end, comma: e.comma })) : n.members.map((m) => ({ start: m.start, end: m.value.end, comma: m.comma }))
+const lineIndent = (text: string, pos: number) => /^[ \t]*/.exec(text.slice(text.lastIndexOf("\n", pos - 1) + 1))![0]
+
+/** `item(indent)` added as the first item of an array or object; removing it again (jRemove) gives back the same bytes. */
+function jInsertFront(text: string, n: JList, item: (indent: string) => string, unit: string, inline = false): string {
+  const items = spans(n)
+  const open = n.start
+  const close = n.end - 1
+  const base = lineIndent(text, open)
+  if (!items.length) {
+    if (/^\s*$/.test(text.slice(open + 1, close))) {
+      if (inline) return text.slice(0, open + 1) + item("") + text.slice(close)
+      return `${text.slice(0, open + 1)}\n${base}${unit}${item(base + unit)}\n${base}${text.slice(close)}`
+    }
+    // Only comments inside: the item goes right after the bracket, before them.
+    return `${text.slice(0, open + 1)}\n${base}${unit}${item(base + unit)}${text.slice(open + 1)}`
+  }
+  const first = items[0]!.start
+  const multi = text.slice(open + 1, first).includes("\n")
+  const ind = multi ? lineIndent(text, first) : base + unit
+  return `${text.slice(0, first)}${item(ind)},${multi ? `\n${ind}` : " "}${text.slice(first)}`
+}
+
+/** The text without item `idx` of an array or object (and the separator that went with it). */
+function jRemove(text: string, n: JList, idx: number): string {
+  const items = spans(n)
+  const it = items[idx]!
+  const open = n.start
+  const close = n.end - 1
+  if (items.length === 1) {
+    if (/^\s*$/.test(text.slice(open + 1, it.start)) && /^\s*,?\s*$/.test(text.slice(it.end, close))) return text.slice(0, open + 1) + text.slice(close)
+    return text.slice(0, open + 1) + text.slice(it.end)
+  }
+  if (idx === 0) return text.slice(0, it.start) + text.slice(items[1]!.start)
+  return text.slice(0, items[idx - 1]!.comma) + text.slice(it.end)
+}
+
+const jUnit = (text: string) => /\n([ \t]+)\S/.exec(text)?.[1] ?? "  "
+const lastMember = (root: Extract<JNode, { kind: "obj" }>, key: string) => {
+  for (let i = root.members.length - 1; i >= 0; i--) if (root.members[i]!.key === key) return i
+  return -1
+}
+
+/**
+ * A JSON config that may hold comments (Continue's config.json, PearAI's), edited as text: `<list>/<label>` keys (see
+ * ListKey) add, replace or remove one item of a top-level list. Comments and formatting everywhere else stay.
+ */
+export function jsonListCodec(keys: Record<string, ListKey>): Codec {
+  const root = (text: string) => {
+    const t = jsoncTree(text.trim() ? text : "{}")
+    if (t.kind !== "obj") throw new Error("not a JSON object")
+    return t
+  }
+  return {
+    check(text) {
+      let r: Extract<JNode, { kind: "obj" }>
+      try {
+        r = root(text)
+      } catch {
+        return "it is not a JSON object (with or without comments); left as it is"
+      }
+      for (const list of new Set(Object.values(keys).map((k) => k.list))) {
+        const i = lastMember(r, list)
+        if (i >= 0 && r.members[i]!.value.kind !== "arr") return `its "${list}" is not a list; left as it is`
+      }
+      return undefined
+    },
+    get(text, key) {
+      const k = keys[key]
+      if (!k) return undefined
+      const o = jsonValue(root(text)) as Json
+      if (!(k.list in o)) return null
+      const v = o[k.list]
+      if (!Array.isArray(v)) return undefined
+      const found = v.find((x) => k.match(x))
+      return found !== undefined ? found : undefined
+    },
+    set(text, key, value) {
+      const k = keys[key]
+      if (!k) return text
+      const base = text.trim() ? text : "{}\n"
+      const r = root(base)
+      const unit = jUnit(base)
+      const mi = lastMember(r, k.list)
+      const arr = mi >= 0 && r.members[mi]!.value.kind === "arr" ? (r.members[mi]!.value as Extract<JNode, { kind: "arr" }>) : undefined
+      const ei = arr ? arr.elems.findIndex((e) => k.match(jsonValue(e.value))) : -1
+      const render = (ind: string) => JSON.stringify(value, null, unit).replace(/\n/g, `\n${ind}`)
+      if (value === undefined || value === null) {
+        // undefined: the item goes, the list stays; null (there was no list): a list left empty goes too.
+        if (!arr) return text
+        let t = ei >= 0 ? jRemove(base, arr, ei) : base
+        if (value === null) {
+          const r2 = root(t)
+          const m2 = lastMember(r2, k.list)
+          const a2 = m2 >= 0 ? r2.members[m2]!.value : undefined
+          if (a2?.kind === "arr" && !a2.elems.length && /^\s*$/.test(t.slice(a2.start + 1, a2.end - 1))) t = jRemove(t, r2, m2)
+        }
+        return t
+      }
+      if (mi < 0) {
+        const list = (ind: string) => `${JSON.stringify(k.list)}: ${k.inline ? `[${render("")}]` : `[\n${ind}${unit}${render(ind + unit)}\n${ind}]`}`
+        return jInsertFront(base, r, list, unit)
+      }
+      if (!arr) return text
+      if (ei >= 0) {
+        const el = arr.elems[ei]!.value
+        return base.slice(0, el.start) + render(lineIndent(base, el.start)) + base.slice(el.end)
+      }
+      return jInsertFront(base, arr, render, unit, k.inline)
+    },
+  }
+}
+
+// ---- the connector ------------------------------------------------------------------------------------------------------
+
+/** Continue's settings folder; $CONTINUE_GLOBAL_DIR describes the person's real home, so it counts only there. */
+export function continueDir(home: string, env: Env): string {
+  const own = !!env.HOME && resolve(env.HOME) === resolve(home)
+  const d = env.CONTINUE_GLOBAL_DIR
+  return own && d && isAbsolute(d) && existsSync(d) ? d : join(home, ".continue")
+}
+
+/** The config Continue loads: config.yaml, or the older config.json when that is the only one. */
+export function continueConfig(dir: string): { path: string; kind: "yaml" | "json" } {
+  const yaml = join(dir, "config.yaml")
+  const json = join(dir, "config.json")
+  return !existsSync(yaml) && existsSync(json) ? { path: json, kind: "json" } : { path: yaml, kind: "yaml" }
+}
+
+const mentionsSecret = (x: unknown) => isPlainObject(x) && typeof x.apiKey === "string" && x.apiKey.includes(SECRET)
+const yamlList = yamlListCodec({ [ENTRY_KEY]: { list: "models", match: mentionsSecret } })
+/**
+ * The codec key for the name/version/schema a config.yaml needs (Continue refuses one without them), set only in a
+ * config.yaml brain creates. Written at the top; removed only when nothing else is left in the file, so a model the person
+ * added to that file meanwhile keeps a config Continue can load.
+ */
+export const HEADER_KEY = "name+version+schema"
+const HEADER = ["name", "version", "schema"]
+const headerOf = (text: string) => {
+  const doc = yParse(text)
+  const present = doc ? HEADER.filter((f) => f in doc) : []
+  return present.length ? Object.fromEntries(present.map((f) => [f, doc![f]])) : undefined
+}
+const withoutHeader = (text: string) => HEADER.reduce((t, f) => yamlTopLevel.set(t, f, undefined), text)
+/** Continue's config.yaml: brain's models entry (found by its apiKey) and, in a config brain created, the header. */
+export const yamlCodec: Codec = {
+  check: yamlList.check!,
+  get: (text, key) => (key === HEADER_KEY ? headerOf(text) : yamlList.get(text, key)),
+  set(text, key, value) {
+    if (key !== HEADER_KEY) return yamlList.set(text, key, value)
+    if (isPlainObject(value)) {
+      if (same(headerOf(text), value)) return text
+      const rest = withoutHeader(text)
+      return `${[...Object.entries(value).map(([k, v]) => `${k}: ${yScalar(v)}`), ...(rest ? [rest.replace(/\n$/, "")] : [])].join("\n")}\n`
+    }
+    const doc = yParse(text)
+    return doc && Object.keys(doc).every((k) => HEADER.includes(k)) ? withoutHeader(text) : text
+  },
+}
+/** Continue's and PearAI's config.json: the entry (its apiKey is the env name) and the env list item. */
+export const jsonCodec = jsonListCodec({
+  [ENTRY_KEY]: { list: "models", match: (x) => isPlainObject(x) && x.apiKey === SECRET },
+  [`env/${SECRET}`]: { list: "env", match: (x) => x === SECRET, inline: true },
+})
+
+const headers = (s: GatewaySettings) => (s.contextEdit ? { requestOptions: { headers: { [EDIT_HEADER]: "on" } } } : {})
+
+/** The models entry in config.json form (older Continue, PearAI): `title`, the key by env name. */
+export function jsonEntry(s: GatewaySettings, extra: Json = {}): Json {
+  return { title: modelName(s.model), provider: "openai", model: s.model, apiBase: `${routeUrl(s)}/v1`, apiKey: SECRET, contextLength: CONTEXT, ...extra, ...headers(s) }
+}
+
+/** The .env edit both Continue and PearAI read their secret from. */
+export const envEdit = (dir: string, home: string) => ({ path: join(dir, ".env"), format: "dotenv" as const, holdsKey: true, secretKeys: [SECRET], values: { [SECRET]: readKey(home) } })
+
+/** Whether config.yaml is missing, empty, or one brain created (it then needs, and keeps, name/version/schema). */
+function ownYaml(path: string): boolean {
+  try {
+    const text = readFileSync(path, "utf8")
+    return !text.trim() || yParse(text)?.name === OWN_CONFIG
+  } catch {
+    return true
+  }
+}
+
+export const connectors: Connector[] = [
+  {
+    id: "continue",
+    label: "Continue",
+    file: (home, env) => continueConfig(continueDir(home, env)).path,
+    probe: [".continue"],
+    authHeader: "authorization",
+    edits: (home, s, env) => {
+      const dir = continueDir(home, env)
+      const cfg = continueConfig(dir)
+      if (cfg.kind === "json")
+        return [envEdit(dir, home), { path: cfg.path, format: "custom", codec: jsonCodec, values: { [ENTRY_KEY]: jsonEntry(s, { capabilities: { tools: true, uploadImage: true } }), [`env/${SECRET}`]: SECRET } }]
+      const entry = {
+        name: modelName(s.model),
+        provider: "openai",
+        model: s.model,
+        apiBase: `${routeUrl(s)}/v1`,
+        apiKey: `\${{ secrets.${SECRET} }}`,
+        roles: ["chat", "edit", "apply", "summarize"],
+        capabilities: ["tool_use", "image_input"],
+        defaultCompletionOptions: { contextLength: CONTEXT },
+        ...headers(s),
+      }
+      return [
+        envEdit(dir, home),
+        {
+          path: cfg.path,
+          format: "custom",
+          codec: yamlCodec,
+          values: { [ENTRY_KEY]: entry, ...(ownYaml(cfg.path) ? { [HEADER_KEY]: { name: OWN_CONFIG, version: "1.0.0", schema: "v1" } } : {}) },
+        },
+      ]
+    },
+    notes: [
+      "Continue (its extensions and the cn CLI) now lists the gateway's model first in its config; it is the default unless you picked another model in Continue before: then pick it once in Continue's model menu.",
+      `Continue cannot read a key from another file, so the key is kept in ~/.continue/.env as ${SECRET} (readable by you only), and the config refers to it.`,
+      "With only the older config.json (no config.yaml) the extensions use the gateway; the cn CLI reads config.yaml only.",
+    ],
+  },
+]