hamster-wheel-cli 0.1.0

package/src/webhook.ts

@@ -0,0 +1,107 @@
+import { Logger } from './logger';
+import { isoNow } from './utils';
+import type { WebhookConfig } from './types';
+
+export type WebhookEvent = 'task_start' | 'iteration_start' | 'task_end';
+
+export interface WebhookPayload {
+  readonly event: WebhookEvent;
+  readonly task: string;
+  readonly branch: string;
+  readonly iteration: number;
+  readonly stage: string;
+  readonly timestamp: string;
+}
+
+export interface WebhookPayloadInput {
+  readonly event: WebhookEvent;
+  readonly task: string;
+  readonly branch?: string;
+  readonly iteration: number;
+  readonly stage: string;
+  readonly timestamp?: string;
+}
+
+export type FetchLikeResponse = {
+  readonly ok: boolean;
+  readonly status: number;
+  readonly statusText: string;
+};
+
+export type FetchLike = (url: string, init: {
+  readonly method: string;
+  readonly headers: Record<string, string>;
+  readonly body: string;
+  readonly signal?: AbortSignal;
+}) => Promise<FetchLikeResponse>;
+
+const DEFAULT_TIMEOUT_MS = 8000;
+
+export function normalizeWebhookUrls(urls?: string[]): string[] {
+  if (!urls || urls.length === 0) return [];
+  return urls
+    .map(url => url.trim())
+    .filter(url => url.length > 0);
+}
+
+export function buildWebhookPayload(input: WebhookPayloadInput): WebhookPayload {
+  return {
+    event: input.event,
+    task: input.task,
+    branch: input.branch ?? '',
+    iteration: input.iteration,
+    stage: input.stage,
+    timestamp: input.timestamp ?? isoNow()
+  };
+}
+
+function resolveFetcher(fetcher?: FetchLike): FetchLike | null {
+  if (fetcher) return fetcher;
+  const globalFetcher = globalThis.fetch;
+  if (typeof globalFetcher !== 'function') return null;
+  return (globalFetcher as typeof fetch) as FetchLike;
+}
+
+async function postWebhook(url: string, payload: WebhookPayload, timeoutMs: number, logger: Logger, fetcher: FetchLike): Promise<void> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetcher(url, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json'
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      logger.warn(`webhook 请求失败（${response.status} ${response.statusText}）：${url}`);
+    } else {
+      logger.debug(`webhook 通知成功：${url}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.warn(`webhook 通知异常：${url}｜${message}`);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function sendWebhookNotifications(
+  config: WebhookConfig | null | undefined,
+  payload: WebhookPayload,
+  logger: Logger,
+  fetcher?: FetchLike
+): Promise<void> {
+  const urls = normalizeWebhookUrls(config?.urls);
+  if (urls.length === 0) return;
+
+  const resolvedFetcher = resolveFetcher(fetcher);
+  if (!resolvedFetcher) {
+    logger.warn('当前 Node 环境不支持 fetch，已跳过 webhook 通知');
+    return;
+  }
+
+  const timeoutMs = config?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  await Promise.all(urls.map(url => postWebhook(url, payload, timeoutMs, logger, resolvedFetcher)));
+}

package/tests/deps.test.ts

@@ -0,0 +1,72 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { buildInstallCommand, resolvePackageManager } from '../src/deps';
+
+const baseHints = {
+  hasYarnLock: false,
+  hasPnpmLock: false,
+  hasNpmLock: false,
+  hasNpmShrinkwrap: false
+};
+
+test('resolvePackageManager 优先 packageManager 字段', () => {
+  const resolution = resolvePackageManager({
+    ...baseHints,
+    packageManagerField: 'pnpm@8.0.0',
+    hasYarnLock: true,
+    hasNpmLock: true
+  });
+
+  assert.equal(resolution.manager, 'pnpm');
+  assert.equal(resolution.source, 'packageManager');
+  assert.equal(resolution.hasLock, false);
+});
+
+test('resolvePackageManager 会根据锁文件选择 yarn', () => {
+  const resolution = resolvePackageManager({
+    ...baseHints,
+    hasYarnLock: true
+  });
+
+  assert.equal(resolution.manager, 'yarn');
+  assert.equal(resolution.source, 'lockfile');
+  assert.equal(resolution.hasLock, true);
+});
+
+test('resolvePackageManager 无提示时默认使用 yarn', () => {
+  const resolution = resolvePackageManager({
+    ...baseHints
+  });
+
+  assert.equal(resolution.manager, 'yarn');
+  assert.equal(resolution.source, 'default');
+  assert.equal(resolution.hasLock, false);
+});
+
+test('buildInstallCommand 会根据包管理器生成命令', () => {
+  const yarnCommand = buildInstallCommand({
+    manager: 'yarn',
+    source: 'lockfile',
+    hasLock: true
+  });
+  const yarnNoLockCommand = buildInstallCommand({
+    manager: 'yarn',
+    source: 'default',
+    hasLock: false
+  });
+  const npmCommand = buildInstallCommand({
+    manager: 'npm',
+    source: 'lockfile',
+    hasLock: true
+  });
+  const pnpmCommand = buildInstallCommand({
+    manager: 'pnpm',
+    source: 'default',
+    hasLock: false
+  });
+
+  assert.equal(yarnCommand, 'yarn install --frozen-lockfile');
+  assert.equal(yarnNoLockCommand, 'yarn install --no-lockfile');
+  assert.equal(npmCommand, 'npm ci --no-audit --no-fund');
+  assert.equal(pnpmCommand, 'pnpm install');
+});

package/tests/e2e/cli.e2e.test.ts

@@ -0,0 +1,77 @@
+import assert from 'node:assert/strict';
+import { execFile } from 'node:child_process';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { test } from 'node:test';
+
+test('CLI 帮助信息可正常输出', async () => {
+  const execFileAsync = promisify(execFile);
+  const cliPath = path.join(process.cwd(), 'src', 'cli.ts');
+  const { stdout } = await execFileAsync('node', ['--require', 'ts-node/register', cliPath, 'run', '--help'], {
+    env: {
+      ...process.env,
+      FORCE_COLOR: '0'
+    }
+  });
+
+  assert.ok(stdout.includes('Usage: wheel-ai run'));
+  assert.ok(!stdout.includes('--ai-env-file'));
+  assert.ok(!stdout.includes('--ai-env'));
+  assert.ok(stdout.includes('--log-file'));
+  assert.ok(stdout.includes('--background'));
+  assert.ok(stdout.includes('--skip-install'));
+  assert.ok(stdout.includes('--webhook'));
+  assert.ok(stdout.includes('--webhook-timeout'));
+});
+
+test('CLI monitor 帮助信息可正常输出', async () => {
+  const execFileAsync = promisify(execFile);
+  const cliPath = path.join(process.cwd(), 'src', 'cli.ts');
+  const { stdout } = await execFileAsync('node', ['--require', 'ts-node/register', cliPath, 'monitor', '--help'], {
+    env: {
+      ...process.env,
+      FORCE_COLOR: '0'
+    }
+  });
+
+  assert.ok(stdout.includes('Usage: wheel-ai monitor'));
+});
+
+test('CLI monitor 在非 TTY 下输出提示', async () => {
+  const execFileAsync = promisify(execFile);
+  const cliPath = path.join(process.cwd(), 'src', 'cli.ts');
+  const { stdout } = await execFileAsync('node', ['--require', 'ts-node/register', cliPath, 'monitor'], {
+    env: {
+      ...process.env,
+      FORCE_COLOR: '0'
+    }
+  });
+
+  assert.ok(stdout.includes('当前终端不支持交互式 monitor。'));
+});
+
+test('CLI logs 帮助信息可正常输出', async () => {
+  const execFileAsync = promisify(execFile);
+  const cliPath = path.join(process.cwd(), 'src', 'cli.ts');
+  const { stdout } = await execFileAsync('node', ['--require', 'ts-node/register', cliPath, 'logs', '--help'], {
+    env: {
+      ...process.env,
+      FORCE_COLOR: '0'
+    }
+  });
+
+  assert.ok(stdout.includes('Usage: wheel-ai logs'));
+});
+
+test('CLI logs 在非 TTY 下输出提示', async () => {
+  const execFileAsync = promisify(execFile);
+  const cliPath = path.join(process.cwd(), 'src', 'cli.ts');
+  const { stdout } = await execFileAsync('node', ['--require', 'ts-node/register', cliPath, 'logs'], {
+    env: {
+      ...process.env,
+      FORCE_COLOR: '0'
+    }
+  });
+
+  assert.ok(stdout.includes('当前终端不支持交互式 logs。'));
+});

package/tests/e2e/gh-pr-create.e2e.test.ts

@@ -0,0 +1,55 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { test } from 'node:test';
+import { createPr } from '../../src/gh';
+import { Logger } from '../../src/logger';
+import type { PrConfig } from '../../src/types';
+
+test('createPr 遇到已存在 PR 提示时视为成功', async () => {
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'wheel-ai-gh-'));
+  const ghPath = path.join(tempDir, 'gh');
+  const prInfo = {
+    number: 12,
+    title: 'feat: demo',
+    url: 'https://example.com/pr/12',
+    state: 'OPEN',
+    headRefName: 'feat/demo'
+  };
+  const script = `#!/usr/bin/env node
+const args = process.argv.slice(2);
+const isCreate = args[0] === 'pr' && args[1] === 'create';
+const isView = args[0] === 'pr' && args[1] === 'view';
+if (isCreate) {
+  const message = 'a pull request for branch "feat/demo" into branch "main" already exists';
+  process.stderr.write(message);
+  process.exit(1);
+}
+if (isView) {
+  process.stdout.write('${JSON.stringify(prInfo)}');
+  process.exit(0);
+}
+process.stderr.write('unknown command');
+process.exit(1);
+`;
+
+  await fs.writeFile(ghPath, script, 'utf8');
+  await fs.chmod(ghPath, 0o755);
+
+  const previousPath = process.env.PATH ?? '';
+  process.env.PATH = `${tempDir}${path.delimiter}${previousPath}`;
+
+  try {
+    const logger = new Logger({ verbose: false });
+    const config: PrConfig = { enable: true };
+    const result = await createPr('feat/demo', config, process.cwd(), logger);
+
+    assert.ok(result);
+    assert.equal(result?.url, prInfo.url);
+    assert.equal(result?.number, prInfo.number);
+  } finally {
+    process.env.PATH = previousPath;
+    await fs.rm(tempDir, { recursive: true, force: true });
+  }
+});

package/tests/e2e/gh-run-list.e2e.test.ts

@@ -0,0 +1,47 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { test } from 'node:test';
+import { listFailedRuns } from '../../src/gh';
+import { Logger } from '../../src/logger';
+
+test('listFailedRuns 可识别失败的 Actions 运行', async () => {
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'wheel-ai-gh-'));
+  const ghPath = path.join(tempDir, 'gh');
+  const output = [
+    {
+      databaseId: 201,
+      name: 'CI',
+      status: 'completed',
+      conclusion: 'failure',
+      url: 'https://example.com/ci'
+    },
+    {
+      databaseId: 202,
+      name: 'Lint',
+      status: 'completed',
+      conclusion: 'success',
+      url: 'https://example.com/lint'
+    }
+  ];
+  const script = `#!/usr/bin/env node\nprocess.stdout.write('${JSON.stringify(output)}');\n`;
+
+  await fs.writeFile(ghPath, script, 'utf8');
+  await fs.chmod(ghPath, 0o755);
+
+  const previousPath = process.env.PATH ?? '';
+  process.env.PATH = `${tempDir}${path.delimiter}${previousPath}`;
+
+  try {
+    const logger = new Logger({ verbose: false });
+    const runs = await listFailedRuns('demo-branch', process.cwd(), logger);
+
+    assert.equal(runs.length, 1);
+    assert.equal(runs[0].name, 'CI');
+    assert.equal(runs[0].conclusion, 'failure');
+  } finally {
+    process.env.PATH = previousPath;
+    await fs.rm(tempDir, { recursive: true, force: true });
+  }
+});

package/tests/gh-pr-create.test.ts

@@ -0,0 +1,55 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { buildPrCreateArgs, isPrAlreadyExistsMessage, resolvePrTitle } from '../src/gh';
+import type { PrConfig } from '../src/types';
+
+test('resolvePrTitle 在未提供标题时生成默认标题', () => {
+  const title = resolvePrTitle('feat/demo', '   ');
+
+  assert.equal(title, 'chore: 自动 PR (feat/demo)');
+});
+
+test('buildPrCreateArgs 始终包含 --title 与 --body 参数', () => {
+  const config: PrConfig = {
+    enable: true,
+    draft: false,
+    reviewers: []
+  };
+  const args = buildPrCreateArgs('feat/demo', config);
+
+  const titleIndex = args.indexOf('--title');
+  const bodyIndex = args.indexOf('--body');
+
+  assert.ok(titleIndex >= 0, '应包含 --title');
+  assert.ok(bodyIndex >= 0, '应包含 --body');
+  assert.equal(args[titleIndex + 1], 'chore: 自动 PR (feat/demo)');
+});
+
+test('buildPrCreateArgs 支持使用 body 文件', () => {
+  const config: PrConfig = {
+    enable: true,
+    title: 'chore: ready',
+    bodyPath: 'memory/pr-body.md',
+    draft: true,
+    reviewers: ['alice', 'bob']
+  };
+  const args = buildPrCreateArgs('feat/demo', config);
+
+  assert.ok(args.includes('--body-file'));
+  assert.ok(args.includes('memory/pr-body.md'));
+  assert.ok(args.includes('--draft'));
+  assert.ok(args.includes('--reviewer'));
+  assert.ok(args.includes('alice,bob'));
+});
+
+test('isPrAlreadyExistsMessage 可识别已有 PR 提示', () => {
+  assert.equal(
+    isPrAlreadyExistsMessage('a pull request for branch "feat/demo" into branch "main" already exists'),
+    true
+  );
+  assert.equal(isPrAlreadyExistsMessage('A PR already exists for branch feat/demo on branch main'), true);
+  assert.equal(isPrAlreadyExistsMessage('针对分支 feat/demo 到分支 main 的拉取请求已存在'), true);
+  assert.equal(isPrAlreadyExistsMessage('分支 feat/demo 已存在 PR，无法重复创建'), true);
+  assert.equal(isPrAlreadyExistsMessage('The draft already exists for PR #123'), false);
+  assert.equal(isPrAlreadyExistsMessage('some other error'), false);
+});

package/tests/gh-run-list.test.ts

@@ -0,0 +1,35 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { parseGhRunList } from '../src/gh';
+
+test('parseGhRunList 可解析 databaseId 与 null conclusion', () => {
+  const output = JSON.stringify([
+    {
+      databaseId: 101,
+      name: 'CI',
+      status: 'completed',
+      conclusion: null,
+      url: 'https://example.com/ci'
+    },
+    {
+      databaseId: 102,
+      name: 'Lint',
+      status: 'completed',
+      conclusion: 'failure',
+      url: 'https://example.com/lint'
+    }
+  ]);
+
+  const runs = parseGhRunList(output);
+
+  assert.equal(runs.length, 2);
+  assert.equal(runs[0].databaseId, 101);
+  assert.equal(runs[0].conclusion, null);
+  assert.equal(runs[1].conclusion, 'failure');
+});
+
+test('parseGhRunList 遇到非法 JSON 返回空数组', () => {
+  const runs = parseGhRunList('not-json');
+
+  assert.deepEqual(runs, []);
+});

package/tests/global-config.test.ts

@@ -0,0 +1,52 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { applyShortcutArgv, parseGlobalConfig, splitCommandArgs } from '../src/global-config';
+
+test('parseGlobalConfig 读取 shortcut 配置', () => {
+  const content = `
+# comment
+[shortcut]
+name = "daily"
+command = "--task \\\"修复 #123\\\" --run-tests" # inline comment
+`;
+  const config = parseGlobalConfig(content);
+  assert.deepEqual(config, {
+    shortcut: {
+      name: 'daily',
+      command: '--task "修复 #123" --run-tests'
+    }
+  });
+});
+
+test('parseGlobalConfig 缺失字段时返回空配置', () => {
+  const content = `
+[shortcut]
+name = "daily run"
+`;
+  const config = parseGlobalConfig(content);
+  assert.deepEqual(config, {});
+});
+
+test('splitCommandArgs 支持引号与转义', () => {
+  const args = splitCommandArgs('--task "fix bug" --ai-args "--model" "claude-3-opus"');
+  assert.deepEqual(args, ['--task', 'fix bug', '--ai-args', '--model', 'claude-3-opus']);
+});
+
+test('applyShortcutArgv 展开快捷指令并追加参数', () => {
+  const config = parseGlobalConfig(`
+[shortcut]
+name = "daily"
+command = "run --task \\\"demo\\\" --run-tests"
+`);
+  const argv = ['node', '/path/cli.js', 'daily', '--run-e2e'];
+  const result = applyShortcutArgv(argv, config);
+  assert.deepEqual(result, [
+    'node',
+    '/path/cli.js',
+    'run',
+    '--task',
+    'demo',
+    '--run-tests',
+    '--run-e2e'
+  ]);
+});

package/tests/logger-file.test.ts

@@ -0,0 +1,56 @@
+import assert from 'node:assert/strict';
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { afterEach, test } from 'node:test';
+import { Logger } from '../src/logger';
+
+const timestampPattern = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} /;
+const tempRoot = path.join(process.cwd(), 'tests', '.tmp');
+
+let tempFile: string | null = null;
+
+const prepareTempFile = async (): Promise<string> => {
+  await fs.mkdir(tempRoot, { recursive: true });
+  const filePath = path.join(tempRoot, `logger-${randomUUID()}.log`);
+  tempFile = filePath;
+  return filePath;
+};
+
+const readLines = async (filePath: string): Promise<string[]> => {
+  const content = await fs.readFile(filePath, 'utf8');
+  return content.split(/\r?\n/).filter(line => line.length > 0);
+};
+
+afterEach(async () => {
+  if (!tempFile) return;
+  await fs.rm(tempFile, { force: true });
+  tempFile = null;
+});
+
+test('Logger 写入日志文件（非 verbose 不写 debug）', async () => {
+  const filePath = await prepareTempFile();
+  const logger = new Logger({ verbose: false, logFile: filePath });
+
+  logger.info('hello');
+  logger.debug('detail');
+  logger.warn('warning');
+
+  const lines = await readLines(filePath);
+  assert.equal(lines.length, 2);
+  assert.match(lines[0], new RegExp(`${timestampPattern.source}info\\s+hello$`));
+  assert.match(lines[1], new RegExp(`${timestampPattern.source}warn\\s+warning$`));
+});
+
+test('Logger verbose 时写入 debug', async () => {
+  const filePath = await prepareTempFile();
+  const logger = new Logger({ verbose: true, logFile: filePath });
+
+  logger.success('ok');
+  logger.debug('detail');
+
+  const lines = await readLines(filePath);
+  assert.equal(lines.length, 2);
+  assert.match(lines[0], new RegExp(`${timestampPattern.source}ok\\s+ok$`));
+  assert.match(lines[1], new RegExp(`${timestampPattern.source}dbg\\s+detail$`));
+});

package/tests/logger.test.ts

@@ -0,0 +1,72 @@
+import assert from 'node:assert/strict';
+import { afterEach, beforeEach, test } from 'node:test';
+import { Logger } from '../src/logger';
+
+type ConsoleMethodName = 'log' | 'warn' | 'error';
+
+const ansiPattern = /\u001b\[[0-9;]*m/g;
+const timestampPattern = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} /;
+
+const originalConsole: Record<ConsoleMethodName, Console['log']> = {
+  log: console.log,
+  warn: console.warn,
+  error: console.error
+};
+
+const outputs: Record<ConsoleMethodName, string[]> = {
+  log: [],
+  warn: [],
+  error: []
+};
+
+const stripAnsi = (value: string): string => value.replace(ansiPattern, '');
+
+const escapeRegExp = (value: string): string => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+const capture = (method: ConsoleMethodName, sink: string[]): void => {
+  const writer = (...data: unknown[]): void => {
+    sink.push(data.map(item => String(item)).join(' '));
+  };
+  console[method] = writer as Console['log'];
+};
+
+const expectLine = (raw: string, label: string, message: string): void => {
+  const value = stripAnsi(raw);
+  const pattern = new RegExp(`^${timestampPattern.source}${label}\\s+${escapeRegExp(message)}$`);
+  assert.match(value, pattern);
+};
+
+beforeEach(() => {
+  outputs.log = [];
+  outputs.warn = [];
+  outputs.error = [];
+  capture('log', outputs.log);
+  capture('warn', outputs.warn);
+  capture('error', outputs.error);
+});
+
+afterEach(() => {
+  console.log = originalConsole.log;
+  console.warn = originalConsole.warn;
+  console.error = originalConsole.error;
+});
+
+test('Logger 输出包含时间戳前缀', () => {
+  const logger = new Logger({ verbose: true });
+
+  logger.info('hello');
+  logger.success('ok');
+  logger.warn('warning');
+  logger.error('boom');
+  logger.debug('detail');
+
+  assert.equal(outputs.log.length, 3);
+  assert.equal(outputs.warn.length, 1);
+  assert.equal(outputs.error.length, 1);
+
+  expectLine(outputs.log[0], 'info', 'hello');
+  expectLine(outputs.log[1], 'ok', 'ok');
+  expectLine(outputs.log[2], 'dbg', 'detail');
+  expectLine(outputs.warn[0], 'warn', 'warning');
+  expectLine(outputs.error[0], 'err', 'boom');
+});

package/tests/logs-viewer.test.ts

@@ -0,0 +1,57 @@
+import assert from 'node:assert/strict';
+import os from 'node:os';
+import path from 'node:path';
+import { test } from 'node:test';
+import fs from 'fs-extra';
+import { CurrentRegistry } from '../src/logs';
+import { buildRunningLogKeys, loadLogEntries } from '../src/logs-viewer';
+
+test('buildRunningLogKeys 会合并 registry key 与 logFile 名称', () => {
+  const registry: CurrentRegistry = {
+    'alpha.log': {
+      command: 'cmd',
+      round: 1,
+      tokenUsed: 2,
+      path: '/tmp',
+      logFile: '/var/log/alpha.log'
+    },
+    'beta.log': {
+      command: 'cmd',
+      round: 1,
+      tokenUsed: 2,
+      path: '/tmp'
+    }
+  };
+
+  const keys = buildRunningLogKeys(registry);
+  assert.ok(keys.has('alpha.log'));
+  assert.ok(keys.has('beta.log'));
+});
+
+test('loadLogEntries 会排除运行中的日志与非 .log 文件', async () => {
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'wheel-ai-logs-'));
+  try {
+    const logA = path.join(tempDir, 'alpha.log');
+    const logB = path.join(tempDir, 'beta.log');
+    const txt = path.join(tempDir, 'note.txt');
+    await fs.writeFile(logA, 'alpha', 'utf8');
+    await fs.writeFile(logB, 'beta', 'utf8');
+    await fs.writeFile(txt, 'note', 'utf8');
+
+    const registry: CurrentRegistry = {
+      'beta.log': {
+        command: 'cmd',
+        round: 1,
+        tokenUsed: 2,
+        path: '/tmp',
+        logFile: logB
+      }
+    };
+
+    const entries = await loadLogEntries(tempDir, registry);
+    const names = entries.map(entry => entry.fileName);
+    assert.deepEqual(names, ['alpha.log']);
+  } finally {
+    await fs.remove(tempDir);
+  }
+});