@100xprompt/brain 0.1.5 → 0.1.6

package/src/gateway/connectors/claude-desktop.ts

@@ -0,0 +1,169 @@
+// Gateway connector for Claude Desktop (macOS): its own third-party mode, "Claude (third-party)", pointed at the gateway.
+//
+// Checked 2026-11-11 in Claude 4.23118.0 (app.asar, read only), and with the app's bundled Claude Code (2.1.317) against
+// the gateway's code:
+//   - Signed in with a Claude account the app talks to Anthropic only, and sets ANTHROPIC_BASE_URL for its Claude Code
+//     itself (so Claude Code's own settings do not move it).
+//   - Its third-party mode takes a gateway ("Configure Third-Party Inference…", or an admin's managed preferences): a
+//     config library in ~/Library/Application Support/Claude-3p/configLibrary, `_meta.json` ({appliedId, entries:
+//     [{id, name}]}) naming the applied `<id>.json`, whose flat keys are the settings: inferenceProvider "gateway",
+//     inferenceGatewayBaseUrl, inferenceCredentialKind "helper-script" + inferenceCredentialHelper (a program that prints
+//     the key; the app caches it for inferenceCredentialHelperTtlSec), inferenceGatewayAuthScheme "bearer",
+//     modelDiscoveryEnabled, inferenceModels ([{name, labelOverride, supports1m, prefer1m, anthropicFamilyTier}]),
+//     inferenceCustomHeaders ({name: value}).
+//   - The app gives its Claude Code ANTHROPIC_BASE_URL = the gateway, ANTHROPIC_AUTH_TOKEN = the helper's output and
+//     the model's name; Claude Code posts the Messages API to <base>/v1/messages, which the gateway's routes serve.
+//   - A model's name must read as an Anthropic model (contain claude, opus, sonnet, haiku or anthropic; never gemini and
+//     the like): so `anthropic/100x-pro` and `anthropic/100x-flash` (the gateway serves a name with "pro" as Pro and any
+//     other as Flash; the auto route serves any name), shown in the menu by their 100xprompt names (labelOverride). With
+//     "[1m]" (supports1m) Claude Code takes the 1M window the models have.
+//   - Third-party mode is a separate profile (its own sessions and settings, in Claude-3p). The app starts in it when a
+//     third-party configuration is applied and the person has not chosen their Claude account there; signing in with the
+//     Claude account again goes back.
+// brain writes its own entry (a fixed id) and applies it; the key never goes into the app's files: the helper reads it
+// from brain's key file each time the app asks.
+import { join } from "node:path"
+import { savedMode } from "../../adapters/claude-desktop/records.ts"
+import { AUTO_MODEL, brainDir, EDIT_HEADER, isAuto, keyPath, routeUrl, type Codec, type Connector } from "../common.ts"
+
+/** brain's entry in the app's config library (a UUID, as the app requires). */
+export const ENTRY_ID = "b7a1e0c0-0100-4000-8000-000000000100"
+const ENTRY_NAME = "100xprompt"
+const MARK = "brain-claude-desktop-key"
+
+export const thirdPartyDir = (home: string) => join(home, "Library", "Application Support", "Claude-3p")
+const libraryDir = (home: string) => join(thirdPartyDir(home), "configLibrary")
+export const metaPath = (home: string) => join(libraryDir(home), "_meta.json")
+export const entryPath = (home: string) => join(libraryDir(home), `${ENTRY_ID}.json`)
+export const helperPath = (home: string) => join(brainDir(home), "bin", "claude-desktop-key")
+
+/** The names the app sends; the gateway serves a name with "pro" as Pro, any other as Flash, and the auto route any. */
+const PRO = { name: "anthropic/100x-pro", labelOverride: "100xprompt Pro", supports1m: true, prefer1m: true, anthropicFamilyTier: "sonnet" }
+const FLASH = { name: "anthropic/100x-flash", labelOverride: "100xprompt Flash", supports1m: true, prefer1m: true, anthropicFamilyTier: "haiku" }
+const AUTO = { name: `anthropic/${AUTO_MODEL}`, labelOverride: "100xprompt Auto", supports1m: true, prefer1m: true, anthropicFamilyTier: "sonnet" }
+
+/** The helper the app runs for the key: it prints the first line of brain's key file. No key in it. */
+export function helperText(v: { keyFile: string }): string {
+  const sq = (s: string) => `'${s.replace(/'/g, `'\\''`)}'`
+  return [
+    "#!/bin/sh",
+    `# ${MARK} ${JSON.stringify(v)}`,
+    "# Prints the 100xprompt gateway key for Claude Desktop's third-party mode (its credential helper). Written by",
+    "# `brain gateway connect --tool claude-desktop`; undo with `brain gateway disconnect --tool claude-desktop`.",
+    `exec head -n 1 ${sq(v.keyFile)}`,
+    "",
+  ].join("\n")
+}
+
+/** The helper script, which brain writes whole; anyone else's file there is left alone. */
+const helperCodec: Codec = {
+  check(text) {
+    return text.trim() && !text.includes(MARK) ? "it is not brain's key helper; left as it is" : undefined
+  },
+  get(text, key) {
+    if (key !== "helper") return undefined
+    const m = new RegExp(`${MARK} (\\{.*\\})`).exec(text)
+    try {
+      return m ? JSON.parse(m[1]!) : undefined
+    } catch {
+      return undefined
+    }
+  },
+  set(_text, key, value) {
+    if (key !== "helper") throw new Error(`unknown helper key ${key}`)
+    return value === undefined ? "" : helperText(value as { keyFile: string })
+  },
+}
+
+type Meta = { appliedId: string; entries: Array<{ id: string; name: string; [k: string]: unknown }>; [k: string]: unknown }
+const parseMeta = (text: string): Meta => {
+  if (!text.trim()) return { appliedId: "", entries: [] }
+  const j = JSON.parse(text)
+  return { ...j, appliedId: typeof j.appliedId === "string" ? j.appliedId : "", entries: Array.isArray(j.entries) ? j.entries : [] }
+}
+
+/**
+ * The config library's list (`_meta.json`): brain's entry in it ("entry") and which entry is applied ("appliedId"). The
+ * person's own entries and anything else the app keeps there are left as they are. A list left with nothing in it is
+ * written empty, so a disconnect takes away a file only connect made.
+ */
+const metaCodec: Codec = {
+  check(text) {
+    if (!text.trim()) return undefined
+    try {
+      const j = JSON.parse(text)
+      if (!j || typeof j !== "object" || Array.isArray(j) || (j.entries !== undefined && !Array.isArray(j.entries))) return "it is not the app's config list; left as it is"
+    } catch {
+      return "it is not valid JSON; left as it is"
+    }
+    return undefined
+  },
+  get(text, key) {
+    const m = parseMeta(text)
+    // brain's entry by its id alone: renamed in the app, it is still brain's (and goes with brain's file at disconnect).
+    if (key === "entry") return m.entries.some((e) => e?.id === ENTRY_ID) ? { id: ENTRY_ID, name: ENTRY_NAME } : undefined
+    if (key === "appliedId") return text.trim() ? m.appliedId : undefined
+    return undefined
+  },
+  set(text, key, value) {
+    const m = parseMeta(text)
+    if (key === "entry") {
+      const at = m.entries.findIndex((e) => e?.id === ENTRY_ID)
+      if (value === undefined) {
+        if (at >= 0) m.entries.splice(at, 1)
+      } else if (at >= 0) m.entries[at] = value as Meta["entries"][number]
+      else m.entries.push(value as Meta["entries"][number])
+    } else if (key === "appliedId") {
+      // Never an id the list no longer has (the person deleted that configuration in the app meanwhile).
+      const id = typeof value === "string" ? value : ""
+      m.appliedId = id && m.entries.some((e) => e?.id === id) ? id : ""
+    }
+    else throw new Error(`unknown config list key ${key}`)
+    const rest = Object.keys(m).filter((k) => k !== "appliedId" && k !== "entries")
+    if (!m.entries.length && !m.appliedId && !rest.length) return ""
+    return `${JSON.stringify(m, null, 2)}\n`
+  },
+}
+
+const claudeDesktop: Connector = {
+  id: "claude-desktop",
+  label: "Claude Desktop",
+  file: (home) => entryPath(home),
+  probe: ["Library/Application Support/Claude"],
+  authHeader: "authorization",
+  edits: (home, s) => {
+    const auto = isAuto(s)
+    // The model the person chose comes first: the app starts a session on the first in the list.
+    const models = auto ? [AUTO] : s.model === "gemini-3.7-flash" ? [FLASH, PRO] : [PRO, FLASH]
+    return [
+      { path: helperPath(home), format: "custom", codec: helperCodec, values: { helper: { keyFile: keyPath(home) } }, mode: 0o700 },
+      {
+        path: entryPath(home),
+        format: "json",
+        values: {
+          inferenceProvider: "gateway",
+          inferenceGatewayBaseUrl: routeUrl(s),
+          inferenceGatewayAuthScheme: "bearer",
+          inferenceCredentialKind: "helper-script",
+          inferenceCredentialHelper: helperPath(home),
+          inferenceCredentialHelperTtlSec: 3600,
+          modelDiscoveryEnabled: false,
+          inferenceModels: models,
+          ...(s.contextEdit ? { inferenceCustomHeaders: { [EDIT_HEADER]: "on" } } : {}),
+        },
+      },
+      { path: metaPath(home), format: "custom", codec: metaCodec, values: { entry: { id: ENTRY_ID, name: ENTRY_NAME }, appliedId: ENTRY_ID } },
+    ]
+  },
+  notesHere: (home) =>
+    savedMode(home) === "1p"
+      ? ["Claude Desktop is set to start on your Claude account (you chose it in the app), so it keeps doing that: to use 100xprompt, choose Configure Third-Party Inference… in Claude's menu and switch to it there."]
+      : [],
+  notes: [
+    "this sets up Claude Desktop's third-party mode, \"Claude (third-party)\": a separate profile with its own sessions, on 100xprompt's models (shown as 100xprompt Pro and Flash, or Auto). Your Claude account's sessions stay where they are.",
+    "quit Claude and open it again: it starts in third-party mode. To go back to your Claude account, sign in with it again in the app; `brain gateway disconnect --tool claude-desktop` takes the setup away.",
+    "the key is read from brain's key file each time the app asks (its credential helper); it is not written into the app's files.",
+  ],
+}
+
+export const connectors: Connector[] = process.platform === "darwin" ? [claudeDesktop] : []

package/src/gateway/connectors/index.ts

@@ -31,6 +31,7 @@ import { connectors as c_cursor_cli } from "./cursor-cli.ts"
 import { connectors as c_copilot_cli } from "./copilot-cli.ts"
 import { connectors as c_windsurf } from "./windsurf.ts"
 import { connectors as c_antigravity } from "./antigravity.ts"
+import { connectors as c_claude_desktop } from "./claude-desktop.ts"
 import { connectors as c_amazon_q_cli } from "./amazon-q-cli.ts"
 import { connectors as c_amazon_q_ide } from "./amazon-q-ide.ts"
 import { connectors as c_kiro_cli } from "./kiro-cli.ts"
@@ -73,6 +74,7 @@ export const EXTRA_CONNECTORS: Connector[] = [
   ...c_copilot_cli,
   ...c_windsurf,
   ...c_antigravity,
+  ...c_claude_desktop,
   ...c_amazon_q_cli,
   ...c_amazon_q_ide,
   ...c_kiro_cli,

package/src/handoff.ts

@@ -72,12 +72,28 @@ function sameProject(h: Handoff, cwd: string, gitRemote?: string): boolean {
 const claimPath = (home: string, id: string, tool: string) => join(handoffDir(home), `${id}.${tool}.claimed`)
 
 /** The newest unexpired handoff for this project that `tool` has not received yet. */
-export function findHandoff(home: string, q: { cwd: string; tool: string; gitRemote?: string; now?: number }): Handoff | undefined {
+/**
+ * Desktop apps that run a CLI's session-start hook (the same agent inside): a brief for the app is delivered by that hook.
+ * Claude Desktop's Code tab runs Claude Code's hooks; the Codex app runs Codex's.
+ */
+export const HOOK_TOOL: Record<string, string> = { "claude-desktop": "claude-code", "codex-desktop": "codex" }
+
+/**
+ * Whether the hook running is the desktop app's (its Claude Code says so in CLAUDE_CODE_ENTRYPOINT: "claude-desktop",
+ * "claude-desktop-3p"). The Codex app's hook cannot be told from the CLI's, so a brief for the Codex app goes to either.
+ */
+export const fromDesktopApp = (target: string, env: Record<string, string | undefined> = process.env) =>
+  target !== "claude-desktop" || /^claude-desktop/.test(env.CLAUDE_CODE_ENTRYPOINT ?? "")
+
+export function findHandoff(
+  home: string,
+  q: { cwd: string; tool: string; gitRemote?: string; now?: number; env?: Record<string, string | undefined> },
+): Handoff | undefined {
   const now = q.now ?? Date.now()
   return listHandoffs(home).find(
     (h) =>
       Date.parse(h.expiresAt) > now &&
-      (h.target === q.tool || h.target === "any") &&
+      (h.target === q.tool || h.target === "any" || (HOOK_TOOL[h.target] === q.tool && fromDesktopApp(h.target, q.env))) &&
       !h.consumedBy.includes(q.tool) &&
       !existsSync(claimPath(home, h.id, q.tool)) &&
       sameProject(h, q.cwd, q.gitRemote),

package/src/hooks.ts

@@ -3,7 +3,7 @@ import { copyFileSync, existsSync, mkdirSync, readFileSync, realpathSync, statSy
 import { dirname, join } from "node:path"
 import { toolLabel } from "./brief.ts"
 import { gitInfo, isDir, writeAtomic } from "./fsutil.ts"
-import { findHandoff, type Handoff, markConsumed } from "./handoff.ts"
+import { findHandoff, type Handoff, HOOK_TOOL, markConsumed } from "./handoff.ts"
 import { syncInBackground } from "./memory/sync.ts"
 import { withBrainLock } from "./lock.ts"
 
@@ -150,7 +150,7 @@ function tomlHasHooks(toml: string): boolean {
 }
 
 /** "cursor" is what `continue --in` calls Cursor; its handoffs are recorded for "cursor-ide". */
-const toolId = (tool: string) => (tool === "cursor" ? "cursor-ide" : tool)
+const toolId = (tool: string) => (tool === "cursor" ? "cursor-ide" : HOOK_TOOL[tool] ?? tool)
 
 const sh = (s: string) => (/^[\w@%+=:,./-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`)
 

package/src/memory/mcp-install.ts

@@ -31,6 +31,11 @@ export interface McpTool {
 
 const plain = (command: string, args: string[]): Json => ({ command, args })
 
+/** The Claude app's folder, from home (its own MCP settings, claude_desktop_config.json, are there). */
+function claudeDesktopDir(): string {
+  return process.platform === "darwin" ? "Library/Application Support/Claude" : process.platform === "win32" ? "AppData/Roaming/Claude" : ".config/Claude"
+}
+
 function vscodeUser(): string {
   return process.platform === "darwin" ? "Library/Application Support/Code/User" : process.platform === "win32" ? "AppData/Roaming/Code/User" : ".config/Code/User"
 }
@@ -38,7 +43,11 @@ function vscodeUser(): string {
 export const MCP_TOOLS: McpTool[] = [
   { id: "claude-code", label: "Claude Code", file: ".claude.json", probe: [".claude.json", ".claude"], format: "json", key: "mcpServers", entry: plain },
   { id: "codex", label: "Codex", file: ".codex/config.toml", probe: [".codex"], format: "toml" },
+  // Claude Desktop: its chats and its Code tab's local tools.
+  { id: "claude-desktop", label: "Claude Desktop", file: `${claudeDesktopDir()}/claude_desktop_config.json`, probe: [`${claudeDesktopDir()}/claude_desktop_config.json`, claudeDesktopDir()], format: "json", key: "mcpServers", entry: plain },
   { id: "cursor", label: "Cursor", file: ".cursor/mcp.json", probe: [".cursor"], format: "json", key: "mcpServers", entry: plain },
+  // Antigravity (Google): its agent's MCP servers.
+  { id: "antigravity", label: "Antigravity", file: ".gemini/antigravity/mcp_config.json", probe: [".gemini/antigravity/mcp_config.json", ".gemini/antigravity"], format: "json", key: "mcpServers", entry: plain },
   { id: "gemini", label: "Gemini CLI", file: ".gemini/settings.json", probe: [".gemini"], format: "json", key: "mcpServers", entry: plain },
   {
     id: "opencode",

package/src/memory/sync.ts

@@ -5,6 +5,7 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs"
 import { join } from "node:path"
 import { gitInfo } from "../fsutil.ts"
+import type { SessionRef } from "../adapters/types.ts"
 import type { Session } from "../session/types.ts"
 import { distill } from "./distill.ts"
 import { projectKey } from "./project.ts"
@@ -17,6 +18,8 @@ export interface SessionSource {
   id: string
   cwd?: string
   updatedAt?: string
+  /** Ids the same session was listed under before (a desktop app's session that brain once listed as its CLI's). */
+  formerIds?: string[]
   read(): Promise<Session>
 }
 
@@ -104,7 +107,20 @@ async function defaultSessions(home: string): Promise<SessionSource[]> {
   const lists = await Promise.all(READERS.map((r) => r.list(home).then((refs) => refs.map((ref) => ({ r, ref }))).catch(() => [])))
   return lists
     .flat()
-    .map(({ r, ref }) => ({ id: `${ref.tool}:${ref.sourceId}`, ...(ref.cwd ? { cwd: ref.cwd } : {}), ...(ref.updatedAt ? { updatedAt: ref.updatedAt } : {}), read: () => r.read(ref, home) }))
+    .map(({ r, ref }) => {
+      const former = formerIds(ref)
+      return { id: `${ref.tool}:${ref.sourceId}`, ...(ref.cwd ? { cwd: ref.cwd } : {}), ...(ref.updatedAt ? { updatedAt: ref.updatedAt } : {}), ...(former.length ? { formerIds: former } : {}), read: () => r.read(ref, home) }
+    })
+}
+
+/** The ids a session was synced under before brain told the desktop apps apart from their CLIs. */
+function formerIds(ref: SessionRef): string[] {
+  if (ref.tool === "claude-desktop") {
+    const ids = [ref.extra?.cliSessionId, ...(Array.isArray(ref.extra?.priorCliSessionIds) ? ref.extra.priorCliSessionIds : [])]
+    return ids.filter((x): x is string => typeof x === "string").map((x) => `claude-code:${x}`)
+  }
+  if (ref.tool === "codex-desktop") return [`codex:${ref.sourceId}`]
+  return []
 }
 
 export async function syncMemory(o: SyncOptions, deps: { memory?: Memory; sessions?: () => Promise<SessionSource[]>; now?: () => number } = {}): Promise<SyncResult> {
@@ -135,9 +151,15 @@ export async function syncMemory(o: SyncOptions, deps: { memory?: Memory; sessio
       try {
         const session = await s.read()
         const items = distill(session)
-        if (items.length) {
+        const former = (s.formerIds ?? []).filter((id) => ledger[id])
+        if (items.length || former.length) {
           const key = projectKey({ ...session.header.project, ...(session.header.project.cwd ? gitInfo(session.header.project.cwd) : {}) })
-          await memory.ingest(key, items)
+          // What was learned from this session under its old id goes, so it is not kept twice (item ids hash the session id).
+          for (const id of former) {
+            await memory.forget(key, { source: id })
+            delete ledger[id]
+          }
+          if (items.length) await memory.ingest(key, items)
         }
         ledger[s.id] = { u: s.updatedAt ?? "none", n: items.length }
         result.ingested++