Skip to content

Garry's Opinionated OpenClaw/Hermes Agent Brain

TypeScript
19.2 KB
Raw Blame
/**
 * Meetings source kind (Fireflies first): repo-less and Git-recorded brains.
 *
 * Synthetic Fireflies GraphQL fixtures only; no network. Covers the repo-less
 * default (record: database, no directory, no file and no git command, the
 * connector cursor in op_checkpoints), a Git-recorded unmanaged brain (the
 * commit lands before the database row; a missing checkout holds the item,
 * never writes it database-only), edits and deletions upstream retiring the
 * facts extracted from the page, deferral of meetings still processing, the
 * account pin, and the provider's rate limit recorded for the scheduler.
 */
import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
import { mkdtempSync, mkdirSync, readdirSync, rmSync, existsSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { spawnSync } from 'node:child_process';
import type { BrainEngine } from '../src/core/engine.ts';
import { connectTemplateBrain } from './helpers/brain-template.ts';
import { json, options } from './helpers/connector-fixture.ts';
import { withEnv } from './helpers/with-env.ts';
import { runMeetingsSync } from '../src/core/meetings/meetings-source.ts';
import { parseMeetingsSourceConfig } from '../src/core/meetings/source-config.ts';
import { firefliesProvider } from '../src/core/meetings/providers/fireflies.ts';
import { meetingPagePath } from '../src/core/meetings/render.ts';
import { connectorFactsSession } from '../src/core/facts/retire.ts';
import { addSource } from '../src/core/sources-ops.ts';
import { slugifyPath } from '../src/core/sync.ts';
import { CONNECTOR_DB_CURSOR_OP } from '../src/core/connectors/db-cursor.ts';
import { performSync } from '../src/commands/sync/perform.ts';

const DAY = 86_400_000;
const NOW = Date.parse('2026-06-15T12:00:00Z');
const OWNER = '[email protected]';

interface FakeMeeting { id: string; title: string; date: number; summary?: string | null; attendees?: string[]; organizer?: string }
interface Fake { userId: string; email: string; meetings: FakeMeeting[]; rateLimited?: boolean; calls: string[] }

function fireflies(fake: Fake) {
  return async (_url: string, init: RequestInit) => {
    const { query, variables } = JSON.parse(String(init.body)) as { query: string; variables: Record<string, unknown> };
    if (fake.rateLimited) return json({ errors: [{ message: 'Too many requests', extensions: { code: 'too_many_requests', metadata: { retryAfter: 600 } } }] });
    if (query.includes('GbrainUser')) { fake.calls.push('user'); return json({ data: { user: { user_id: fake.userId, email: fake.email, name: 'Owner Example' } } }); }
    if (query.includes('GbrainTranscripts')) {
      fake.calls.push('list');
      const from = Date.parse(String(variables.fromDate)); const to = Date.parse(String(variables.toDate));
      const hits = fake.meetings.filter(m => m.date >= from && m.date < to).sort((a, b) => b.date - a.date);
      const skip = Number(variables.skip ?? 0); const limit = Number(variables.limit ?? 50);
      return json({ data: { transcripts: hits.slice(skip, skip + limit).map(m => ({ id: m.id, title: m.title, date: m.date })) } });
    }
    fake.calls.push(`get:${variables.id}`);
    const m = fake.meetings.find(x => x.id === variables.id);
    if (!m) return json({ data: { transcript: null }, errors: [{ message: 'Transcript not found', extensions: { code: 'object_not_found' } }] });
    const attendees = m.attendees ?? [OWNER, '[email protected]'];
    return json({ data: { transcript: {
      id: m.id, title: m.title, date: m.date, duration: 30, transcript_url: `https://app.fireflies.example/view/${m.id}`,
      organizer_email: m.organizer ?? attendees[0], participants: attendees,
      meeting_attendees: attendees.map(email => ({ email, displayName: email.split('@')[0] })),
      summary: m.summary === null ? null : { overview: m.summary ?? `Summary of ${m.title}.`, action_items: '- Send the follow-up', keywords: ['planning'] },
    } } });
  };
}

const provider = (fake: Fake, now = () => NOW) => firefliesProvider({ token: 'synthetic-fixture-key', userAgent: 'gbrain-test', now,
  fetchImpl: fireflies(fake), sleep: async () => {} });

let home: string;
let engine: BrainEngine;
beforeAll(async () => {
  home = mkdtempSync(join(tmpdir(), 'gbrain-meetings-'));
  engine = await connectTemplateBrain(join(home, 'database'));
  await engine.executeRaw('UPDATE persistence_brain SET enabled=false WHERE singleton=1');
}, 120_000);
afterAll(async () => { await engine.disconnect(); rmSync(home, { recursive: true, force: true }); });

let n = 0;
async function meetingsSource(extra: Record<string, unknown> = {}, dir: string | null = null) {
  const id = `meet-${++n}`;
  const config = { kind: 'meetings', m_provider: 'fireflies', m_record: dir ? 'git' : 'database', ...(dir ? { m_dir: dir } : {}), federated: false, ...extra };
  await engine.executeRaw('INSERT INTO sources(id,name,local_path,config) VALUES($1,$1,$2,$3::text::jsonb)', [id, dir, JSON.stringify(config)]);
  return { id, cfg: parseMeetingsSourceConfig(config, '') };
}
const pages = (sourceId: string) => engine.executeRaw<{ slug: string; visibility: string | null; title: string; body: string }>(
  `SELECT slug, frontmatter->>'visibility' AS visibility, title, compiled_truth AS body FROM pages WHERE source_id=$1 AND deleted_at IS NULL ORDER BY slug`, [sourceId]);
const meetingSlug = (m: FakeMeeting) => slugifyPath(meetingPagePath({ id: m.id, title: m.title, startedAt: new Date(m.date).toISOString() }));
async function addFact(sourceId: string, slug: string, fact: string) {
  await engine.executeRaw(`INSERT INTO facts (fact, source, source_id, source_session) VALUES ($1, 'sync:import', $2, $3)`, [fact, sourceId, connectorFactsSession(sourceId, slug)]);
}
const activeFacts = async (sourceId: string) => (await engine.executeRaw<{ fact: string }>(
  'SELECT fact FROM facts WHERE source_id=$1 AND expired_at IS NULL ORDER BY fact', [sourceId])).map(r => r.fact);

describe('repo-less brain (record: database)', () => {
  test('imports meetings with no directory, no file and no git; the cursor lives in the database', async () => {
    const fake: Fake = { userId: 'u-1', email: OWNER, calls: [], meetings: [
      { id: 'mtg-aaa111', title: 'Weekly planning', date: NOW - 2 * DAY },
      { id: 'mtg-bbb222', title: 'Board prep', date: NOW - 5 * DAY, attendees: ['[email protected]', '[email protected]'] },
      { id: 'mtg-old000', title: 'Too old', date: NOW - 40 * DAY },
    ] };
    const { id, cfg } = await meetingsSource();
    expect(cfg.record).toBe('database');
    expect(cfg.dir).toBeNull();
    const before = readdirSync(home).sort();
    const result = await runMeetingsSync(engine, id, cfg, options, { provider: provider(fake), now: () => NOW });
    expect(result.added).toBe(2);
    expect(readdirSync(home).sort()).toEqual(before);
    const rows = await pages(id);
    expect(rows.map(r => r.slug)).toEqual([meetingSlug(fake.meetings[0]!), meetingSlug(fake.meetings[1]!)].sort());
    const byTitle = Object.fromEntries(rows.map(r => [r.title, r]));
    expect(byTitle['Weekly planning']!.visibility).toBeNull();
    expect(byTitle['Board prep']!.visibility).toBe('private');
    expect(byTitle['Weekly planning']!.body).toContain('Summary of Weekly planning.');
    const [cursor] = await engine.executeRaw<{ n: number }>('SELECT count(*)::int AS n FROM op_checkpoints WHERE op=$1', [CONNECTOR_DB_CURSOR_OP]);
    expect(cursor!.n).toBeGreaterThan(0);

    const again = await runMeetingsSync(engine, id, cfg, options, { provider: provider(fake), now: () => NOW + 60_000 });
    expect(again.added + again.modified + again.deleted).toBe(0);
  });

  test('an edit upstream updates the page and retires its facts; a deletion removes the page and retires its facts', async () => {
    const fake: Fake = { userId: 'u-2', email: OWNER, calls: [], meetings: [
      { id: 'mtg-ccc333', title: 'Pricing review', date: NOW - 1 * DAY },
      { id: 'mtg-ddd444', title: 'Hiring sync', date: NOW - 1 * DAY + 3_600_000 },
    ] };
    const { id, cfg } = await meetingsSource();
    await runMeetingsSync(engine, id, cfg, options, { provider: provider(fake), now: () => NOW });
    const [edited, deleted] = fake.meetings.map(meetingSlug) as [string, string];
    await addFact(id, edited, 'Pricing moves to annual plans');
    await addFact(id, deleted, 'Two engineers start in July');
    expect(await activeFacts(id)).toHaveLength(2);

    fake.meetings[0]!.summary = 'Pricing stays monthly after review.';
    fake.meetings.splice(1, 1);
    const result = await runMeetingsSync(engine, id, cfg, options, { provider: provider(fake), now: () => NOW + 3_600_000 });
    expect(result.modified).toBe(1);
    expect(result.deleted).toBe(1);
    expect(await activeFacts(id)).toEqual([]);
    const rows = await pages(id);
    expect(rows.map(r => r.slug)).toEqual([edited]);
    expect(rows[0]!.body).toContain('Pricing stays monthly after review.');
  });

  test('a meeting still processing is deferred, then published once its summary arrives', async () => {
    const fake: Fake = { userId: 'u-3', email: OWNER, calls: [], meetings: [{ id: 'mtg-eee555', title: 'Fresh call', date: NOW - 3_600_000, summary: null }] };
    const { id, cfg } = await meetingsSource();
    const first = await runMeetingsSync(engine, id, cfg, options, { provider: provider(fake), now: () => NOW });
    expect(first.added).toBe(0);
    expect(await pages(id)).toEqual([]);
    fake.meetings[0]!.summary = 'The summary arrived.';
    const second = await runMeetingsSync(engine, id, cfg, options, { provider: provider(fake), now: () => NOW + 600_000 });
    expect(second.added).toBe(1);
    expect((await pages(id))[0]!.body).toContain('The summary arrived.');
  });

  test('a key for another account is refused before anything is imported', async () => {
    const fake: Fake = { userId: 'u-4', email: OWNER, calls: [], meetings: [{ id: 'mtg-fff666', title: 'First', date: NOW - DAY }] };
    const { id, cfg } = await meetingsSource();
    await runMeetingsSync(engine, id, cfg, options, { provider: provider(fake), now: () => NOW });
    const other: Fake = { userId: 'u-other', email: '[email protected]', calls: [], meetings: [{ id: 'mtg-ggg777', title: 'Other', date: NOW - DAY }] };
    await expect(runMeetingsSync(engine, id, cfg, options, { provider: provider(other), now: () => NOW + 60_000 })).rejects.toMatchObject({ code: 'connector_account_changed' });
    expect((await pages(id)).map(r => r.title)).toEqual(['First']);
  });

  test('a rate limit stops the run with rate_limited and records when the provider resets', async () => {
    const fake: Fake = { userId: 'u-5', email: OWNER, calls: [], meetings: [] };
    const { id, cfg } = await meetingsSource();
    await runMeetingsSync(engine, id, cfg, options, { provider: provider(fake), now: () => NOW });
    fake.rateLimited = true;
    await expect(runMeetingsSync(engine, id, cfg, options, { provider: provider(fake), now: () => NOW })).rejects.toMatchObject({ code: 'rate_limited' });
    const [row] = await engine.executeRaw<{ keys: Array<{ retry_at: string }> }>(`SELECT completed_keys AS keys FROM op_checkpoints WHERE op='connector-rate-limit' AND fingerprint=$1`, [id]);
    expect(Date.parse(row!.keys[0]!.retry_at)).toBe(NOW + 600_000);
  });

  test('sources add --kind meetings on a repo-less brain records to the database and keeps no directory', async () => {
    await withEnv({ GBRAIN_HOME: home }, async () => {
      await addSource(engine, { id: 'meet-added', meetings: { provider: 'fireflies', record: 'auto', transcript: 'none', private: false } });
    });
    const [row] = await engine.executeRaw<{ local_path: string | null; config: Record<string, unknown> }>('SELECT local_path, config FROM sources WHERE id=$1', ['meet-added']);
    expect(row!.local_path).toBeNull();
    expect(row!.config).toMatchObject({ kind: 'meetings', m_provider: 'fireflies', m_record: 'database', federated: false });
    expect(JSON.stringify(row!.config)).not.toMatch(/token|key/i);
  });
});

describe('Git-recorded brain (record: git, unmanaged)', () => {
  const git = (cwd: string, ...args: string[]) => spawnSync('git', args, { cwd, encoding: 'utf8' });

  test('each page is committed to the checkout before its database row', async () => {
    const repo = join(home, 'repo-brain');
    mkdirSync(repo);
    git(repo, 'init', '-q', '-b', 'main');
    git(repo, 'config', 'user.email', '[email protected]');
    git(repo, 'config', 'user.name', 'Test Example');
    git(repo, 'commit', '-q', '--allow-empty', '-m', 'init');
    const dir = join(repo, 'meetings-source');
    await withEnv({ GBRAIN_HOME: home }, async () => {
      await addSource(engine, { id: 'meet-git', meetings: { provider: 'fireflies', record: 'auto', transcript: 'none', private: false, dir } });
    });
    const [src] = await engine.executeRaw<{ config: Record<string, unknown> }>('SELECT config FROM sources WHERE id=$1', ['meet-git']);
    const cfg = parseMeetingsSourceConfig(src!.config, '');
    expect(cfg.record).toBe('git');
    const fake: Fake = { userId: 'u-6', email: OWNER, calls: [], meetings: [
      { id: 'mtg-hhh888', title: 'Roadmap review', date: NOW - DAY },
      { id: 'mtg-iii999', title: 'Not attended', date: NOW - DAY, attendees: ['[email protected]'] },
    ] };
    const result = await runMeetingsSync(engine, 'meet-git', cfg, options, { provider: provider(fake), now: () => NOW });
    expect(result.added).toBe(2);
    const committed = git(repo, 'log', '--name-only', '--format=%s').stdout;
    const publicPath = meetingPagePath({ id: 'mtg-hhh888', title: 'Roadmap review', startedAt: new Date(NOW - DAY).toISOString() });
    const privatePath = meetingPagePath({ id: 'mtg-iii999', title: 'Not attended', startedAt: new Date(NOW - DAY).toISOString() });
    expect(committed).toContain(`meetings-source/${publicPath}`);
    expect(committed).not.toContain(privatePath);
    expect(existsSync(join(dir, privatePath))).toBe(false);
    expect((await pages('meet-git')).map(r => r.visibility).sort()).toEqual([null, 'private'].sort());
    expect(git(repo, 'status', '--porcelain').stdout.trim()).toBe('');
  });

  test('a missing checkout holds the meeting; nothing is written database-only', async () => {
    const dir = join(home, 'gone-checkout', 'meetings');
    const { id, cfg } = await meetingsSource({}, dir);
    const fake: Fake = { userId: 'u-7', email: OWNER, calls: [], meetings: [{ id: 'mtg-jjj000', title: 'Held meeting', date: NOW - DAY }] };
    const result = await runMeetingsSync(engine, id, cfg, options, { provider: provider(fake), now: () => NOW });
    expect(result.status).toBe('partial');
    expect(await pages(id)).toEqual([]);
    const [cursor] = await engine.executeRaw<{ keys: Array<{ state: { item_holds: { items: Record<string, { code: string }> } } }> }>(
      'SELECT completed_keys AS keys FROM op_checkpoints WHERE op=$1 AND completed_keys::text LIKE $2', [CONNECTOR_DB_CURSOR_OP, '%mtg-jjj000%']);
    expect(cursor!.keys[0]!.state.item_holds.items['mtg-jjj000']!.code).toBe('connector_binding_missing');
  });
});

describe('review fixes (#7970 /ship)', () => {
  test('an unmanaged dry run calls the provider for nothing and writes nothing', async () => {
    const fake: Fake = { userId: 'u-dry', email: OWNER, calls: [], meetings: [{ id: 'mtg-dry001', title: 'Dry', date: NOW - DAY }] };
    const { id, cfg } = await meetingsSource();
    const result = await runMeetingsSync(engine, id, cfg, { ...options, dryRun: true }, { provider: provider(fake), now: () => NOW });
    expect(result.status).toBe('dry_run');
    expect(fake.calls).toEqual([]);
    expect(await pages(id)).toEqual([]);
  });

  test('the account pin survives a content-config change', async () => {
    const fake: Fake = { userId: 'u-pin', email: OWNER, calls: [], meetings: [{ id: 'mtg-pin001', title: 'Pinned', date: NOW - DAY }] };
    const { id, cfg } = await meetingsSource();
    await runMeetingsSync(engine, id, cfg, options, { provider: provider(fake), now: () => NOW });
    const changed = { kind: 'meetings', m_provider: 'fireflies', m_record: 'database', m_transcript: 'full', federated: false };
    await engine.executeRaw('UPDATE sources SET config=$2::text::jsonb WHERE id=$1', [id, JSON.stringify(changed)]);
    const other: Fake = { userId: 'u-swap', email: '[email protected]', calls: [], meetings: [{ id: 'mtg-pin002', title: 'Swapped', date: NOW - DAY }] };
    await expect(runMeetingsSync(engine, id, parseMeetingsSourceConfig(changed, ''), options, { provider: provider(other), now: () => NOW + 60_000 }))
      .rejects.toMatchObject({ code: 'connector_account_changed' });
    expect((await pages(id)).map(r => r.title)).toEqual(['Pinned']);
  });

  test("a fresh source never inherits another source's pending meetings", async () => {
    const a: Fake = { userId: 'u-pa', email: OWNER, calls: [], meetings: [{ id: 'mtg-pend01', title: 'Processing', date: NOW - 3_600_000, summary: null }] };
    const first = await meetingsSource();
    await runMeetingsSync(engine, first.id, first.cfg, options, { provider: provider(a), now: () => NOW });
    const b: Fake = { userId: 'u-pb', email: OWNER, calls: [], meetings: [] };
    const second = await meetingsSource();
    await runMeetingsSync(engine, second.id, second.cfg, options, { provider: provider(b), now: () => NOW });
    expect(b.calls).not.toContain('get:mtg-pend01');
  });

  test('--full re-walks the whole history window', async () => {
    const fake: Fake = { userId: 'u-full', email: OWNER, calls: [], meetings: [{ id: 'mtg-full01', title: 'Recent', date: NOW - 2 * DAY }] };
    const { id, cfg } = await meetingsSource();
    await runMeetingsSync(engine, id, cfg, options, { provider: provider(fake), now: () => NOW });
    fake.meetings.push({ id: 'mtg-full02', title: 'Backfilled', date: NOW - 20 * DAY });
    expect((await runMeetingsSync(engine, id, cfg, options, { provider: provider(fake), now: () => NOW + 3_600_000 })).added).toBe(0);
    expect((await runMeetingsSync(engine, id, cfg, { ...options, full: true }, { provider: provider(fake), now: () => NOW + 7_200_000 })).added).toBe(1);
  });

  test('a listing that never ends stops at the page cap', async () => {
    const fake: Fake = { userId: 'u-cap', email: OWNER, calls: [], meetings: Array.from({ length: 60 }, (_, i) => ({ id: `mtg-cap${i}`, title: `Cap ${i}`, date: NOW - DAY - i * 60_000 })) };
    const inner = fireflies(fake);
    const stuck = firefliesProvider({ token: 'synthetic-fixture-key', userAgent: 'gbrain-test', now: () => NOW, sleep: async () => {},
      fetchImpl: async (url: string, init: RequestInit) => {
        const body = JSON.parse(String(init.body)) as { query: string; variables: Record<string, unknown> };
        if (body.query.includes('GbrainTranscripts')) body.variables.skip = 0;
        return inner(url, { ...init, body: JSON.stringify(body) });
      } });
    const { id, cfg } = await meetingsSource();
    await expect(runMeetingsSync(engine, id, cfg, options, { provider: stuck, now: () => NOW })).rejects.toThrow(/listing_unbounded/);
  });

  test('gbrain sync reaches a repo-less meetings source instead of asking for a local_path', async () => {
    const { id } = await meetingsSource();
    await withEnv({ GBRAIN_HOME: join(home, 'cli-home'), GBRAIN_CONNECTOR_FIREFLIES_TOKEN: undefined }, async () => {
      await expect(performSync(engine, { sourceId: id, noPull: true, noEmbed: true, noExtract: true } as never)).rejects.toMatchObject({ code: 'connector_auth_required' });
    });
  });
});