@100xprompt/brain 0.0.0-stage → 0.1.1

package/src/gateway/connectors/qwen-code.ts

@@ -0,0 +1,411 @@
+// Gateway connector for Qwen Code (`qwen`), and the comment-keeping JSON editor it (and iflow-cli.ts) writes settings with.
+//
+// Checked against Qwen Code 0.27.0 as installed (~/.cache/brain-wire/qwen-code, @qwen-code/qwen-code; the bundle is
+// minified, so places are named by chunk file, line and function) and its docs
+// (https://qwenlm.github.io/qwen-code-docs/en/users/configuration/model-providers/):
+//   - Config lives in $QWEN_HOME or ~/.qwen (chunks/chunk-5VB4YX3Z.js:3 Storage.getGlobalQwenDir); user settings are
+//     <dir>/settings.json, read as JSON with comments (strip-json-comments then JSON.parse: no trailing commas;
+//     chunks/chunk-E6R76DS6.js:39 loadAndMigrate). Qwen Code writes it back itself keeping comments and the file's mode
+//     (chunks/chunk-6O22NZFU.js:3 updateSettingsFilePreservingFormat, writeWithBackupSync), and adds "$version": 4 to a file
+//     that has none on its first start.
+//   - A custom OpenAI-compatible endpoint is a `modelProviders` entry: { id, name, description, baseUrl, envKey,
+//     generationConfig: { customHeaders } }. A provider id that is not built in is routed by `providerProtocol`
+//     ({ "<id>": "openai" }, Chat Completions unless wireApi says otherwise; chunks/chunk-KUBWE5YV.js:3
+//     resolveProviderProtocol, ModelRegistry). The selected model is `model.name` (+ `model.baseUrl` to tell entries with
+//     the same id apart) under `security.auth.selectedType` "openai". The entry's id, baseUrl and envKey win over
+//     OPENAI_MODEL / OPENAI_BASE_URL / OPENAI_API_KEY (chunks/chunk-576P2HBP.js:2151 resolveModelConfig).
+//   - The key: only ever from the environment variable the entry names (`envKey`); there is no key-file or command
+//     option. The docs recommend ~/.qwen/.env for it, which Qwen Code always loads, also in a project with its own .env
+//     (chunks/chunk-WGMYJOAD.js:3 findEnvFiles pushes the home candidates after a project's). So the key is copied there,
+//     under a name of its own (BRAIN_GATEWAY_KEY, so no OPENAI_API_KEY of the person's is touched), and that file is 0600.
+//   - Custom headers: generationConfig.customHeaders is sent with every request (chunks/chunk-ESPAP3UW.js buildHeaders),
+//     so `x-100x-context-edit: on` goes there.
+// What connect writes: settings.json gets a "brain-gateway" provider ("100xprompt gateway", model shown as its 100xprompt
+// name), its providerProtocol mapping, and the selection (auth type, model.name, model.baseUrl); ~/.qwen/.env gets the
+// key. The person's own providers, models and comments are left as they are; disconnect puts every key back.
+// Needs Qwen Code 0.23 or later (custom provider ids through providerProtocol); older ones skip the provider.
+import { existsSync } from "node:fs"
+import { join } from "node:path"
+import { type Codec, type Connector, EDIT_HEADER, type Env, type GatewaySettings, type Json, modelName, readKey, routeUrl } from "../common.ts"
+
+// ---- JSON with comments, edited in place ----------------------------------------------------------------------------
+//
+// The core's "json" format refuses a file with comments and rewrites the whole file. This codec changes only the bytes of
+// the keys it is given: a new key is added as the last member of its object (in the file's own indentation), a value is
+// replaced where it stands, and a removed key takes away exactly what adding it put there, so disconnect gives back the
+// file byte for byte. Keys are paths with "/" (security/auth/selectedType), like the core's json format; an object that a
+// removal leaves empty is removed too (as the core does), never the root.
+
+interface JObject {
+  t: "object"
+  start: number
+  end: number
+  members: JMember[]
+}
+interface JArray {
+  t: "array"
+  start: number
+  end: number
+  items: JNode[]
+}
+interface JScalar {
+  t: "scalar"
+  start: number
+  end: number
+  value: unknown
+}
+type JNode = JObject | JArray | JScalar
+interface JMember {
+  key: string
+  keyStart: number
+  value: JNode
+  /** Index of the comma after the value, -1 for the last member. */
+  comma: number
+}
+
+class JsoncError extends Error {}
+
+/** Parses JSON with // and /* comments (no trailing commas: the tools' own JSON.parse refuses them). Empty text: no root. */
+function parseJsonc(text: string): { root?: JNode; duplicate: boolean } {
+  let i = text.charCodeAt(0) === 0xfeff ? 1 : 0
+  let duplicate = false
+  const fail = (why: string): never => {
+    throw new JsoncError(`${why} at offset ${i}`)
+  }
+  const skip = () => {
+    for (;;) {
+      const c = text[i]
+      if (c === " " || c === "\t" || c === "\n" || c === "\r") i++
+      else if (c === "/" && text[i + 1] === "/") {
+        const n = text.indexOf("\n", i)
+        i = n < 0 ? text.length : n
+      } else if (c === "/" && text[i + 1] === "*") {
+        const n = text.indexOf("*/", i + 2)
+        if (n < 0) fail("unclosed comment")
+        i = n + 2
+      } else return
+    }
+  }
+  const str = (): string => {
+    const s = i++
+    while (i < text.length && text[i] !== '"') {
+      if (text[i] === "\\") i++
+      i++
+    }
+    if (i >= text.length) fail("unclosed string")
+    i++
+    try {
+      return JSON.parse(text.slice(s, i)) as string
+    } catch {
+      return fail("bad string")
+    }
+  }
+  const value = (): JNode => {
+    skip()
+    const s = i
+    const c = text[i]
+    if (c === "{") {
+      i++
+      const members: JMember[] = []
+      const seen = new Set<string>()
+      skip()
+      if (text[i] === "}") return { t: "object", start: s, end: ++i, members }
+      for (;;) {
+        skip()
+        if (text[i] !== '"') fail("expected a key")
+        const keyStart = i
+        const key = str()
+        if (seen.has(key)) duplicate = true
+        seen.add(key)
+        skip()
+        if (text[i] !== ":") fail("expected ':'")
+        i++
+        const v = value()
+        skip()
+        if (text[i] === ",") {
+          members.push({ key, keyStart, value: v, comma: i++ })
+          continue
+        }
+        if (text[i] === "}") {
+          members.push({ key, keyStart, value: v, comma: -1 })
+          return { t: "object", start: s, end: ++i, members }
+        }
+        fail("expected ',' or '}'")
+      }
+    }
+    if (c === "[") {
+      i++
+      const items: JNode[] = []
+      skip()
+      if (text[i] === "]") return { t: "array", start: s, end: ++i, items }
+      for (;;) {
+        items.push(value())
+        skip()
+        if (text[i] === ",") {
+          i++
+          continue
+        }
+        if (text[i] === "]") return { t: "array", start: s, end: ++i, items }
+        fail("expected ',' or ']'")
+      }
+    }
+    if (c === '"') return { t: "scalar", start: s, value: str(), end: i }
+    const lit = /true|false|null|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/y
+    lit.lastIndex = i
+    const m = lit.exec(text)
+    if (!m) return fail("unexpected character")
+    i += m[0].length
+    return { t: "scalar", start: s, end: i, value: JSON.parse(m[0]) }
+  }
+  skip()
+  if (i >= text.length) return { duplicate }
+  const root = value()
+  skip()
+  if (i < text.length) fail("unexpected text after the end")
+  return { root, duplicate }
+}
+
+const valueOf = (n: JNode): unknown =>
+  n.t === "scalar" ? n.value : n.t === "array" ? n.items.map(valueOf) : Object.fromEntries(n.members.map((m) => [m.key, valueOf(m.value)]))
+
+/** The member called `key` (the last one, as JSON.parse would take it). */
+const memberOf = (o: JObject, key: string) => [...o.members].reverse().find((m) => m.key === key)
+
+/** Walks `path` from the root: the objects passed through, and the member at the end if it is there. */
+function walk(root: JObject, path: string[]): { chain: Array<{ obj: JObject; member?: JMember }> } {
+  const chain: Array<{ obj: JObject; member?: JMember }> = []
+  let obj: JObject | undefined = root
+  for (const p of path) {
+    if (!obj) break
+    const member: JMember | undefined = memberOf(obj, p)
+    chain.push({ obj, ...(member ? { member } : {}) })
+    obj = member?.value.t === "object" ? member.value : undefined
+  }
+  return { chain }
+}
+
+function editor(text: string) {
+  const nl = text.includes("\r\n") ? "\r\n" : "\n"
+  const lineStart = (pos: number) => text.lastIndexOf("\n", pos - 1) + 1
+  const indentAt = (pos: number) => /^[ \t]*/.exec(text.slice(lineStart(pos)))![0]
+  /** Only spaces or tabs (or the BOM) between the start of its line and `pos`. */
+  const ownLine = (pos: number) => /^[ \t\uFEFF]*$/.test(text.slice(lineStart(pos), pos))
+  /** Where the line that `pos` is on ends (the \r of \r\n, or the \n), skipping comments; -1 when `limit` comes first. */
+  const lineEnd = (pos: number, limit: number) => {
+    for (let j = pos; j < limit; j++) {
+      if (text[j] === "\n") return text[j - 1] === "\r" ? j - 1 : j
+      if (text[j] === "/" && text[j + 1] === "/") {
+        const n = text.indexOf("\n", j)
+        return n < 0 ? -1 : text[n - 1] === "\r" ? n - 1 : n
+      }
+      if (text[j] === "/" && text[j + 1] === "*") {
+        const close = text.indexOf("*/", j + 2)
+        if (close < 0) return -1
+        j = close + 1
+      }
+    }
+    return -1
+  }
+  const lineBreakLen = (at: number) => (text[at] === "\r" ? 2 : 1)
+  const blank = (s: string) => /^[ \t\r]*$/.test(s)
+  return { nl, lineStart, indentAt, ownLine, lineEnd, lineBreakLen, blank }
+}
+
+/** One indentation step as the file uses it (the root's first member on a line of its own), else two spaces. */
+function indentUnit(text: string, root: JObject): string {
+  const first = root.members[0]
+  if (!first) return "  "
+  const e = editor(text)
+  return e.ownLine(first.keyStart) ? e.indentAt(first.keyStart) || "  " : "  "
+}
+
+const splice = (text: string, from: number, to: number, put: string) => text.slice(0, from) + put + text.slice(to)
+
+/** `value` as JSON, indented to sit at `indent`. */
+const render = (value: unknown, indent: string, unit: string, nl: string) => JSON.stringify(value, null, unit).split("\n").join(nl + indent)
+
+/** Adds `key: value` as the last member of `obj`. */
+function insertMember(text: string, obj: JObject, key: string, value: unknown, unit: string): string {
+  const e = editor(text)
+  const first = obj.members[0]
+  const indent = first && e.ownLine(first.keyStart) ? e.indentAt(first.keyStart) : e.indentAt(obj.start) + unit
+  const entry = `${JSON.stringify(key)}: ${render(value, indent, unit, e.nl)}`
+  const last = obj.members[obj.members.length - 1]
+  if (!last) {
+    const inner = text.slice(obj.start + 1, obj.end - 1)
+    if (!inner.trim()) return splice(text, obj.start + 1, obj.end - 1, `${e.nl}${indent}${entry}${e.nl}${e.indentAt(obj.start)}`)
+    return splice(text, obj.start + 1, obj.start + 1, `${e.nl}${indent}${entry}`)
+  }
+  const at = e.lineEnd(last.value.end, obj.end - 1)
+  // The closing brace on the same line as the last value: an inline object, so the member goes inline too.
+  if (at < 0) return splice(text, last.value.end, last.value.end, `, ${JSON.stringify(key)}: ${JSON.stringify(value)}`)
+  const withEntry = splice(text, at, at, `${e.nl}${indent}${entry}`)
+  return splice(withEntry, last.value.end, last.value.end, ",")
+}
+
+/** Removes `m` from `obj`, taking away what insertMember put there (and, for a member it did not add, as little as can be). */
+function removeMember(text: string, obj: JObject, m: JMember): string {
+  const e = editor(text)
+  const ms = obj.members
+  const idx = ms.indexOf(m)
+  if (ms.length === 1) {
+    const before = text.slice(obj.start + 1, m.keyStart)
+    const after = text.slice(m.value.end, obj.end - 1)
+    if (!before.trim() && !after.trim()) return splice(text, obj.start + 1, obj.end - 1, "")
+    if (!before.trim()) return splice(text, obj.start + 1, m.value.end, "")
+    return splice(text, m.keyStart, m.value.end, "")
+  }
+  if (idx < ms.length - 1) {
+    const next = ms[idx + 1]!
+    const end = e.lineEnd(m.comma + 1, next.keyStart)
+    // On lines of its own, nothing after its comma: those lines go, with one line break.
+    if (e.ownLine(m.keyStart) && end >= 0 && e.blank(text.slice(m.comma + 1, end))) return splice(text, e.lineStart(m.keyStart), end + e.lineBreakLen(end), "")
+    // The next member on the same line: up to it.
+    if (end < 0) return splice(text, m.keyStart, next.keyStart, "")
+    return splice(text, m.keyStart, m.comma + 1, "")
+  }
+  // The last member: it goes from the line break before it (or the spaces before it), and the comma before it goes too.
+  const prev = ms[idx - 1]!
+  let from = m.keyStart
+  if (e.ownLine(m.keyStart) && e.lineStart(m.keyStart) > prev.comma + 1) {
+    from = e.lineStart(m.keyStart) - 1
+    if (text[from - 1] === "\r") from--
+  } else while (from > prev.comma + 1 && /[ \t]/.test(text[from - 1]!)) from--
+  return splice(splice(text, from, m.value.end, ""), prev.comma, prev.comma + 1, "")
+}
+
+/** `text` with the value at `key` (a "/" path) set to `value`, or removed when `value` is undefined. */
+function setPath(text: string, key: string, value: unknown): string {
+  const path = key.split("/")
+  // An empty (or missing) file starts as an empty object.
+  const src = text.trim() ? text : "{}\n"
+  const { root } = parseJsonc(src)
+  if (!root || root.t !== "object") throw new JsoncError("not a JSON object")
+  const unit = indentUnit(src, root)
+  const { chain } = walk(root, path)
+  if (value === undefined) {
+    const last = chain[path.length - 1]
+    if (chain.length < path.length || !last?.member) return text
+    let out = removeMember(src, last.obj, last.member)
+    // Objects this removal left empty go too (never the root).
+    for (let depth = path.length - 1; depth >= 1; depth--) {
+      const r = parseJsonc(out).root as JObject
+      const c = walk(r, path.slice(0, depth)).chain[depth - 1]
+      const holder = c?.member
+      if (!holder || holder.value.t !== "object" || holder.value.members.length) break
+      out = removeMember(out, c.obj, holder)
+    }
+    return out
+  }
+  // Down the path: the first part that is missing (or not an object) gets the rest of the path as a new value.
+  for (let d = 0; d < path.length; d++) {
+    const step = chain[d]!
+    const rest = path.slice(d + 1).reduceRight<unknown>((v, p) => ({ [p]: v }), value)
+    if (!step.member) return insertMember(src, step.obj, path[d]!, rest, unit)
+    if (d === path.length - 1 || step.member.value.t !== "object") {
+      const e = editor(src)
+      return splice(src, step.member.value.start, step.member.value.end, render(rest, e.indentAt(step.member.keyStart), unit, e.nl))
+    }
+  }
+  return src
+}
+
+/**
+ * A codec for a JSON settings file that may have comments (Qwen Code, iFlow CLI and the other Gemini CLI forks read theirs
+ * through strip-json-comments). `objects`: paths that must be objects where the file has them (an older layout where one
+ * is a string is refused, rather than replaced).
+ */
+export function jsonc(objects: string[] = []): Codec {
+  return {
+    check(text) {
+      if (!text.trim()) return undefined
+      let parsed: ReturnType<typeof parseJsonc>
+      try {
+        parsed = parseJsonc(text)
+      } catch {
+        return "it is not valid JSON (comments are fine, trailing commas are not); left as it is"
+      }
+      if (parsed.root?.t !== "object") return "it is not a JSON object; left as it is"
+      if (parsed.duplicate) return "it has the same key twice in one object; left as it is"
+      const v = valueOf(parsed.root) as Json
+      for (const path of objects) {
+        let cur: unknown = v
+        for (const p of path.split("/")) {
+          if (!cur || typeof cur !== "object" || Array.isArray(cur)) break
+          cur = (cur as Json)[p]
+          if (cur !== undefined && (typeof cur !== "object" || cur === null || Array.isArray(cur)))
+            return `its "${path.replace(/\//g, ".")}" setting is not an object (an older settings layout?); start the tool once so it updates the file, then connect`
+        }
+      }
+      return undefined
+    },
+    get(text, key) {
+      if (!text.trim()) return undefined
+      const { root } = parseJsonc(text)
+      if (root?.t !== "object") return undefined
+      let cur: unknown = valueOf(root)
+      for (const p of key.split("/")) {
+        if (!cur || typeof cur !== "object" || Array.isArray(cur) || !(p in (cur as Json))) return undefined
+        cur = (cur as Json)[p]
+      }
+      return cur
+    },
+    set: setPath,
+  }
+}
+
+// ---- Qwen Code --------------------------------------------------------------------------------------------------------
+
+/** The variable the provider entry reads its key from, set in <dir>/.env. */
+export const QWEN_KEY_VAR = "BRAIN_GATEWAY_KEY"
+const PROVIDER = "brain-gateway"
+
+/** $QWEN_HOME (as Qwen Code resolves it: ~ expanded, used when it exists here) or ~/.qwen. */
+export function qwenDir(home: string, env: Env): string {
+  const raw = env.QWEN_HOME?.trim()
+  if (raw) {
+    const p = raw === "~" ? home : raw.startsWith("~/") ? join(home, raw.slice(2)) : raw
+    if (p.startsWith("/") && existsSync(p)) return p
+  }
+  return join(home, ".qwen")
+}
+
+const base = (s: GatewaySettings) => `${routeUrl(s)}/v1`
+
+export const connectors: Connector[] = [
+  {
+    id: "qwen-code",
+    label: "Qwen Code",
+    file: (home, env) => join(qwenDir(home, env), "settings.json"),
+    probe: [".qwen"],
+    authHeader: "authorization",
+    edits: (home, s, env) => [
+      {
+        path: join(qwenDir(home, env), "settings.json"),
+        format: "custom",
+        codec: jsonc(["modelProviders", "providerProtocol", "security", "security/auth", "model"]),
+        values: {
+          [`modelProviders/${PROVIDER}`]: [
+            {
+              id: s.model,
+              name: modelName(s.model),
+              description: "100xprompt gateway",
+              baseUrl: base(s),
+              envKey: QWEN_KEY_VAR,
+              ...(s.contextEdit ? { generationConfig: { customHeaders: { [EDIT_HEADER]: "on" } } } : {}),
+            },
+          ],
+          [`providerProtocol/${PROVIDER}`]: "openai",
+          "security/auth/selectedType": "openai",
+          "model/name": s.model,
+          "model/baseUrl": base(s),
+        },
+      },
+      { path: join(qwenDir(home, env), ".env"), format: "dotenv", holdsKey: true, secretKeys: [QWEN_KEY_VAR], values: { [QWEN_KEY_VAR]: readKey(home) } },
+    ],
+    notes: [
+      `Qwen Code reads the key from ~/.qwen/.env (${QWEN_KEY_VAR}; it has no key-file option), so that file is now readable by you only (0600). settings.json gets a "100xprompt gateway" provider, made the default, with its sign-in set to OpenAI-compatible; your own providers stay listed in /model.`,
+      "Needs Qwen Code 0.23 or later. A project's own .qwen/settings.json that sets modelProviders or model takes precedence in that project.",
+    ],
+  },
+]

package/src/gateway/connectors/roo.ts

@@ -0,0 +1,43 @@
+// Gateway connector for Roo Code (the VS Code extension rooveterinaryinc.roo-cline): NOT BUILT. Roo can be pointed at the
+// gateway only through its own storage, which a disconnect cannot undo.
+//
+// Checked against Roo Code 3.38.1 (~/.vscode/extensions/rooveterinaryinc.roo-cline-3.38.1: package.json, package.nls.json,
+// dist/extension.js) and 3.54.0 (the official bundle in ~/.cache/brain-wire/roo/roo-cli-darwin-arm64/extension, run by the
+// wire harness), and shown with the real 3.54.0 bundle by scripts/gateway-real/roo.ts.
+//
+// Where Roo keeps a provider: as a "provider profile" (apiProvider "openai" takes an OpenAI-compatible openAiBaseUrl,
+// openAiApiKey, openAiModelId and openAiHeaders, so the gateway and the x-100x-context-edit header would both work). The
+// profile list, keys included, is one entry of VS Code's SecretStorage (roo_cline_config_api_config: the OS keychain in
+// VS Code), and the active profile's settings are in VS Code's extension state (globalState) with its key in SecretStorage
+// again (openAiApiKey). No file brain can write, and nothing reads a key from a file or a command.
+//
+// The one file-based way in: the VS Code setting roo-cline.autoImportSettingsPath (3.38.1 package.json:374; package.nls.json:39
+// "Path to a RooCode configuration file to automatically import on extension startup"). On every activation Roo reads that
+// file ({"providerProfiles": {"currentApiConfigName", "apiConfigs"}, "globalSettings"?}) and imports it (extension.js:
+// the auto-import at activation, then importSettingsFromPath): the imported profiles are merged into the profile list,
+// the imported current profile becomes Roo's current one, its settings become the active provider, and every key is
+// stored in SecretStorage. So a connector could write such a file (0600, it holds the key) and the setting in VS Code's
+// settings.json, and Roo would talk to the gateway from its next start.
+//
+// Why that is not safe: removing the setting and the file (all a disconnect can do) undoes nothing inside Roo. The import
+// only ever adds; Roo keeps the "100xprompt gateway" profile, keeps it selected, and keeps the gateway key in the keychain.
+// scripts/gateway-real/roo.ts shows it with the real 3.54.0 bundle: after the import the profiles are ["default",
+// "100xprompt gateway"], current "100xprompt gateway", active provider openai at the gateway URL, the key in SecretStorage;
+// after the setting and the file are removed and Roo starts again, all of that is still there. So:
+//   - after `brain gateway disconnect --tool roo` Roo would go on sending every request to the gateway, billed to the
+//     100xprompt account, while brain reports it disconnected;
+//   - a key copy in the keychain cannot be refreshed by a new sign-in or removed by brain (logout's "disconnect removes the
+//     copy" would be false);
+//   - the person's own profile is not restored: they would have to open Roo's settings, pick their profile again and
+//     delete "100xprompt gateway" by hand, and the import cannot do that for them (it cannot delete a profile, and it
+//     can only select one it brings along, with its key).
+// Writing the profile into SecretStorage or state.vscdb directly would be worse (the keychain, and VS Code's own database
+// while it may be running). By hand, a person can add an "OpenAI Compatible" profile in Roo's settings with the gateway's
+// <route>/v1 address and the key, and remove it there again.
+//
+// What would make a connector possible: a Roo setting or file that is read, not imported (a provider from a file each
+// time, as Kilo Code 7 and OpenCode do), or an import that can remove what it brought. Kilo Code 7 is no longer built on
+// Roo and is connected through the Kilo CLI's config (kilo-code.ts).
+import type { Connector } from "../common.ts"
+
+export const connectors: Connector[] = []

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

@@ -0,0 +1,6 @@
+// Gateway connector for Tabnine CLI: none. It uses only models served by the Tabnine host (custom endpoints are an admin's
+// self-managed models on that host, not a client setting), and the CLI only gets critical fixes until 2026-12-31
+// (https://docs.tabnine.com/main/getting-started/tabnine-cli/features/model-selection).
+import type { Connector } from "../common.ts"
+
+export const connectors: Connector[] = []

package/src/gateway/connectors/void.ts

@@ -0,0 +1,6 @@
+// Gateway connector for Void: none. Void can use any OpenAI-compatible endpoint, but its provider settings are kept only
+// encrypted (OS keychain) in the app's state database (voidSettingsService.ts:351-365, key 'void.settingsServiceStorageII');
+// the project is archived and deprecated (https://github.com/voideditor/void).
+import type { Connector } from "../common.ts"
+
+export const connectors: Connector[] = []