test(migrate): use withEnv() for GBRAIN_HOME mutation (check:test-isolation R1)

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

src/commands/autopilot.ts

@@ -151,100 +151,6 @@ export function shouldSpawnAutopilotWorker(args: string[]): boolean {
   return !args.includes('--no-worker');
 }
 
-/**
- * #1525 — positional subcommand translation.
- *
- * Pre-fix, `gbrain autopilot status` silently fell through to "start daemon"
- * because `runAutopilot()` only branched on flag forms (`--status`, etc.).
- * `status` was treated as a stray positional and ignored.
- *
- * This translator maps known positional subcommands to their flag form so
- * `autopilot status` is equivalent to `autopilot --status`, then rejects
- * any unrecognized positional with a fail-loud error before any side
- * effect (lockfile, daemon spawn, sync dispatch) runs.
- *
- * Scope decisions:
- *   - Known aliases: `status` → `--status`, `install` → `--install`,
- *     `uninstall` → `--uninstall`, `start` → (drop; default daemon launch).
- *   - `stop` is intentionally NOT aliased here. Stopping a running daemon
- *     is a new behavior (read PID from lock, SIGTERM, drain) that deserves
- *     its own design and PR. Users typing `gbrain autopilot stop` today get
- *     the unknown-positional error with the canonical alternatives.
- *   - At most one positional allowed; multiple positionals fail loud.
- */
-// Every flag that consumes the NEXT argv token. Missing one here makes the
-// translator misread the flag's value as a positional subcommand and exit 2
-// (e.g. `--install --target linux-cron`). Keep in sync with parseArg call sites.
-const AUTOPILOT_VALUE_FLAGS = new Set(['--repo', '--interval', '--target']);
-const AUTOPILOT_POSITIONAL_ALIASES: Record<string, string | null> = {
-  status: '--status',
-  install: '--install',
-  uninstall: '--uninstall',
-  start: null, // drop the positional; default behavior is daemon launch
-};
-
-export type PositionalTranslation =
-  | { ok: true; args: string[] }
-  | {
-      ok: false;
-      reason: 'unknown_subcommand' | 'multiple_subcommands';
-      message: string;
-    };
-
-export function translatePositionalSubcommands(args: string[]): PositionalTranslation {
-  const out: string[] = [];
-  let positionalSeen = false;
-  let i = 0;
-  while (i < args.length) {
-    const a = args[i];
-    if (AUTOPILOT_VALUE_FLAGS.has(a)) {
-      // Pass through the flag and its value untouched. If the value is
-      // missing at end-of-argv, fall through so the existing parseArg
-      // path can report the broken usage.
-      out.push(a);
-      if (i + 1 < args.length) {
-        out.push(args[i + 1]);
-        i += 2;
-      } else {
-        i += 1;
-      }
-      continue;
-    }
-    if (a.startsWith('-')) {
-      out.push(a);
-      i += 1;
-      continue;
-    }
-    // Positional subcommand.
-    if (positionalSeen) {
-      const known = Object.keys(AUTOPILOT_POSITIONAL_ALIASES).join(', ');
-      return {
-        ok: false,
-        reason: 'multiple_subcommands',
-        message: `Multiple subcommands given. Use only one of: ${known}.`,
-      };
-    }
-    positionalSeen = true;
-    if (a in AUTOPILOT_POSITIONAL_ALIASES) {
-      const alias = AUTOPILOT_POSITIONAL_ALIASES[a];
-      if (alias) out.push(alias);
-      i += 1;
-      continue;
-    }
-    const known = Object.keys(AUTOPILOT_POSITIONAL_ALIASES).join(', ');
-    return {
-      ok: false,
-      reason: 'unknown_subcommand',
-      message:
-        `Unknown subcommand: \`${a}\`.\n` +
-        `Allowed subcommands: ${known}.\n` +
-        `Or use the flag form: --status, --install, --uninstall.\n` +
-        `Run \`gbrain autopilot --help\` for full usage.`,
-    };
-  }
-  return { ok: true, args: out };
-}
-
 export function isPidAlive(pid: number): boolean {
   if (!Number.isFinite(pid) || pid <= 0) return false;
   try {
@@ -457,11 +363,6 @@ export async function runAutopilot(engine: BrainEngine, args: string[]) {
       '       gbrain autopilot --install [--repo <path>]\n' +
       '       gbrain autopilot --uninstall\n' +
       '       gbrain autopilot --status [--json]\n\n' +
-      'Subcommand aliases:\n' +
-      '       gbrain autopilot status     → --status\n' +
-      '       gbrain autopilot install    → --install\n' +
-      '       gbrain autopilot uninstall  → --uninstall\n' +
-      '       gbrain autopilot start      → (default daemon launch)\n\n' +
       'Self-maintaining brain daemon. Runs the full maintenance cycle\n' +
       '(lint + backlinks + sync + extract + embed + orphans) on an interval.\n\n' +
       'For a one-shot cron-triggered cycle, see `gbrain dream`.',
@@ -469,16 +370,6 @@ export async function runAutopilot(engine: BrainEngine, args: string[]) {
     return;
   }
 
-  // #1525: translate positional subcommands to their flag form BEFORE any
-  // side effect (lockfile, daemon spawn, sync dispatch). Unknown positionals
-  // fail loud here rather than silently starting the daemon.
-  const translated = translatePositionalSubcommands(args);
-  if (!translated.ok) {
-    console.error(translated.message);
-    process.exit(2);
-  }
-  args = translated.args;
-
   if (args.includes('--install')) {
     await installDaemon(engine, args);
     return;

src/commands/migrate-engine.ts

@@ -3,7 +3,11 @@
  *
  * Usage:
  *   gbrain migrate --to supabase [--url <connection_string>]
+ *     (--url is persisted to config.json, mode 0600, so the migrated brain
+ *      works without env — #1271)
  *   gbrain migrate --to pglite [--path <db_path>]
+ *     (an explicit --path destination is bootstrapped with its own
+ *      <path>/.gbrain/config.json so GBRAIN_HOME=<path> just works — #1271)
  *   gbrain migrate --to <engine> --force  (overwrite non-empty target)
  */
 
@@ -11,9 +15,9 @@ import { createEngine } from '../core/engine-factory.ts';
 import { loadConfig, saveConfig, toEngineConfig, gbrainPath, effectiveEnvDatabaseUrl, type GBrainConfig } from '../core/config.ts';
 import type { BrainEngine } from '../core/engine.ts';
 import type { EngineConfig } from '../core/types.ts';
-import { writeFileSync, readFileSync, existsSync, unlinkSync } from 'fs';
+import { writeFileSync, readFileSync, existsSync, unlinkSync, mkdirSync, chmodSync } from 'fs';
 import { createHash } from 'crypto';
-import { resolve } from 'path';
+import { resolve, join } from 'path';
 import { createProgress } from '../core/progress.ts';
 import { getCliOptions, cliOptsToProgressOptions } from '../core/cli-options.ts';
 
@@ -59,6 +63,31 @@ export interface MigrateManifest {
   started_at: string;
 }
 
+/**
+ * #1271 Finding 1: make an explicit `--to pglite --path P` destination usable
+ * as a standalone brain. Writes `P/.gbrain/config.json` (mode 0600, plus a
+ * `*` .gitignore) so `GBRAIN_HOME=P` resolves without a manual `gbrain init`.
+ * Never clobbers an existing config at the destination. Returns the written
+ * config path, or null when skipped.
+ */
+export function bootstrapDestinationConfig(dbPath: string): string | null {
+  const abs = resolve(dbPath);
+  const dir = join(abs, '.gbrain');
+  const file = join(dir, 'config.json');
+  if (existsSync(file)) return null;
+  mkdirSync(dir, { recursive: true });
+  const cfg: GBrainConfig = { engine: 'pglite', database_path: abs };
+  writeFileSync(file, JSON.stringify(cfg, null, 2) + '\n', { mode: 0o600 });
+  try { chmodSync(file, 0o600); } catch { /* platform-specific */ }
+  // Same worktree-safety pattern as saveConfig()'s ensureGitignore, scoped
+  // to the destination home. Don't clobber a user-customized .gitignore.
+  const gitignore = join(dir, '.gitignore');
+  if (!existsSync(gitignore)) {
+    writeFileSync(gitignore, '*\n', { mode: 0o600 });
+  }
+  return file;
+}
+
 export function migrationTargetId(config: EngineConfig): string {
   const locator = config.engine === 'postgres'
     ? config.database_url ?? ''
@@ -352,6 +381,25 @@ export async function runMigrateEngine(sourceEngine: BrainEngine, args: string[]
   };
   saveConfig(newConfig);
 
+  // #1271 Finding 2 (by design, but say it out loud): the connection string
+  // is persisted so the migrated brain works without env. Mode 0600.
+  if (opts.targetEngine === 'postgres' && opts.targetUrl) {
+    console.error('Note: the --url connection string (including credentials) is persisted to config.json (mode 0600).');
+  }
+
+  // #1271 Finding 1: an explicit --path destination doubles as a standalone
+  // GBRAIN_HOME. Best-effort — never fail a completed migration over it.
+  if (opts.targetEngine === 'pglite' && opts.targetPath) {
+    try {
+      const written = bootstrapDestinationConfig(opts.targetPath);
+      if (written) {
+        console.log(`Destination bootstrapped: ${written} (usable via GBRAIN_HOME=${resolve(opts.targetPath)})`);
+      }
+    } catch (e) {
+      console.warn(`  WARN could not bootstrap destination config: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+
   // Clean up
   clearManifest();
 

test/autopilot-positional-subcommands.test.ts

@@ -1,197 +0,0 @@
-/**
- * Tests for translatePositionalSubcommands() — the v0.41.x #1525 fix that
- * prevents `gbrain autopilot status` from silently starting the daemon.
- *
- * IRON RULE regression guard: the exact ticket repro (`gbrain autopilot
- * status`) MUST translate to `--status`, not fall through to the default
- * daemon launch. Verified by the "ticket-exact repro" case below.
- */
-
-import { describe, test, expect } from 'bun:test';
-import { translatePositionalSubcommands } from '../src/commands/autopilot.ts';
-
-describe('translatePositionalSubcommands — known aliases', () => {
-  test('IRON RULE — `autopilot status` translates to `--status` (ticket #1525 repro)', () => {
-    const r = translatePositionalSubcommands(['status']);
-    expect(r.ok).toBe(true);
-    if (r.ok) expect(r.args).toEqual(['--status']);
-  });
-
-  test('`install` translates to `--install`', () => {
-    const r = translatePositionalSubcommands(['install']);
-    expect(r.ok).toBe(true);
-    if (r.ok) expect(r.args).toEqual(['--install']);
-  });
-
-  test('`uninstall` translates to `--uninstall`', () => {
-    const r = translatePositionalSubcommands(['uninstall']);
-    expect(r.ok).toBe(true);
-    if (r.ok) expect(r.args).toEqual(['--uninstall']);
-  });
-
-  test('`start` drops the positional (default daemon launch)', () => {
-    const r = translatePositionalSubcommands(['start']);
-    expect(r.ok).toBe(true);
-    if (r.ok) expect(r.args).toEqual([]);
-  });
-
-  test('`start --json` drops only the positional, keeps the flag', () => {
-    const r = translatePositionalSubcommands(['start', '--json']);
-    expect(r.ok).toBe(true);
-    if (r.ok) expect(r.args).toEqual(['--json']);
-  });
-});
-
-describe('translatePositionalSubcommands — flag/positional interleaving', () => {
-  test('`status --json` preserves the trailing flag', () => {
-    const r = translatePositionalSubcommands(['status', '--json']);
-    expect(r.ok).toBe(true);
-    if (r.ok) expect(r.args).toEqual(['--status', '--json']);
-  });
-
-  test('`--json status` preserves the leading flag', () => {
-    const r = translatePositionalSubcommands(['--json', 'status']);
-    expect(r.ok).toBe(true);
-    if (r.ok) expect(r.args).toEqual(['--json', '--status']);
-  });
-
-  test('`--repo /foo status` does not mis-classify the path as positional', () => {
-    const r = translatePositionalSubcommands(['--repo', '/foo', 'status']);
-    expect(r.ok).toBe(true);
-    if (r.ok) expect(r.args).toEqual(['--repo', '/foo', '--status']);
-  });
-
-  test('`--interval 300 install` does not mis-classify the number as positional', () => {
-    const r = translatePositionalSubcommands(['--interval', '300', 'install']);
-    expect(r.ok).toBe(true);
-    if (r.ok) expect(r.args).toEqual(['--interval', '300', '--install']);
-  });
-
-  test('`--install --target linux-cron` does not mis-classify the target as positional', () => {
-    // --target is installDaemon's value flag; its value must never be read
-    // as a positional subcommand (regression guard for the review fix).
-    const r = translatePositionalSubcommands(['--install', '--target', 'linux-cron']);
-    expect(r.ok).toBe(true);
-    if (r.ok) expect(r.args).toEqual(['--install', '--target', 'linux-cron']);
-  });
-
-  test('`install --target macos` keeps the alias translation and the target value', () => {
-    const r = translatePositionalSubcommands(['install', '--target', 'macos']);
-    expect(r.ok).toBe(true);
-    if (r.ok) expect(r.args).toEqual(['--install', '--target', 'macos']);
-  });
-
-  test('value-flag at end of argv with missing value passes through (so parseArg can report it)', () => {
-    const r = translatePositionalSubcommands(['--repo']);
-    expect(r.ok).toBe(true);
-    if (r.ok) expect(r.args).toEqual(['--repo']);
-  });
-
-  test('value-flag whose value looks like an alias is NOT translated', () => {
-    // `--repo status` means "use repo path 'status'", not "show status".
-    // Translator must not destructure the value of --repo.
-    const r = translatePositionalSubcommands(['--repo', 'status']);
-    expect(r.ok).toBe(true);
-    if (r.ok) expect(r.args).toEqual(['--repo', 'status']);
-  });
-});
-
-describe('translatePositionalSubcommands — pass-through cases', () => {
-  test('empty args returns empty args', () => {
-    const r = translatePositionalSubcommands([]);
-    expect(r.ok).toBe(true);
-    if (r.ok) expect(r.args).toEqual([]);
-  });
-
-  test('flag-only invocation passes through unchanged', () => {
-    const r = translatePositionalSubcommands(['--status', '--json']);
-    expect(r.ok).toBe(true);
-    if (r.ok) expect(r.args).toEqual(['--status', '--json']);
-  });
-
-  test('short flag `-h` passes through unchanged', () => {
-    const r = translatePositionalSubcommands(['-h']);
-    expect(r.ok).toBe(true);
-    if (r.ok) expect(r.args).toEqual(['-h']);
-  });
-
-  test('all known bare flags pass through unchanged', () => {
-    const flags = ['--help', '--install', '--uninstall', '--status', '--json', '--inline', '--no-worker'];
-    const r = translatePositionalSubcommands(flags);
-    expect(r.ok).toBe(true);
-    if (r.ok) expect(r.args).toEqual(flags);
-  });
-});
-
-describe('translatePositionalSubcommands — rejection of unknown positionals', () => {
-  test('unknown positional `foo` fails with reason=unknown_subcommand + structured message', () => {
-    const r = translatePositionalSubcommands(['foo']);
-    expect(r.ok).toBe(false);
-    if (!r.ok) {
-      expect(r.reason).toBe('unknown_subcommand');
-      expect(r.message).toContain('Unknown subcommand: `foo`');
-      expect(r.message).toContain('status');
-      expect(r.message).toContain('install');
-      expect(r.message).toContain('uninstall');
-      expect(r.message).toContain('--help');
-    }
-  });
-
-  test('unknown positional `stop` fails with reason=unknown_subcommand (NOT silently aliased)', () => {
-    // Stop is mentioned in the ticket but deliberately NOT aliased in this
-    // PR — stopping a running daemon is a new behavior, not just an alias.
-    // Until that feature lands separately, `stop` must fail loud rather
-    // than starting the daemon (the bug we're fixing).
-    const r = translatePositionalSubcommands(['stop']);
-    expect(r.ok).toBe(false);
-    if (!r.ok) {
-      expect(r.reason).toBe('unknown_subcommand');
-      expect(r.message).toContain('Unknown subcommand: `stop`');
-    }
-  });
-
-  test('unknown positional `status-detail` (close-but-not-matching) fails', () => {
-    const r = translatePositionalSubcommands(['status-detail']);
-    expect(r.ok).toBe(false);
-    if (!r.ok) {
-      expect(r.reason).toBe('unknown_subcommand');
-      expect(r.message).toContain('Unknown subcommand: `status-detail`');
-    }
-  });
-
-  test('multiple positionals fail with reason=multiple_subcommands (`start install`)', () => {
-    const r = translatePositionalSubcommands(['start', 'install']);
-    expect(r.ok).toBe(false);
-    if (!r.ok) {
-      expect(r.reason).toBe('multiple_subcommands');
-      expect(r.message).toContain('Multiple subcommands');
-    }
-  });
-
-  test('multiple positionals fail even when both are known aliases (`status install`)', () => {
-    const r = translatePositionalSubcommands(['status', 'install']);
-    expect(r.ok).toBe(false);
-    if (!r.ok) {
-      expect(r.reason).toBe('multiple_subcommands');
-      expect(r.message).toContain('Multiple subcommands');
-    }
-  });
-
-  test('known-then-unknown rejects with multiple_subcommands (first-positional-wins)', () => {
-    // First positional is known, second is not. Rejection comes from the
-    // multiple-positional rule, which fires before the unknown check; the
-    // intent is "only one subcommand allowed."
-    const r = translatePositionalSubcommands(['status', 'garbage']);
-    expect(r.ok).toBe(false);
-    if (!r.ok) expect(r.reason).toBe('multiple_subcommands');
-  });
-
-  test('unknown-then-known rejects on the unknown (unknown fires before second-positional check)', () => {
-    const r = translatePositionalSubcommands(['garbage', 'status']);
-    expect(r.ok).toBe(false);
-    if (!r.ok) {
-      expect(r.reason).toBe('unknown_subcommand');
-      expect(r.message).toContain('garbage');
-    }
-  });
-});

test/migrate-engine-dest-bootstrap.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, test } from 'bun:test';
+import { mkdtempSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join, resolve } from 'path';
+import { bootstrapDestinationConfig } from '../src/commands/migrate-engine.ts';
+import { loadConfigFileOnly } from '../src/core/config.ts';
+import { withEnv } from './helpers/with-env.ts';
+
+describe('migrate --to pglite destination bootstrap (#1271)', () => {
+  test('writes <path>/.gbrain/config.json so GBRAIN_HOME=<path> resolves a brain', async () => {
+    const dest = mkdtempSync(join(tmpdir(), 'gbrain-dest-'));
+    const written = bootstrapDestinationConfig(dest);
+    const file = join(dest, '.gbrain', 'config.json');
+    expect(written).toBe(file);
+
+    const cfg = JSON.parse(readFileSync(file, 'utf-8'));
+    expect(cfg.engine).toBe('pglite');
+    expect(cfg.database_path).toBe(resolve(dest));
+    expect(statSync(file).mode & 0o777).toBe(0o600);
+    // worktree safety: destination home is git-ignored like saveConfig()'s home
+    expect(readFileSync(join(dest, '.gbrain', '.gitignore'), 'utf-8')).toBe('*\n');
+
+    // The exact failure mode from #1271: config resolution under
+    // GBRAIN_HOME=<path> used to find nothing ("No brain configured").
+    await withEnv({ GBRAIN_HOME: dest }, () => {
+      const loaded = loadConfigFileOnly();
+      expect(loaded?.engine).toBe('pglite');
+      expect(loaded?.database_path).toBe(resolve(dest));
+    });
+  });
+
+  test('never clobbers an existing destination config', () => {
+    const dest = mkdtempSync(join(tmpdir(), 'gbrain-dest-'));
+    mkdirSync(join(dest, '.gbrain'), { recursive: true });
+    writeFileSync(join(dest, '.gbrain', 'config.json'), '{"engine":"postgres"}\n');
+
+    expect(bootstrapDestinationConfig(dest)).toBe(null);
+    expect(JSON.parse(readFileSync(join(dest, '.gbrain', 'config.json'), 'utf-8')).engine).toBe('postgres');
+  });
+});