plugin-manager.test.ts

import { afterEach, describe, expect, test } from 'bun:test';
import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
import { join } from 'node:path';
import { Context } from 'cordis';
import { ConfigService, type GatewayConfig } from './config.js';
import { ContractsService } from './contracts.js';
import { PluginManagerService } from './plugin-manager.js';
import type { PluginDatabase, PluginRegistryEntry } from '@tradinggoose/db';

const TEMP_DIRS: string[] = [];

function makeTempDir(): string {
  const dir = mkdtempSync(join(process.cwd(), '.tmp-tradinggoose-plugin-manager-'));
  TEMP_DIRS.push(dir);
  return dir;
}

function writePlugin(pluginDir: string, name: string, source = 'export default function plugin() {}'): string {
  const dir = join(pluginDir, name);
  mkdirSync(dir, { recursive: true });
  writeFileSync(join(dir, 'index.ts'), source);
  writeFileSync(
    join(dir, 'manifest.ts'),
    `
      export const manifest = {
        id: '${name}',
        displayName: '${name}',
        version: '0.1.0',
        description: '${name} plugin.',
        provides: [],
        consumes: [],
      };
    `,
  );
  return dir;
}

function writeManifest(pluginPath: string, source: string): void {
  writeFileSync(join(pluginPath, 'manifest.ts'), source);
}

function makeConfig(rootDir: string, overrides: Partial<GatewayConfig> = {}): GatewayConfig {
  return {
    databaseUrl: 'postgresql://example.test:5432/gateway',
    databaseMode: 'postgres',
    embeddedPostgresDataDir: join(rootDir, 'data', '_gateway', 'postgres'),
    embeddedPostgresPort: 54329,
    logLevel: 'debug',
    pluginDir: join(rootDir, 'plugins'),
    dataDir: join(rootDir, 'data'),
    ...overrides,
  };
}

async function withMutedConsole<T>(fn: () => Promise<T> | T): Promise<T> {
  const originalLog = console.log;
  const originalWarn = console.warn;
  const originalError = console.error;
  console.log = (() => {}) as typeof console.log;
  console.warn = (() => {}) as typeof console.warn;
  console.error = (() => {}) as typeof console.error;
  try {
    return await fn();
  } finally {
    console.log = originalLog;
    console.warn = originalWarn;
    console.error = originalError;
  }
}

function mockDb() {
  const plugins: PluginRegistryEntry[] = [];
  const schemas = new Set<string>();
  const activities: string[] = [];
  const errors: unknown[] = [];

  return {
    _plugins: plugins,
    _schemas: schemas,
    _activities: activities,
    _errors: errors,
    async getEnabledPlugins() {
      return plugins.filter((plugin) => plugin.enabled);
    },
    async getAllPlugins() {
      return [...plugins];
    },
    async getPlugin(name: string) {
      return plugins.find((plugin) => plugin.name === name) ?? null;
    },
    async registerPlugin(name: string, source: string) {
      const existing = plugins.find((plugin) => plugin.name === name);
      if (existing) {
        existing.source = source;
        existing.enabled = true;
      } else {
        plugins.push({
          name,
          source,
          enabled: true,
          installed_at: new Date().toISOString(),
          updated_at: new Date().toISOString(),
        });
      }
    },
    async unregisterPlugin(name: string) {
      const index = plugins.findIndex((plugin) => plugin.name === name);
      if (index !== -1) plugins.splice(index, 1);
    },
    async setPluginEnabled(name: string, enabled: boolean) {
      const existing = plugins.find((plugin) => plugin.name === name);
      if (existing) existing.enabled = enabled;
    },
    async createPluginSchema(name: string) {
      schemas.add(name);
    },
    async dropPluginSchema(name: string) {
      schemas.delete(name);
    },
    async runPluginMigrations() {},
    createPluginDb(name: string) {
      return {
        schema: name.replace(/[^a-zA-Z0-9_]/g, '_'),
        drizzle() {
          return {} as any;
        },
      } as PluginDatabase;
    },
    async logActivity(input: { action: string }) {
      activities.push(input.action);
    },
    async logEvent() {},
    async logError(input: unknown) {
      errors.push(input);
    },
  };
}

async function createManagerHarness() {
  const rootDir = makeTempDir();
  const pluginDir = join(rootDir, 'plugins');
  const dataDir = join(rootDir, 'data');
  writePlugin(pluginDir, 'example');

  const config = makeConfig(rootDir, { pluginDir, dataDir });

  const db = mockDb();
  await db.registerPlugin('example', 'github:user/example');

  const ctx = new Context();
  await ctx.plugin(ConfigService, config);
  ctx.provide('dbRoot', db as any);
  await ctx.plugin(ContractsService);
  await ctx.plugin(PluginManagerService, config);

  return { ctx, db, config };
}

afterEach(() => {
  for (const dir of TEMP_DIRS.splice(0)) {
    rmSync(dir, { recursive: true, force: true });
  }
  delete (globalThis as { __tgSequence?: string[] }).__tgSequence;
});

describe('PluginManagerService', () => {
  test('loads boot plugins and reports user plugin state', async () => {
    const { ctx } = await createManagerHarness();

    const loaded = await withMutedConsole(() => ctx.pluginManager.loadBootPlugins());
    expect(loaded.some((plugin) => plugin.name === 'example' && !plugin.bootstrap)).toBe(true);

    const info = await ctx.pluginManager.getInfo('example');
    expect(info).toMatchObject({
      name: 'example',
      enabled: true,
      running: true,
      bootstrap: false,
    });
  });

  test('disable and enable update registry state and running state', async () => {
    const { ctx, db } = await createManagerHarness();
    await withMutedConsole(() => ctx.pluginManager.loadBootPlugins());

    await withMutedConsole(() => ctx.pluginManager.disable('example'));
    expect(db._plugins.find((plugin) => plugin.name === 'example')?.enabled).toBe(false);
    expect((await ctx.pluginManager.getInfo('example'))?.running).toBe(false);

    await withMutedConsole(() => ctx.pluginManager.enable('example'));
    expect(db._plugins.find((plugin) => plugin.name === 'example')?.enabled).toBe(true);
    expect((await ctx.pluginManager.getInfo('example'))?.running).toBe(true);
  });

  test('soft uninstall removes files and registry but preserves schema', async () => {
    const { ctx, db, config } = await createManagerHarness();
    await withMutedConsole(() => ctx.pluginManager.loadBootPlugins());

    const result = await withMutedConsole(() => ctx.pluginManager.uninstall('example', { keepData: true }));

    expect(result).toMatchObject({ success: true, restartRequired: true });
    expect(db._plugins).toEqual([]);
    expect(db._schemas.has('example')).toBe(true);
    expect(existsSync(join(config.pluginDir, 'example'))).toBe(false);
    expect(existsSync(join(config.dataDir, 'example'))).toBe(false);
  });

  test('disabling one plugin leaves unrelated plugins active', async () => {
    const rootDir = makeTempDir();
    const pluginDir = join(rootDir, 'plugins');
    const dataDir = join(rootDir, 'data');
    writePlugin(pluginDir, 'alpha');
    writePlugin(pluginDir, 'bravo');

    const config = makeConfig(rootDir, { pluginDir, dataDir });

    const db = mockDb();
    await db.registerPlugin('alpha', 'github:user/alpha');
    await db.registerPlugin('bravo', 'github:user/bravo');

    const ctx = new Context();
    await ctx.plugin(ConfigService, config);
    ctx.provide('dbRoot', db as any);
    await ctx.plugin(ContractsService);
    await ctx.plugin(PluginManagerService, config);
    await withMutedConsole(() => ctx.pluginManager.loadBootPlugins());

    await withMutedConsole(() => ctx.pluginManager.disable('alpha'));
    await Bun.sleep(0);
    expect((await ctx.pluginManager.getInfo('alpha'))?.running).toBe(false);
    expect((await ctx.pluginManager.getInfo('bravo'))?.running).toBe(true);
  });

  test('hard inject activates after a later plugin provides the service', async () => {
    const rootDir = makeTempDir();
    const pluginDir = join(rootDir, 'plugins');
    const dataDir = join(rootDir, 'data');

    writePlugin(
      pluginDir,
      'alpha-consumer',
      `
        export const inject = ['demoService'];

        export default function plugin(ctx: any) {
          (globalThis as any).__tgSequence ??= [];
          const service = ctx.get('demoService');
          (globalThis as any).__tgSequence.push(\`consumer:\${service?.ping?.()}\`);
        }
      `,
    );
    writePlugin(
      pluginDir,
      'zeta-provider',
      `
        export default function plugin(ctx: any) {
          (globalThis as any).__tgSequence ??= [];
          (globalThis as any).__tgSequence.push('provider');
          ctx.provide('demoService', { ping: () => 'ok' });
        }
      `,
    );

    const config = makeConfig(rootDir, { pluginDir, dataDir });

    const db = mockDb();
    await db.registerPlugin('alpha-consumer', 'github:user/alpha-consumer');
    await db.registerPlugin('zeta-provider', 'github:user/zeta-provider');

    (globalThis as { __tgSequence?: string[] }).__tgSequence = [];

    const ctx = new Context();
    await ctx.plugin(ConfigService, config);
    ctx.provide('dbRoot', db as any);
    await ctx.plugin(ContractsService);
    await ctx.plugin(PluginManagerService, config);
    await withMutedConsole(() => ctx.pluginManager.loadBootPlugins());

    expect((globalThis as { __tgSequence?: string[] }).__tgSequence).toEqual([
      'provider',
      'consumer:ok',
    ]);
    expect((await ctx.pluginManager.getInfo('alpha-consumer'))?.state).toBe('active');
    expect((await ctx.pluginManager.getInfo('alpha-consumer'))?.running).toBe(true);

    delete (globalThis as { __tgSequence?: string[] }).__tgSequence;
  });

  test('plugin remains pending when a required injected service never appears', async () => {
    const rootDir = makeTempDir();
    const pluginDir = join(rootDir, 'plugins');
    const dataDir = join(rootDir, 'data');

    writePlugin(
      pluginDir,
      'needs-service',
      `
        export const inject = ['missingService'];
        export default function plugin() {}
      `,
    );

    const config = makeConfig(rootDir, { pluginDir, dataDir });

    const db = mockDb();
    await db.registerPlugin('needs-service', 'github:user/needs-service');

    const ctx = new Context();
    await ctx.plugin(ConfigService, config);
    ctx.provide('dbRoot', db as any);
    await ctx.plugin(ContractsService);
    await ctx.plugin(PluginManagerService, config);
    await withMutedConsole(() => ctx.pluginManager.loadBootPlugins());

    expect((await ctx.pluginManager.getInfo('needs-service'))).toMatchObject({
      running: false,
      state: 'pending',
    });
  });

  test('ctx.inject supports lazy binding when a provider appears later', async () => {
    const rootDir = makeTempDir();
    const pluginDir = join(rootDir, 'plugins');
    const dataDir = join(rootDir, 'data');

    writePlugin(
      pluginDir,
      'alpha-consumer',
      `
        export default function plugin(ctx: any) {
          (globalThis as any).__tgSequence ??= [];
          (globalThis as any).__tgSequence.push('consumer:start');
          ctx.inject(['demoService'], (readyCtx: any) => {
            (globalThis as any).__tgSequence.push(\`consumer:bound:\${readyCtx.get('demoService')?.ping?.()}\`);
          });
        }
      `,
    );
    writePlugin(
      pluginDir,
      'zeta-provider',
      `
        export default function plugin(ctx: any) {
          (globalThis as any).__tgSequence ??= [];
          (globalThis as any).__tgSequence.push('provider');
          ctx.provide('demoService', { ping: () => 'ok' });
        }
      `,
    );

    const config = makeConfig(rootDir, { pluginDir, dataDir });

    const db = mockDb();
    await db.registerPlugin('alpha-consumer', 'github:user/alpha-consumer');
    await db.registerPlugin('zeta-provider', 'github:user/zeta-provider');

    (globalThis as { __tgSequence?: string[] }).__tgSequence = [];

    const ctx = new Context();
    await ctx.plugin(ConfigService, config);
    ctx.provide('dbRoot', db as any);
    await ctx.plugin(ContractsService);
    await ctx.plugin(PluginManagerService, config);
    await withMutedConsole(() => ctx.pluginManager.loadBootPlugins());
    await Bun.sleep(0);

    expect((globalThis as { __tgSequence?: string[] }).__tgSequence).toEqual([
      'consumer:start',
      'provider',
      'consumer:bound:ok',
    ]);

    delete (globalThis as { __tgSequence?: string[] }).__tgSequence;
  });

  test('plugin info reports manifest capabilities and runtime contract registrations', async () => {
    const { ctx } = await createManagerHarness();
    await withMutedConsole(() => ctx.pluginManager.loadBootPlugins());
    ctx.contracts.register({
      contract: 'llm.chat/v1',
      plugin: 'example',
      implementationId: 'chat',
      implementation: { name: 'openai' },
      priority: 10,
    });
    await Bun.sleep(0);

    const info = await ctx.pluginManager.getInfo('example');
    expect(info?.provides).toEqual([]);
    expect(info?.registeredContracts).toEqual(['llm.chat/v1']);
  });

  test('plugin manager methods work from a plugin child context with dbRoot isolated', async () => {
    const rootDir = makeTempDir();
    const pluginDir = join(rootDir, 'plugins');
    const dataDir = join(rootDir, 'data');

    writePlugin(
      pluginDir,
      'observer',
      `
        export const inject = ['pluginManager'];

        export default async function plugin(ctx: any) {
          (globalThis as any).__tgPluginList = await ctx.pluginManager.list();
        }
      `,
    );

    const config = makeConfig(rootDir, { pluginDir, dataDir });
    const db = mockDb();
    await db.registerPlugin('observer', 'github:user/observer');

    const ctx = new Context();
    await ctx.plugin(ConfigService, config);
    ctx.provide('dbRoot', db as any);
    await ctx.plugin(ContractsService);
    await ctx.plugin(PluginManagerService, config);
    await withMutedConsole(() => ctx.pluginManager.loadBootPlugins());

    const listed = (globalThis as { __tgPluginList?: Array<{ name: string }> }).__tgPluginList ?? [];
    expect(Array.isArray(listed)).toBe(true);
    expect((await ctx.pluginManager.getInfo('observer'))?.running).toBe(true);

    delete (globalThis as { __tgPluginList?: Array<{ name: string }> }).__tgPluginList;
  });
});