@100xprompt/brain 0.1.0 → 0.1.2

package/src/gateway/connectors/aider.ts

@@ -0,0 +1,356 @@
+// Gateway connector for Aider (aider-chat; checked against aider 0.86.2 with litellm 1.81.10, the copy in
+// ~/.cache/brain-wire/aider/venv).
+//
+// How Aider is pointed at the gateway: a model entry of its own, made Aider's default, without touching the person's
+// OpenAI settings (openai-api-base / openai-api-key / OPENAI_API_KEY keep serving their own OpenAI models).
+//   ~/.aider.model.settings.yml   an entry `name: openai/<model>` (marked with a comment as brain's) whose extra_params
+//       carry api_base <route>/v1, api_key and extra_headers { x-100x-context-edit: on }. Aider passes extra_params
+//       straight to litellm.completion, so the gateway is called as OpenAI Chat Completions (<route>/v1/chat/completions,
+//       Authorization: Bearer <key>). The entry also gives Aider the edit settings it uses for Gemini Flash.
+//   ~/.aider.model.metadata.json   the same model's context window (else Aider assumes an unknown model: a 1k-token chat
+//       history budget, a small repo map and a warning on every start). JSON5, read by Aider with json5.loads.
+//   ~/.aider.conf.yml   `model: openai/<model>` (the default model) and `show-model-warnings: false` (Aider would warn
+//       at every start that OPENAI_API_KEY is not set, which the gateway model does not use). Both put back on disconnect.
+// The key is copied (holdsKey, 0600): Aider has no key-file or key-command option. Its conf file (configargparse YAML)
+// and settings file (yaml.safe_load) do no interpolation, and its .env files (python-dotenv) only expand ${VAR}. litellm
+// can read a key file (api_key "os.environ/oidc/file/<path>", litellm/secret_managers/main.py get_secret), but it does
+// not strip the trailing newline the brain's key file ends with, and the request then fails (tried: "Connection error").
+//
+// Evidence (site-packages of the copy above):
+//   aider/main.py:464-497   config files: ./.aider.conf.yml, <git root>/.aider.conf.yml, ~/.aider.conf.yml (the nearest wins).
+//   aider/main.py:305-358   .aider.model.settings.yml searched in ~, the git root and the cwd (register_models).
+//   aider/main.py:390-412   .aider.model.metadata.json likewise (register_litellm_models); aider/models.py:1097-1118 json5.
+//   aider/main.py:500-504   .env files (~/.env, git root, cwd) are loaded, then the arguments parsed again (AIDER_* win).
+//   aider/models.py:1070-1094   each settings entry replaces any earlier entry of the same name (later files/entries win).
+//   aider/models.py:116-138   ModelSettings fields (extra_params among them); unknown fields are an error.
+//   aider/models.py:970-1022   send_completion(): kwargs.update(self.extra_params) (996), then litellm.completion(**kwargs) (1021).
+//   aider/models.py:697-765, 1149-1185   the start-up check that warns when OPENAI_API_KEY is missing for openai/ models.
+//   aider/main.py:890-902   that check runs only with --show-model-warnings (the default).
+//   Docs: https://aider.chat/docs/config/adv-model-settings.html (extra_params, extra_headers, metadata file),
+//         https://aider.chat/docs/llms/openai-compat.html (openai/<model> against an OpenAI-compatible API).
+import { join } from "node:path"
+import { type Codec, type Connector, EDIT_HEADER, type Json, readKey, routeUrl, yamlTopLevel } from "../common.ts"
+
+/** The one key of brain's own entry in the settings list and in the metadata object. */
+export const AIDER_ENTRY = "brain-gateway"
+/** Marks brain's entry in each file (a YAML comment, a JSON5 comment), so it is told apart from the person's own. */
+export const AIDER_MARK = "100xprompt gateway, added by brain gateway connect --tool aider"
+/** What Aider is told about the gateway's model: the Gemini Flash models' window and output limit. */
+const CONTEXT = 1_048_576
+const OUTPUT = 65_536
+
+const esc = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+
+/** A value in YAML flow style, written as JSON (which PyYAML and Bun both read): strings are always quoted. */
+const flow = (v: unknown): string =>
+  Array.isArray(v)
+    ? `[${v.map(flow).join(", ")}]`
+    : v && typeof v === "object"
+      ? `{${Object.entries(v)
+          .filter(([, x]) => x !== undefined)
+          .map(([k, x]) => `${JSON.stringify(k)}: ${flow(x)}`)
+          .join(", ")}}`
+      : JSON.stringify(v)
+
+// ---- ~/.aider.model.settings.yml: a YAML list; brain's entry is one key ---------------------------------------------
+
+/** Where brain's entry is: [start, end) is its text without the last newline; `next` is past that newline. */
+function findEntry(text: string): { start: number; end: number; next: number } | undefined {
+  const m = new RegExp(`^- .*# ${esc(AIDER_MARK)}[ \\t]*$`, "m").exec(text)
+  if (!m) return undefined
+  const start = m.index
+  let end = start + m[0].length
+  // Its fields: the indented lines that follow (brain writes no blank or comment lines inside it).
+  while (text[end] === "\n") {
+    const nl = text.indexOf("\n", end + 1)
+    const lineEnd = nl < 0 ? text.length : nl
+    const line = text.slice(end + 1, lineEnd)
+    if (!/^[ \t]+[^\s#]/.test(line)) break
+    end = lineEnd
+  }
+  return { start, end, next: end < text.length ? end + 1 : end }
+}
+
+function renderEntry(v: Json): string {
+  const { name, ...rest } = v
+  const fields = Object.entries(rest)
+    .filter(([, x]) => x !== undefined)
+    .map(([k, x]) => `  ${k}: ${flow(x)}`)
+  return [`- name: ${flow(name)}  # ${AIDER_MARK}`, ...fields].join("\n")
+}
+
+const SAMPLE_ENTRY = { name: "openai/brain-check", extra_params: { api_base: "https://example.invalid/v1" } }
+
+/**
+ * Aider's model settings file: a top-level YAML list of entries. Brain's entry (the key AIDER_ENTRY) is found by its
+ * marker comment, replaced or removed as a whole, and added at the end (a later entry of the same name wins in Aider).
+ * Every other byte stays as it was; adding and then removing the entry gives the file back exactly.
+ */
+export const modelSettingsList: Codec = {
+  check(text) {
+    if (!text.trim()) return undefined
+    if (/^---\s*$/m.test(text.replace(/^---\s*\n/, "")) || /^\.\.\.\s*$/m.test(text)) return "it holds more than one YAML document; left as it is"
+    let v: unknown
+    try {
+      v = Bun.YAML.parse(text)
+    } catch {
+      return "it is not valid YAML; left as it is"
+    }
+    if (v !== null && !Array.isArray(v)) return "it is not a YAML list of model settings; left as it is"
+    // Brain adds `- name: ...` at the left margin, so the list must be written that way (not [...] or indented).
+    const first = text.split("\n").find((l) => l.trim() && !/^\s*#/.test(l) && !/^---\s*$/.test(l))
+    if (first !== undefined && !/^-(\s|$)/.test(first)) return "its list is not a block list at the left margin; left as it is"
+    // Proof that brain's entry can be added: the result reads as the same list plus that entry.
+    try {
+      const had = Array.isArray(v) ? v.length : 0
+      const ours = findEntry(text) !== undefined
+      const probe = Bun.YAML.parse(modelSettingsList.set(text, AIDER_ENTRY, SAMPLE_ENTRY)) as unknown
+      // Brain's entry already there is replaced in place; otherwise the sample must be a new last entry.
+      if (!Array.isArray(probe) || probe.length !== had + (ours ? 0 : 1) || (!ours && (probe.at(-1) as Json | undefined)?.name !== SAMPLE_ENTRY.name))
+        return "brain cannot add its entry to it safely; left as it is"
+    } catch {
+      return "brain cannot add its entry to it safely; left as it is"
+    }
+    return undefined
+  },
+  get(text, key) {
+    if (key !== AIDER_ENTRY) return undefined
+    const at = findEntry(text)
+    if (!at) return undefined
+    try {
+      const v = Bun.YAML.parse(text.slice(at.start, at.end)) as unknown
+      return Array.isArray(v) ? v[0] : v
+    } catch {
+      return text.slice(at.start, at.end)
+    }
+  },
+  set(text, key, value) {
+    if (key !== AIDER_ENTRY) return text
+    const at = findEntry(text)
+    if (value === undefined) {
+      if (!at) return text
+      // The last line of a file with no final newline: the newline brain put before it goes too.
+      if (at.next === at.end && at.start > 0) return text.slice(0, at.start - 1)
+      return text.slice(0, at.start) + text.slice(at.next)
+    }
+    const entry = renderEntry(value as Json)
+    if (at) return text.slice(0, at.start) + entry + text.slice(at.end)
+    if (!text) return `${entry}\n`
+    return text.endsWith("\n") ? `${text}${entry}\n` : `${text}\n${entry}`
+  },
+}
+
+// ---- ~/.aider.model.metadata.json: a JSON5 object; brain's member is one key -----------------------------------------
+
+/** The index just past the JSON string that starts at i (a double quote). */
+function stringEnd(t: string, i: number): number {
+  let j = i + 1
+  while (j < t.length) {
+    if (t[j] === "\\") j += 2
+    else if (t[j] === '"') return j + 1
+    else j++
+  }
+  return t.length
+}
+
+/** The index of the next character that is not whitespace or inside a comment. */
+function skipBlank(t: string, i: number): number {
+  while (i < t.length) {
+    if (/\s/.test(t[i]!)) i++
+    else if (t.startsWith("//", i)) {
+      const n = t.indexOf("\n", i)
+      i = n < 0 ? t.length : n + 1
+    } else if (t.startsWith("/*", i)) {
+      const n = t.indexOf("*/", i + 2)
+      if (n < 0) throw new Error("unclosed comment")
+      i = n + 2
+    } else break
+  }
+  return i
+}
+
+/** The text with comments and trailing commas taken out (outside strings): what JSON.parse can read. */
+function plainJson(t: string): string {
+  let out = ""
+  let i = 0
+  while (i < t.length) {
+    const c = t[i]!
+    if (c === '"') {
+      const j = stringEnd(t, i)
+      out += t.slice(i, j)
+      i = j
+    } else if (t.startsWith("//", i) || t.startsWith("/*", i)) {
+      const j = skipBlank(t, i)
+      out += " "
+      i = j
+    } else if (c === ",") {
+      const j = skipBlank(t, i + 1)
+      if (t[j] !== "}" && t[j] !== "]") out += c
+      i++
+    } else {
+      out += c
+      i++
+    }
+  }
+  return out
+}
+
+/** The index just past the JSON value that starts at i. */
+function valueEnd(t: string, i: number): number {
+  if (t[i] === '"') return stringEnd(t, i)
+  if (t[i] === "{" || t[i] === "[") {
+    let depth = 0
+    let j = i
+    while (j < t.length) {
+      const c = t[j]!
+      if (c === '"') {
+        j = stringEnd(t, j)
+        continue
+      }
+      if (t.startsWith("//", j) || t.startsWith("/*", j)) {
+        j = skipBlank(t, j)
+        continue
+      }
+      if (c === "{" || c === "[") depth++
+      else if (c === "}" || c === "]") {
+        depth--
+        if (depth === 0) return j + 1
+      }
+      j++
+    }
+    return t.length
+  }
+  let j = i
+  while (j < t.length && !/[\s,}\]]/.test(t[j]!) && !t.startsWith("//", j) && !t.startsWith("/*", j)) j++
+  return j
+}
+
+const TAG = `/* ${AIDER_MARK} */`
+
+/** Brain's member: `\n  /* mark *\/ "<name>": <value>,` from start to end, as brain writes it right after the opening brace. */
+function findMember(t: string): { start: number; end: number; name: string; value: string } | undefined {
+  const at = t.indexOf(TAG)
+  if (at < 0) return undefined
+  let i = at + TAG.length
+  while (t[i] === " ") i++
+  if (t[i] !== '"') return undefined
+  const nameEnd = stringEnd(t, i)
+  let name: string
+  try {
+    name = JSON.parse(t.slice(i, nameEnd))
+  } catch {
+    return undefined
+  }
+  i = nameEnd
+  while (t[i] === " ") i++
+  if (t[i] !== ":") return undefined
+  i++
+  while (t[i] === " ") i++
+  const vEnd = valueEnd(t, i)
+  if (t[vEnd] !== ",") return undefined
+  return { start: t.slice(at - 3, at) === "\n  " ? at - 3 : at, end: vEnd + 1, name, value: t.slice(i, vEnd) }
+}
+
+const memberText = (name: string, info: unknown) => `\n  ${TAG} ${JSON.stringify(name)}: ${JSON.stringify(info)},`
+
+/**
+ * Aider's model metadata file: a JSON5 object (Aider reads it with json5.loads). Brain's member (the key AIDER_ENTRY,
+ * value { "<model>": {...} }) is written on one line right after the opening brace, marked with a comment, and taken
+ * out again exactly; comments and the person's own members stay as they were. A file that is JSON5 beyond comments and
+ * trailing commas (unquoted keys, single quotes) is left alone.
+ */
+export const modelMetadataJson: Codec = {
+  check(text) {
+    if (!text.trim()) return undefined
+    try {
+      const v = JSON.parse(plainJson(text))
+      if (!v || typeof v !== "object" || Array.isArray(v)) return "it is not a JSON object; left as it is"
+      const probe = JSON.parse(plainJson(modelMetadataJson.set(text, AIDER_ENTRY, { "openai/brain-check": { mode: "chat" } })))
+      if (!probe?.["openai/brain-check"]) return "brain cannot add its entry to it safely; left as it is"
+    } catch {
+      return "it is not JSON that brain can edit safely (JSON5 beyond comments and trailing commas?); left as it is"
+    }
+    return undefined
+  },
+  get(text, key) {
+    if (key !== AIDER_ENTRY) return undefined
+    const m = findMember(text)
+    if (!m) return undefined
+    try {
+      return { [m.name]: JSON.parse(plainJson(m.value)) }
+    } catch {
+      return m.value
+    }
+  },
+  set(text, key, value) {
+    if (key !== AIDER_ENTRY) return text
+    const m = findMember(text)
+    if (value === undefined) {
+      if (!m) return text
+      // Added to an empty object, the member took the newline before the closing brace with it.
+      const extra = text[m.start - 1] === "{" && text.startsWith("\n}", m.end) ? 1 : 0
+      return text.slice(0, m.start) + text.slice(m.end + extra)
+    }
+    const [name, info] = Object.entries(value as Json)[0]!
+    const seg = memberText(name, info)
+    if (m) return text.slice(0, m.start) + seg + text.slice(m.end)
+    const base = text.trim() ? text : "{}\n"
+    const open = skipBlank(base, 0)
+    const rest = base.slice(open + 1)
+    if (/^\s*\}/.test(rest)) return `${base.slice(0, open + 1)}${seg}\n${rest.replace(/^\s*/, "")}`
+    return base.slice(0, open + 1) + seg + rest
+  },
+}
+
+// ---- the connector ------------------------------------------------------------------------------------------------------
+
+export const connectors: Connector[] = [
+  {
+    id: "aider",
+    label: "Aider",
+    file: (home) => join(home, ".aider.conf.yml"),
+    // ~/.aider holds Aider's caches and analytics from its first run.
+    probe: [".aider"],
+    authHeader: "authorization",
+    edits: (home, s) => {
+      const model = `openai/${s.model}`
+      return [
+        {
+          path: join(home, ".aider.model.settings.yml"),
+          format: "custom",
+          codec: modelSettingsList,
+          holdsKey: true,
+          secretKeys: [AIDER_ENTRY],
+          values: {
+            [AIDER_ENTRY]: {
+              name: model,
+              // As Aider's own settings for Gemini Flash (aider/resources/model-settings.yml, gemini/gemini-3-flash-preview).
+              edit_format: "diff-fenced",
+              use_repo_map: true,
+              overeager: true,
+              use_temperature: false,
+              extra_params: { api_base: `${routeUrl(s)}/v1`, api_key: readKey(home), ...(s.contextEdit ? { extra_headers: { [EDIT_HEADER]: "on" } } : {}) },
+            },
+          },
+        },
+        {
+          path: join(home, ".aider.model.metadata.json"),
+          format: "custom",
+          codec: modelMetadataJson,
+          values: { [AIDER_ENTRY]: { [model]: { max_input_tokens: CONTEXT, max_output_tokens: OUTPUT, max_tokens: OUTPUT, litellm_provider: "openai", mode: "chat" } } },
+        },
+        {
+          path: join(home, ".aider.conf.yml"),
+          format: "custom",
+          codec: yamlTopLevel,
+          values: { model, "show-model-warnings": false },
+        },
+      ]
+    },
+    notes: [
+      "Aider cannot read its key from a file, so the key is kept in ~/.aider.model.settings.yml (the gateway model's own entry), which is now readable by you only (0600); a new sign-in replaces it there.",
+      "The gateway's model is now Aider's default (model: in ~/.aider.conf.yml); --model, AIDER_MODEL (in your shell or a .env file) or a project's own .aider.conf.yml still take precedence. Your OpenAI settings are not touched.",
+      "Aider's start-up model warnings are off while connected (it would warn that OPENAI_API_KEY is not set, which the gateway does not use); disconnect puts that setting back.",
+    ],
+  },
+]

package/src/gateway/connectors/amazon-q-cli.ts

@@ -0,0 +1,6 @@
+// Gateway connector for Amazon Q Developer CLI: none. Its endpoint settings (api.codewhisperer.service, api.q.service) only
+// move it between AWS Q servers, which speak AWS's own streaming API (generateAssistantResponse), not OpenAI or Anthropic; it is
+// replaced by Kiro CLI (aws/amazon-q-developer-cli crates/chat-cli/src/api_client/endpoints.rs; wire/drivers/b.ts:26).
+import type { Connector } from "../common.ts"
+
+export const connectors: Connector[] = []

package/src/gateway/connectors/amazon-q-ide.ts

@@ -0,0 +1,6 @@
+// Gateway connector for Amazon Q Developer (IDE plugin): none. Chat runs in AWS's language server against Amazon Q (AWS
+// sign-in, AWS event-stream API); the model menu offers only Amazon Q's own models and there is no endpoint or key setting
+// (https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/q-in-ides-chat-models.html; wire/drivers/e.ts:306).
+import type { Connector } from "../common.ts"
+
+export const connectors: Connector[] = []

package/src/gateway/connectors/antigravity.ts

@@ -0,0 +1,6 @@
+// Gateway connector for Antigravity: none. The IDE's agent runs in Google's `agy` language server against Google's backend
+// with a fixed model list; neither Antigravity IDE 1.107.0 (extensions/agy/package.json settings) nor its docs offer an
+// endpoint or key, and a settings.json "openai-compatible" attempt went unanswered (https://discuss.ai.google.dev/t/168654, 2026-06-01).
+import type { Connector } from "../common.ts"
+
+export const connectors: Connector[] = []

package/src/gateway/connectors/auggie.ts

@@ -0,0 +1,6 @@
+// Gateway connector for Auggie: none. It speaks only Augment's own chat-stream API (its model registry keeps provider
+// "augment" models only, wire/drivers/b.ts:12), and ~/.augment/settings.json has `defaultModel` but no provider, endpoint or
+// key (https://docs.augmentcode.com/cli/config, checked 2026-11-10).
+import type { Connector } from "../common.ts"
+
+export const connectors: Connector[] = []

package/src/gateway/connectors/cline-sdk.ts

@@ -0,0 +1,85 @@
+// Gateway connector for Cline's CLI / SDK (`cline`, npm package cline 3.0.74 on @cline/core 0.2.0, checked 2026-11-10 in
+// ~/.cache/brain-wire/cline-sdk). Cline keeps its providers in two plain JSON files under ~/.cline/data/settings/:
+//
+//   providers.json  { version: 1, lastUsedProvider, modes, providers: { <id>: { settings, updatedAt, tokenSource } } }
+//                   settings = { provider, apiKey, model, baseUrl, headers, ... }  (@cline/core dist/services/llms/
+//                   provider-settings.d.ts ProviderSettingsSchema; StoredProviderSettings in dist/types/provider-settings.d.ts).
+//                   Cline itself keeps this file 0600 (ProviderSettingsManager: write() with mode 384, chmod 384 on load),
+//                   reads it fresh before every change (saveProviderSettings is read-modify-write) and starts a run on
+//                   `lastUsedProvider` when no -P is given.
+//   models.json     { version: 1, providers: { <id>: { provider: { name, baseUrl, defaultModelId, protocol, client,
+//                   capabilities }, models: { <model>: { id, name, contextWindow, maxTokens, capabilities } } } } }
+//                   (dist/services/providers/local-provider-registry.d.ts StoredModelsFileSchema): the custom providers
+//                   Cline knows about; `cline auth -p <id>` refuses an id that is in neither the built-ins nor this file.
+//
+// So brain adds its own named provider, "brain-gateway" (shown as "100xprompt gateway", its model as 100xprompt Pro), an
+// OpenAI Chat Completions client on <route>/v1 with the x-100x-context-edit header (settings.headers), and makes it the
+// last-used provider. The person's own providers are not touched. Cline has no key-file or key-command option for a
+// custom provider (built-ins read a fixed env var at most: `apiKeyEnv` in @cline/llms), so the key is copied into
+// providers.json, which stays 0600.
+//
+// Checked for real (scripts/gateway-real/cline-sdk.ts): with these two files, `cline -y "<prompt>"` sends POST
+// /flash/v1/chat/completions with `Authorization: Bearer <key>`, `x-100x-context-edit: on` and model gemini-3.8-flash, and
+// never asks for /v1/models.
+//
+// Not covered here: CLINE_PROVIDER_SETTINGS_PATH (a providers.json somewhere else; models.json then sits next to it) is
+// not followed; CLINE_DIR and CLINE_DATA_DIR are, when they exist. The VS Code extension (id `cline`, see cline.ts) shares
+// ~/.cline/data but chooses its provider from its own globalState.json, so this connector does not change it.
+import { join } from "node:path"
+import { type Connector, dirFromEnv, EDIT_HEADER, type Env, modelName, readKey, routeUrl } from "../common.ts"
+
+const ID = "brain-gateway"
+/** Gemini 3.x Flash, which the gateway's models are: a 1M-token window, 64K out. */
+const CONTEXT_WINDOW = 1_048_576
+const MAX_OUTPUT = 65_536
+/** Cline requires an ISO date here; a fixed one keeps edits() free of side effects (Cline sets its own when it saves). */
+const UPDATED_AT = "2026-01-01T00:00:00.000Z"
+
+/** ~/.cline/data, or $CLINE_DATA_DIR, or $CLINE_DIR/data (each only when it exists), as @cline/shared resolves it. */
+export const clineDataDir = (home: string, env: Env) => dirFromEnv(env, "CLINE_DATA_DIR", join(dirFromEnv(env, "CLINE_DIR", join(home, ".cline")), "data"))
+const settingsDir = (home: string, env: Env) => join(clineDataDir(home, env), "settings")
+
+export const connectors: Connector[] = [
+  {
+    id: "cline-sdk",
+    label: "Cline CLI",
+    file: (home, env) => join(settingsDir(home, env), "providers.json"),
+    probe: [".cline"],
+    authHeader: "authorization",
+    edits: (home, s, env) => {
+      const baseUrl = `${routeUrl(s)}/v1`
+      return [
+        {
+          path: join(settingsDir(home, env), "models.json"),
+          format: "json",
+          values: {
+            version: 1,
+            [`providers/${ID}`]: {
+              provider: { name: "100xprompt gateway", baseUrl, defaultModelId: s.model, protocol: "openai-chat", client: "openai-compatible", capabilities: ["tools", "streaming"] },
+              models: { [s.model]: { id: s.model, name: modelName(s.model), contextWindow: CONTEXT_WINDOW, maxTokens: MAX_OUTPUT, capabilities: ["tools", "streaming", "images"] } },
+            },
+          },
+        },
+        {
+          path: join(settingsDir(home, env), "providers.json"),
+          format: "json",
+          holdsKey: true,
+          secretKeys: [`providers/${ID}`],
+          values: {
+            version: 1,
+            lastUsedProvider: ID,
+            [`providers/${ID}`]: {
+              settings: { provider: ID, apiKey: readKey(home), model: s.model, baseUrl, ...(s.contextEdit ? { headers: { [EDIT_HEADER]: "on" } } : {}) },
+              updatedAt: UPDATED_AT,
+              tokenSource: "manual",
+            },
+          },
+        },
+      ]
+    },
+    notes: [
+      "Cline CLI now starts on the 100xprompt gateway provider (its last-used provider); `cline -P <provider>` or /model still picks another for a run.",
+      "Cline keeps provider keys in ~/.cline/data/settings/providers.json (it has no key-file option), so the gateway key is copied there; the file stays readable by you only (0600).",
+    ],
+  },
+]

package/src/gateway/connectors/cline.ts

@@ -0,0 +1,34 @@
+// Gateway connector for Cline, the VS Code extension: NOT BUILT. Its settings are files, but not files brain can safely
+// write and cleanly undo. (Cline's CLI / SDK is connected by cline-sdk.ts.)
+//
+// Checked 2026-11-10 against Cline 4.1.26 (saoudrizwan.claude-dev-4.1.26 in ~/.vscode/extensions, dist/extension.js) and
+// the SDK it shares with the CLI (@cline/core 0.2.0 in ~/.cache/brain-wire/cline-sdk):
+//   - Where the settings are: since 4.x the extension's global state and secrets are JSON files, ~/.cline/data/
+//     globalState.json and secrets.json (0600) ($CLINE_DATA_DIR overrides): p3s() builds them as TDe file stores, and
+//     activation (bg0 -> RWu) migrates VS Code's own extension state into them. The provider a task uses comes from that
+//     state (SessionFactory: getApiConfiguration() -> actModeApiProvider / planModeApiProvider), with per-provider keys:
+//     for an OpenAI-compatible endpoint `openAiBaseUrl`, `actModeOpenAiModelId` / `planModeOpenAiModelId`,
+//     `actModeOpenAiModelInfo`, `openAiHeaders` in globalState.json and `openAiApiKey` in secrets.json.
+//   - Why brain cannot edit them safely:
+//     1. The extension keeps both files in memory and writes them back whole. TDe reads its file once, in the constructor
+//        (`this.data = this.readFromDisk()`), and every change rewrites the file from that copy (setBatch -> writeToDisk);
+//        nothing reloads it. While VS Code (or Cursor or Windsurf, which share ~/.cline/data) runs Cline, a connect is
+//        overwritten by the next state write, and a disconnect is undone: the gateway settings, and on the next secrets
+//        write the key copy, come back from memory after brain recorded them as removed.
+//     2. There is one OpenAI-compatible slot, not a named provider: connect would have to rewrite the person's own
+//        openAiBaseUrl / openAiApiKey / model entries and the act and plan providers.
+//     3. A second key copy brain would not know about: the SDK's legacy migration (@cline/core migrateLegacyProviderSettings,
+//        run by the ProviderSettingsManager constructor, which both the extension and the CLI create to read
+//        providers.json) copies every provider that has a key in
+//        globalState.json / secrets.json (`openAiApiKey` -> "openai" -> "openai-compatible") into
+//        ~/.cline/data/settings/providers.json, key included, when that provider is not there yet. Disconnect would leave it.
+//   - What does reach the extension: when no provider was ever chosen in it (actModeApiProvider unset), the SessionFactory
+//     falls back to providers.json's last-used provider ("Using SDK provider fallback"), which `--tool cline-sdk` sets. Not
+//     verified with a custom provider id in the extension, so not claimed.
+//
+// What would make it buildable: a connector hook in the core that refuses to connect or disconnect while the app holding
+// the files is running (VS Code, Cursor, Windsurf), and a way to also own (and remove) the providers.json copy the
+// migration makes, e.g. by writing providers.json's "openai-compatible" entry as well so the migration skips it.
+import type { Connector } from "../common.ts"
+
+export const connectors: Connector[] = []

package/src/gateway/connectors/codebuff.ts

@@ -0,0 +1,6 @@
+// Gateway connector for Codebuff (now the Freebuff CLI, npm `freebuff`): not built. Its /byok takes an OpenAI-compatible
+// base URL (kept in ~/.config/freebuff/byok/connections.json), but a CLI connection's key can only be an `env:NAME` reference
+// or an OS-keychain entry, never a file (CodebuffAI/codebuff sdk/src/byok.ts:27,1196-1300 and cli/src/utils/byok.ts:57-63, 2026-10-14).
+import type { Connector } from "../common.ts"
+
+export const connectors: Connector[] = []