Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

25.8 KB
Raw Blame
import {
  chmodSync,
  existsSync,
  mkdirSync,
  mkdtempSync,
  readFileSync,
  rmSync,
  writeFileSync,
} from 'node:fs';
import { tmpdir } from 'node:os';
import { join, resolve } from 'node:path';
import { EDITOR_USER_SKILL_ROOT } from '@inkeep/open-knowledge-core';
import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test } from 'vitest';
import { withFsCopyCompletionObserver } from '../../../server/src/fs-copy-observer.test-helper.ts';
import {
  createTestServer,
  HARNESS_BOOT_TIMEOUT_MS,
  pollUntil,
  type TestServer,
} from './test-harness.ts';

let srcRoot: string;

function writeSkillDir(dir: string, name: string, description: string, body = 'Body.'): void {
  mkdirSync(dir, { recursive: true });
  writeFileSync(
    join(dir, 'SKILL.md'),
    `---\nname: ${name}\ndescription: ${description}\n---\n\n${body}\n`,
  );
}

beforeAll(() => {
  srcRoot = mkdtempSync(join(tmpdir(), 'ok-import-src-'));
}, HARNESS_BOOT_TIMEOUT_MS);
afterAll(() => {
  rmSync(srcRoot, { recursive: true, force: true });
});

describe('POST /api/skill/import', () => {
  let server: TestServer;
  beforeEach(async () => {
    server = await createTestServer();
    mkdirSync(join(server.contentDir, '.claude'), { recursive: true });
  });
  afterEach(async () => {
    await server.cleanup();
  });

  const base = () => `http://127.0.0.1:${server.port}`;
  const importSkill = (payload: Record<string, unknown>) =>
    fetch(`${base()}/api/skill/import`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(payload),
    });

  test('project import reports no usable target without creating a host root', async () => {
    rmSync(join(server.contentDir, '.claude'), { recursive: true, force: true });
    rmSync(join(server.contentDir, '.agents'), { recursive: true, force: true });
    const dir = join(srcRoot, 'project-no-host');
    writeSkillDir(dir, 'project-no-host', 'No implicit host');

    const res = await importSkill({ source: dir });
    const body = (await res.json()) as { detail?: string; title?: string };

    expect({
      status: res.status,
      detail: body.detail,
      claudeRootExists: existsSync(join(server.contentDir, '.claude')),
      agentsRootExists: existsSync(join(server.contentDir, '.agents')),
    }).toEqual({
      status: 400,
      detail: 'NO_USABLE_SKILL_HOME',
      claudeRootExists: false,
      agentsRootExists: false,
    });
    expect(body.title).toContain('.claude/');
    expect(body.title).toContain('Create the folder your agent uses');
  });

  test('imports a local skill-dir as content + records provenance; scripts not executed', async () => {
    const dir = join(srcRoot, 'single');
    writeSkillDir(dir, 'cool-skill', 'Does cool things', '# Cool\n');
    const marker = join(srcRoot, 'PWNED');
    mkdirSync(join(dir, 'scripts'), { recursive: true });
    writeFileSync(join(dir, 'scripts', 'run.sh'), `#!/bin/sh\ntouch '${marker}'\n`);
    mkdirSync(join(dir, 'references'), { recursive: true });
    writeFileSync(join(dir, 'references', 'api.md'), '# API\n');

    const res = await importSkill({ source: dir });
    expect(res.status).toBe(200);
    const out = (await res.json()) as {
      name: string;
      created: boolean;
      alreadyImported: boolean;
      provenance: { contentHash: string; source: string };
    };
    expect(out.name).toBe('cool-skill');
    expect(out.created).toBe(true);
    expect(out.alreadyImported).toBe(false);
    expect(out.provenance.contentHash).toMatch(/^[0-9a-f]{64}$/);

    const skillMd = resolve(server.contentDir, '.claude', 'skills', 'cool-skill', 'SKILL.md');
    await pollUntil(() => existsSync(skillMd));
    expect(readFileSync(skillMd, 'utf-8')).toContain('name: cool-skill');
    expect(
      existsSync(
        resolve(server.contentDir, '.claude', 'skills', 'cool-skill', 'scripts', 'run.sh'),
      ),
    ).toBe(true);
    expect(existsSync(marker)).toBe(false);

    const lock = JSON.parse(
      readFileSync(resolve(server.contentDir, '.ok', 'skills-lock.json'), 'utf-8'),
    );
    expect(lock.skills['cool-skill'].contentHash).toBe(out.provenance.contentHash);
    expect(lock.skills['cool-skill'].source).toBe(dir);
  });

  test('identical re-import is a no-op (contentHash dedupe)', async () => {
    const dir = join(srcRoot, 'dup');
    writeSkillDir(dir, 'dup-skill', 'd');
    expect((await importSkill({ source: dir })).status).toBe(200);
    const second = (await importSkill({ source: dir }).then((r) => r.json())) as {
      alreadyImported: boolean;
      name: string;
    };
    expect(second.alreadyImported).toBe(true);
    expect(second.name).toBe('dup-skill');
  });

  test('duplicate copies the complete bundle, including binary files', async () => {
    const dir = join(srcRoot, 'duplicate-source');
    writeSkillDir(dir, 'duplicate-source', 'source', '# Original\n');
    mkdirSync(join(dir, 'assets'), { recursive: true });
    const binary = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x00, 0xff]);
    writeFileSync(join(dir, 'assets', 'logo.png'), binary);
    expect((await importSkill({ source: dir, install: false })).status).toBe(200);
    const sourceHome = existsSync(join(server.contentDir, '.agents')) ? '.agents' : '.claude';
    const installedSourceDir = resolve(server.contentDir, sourceHome, 'skills', 'duplicate-source');
    writeFileSync(
      join(installedSourceDir, 'SKILL.md'),
      [
        '---',
        '# keep this comment',
        'name: duplicate-source',
        'description: source',
        'tags: [audit, reusable]',
        'metadata:',
        '  owner: platform',
        '---',
        '# Original',
        '',
      ].join('\n'),
    );

    const duplicate = await fetch(`${base()}/api/skill/duplicate`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        scope: 'project',
        name: 'duplicate-source',
        toName: 'duplicate-source-copy',
      }),
    });
    expect(duplicate.status).toBe(200);
    expect(await duplicate.json()).toMatchObject({ name: 'duplicate-source-copy' });

    const copiedDir = resolve(server.contentDir, sourceHome, 'skills', 'duplicate-source-copy');
    expect(readFileSync(join(copiedDir, 'assets', 'logo.png')).equals(binary)).toBe(true);
    const copiedSkillMd = readFileSync(join(copiedDir, 'SKILL.md'), 'utf-8');
    expect(copiedSkillMd).toContain('name: duplicate-source-copy');
    expect(copiedSkillMd).toContain('# keep this comment');
    expect(copiedSkillMd).toMatch(/tags: \[\s*audit,\s*reusable\s*\]/);
    expect(copiedSkillMd).toContain('owner: platform');

    const conflict = await fetch(`${base()}/api/skill/duplicate`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        scope: 'project',
        name: 'duplicate-source',
        toName: 'duplicate-source-copy',
      }),
    });
    expect(conflict.status).toBe(409);

    const missing = await fetch(`${base()}/api/skill/duplicate`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        scope: 'project',
        name: 'does-not-exist',
        toName: 'does-not-exist-copy',
      }),
    });
    expect(missing.status).toBe(404);
  });

  test('an unparseable source frontmatter fails the duplicate with the parse reason', async () => {
    const dir = join(srcRoot, 'dup-bad-fm');
    writeSkillDir(dir, 'dup-bad-fm', 'source');
    expect((await importSkill({ source: dir, install: false })).status).toBe(200);
    const home = existsSync(join(server.contentDir, '.agents')) ? '.agents' : '.claude';
    const sourceDir = resolve(server.contentDir, home, 'skills', 'dup-bad-fm');
    const copyDir = resolve(server.contentDir, home, 'skills', 'dup-bad-fm-copy');
    writeFileSync(join(sourceDir, 'SKILL.md'), '---\nname: [unclosed\n---\n\nBody.\n');

    const response = await fetch(`${base()}/api/skill/duplicate`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        scope: 'project',
        name: 'dup-bad-fm',
        toName: 'dup-bad-fm-copy',
      }),
    });
    const result = (await response.json()) as { detail?: string; title?: string; type?: string };

    expect(response.status).toBe(400);
    expect(result.type).toBe('urn:ok:error:invalid-request');
    expect(result.title).toContain('destination copy removed');
    expect(result.detail).toMatch(/parse_failed \(frontmatter region unparseable: .+\)/);
    expect(result.detail).toContain('was not touched');
    expect(existsSync(copyDir)).toBe(false);
  });

  test('duplicate write and cleanup failures report the stray copy', async (ctx) => {
    if (process.platform === 'win32' || process.getuid?.() === 0) {
      ctx.skip('Requires a non-root POSIX user to enforce directory write permissions.');
    }
    const dir = join(srcRoot, 'dup-cleanup');
    writeSkillDir(dir, 'dup-cleanup', 'source');
    expect((await importSkill({ source: dir, install: false })).status).toBe(200);
    const home = existsSync(join(server.contentDir, '.agents')) ? '.agents' : '.claude';
    const copyDir = resolve(server.contentDir, home, 'skills', 'dup-cleanup-copy');

    try {
      const response = await withFsCopyCompletionObserver(
        (path) => path.endsWith(join('skills', 'dup-cleanup-copy')),
        () => {
          chmodSync(join(copyDir, 'SKILL.md'), 0o444);
          chmodSync(copyDir, 0o555);
        },
        () =>
          fetch(`${base()}/api/skill/duplicate`, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
              scope: 'project',
              name: 'dup-cleanup',
              toName: 'dup-cleanup-copy',
            }),
          }),
      );
      const result = (await response.json()) as { detail?: string; title?: string };

      expect(response.status).toBe(500);
      expect(result.title).toContain('destination cleanup failed');
      expect(result.detail).toContain('UNLINK_FAILED');
      expect(result.detail).toContain(`${home}/skills/dup-cleanup-copy`);
      expect(result.detail).toContain('Inspect the destination before retrying');
      expect(existsSync(copyDir)).toBe(true);
    } finally {
      if (existsSync(copyDir)) chmodSync(copyDir, 0o755);
    }
  });

  test('name collision with different content lands under -imported', async () => {
    const a = join(srcRoot, 'collide-a');
    const b = join(srcRoot, 'collide-b');
    writeSkillDir(a, 'twin', 'first', 'Original.');
    writeSkillDir(b, 'twin', 'second', 'Different body.');
    expect((await importSkill({ source: a })).status).toBe(200);
    const out = (await importSkill({ source: b }).then((r) => r.json())) as {
      name: string;
      collisionRenamedFrom?: string;
    };
    expect(out.name).toBe('twin-imported');
    expect(out.collisionRenamedFrom).toBe('twin');
  });

  test('multi-skill source requires --skill and imports the chosen one', async () => {
    const repo = join(srcRoot, 'multi');
    writeSkillDir(join(repo, 'skills', 'alpha'), 'alpha', 'a');
    writeSkillDir(join(repo, 'skills', 'beta'), 'beta', 'b');

    const ambiguous = await importSkill({ source: repo });
    expect(ambiguous.status).toBe(400);

    const picked = (await importSkill({ source: repo, skill: 'beta' }).then((r) => r.json())) as {
      name: string;
    };
    expect(picked.name).toBe('beta');
  });

  test('picks a skill by frontmatter name when it differs from the folder', async () => {
    const repo = join(srcRoot, 'fm-name');
    writeSkillDir(join(repo, 'skills', 'react-native-skills'), 'vercel-react-native-skills', 'rn');
    writeSkillDir(join(repo, 'skills', 'other'), 'other', 'o');

    const picked = (await importSkill({
      source: repo,
      skill: 'vercel-react-native-skills',
    }).then((r) => r.json())) as { name: string };
    expect(picked.name).toBe('vercel-react-native-skills');
  });

  test('rejects a request with no source', async () => {
    expect((await importSkill({})).status).toBe(400);
  });
});

describe('POST /api/skill/import at global scope', () => {
  let server: TestServer;
  let homeDir: string;
  let sourceDir: string;

  beforeEach(async () => {
    homeDir = mkdtempSync(join(tmpdir(), 'ok-global-import-home-'));
    sourceDir = mkdtempSync(join(tmpdir(), 'ok-global-import-source-'));
    writeSkillDir(sourceDir, 'global-copy', 'Global plugin copy');
    mkdirSync(join(homeDir, '.claude'), { recursive: true });
    server = await createTestServer({ configHomedirOverride: homeDir });
  });

  afterEach(async () => {
    await server.cleanup();
    rmSync(homeDir, { recursive: true, force: true });
    rmSync(sourceDir, { recursive: true, force: true });
  });

  test('records provenance in the global lock and surfaces it on the copied skill', async () => {
    const importResponse = await fetch(`${server.baseUrl}/api/skill/import`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        source: sourceDir,
        scope: 'global',
        install: false,
      }),
    });
    expect(importResponse.status).toBe(200);

    const globalLockPath = join(homeDir, '.ok', 'skills-lock.json');
    const globalLock = JSON.parse(readFileSync(globalLockPath, 'utf-8')) as {
      skills: Record<string, { source: string }>;
    };
    expect(globalLock.skills['global-copy']?.source).toBe(sourceDir);

    const projectLockPath = join(server.contentDir, '.ok', 'skills-lock.json');
    const projectLock = existsSync(projectLockPath)
      ? (JSON.parse(readFileSync(projectLockPath, 'utf-8')) as {
          skills: Record<string, { source: string }>;
        })
      : null;
    expect(projectLock?.skills['global-copy']).toBeUndefined();

    const list = (await fetch(`${server.baseUrl}/api/skills`).then((res) => res.json())) as {
      skills: Array<{ name: string; scope: string; origin?: { source: string } }>;
    };
    expect(
      list.skills.find((skill) => skill.scope === 'global' && skill.name === 'global-copy')?.origin
        ?.source,
    ).toBe(sourceDir);
  });

  test('global import reports no usable target without creating a host root', async () => {
    for (const root of Object.values(EDITOR_USER_SKILL_ROOT)) {
      const hostRoot = root?.split('/')[0];
      if (hostRoot !== undefined) rmSync(join(homeDir, hostRoot), { recursive: true, force: true });
    }
    rmSync(join(homeDir, '.agents'), { recursive: true, force: true });

    const res = await fetch(`${server.baseUrl}/api/skill/import`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ source: sourceDir, scope: 'global' }),
    });
    const body = (await res.json()) as { detail?: string };

    expect({
      status: res.status,
      detail: body.detail,
      claudeRootExists: existsSync(join(homeDir, '.claude')),
      agentsRootExists: existsSync(join(homeDir, '.agents')),
    }).toEqual({
      status: 400,
      detail: 'NO_USABLE_SKILL_HOME',
      claudeRootExists: false,
      agentsRootExists: false,
    });
  });
});

describe('POST /api/skill/reimport', () => {
  let server: TestServer;
  beforeEach(async () => {
    server = await createTestServer();
    mkdirSync(join(server.contentDir, '.claude'), { recursive: true });
  });
  afterEach(async () => {
    await server.cleanup();
  });

  const base = () => `http://127.0.0.1:${server.port}`;
  const importSkill = (payload: Record<string, unknown>) =>
    fetch(`${base()}/api/skill/import`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(payload),
    });
  const reimport = (payload: Record<string, unknown>) =>
    fetch(`${base()}/api/skill/reimport`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(payload),
    });

  test('reimport overwrites in place when the source changed, no-ops when unchanged', async () => {
    const dir = join(srcRoot, 'reimport-src');
    writeSkillDir(dir, 'evolving', 'v1', '# One\n');
    expect((await importSkill({ source: dir })).status).toBe(200);

    const same = (await reimport({ name: 'evolving' }).then((r) => r.json())) as {
      updated: boolean;
    };
    expect(same.updated).toBe(false);

    writeSkillDir(dir, 'evolving', 'v2', '# Two\n');
    const changed = (await reimport({ name: 'evolving' }).then((r) => r.json())) as {
      updated: boolean;
      name: string;
    };
    expect(changed.updated).toBe(true);
    expect(changed.name).toBe('evolving');

    const skillMd = resolve(server.contentDir, '.claude', 'skills', 'evolving', 'SKILL.md');
    await pollUntil(() => readFileSync(skillMd, 'utf-8').includes('# Two'));
    expect(readFileSync(skillMd, 'utf-8')).toContain('description: v2');
  });

  test('reimport prunes bundle files removed upstream before advancing the lock', async () => {
    const dir = join(srcRoot, 'reimport-prune-src');
    writeSkillDir(dir, 'shrinking', 'v1', '# One\n');
    mkdirSync(join(dir, 'references'), { recursive: true });
    mkdirSync(join(dir, 'assets'), { recursive: true });
    writeFileSync(join(dir, 'references', 'keep.md'), '# Keep\n');
    writeFileSync(join(dir, 'references', 'removed.md'), '# Remove\n');
    writeFileSync(join(dir, 'assets', 'removed.bin'), Buffer.from([0x00, 0xff]));
    expect((await importSkill({ source: dir, install: false })).status).toBe(200);

    const skillRoot = existsSync(join(server.contentDir, '.agents'))
      ? resolve(server.contentDir, '.agents', 'skills', 'shrinking')
      : resolve(server.contentDir, '.claude', 'skills', 'shrinking');
    expect(existsSync(join(skillRoot, 'references', 'removed.md'))).toBe(true);
    expect(existsSync(join(skillRoot, 'assets', 'removed.bin'))).toBe(true);

    rmSync(join(dir, 'references', 'removed.md'));
    rmSync(join(dir, 'assets', 'removed.bin'));
    writeSkillDir(dir, 'shrinking', 'v2', '# Two\n');
    const updated = (await reimport({ name: 'shrinking' }).then((r) => r.json())) as {
      updated: boolean;
    };
    expect(updated.updated).toBe(true);
    expect(existsSync(join(skillRoot, 'references', 'keep.md'))).toBe(true);
    expect(existsSync(join(skillRoot, 'references', 'removed.md'))).toBe(false);
    expect(existsSync(join(skillRoot, 'assets', 'removed.bin'))).toBe(false);

    const second = (await reimport({ name: 'shrinking' }).then((r) => r.json())) as {
      updated: boolean;
    };
    expect(second.updated).toBe(false);

    const lockPath = resolve(server.contentDir, '.ok', 'skills-lock.json');
    const lock = JSON.parse(readFileSync(lockPath, 'utf-8'));
    delete lock.skills.shrinking.files;
    writeFileSync(lockPath, `${JSON.stringify(lock, null, 2)}\n`);
    writeFileSync(join(skillRoot, 'references', 'user-notes.md'), '# Local notes\n');
    writeSkillDir(dir, 'shrinking', 'v3', '# Three\n');

    const legacyUpdated = (await reimport({ name: 'shrinking' }).then((r) => r.json())) as {
      updated: boolean;
    };
    expect(legacyUpdated.updated).toBe(true);
    expect(readFileSync(join(skillRoot, 'references', 'user-notes.md'), 'utf-8')).toBe(
      '# Local notes\n',
    );
  });

  test('setAutoUpdate persists the per-skill opt-out without fetching upstream', async () => {
    const dir = join(srcRoot, 'auto-update-src');
    writeSkillDir(dir, 'auto-toggled', 'v1', '# One\n');
    expect((await importSkill({ source: dir })).status).toBe(200);

    const lockPath = resolve(server.contentDir, '.ok', 'skills-lock.json');
    expect(JSON.parse(readFileSync(lockPath, 'utf-8')).skills['auto-toggled'].autoUpdate).toBe(
      undefined,
    );

    const off = (await reimport({ name: 'auto-toggled', setAutoUpdate: false }).then((r) =>
      r.json(),
    )) as { updated: boolean };
    expect(off.updated).toBe(false);
    expect(JSON.parse(readFileSync(lockPath, 'utf-8')).skills['auto-toggled'].autoUpdate).toBe(
      false,
    );

    const list = (await fetch(`${base()}/api/skills?scope=project`).then((r) => r.json())) as {
      skills: { name: string; origin?: { autoUpdate?: boolean } }[];
    };
    expect(list.skills.find((sk) => sk.name === 'auto-toggled')?.origin?.autoUpdate).toBe(false);

    expect((await reimport({ name: 'auto-toggled', setAutoUpdate: true })).status).toBe(200);
    expect(JSON.parse(readFileSync(lockPath, 'utf-8')).skills['auto-toggled'].autoUpdate).toBe(
      true,
    );
  });

  test('reimport of a non-imported (authored) skill is rejected', async () => {
    expect((await reimport({ name: 'never-imported' })).status).toBeGreaterThanOrEqual(400);
  });
});

describe('GET /api/skills/preview', () => {
  let server: TestServer;
  beforeEach(async () => {
    server = await createTestServer();
  });
  afterEach(async () => {
    await server.cleanup();
  });

  const preview = (params: Record<string, string>) =>
    fetch(`http://127.0.0.1:${server.port}/api/skills/preview?${new URLSearchParams(params)}`);

  test('returns the un-imported skill SKILL.md text (verbatim, frontmatter included)', async () => {
    const dir = join(srcRoot, 'preview-single');
    writeSkillDir(dir, 'previewable', 'Preview me', '# Heading\n\nProse.\n');
    const res = await preview({ source: dir, name: 'previewable' });
    expect(res.status).toBe(200);
    const body = (await res.json()) as { name: string; skillMd: string };
    expect(body.name).toBe('previewable');
    expect(body.skillMd).toContain('name: previewable');
    expect(body.skillMd).toContain('# Heading');
  });

  test('normalizes provider-owned plugin metadata without leaking cache paths to the UI', async () => {
    const pluginsRoot = join(srcRoot, 'preview-plugin', 'plugins');
    const pluginRoot = join(pluginsRoot, 'cache', 'market', 'toolkit', '1.2.3');
    const skillDir = join(pluginRoot, 'skills', 'previewable-plugin');
    writeSkillDir(skillDir, 'previewable-plugin', 'Plugin preview');
    mkdirSync(join(pluginRoot, '.claude-plugin'), { recursive: true });
    writeFileSync(
      join(pluginRoot, '.claude-plugin', 'plugin.json'),
      JSON.stringify({ name: 'toolkit', version: '1.2.3' }),
    );
    writeFileSync(
      join(pluginsRoot, 'known_marketplaces.json'),
      JSON.stringify({ market: { source: { source: 'github', repo: 'acme/toolkit' } } }),
    );

    const res = await preview({ source: skillDir, name: 'previewable-plugin' });
    expect(res.status).toBe(200);
    const body = (await res.json()) as {
      plugin?: Record<string, string>;
      marketplaceUrl?: string;
    };
    expect(body.plugin).toEqual({
      provider: 'claude',
      plugin: 'toolkit',
      version: '1.2.3',
      marketplace: 'market',
      repositoryUrl: 'https://github.com/acme/toolkit',
    });
    expect(body.marketplaceUrl).toBeUndefined();
  });

  test('404s when the name does not match a source skill, exactly as import does', async () => {
    const repo = join(srcRoot, 'preview-multi');
    writeSkillDir(join(repo, 'alpha'), 'alpha', 'A');
    writeSkillDir(join(repo, 'beta'), 'beta', 'B');
    const res = await preview({ source: repo, name: 'does-not-exist' });
    expect(res.status).toBe(404);
  });

  test('matches on the frontmatter name when it differs from the folder', async () => {
    const repo = join(srcRoot, 'preview-fm-name');
    writeSkillDir(join(repo, 'react-native-skills'), 'vercel-react-native', 'A');
    writeSkillDir(join(repo, 'beta'), 'beta', 'B');
    const res = await preview({ source: repo, name: 'vercel-react-native' });
    expect(res.status).toBe(200);
    expect(((await res.json()) as { name: string }).name).toBe('vercel-react-native');
  });

  test('with no name, still renders the first skill so a source can be browsed', async () => {
    const repo = join(srcRoot, 'preview-browse');
    writeSkillDir(join(repo, 'alpha'), 'alpha', 'A');
    writeSkillDir(join(repo, 'beta'), 'beta', 'B');
    const res = await preview({ source: repo });
    expect(res.status).toBe(200);
    expect(['alpha', 'beta']).toContain(((await res.json()) as { name: string }).name);
  });

  test('rejects a source with no SKILL.md', async () => {
    const empty = join(srcRoot, 'preview-empty');
    mkdirSync(empty, { recursive: true });
    expect((await preview({ source: empty, name: 'x' })).status).toBe(404);
  });

  test('rejects a missing source', async () => {
    expect((await preview({ name: 'x' })).status).toBe(400);
  });
});

describe('GET /api/skills/discover', () => {
  let server: TestServer;
  beforeEach(async () => {
    server = await createTestServer();
  });
  afterEach(async () => {
    await server.cleanup();
  });

  const discover = (source: string) =>
    fetch(`http://127.0.0.1:${server.port}/api/skills/discover?${new URLSearchParams({ source })}`);

  test('lists every skill (frontmatter name + description) in a multi-skill source', async () => {
    const repo = join(srcRoot, 'discover-multi');
    writeSkillDir(join(repo, 'skills', 'a'), 'alpha', 'A skill');
    writeSkillDir(join(repo, 'skills', 'b'), 'beta', 'B skill');
    const res = await discover(repo);
    expect(res.status).toBe(200);
    const body = (await res.json()) as { skills: { name: string; description: string | null }[] };
    const byName = Object.fromEntries(body.skills.map((s) => [s.name, s.description]));
    expect(byName.alpha).toBe('A skill');
    expect(byName.beta).toBe('B skill');
  });

  test('returns the single skill for a one-skill source', async () => {
    const dir = join(srcRoot, 'discover-single');
    writeSkillDir(dir, 'solo', 'only one');
    const body = (await discover(dir).then((r) => r.json())) as { skills: { name: string }[] };
    expect(body.skills.map((s) => s.name)).toEqual(['solo']);
  });

  test('returns an empty list (200) for a source with no SKILL.md', async () => {
    const empty = join(srcRoot, 'discover-empty');
    mkdirSync(empty, { recursive: true });
    const res = await discover(empty);
    expect(res.status).toBe(200);
    expect(((await res.json()) as { skills: unknown[] }).skills).toEqual([]);
  });

  test('rejects a missing source', async () => {
    const res = await fetch(`http://127.0.0.1:${server.port}/api/skills/discover`);
    expect(res.status).toBe(400);
  });
});