Garry's Opinionated OpenClaw/Hermes Agent Brain
TypeScript
/**
* sources-ops tests — pure-function coverage for the v0.28 sources-management
* module. Runs against PGLite (zero-config in-memory). Real-Postgres E2E
* coverage lives in test/e2e/sources-remote-mcp.test.ts.
*/
import { test, expect, describe, beforeAll, afterAll, beforeEach, spyOn } from 'bun:test';
import {
mkdirSync,
writeFileSync,
rmSync,
symlinkSync,
chmodSync,
existsSync,
} from 'fs';
import { join } from 'path';
import { tmpdir } from 'os';
import { execFileSync } from 'child_process';
import { PGLiteEngine } from '../src/core/pglite-engine.ts';
import {
addSource,
listSources,
removeSource,
getSourceStatus,
recloneIfMissing,
isPathContained,
isOwnedClone,
unownedHint,
defaultCloneDir,
SourceOpError,
} from '../src/core/sources-ops.ts';
import { readdirSync } from 'fs';
import { runSources } from '../src/commands/sources.ts';
import { resetPgliteState } from './helpers/reset-pglite.ts';
import { withEnv } from './helpers/with-env.ts';
// Tier 3: every PGLite spinup path needs the snapshot env unset (test
// infrastructure detail; matches bootstrap.test.ts pattern).
let engine: PGLiteEngine;
const FAKE_GIT_DIR = join(tmpdir(), `gbrain-sources-ops-test-${process.pid}`);
const GBRAIN_HOME = join(FAKE_GIT_DIR, 'gbrain-home');
// gbrainPath() appends `.gbrain` to GBRAIN_HOME, so the actual clone root the
// production code resolves to is $GBRAIN_HOME/.gbrain/clones/. Tests that
// hand-craft path fixtures must use this, NOT $GBRAIN_HOME/clones/.
const CLONE_ROOT = join(GBRAIN_HOME, '.gbrain', 'clones');
// ---------------------------------------------------------------------------
// Fake-git harness — controllable success/failure so addSource's clone
// rollback paths are exercisable without real network.
// ---------------------------------------------------------------------------
function writeFakeGit(): void {
mkdirSync(FAKE_GIT_DIR, { recursive: true });
const modeFile = join(FAKE_GIT_DIR, 'mode');
writeFileSync(modeFile, 'ok');
// Fake git: first arg after SSRF flags is `clone`, then url, then dest.
// We just mkdir the dest and write a sentinel .git dir so the clone
// appears successful from the rest of the code's POV.
const script = `#!/usr/bin/env bash
mode=$(cat "${modeFile}" 2>/dev/null || echo ok)
case "$mode" in
clone-fail) exit 1 ;;
esac
# Detect verb by iterating argv (bash glob *" foo "* patterns are flaky
# with multiple verbs so we just walk the array).
has_clone=0
has_remote_get_url=0
for ((i=1; i<=$#; i++)); do
arg="\${!i}"
next_idx=$((i+1))
next="\${!next_idx:-}"
if [ "$arg" = "clone" ]; then has_clone=1; fi
if [ "$arg" = "remote" ] && [ "$next" = "get-url" ]; then has_remote_get_url=1; fi
done
if [ "$has_clone" = "1" ]; then
dest="\${@: -1}"
mkdir -p "$dest/.git"
echo "ref: refs/heads/main" > "$dest/.git/HEAD"
exit 0
fi
if [ "$has_remote_get_url" = "1" ]; then
echo "https://github.com/example/repo"
exit 0
fi
exit 0
`;
const path = join(FAKE_GIT_DIR, 'git');
writeFileSync(path, script);
chmodSync(path, 0o755);
}
function setMode(mode: 'ok' | 'clone-fail'): void {
writeFileSync(join(FAKE_GIT_DIR, 'mode'), mode);
}
const fakePath = (): string => `${FAKE_GIT_DIR}:${process.env.PATH ?? ''}`;
// ---------------------------------------------------------------------------
// PGLite lifecycle (R3 + R4 canonical block per CLAUDE.md test-isolation lint)
// ---------------------------------------------------------------------------
beforeAll(async () => {
writeFakeGit();
engine = new PGLiteEngine();
await engine.connect({});
await engine.initSchema();
});
afterAll(async () => {
await engine.disconnect();
rmSync(FAKE_GIT_DIR, { recursive: true, force: true });
});
beforeEach(async () => {
// resetPgliteState re-seeds the default source row (tests that rely on the
// v0.17 row get it from there; a second ON CONFLICT DO NOTHING insert here
// was always a no-op).
await resetPgliteState(engine);
// Reset GBRAIN_HOME fixtures between tests
rmSync(GBRAIN_HOME, { recursive: true, force: true });
mkdirSync(GBRAIN_HOME, { recursive: true });
setMode('ok');
});
// Run every test with GBRAIN_HOME pointing at our fixture dir AND fake git
// in PATH. Passed via withEnv so other test files in the shard don't see
// it leak.
async function withEnv2<T>(fn: () => Promise<T>): Promise<T> {
return withEnv(
{ GBRAIN_HOME, PATH: fakePath() },
fn,
);
}
// ---------------------------------------------------------------------------
// addSource — pre-flight collision (Q4)
// ---------------------------------------------------------------------------
describe('addSource — Q4 pre-flight collision', () => {
test('rejects existing id BEFORE any clone work', async () => {
await withEnv2(async () => {
const absent = join(tmpdir(), `gbrain-q4-absent-${process.pid}-${Date.now()}`);
await addSource(engine, { id: 'taken', localPath: absent });
try {
await addSource(engine, {
id: 'taken',
remoteUrl: 'https://github.com/example/repo',
});
throw new Error('expected throw');
} catch (e) {
expect(e).toBeInstanceOf(SourceOpError);
expect((e as SourceOpError).code).toBe('source_id_taken');
}
});
});
test('rejects invalid id format with structured error', async () => {
await withEnv2(async () => {
try {
await addSource(engine, { id: 'BadCaseId', localPath: '/tmp/b' });
throw new Error('expected throw');
} catch (e) {
expect(e).toBeInstanceOf(SourceOpError);
expect((e as SourceOpError).code).toBe('invalid_id');
}
});
});
});
// ---------------------------------------------------------------------------
// addSource — happy paths (localPath only AND remoteUrl)
// ---------------------------------------------------------------------------
describe('addSource — happy paths', () => {
test('localPath only (existing v0.17+ behavior preserved)', async () => {
await withEnv2(async () => {
const row = await addSource(engine, {
id: 'wiki',
localPath: '/tmp/wiki-fixture',
federated: true,
});
expect(row.id).toBe('wiki');
expect(row.local_path).toBe('/tmp/wiki-fixture');
expect(row.config).toEqual({ federated: true });
});
});
test('remoteUrl: clones, INSERTs, renames atomically', async () => {
await withEnv2(async () => {
const row = await addSource(engine, {
id: 'yc-artifacts',
remoteUrl: 'https://github.com/example/repo',
federated: true,
});
expect(row.id).toBe('yc-artifacts');
expect(row.local_path).toBe(defaultCloneDir('yc-artifacts'));
expect((row.config as any).remote_url).toBe('https://github.com/example/repo');
expect((row.config as any).federated).toBe(true);
// Final clone dir exists with .git inside
expect(existsSync(join(row.local_path!, '.git'))).toBe(true);
// Temp dir was renamed away (parent persists)
expect(existsSync(join(CLONE_ROOT, '.tmp'))).toBe(true);
});
});
test('rejects internal-target URL via parseRemoteUrl gate', async () => {
await withEnv2(async () => {
try {
await addSource(engine, {
id: 'bad',
remoteUrl: 'https://192.168.1.1/x.git',
});
throw new Error('expected throw');
} catch (e) {
expect(e).toBeInstanceOf(SourceOpError);
expect((e as SourceOpError).code).toBe('invalid_remote_url');
}
});
});
});
// ---------------------------------------------------------------------------
// addSource — D3 atomic-rollback paths
// ---------------------------------------------------------------------------
describe('addSource — D3 rollback', () => {
test('clone failure: tempDir cleaned + no DB row', async () => {
await withEnv2(async () => {
setMode('clone-fail');
try {
await addSource(engine, {
id: 'fail-clone',
remoteUrl: 'https://github.com/example/repo',
});
throw new Error('expected throw');
} catch (e) {
expect(e).toBeInstanceOf(SourceOpError);
expect((e as SourceOpError).code).toBe('clone_failed');
}
const rows = await engine.executeRaw(
`SELECT id FROM sources WHERE id = $1`,
['fail-clone'],
);
expect(rows.length).toBe(0);
});
});
test('INSERT failure after successful clone: tempDir cleaned + no row', async () => {
await withEnv2(async () => {
// Pre-create the row so INSERT (without ON CONFLICT) violates PK.
await engine.executeRaw(
`INSERT INTO sources (id, name, local_path, config) VALUES ('insert-collision', 'fixture', '/somewhere', '{}'::jsonb)`,
);
try {
await addSource(engine, {
id: 'insert-collision',
remoteUrl: 'https://github.com/example/repo',
});
throw new Error('expected throw');
} catch (e) {
expect(e).toBeInstanceOf(SourceOpError);
// Could be 'source_id_taken' (caught at pre-flight) — that's the
// intended behavior since pre-flight catches the case before clone.
expect(['source_id_taken', 'insert_failed']).toContain(
(e as SourceOpError).code,
);
}
// Make sure no .tmp/ entry leaked.
const tmp = join(CLONE_ROOT, '.tmp');
if (existsSync(tmp)) {
const fs = await import('fs');
expect(fs.readdirSync(tmp)).toEqual([]);
}
});
});
});
// ---------------------------------------------------------------------------
// listSources — surfaces remote_url
// ---------------------------------------------------------------------------
describe('listSources', () => {
test('exposes remote_url field for remoteUrl-managed sources', async () => {
await withEnv2(async () => {
await addSource(engine, {
id: 'with-url',
remoteUrl: 'https://github.com/example/repo',
federated: true,
});
await addSource(engine, { id: 'with-path', localPath: '/tmp/p' });
const list = await listSources(engine);
const withUrl = list.find(e => e.id === 'with-url');
const withPath = list.find(e => e.id === 'with-path');
expect(withUrl?.remote_url).toBe('https://github.com/example/repo');
expect(withPath?.remote_url).toBeNull();
});
});
});
// ---------------------------------------------------------------------------
// removeSource — symlink-safe clone-cleanup
// ---------------------------------------------------------------------------
describe('removeSource — clone-cleanup', () => {
test('counts soft-deleted pages for destructive removal while list/status show active pages', async () => {
await withEnv2(async () => {
await addSource(engine, { id: 'soft-only', localPath: '/tmp/soft-only-fixture' });
await engine.putPage(
'notes/recoverable',
{
type: 'note',
title: 'Recoverable',
compiled_truth: 'still recoverable during the soft-delete window',
timeline: '',
frontmatter: {},
},
{ sourceId: 'soft-only' },
);
expect(await engine.softDeletePage('notes/recoverable', { sourceId: 'soft-only' }))
.toEqual({ slug: 'notes/recoverable' });
const listed = await listSources(engine);
expect(listed.find((s) => s.id === 'soft-only')?.page_count).toBe(0);
const status = await getSourceStatus(engine, 'soft-only');
expect(status.page_count).toBe(0);
const dryRun = await removeSource(engine, { id: 'soft-only', dryRun: true });
expect(dryRun.pages_deleted).toBe(1);
try {
await removeSource(engine, { id: 'soft-only' });
throw new Error('expected throw');
} catch (e) {
expect(e).toBeInstanceOf(SourceOpError);
expect((e as SourceOpError).message).toContain('with 1 pages');
}
});
});
test('removes clone IFF managed (local_path under $GBRAIN_HOME/clones/ + remote_url set)', async () => {
await withEnv2(async () => {
const row = await addSource(engine, {
id: 'cleanup-yes',
remoteUrl: 'https://github.com/example/repo',
});
const clonePath = row.local_path!;
expect(existsSync(clonePath)).toBe(true);
const result = await removeSource(engine, {
id: 'cleanup-yes',
confirmDestructive: true,
});
expect(result.clone_removed).toBe(true);
expect(existsSync(clonePath)).toBe(false);
});
});
test('does NOT remove clone for user-supplied --path (no remote_url)', async () => {
await withEnv2(async () => {
const userPath = join(GBRAIN_HOME, 'user-managed-fixture');
mkdirSync(userPath, { recursive: true });
writeFileSync(join(userPath, 'file'), 'hi');
// #2707: this fixture is intentionally not a git repo (unrelated to
// what this test covers — clone-cleanup ownership) — force past the
// registration-time git check.
await addSource(engine, { id: 'cleanup-no', localPath: userPath, force: true });
const result = await removeSource(engine, {
id: 'cleanup-no',
confirmDestructive: true,
});
expect(result.clone_removed).toBe(false);
expect(existsSync(userPath)).toBe(true); // user dir intact
rmSync(userPath, { recursive: true, force: true });
});
});
test('symlink-target-OUTSIDE-clones: realpath confinement foils escape', async () => {
await withEnv2(async () => {
// Attacker replaces $CLONE_ROOT/evil with a symlink to a sibling dir
// (e.g. ~/.ssh, /etc). The realpath check in isPathContained resolves
// the link and rejects because the target isn't under the clones/
// confine. removeSource skips cleanup and just deletes the DB row.
// Sentinel stays intact.
const target = join(GBRAIN_HOME, 'sensitive-fixture');
mkdirSync(target, { recursive: true });
writeFileSync(join(target, 'sentinel'), 'do-not-touch');
const linkPath = join(CLONE_ROOT, 'evil');
mkdirSync(CLONE_ROOT, { recursive: true });
symlinkSync(target, linkPath);
await engine.executeRaw(
`INSERT INTO sources (id, name, local_path, config) VALUES ('evil', 'evil', $1, $2::jsonb)`,
[linkPath, JSON.stringify({ remote_url: 'https://github.com/x/y' })],
);
const result = await removeSource(engine, {
id: 'evil',
confirmDestructive: true,
});
expect(result.clone_removed).toBe(false);
// Sentinel must still exist — symlink target untouched (THE attack
// we're defending against).
expect(existsSync(join(target, 'sentinel'))).toBe(true);
// Symlink itself is also untouched.
expect(existsSync(linkPath)).toBe(true);
rmSync(target, { recursive: true, force: true });
rmSync(linkPath, { force: true });
});
});
test('symlink-target-INSIDE-clones: lstat check refuses with symlink_escape', async () => {
await withEnv2(async () => {
// Edge case: symlink that resolves INSIDE clones/ (so isPathContained
// returns true), but the symlink itself is the local_path. lstat-check
// detects this and refuses rather than rm-rfing the resolved target.
mkdirSync(join(CLONE_ROOT, 'real-target'), { recursive: true });
writeFileSync(
join(CLONE_ROOT, 'real-target', 'sentinel'),
'do-not-touch',
);
const linkPath = join(CLONE_ROOT, 'symlink-source');
symlinkSync(join(CLONE_ROOT, 'real-target'), linkPath);
await engine.executeRaw(
`INSERT INTO sources (id, name, local_path, config) VALUES ('inner-symlink', 'x', $1, $2::jsonb)`,
[linkPath, JSON.stringify({ remote_url: 'https://github.com/x/y' })],
);
try {
await removeSource(engine, {
id: 'inner-symlink',
confirmDestructive: true,
});
throw new Error('expected throw');
} catch (e) {
expect(e).toBeInstanceOf(SourceOpError);
expect((e as SourceOpError).code).toBe('symlink_escape');
}
// Sentinel preserved through rm-rf-via-symlink attack.
expect(
existsSync(join(CLONE_ROOT, 'real-target', 'sentinel')),
).toBe(true);
rmSync(linkPath, { force: true });
rmSync(join(CLONE_ROOT, 'real-target'), { recursive: true, force: true });
});
});
test('refuses to remove "default" source', async () => {
await withEnv2(async () => {
try {
await removeSource(engine, { id: 'default', confirmDestructive: true });
throw new Error('expected throw');
} catch (e) {
expect(e).toBeInstanceOf(SourceOpError);
expect((e as SourceOpError).code).toBe('protected_id');
}
});
});
});
// ---------------------------------------------------------------------------
// getSourceStatus — clone_state branches
// ---------------------------------------------------------------------------
describe('getSourceStatus', () => {
test('clone_state = "healthy" for working clone', async () => {
await withEnv2(async () => {
await addSource(engine, {
id: 'status-healthy',
remoteUrl: 'https://github.com/example/repo',
});
const s = await getSourceStatus(engine, 'status-healthy');
expect(s.clone_state).toBe('healthy');
expect(s.remote_url).toBe('https://github.com/example/repo');
});
});
test('clone_state = "missing" when clone dir was rmd', async () => {
await withEnv2(async () => {
const row = await addSource(engine, {
id: 'status-missing',
remoteUrl: 'https://github.com/example/repo',
});
rmSync(row.local_path!, { recursive: true, force: true });
const s = await getSourceStatus(engine, 'status-missing');
expect(s.clone_state).toBe('missing');
});
});
test('clone_state = "not-applicable" for path-only source (no remote)', async () => {
await withEnv2(async () => {
const userPath = join(GBRAIN_HOME, 'na-fixture');
mkdirSync(userPath, { recursive: true });
// path-only source still gets validateRepoState — but with no expected
// URL, it just probes existence + .git. Path exists with no .git → 'no-git'.
// To match contract docstring we'd want 'not-applicable' only when
// local_path is null. Test the truthful behavior. #2707: this fixture
// is deliberately no-git (that's what's under test for getSourceStatus)
// — force past the registration-time git check to construct it.
await addSource(engine, { id: 'status-no-url', localPath: userPath, force: true });
const s = await getSourceStatus(engine, 'status-no-url');
// local_path set but no .git: returns 'no-git'
expect(s.clone_state).toBe('no-git');
expect(s.remote_url).toBeNull();
rmSync(userPath, { recursive: true, force: true });
});
});
test('throws not_found for unknown id', async () => {
await withEnv2(async () => {
try {
await getSourceStatus(engine, 'never-existed');
throw new Error('expected throw');
} catch (e) {
expect(e).toBeInstanceOf(SourceOpError);
expect((e as SourceOpError).code).toBe('not_found');
}
});
});
});
// ---------------------------------------------------------------------------
// T4 — recloneIfMissing (restore-with-autopurged-clone path)
// ---------------------------------------------------------------------------
describe('recloneIfMissing — T4 restore + autopurge recovery', () => {
test('re-clones when local_path is missing on disk', async () => {
await withEnv2(async () => {
const row = await addSource(engine, {
id: 't4-purged',
remoteUrl: 'https://github.com/example/repo',
});
rmSync(row.local_path!, { recursive: true, force: true });
expect(existsSync(row.local_path!)).toBe(false);
const recloned = await recloneIfMissing(engine, 't4-purged');
expect(recloned).toBe(true);
expect(existsSync(join(row.local_path!, '.git'))).toBe(true);
});
});
test('returns false when clone is already healthy (idempotent)', async () => {
await withEnv2(async () => {
await addSource(engine, {
id: 't4-healthy',
remoteUrl: 'https://github.com/example/repo',
});
const recloned = await recloneIfMissing(engine, 't4-healthy');
expect(recloned).toBe(false);
});
});
test('returns false when source has no remote_url (path-only)', async () => {
await withEnv2(async () => {
await addSource(engine, { id: 't4-no-url', localPath: '/tmp/anywhere' });
const recloned = await recloneIfMissing(engine, 't4-no-url');
expect(recloned).toBe(false);
});
});
});
// ---------------------------------------------------------------------------
// #1881 — ownership guard: recloneIfMissing must NEVER delete a user working
// tree. Ownership (config.managed_clone OR default-location equality), not
// path-containment.
// ---------------------------------------------------------------------------
describe('isOwnedClone — ownership predicate', () => {
test('marker config.managed_clone:true → owned (even at an external path)', async () => {
await withEnv2(async () => {
expect(
isOwnedClone({
id: 'x',
local_path: '/some/external/path',
config: { remote_url: 'https://github.com/example/repo', managed_clone: true },
}),
).toBe(true);
});
});
test('default-location clone, no marker → owned (back-compat equality)', async () => {
await withEnv2(async () => {
expect(
isOwnedClone({
id: 'legacy',
local_path: defaultCloneDir('legacy'),
config: { remote_url: 'https://github.com/example/repo' },
}),
).toBe(true);
});
});
test('external path, no marker → NOT owned (the #1881 federated shape)', async () => {
await withEnv2(async () => {
expect(
isOwnedClone({
id: 'gstack-code-app-abc',
local_path: '/Users/dev/tt-flutter-app',
config: { remote_url: 'https://github.com/example/repo', federated: true },
}),
).toBe(false);
});
});
test('null local_path → NOT owned', async () => {
await withEnv2(async () => {
expect(isOwnedClone({ id: 'x', local_path: null, config: {} })).toBe(false);
});
});
test('config as JSON string (DB shape) is parsed', async () => {
await withEnv2(async () => {
expect(
isOwnedClone({
id: 'x',
local_path: '/external',
config: JSON.stringify({ managed_clone: true }),
}),
).toBe(true);
});
});
});
describe('unownedHint — healthy vs degraded guidance', () => {
test('healthy: read-only guidance, no "missing clone" framing', () => {
const msg = unownedHint({ id: 'x', local_path: '/Users/dev/repo' }, 'healthy');
expect(msg).toMatch(/read-only/);
expect(msg).toMatch(/drop config\.remote_url/);
expect(msg).not.toMatch(/not a usable git repo/);
});
test('degraded: names the state and does not suggest dropping remote_url alone recovers it', () => {
const msg = unownedHint({ id: 'x', local_path: '/Users/dev/repo' }, 'no-git');
expect(msg).toMatch(/not a usable git repo/);
expect(msg).toMatch(/no-git/);
});
});
describe('recloneIfMissing — refuses to delete an unowned working tree (#1881)', () => {
test('external local_path + remote_url, no marker → throws unmanaged_path, tree survives', async () => {
await withEnv2(async () => {
// Simulate the gstack orchestrator's federated row: remote_url set, but
// local_path points at a live user working tree (no .git → no-git state),
// and NO managed_clone marker.
const userTree = join(FAKE_GIT_DIR, 'user-working-tree');
rmSync(userTree, { recursive: true, force: true });
mkdirSync(userTree, { recursive: true });
const sentinel = join(userTree, 'KEEP_ME.txt');
writeFileSync(sentinel, 'two unpushed commits live here');
await engine.executeRaw(
`INSERT INTO sources (id, name, local_path, config)
VALUES ('gstack-code-app-abc', 'flutter', $1,
'{"remote_url":"https://github.com/example/repo","federated":true}'::jsonb)`,
[userTree],
);
let threw: SourceOpError | null = null;
try {
await recloneIfMissing(engine, 'gstack-code-app-abc');
} catch (e) {
threw = e as SourceOpError;
}
expect(threw).toBeInstanceOf(SourceOpError);
expect(threw?.code).toBe('unmanaged_path');
// The working tree and its sentinel MUST survive untouched.
expect(existsSync(userTree)).toBe(true);
expect(existsSync(sentinel)).toBe(true);
});
});
test('sync-shape: same refusal surfaces before any filesystem op', async () => {
await withEnv2(async () => {
// A degraded unowned path (the path does not exist at all → missing).
const ghost = join(FAKE_GIT_DIR, 'ghost-tree');
rmSync(ghost, { recursive: true, force: true });
await engine.executeRaw(
`INSERT INTO sources (id, name, local_path, config)
VALUES ('ghost', 'g', $1,
'{"remote_url":"https://github.com/example/repo"}'::jsonb)`,
[ghost],
);
await expect(recloneIfMissing(engine, 'ghost')).rejects.toThrow(/unmanaged_path|not a clone gbrain created/);
});
});
});
describe('recloneIfMissing — symlink TOCTOU + EXDEV-safe swap', () => {
test('symlink at an owned default-location path → symlink_escape, target untouched', async () => {
await withEnv2(async () => {
// Owned by equality: local_path === defaultCloneDir(id). But the path is a
// symlink to a real dir → reclone must refuse rather than rename through it.
const id = 'sym-owned';
const target = join(FAKE_GIT_DIR, 'sym-target');
rmSync(target, { recursive: true, force: true });
mkdirSync(target, { recursive: true });
const targetSentinel = join(target, 'precious.txt');
writeFileSync(targetSentinel, 'do not delete');
mkdirSync(CLONE_ROOT, { recursive: true });
const clonePath = defaultCloneDir(id); // = CLONE_ROOT/sym-owned
symlinkSync(target, clonePath);
await engine.executeRaw(
`INSERT INTO sources (id, name, local_path, config)
VALUES ($1, 's', $2,
'{"remote_url":"https://github.com/example/repo"}'::jsonb)`,
[id, clonePath],
);
let threw: SourceOpError | null = null;
try {
await recloneIfMissing(engine, id);
} catch (e) {
threw = e as SourceOpError;
}
expect(threw?.code).toBe('symlink_escape');
// Symlink target and its contents survive.
expect(existsSync(targetSentinel)).toBe(true);
});
});
test('owned no-git clone reclones; no .gbrain-reclone-* / .old-* residue left', async () => {
await withEnv2(async () => {
const row = await addSource(engine, {
id: 'swap-clean',
remoteUrl: 'https://github.com/example/repo',
});
// Degrade to no-git so reclone fires.
rmSync(join(row.local_path!, '.git'), { recursive: true, force: true });
const recloned = await recloneIfMissing(engine, 'swap-clean');
expect(recloned).toBe(true);
expect(existsSync(join(row.local_path!, '.git'))).toBe(true);
// Parent (CLONE_ROOT) must hold no swap residue.
const residue = readdirSync(CLONE_ROOT).filter(
(e) => e.startsWith('.gbrain-reclone-') || e.includes('.old-'),
);
expect(residue).toEqual([]);
});
});
});
describe('sources restore — unowned source (CV3)', () => {
test('restore of an unowned remote_url row: DB row restored, tree survives, correct guidance', async () => {
await withEnv2(async () => {
// Archived federated row: remote_url set, local_path = a live user tree
// (no .git, no managed_clone marker). Restore calls recloneIfMissing,
// which now throws unmanaged_path; runRestore must catch it, keep the tree,
// and NOT print the misleading "missing clone, try sync to recover" hint.
const userTree = join(FAKE_GIT_DIR, 'restore-user-tree');
rmSync(userTree, { recursive: true, force: true });
mkdirSync(userTree, { recursive: true });
const sentinel = join(userTree, 'KEEP_ME.txt');
writeFileSync(sentinel, 'live repo');
await engine.executeRaw(
`INSERT INTO sources (id, name, local_path, config, archived)
VALUES ('restore-unowned', 'flutter', $1,
'{"remote_url":"https://github.com/example/repo","federated":false}'::jsonb,
true)`,
[userTree],
);
const errs: string[] = [];
const origErr = console.error;
console.error = (...a: unknown[]) => { errs.push(a.join(' ')); };
try {
// Real CLI dispatch → runRestore. Must not throw.
await runSources(engine, ['restore', 'restore-unowned']);
} finally {
console.error = origErr;
}
// DB row un-archived (restore succeeded).
const rows = await engine.executeRaw<{ archived: boolean }>(
`SELECT archived FROM sources WHERE id = 'restore-unowned'`,
);
expect(rows[0].archived).toBe(false);
// Working tree untouched.
expect(existsSync(userTree)).toBe(true);
expect(existsSync(sentinel)).toBe(true);
// Guidance is the read-only one, NOT the misleading "missing clone" hint.
const joined = errs.join('\n');
expect(joined).toMatch(/read-only/);
expect(joined).not.toMatch(/on-disk clone is missing/);
});
});
});
describe('addSource --url — writes ownership marker', () => {
test('config carries managed_clone:true', async () => {
await withEnv2(async () => {
await addSource(engine, {
id: 'marked',
remoteUrl: 'https://github.com/example/repo',
});
const rows = await engine.executeRaw<{ config: unknown }>(
`SELECT config FROM sources WHERE id = 'marked'`,
);
const cfg =
typeof rows[0].config === 'string'
? JSON.parse(rows[0].config as string)
: (rows[0].config as Record<string, unknown>);
expect(cfg.managed_clone).toBe(true);
});
});
test('--clone-dir clone (external path) is owned via marker and reclones', async () => {
await withEnv2(async () => {
const externalClone = join(FAKE_GIT_DIR, 'custom-clone-dir');
rmSync(externalClone, { recursive: true, force: true });
const row = await addSource(engine, {
id: 'cdir',
remoteUrl: 'https://github.com/example/repo',
cloneDir: externalClone,
});
expect(row.local_path).toBe(externalClone);
// Remove the leaf → reclone must succeed (owned via marker, NOT containment).
rmSync(externalClone, { recursive: true, force: true });
const recloned = await recloneIfMissing(engine, 'cdir');
expect(recloned).toBe(true);
expect(existsSync(join(externalClone, '.git'))).toBe(true);
});
});
});
// ---------------------------------------------------------------------------
// addSource --path — #2707 git-repo validation at registration time
//
// Deliberately does NOT run under withEnv2 (the fake-git harness above):
// writeFakeGit()'s catch-all `exit 0` would make `rev-parse --show-toplevel`
// (and therefore isInsideGitRepo) succeed unconditionally for any path,
// which defeats the point of these tests. Real system git applies here.
// ---------------------------------------------------------------------------
describe('addSource --path — #2707 git-repo validation', () => {
const SANDBOX = join(tmpdir(), `gbrain-2707-git-validate-${process.pid}`);
beforeEach(() => {
rmSync(SANDBOX, { recursive: true, force: true });
mkdirSync(SANDBOX, { recursive: true });
});
afterAll(() => {
rmSync(SANDBOX, { recursive: true, force: true });
});
test('registers an existing plain directory outside any git repository without --force (GST-2732)', async () => {
const plainDir = join(SANDBOX, 'plain-ok');
mkdirSync(plainDir, { recursive: true });
writeFileSync(join(plainDir, 'notes.md'), 'a plain folder');
const row = await addSource(engine, { id: 'plain-ok-src', localPath: plainDir });
expect(row.local_path).toBe(plainDir);
});
test('a folder with a .git entry that git cannot read is not a plain folder: refused like sync would treat it (GST-2732)', async () => {
const brokenDir = join(SANDBOX, 'broken-gitlink');
mkdirSync(brokenDir, { recursive: true });
writeFileSync(join(brokenDir, '.git'), 'gitdir: /nonexistent/gbrain-gst2732\n');
writeFileSync(join(brokenDir, 'notes.md'), 'inside a checkout git cannot open');
let threw: SourceOpError | undefined;
try {
await addSource(engine, { id: 'broken-gitlink-src', localPath: brokenDir });
} catch (e) {
threw = e as SourceOpError;
}
expect(threw?.code).toBe('not_a_git_repo');
});
test('rejects a git repository with untracked files only, with an actionable error', async () => {
const plainDir = join(SANDBOX, 'plain');
mkdirSync(plainDir, { recursive: true });
execFileSync('git', ['-C', plainDir, 'init', '-q']);
writeFileSync(join(plainDir, 'notes.md'), 'not committed anywhere');
let threw: SourceOpError | undefined;
try {
await addSource(engine, { id: 'plain-src', localPath: plainDir });
} catch (e) {
threw = e as SourceOpError;
}
expect(threw).toBeInstanceOf(SourceOpError);
expect(threw?.code).toBe('not_a_git_repo');
expect(threw?.message).toContain(plainDir);
expect(threw?.message).toContain('--force');
expect(threw?.message).toMatch(/git .*init/);
// Source was never registered — no partial row left behind.
const rows = await engine.executeRaw<{ id: string }>(
`SELECT id FROM sources WHERE id = 'plain-src'`,
);
expect(rows.length).toBe(0);
});
test('rejects a git-initialized directory with zero commits (codex round 1)', async () => {
const unbornDir = join(SANDBOX, 'unborn');
mkdirSync(unbornDir, { recursive: true });
execFileSync('git', ['-C', unbornDir, 'init', '-q']);
// No `git add` / `git commit` — isInsideGitRepo alone would pass this.
let threw: SourceOpError | undefined;
try {
await addSource(engine, { id: 'unborn-src', localPath: unbornDir });
} catch (e) {
threw = e as SourceOpError;
}
expect(threw).toBeInstanceOf(SourceOpError);
expect(threw?.code).toBe('not_a_git_repo');
});
test('rejects an empty-commit repo whose files are untracked (codex round 2)', async () => {
// git commit --allow-empty gives a resolvable HEAD (so a bare "has a
// commit" check would wrongly pass this) but the tree is empty; files
// written afterward are untracked and invisible to the sync walker.
const emptyCommitDir = join(SANDBOX, 'empty-commit');
mkdirSync(emptyCommitDir, { recursive: true });
execFileSync('git', ['-C', emptyCommitDir, 'init', '-q']);
execFileSync('git', ['-C', emptyCommitDir, 'config', 'user.email', '[email protected]']);
execFileSync('git', ['-C', emptyCommitDir, 'config', 'user.name', 'Test']);
execFileSync('git', ['-C', emptyCommitDir, 'commit', '--allow-empty', '-q', '-m', 'empty']);
writeFileSync(join(emptyCommitDir, 'notes.md'), 'never committed');
let threw: SourceOpError | undefined;
try {
await addSource(engine, { id: 'empty-commit-src', localPath: emptyCommitDir });
} catch (e) {
threw = e as SourceOpError;
}
expect(threw).toBeInstanceOf(SourceOpError);
expect(threw?.code).toBe('not_a_git_repo');
});
test('rejects an untracked subdirectory of an otherwise-real git repo (codex round 2)', async () => {
const parent = join(SANDBOX, 'partial-repo');
const trackedFile = join(parent, 'README.md');
const untrackedSub = join(parent, 'untracked-sub');
mkdirSync(untrackedSub, { recursive: true });
writeFileSync(trackedFile, '# fixture');
execFileSync('git', ['-C', parent, 'init', '-q']);
execFileSync('git', ['-C', parent, 'config', 'user.email', '[email protected]']);
execFileSync('git', ['-C', parent, 'config', 'user.name', 'Test']);
execFileSync('git', ['-C', parent, 'add', 'README.md']);
execFileSync('git', ['-C', parent, 'commit', '-q', '-m', 'initial import']);
writeFileSync(join(untrackedSub, 'x.md'), 'never git add-ed');
let threw: SourceOpError | undefined;
try {
await addSource(engine, { id: 'partial-repo-src', localPath: untrackedSub });
} catch (e) {
threw = e as SourceOpError;
}
expect(threw).toBeInstanceOf(SourceOpError);
expect(threw?.code).toBe('not_a_git_repo');
});
test('registers a repo with many tracked entries without buffer-size false rejection (codex round 3)', async () => {
// Codex round 3 (P2): the earlier `git ls-tree` listing implementation
// buffered the whole tree and could exceed execFileSync's default 1 MiB
// maxBuffer on a large repo, causing an incorrect rejection. The
// rev-parse HEAD:./ + empty-tree-SHA-comparison implementation reads a
// fixed ~40-byte SHA regardless of tree size — this locks that in.
const bigDir = join(SANDBOX, 'many-entries');
mkdirSync(bigDir, { recursive: true });
for (let i = 0; i < 300; i++) {
writeFileSync(join(bigDir, `file-${i}.md`), `# entry ${i}`);
}
execFileSync('git', ['-C', bigDir, 'init', '-q']);
execFileSync('git', ['-C', bigDir, 'config', 'user.email', '[email protected]']);
execFileSync('git', ['-C', bigDir, 'config', 'user.name', 'Test']);
execFileSync('git', ['-C', bigDir, 'add', '-A']);
execFileSync('git', ['-C', bigDir, 'commit', '-q', '-m', 'many files']);
const row = await addSource(engine, { id: 'many-entries-src', localPath: bigDir });
expect(row.local_path).toBe(bigDir);
});
// Codex round 4 (P2): the empty-tree OID is hash-algorithm-specific — a
// hardcoded SHA-1 constant silently mismatched (and so accepted) an empty
// SHA-256 repo. --object-format=sha256 needs git 2.29+; skip rather than
// hard-fail on an older CI git.
const SHA256_SUPPORTED = (() => {
try {
const probe = join(tmpdir(), `gbrain-2707-sha256-probe-${process.pid}`);
mkdirSync(probe, { recursive: true });
execFileSync('git', ['-C', probe, 'init', '-q', '--object-format=sha256'], {
stdio: ['ignore', 'pipe', 'pipe'],
});
rmSync(probe, { recursive: true, force: true });
return true;
} catch {
return false;
}
})();
test.skipIf(!SHA256_SUPPORTED)(
'rejects an empty-commit SHA-256 repo the same as a SHA-1 one (codex round 4)',
async () => {
const sha256Dir = join(SANDBOX, 'sha256-empty');
mkdirSync(sha256Dir, { recursive: true });
execFileSync('git', ['-C', sha256Dir, 'init', '-q', '--object-format=sha256']);
execFileSync('git', ['-C', sha256Dir, 'config', 'user.email', '[email protected]']);
execFileSync('git', ['-C', sha256Dir, 'config', 'user.name', 'Test']);
execFileSync('git', ['-C', sha256Dir, 'commit', '--allow-empty', '-q', '-m', 'empty']);
writeFileSync(join(sha256Dir, 'notes.md'), 'never committed');
let threw: SourceOpError | undefined;
try {
await addSource(engine, { id: 'sha256-empty-src', localPath: sha256Dir });
} catch (e) {
threw = e as SourceOpError;
}
expect(threw).toBeInstanceOf(SourceOpError);
expect(threw?.code).toBe('not_a_git_repo');
},
);
test.skipIf(!SHA256_SUPPORTED)(
'registers a SHA-256 repo with real committed content (no regression)',
async () => {
const sha256Dir = join(SANDBOX, 'sha256-real');
mkdirSync(sha256Dir, { recursive: true });
writeFileSync(join(sha256Dir, 'README.md'), '# fixture');
execFileSync('git', ['-C', sha256Dir, 'init', '-q', '--object-format=sha256']);
execFileSync('git', ['-C', sha256Dir, 'config', 'user.email', '[email protected]']);
execFileSync('git', ['-C', sha256Dir, 'config', 'user.name', 'Test']);
execFileSync('git', ['-C', sha256Dir, 'add', '-A']);
execFileSync('git', ['-C', sha256Dir, 'commit', '-q', '-m', 'initial import']);
const row = await addSource(engine, { id: 'sha256-real-src', localPath: sha256Dir });
expect(row.local_path).toBe(sha256Dir);
},
);
test('quotes a path with a space in the remediation command (codex round 1)', async () => {
const spacedDir = join(SANDBOX, 'has space here');
mkdirSync(spacedDir, { recursive: true });
execFileSync('git', ['-C', spacedDir, 'init', '-q']);
let threw: SourceOpError | undefined;
try {
await addSource(engine, { id: 'spaced-src', localPath: spacedDir });
} catch (e) {
threw = e as SourceOpError;
}
expect(threw?.message).toContain(`'${spacedDir}'`);
});
test('--force bypasses the check and registers the plain directory as-is', async () => {
const plainDir = join(SANDBOX, 'plain-forced');
mkdirSync(plainDir, { recursive: true });
const row = await addSource(engine, {
id: 'plain-forced-src',
localPath: plainDir,
force: true,
});
expect(row.local_path).toBe(plainDir);
});
test('an already git-initialized directory registers unaffected (no regression)', async () => {
const gitDir = join(SANDBOX, 'gitrepo');
mkdirSync(gitDir, { recursive: true });
writeFileSync(join(gitDir, 'README.md'), '# fixture');
execFileSync('git', ['-C', gitDir, 'init', '-q']);
execFileSync('git', ['-C', gitDir, 'config', 'user.email', '[email protected]']);
execFileSync('git', ['-C', gitDir, 'config', 'user.name', 'Test']);
execFileSync('git', ['-C', gitDir, 'add', '-A']);
execFileSync('git', ['-C', gitDir, 'commit', '-q', '-m', 'initial import']);
const row = await addSource(engine, { id: 'gitrepo-src', localPath: gitDir });
expect(row.local_path).toBe(gitDir);
});
test('a subdirectory of a git repo registers unaffected (#753/#774 parity with sync-time discovery)', async () => {
const gitDir = join(SANDBOX, 'gitrepo-parent');
const subDir = join(gitDir, 'sub');
mkdirSync(subDir, { recursive: true });
writeFileSync(join(subDir, 'README.md'), '# fixture');
execFileSync('git', ['-C', gitDir, 'init', '-q']);
execFileSync('git', ['-C', gitDir, 'config', 'user.email', '[email protected]']);
execFileSync('git', ['-C', gitDir, 'config', 'user.name', 'Test']);
execFileSync('git', ['-C', gitDir, 'add', '-A']);
execFileSync('git', ['-C', gitDir, 'commit', '-q', '-m', 'initial import']);
const row = await addSource(engine, { id: 'subdir-src', localPath: subDir });
expect(row.local_path).toBe(subDir);
});
test('a not-yet-created path is unaffected (pre-existing lenient behavior, out of #2707 scope)', async () => {
const missingDir = join(SANDBOX, 'does-not-exist-yet');
expect(existsSync(missingDir)).toBe(false);
const row = await addSource(engine, { id: 'missing-src', localPath: missingDir });
expect(row.local_path).toBe(missingDir);
});
});
// ---------------------------------------------------------------------------
// addSource --path — #3903 attach path to an existing path-less source
//
// `gbrain sync --source X` on a no-local_path source prints
// "Run: gbrain sources add X --path <path>", but addSource used to throw
// source_id_taken for ANY existing id — the only recovery it offered was
// `sources remove --confirm-destructive`, which cascades page deletion.
// Attaching a local_path to an existing row with local_path IS NULL is
// non-destructive and is exactly what the sync hint promises.
//
// Runs OUTSIDE withEnv2 (real system git) because the attach path reuses the
// #2707 git validation, which the fake-git harness defeats.
// ---------------------------------------------------------------------------
describe('addSource --path — #3903 attach to existing path-less source', () => {
const SANDBOX = join(tmpdir(), `gbrain-3903-attach-${process.pid}`);
function makeGitRepo(name: string): string {
const dir = join(SANDBOX, name);
mkdirSync(dir, { recursive: true });
writeFileSync(join(dir, 'README.md'), '# fixture');
execFileSync('git', ['-C', dir, 'init', '-q']);
execFileSync('git', ['-C', dir, 'config', 'user.email', '[email protected]']);
execFileSync('git', ['-C', dir, 'config', 'user.name', 'Test']);
execFileSync('git', ['-C', dir, 'add', '-A']);
execFileSync('git', ['-C', dir, 'commit', '-q', '-m', 'initial import']);
return dir;
}
beforeEach(() => {
rmSync(SANDBOX, { recursive: true, force: true });
mkdirSync(SANDBOX, { recursive: true });
});
afterAll(() => {
rmSync(SANDBOX, { recursive: true, force: true });
});
test('attach happy path: NULL local_path + --path updates the row, keeps config', async () => {
await engine.executeRaw(
`INSERT INTO sources (id, name, local_path, config)
VALUES ('attach-me', 'Attach Me', NULL, '{"federated":true}'::jsonb)`,
);
const gitDir = makeGitRepo('attach-happy');
const row = await addSource(engine, { id: 'attach-me', localPath: gitDir });
expect(row.id).toBe('attach-me');
expect(row.local_path).toBe(gitDir);
// Attach is an UPDATE, not a re-INSERT: name + config survive.
expect(row.name).toBe('Attach Me');
expect((row.config as any).federated).toBe(true);
});
test('attach applies explicitly-passed --name and --federated (review: not silently dropped)', async () => {
await engine.executeRaw(
`INSERT INTO sources (id, name, local_path, config)
VALUES ('attach-flags', 'Old Name', NULL, '{"federated":true,"other":"kept"}'::jsonb)`,
);
const gitDir = makeGitRepo('attach-flags');
const row = await addSource(engine, {
id: 'attach-flags',
localPath: gitDir,
name: 'New Name',
federated: false, // explicit false must override the stored true
});
expect(row.local_path).toBe(gitDir);
expect(row.name).toBe('New Name');
expect((row.config as any).federated).toBe(false);
// Merge, not replace: unrelated config keys survive the attach.
expect((row.config as any).other).toBe('kept');
});
test('attach still runs the #2707 git validation (not_a_git_repo unless --force)', async () => {
await engine.executeRaw(
`INSERT INTO sources (id, name, local_path, config)
VALUES ('attach-plain', 'x', NULL, '{}'::jsonb)`,
);
const plainDir = join(SANDBOX, 'plain-attach');
mkdirSync(plainDir, { recursive: true });
execFileSync('git', ['-C', plainDir, 'init', '-q']);
let threw: SourceOpError | undefined;
try {
await addSource(engine, { id: 'attach-plain', localPath: plainDir });
} catch (e) {
threw = e as SourceOpError;
}
expect(threw).toBeInstanceOf(SourceOpError);
expect(threw?.code).toBe('not_a_git_repo');
// Row untouched (local_path still NULL).
const rows = await engine.executeRaw<{ local_path: string | null }>(
`SELECT local_path FROM sources WHERE id = 'attach-plain'`,
);
expect(rows[0]?.local_path).toBeNull();
// --force attaches anyway (same escape hatch as fresh registration).
const row = await addSource(engine, { id: 'attach-plain', localPath: plainDir, force: true });
expect(row.local_path).toBe(plainDir);
});
test('attach runs the overlap check against other sources', async () => {
const gitDir = makeGitRepo('overlap-owner');
await engine.executeRaw(
`INSERT INTO sources (id, name, local_path, config)
VALUES ('overlap-owner', 'overlap-owner', $1, '{}'::jsonb)`,
[gitDir],
);
await engine.executeRaw(
`INSERT INTO sources (id, name, local_path, config)
VALUES ('attach-overlap', 'attach-overlap', NULL, '{}'::jsonb)`,
);
let threw: SourceOpError | undefined;
try {
await addSource(engine, { id: 'attach-overlap', localPath: gitDir });
} catch (e) {
threw = e as SourceOpError;
}
expect(threw).toBeInstanceOf(SourceOpError);
expect(threw?.code).toBe('overlapping_path');
});
test('taken-WITH-path still throws, and the message warns remove deletes pages', async () => {
const gitDir = makeGitRepo('already-pathed');
await engine.executeRaw(
`INSERT INTO sources (id, name, local_path, config)
VALUES ('has-path', 'x', $1, '{}'::jsonb)`,
[gitDir],
);
let threw: SourceOpError | undefined;
try {
await addSource(engine, { id: 'has-path', localPath: join(SANDBOX, 'elsewhere') });
} catch (e) {
threw = e as SourceOpError;
}
expect(threw).toBeInstanceOf(SourceOpError);
expect(threw?.code).toBe('source_id_taken');
expect(threw?.message).toMatch(/deletes every page/i);
});
test('NULL local_path + --url does NOT attach (still source_id_taken)', async () => {
await engine.executeRaw(
`INSERT INTO sources (id, name, local_path, config)
VALUES ('attach-url', 'x', NULL, '{}'::jsonb)`,
);
let threw: SourceOpError | undefined;
try {
await addSource(engine, {
id: 'attach-url',
remoteUrl: 'https://github.com/example/repo',
});
} catch (e) {
threw = e as SourceOpError;
}
expect(threw).toBeInstanceOf(SourceOpError);
expect(threw?.code).toBe('source_id_taken');
});
});
// ---------------------------------------------------------------------------
// isPathContained — symlink-safe confinement helper (exported for reuse)
// ---------------------------------------------------------------------------
describe('isPathContained', () => {
// Use a sandbox dir, not GBRAIN_HOME (which has the .gbrain quirk).
const SANDBOX = join(tmpdir(), `gbrain-isPathContained-${process.pid}`);
beforeEach(() => {
rmSync(SANDBOX, { recursive: true, force: true });
mkdirSync(SANDBOX, { recursive: true });
});
afterAll(() => {
rmSync(SANDBOX, { recursive: true, force: true });
});
test('accepts real subtree', () => {
const inside = join(SANDBOX, 'sub', 'dir');
mkdirSync(inside, { recursive: true });
expect(isPathContained(inside, SANDBOX)).toBe(true);
});
test('rejects path outside parent', () => {
const outside = '/usr';
expect(isPathContained(outside, SANDBOX)).toBe(false);
});
test('rejects symlink escape (the codex finding case)', () => {
const target = join(tmpdir(), `escape-${process.pid}-${Date.now()}`);
mkdirSync(target, { recursive: true });
const link = join(SANDBOX, 'innocent-name');
symlinkSync(target, link);
// After realpath the link resolves to /tmp/escape-…, which is NOT
// contained under SANDBOX. Function returns false.
expect(isPathContained(link, SANDBOX)).toBe(false);
rmSync(target, { recursive: true, force: true });
});
test('returns false for missing paths (fail-closed)', () => {
expect(isPathContained(join(SANDBOX, 'never'), SANDBOX)).toBe(false);
});
});
// ---------------------------------------------------------------------------
// v0.46 github-kind source registration (Path C in addSource): a fresh mirror
// is federated by default so unqualified search/query span it, unless the
// caller explicitly passes federated:false.
// ---------------------------------------------------------------------------
describe('addSource github kind', () => {
beforeEach(async () => {
await resetPgliteState(engine);
});
async function addGithubSource(federated?: boolean | null) {
const ghDir = join(CLONE_ROOT, 'ghsrc-github');
await addSource(engine, {
id: 'ghsrc',
...(federated !== undefined ? { federated } : {}),
github: {
tokenEnv: 'GH_TOKEN',
handle: 'example-handle',
scope: 'repos',
repos: ['example/repo'],
dir: ghDir,
involvement: false,
},
});
const rows = await engine.executeRaw<{ config: unknown }>(
`SELECT config FROM sources WHERE id = 'ghsrc'`,
);
return rows[0]?.config as Record<string, unknown>;
}
test('defaults to federated:true (searchable alongside the vault)', async () => {
const config = await addGithubSource();
expect(config.federated).toBe(true);
});
test('explicit federated:false opts out of unqualified reads', async () => {
const config = await addGithubSource(false);
expect(config.federated).toBe(false);
});
test('github mirror is not reported as a broken git clone', async () => {
await addGithubSource();
const status = await getSourceStatus(engine, 'ghsrc');
expect(status.clone_state).toBe('not-applicable');
});
});
describe('#7630 — a relative clone local_path never names the current directory', () => {
async function insideRelativeClone(id: string, config: Record<string, unknown>, fn: (dir: string) => Promise<void>): Promise<void> {
await withEnv2(async () => {
const dir = join(CLONE_ROOT, `${id}-cwd`);
mkdirSync(dir, { recursive: true });
writeFileSync(join(dir, 'KEEP_ME.md'), 'another clone lives here');
await engine.executeRaw(
'INSERT INTO sources (id, name, local_path, config) VALUES ($1, $1, $2, $3::jsonb)',
[id, '.', JSON.stringify(config)],
);
const previous = process.cwd();
process.chdir(dir);
try { await fn(dir); } finally { process.chdir(previous); }
});
}
test('removeSource skips clone cleanup and leaves the current directory', async () => {
await insideRelativeClone('rel-remove', { remote_url: 'https://github.com/example/repo' }, async dir => {
const result = await removeSource(engine, { id: 'rel-remove', confirmDestructive: true });
expect(result.clone_removed).toBe(false);
expect(existsSync(join(dir, 'KEEP_ME.md'))).toBe(true);
});
});
test('recloneIfMissing refuses unmanaged_path and leaves the current directory', async () => {
await insideRelativeClone('rel-reclone', { remote_url: 'https://github.com/example/repo', managed_clone: true }, async dir => {
let threw: SourceOpError | null = null;
try { await recloneIfMissing(engine, 'rel-reclone'); } catch (e) { threw = e as SourceOpError; }
expect(threw?.code).toBe('unmanaged_path');
expect(threw?.message).toContain('gbrain sources set-path rel-reclone');
expect(existsSync(join(dir, 'KEEP_ME.md'))).toBe(true);
expect(readdirSync(dir)).toEqual(['KEEP_ME.md']);
});
});
// #7646: the skipped cleanup is reported in the result (remote sources_remove sees only that) and the warning names gbrain's
// own clone directory, which a later sources add <id> --url refuses while it holds files.
test('removeSource reports clone_skipped_reason and names the clone directory it left', async () => {
await insideRelativeClone('rel-orphan', { remote_url: 'https://github.com/example/repo', managed_clone: true }, async dir => {
const cloneDir = defaultCloneDir('rel-orphan');
mkdirSync(cloneDir, { recursive: true });
writeFileSync(join(cloneDir, 'README.md'), 'the clone gbrain made');
const errors: string[] = [];
const spy = spyOn(console, 'error').mockImplementation((...a: unknown[]) => { errors.push(a.map(String).join(' ')); });
let result: Awaited<ReturnType<typeof removeSource>>;
try { result = await removeSource(engine, { id: 'rel-orphan', confirmDestructive: true }); } finally { spy.mockRestore(); }
expect(result).toMatchObject({ clone_removed: false, clone_skipped_reason: 'relative_path' });
expect(errors.join('\n')).toContain(`gbrain's clone directory for this source is ${cloneDir}`);
expect(existsSync(join(cloneDir, 'README.md'))).toBe(true);
expect(existsSync(join(dir, 'KEEP_ME.md'))).toBe(true);
});
});
});