Skip to content

Soul-driven AI agent with permission-hardened tools, token budgets, and multi-channel access. Runs 24/7 from CLI, Telegram or More.

7.1 KB
Raw Blame
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
import { mkdtempSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';

// Mock only generateText; tool()/zodSchema/stepCountIs stay real.
vi.mock('ai', async (importOriginal) => {
  const actual = await importOriginal<typeof import('ai')>();
  return { ...actual, generateText: vi.fn(), streamText: vi.fn() };
});

import { generateText, streamText } from 'ai';
import { BotManager } from './bot-manager.js';
import { BotStore } from './store.js';
import { getDefaultConfig, type MercuryConfig } from '../utils/config.js';

const mockedGenerateText = vi.mocked(generateText);

const mockedStreamText = vi.mocked(streamText);
// Bot turns run on streamText (live thinking deltas). Tests script
// generateText; this shim feeds THAT script through the streaming shape the
// turn loop consumes: the (async, mocked) generateText call fires the same
// step callbacks inside fullStream consumption, and its final result shows
// up as the text/finishReason promises runBotTurn awaits.
mockedStreamText.mockImplementation(((opts: any) => {
  let final = { text: '', finishReason: 'stop', usage: {} };
  let failed: unknown = null;
  let resolveSettled: () => void = () => { };
  const settled = new Promise<void>((r) => { resolveSettled = r; });
  const gen: any = (generateText as any)(opts) || Promise.resolve(final);
  const fullStream = (async function* () {
    try {
      final = await gen;
    } catch (err) {
      failed = err; // rethrown by the text/finishReason promises below
    }
    resolveSettled();
  })();
  // Resolve only after the underlying generateText settles; its promises
  // must never reject unhandled (the fullStream consumer owns the error).
  const once = async (pick: () => any) => { await settled; if (failed !== null) throw failed; return pick(); };
  return {
    fullStream,
    text: once(() => final.text),
    finishReason: once(() => final.finishReason),
    // runBotTurn reads usage from onStepFinish — usage must never reject
    // unhandled (Promise.all only consumes text/finishReason).
    usage: once(() => final.usage).catch(() => ({})),
  };
}) as any);

function makeManager(root: string): BotManager {
  const config = getDefaultConfig() as MercuryConfig;
  config.bots.maxConcurrent = 4;
  const manager = new BotManager({
    config,
    providers: {
      get: () => undefined,
      getDefault: () => ({
        name: 'stub', model: 'stub-model',
        generateText: async () => ({ text: 'ok', inputTokens: 0, outputTokens: 0, totalTokens: 0, model: 'stub-model', provider: 'stub' }),
        streamText: async function* () { yield { text: 'ok', done: true }; },
        isAvailable: () => true, getModelInstance: () => ({}), getModel: () => 'stub-model',
      } as any),
    } as any,
    tokenBudget: { recordUsage: () => {}, getRemaining: () => 100000, getStatusText: () => '', getUsagePercentage: () => 0 } as any,
    store: new BotStore(join(root, 'bots')),
    userMemoryFactory: () => null,
  });
  activeManagers.push(manager);
  return manager;
}

beforeEach(() => {
  mockedStreamText.mockClear();
    mockedGenerateText.mockReset();
});

// Windows EBUSY guard: every BotManager owns an open SQLite queue handle;
// afterEach disposes all of them before the tmpdir is deleted.
const activeManagers: Array<{ dispose: () => void }> = [];

describe('fleet stop/start cascade', () => {
  let root: string;
  let manager: BotManager;
  let store: BotStore;

  beforeEach(() => {
    root = mkdtempSync(join(tmpdir(), 'mercury-fleet-stop-'));
    manager = makeManager(root);
    store = manager['store'];
    // CEO → eng (mid-level lead) → backend; CEO → qa.
    store.create({ id: 'ceo', name: 'CEO', manifest: { fleetRole: 'lead' } });
    store.create({ id: 'eng', name: 'Eng', manifest: { fleetRole: 'lead', parent: 'ceo' } });
    store.create({ id: 'backend', name: 'Backend', manifest: { fleetRole: 'crew', parent: 'eng' } });
    store.create({ id: 'qa', name: 'QA', manifest: { fleetRole: 'crew', parent: 'ceo' } });
  });

  afterEach(() => {
    for (const m of activeManagers.splice(0)) m.dispose();
    rmSync(root, { recursive: true, force: true });
  });

  it('stopping the lead halts running crew and holds their queues, recursively', async () => {
    let released: (() => void) | null = null;
    const gate = new Promise<void>(r => { released = r; });
    mockedGenerateText.mockImplementation(async (opts: any) => {
      if (JSON.stringify(opts?.messages ?? '').includes('long delegated work')) {
        // Crew turn hangs until we stop the lead — but a real generateText
        // rejects on abort, so race the gate against the abort signal.
        await Promise.race([
          gate,
          new Promise((_, rej) => opts.abortSignal?.addEventListener('abort', () => rej(new Error('Request was aborted')))),
        ]);
        if (opts.abortSignal?.aborted) throw new Error('Request was aborted');
        return { text: 'done', finishReason: 'stop', usage: { inputTokens: 1, outputTokens: 1 } } as any;
      }
      return { text: 'ok', finishReason: 'stop', usage: { inputTokens: 1, outputTokens: 1 } } as any;
    });

    manager.dispatchTask('backend', 'eng', 'long delegated work');
    // Two distinct jobs: per-bot concurrency is 1, so one runs (held on the
    // gate) and one stays queued at stop time.
    manager.enqueue('qa', { trigger: 'chat', prompt: 'long delegated work A' });
    manager.enqueue('qa', { trigger: 'chat', prompt: 'long delegated work B' });
    await vi.waitFor(() => {
      expect(manager.getStatusSummaries().find(s => s.id === 'backend')?.state).toBe('running');
    });

    const result = await manager.stop('ceo');
    expect(result.crewStopped).toBe(3); // eng + backend + qa
    expect(result.heldJobs).toBe(1); // qa's queued job

    // Nothing in the subtree is running; all held.
    await vi.waitFor(() => {
      const states = Object.fromEntries(manager.getStatusSummaries().map(s => [s.id, s.state]));
      expect(states['backend']).not.toBe('running');
      expect(states['eng']).not.toBe('running');
    });
    for (const id of ['ceo', 'eng', 'backend', 'qa']) {
      expect(manager['held'].has(id)).toBe(true);
    }
    (released as unknown as (() => void) | null)?.();
  });

  it('starting the lead resumes the crew subtree except explicitly disabled crew', async () => {
    // Arrange held state across the fleet.
    await manager.stop('ceo');
    store.setEnabled('qa', false);

    const result = manager.start('ceo');
    expect(manager['held'].has('ceo')).toBe(false);
    expect(manager['held'].has('eng')).toBe(false);
    expect(manager['held'].has('backend')).toBe(false);
    // Explicitly disabled crew stay off.
    expect(manager['held'].has('qa')).toBe(true);
    expect(store.get('qa')!.enabled).toBe(false);
    void result;
  });

  it('stop of a mid-level lead only stops its own subtree, not its siblings', async () => {
    manager.enqueue('qa', { trigger: 'chat', prompt: 'qa task' });
    const result = await manager.stop('eng');
    expect(result.crewStopped).toBe(1); // backend only
    expect(manager['held'].has('qa')).toBe(false);
    expect(manager['held'].has('backend')).toBe(true);
  });
});