mirror of
https://github.com/garrytan/gbrain.git
synced 2026-07-27 22:15:33 +00:00
df86ea5f1d
* wip: federated sync v2 pre-merge snapshot
* v0.40.5.0 Federated Sync v2 — parallel source sync + push triggers + per-source health
Bump VERSION + package.json + CHANGELOG header + migration walkthrough filename
to v0.40.5.0 (claiming the next free slot in the v0.40.x patch series after
master's v0.40.1.0).
What ships (6 components, all behind sync.federated_v2 feature flag default-on):
1. Per-source sync lock — syncLockId(sourceId), phantom-redirect parity
2. Parallel sync --all — pMapAllSettled fan-out, --max-sources N cap
3. embed-backfill minion handler — D2 per-source lock + D6 $10/job budget + D15.1
fire-and-forget submission + D19 source-level cooldown + 24h $25 rolling cap
4. sync trigger CLI + POST /webhooks/github — HMAC-verified (60 req/min/IP),
X-GitHub-Event=push + ref filter against tracked_branch
5. sources status + federation_health doctor — batched GROUP BY pipeline
(4 queries instead of 6×N per-source roundtrips)
6. sources federate/unfederate hook — auto-submit embed-backfill on flip
Correctness fixes (unconditional):
- D21: sync.ts:959 facts backstop now passes sourceId to engine.getPage
- D15.4: redactSourceConfig + CI guard prevent webhook_secret leak
- D15.5: safeHexEqual extracted to src/core/timing-safe.ts
Schema:
- Migration v89 (sources_github_repo_index): partial expression index on
config->>'github_repo' for fast webhook source-lookup
Tests:
- 14 new test files, 112 cases. 4 IRON-RULE regressions pinned (SYNC_LOCK_ID
back-compat, phantom per-source lock, embed-backfill kill+resume,
webhook HMAC prefix-strip). All 9449 unit tests pass.
Caught at test-write time: the webhook handler had a Buffer.from('sha256=...',
'hex') truncation bug — without the prefix-strip, every signature would have
"matched" empty buffers. Pinned by a test/sources-webhook.test.ts IRON-RULE.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
* fix(check-source-config-leak): tighten regex to source-row patterns only
The v0.40.5.0 wave added scripts/check-source-config-leak.sh with a
too-broad pattern (JSON\.stringify\(.*config) that flagged any variable
named 'config' — catching the GLOBAL gbrain config.json serializers in
src/commands/init.ts (status envelopes) and src/core/config.ts (the
config-file write site). On the CI runner without rg installed, the
grep -rE fallback fired correctly and produced 4 false positives that
broke the `verify` script.
Tightened the patterns to specifically match `(source|src|row|s).config`
property access — the actual risk shape (a sources-table row being
serialized whole). The global gbrain config has a different shape and
threat model (file-mode 0o600 at the write site), so it's safe to
exempt at the regex level rather than per-file whitelist.
Also fixed a latent bug: the rg branch used `--include='*.ts'` (grep's
flag, not rg's). rg silently rejected it and CANDIDATES came back empty,
so the local-dev runs (which have rg) would never have caught a real
leak. Now branches on tool availability: `-g '*.ts'` for rg, `--include`
for grep -rE. Both branches verified against a synthetic leak fixture.
Also added init.ts + config.ts to the whitelist as a belt-and-suspenders
since they handle gbrain-global config (not source rows) and could
otherwise reflect-back via regex iteration.
CI: `bun run verify` exit 0 locally with both the original false-positive
fixture (clean repo) and a synthetic leak fixture (correctly caught,
exit 1).
---------
Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
87 lines
3.4 KiB
TypeScript
87 lines
3.4 KiB
TypeScript
/**
|
|
* v0.40 Federated Sync v2 — per-source lock contract.
|
|
*
|
|
* Pins the iron-rule regression for the SYNC_LOCK_ID rename:
|
|
* - SYNC_LOCK_ID === syncLockId('default') (back-compat alias)
|
|
* - syncLockId(X) !== syncLockId(Y) for X !== Y (per-source isolation)
|
|
* - two concurrent tryAcquireDbLock calls against DIFFERENT sources both succeed
|
|
* - two concurrent tryAcquireDbLock calls against the SAME source: second returns null
|
|
*
|
|
* Without this guard, a future drift in the constant value would silently change
|
|
* semantics (e.g. someone hardcoding 'gbrain-sync' elsewhere would no longer match
|
|
* the same row, breaking the writer-window exclusion that performSync relies on).
|
|
*/
|
|
import { describe, test, expect, beforeAll, afterAll, beforeEach } from 'bun:test';
|
|
import { PGLiteEngine } from '../src/core/pglite-engine.ts';
|
|
import { resetPgliteState } from './helpers/reset-pglite.ts';
|
|
import { syncLockId, SYNC_LOCK_ID, tryAcquireDbLock } from '../src/core/db-lock.ts';
|
|
|
|
let engine: PGLiteEngine;
|
|
|
|
beforeAll(async () => {
|
|
engine = new PGLiteEngine();
|
|
await engine.connect({});
|
|
await engine.initSchema();
|
|
}, 30000);
|
|
|
|
afterAll(async () => {
|
|
await engine.disconnect();
|
|
});
|
|
|
|
beforeEach(async () => {
|
|
await resetPgliteState(engine);
|
|
});
|
|
|
|
describe('syncLockId (per-source lock helper)', () => {
|
|
test('default source returns gbrain-sync:default', () => {
|
|
expect(syncLockId('default')).toBe('gbrain-sync:default');
|
|
});
|
|
|
|
test('non-default source returns gbrain-sync:<id>', () => {
|
|
expect(syncLockId('zion-brain')).toBe('gbrain-sync:zion-brain');
|
|
expect(syncLockId('media-corpus')).toBe('gbrain-sync:media-corpus');
|
|
});
|
|
|
|
test('IRON-RULE: SYNC_LOCK_ID back-compat alias resolves to syncLockId(default)', () => {
|
|
expect(SYNC_LOCK_ID).toBe(syncLockId('default'));
|
|
expect(SYNC_LOCK_ID).toBe('gbrain-sync:default');
|
|
});
|
|
|
|
test('different sources produce distinct lock keys', () => {
|
|
expect(syncLockId('a')).not.toBe(syncLockId('b'));
|
|
});
|
|
});
|
|
|
|
describe('tryAcquireDbLock with per-source keys', () => {
|
|
test('two locks against different sources both succeed', async () => {
|
|
const lockA = await tryAcquireDbLock(engine, syncLockId('source-a'));
|
|
const lockB = await tryAcquireDbLock(engine, syncLockId('source-b'));
|
|
expect(lockA).not.toBeNull();
|
|
expect(lockB).not.toBeNull();
|
|
await lockA?.release();
|
|
await lockB?.release();
|
|
});
|
|
|
|
test('second lock against the same source returns null while first is held', async () => {
|
|
const first = await tryAcquireDbLock(engine, syncLockId('source-c'));
|
|
expect(first).not.toBeNull();
|
|
const second = await tryAcquireDbLock(engine, syncLockId('source-c'));
|
|
expect(second).toBeNull();
|
|
await first?.release();
|
|
// After release, third acquire succeeds.
|
|
const third = await tryAcquireDbLock(engine, syncLockId('source-c'));
|
|
expect(third).not.toBeNull();
|
|
await third?.release();
|
|
});
|
|
|
|
test('SYNC_LOCK_ID and syncLockId(default) acquire the SAME lock row', async () => {
|
|
// This is the critical back-compat check: pre-v0.40 callers using SYNC_LOCK_ID
|
|
// and new callers using syncLockId('default') MUST conflict (not bypass each other).
|
|
const first = await tryAcquireDbLock(engine, SYNC_LOCK_ID);
|
|
expect(first).not.toBeNull();
|
|
const second = await tryAcquireDbLock(engine, syncLockId('default'));
|
|
expect(second).toBeNull();
|
|
await first?.release();
|
|
});
|
|
});
|