fix(gateway): fall back to the pooler when the derived direct host is unreachable (#1641)

deriveDirectUrl() swaps the Supabase pooler host to db.<ref>.supabase.co:5432,
which is IPv6-only without the paid IPv4 add-on. On IPv4-only networks the
direct pool could never connect, and initDirectPool()'s throw killed
'gbrain init --url' and migrations with ENOTFOUND/ECONNREFUSED.

getDirectPool() now classifies network-unreachable errors (ENOTFOUND,
ECONNREFUSED, ENETUNREACH, EHOSTUNREACH, ETIMEDOUT, CONNECT_TIMEOUT) via the
new isNetworkUnreachableError(), self-activates the kill-switch, logs one
stderr line pointing at GBRAIN_DIRECT_DATABASE_URL / GBRAIN_DISABLE_DIRECT_POOL,
and returns the read pool. Auth/SQL errors still throw (misconfig, not
unreachability). The failed pool is ended via endPoolBounded so it can't
leak sockets into the now-continuing process.

Also surfaces the kill-switch + override envs in the init.ts IPv6 warnings
and docs/guides/live-sync.md (they were previously undocumented outside
connection-manager.ts).

Fixes #1641

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

docs/guides/live-sync.md

@@ -21,14 +21,17 @@ GBrain is tuned for the Supabase **Transaction pooler** (port 6543): it
 auto-disables prepared statements there and routes `engine.transaction()`
 (migrations, DDL, sync imports) to a derived **direct** connection
 (`db.<ref>.supabase.co:5432`). That direct host is IPv6-only, so on an
-IPv4-only host, reads work but sync **silently skips most pages**. This is the
-number one cause of "sync ran but nothing happened."
+IPv4-only host it is unreachable. When that happens gbrain now falls back to
+the pooler automatically (one stderr warning, then single-pool mode for the
+rest of the process) — but the pooler's ~2-min statement timeout can truncate
+very long migrations or bulk imports.
 
 Fix: make the direct connection reachable over IPv4. Either set
 `GBRAIN_DIRECT_DATABASE_URL` to the **Session pooler** string (port 5432 on the
-`pooler.supabase.com` host, IPv4), or enable Supabase's IPv4 add-on. Verify by
-running `gbrain sync` and checking that the page count in `gbrain stats` matches
-the syncable file count in the repo.
+`pooler.supabase.com` host, IPv4), or enable Supabase's IPv4 add-on.
+`GBRAIN_DISABLE_DIRECT_POOL=1` skips the direct pool (and the fallback warning)
+entirely. Verify by running `gbrain sync` and checking that the page count in
+`gbrain stats` matches the syncable file count in the repo.
 
 ### The Primitives
 

llms-full.txt

@@ -2720,14 +2720,17 @@ GBrain is tuned for the Supabase **Transaction pooler** (port 6543): it
 auto-disables prepared statements there and routes `engine.transaction()`
 (migrations, DDL, sync imports) to a derived **direct** connection
 (`db.<ref>.supabase.co:5432`). That direct host is IPv6-only, so on an
-IPv4-only host, reads work but sync **silently skips most pages**. This is the
-number one cause of "sync ran but nothing happened."
+IPv4-only host it is unreachable. When that happens gbrain now falls back to
+the pooler automatically (one stderr warning, then single-pool mode for the
+rest of the process) — but the pooler's ~2-min statement timeout can truncate
+very long migrations or bulk imports.
 
 Fix: make the direct connection reachable over IPv4. Either set
 `GBRAIN_DIRECT_DATABASE_URL` to the **Session pooler** string (port 5432 on the
-`pooler.supabase.com` host, IPv4), or enable Supabase's IPv4 add-on. Verify by
-running `gbrain sync` and checking that the page count in `gbrain stats` matches
-the syncable file count in the repo.
+`pooler.supabase.com` host, IPv4), or enable Supabase's IPv4 add-on.
+`GBRAIN_DISABLE_DIRECT_POOL=1` skips the direct pool (and the fallback warning)
+entirely. Verify by running `gbrain sync` and checking that the page count in
+`gbrain stats` matches the syncable file count in the repo.
 
 ### The Primitives
 

src/cli.ts

@@ -464,7 +464,7 @@ async function main() {
     // routed path. Date → ISO string; bigint → string (postgres.js shape);
     // Buffer → object. Microsecond-cost; eliminates a whole drift bug class.
     const result = JSON.parse(JSON.stringify(rawResult, bigintToStringReplacer));
-    const output = formatResult(op.name, result, params);
+    const output = formatResult(op.name, result);
     if (output) process.stdout.write(output);
   } catch (e: unknown) {
     // v0.42.20.0 (codex D4): on error, set exitCode + return so the `finally`
@@ -547,7 +547,7 @@ async function runThinClientRouted(
       signal: sigintController.signal,
     });
     const result = unpackToolResult(raw);
-    const output = formatResult(op.name, result, params);
+    const output = formatResult(op.name, result);
     if (output) process.stdout.write(output);
   } catch (e: unknown) {
     if (e instanceof RemoteMcpError) {
@@ -777,10 +777,6 @@ export function parseOpArgs(op: Operation, args: string[]): Record<string, unkno
       const paramDef = op.params[key];
       if (paramDef?.type === 'boolean') {
         params[key] = true;
-      } else if (key === 'json') {
-        // Generic operation formatter flag. It is intentionally CLI-local:
-        // do not add it to the operation contract exposed over MCP/tools.
-        params[key] = true;
       } else if (i + 1 < args.length) {
         params[key] = args[++i];
         if (paramDef?.type === 'number') params[key] = Number(params[key]);
@@ -842,11 +838,7 @@ async function makeContext(engine: BrainEngine, params: Record<string, unknown>)
 }
 
 // Exported for tests (same import-safety contract as cliAliases/printOpHelp).
-export function formatResult(
-  opName: string,
-  result: unknown,
-  params: Record<string, unknown> = {},
-): string {
+export function formatResult(opName: string, result: unknown): string {
   switch (opName) {
     case 'volunteer_context': {
       const r = result as any;
@@ -885,7 +877,6 @@ export function formatResult(
     case 'search':
     case 'query': {
       const results = result as any[];
-      if (params.json === true) return JSON.stringify(results, null, 2) + '\n';
       if (results.length === 0) return 'No results.\n';
       // v0.40.4 — --explain switches to per-stage attribution formatter.
       // Reads CliOptions.explain via the module-level singleton.

src/commands/init.ts

@@ -1078,6 +1078,9 @@ async function initPostgres(opts: {
     console.warn('  Direct connections are IPv6 only and fail in many environments.');
     console.warn('  Use the Transaction pooler connection string instead (port 6543):');
     console.warn('  Supabase Dashboard > Connect (top bar) > Connection String > Transaction pooler');
+    console.warn('  (With a pooler URL, gbrain derives a direct connection for DDL and falls back');
+    console.warn('  to the pooler automatically if that host is unreachable. Power users:');
+    console.warn('  GBRAIN_DIRECT_DATABASE_URL overrides the derived URL; GBRAIN_DISABLE_DIRECT_POOL=1 disables it.)');
     console.warn('');
   }
 
@@ -1091,6 +1094,9 @@ async function initPostgres(opts: {
       if (databaseUrl.includes('supabase.co') && (msg.includes('ECONNREFUSED') || msg.includes('ETIMEDOUT'))) {
         console.error('Connection failed. Supabase direct connections (db.*.supabase.co:5432) are IPv6 only.');
         console.error('Use the Transaction pooler connection string instead (port 6543).');
+        console.error('(gbrain derives its own direct connection from pooler URLs for DDL; if that host is');
+        console.error('unreachable it falls back to the pooler. GBRAIN_DIRECT_DATABASE_URL overrides the');
+        console.error('derived URL; GBRAIN_DISABLE_DIRECT_POOL=1 disables the direct pool entirely.)');
       }
       throw e;
     }

src/core/connection-manager.ts

@@ -167,6 +167,25 @@ export function deriveDirectUrl(url: string): string | null {
   }
 }
 
+/**
+ * Error codes that mean "the direct host is unreachable from this network"
+ * (#1641). The auto-derived db.<ref>.supabase.co host is IPv6-only without
+ * the paid IPv4 add-on, so ENOTFOUND/ECONNREFUSED here is expected on
+ * IPv4-only networks — we fall back to the pooler instead of failing init.
+ */
+const NETWORK_UNREACHABLE_CODES = [
+  'ENOTFOUND', 'ECONNREFUSED', 'ENETUNREACH', 'EHOSTUNREACH',
+  'ETIMEDOUT', 'CONNECT_TIMEOUT',
+];
+
+/** True when err looks like a network-unreachable failure (not auth/SQL). */
+export function isNetworkUnreachableError(err: unknown): boolean {
+  const code = (err as { code?: unknown } | null)?.code;
+  if (typeof code === 'string' && NETWORK_UNREACHABLE_CODES.includes(code)) return true;
+  const msg = err instanceof Error ? err.message : String(err);
+  return NETWORK_UNREACHABLE_CODES.some(c => msg.includes(c));
+}
+
 /**
  * Read kill-switch state from env. Subordinate to parent manager's state
  * when present (A2 inheritance).
@@ -319,7 +338,30 @@ export class ConnectionManager {
         throw err;
       });
     }
-    const pool = await this._directInit;
+    let pool: Sql | null;
+    try {
+      pool = await this._directInit;
+    } catch (err) {
+      // #1641: the derived direct host (db.<ref>.supabase.co) is IPv6-only
+      // without Supabase's IPv4 add-on. On IPv4-only networks the direct
+      // pool can never connect — permanently fall back to the read pool
+      // (self-activating kill-switch) instead of failing init/migrations.
+      // Non-network errors (auth, SQL) still throw: they mean misconfig,
+      // not unreachability.
+      if (isNetworkUnreachableError(err)) {
+        const alreadyWarned = this._killSwitch;
+        this._killSwitch = true;
+        const msg = err instanceof Error ? err.message : String(err);
+        if (!alreadyWarned) console.error(
+          `gbrain: direct connection to ${this._directUrl ? this.hostOnly(this._directUrl) : 'unknown host'} unreachable (${msg}); ` +
+          'falling back to the pooler for DDL/bulk (long migrations may hit the pooler statement timeout). ' +
+          'Set GBRAIN_DIRECT_DATABASE_URL to a reachable direct URL (e.g. the Session pooler, port 5432) or enable the Supabase IPv4 add-on; ' +
+          'GBRAIN_DISABLE_DIRECT_POOL=1 silences this.',
+        );
+        return this.getReadPool();
+      }
+      throw err;
+    }
     if (!pool) {
       // Defensive — initDirectPool should have thrown.
       throw new Error('connection-manager: direct pool init returned null');
@@ -350,8 +392,9 @@ export class ConnectionManager {
       },
     };
     const t0 = Date.now();
+    let pool: Sql | null = null;
     try {
-      const pool = postgres(this._directUrl, opts);
+      pool = postgres(this._directUrl, opts);
       // Probe to validate connectivity early.
       await pool`SELECT 1`;
       logConnectionEvent({
@@ -362,6 +405,9 @@ export class ConnectionManager {
       });
       return pool;
     } catch (err) {
+      // Don't leak the failed pool's sockets/timers (#1641 fallback keeps
+      // the process running afterward).
+      if (pool) await endPoolBounded(pool);
       logConnectionEvent({
         pool: 'ddl',
         op: 'error',

test/cli-args.test.ts

@@ -20,16 +20,5 @@ describe('parseOpArgs', () => {
       source_id: 'gstack-code-repo-0e4763c9',
     });
   });
-
-  test('--json is a CLI-local formatter flag for shared operations', () => {
-    const params = parseOpArgs(operationsByName.search, [
-      'needle',
-      '--json',
-    ]);
-
-    expect(params).toEqual({
-      query: 'needle',
-      json: true,
-    });
-  });
 });
+

test/cli-format-search-json.test.ts

@@ -1,28 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { formatResult } from '../src/cli.ts';
-
-describe('formatResult - search/query --json', () => {
-  test('search --json renders the raw result array as parseable JSON', () => {
-    const out = formatResult('search', [
-      {
-        slug: 'docs/example',
-        score: 0.42,
-        chunk_text: 'Example result text',
-      },
-    ], { json: true });
-
-    expect(JSON.parse(out)).toEqual([
-      {
-        slug: 'docs/example',
-        score: 0.42,
-        chunk_text: 'Example result text',
-      },
-    ]);
-  });
-
-  test('query --json keeps empty results machine-readable', () => {
-    const out = formatResult('query', [], { json: true });
-
-    expect(JSON.parse(out)).toEqual([]);
-  });
-});

test/cli-search-dispatch.test.ts

@@ -49,15 +49,6 @@ describe('T5 — gbrain search dispatch', () => {
     });
   });
 
-  test('`search "<freetext>" --json` emits a parseable result array', () => {
-    withHome((home) => {
-      const { stdout, stderr, status } = run(['search', 'zzz-no-such-page-xyz', '--json'], home);
-      expect(status).toBe(0);
-      expect(stderr).not.toContain('Unknown subcommand');
-      expect(JSON.parse(stdout)).toEqual([]);
-    });
-  });
-
   test('`search stats --json` routes to the dashboard', () => {
     withHome((home) => {
       const { stdout, status } = run(['search', 'stats', '--json'], home);

test/connection-manager.serial.test.ts

@@ -3,6 +3,7 @@ import {
   isSupabasePoolerUrl,
   deriveDirectUrl,
   readKillSwitchEnv,
+  isNetworkUnreachableError,
   resolveDirectPoolSize,
   ConnectionManager,
   DEFAULT_DIRECT_POOL_SIZE,
@@ -238,3 +239,65 @@ describe('ConnectionManager — parent inheritance (A2)', () => {
     }
   });
 });
+
+describe('isNetworkUnreachableError (#1641)', () => {
+  test('classifies network codes as unreachable', () => {
+    for (const code of ['ENOTFOUND', 'ECONNREFUSED', 'ENETUNREACH', 'EHOSTUNREACH', 'ETIMEDOUT', 'CONNECT_TIMEOUT']) {
+      const err = Object.assign(new Error('connect failed'), { code });
+      expect(isNetworkUnreachableError(err)).toBe(true);
+    }
+  });
+
+  test('classifies by message when code absent', () => {
+    expect(isNetworkUnreachableError(new Error('getaddrinfo ENOTFOUND db.abc.supabase.co'))).toBe(true);
+  });
+
+  test('auth/SQL errors are NOT unreachable', () => {
+    expect(isNetworkUnreachableError(new Error('password authentication failed for user "postgres"'))).toBe(false);
+    expect(isNetworkUnreachableError(new Error('syntax error at or near "SELEC"'))).toBe(false);
+    expect(isNetworkUnreachableError(null)).toBe(false);
+  });
+});
+
+describe('ConnectionManager — direct-pool fallback on unreachable host (#1641)', () => {
+  let originalKillSwitch: string | undefined;
+  let originalError: typeof console.error;
+  let errLines: string[];
+  beforeEach(() => {
+    originalKillSwitch = process.env.GBRAIN_DISABLE_DIRECT_POOL;
+    delete process.env.GBRAIN_DISABLE_DIRECT_POOL;
+    originalError = console.error;
+    errLines = [];
+    console.error = (...args: unknown[]) => { errLines.push(args.join(' ')); };
+  });
+  afterEach(() => {
+    console.error = originalError;
+    if (originalKillSwitch === undefined) delete process.env.GBRAIN_DISABLE_DIRECT_POOL;
+    else process.env.GBRAIN_DISABLE_DIRECT_POOL = originalKillSwitch;
+  });
+
+  test('ddl() falls back to the read pool when the direct host is unreachable', async () => {
+    const cm = new ConnectionManager({
+      url: 'postgresql://postgres.abc:p@aws.pooler.supabase.com:6543/db',
+      // 127.0.0.1:9 (discard) → instant ECONNREFUSED, the IPv4-only-network shape.
+      directUrl: 'postgresql://postgres:p@127.0.0.1:9/db',
+    });
+    const fakeReadPool = {} as ReturnType<typeof ConnectionManager.prototype.read>;
+    cm.setReadPool(fakeReadPool);
+    expect(cm.isDualPoolActive()).toBe(true);
+
+    const pool = await cm.ddl(); // without the fix this throws ECONNREFUSED
+    expect(pool).toBe(fakeReadPool);
+    // Self-activating kill-switch: subsequent calls skip the direct pool.
+    expect(cm.isKillSwitchActive()).toBe(true);
+    expect(cm.isDualPoolActive()).toBe(false);
+    expect(cm.describeMode().mode).toBe('single (kill-switch)');
+    // One stderr line mentioning the power-user override.
+    const warning = errLines.filter(l => l.includes('GBRAIN_DIRECT_DATABASE_URL'));
+    expect(warning.length).toBe(1);
+
+    const again = await cm.ddl();
+    expect(again).toBe(fakeReadPool);
+    expect(errLines.filter(l => l.includes('GBRAIN_DIRECT_DATABASE_URL')).length).toBe(1);
+  }, 20000);
+});