@100xprompt/brain 0.1.0 → 0.1.2

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

@@ -0,0 +1,286 @@
+// Gateway connector for GitHub Copilot Chat in VS Code (checked 2026-11-10 against VS Code 1.144.0 and the Copilot Chat
+// extension 0.72.0 built into it: /Applications/Visual Studio Code.app/Contents/Resources/app/extensions/copilot).
+//
+// Bring-your-own-key models live in the VS Code user folder, in chatLanguageModels.json (out/vs/workbench/
+// workbench.desktop.main.js: profile `languageModelsResource` = <User>/chatLanguageModels.json, a JSON array of provider
+// groups `{ name, vendor, ...settings }` that VS Code watches and parses as JSON with comments). The Copilot extension's
+// "Custom Endpoint" provider (vendor `customendpoint`, package.json contributes.languageModelChatProviders; in Stable since
+// VS Code 1.122, https://code.visualstudio.com/updates/v1_122) takes per model an `id`, `name`, `url`, `apiType`
+// (chat-completions | responses | messages) and `requestHeaders`.
+//
+// The key. A group's `apiKey` is a secret: VS Code keeps only `${input:chat.lm.secret.<n>}` in the file and the value in
+// its secret storage (workbench: _resolveConfiguration / _resolveLanguageModelProviderGroup), which brain cannot write.
+// But the Custom Endpoint provider lets a model's `requestHeaders` carry the authorization itself: dist/extension.js class
+// for `CustomEndpoint` endpoints overrides _isReservedHeader so `authorization` and `api-key` are allowed
+// (_overridableReservedAuthHeaders), and skips its own `Authorization: Bearer <apiKey>` when the model sets one
+// (_userAuthHeaderSuppressionSet). So brain adds one group, "100xprompt gateway", with no apiKey and a model whose
+// requestHeaders hold `Authorization: Bearer <key>` (and `x-100x-context-edit: on`): the key is copied into the file, which
+// is made private (0600). chatLanguageModels.json is not part of Settings Sync (sync resources: settings, keybindings,
+// snippets, prompts, tasks, extensions, globalState, profiles, mcp), so the copy stays on this machine.
+//
+// What brain does not set: the model picked in Copilot Chat. VS Code remembers that in its own storage; the
+// `chat.defaultModel` setting matches models by their id alone (workbench: function resolving it compares metadata.id),
+// and the gateway's model id (gemini-3.8-flash) could equally name a model Copilot serves itself, so the person picks
+// "100xprompt Pro" in the model picker once (the notes say so). The model list is given in the file, so the gateway's
+// /v1/models (403) is never asked (CustomEndpoint.getAllModels reads `models` unless the group has a `url`).
+//
+// Only the default VS Code profile and VS Code Stable ("Code") are handled; Insiders, VSCodium and other profiles keep
+// their own User folders.
+import { join, resolve } from "node:path"
+import { type Codec, type Connector, EDIT_HEADER, type Env, type Json, modelName, readKey, routeUrl } from "../common.ts"
+
+const GROUP = "100xprompt gateway"
+const VENDOR = "customendpoint"
+/** Gemini 3.x Flash, which the gateway's models are: a 1M-token window, 64K out. */
+const MAX_OUTPUT = 65_536
+const MAX_INPUT = 1_048_576 - MAX_OUTPUT
+
+/** VS Code's user folder: ~/Library/Application Support/Code/User on macOS, $XDG_CONFIG_HOME/Code/User or ~/.config/Code/User elsewhere. */
+export function vscodeUserDir(home: string, env: Env, platform: string = process.platform): string {
+  if (platform === "darwin") return join(home, "Library", "Application Support", "Code", "User")
+  if (platform === "win32") return join(env.APPDATA ?? join(home, "AppData", "Roaming"), "Code", "User")
+  // XDG_CONFIG_HOME describes the real home: followed only when brain works in that home.
+  const xdg = env.XDG_CONFIG_HOME?.startsWith("/") && env.HOME && resolve(home) === resolve(env.HOME) ? env.XDG_CONFIG_HOME : join(home, ".config")
+  return join(xdg, "Code", "User")
+}
+
+// ---- JSON with comments, with the position of every value -------------------------------------------------------------
+
+type Node =
+  | { kind: "object"; start: number; end: number; members: Array<{ key: string; value: Node }> }
+  | { kind: "array"; start: number; end: number; items: Node[] }
+  | { kind: "scalar"; start: number; end: number; value: unknown }
+
+/** Parses JSON with // and /* comments and trailing commas (what VS Code accepts in its JSON files); throws otherwise. */
+export function parseJsonc(text: string): Node | undefined {
+  let i = 0
+  const fail = (what: string): never => {
+    throw new Error(`${what} at offset ${i}`)
+  }
+  const skip = () => {
+    for (;;) {
+      while (i < text.length && /\s/.test(text[i]!)) i++
+      if (text.startsWith("//", i)) {
+        const nl = text.indexOf("\n", i)
+        i = nl < 0 ? text.length : nl + 1
+      } else if (text.startsWith("/*", i)) {
+        const end = text.indexOf("*/", i + 2)
+        if (end < 0) fail("unclosed comment")
+        i = end + 2
+      } else return
+    }
+  }
+  const string = (): string => {
+    const start = i
+    i++
+    while (i < text.length && text[i] !== '"') i += text[i] === "\\" ? 2 : 1
+    if (i >= text.length) fail("unclosed string")
+    i++
+    return JSON.parse(text.slice(start, i)) as string
+  }
+  const value = (): Node => {
+    skip()
+    const start = i
+    const c = text[i]
+    if (c === "{") {
+      i++
+      const members: Array<{ key: string; value: Node }> = []
+      for (;;) {
+        skip()
+        if (text[i] === "}") break
+        if (text[i] !== '"') fail("expected a key")
+        const key = string()
+        skip()
+        if (text[i] !== ":") fail("expected :")
+        i++
+        members.push({ key, value: value() })
+        skip()
+        if (text[i] === ",") i++
+        else if (text[i] !== "}") fail("expected , or }")
+      }
+      i++
+      return { kind: "object", start, end: i, members }
+    }
+    if (c === "[") {
+      i++
+      const items: Node[] = []
+      for (;;) {
+        skip()
+        if (text[i] === "]") break
+        items.push(value())
+        skip()
+        if (text[i] === ",") i++
+        else if (text[i] !== "]") fail("expected , or ]")
+      }
+      i++
+      return { kind: "array", start, end: i, items }
+    }
+    if (c === '"') {
+      const v = string()
+      return { kind: "scalar", start, end: i, value: v }
+    }
+    const m = /^(?:true|false|null|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)/.exec(text.slice(i, i + 400))
+    if (!m) fail("unexpected character")
+    i += m![0].length
+    return { kind: "scalar", start, end: i, value: JSON.parse(m![0]) }
+  }
+  skip()
+  if (i >= text.length) return undefined
+  const root = value()
+  skip()
+  if (i < text.length) fail("text after the end")
+  return root
+}
+
+export function plain(n: Node): unknown {
+  if (n.kind === "scalar") return n.value
+  if (n.kind === "array") return n.items.map(plain)
+  const o: Json = {}
+  for (const m of n.members) o[m.key] = plain(m.value)
+  return o
+}
+
+/** The first `,` between from and to that is not inside a comment, or -1. */
+function commaBetween(text: string, from: number, to: number): number {
+  for (let i = from; i < to; i++) {
+    if (text.startsWith("//", i)) {
+      const nl = text.indexOf("\n", i)
+      i = nl < 0 ? to : nl
+    } else if (text.startsWith("/*", i)) i = text.indexOf("*/", i + 2) + 1
+    else if (text[i] === ",") return i
+  }
+  return -1
+}
+
+/** The whitespace a value at `at` is indented by, when it starts its line; undefined when something precedes it there. */
+function lineIndent(text: string, at: number): string | undefined {
+  const lineStart = text.lastIndexOf("\n", at - 1) + 1
+  const before = text.slice(lineStart, at)
+  return /^[ \t]*$/.test(before) ? before : undefined
+}
+
+const indentUnit = (text: string) => text.match(/\n([ \t]+)[^\s]/)?.[1]?.replace(/^(\t| {2,4}).*$/, "$1") ?? "\t"
+const render = (v: unknown, indent: string, unit: string) => JSON.stringify(v, null, unit).replace(/\n/g, `\n${indent}`)
+
+/**
+ * chatLanguageModels.json: a JSON-with-comments array of model groups. A key names one Custom Endpoint group (its `name`);
+ * set adds, replaces or removes that one array element and leaves every other byte as it was, so removing a group this
+ * codec added gives the file back exactly. A file that does not parse as such an array is refused.
+ */
+export const languageModelGroups: Codec = {
+  check(text) {
+    try {
+      const root = parseJsonc(text)
+      if (root && root.kind !== "array") return "it is not a list of model groups; left as it is"
+    } catch {
+      return "it is not valid JSON (with comments); left as it is"
+    }
+    return undefined
+  },
+  get(text, key) {
+    const root = parseJsonc(text)
+    if (root?.kind !== "array") return undefined
+    const el = findGroup(root, key)
+    return el ? plain(el) : undefined
+  },
+  set(text, key, value) {
+    const root = parseJsonc(text)
+    const unit = indentUnit(text)
+    if (!root) return value === undefined ? text : `[\n${unit}${render(value, unit, unit)}\n]\n`
+    if (root.kind !== "array") throw new Error("not a list of model groups")
+    const el = findGroup(root, key)
+    if (el && value !== undefined) return text.slice(0, el.start) + render(value, lineIndent(text, el.start) ?? unit, unit) + text.slice(el.end)
+    if (!el && value === undefined) return text
+    if (!el) {
+      const last = root.items[root.items.length - 1]
+      if (!last) {
+        // An empty list: `[]` (VS Code's own empty file) becomes one element on its own lines, closing at the list's indent.
+        const close = lineIndent(text, root.end - 1) ?? ""
+        const inner = text.slice(root.start + 1, root.end - 1)
+        const body = inner.trim() ? `${inner.replace(/\s*$/, "")}\n${close}${unit}` : `\n${close}${unit}`
+        return `${text.slice(0, root.start + 1)}${body}${render(value, close + unit, unit)}\n${close}${text.slice(root.end - 1)}`
+      }
+      const indent = lineIndent(text, last.start) ?? unit
+      return `${text.slice(0, last.end)},\n${indent}${render(value, indent, unit)}${text.slice(last.end)}`
+    }
+    // Remove the element with the comma that joins it to its neighbour.
+    const at = root.items.indexOf(el)
+    const prev = root.items[at - 1]
+    const next = root.items[at + 1]
+    let out: string
+    if (prev) {
+      const gap = text.slice(prev.end, el.start)
+      if (/^\s*,\s*$/.test(gap)) out = text.slice(0, prev.end) + text.slice(el.end)
+      else {
+        // Comments between the two: keep them, drop the comma before this element and the element's own line.
+        const comma = commaBetween(text, prev.end, el.start)
+        const from = lineIndent(text, el.start) !== undefined ? text.lastIndexOf("\n", el.start - 1) : el.start
+        out = text.slice(0, comma) + text.slice(comma + 1, from) + text.slice(el.end)
+      }
+    } else if (next) {
+      const comma = commaBetween(text, el.end, next.start)
+      out = text.slice(0, el.start) + (/^\s*,\s*$/.test(text.slice(el.end, next.start)) ? text.slice(next.start) : text.slice(comma + 1).replace(/^[ \t]*\n?[ \t]*/, ""))
+    } else {
+      const inner = text.slice(root.start + 1, el.start) + text.slice(el.end, root.end - 1)
+      out = text.slice(0, root.start + 1) + (inner.trim() ? inner : "") + text.slice(root.end - 1)
+    }
+    // A file this codec created (one group, "[...]\n") ends empty, so disconnect removes it; VS Code's own "[]" stays.
+    return out === "[]\n" ? "" : out
+  },
+}
+
+function findGroup(root: Extract<Node, { kind: "array" }>, name: string) {
+  let found: Node | undefined
+  for (const it of root.items) {
+    if (it.kind !== "object") continue
+    const v = plain(it) as Json
+    if (v.name === name && v.vendor === VENDOR) found = it
+  }
+  return found
+}
+
+// ---- the connector ------------------------------------------------------------------------------------------------------
+
+export const connectors: Connector[] = [
+  {
+    id: "vscode-copilot",
+    label: "Copilot Chat (VS Code)",
+    file: (home, env) => join(vscodeUserDir(home, env), "chatLanguageModels.json"),
+    probe: [],
+    authHeader: "authorization",
+    edits: (home, s, env) => [
+      {
+        path: join(vscodeUserDir(home, env), "chatLanguageModels.json"),
+        format: "custom",
+        codec: languageModelGroups,
+        holdsKey: true,
+        secretKeys: [GROUP],
+        values: {
+          [GROUP]: {
+            name: GROUP,
+            vendor: VENDOR,
+            apiType: "chat-completions",
+            models: [
+              {
+                id: s.model,
+                name: modelName(s.model),
+                url: `${routeUrl(s)}/v1/chat/completions`,
+                apiType: "chat-completions",
+                toolCalling: true,
+                vision: true,
+                maxInputTokens: MAX_INPUT,
+                maxOutputTokens: MAX_OUTPUT,
+                requestHeaders: { Authorization: `Bearer ${readKey(home)}`, ...(s.contextEdit ? { [EDIT_HEADER]: "on" } : {}) },
+              },
+            ],
+          },
+        },
+      },
+    ],
+    notes: [
+      'In Copilot Chat, open the model picker and choose the model listed under "100xprompt gateway" once; VS Code remembers the choice (brain does not change your default model).',
+      "VS Code keeps a custom model's key in its secret storage, which brain cannot write, so the gateway key is in the model's request headers in chatLanguageModels.json instead; that file is now readable by you only (0600) and is not synced by Settings Sync.",
+      "Needs VS Code 1.122 or later (the Custom Endpoint provider). On Copilot Business or Enterprise, your organization must allow bring-your-own-key models.",
+    ],
+  },
+]

package/src/gateway/connectors/windsurf.ts

@@ -0,0 +1,6 @@
+// Gateway connector for Windsurf (now Devin Desktop): none. Its models are served by Cognition's backend only; the one
+// network setting is an HTTP proxy, and "You cannot point Devin Desktop at your own LLM" (checked 2026-11-10:
+// https://agentgateway.dev/docs/standalone/main/integrations/llm-clients/devin/; docs.windsurf.com now redirects to docs.devin.ai).
+import type { Connector } from "../common.ts"
+
+export const connectors: Connector[] = []

package/src/gateway/connectors/zed.ts

@@ -0,0 +1,29 @@
+// Gateway connector for Zed: NOT BUILT. Zed cannot be given the gateway key through a file brain can write and undo.
+//
+// Checked 2026-11-10 (Zed is not installed on this machine) against the Zed docs and the zed-industries/zed main source:
+//   - https://zed.dev/docs/ai/use-api-access ("OpenAI-Compatible Endpoints", "Anthropic-Compatible Endpoints"): providers
+//     go in settings.json (JSON with comments, ~/.config/zed/settings.json) under `language_models.openai_compatible.<id>`
+//     (`api_url`, `available_models: [{ name, display_name, max_tokens, max_output_tokens, capabilities }]`,
+//     `custom_headers`) or `language_models.anthropic_compatible.<name>`, and the agent's model under `agent.default_model`.
+//     All of that is writable. The key is not: "Enter the API key in the provider settings UI or set the generated
+//     environment variable" (<PROVIDER_ID>_API_KEY, upper snake case), keys saved in Zed "are stored in the system
+//     keychain, not in settings.json", and `custom_headers` cannot carry it ("Headers Zed manages, such as provider
+//     authentication headers, are ignored with a warning").
+//   - crates/language_model/src/api_key.rs (ApiKeyState::load_if_needed): the key comes from the environment variable if it
+//     is set and non-empty, otherwise from the credentials provider (the system keychain) keyed by the API URL
+//     (read_credentials(url)); there is no file or command source.
+//   - crates/language_models/src/provider/open_ai_compatible.rs: OpenAiCompatibleSettings { api_url, available_models,
+//     custom_headers }; requests fail with NoApiKey when neither source has a key.
+//
+// So the key could only reach Zed through (a) the keychain, which brain must not write (and could neither refresh on a new
+// sign-in nor remove on disconnect), or (b) an environment variable in Zed's own launch environment, which means the
+// person's shell profile, not Zed's config, and would expose the key to every process started from that shell.
+//
+// A semi-manual connector was considered and not built: brain could add the provider and default model to settings.json
+// and ask the person to paste the key into Zed's Agent settings. It is not automatic, `connect` would report Zed as
+// connected while it has no key, `disconnect` would leave the key in the keychain, and a new `brain gateway login` would
+// leave Zed on the old key without anyone noticing. Not worth it until the core can mark a connector as needing a manual
+// key step (and status can say whether that step was done).
+import type { Connector } from "../common.ts"
+
+export const connectors: Connector[] = []