@100xprompt/brain 0.1.5 → 0.1.6

package/src/dashboard/sessions.ts

@@ -0,0 +1,127 @@
+// This computer's session list, for the dashboard's Sessions panel (docs/sessions-contract.md, section 1): every session
+// brain can list, by id, tool, title, project folder name and when; never chat text, never a full path. Sent with the
+// computer's token (only a paired computer sends it), from the background service when the list changed (looked at no
+// more than every 5 minutes) and from `brain dashboard` / `brain sync`.
+import { createHash } from "node:crypto"
+import { basename } from "node:path"
+import type { Env } from "../gateway/common.ts"
+import { cleanText } from "../settings/catalog.ts"
+import { sessionsListOn } from "../settings/values.ts"
+import { gatewayUrl, safeUrl, sendingOff } from "./send.ts"
+import { machineId, readCache, readMachineToken, updateCache } from "./state.ts"
+
+export const SESSIONS_PATH = "/api/brain/sessions"
+/** The background service looks at the list (and sends it when it changed) at most this often. */
+export const SESSIONS_EVERY_MS = 5 * 60_000
+export const MAX_SESSIONS = 20_000
+const TOOL = /^[a-z0-9][a-z0-9-]{0,39}$/
+// biome-ignore lint/suspicious/noControlCharactersInRegex: control characters are what it finds
+const CONTROL = /[\u0000-\u001f\u007f-\u009f]/
+/** Control, bidirectional and zero-width characters: never in what the dashboard shows. */
+// biome-ignore lint/suspicious/noControlCharactersInRegex: control characters are what it removes
+const UNSHOWN = /[\u0000-\u001f\u007f-\u009f\u061c\u200b-\u200f\u202a-\u202e\u2060-\u2069\ufeff]/g
+/** The upload stays under the gateway's 4 MB: sessions past this many bytes are left out (the newest are kept). */
+export const MAX_UPLOAD_BYTES = 3_900_000
+
+export interface ListedSession {
+  id: string
+  tool: string
+  title: string | null
+  project: string | null
+  updatedAt: string | null
+}
+
+export interface SessionsUpload {
+  machine: string
+  sentAt: string
+  total: number
+  off: boolean
+  sessions: ListedSession[]
+}
+
+const clip = (s: string, n: number) => (s.length <= n ? s : `${s.slice(0, n - 1)}…`)
+const iso = (v: unknown): string | null => {
+  const t = typeof v === "string" ? Date.parse(v) : NaN
+  return Number.isFinite(t) ? new Date(t).toISOString() : null
+}
+
+/** The upload as it would go now: the list (or nothing, with `off`, when reports.sessions is off here). */
+export async function buildSessionsUpload(home: string, o: { now?: Date } = {}): Promise<SessionsUpload> {
+  const base = { machine: machineId(home), sentAt: (o.now ?? new Date()).toISOString() }
+  if (!sessionsListOn(home)) return { ...base, total: 0, off: true, sessions: [] }
+  const { listSessions } = await import("../session/ops.ts")
+  const { refs } = await listSessions(home)
+  const sessions: ListedSession[] = []
+  let bytes = 200
+  for (const r of refs) {
+    if (sessions.length >= MAX_SESSIONS) break
+    const id = `${r.tool}:${r.sourceId}`
+    if (!TOOL.test(r.tool) || id.length > 200 || CONTROL.test(id) || /[\u061c\u200b-\u200f\u202a-\u202e\u2060-\u2069\ufeff]/.test(id)) continue
+    const title = r.title ? clip(cleanText(r.title, home).replace(UNSHOWN, " ").replace(/\s+/g, " ").trim(), 120) : ""
+    // The project is its folder's name; a session in the home folder itself has none worth naming.
+    const project = r.cwd && r.cwd !== home ? clip(basename(r.cwd).replace(UNSHOWN, " ").replace(/\s+/g, " ").trim(), 80) : ""
+    const s: ListedSession = { id, tool: r.tool, title: title || null, project: project || null, updatedAt: iso(r.updatedAt) }
+    bytes += Buffer.byteLength(JSON.stringify(s)) + 1
+    if (bytes > MAX_UPLOAD_BYTES) break
+    sessions.push(s)
+  }
+  return { ...base, total: refs.length, off: false, sessions }
+}
+
+/** What changes when the list changes (not when it was sent). */
+export const sessionsHash = (u: SessionsUpload) => createHash("sha256").update(JSON.stringify([u.off, u.total, u.sessions])).digest("hex").slice(0, 32)
+
+export type SessionsSent = { sent: true; total: number } | { sent: false; why: string }
+
+/**
+ * Sends the list when it is due: `force` (brain dashboard, brain sync) always; otherwise when SESSIONS_EVERY_MS passed
+ * since the last look and the list changed. Only a paired computer with reports on. Never throws.
+ */
+export async function sendSessions(home: string, o: { env?: Env; force?: boolean; fetchImpl?: typeof fetch; timeoutMs?: number; now?: number } = {}): Promise<SessionsSent> {
+  const env = o.env ?? process.env
+  try {
+    const token = readMachineToken(home)
+    if (!token) return { sent: false, why: "not paired (brain pair)" }
+    const off = sendingOff(home, env)
+    if (off) return { sent: false, why: off }
+    const now = o.now ?? Date.now()
+    const cache = readCache(home).sessions ?? {}
+    if (!o.force && cache.lastLookMs && now - cache.lastLookMs < SESSIONS_EVERY_MS) return { sent: false, why: "not due" }
+    const upload = await buildSessionsUpload(home)
+    const hash = sessionsHash(upload)
+    updateCache(home, (c) => {
+      c.sessions = { ...c.sessions, lastLookMs: now }
+    })
+    if (!o.force && hash === cache.hash && cache.lastSentAt) return { sent: false, why: "unchanged" }
+    const url = `${gatewayUrl(home)}${SESSIONS_PATH}`
+    if (!safeUrl(url)) return { sent: false, why: `the gateway address ${gatewayUrl(home)} is not https; the token is never sent over it` }
+    let why: string | undefined
+    try {
+      const res = await (o.fetchImpl ?? fetch)(url, {
+        method: "PUT",
+        headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+        body: JSON.stringify(upload),
+        redirect: "manual",
+        signal: AbortSignal.timeout(o.timeoutMs ?? 20_000),
+      })
+      await res.text().catch(() => "")
+      if (!res.ok) why = res.status === 401 ? "your account no longer takes this computer's token: pair it again with `brain pair`" : res.status === 429 ? "too many uploads for now; the next one carries everything" : `the gateway answered HTTP ${res.status}`
+    } catch (e) {
+      const n = (e as Error)?.name
+      why = n === "TimeoutError" || n === "AbortError" ? "the gateway did not answer in time" : `could not reach ${gatewayUrl(home)}`
+    }
+    const at = new Date(now).toISOString()
+    updateCache(home, (c) => {
+      c.sessions = why ? { ...c.sessions, lastError: why } : { lastLookMs: now, hash, lastSentAt: at, total: upload.total, off: upload.off }
+    })
+    return why ? { sent: false, why } : { sent: true, total: upload.total }
+  } catch (e) {
+    return { sent: false, why: `the session list could not be made: ${String((e as Error)?.message ?? e).slice(0, 200)}` }
+  }
+}
+
+/** What the report says about it: what was last sent. */
+export function sessionsState(home: string): { total: number; uploadedAt: string | null; off: boolean } {
+  const c = readCache(home).sessions ?? {}
+  return { total: typeof c.total === "number" ? c.total : 0, uploadedAt: typeof c.lastSentAt === "string" ? c.lastSentAt : null, off: c.off === true || !sessionsListOn(home) }
+}

package/src/dashboard/state.ts

@@ -8,8 +8,9 @@
 //                         (when the last report went out, a push that is waiting to run).
 // Every write re-reads the file first and changes only its own fields, then replaces the file atomically.
 import { createHash } from "node:crypto"
-import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs"
+import { chmodSync, linkSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs"
 import { dirname, join } from "node:path"
+import { withBrainLockSync } from "../lock.ts"
 
 export const brainDir = (home: string) => join(home, ".brain")
 export const machinePath = (home: string) => join(brainDir(home), "machine.json")
@@ -41,6 +42,17 @@ export interface DashboardCache {
     /** Why the last attempt failed (cleared by a success). */
     lastError?: string
   }
+  /** Where a session can go from here, from the last `brain dashboard` / `brain sync` (each writer's check can run its tool). */
+  targets?: { at: string; list: Array<{ tool: string; label: string; ways: Array<{ way: string; ready: boolean; why?: string }> }> }
+  /** The session list for the dashboard (sessions.ts): when it was last looked at, and what was last sent. */
+  sessions?: {
+    lastLookMs?: number
+    hash?: string
+    lastSentAt?: string
+    total?: number
+    off?: boolean
+    lastError?: string
+  }
 }
 
 function readJson<T extends object>(path: string): T {
@@ -133,9 +145,40 @@ export function hardwareHash(env: Record<string, string | undefined> = process.e
  * another computer (its hardware hash differs) gets a new id too, and that computer's token is dropped here: the copy is
  * a computer of its own, and is paired on its own.
  */
+/**
+ * Writes `value` to `path` only when there is no file there yet (link of a finished file: never a half-written one). True
+ * when this call made it; false when one was there already.
+ */
+function createPrivateJson(path: string, value: unknown): boolean {
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 })
+  const tmp = `${path}.${process.pid}.${Math.random().toString(36).slice(2, 8)}.brain-new`
+  try {
+    writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 })
+    chmodSync(tmp, 0o600)
+    linkSync(tmp, path)
+    return true
+  } catch (e) {
+    if ((e as NodeJS.ErrnoException)?.code === "EEXIST") return false
+    throw e
+  } finally {
+    rmSync(tmp, { force: true })
+  }
+}
+
 export function machineId(home: string): string {
   const m = readJson<{ id?: unknown; createdAt?: unknown; hw?: unknown }>(machinePath(home))
   const here = hardwareHash()
+  const fresh = (id: string) => ({ id, createdAt: new Date().toISOString(), ...(here ? { hw: here } : {}) })
+  if (m.id === undefined) {
+    // The first id: made once, even when two brains start at the same moment (`brain gateway login` leaves a report
+    // starting in the background as `brain pair` begins): whichever makes the file first, both use its id.
+    const id = crypto.randomUUID()
+    try {
+      if (createPrivateJson(machinePath(home), fresh(id))) return id
+      const made = readJson<{ id?: unknown }>(machinePath(home))
+      if (typeof made.id === "string" && UUID.test(made.id)) return made.id
+    } catch {}
+  }
   if (typeof m.id === "string" && UUID.test(m.id)) {
     if (!here || m.hw === here) return m.id
     if (m.hw === undefined) {
@@ -149,9 +192,25 @@ export function machineId(home: string): string {
       rmSync(machineKeyPath(home), { force: true })
     } catch {}
   }
-  const id = crypto.randomUUID()
+  // A damaged file, or one made on another computer: replaced once, under the brain lock, so two brains doing it at the
+  // same moment keep one id (the second finds the first one's).
   try {
-    writePrivateJson(machinePath(home), { id, createdAt: new Date().toISOString(), ...(here ? { hw: here } : {}) })
-  } catch {}
-  return id
+    return withBrainLockSync(
+      home,
+      () => {
+        const again = readJson<{ id?: unknown; hw?: unknown }>(machinePath(home))
+        if (typeof again.id === "string" && UUID.test(again.id) && again.id !== m.id && (!here || again.hw === here)) return again.id
+        const id = crypto.randomUUID()
+        writePrivateJson(machinePath(home), fresh(id))
+        return id
+      },
+      { what: "this computer's id" },
+    )
+  } catch {
+    const id = crypto.randomUUID()
+    try {
+      writePrivateJson(machinePath(home), fresh(id))
+    } catch {}
+    return id
+  }
 }

package/src/gateway/common.ts

@@ -145,6 +145,8 @@ export interface FileEdit {
   holdsKey?: boolean
   /** Keys among `values` whose value contains the key: never shown or recorded, and replaced when the person signs in again. */
   secretKeys?: string[]
+  /** The mode the file is written with (a launcher script brain writes whole: 0700); otherwise the file keeps its own. */
+  mode?: number
 }
 
 export interface Connector {
@@ -161,6 +163,12 @@ export interface Connector {
   authHeader: "x-api-key" | "authorization" | "x-goog-api-key"
   /** What the person should know (shown on connect). */
   notes: string[]
+  /** What the person should know at connect that depends on this computer (shown after `notes`). */
+  notesHere?(home: string, env: Env): string[]
+  /** Files the tool's own launcher writes while it runs (not edits): removed on disconnect. */
+  leftovers?(home: string): string[]
+  /** What keeps using the gateway after a disconnect or a sign-out until the person quits it (said then). */
+  stillRunning?: string
 }
 
 // ---- JSON paths --------------------------------------------------------------------------------------------------------

package/src/gateway/connect.ts

@@ -33,6 +33,7 @@ import {
   type GatewaySettings,
   getAt,
   type Json,
+  modelId,
   keyPath,
   MODEL_NAMES,
   modelName,
@@ -284,6 +285,7 @@ function logoutLocked(home: string, env: Record<string, string | undefined>): st
     out.push(`${names(readers)} ${readers.length === 1 ? "reads" : "read"} the key from that file, so ${readers.length === 1 ? "it" : "they"} cannot reach the gateway until you sign in again (brain gateway login), and a tool that reads it at start may refuse to start; brain gateway disconnect --tool <id> puts ${readers.length === 1 ? "it" : "them"} back as before.`)
   if (copies.length)
     out.push(`${names(copies)} ${copies.length === 1 ? "keeps its" : "keep their"} own copy of the key and still ${copies.length === 1 ? "reaches" : "reach"} the gateway with it (signing out here does not revoke a key): brain gateway disconnect --tool <id> removes the copy.`)
+  for (const c of connected) if (c.stillRunning) out.push(c.stillRunning)
   return out
 }
 
@@ -395,7 +397,12 @@ export const CONNECTORS: Connector[] = [...BUILT_IN, ...EXTRA_CONNECTORS]
 const SECRET_KEYS = new Set(["GEMINI_API_KEY", "model_providers/brain-gateway"])
 const isSecret = (e: FileEdit, key: string) => SECRET_KEYS.has(key) || !!e.secretKeys?.includes(key)
 
-export const connectorFor = (id: string) => CONNECTORS.find((c) => c.id === id || c.label.toLowerCase() === id.toLowerCase())
+/** Tools that have no connection of their own: they use another tool's (the Codex app reads Codex's ~/.codex). */
+const SAME_CONNECTION: Record<string, string> = { "codex-desktop": "codex", "codex desktop": "codex" }
+export const connectorFor = (id: string) => {
+  const want = SAME_CONNECTION[id.toLowerCase()] ?? id
+  return CONNECTORS.find((c) => c.id === want || c.label.toLowerCase() === want.toLowerCase())
+}
 
 // ---- reading and writing each format ---------------------------------------------------------------------------------
 
@@ -691,6 +698,12 @@ export async function connect(
     usePrefs?: boolean
     /** Called after the files are written, still under the brain lock, with the settings used (to record them). */
     onWritten?: (s: GatewaySettings) => void
+    /**
+     * A reconnect for one setting (model, context editing): the values that setting decides are set again (a hand edit of
+     * them is replaced, as asking for the value again means); any other value the person changed since brain set it stays
+     * theirs (Claude Desktop's applied configuration they chose again in the app, say). A connect asked for takes all back.
+     */
+    keepTheirs?: { for: "model" | "contextEdit" }
   } = {},
 ): Promise<Result> {
   const env = o.env ?? process.env
@@ -738,6 +751,17 @@ export async function connect(
     const s = fresh
     // Read and check every file first: nothing is written unless all of them can be changed.
     const edits = c.edits(home, s, env)
+    // The values the setting being applied decides: those that differ when it is set otherwise.
+    const decided = new Set<string>()
+    if (o.keepTheirs) {
+      const other = o.keepTheirs.for === "model" ? { ...s, model: s.model === modelId("pro") ? modelId("flash") : modelId("pro") } : { ...s, contextEdit: !s.contextEdit }
+      const alt = c.edits(home, other, env)
+      for (const e of edits)
+        for (const k of Object.keys(e.values)) {
+          const v = alt.find((x) => x.path === e.path)?.values[k]
+          if (JSON.stringify(v) !== JSON.stringify(e.values[k])) decided.add(`${e.path}\u0000${k}`)
+        }
+    }
     const docs: Array<{ e: FileEdit; d: Doc }> = []
     for (const e of edits) {
       const d = load(e.format, e.path, e.codec)
@@ -754,6 +778,10 @@ export async function connect(
           // A reconnect keeps the value from before the FIRST connect, so disconnect still restores the person's own.
           const was = prior.find((x) => x.file === e.path && x.key === key)
           const secret = isSecret(e, key)
+          if (o.keepTheirs && !decided.has(`${e.path}\u0000${key}`) && was && was.after !== "(contains the key)" && !secret && !same(current, was.after)) {
+            changes.push(was)
+            continue
+          }
           changes.push({ file: e.path, format: e.format, key, before: was ? was.before : current, after: secret ? "(contains the key)" : after })
           if (!same(current, after)) setKey(d, key, after)
           shown.push(`  ${basename(e.path)}: ${key.replace(/\//g, ".")} = ${secret ? "(gateway settings and key)" : shownValue(after)}`)
@@ -785,7 +813,7 @@ export async function connect(
       } catch {}
     }
     const first = !st.tools[c.id]
-    for (const { e, d } of docs) writeToolFile(home, c.id, e.path, render(d), e.holdsKey ? 0o600 : undefined, first)
+    for (const { e, d } of docs) writeToolFile(home, c.id, e.path, render(d), e.holdsKey ? 0o600 : e.mode, first)
     st.settings = s
     st.tools[c.id] = { at: new Date().toISOString(), changes, ...(created.size ? { created: [...created] } : {}), ...(createdDirs.size ? { createdDirs: [...createdDirs] } : {}), ...(Object.keys(modes).length ? { modes } : {}), settings: s }
     saveState(home, st)
@@ -801,6 +829,7 @@ export async function connect(
         "changed:",
         ...shown,
         ...c.notes.map((n) => `note: ${n}`),
+        ...(c.notesHere?.(home, env) ?? []).map((n) => `note: ${n}`),
         `undo: brain gateway disconnect --tool ${c.id}`,
       ],
     }
@@ -855,10 +884,11 @@ function disconnectLocked(home: string, c: Connector, o: { dryRun?: boolean; env
       } catch {}
     }
   if (!o.dryRun) {
+    for (const f of c.leftovers?.(home) ?? []) rmSync(f, { force: true })
     delete st.tools[c.id]
     saveState(home, st)
   }
-  return { ok: true, lines: [`${o.dryRun ? "would disconnect" : "disconnected"} ${c.label}:`, ...lines] }
+  return { ok: true, lines: [`${o.dryRun ? "would disconnect" : "disconnected"} ${c.label}:`, ...lines, ...(c.stillRunning ? [`note: ${c.stillRunning}`] : [])] }
 }
 
 export function status(home: string, env: Record<string, string | undefined> = process.env): string[] {

package/src/gateway/connectors/antigravity.ts

@@ -1,6 +1,206 @@
-// 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"
+// Gateway connector for Antigravity (macOS): a launcher app, "Antigravity with 100xprompt", that opens Antigravity with its
+// agent on the gateway.
+//
+// Antigravity's agent is Google's `agy` (~/.gemini/bin/agy; the IDE starts it as `agy --hub`, passing its own environment).
+// agy 1.5 has an LLM gateway mode that only environment variables turn on (checked 2026-11-11 against agy 1.5.5 by running
+// it against a local stand-in for the gateway, with every other connection refused):
+//   AGY_LLM_GATEWAY_URL        the gateway's base: agy lists models with GET <base>/v1beta/models and calls
+//                              POST <base>/v1beta/models/<id>:streamGenerateContent?alt=sse (the Gemini API's shape,
+//                              wire protocol "genai", the default; "openai" is the other)
+//   AGY_LLM_GATEWAY_API_KEY    sent as `Authorization: Bearer <key>`; no Google sign-in is needed in this mode
+//   AGY_LLM_GATEWAY_TIER_PRO / _FLASH / _FLASH_LITE   the model ids agy uses for its own tiers (titles, summaries)
+//   (agy sizes a request from the model list: an id it does not know gets 4,096 tokens out and no thinking unless the
+//   gateway's list says more, which is why the gateway answers the list itself, on /flash and on /auto)
+//   AGY_LLM_GATEWAY_HEADERS    extra headers, a JSON object
+// Without them agy uses Google's backend as usual. settings.json has no place for the key (an "env" block there is not
+// read), and the IDE has no setting that reaches agy's environment.
+//
+// So the variables go only to Antigravity, at launch: the launcher runs `open -a "Antigravity IDE" --env ...`, reading the
+// key from brain's key file each time (it is never written into the launcher), and remembers which Antigravity it started.
+// An Antigravity that was already open without them keeps Google's models: the launcher says so instead of pretending.
+// Opening Antigravity the usual way (Dock, Spotlight) is unchanged. A shell-profile export was not used: it would hand the
+// key to every program started from that shell (the same reason as zed.ts).
+import { createHash } from "node:crypto"
+import { join } from "node:path"
+import { AUTO_MODEL, brainDir, EDIT_HEADER, isAuto, keyPath, routeUrl, type Codec, type Connector } from "../common.ts"
 
-export const connectors: Connector[] = []
+export const LAUNCHER_NAME = "Antigravity with 100xprompt"
+const BUNDLE_ID = "com.100xprompt.brain.antigravity"
+/** The names the Antigravity app has had (the launcher opens the first it finds, in /Applications or ~/Applications). */
+const APP_NAMES = ["Antigravity IDE", "Antigravity"]
+const MARK = "brain-antigravity-launcher"
+/** Bumped whenever launcherText changes, so a connect rewrites launchers made by an older brain. */
+const LAUNCHER_FORMAT = 3
+/** The model ids the gateway serves for 100xprompt Pro and Flash (its Gemini routes take them in the path). */
+const PRO = "gemini-3.8-flash"
+const FLASH = "gemini-3.7-flash"
+
+export const launcherApp = (home: string) => join(home, "Applications", `${LAUNCHER_NAME}.app`)
+const launcherScript = (home: string) => join(launcherApp(home), "Contents", "MacOS", "launch")
+const launcherPlist = (home: string) => join(launcherApp(home), "Contents", "Info.plist")
+/** The process id of the Antigravity the launcher started (so a second click only brings it forward). */
+const pidFile = (home: string) => join(brainDir(home), "antigravity-launch.pid")
+
+export interface LaunchSettings {
+  /** The launcher's own format: a newer brain with a changed launcher rewrites it on the next connect. */
+  format: number
+  url: string
+  keyFile: string
+  pidFile: string
+  pro: string
+  flash: string
+  headers?: Record<string, string>
+}
+
+const sq = (s: string) => `'${s.replace(/'/g, `'\\''`)}'`
+
+/** The launcher script for `v`. Its first comment line carries `v` back (codec `get`). No key in it. */
+export function launcherText(v: LaunchSettings): string {
+  const env: Array<[string, string]> = [
+    ["AGY_LLM_GATEWAY_URL", v.url],
+    ["AGY_LLM_GATEWAY_TIER_PRO", v.pro],
+    ["AGY_LLM_GATEWAY_TIER_FLASH", v.flash],
+    ["AGY_LLM_GATEWAY_TIER_FLASH_LITE", v.flash],
+    ...(v.headers && Object.keys(v.headers).length ? ([["AGY_LLM_GATEWAY_HEADERS", JSON.stringify(v.headers)]] as Array<[string, string]>) : []),
+  ]
+  // What Antigravity is started with (not the key): a running one started with other settings is told to restart.
+  const fingerprint = createHash("sha256").update(JSON.stringify(env)).digest("hex").slice(0, 16)
+  const alert = (title: string, text: string) => `osascript -e ${sq(`display alert ${JSON.stringify(title)} message ${JSON.stringify(text)}`)} >/dev/null 2>&1`
+  const apps = APP_NAMES.flatMap((n) => [`/Applications/${n}.app`, `$HOME/Applications/${n}.app`])
+  return [
+    "#!/bin/sh",
+    `# ${MARK} ${JSON.stringify(v)}`,
+    "# Opens Antigravity with its agent on the 100xprompt gateway. Written by `brain gateway connect --tool antigravity`;",
+    "# undo with `brain gateway disconnect --tool antigravity`. The key is read from brain's key file each time and given to",
+    "# Antigravity in open's environment: never kept here, never on a command line.",
+    "umask 077",
+    `pidfile=${sq(v.pidFile)}`,
+    `fp=${sq(fingerprint)}`,
+    "# The Antigravity app here (its name has changed between releases).",
+    'app=""',
+    `for a in ${apps.map((a) => (a.startsWith("$HOME") ? `"${a}"` : sq(a))).join(" ")}; do`,
+    '  if [ -d "$a" ]; then app=$a; break; fi',
+    "done",
+    'if [ -z "$app" ]; then',
+    `  ${alert("Antigravity is not on this computer", `Install Antigravity, then open ${LAUNCHER_NAME} again.`)}`,
+    "  exit 1",
+    "fi",
+    "# This person's own Antigravity only: a process of theirs whose command line starts with the app's binary.",
+    "app_pid() {",
+    '  for p in $(pgrep -U "$(id -u)" -f "/Contents/MacOS/"); do',
+    '    case "$(ps -o command= -p "$p" 2>/dev/null)" in "$app"/Contents/MacOS/*) echo "$p"; return 0 ;; esac',
+    "  done",
+    "}",
+    "pid=$(app_pid)",
+    'if [ -n "$pid" ]; then',
+    '  was_pid=""; was_fp=""',
+    '  if [ -f "$pidfile" ]; then read -r was_pid was_fp < "$pidfile"; fi',
+    '  if [ "$pid" = "$was_pid" ]; then',
+    `    [ "$fp" = "$was_fp" ] || ${alert("Antigravity is on older 100xprompt settings", `Your 100xprompt settings changed after Antigravity started. Quit Antigravity, then open ${LAUNCHER_NAME} again to use them.`)}`,
+    '    exec open -a "$app"',
+    "  fi",
+    `  ${alert("Antigravity is already open", `It uses 100xprompt models only when it starts from ${LAUNCHER_NAME}. Quit Antigravity, then open ${LAUNCHER_NAME} again.`)}`,
+    '  exec open -a "$app"',
+    "fi",
+    `key=$(head -n 1 ${sq(v.keyFile)} 2>/dev/null)`,
+    'if [ -z "$key" ]; then',
+    `  ${alert(LAUNCHER_NAME, "brain is not signed in to 100xprompt. Run: brain gateway login, then open this again.")}`,
+    "  exit 1",
+    "fi",
+    'out=$(AGY_LLM_GATEWAY_API_KEY="$key" open -a "$app" \\',
+    ...env.map(([k, val]) => `  --env ${sq(`${k}=${val}`)} \\`),
+    '  2>&1); rc=$?',
+    'case "$out" in *"already running"*|*"could not be set"*) rc=2 ;; esac',
+    'if [ "$rc" -ne 0 ]; then',
+    `  ${alert("Antigravity did not open on 100xprompt", `macOS could not start Antigravity with 100xprompt's settings (it may already be running). Quit Antigravity, then open ${LAUNCHER_NAME} again.`)}`,
+    "  exit 1",
+    "fi",
+    "i=0",
+    'while [ $i -lt 20 ]; do',
+    '  pid=$(app_pid); if [ -n "$pid" ]; then echo "$pid $fp" > "$pidfile"; exit 0; fi',
+    "  i=$((i + 1)); sleep 0.5",
+    "done",
+    "",
+  ].join("\n")
+}
+
+/** The launcher's Info.plist: a background app (no Dock icon of its own) that only starts Antigravity. */
+export function plistText(v: { name: string; id: string }): string {
+  const esc = (s: string) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+    `<!-- ${MARK} ${JSON.stringify(v)} -->`,
+    '<plist version="1.0">',
+    "<dict>",
+    "  <key>CFBundleExecutable</key><string>launch</string>",
+    `  <key>CFBundleIdentifier</key><string>${esc(v.id)}</string>`,
+    `  <key>CFBundleName</key><string>${esc(v.name)}</string>`,
+    `  <key>CFBundleDisplayName</key><string>${esc(v.name)}</string>`,
+    "  <key>CFBundlePackageType</key><string>APPL</string>",
+    "  <key>CFBundleShortVersionString</key><string>1.0</string>",
+    "  <key>LSUIElement</key><true/>",
+    "</dict>",
+    "</plist>",
+    "",
+  ].join("\n")
+}
+
+/** A file brain writes whole: one key, whose value is carried in the file's marker line. Anyone else's file is left alone. */
+function wholeFile(key: string, render: (v: any) => string): Codec {
+  const marker = new RegExp(`${MARK} (\\{.*\\})`)
+  return {
+    check(text) {
+      return text.trim() && !marker.test(text) ? `it is not brain's ${LAUNCHER_NAME} launcher; left as it is` : undefined
+    },
+    get(text, k) {
+      if (k !== key) return undefined
+      const m = marker.exec(text)
+      if (!m) return undefined
+      try {
+        return JSON.parse(m[1]!)
+      } catch {
+        return undefined
+      }
+    },
+    set(_text, k, value) {
+      if (k !== key) throw new Error(`unknown launcher key ${k}`)
+      return value === undefined ? "" : render(value)
+    },
+  }
+}
+
+const antigravity: Connector = {
+  id: "antigravity",
+  label: "Antigravity",
+  file: (home) => launcherScript(home),
+  probe: [".gemini/bin/agy", ".gemini/antigravity"],
+  authHeader: "authorization",
+  edits: (home, s) => {
+    // Antigravity lists the route's models (Pro and Flash; on the auto route, auto alone) and calls the Gemini API's paths
+    // there. Its own tiers (titles, summaries) get Pro and Flash, or auto.
+    const auto = isAuto(s)
+    const launch: LaunchSettings = {
+      format: LAUNCHER_FORMAT,
+      url: routeUrl(s),
+      keyFile: keyPath(home),
+      pidFile: pidFile(home),
+      pro: auto ? AUTO_MODEL : PRO,
+      flash: auto ? AUTO_MODEL : FLASH,
+      ...(s.contextEdit ? { headers: { [EDIT_HEADER]: "on" } } : {}),
+    }
+    return [
+      { path: launcherPlist(home), format: "custom", codec: wholeFile("bundle", plistText), values: { bundle: { name: LAUNCHER_NAME, id: BUNDLE_ID } } },
+      { path: launcherScript(home), format: "custom", codec: wholeFile("launch", launcherText), values: { launch }, mode: 0o700 },
+    ]
+  },
+  notes: [
+    `open Antigravity from "${LAUNCHER_NAME}" (in ~/Applications; Spotlight finds it) to use 100xprompt's models; its model menu then lists them. Opened the usual way, Antigravity keeps Google's models.`,
+    "quit Antigravity first if it is open: the launcher can only give 100xprompt to an Antigravity it starts.",
+    "the key is read from brain's key file each time the launcher runs and given to Antigravity in its environment; it is not written into the launcher, nor put on a command line.",
+  ],
+  leftovers: (home) => [pidFile(home)],
+  stillRunning: "an Antigravity started from the launcher keeps using 100xprompt (with the key it started with) until you quit it.",
+}
+
+export const connectors: Connector[] = process.platform === "darwin" ? [antigravity] : []