@100xprompt/brain 0.0.0-stage → 0.1.1

package/src/gateway/connectors/copilot-cli.ts

@@ -0,0 +1,138 @@
+// Gateway connector for GitHub Copilot CLI. Copilot CLI's "bring your own key" providers live in $COPILOT_HOME/providers.json
+// (default ~/.copilot; $COPILOT_PROVIDERS_CONFIG names another file), and settings.json's `model` picks one as the default
+// as "<provider>/<model id>". Checked against @github/copilot 1.0.107 run against a local fake server (2026-11-10): an
+// "openai" provider with baseUrl <route>/v1 sends POST <route>/v1/chat/completions with `Authorization: Bearer <apiKey>`
+// and the provider's `headers`, with no GitHub sign-in; `apiKeyCommand` is NOT read from this file (no key is sent), so
+// the key itself is kept there and the file is made private. A `modelProviderId` left in settings.json by an earlier /model
+// pick makes the CLI refuse the gateway model ("The configured provider/model pair is not available"), so it is cleared
+// while connected. Docs: https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/use-byok-models
+import { isAbsolute, join } from "node:path"
+import { type Codec, type Connector, dirFromEnv, EDIT_HEADER, type Env, type Json, readKey, routeUrl } from "../common.ts"
+
+const PROVIDER = "brain-gateway"
+const copilotHome = (home: string, env: Env) => dirFromEnv(env, "COPILOT_HOME", join(home, ".copilot"))
+/** The providers file the CLI reads: $COPILOT_PROVIDERS_CONFIG when it is set (the CLI then reads nothing else), else <home>/providers.json. */
+const providersPath = (home: string, env: Env) => {
+  const named = env.COPILOT_PROVIDERS_CONFIG?.trim()
+  return named && isAbsolute(named) ? named : join(copilotHome(home, env), "providers.json")
+}
+
+/** Parses a JSON object file ({} when empty); throws on anything else. */
+function parseObject(text: string): Json {
+  if (!text.trim()) return {}
+  const v = JSON.parse(text)
+  if (!v || typeof v !== "object" || Array.isArray(v)) throw new Error("not an object")
+  return v as Json
+}
+const render = (text: string, o: Json) => `${JSON.stringify(o, null, text.match(/\n([ \t]+)"/)?.[1] ?? "  ")}\n`
+function checkObject(text: string): string | undefined {
+  try {
+    parseObject(text)
+    return undefined
+  } catch {
+    return "it is not a plain JSON object (comments?); left as it is"
+  }
+}
+
+/**
+ * providers.json: only brain's own entries are touched, so the person's other providers and models stay usable while
+ * connected. Keys:
+ *   providers/brain-gateway   the entry of `providers` whose name is brain-gateway
+ *   models/brain-gateway      the entry of `models` whose provider is brain-gateway
+ * An entry is replaced where it is, or added at the end; removing the last entry of a list removes the list.
+ */
+const ENTRY: Record<string, { list: "providers" | "models"; field: "name" | "provider" }> = {
+  [`providers/${PROVIDER}`]: { list: "providers", field: "name" },
+  [`models/${PROVIDER}`]: { list: "models", field: "provider" },
+}
+export const providersCodec: Codec = {
+  check(text) {
+    const why = checkObject(text)
+    if (why) return why
+    const o = parseObject(text)
+    for (const list of ["providers", "models"]) if (list in o && !Array.isArray(o[list])) return `its "${list}" is not a list; left as it is`
+    return undefined
+  },
+  get(text, key) {
+    const at = ENTRY[key]
+    if (!at) return undefined
+    const list = parseObject(text)[at.list]
+    return Array.isArray(list) ? list.find((x) => x && typeof x === "object" && x[at.field] === PROVIDER) : undefined
+  },
+  set(text, key, value) {
+    const at = ENTRY[key]
+    if (!at) return text
+    const o = parseObject(text)
+    const list: unknown[] = Array.isArray(o[at.list]) ? [...o[at.list]] : []
+    const i = list.findIndex((x) => !!x && typeof x === "object" && (x as Json)[at.field] === PROVIDER)
+    if (value === undefined) {
+      if (i < 0) return text
+      list.splice(i, 1)
+    } else if (i >= 0) list[i] = value
+    else list.push(value)
+    if (list.length) o[at.list] = list
+    else delete o[at.list]
+    return render(text, o)
+  },
+}
+
+/**
+ * settings.json: top-level keys. `modelProviderId` reads as null when it is absent, and setting it to null removes it:
+ * connect sets null (cleared), and disconnect puts back the person's own provider id, or nothing.
+ */
+const CLEARED = "modelProviderId"
+export const settingsCodec: Codec = {
+  check: checkObject,
+  get(text, key) {
+    const o = parseObject(text)
+    return key in o ? o[key] : key === CLEARED ? null : undefined
+  },
+  set(text, key, value) {
+    const o = parseObject(text)
+    if (value === undefined || (key === CLEARED && value === null)) {
+      if (!(key in o)) return text
+      delete o[key]
+    } else o[key] = value
+    return render(text, o)
+  },
+}
+
+export const connectors: Connector[] = [
+  {
+    id: "copilot-cli",
+    label: "GitHub Copilot CLI",
+    file: (home, env) => providersPath(home, env),
+    probe: [".copilot"],
+    authHeader: "authorization",
+    edits: (home, s, env) => [
+      {
+        path: providersPath(home, env),
+        format: "custom",
+        codec: providersCodec,
+        holdsKey: true,
+        secretKeys: [`providers/${PROVIDER}`],
+        values: {
+          [`providers/${PROVIDER}`]: {
+            name: PROVIDER,
+            type: "openai",
+            baseUrl: `${routeUrl(s)}/v1`,
+            apiKey: readKey(home),
+            ...(s.contextEdit ? { headers: { [EDIT_HEADER]: "on" } } : {}),
+          },
+          // Gemini takes images; without this Copilot CLI treats a BYOK model as text-only and drops images tools return.
+          [`models/${PROVIDER}`]: { id: s.model, provider: PROVIDER, capabilities: { supports: { vision: true } } },
+        },
+      },
+      {
+        path: join(copilotHome(home, env), "settings.json"),
+        format: "custom",
+        codec: settingsCodec,
+        values: { model: `${PROVIDER}/${s.model}`, [CLEARED]: null },
+      },
+    ],
+    notes: [
+      "Copilot CLI reads a provider's key only from providers.json or the environment, so the key is kept in providers.json, which is now readable by you only (0600).",
+      "The gateway model is now Copilot CLI's default and needs no GitHub sign-in; --model, COPILOT_MODEL or /model still pick another model for a session.",
+    ],
+  },
+]

package/src/gateway/connectors/crush.ts

@@ -0,0 +1,313 @@
+// Gateway connector for Crush (charmbracelet/crush), checked against v0.100.0 (the copy in ~/.cache/brain-wire/crush,
+// `crush --version`) and its source at tag v0.100.0.
+//
+// Where Crush reads its settings (internal/config/load.go, lookupConfigs and Load): these files are merged, a later one
+// winning over an earlier one:
+//   ~/.config/crush/crush.json        the person's JSON config (deprecated for crushrc; JSONC, may hold comments)
+//   ~/.config/crush/crushrc           the person's Bash config (docs/config/README.md, "Where config lives")
+//   ~/.local/share/crush/crush.json   Crush's data file ($CRUSH_GLOBAL_DATA/crush.json, else $XDG_DATA_HOME/crush/crush.json;
+//                                     load.go GlobalConfigData)
+//   ./crushrc, ./crush.json, ...      project files, then <project>/.crush/crush.json (the workspace file)
+// The model picked in Crush's UI, and an API key typed into it, go to the data file (store.go: configPath returns
+// globalDataPath for the global scope; UpdatePreferredModel writes models.large / models.small there), and the data file
+// outranks ~/.config/crush. A model selection written to the person's config would be overridden for anyone who has ever
+// picked a model, so brain writes where Crush itself writes: the data file. It is plain JSON (Crush refuses anything else:
+// json.Valid) that Crush edits in place with sjson; the codec below edits it the same way, changing only the members brain
+// owns, so every other byte stays and disconnect gives back the exact bytes.
+//
+// What is written there:
+//   providers.brain-gateway   a custom OpenAI-compatible provider: "type": "openai-compat" (Chat Completions at
+//                             <route>/v1; v0.100.0 reads it as "completions" in memory, load.go NormalizeProviderType,
+//                             without rewriting the file; older versions take it as it is), "api_key": "$(cat '<keyPath>')"
+//                             (Crush shell-expands api_key, base_url and extra_headers when it loads, load.go
+//                             configureProviders and the README's "any $(...) in crush.json runs at load time": the key is
+//                             read from brain's key file at each start and never copied), "extra_headers" with
+//                             x-100x-context-edit, and one model shown as "100xprompt Pro". The model uses only catwalk v3
+//                             fields: a v2 field (supports_attachments, can_reason, cost_per_1m_in) would make Crush rewrite
+//                             the whole file on load (load.go migrateCatwalkV2File).
+//   models.large, models.small that model. The small one titles sessions and summarises; left on another provider it would
+//                             go around the gateway.
+// A model list is given, so Crush does not ask the gateway for /v1/models (403 there).
+import { existsSync } from "node:fs"
+import { isAbsolute, join, resolve } from "node:path"
+import { type Codec, type Connector, EDIT_HEADER, type Env, getAt, type Json, keyPath, modelName, routeUrl, shellQuote } from "../common.ts"
+
+/** Crush's data file, resolved as Crush does; the env overrides describe the person's real home, so they count only there. */
+export function crushDataFile(home: string, env: Env): string {
+  const own = !!env.HOME && resolve(env.HOME) === resolve(home)
+  const g = env.CRUSH_GLOBAL_DATA
+  if (own && g && isAbsolute(g) && existsSync(g)) return join(g, "crush.json")
+  const x = env.XDG_DATA_HOME
+  if (own && x && isAbsolute(x)) return join(x, "crush", "crush.json")
+  return join(home, ".local", "share", "crush", "crush.json")
+}
+
+// ---- JSON, edited in place ----------------------------------------------------------------------------------------------
+
+interface Member {
+  key: string
+  keyStart: number
+  keyEnd: number
+  valueStart: number
+  valueEnd: number
+  value: Node
+}
+type Node = { kind: "object"; start: number; end: number; members: Member[] } | { kind: "value"; start: number; end: number }
+type ObjectNode = Extract<Node, { kind: "object" }>
+
+/** Where every value of a JSON text starts and ends (throws on anything that is not JSON). */
+function scan(text: string): Node {
+  let i = 0
+  const ws = () => {
+    while (i < text.length && " \t\n\r".includes(text[i]!)) i++
+  }
+  const str = (): string => {
+    const s = i++
+    while (i < text.length && text[i] !== '"') i += text[i] === "\\" ? 2 : 1
+    if (i >= text.length) throw new Error("unterminated string")
+    i++
+    return JSON.parse(text.slice(s, i)) as string
+  }
+  const value = (): Node => {
+    ws()
+    const start = i
+    const c = text[i]
+    if (c === "{") {
+      i++
+      const members: Member[] = []
+      ws()
+      if (text[i] === "}") return { kind: "object", start, end: ++i, members }
+      for (;;) {
+        ws()
+        if (text[i] !== '"') throw new Error("expected a key")
+        const keyStart = i
+        const key = str()
+        const keyEnd = i
+        ws()
+        if (text[i++] !== ":") throw new Error("expected :")
+        const v = value()
+        members.push({ key, keyStart, keyEnd, valueStart: v.start, valueEnd: v.end, value: v })
+        ws()
+        const d = text[i++]
+        if (d === "}") return { kind: "object", start, end: i, members }
+        if (d !== ",") throw new Error("expected , or }")
+      }
+    }
+    if (c === "[") {
+      i++
+      ws()
+      if (text[i] === "]") return { kind: "value", start, end: ++i }
+      for (;;) {
+        value()
+        ws()
+        const d = text[i++]
+        if (d === "]") return { kind: "value", start, end: i }
+        if (d !== ",") throw new Error("expected , or ]")
+      }
+    }
+    if (c === '"') {
+      str()
+      return { kind: "value", start, end: i }
+    }
+    while (i < text.length && !",}] \t\n\r".includes(text[i]!)) i++
+    if (i === start) throw new Error("expected a value")
+    return { kind: "value", start, end: i }
+  }
+  const root = value()
+  ws()
+  if (i !== text.length) throw new Error("text after the JSON value")
+  return root
+}
+
+/** How the file is laid out, so what is added looks like what is there (one line, as Crush writes it, or indented). */
+interface Style {
+  pretty: boolean
+  indent: string
+  /** Between a key and its value: ":" or ": ". */
+  colon: string
+}
+function styleOf(text: string, root: ObjectNode): Style {
+  const pretty = text.slice(root.start, root.end).includes("\n")
+  const indent = text.match(/\n([ \t]+)"/)?.[1] ?? "  "
+  const m = root.members[0]
+  return { pretty, indent, colon: m ? text.slice(m.keyEnd, m.valueStart) : pretty ? ": " : ":" }
+}
+const render = (v: unknown, depth: number, s: Style) => (s.pretty ? JSON.stringify(v, null, s.indent).split("\n").join(`\n${s.indent.repeat(depth)}`) : JSON.stringify(v))
+const splice = (text: string, from: number, to: number, put: string) => text.slice(0, from) + put + text.slice(to)
+const lastIndex = (o: ObjectNode, key: string) => o.members.map((m) => m.key).lastIndexOf(key)
+
+/** Adds `"key": value` at the end of `o` (whose members sit at `depth`), separated the way its members already are. */
+function insert(text: string, o: ObjectNode, depth: number, key: string, v: unknown, s: Style): string {
+  const member = `${JSON.stringify(key)}${s.colon}${render(v, depth, s)}`
+  const n = o.members.length
+  if (!n) return splice(text, o.start + 1, o.end - 1, s.pretty ? `\n${s.indent.repeat(depth)}${member}\n${s.indent.repeat(depth - 1)}` : member)
+  const last = o.members[n - 1]!
+  const gap = n >= 2 ? text.slice(o.members[n - 2]!.valueEnd, last.keyStart) : `,${text.slice(o.start + 1, o.members[0]!.keyStart)}`
+  return splice(text, last.valueEnd, last.valueEnd, `${gap}${member}`)
+}
+
+/** Removes member `i` of `o` with the separator that came with it (the exact reverse of insert). */
+function remove(text: string, o: ObjectNode, i: number): string {
+  const n = o.members.length
+  if (n === 1) return splice(text, o.start + 1, o.end - 1, "")
+  if (i > 0) return splice(text, o.members[i - 1]!.valueEnd, o.members[i]!.valueEnd, "")
+  return splice(text, o.members[0]!.keyStart, o.members[1]!.keyStart, "")
+}
+
+/** The object at `path` (undefined when absent or not an object). */
+function objectAt(root: ObjectNode, path: string[]): ObjectNode | undefined {
+  let cur: ObjectNode = root
+  for (const p of path) {
+    const i = lastIndex(cur, p)
+    const next = i >= 0 ? cur.members[i]!.value : undefined
+    if (!next || next.kind !== "object") return undefined
+    cur = next
+  }
+  return cur
+}
+
+const rootOf = (text: string): ObjectNode => {
+  const r = scan(text)
+  if (r.kind !== "object") throw new Error("not a JSON object")
+  return r
+}
+
+function jsonSet(text: string, key: string, value: unknown): string {
+  const blank = !text.trim()
+  if (blank && value === undefined) return text
+  const base = blank ? "{}\n" : text
+  const root = rootOf(base)
+  // A file brain starts is indented, for people to read; one that exists keeps its own layout.
+  const s: Style = blank ? { pretty: true, indent: "  ", colon: ": " } : styleOf(base, root)
+  const parts = key.split("/")
+  // The deepest object on the path that exists, and the members still missing below it.
+  let depth = 0
+  let o = root
+  while (depth < parts.length - 1) {
+    const i = lastIndex(o, parts[depth]!)
+    const next = i >= 0 ? o.members[i]!.value : undefined
+    if (!next || next.kind !== "object") break
+    o = next
+    depth++
+  }
+  const name = parts[depth]!
+  const i = lastIndex(o, name)
+  if (value === undefined) {
+    if (depth < parts.length - 1 || i < 0) return text
+    let out = remove(base, o, i)
+    // Drop the objects this left empty (as the core's JSON handling does), never the root.
+    for (let d = parts.length - 1; d >= 1; d--) {
+      const r = rootOf(out)
+      const child = objectAt(r, parts.slice(0, d))
+      if (!child || child.members.length) break
+      const parent = objectAt(r, parts.slice(0, d - 1))!
+      out = remove(out, parent, lastIndex(parent, parts[d - 1]!))
+    }
+    return out
+  }
+  // What goes in at `name`: the value itself, or the missing objects around it.
+  const nested = parts.slice(depth + 1).reduceRight<unknown>((v, p) => ({ [p]: v }), value)
+  if (i >= 0) {
+    const m = o.members[i]!
+    return splice(base, m.valueStart, m.valueEnd, render(nested, depth + 1, s))
+  }
+  return insert(base, o, depth + 1, name, nested, s)
+}
+
+const canon = (v: unknown): string =>
+  Array.isArray(v) ? `[${v.map(canon).join(",")}]` : v && typeof v === "object" ? `{${Object.keys(v).sort().map((k) => `${JSON.stringify(k)}:${canon((v as Json)[k])}`).join(",")}}` : JSON.stringify(v)
+
+/** Drops `key` and the objects it leaves empty (to compare the rest of a file). */
+function without(o: Json, key: string): Json {
+  const c = structuredClone(o)
+  const ps = key.split("/")
+  const chain: Json[] = [c]
+  for (const p of ps.slice(0, -1)) {
+    const next = chain[chain.length - 1]?.[p]
+    if (!next || typeof next !== "object" || Array.isArray(next)) return c
+    chain.push(next)
+  }
+  delete chain[chain.length - 1]![ps[ps.length - 1]!]
+  for (let d = ps.length - 1; d >= 1; d--) if (!Object.keys(chain[d]!).length) delete chain[d - 1]![ps[d - 1]!]
+  return c
+}
+
+/** The members brain sets, with stand-in values: a trial edit with them must land exactly there and touch nothing else. */
+const TRIAL: Record<string, unknown> = {
+  "providers/brain-gateway": { name: "trial", type: "openai-compat", models: [{ id: "m" }] },
+  "models/large": { model: "m", provider: "brain-gateway" },
+  "models/small": { model: "m", provider: "brain-gateway" },
+}
+
+/** Crush's data file: plain JSON, edited in place (keys are paths with "/", as in the core's JSON handling). */
+export const crushJson: Codec = {
+  check(text) {
+    if (!text.trim()) return undefined
+    let parsed: unknown
+    try {
+      parsed = JSON.parse(text)
+    } catch {
+      return "it is not valid JSON; left as it is"
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return "it is not a JSON object; left as it is"
+    try {
+      let t = text
+      for (const [k, v] of Object.entries(TRIAL)) t = jsonSet(t, k, v)
+      const after = JSON.parse(t) as Json
+      let rest = after
+      let was = parsed as Json
+      for (const [k, v] of Object.entries(TRIAL)) {
+        if (canon(getAt(after, k)) !== canon(v)) throw new Error(k)
+        rest = without(rest, k)
+        was = without(was, k)
+      }
+      if (canon(rest) !== canon(was)) throw new Error("other values moved")
+    } catch {
+      return "brain cannot change it without touching other settings; left as it is"
+    }
+    return undefined
+  },
+  get(text, key) {
+    if (!text.trim()) return undefined
+    return getAt(JSON.parse(text) as Json, key)
+  },
+  set: jsonSet,
+}
+
+export const PROVIDER = "brain-gateway"
+
+export const connectors: Connector[] = [
+  {
+    id: "crush",
+    label: "Crush",
+    file: crushDataFile,
+    probe: [".config/crush", ".local/share/crush"],
+    authHeader: "authorization",
+    edits: (home, s, env) => {
+      const pick = { model: s.model, provider: PROVIDER }
+      return [
+        {
+          path: crushDataFile(home, env),
+          format: "custom",
+          codec: crushJson,
+          values: {
+            [`providers/${PROVIDER}`]: {
+              name: "100xprompt gateway",
+              type: "openai-compat",
+              base_url: `${routeUrl(s)}/v1`,
+              api_key: `$(cat ${shellQuote(keyPath(home))})`,
+              ...(s.contextEdit ? { extra_headers: { [EDIT_HEADER]: "on" } } : {}),
+              models: [{ id: s.model, name: modelName(s.model), context_window: 1048576, default_max_tokens: 65536, capabilities: { vision: true } }],
+            },
+            "models/large": pick,
+            "models/small": pick,
+          },
+        },
+      ]
+    },
+    notes: [
+      "Crush reads the key from the brain's key file each time it starts (its api_key runs `cat` on that file); no key is written to Crush's files.",
+      "The gateway and the model choice are in Crush's own data file (~/.local/share/crush/crush.json), where Crush keeps the model you pick in its UI; a crushrc or crush.json inside a project still overrides it there.",
+    ],
+  },
+]

package/src/gateway/connectors/cursor-cli.ts

@@ -0,0 +1,6 @@
+// Gateway connector for Cursor CLI (cursor-agent): none. It talks only to Cursor's backend: its hidden --endpoint picks a
+// Cursor API server (default https://api2.cursor.sh, index.js:33 of build 2025.09.12), and Cursor offers no own key or base
+// URL in the CLI (https://help.openai.com/en/articles/20001506; https://docs.litellm.ai/docs/tutorials/cursor_integration).
+import type { Connector } from "../common.ts"
+
+export const connectors: Connector[] = []

package/src/gateway/connectors/cursor.ts

@@ -0,0 +1,6 @@
+// Gateway connector for Cursor (IDE): none. Its "Override OpenAI Base URL" and key live only in the app's state database and
+// the OS keychain (Cursor 3.29.9 workbench.desktop.main.js:2037 `openAIBaseUrl`, :20344 `cursorAuth/openAIKey`), and Cursor's
+// servers make the calls, for chat models only (https://cursor.com/docs/settings/api-keys; env-var local agent off: :59).
+import type { Connector } from "../common.ts"
+
+export const connectors: Connector[] = []

package/src/gateway/connectors/devin.ts

@@ -0,0 +1,6 @@
+// Gateway connector for Devin CLI: none. The standard CLI uses Cognition's models only (~/.config/devin/config.json names one,
+// with no endpoint or key; wire/drivers/f.ts:47); a custom endpoint exists only in federal air-gapped builds, through
+// $DEVIN_MODELS_FILE with the key in an environment variable (https://docs.devin.ai/federal/air-gapped/models-file).
+import type { Connector } from "../common.ts"
+
+export const connectors: Connector[] = []