plugin-loader.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 type { Context } from 'cordis';
import type { GatewayConfig } from './config.js';
import type { DatabaseService, PluginDatabase, PluginRegistryEntry } from '@tradinggoose/db';
import { installPlugin, uninstallPlugin, loadUserPlugins } from './plugin-loader.js';

const TEMP_DIRS: string[] = [];

function makeTempDir(): string {
  const dir = mkdtempSync(join(process.cwd(), '.tmp-tradinggoose-gateway-'));
  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: '',
    databaseMode: 'embedded-postgres',
    embeddedPostgresDataDir: join(rootDir, 'data', '_gateway', 'postgres'),
    embeddedPostgresPort: 54329,
    logLevel: 'info',
    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;
  }
}

/** In-memory mock of DatabaseService for tests (no real PostgreSQL needed). */
function mockDb(): DatabaseService & {
  _plugins: PluginRegistryEntry[];
  _schemas: string[];
  _migrations: Array<{ plugin: string; dir: string }>;
  _errors: unknown[];
} {
  const plugins: PluginRegistryEntry[] = [];
  const schemas: string[] = [];
  const migrations: Array<{ plugin: string; dir: string }> = [];
  const errors: unknown[] = [];

  return {
    _plugins: plugins,
    _schemas: schemas,
    _migrations: migrations,
    _errors: errors,
    async getEnabledPlugins() {
      return plugins.filter((p) => p.enabled);
    },
    async getAllPlugins() {
      return [...plugins];
    },
    async getPlugin(name: string) {
      return plugins.find((p) => p.name === name) ?? null;
    },
    async registerPlugin(name: string, source: string) {
      const existing = plugins.find((p) => p.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 idx = plugins.findIndex((p) => p.name === name);
      if (idx !== -1) plugins.splice(idx, 1);
    },
    async setPluginEnabled(name: string, enabled: boolean) {
      const entry = plugins.find((p) => p.name === name);
      if (entry) entry.enabled = enabled;
    },
    async createPluginSchema(pluginName: string) {
      schemas.push(pluginName);
    },
    async dropPluginSchema(pluginName: string) {
      const idx = schemas.indexOf(pluginName);
      if (idx !== -1) schemas.splice(idx, 1);
    },
    async runPluginMigrations(pluginName: string, migrationsDir: string) {
      migrations.push({ plugin: pluginName, dir: migrationsDir });
    },
    createPluginDb(pluginName: string) {
      return {
        schema: pluginName.replace(/[^a-zA-Z0-9_]/g, '_'),
        drizzle() {
          return {} as any;
        },
      } as PluginDatabase;
    },
    async logError(input: unknown) {
      errors.push(input);
    },
  } as unknown as DatabaseService & {
    _plugins: PluginRegistryEntry[];
    _schemas: string[];
    _migrations: Array<{ plugin: string; dir: string }>;
    _errors: unknown[];
  };
}

function makeMockContext(
  db: DatabaseService,
  options?: {
    registrations?: Array<{ name: string; dataDir: string }>;
    providedDbs?: PluginDatabase[];
    plugins?: unknown[];
  },
): Context {
  const scope = {
    get(name: string) {
      if (name === 'dbRoot') return db;
      return undefined;
    },
    isolate() {
      return scope;
    },
    extend() {
      return scope;
    },
    provide(name: string, value?: unknown) {
      if (name === 'db' && value) {
        options?.providedDbs?.push(value as PluginDatabase);
      }
      return () => {};
    },
    plugin(plugin: unknown, pluginOptions: { name: string; dataDir: string }) {
      options?.plugins?.push(plugin);
      options?.registrations?.push(pluginOptions);
    },
  };

  return scope as unknown as Context;
}

afterEach(() => {
  for (const dir of TEMP_DIRS.splice(0)) {
    rmSync(dir, { recursive: true, force: true });
  }
});

describe("loadUserPlugins", () => {
  test('returns empty when no plugins are registered', async () => {
    const rootDir = makeTempDir();
    const db = mockDb();
    const config = makeConfig(rootDir);

    const ctx = makeMockContext(db);
    const loaded = await withMutedConsole(() => loadUserPlugins(ctx, config));

    expect(loaded).toEqual([]);
    expect(existsSync(join(rootDir, 'plugins'))).toBe(true);
  });

  test('loads registered plugins, provisions data dirs, and runs schema setup', async () => {
    const rootDir = makeTempDir();
    const pluginDir = join(rootDir, 'plugins');
    const dataDir = join(rootDir, 'data');

    const alphaDir = writePlugin(pluginDir, '_alpha');
    writePlugin(pluginDir, 'z-user');
    mkdirSync(join(alphaDir, 'migrations'), { recursive: true });
    writeFileSync(join(alphaDir, 'migrations', '0001_initial.sql'), 'select 1;');

    const db = mockDb();
    await db.registerPlugin('_alpha', 'local');
    await db.registerPlugin('z-user', 'local');

    const registrations: Array<{ name: string; dataDir: string }> = [];
    const providedDbs: PluginDatabase[] = [];
    const ctx = makeMockContext(db, { registrations, providedDbs });

    const config = makeConfig(rootDir, { pluginDir, dataDir });
    const loaded = await withMutedConsole(() => loadUserPlugins(ctx, config));

    expect(db._errors).toEqual([]);
    expect(loaded.map((p) => p.name)).toEqual(['_alpha', 'z-user']);
    expect(db._schemas).toEqual(['_alpha', 'z-user']);
    expect(db._migrations.map((m) => m.plugin)).toEqual(['_alpha', 'z-user']);
    expect(registrations.map((r) => r.name)).toEqual(['_alpha', 'z-user']);
    expect(providedDbs.map((entry) => entry.schema)).toEqual(['_alpha', 'z_user']);
    expect(existsSync(join(dataDir, '_alpha'))).toBe(true);
    expect(existsSync(join(dataDir, 'z-user'))).toBe(true);
  });

  test('skips registered plugins whose folders are missing', async () => {
    const rootDir = makeTempDir();
    const db = mockDb();
    await db.registerPlugin('missing', 'local');

    const ctx = makeMockContext(db);
    const config = makeConfig(rootDir);

    const loaded = await withMutedConsole(() => loadUserPlugins(ctx, config));
    expect(loaded).toEqual([]);
    expect(db._schemas).toEqual([]); // schema not created for missing plugin
  });

  test('continues loading when one plugin import fails', async () => {
    const rootDir = makeTempDir();
    const pluginDir = join(rootDir, 'plugins');
    writePlugin(pluginDir, 'broken', 'throw new Error("boom");');
    writePlugin(pluginDir, 'working');

    const db = mockDb();
    await db.registerPlugin('broken', 'local');
    await db.registerPlugin('working', 'local');

    const ctx = makeMockContext(db);
    const config = makeConfig(rootDir, { pluginDir, dataDir: join(rootDir, 'data') });

    const loaded = await withMutedConsole(() => loadUserPlugins(ctx, config));
    expect(loaded.map((p) => p.name)).toEqual(['working']);
  });

  test('loads user plugins in deterministic name order regardless of registry order', async () => {
    const rootDir = makeTempDir();
    const pluginDir = join(rootDir, 'plugins');
    const providerDir = writePlugin(pluginDir, 'llm-openai');
    const consumerDir = writePlugin(pluginDir, 'openclaw-runtime');

    writeManifest(providerDir, `
      export const manifest = {
        id: 'llm-openai',
        displayName: 'OpenAI LLM Provider',
        version: '0.1.0',
        description: 'OpenAI provider.',
        provides: ['llm.chat/v1'],
        consumes: [],
      };
    `);
    writeManifest(consumerDir, `
      export const manifest = {
        id: 'openclaw-runtime',
        displayName: 'OpenClaw Runtime',
        version: '0.1.0',
        description: 'OpenClaw runtime.',
        provides: [],
        consumes: ['llm.chat/v1'],
      };
    `);

    const db = mockDb();
    await db.registerPlugin('openclaw-runtime', 'local');
    await db.registerPlugin('llm-openai', 'local');

    const registrations: Array<{ name: string; dataDir: string }> = [];
    const ctx = makeMockContext(db, { registrations });

    const config = makeConfig(rootDir, { pluginDir, dataDir: join(rootDir, 'data') });
    const loaded = await withMutedConsole(() => loadUserPlugins(ctx, config));

    expect(loaded.map((plugin) => plugin.name)).toEqual(['llm-openai', 'openclaw-runtime']);
    expect(registrations.map((registration) => registration.name)).toEqual(['llm-openai', 'openclaw-runtime']);
  });

  test('does not block consumer plugins when no provider is installed yet', async () => {
    const rootDir = makeTempDir();
    const pluginDir = join(rootDir, 'plugins');
    const consumerDir = writePlugin(pluginDir, 'openclaw-runtime');

    writeManifest(consumerDir, `
      export const manifest = {
        id: 'openclaw-runtime',
        displayName: 'OpenClaw Runtime',
        version: '0.1.0',
        description: 'OpenClaw runtime.',
        provides: [],
        consumes: ['llm.chat/v1'],
      };
    `);

    const db = mockDb();
    await db.registerPlugin('openclaw-runtime', 'local');

    const ctx = makeMockContext(db);
    const config = makeConfig(rootDir, { pluginDir, dataDir: join(rootDir, 'data') });

    const loaded = await withMutedConsole(() => loadUserPlugins(ctx, config));
    expect(loaded.map((plugin) => plugin.name)).toEqual(['openclaw-runtime']);
  });

  test('preserves named plugin metadata like inject on default exports', async () => {
    const rootDir = makeTempDir();
    const pluginDir = join(rootDir, 'plugins');
    writePlugin(
      pluginDir,
      'needs-contracts',
      `
        export const inject = ['contracts'];
        export default function plugin() {}
      `,
    );

    const db = mockDb();
    await db.registerPlugin('needs-contracts', 'local');

    const seenPlugins: unknown[] = [];
    const ctx = makeMockContext(db, { plugins: seenPlugins });
    const config = makeConfig(rootDir, { pluginDir, dataDir: join(rootDir, 'data') });

    await withMutedConsole(() => loadUserPlugins(ctx, config));

    expect(seenPlugins).toHaveLength(1);
    expect((seenPlugins[0] as { inject?: string[] }).inject).toEqual(['contracts']);
  });

  test('shadows ctx.db with a plugin-scoped database facade', async () => {
    const rootDir = makeTempDir();
    const pluginDir = join(rootDir, 'plugins');
    writePlugin(pluginDir, 'broker-alpaca');

    const db = mockDb();
    await db.registerPlugin('broker-alpaca', 'local');

    const providedDbs: PluginDatabase[] = [];
    const ctx = makeMockContext(db, { providedDbs });
    const config = makeConfig(rootDir, { pluginDir, dataDir: join(rootDir, 'data') });

    await withMutedConsole(() => loadUserPlugins(ctx, config));

    expect(providedDbs).toHaveLength(1);
    expect(providedDbs[0]?.schema).toBe('broker_alpaca');
  });
});

describe('installPlugin', () => {
  test('rejects non-cloneable source', async () => {
    const rootDir = makeTempDir();
    const db = mockDb();
    const config = makeConfig(rootDir);

    const result = await installPlugin('local', db, config);
    expect(result.success).toBe(false);
    expect(result.error).toContain('Cannot install');
  });

  test('rejects duplicate install', async () => {
    const rootDir = makeTempDir();
    const db = mockDb();
    await db.registerPlugin('my-plugin', 'github:user/tg-plugin-my-plugin');

    const config = makeConfig(rootDir);

    const result = await installPlugin('github:user/tg-plugin-my-plugin', db, config);
    expect(result.success).toBe(false);
    expect(result.error).toContain('already registered');
  });
});

describe('uninstallPlugin', () => {
  test('removes plugin from DB, files, and data', async () => {
    const rootDir = makeTempDir();
    const pluginDir = join(rootDir, 'plugins');
    const dataDir = join(rootDir, 'data');

    writePlugin(pluginDir, 'doomed');
    mkdirSync(join(dataDir, 'doomed'), { recursive: true });
    writeFileSync(join(dataDir, 'doomed', '.env'), 'API_KEY=val');

    const db = mockDb();
    await db.registerPlugin('doomed', 'local');
    db._schemas.push('doomed');

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

    const result = await withMutedConsole(() => uninstallPlugin('doomed', db, config));
    expect(result.success).toBe(true);
    expect(db._plugins).toEqual([]);
    expect(existsSync(join(pluginDir, 'doomed'))).toBe(false);
    expect(existsSync(join(dataDir, 'doomed'))).toBe(false);
  });

  test('returns error for unknown plugin', async () => {
    const db = mockDb();
    const rootDir = makeTempDir();
    const config = makeConfig(rootDir);

    const result = await uninstallPlugin('nope', db, config);
    expect(result.success).toBe(false);
    expect(result.error).toContain('not registered');
  });
});