@atlassian-dc-mcp/common 0.16.0 → 0.17.0

package/src/config/__tests__/sources/home-file.test.ts

@@ -0,0 +1,129 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { HomeFileSource, getHomeFilePath, HOME_DIR_NAME } from '../../sources/home-file.js';
+import type { ProductDefinition } from '../../source.js';
+
+const JIRA: ProductDefinition = {
+  id: 'jira',
+  envVars: {
+    host: 'JIRA_HOST',
+    apiBasePath: 'JIRA_API_BASE_PATH',
+    token: 'JIRA_API_TOKEN',
+    defaultPageSize: 'JIRA_DEFAULT_PAGE_SIZE',
+  },
+};
+
+const CONFLUENCE: ProductDefinition = {
+  id: 'confluence',
+  envVars: {
+    host: 'CONFLUENCE_HOST',
+    apiBasePath: 'CONFLUENCE_API_BASE_PATH',
+    token: 'CONFLUENCE_API_TOKEN',
+    defaultPageSize: 'CONFLUENCE_DEFAULT_PAGE_SIZE',
+  },
+};
+
+describe('HomeFileSource', () => {
+  let tempHome: string;
+  let homedirSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    tempHome = fs.mkdtempSync(path.join(os.tmpdir(), 'home-file-src-'));
+    homedirSpy = jest.spyOn(os, 'homedir').mockReturnValue(tempHome);
+  });
+
+  afterEach(() => {
+    homedirSpy.mockRestore();
+    fs.rmSync(tempHome, { recursive: true, force: true });
+  });
+
+  it('returns undefined when the home file does not exist', () => {
+    expect(new HomeFileSource().read(JIRA, 'host')).toBeUndefined();
+  });
+
+  it('writes values and reads them back', () => {
+    const source = new HomeFileSource();
+    source.write(JIRA, 'host', 'j-host');
+    source.write(JIRA, 'token', 'j-token');
+    expect(source.read(JIRA, 'host')).toBe('j-host');
+    expect(source.read(JIRA, 'token')).toBe('j-token');
+  });
+
+  it('writes files with mode 0600 on POSIX', () => {
+    if (process.platform === 'win32') {
+      return;
+    }
+    const source = new HomeFileSource();
+    source.write(JIRA, 'host', 'j-host');
+    const stat = fs.statSync(getHomeFilePath(JIRA));
+    expect(stat.mode & 0o777).toBe(0o600);
+  });
+
+  it('merge preserves unrelated keys', () => {
+    const filePath = getHomeFilePath(JIRA);
+    fs.mkdirSync(path.join(tempHome, HOME_DIR_NAME), { recursive: true });
+    fs.writeFileSync(filePath, 'JIRA_HOST=old\nUNRELATED_KEY=keep-me\n', { mode: 0o600 });
+    const source = new HomeFileSource();
+    source.write(JIRA, 'host', 'new');
+    const contents = fs.readFileSync(filePath, 'utf8');
+    expect(contents).toContain('JIRA_HOST=new');
+    expect(contents).toContain('UNRELATED_KEY=keep-me');
+  });
+
+  it('clear removes only the specified key', () => {
+    const source = new HomeFileSource();
+    source.write(JIRA, 'host', 'j-host');
+    source.write(JIRA, 'token', 'j-token');
+    source.clear(JIRA, 'token');
+    expect(source.read(JIRA, 'host')).toBe('j-host');
+    expect(source.read(JIRA, 'token')).toBeUndefined();
+  });
+
+  it('quotes values that contain whitespace', () => {
+    const source = new HomeFileSource();
+    source.write(JIRA, 'host', 'value with spaces');
+    const contents = fs.readFileSync(getHomeFilePath(JIRA), 'utf8');
+    expect(contents).toMatch(/JIRA_HOST="value with spaces"/);
+    expect(source.read(JIRA, 'host')).toBe('value with spaces');
+  });
+
+  it('stores each product in its own file', () => {
+    const source = new HomeFileSource();
+    source.write(JIRA, 'host', 'j-host');
+    source.write(CONFLUENCE, 'host', 'c-host');
+    expect(fs.existsSync(getHomeFilePath(JIRA))).toBe(true);
+    expect(fs.existsSync(getHomeFilePath(CONFLUENCE))).toBe(true);
+    expect(source.read(JIRA, 'host')).toBe('j-host');
+    expect(source.read(CONFLUENCE, 'host')).toBe('c-host');
+  });
+
+  it('evicts cache when the home file is deleted externally so writes do not merge stale values', () => {
+    const source = new HomeFileSource();
+    source.write(JIRA, 'host', 'stale-host');
+    expect(source.read(JIRA, 'host')).toBe('stale-host');
+
+    fs.unlinkSync(getHomeFilePath(JIRA));
+    expect(source.read(JIRA, 'host')).toBeUndefined();
+
+    source.write(JIRA, 'token', 'fresh-token');
+    const contents = fs.readFileSync(getHomeFilePath(JIRA), 'utf8');
+    expect(contents).not.toContain('stale-host');
+    expect(contents).toContain('JIRA_API_TOKEN=fresh-token');
+  });
+
+  it('removes the temp file if rename fails', () => {
+    const source = new HomeFileSource();
+    const renameSpy = jest.spyOn(fs, 'renameSync').mockImplementation(() => {
+      throw new Error('boom');
+    });
+    try {
+      expect(() => source.write(JIRA, 'host', 'x')).toThrow('boom');
+      const dir = path.join(tempHome, HOME_DIR_NAME);
+      const entries = fs.existsSync(dir) ? fs.readdirSync(dir) : [];
+      expect(entries.filter((e) => e.includes('.tmp-'))).toEqual([]);
+    } finally {
+      renameSpy.mockRestore();
+    }
+  });
+});

package/src/config/__tests__/sources/macos-keychain.test.ts

@@ -0,0 +1,136 @@
+import { MacosKeychainSource, SECURITY_BINARY, type KeychainDeps } from '../../sources/macos-keychain.js';
+import type { ProductDefinition } from '../../source.js';
+
+const JIRA: ProductDefinition = {
+  id: 'jira',
+  envVars: {
+    host: 'JIRA_HOST',
+    apiBasePath: 'JIRA_API_BASE_PATH',
+    token: 'JIRA_API_TOKEN',
+    defaultPageSize: 'JIRA_DEFAULT_PAGE_SIZE',
+  },
+};
+
+function makeDeps(overrides: Partial<KeychainDeps> = {}) {
+  return {
+    execFileSync: jest.fn(),
+    existsSync: jest.fn(() => true),
+    getPlatform: () => 'darwin' as NodeJS.Platform,
+    ...overrides,
+  };
+}
+
+describe('MacosKeychainSource', () => {
+  it('isAvailable is true on darwin when binary exists', () => {
+    expect(new MacosKeychainSource(makeDeps()).isAvailable()).toBe(true);
+  });
+
+  it('isAvailable is false off darwin', () => {
+    const deps = makeDeps({ getPlatform: () => 'linux' as NodeJS.Platform });
+    expect(new MacosKeychainSource(deps).isAvailable()).toBe(false);
+  });
+
+  it('isAvailable is false when binary is missing', () => {
+    const deps = makeDeps({ existsSync: jest.fn(() => false) });
+    expect(new MacosKeychainSource(deps).isAvailable()).toBe(false);
+  });
+
+  it('read returns token on success and strips trailing newline', () => {
+    const execFileSync = jest.fn().mockReturnValueOnce('secret-token\n');
+    const deps = makeDeps({ execFileSync: execFileSync as unknown as KeychainDeps['execFileSync'] });
+    const source = new MacosKeychainSource(deps);
+    expect(source.read(JIRA, 'token')).toBe('secret-token');
+    expect(execFileSync).toHaveBeenCalledWith(
+      SECURITY_BINARY,
+      ['find-generic-password', '-s', 'atlassian-dc-mcp', '-a', 'jira-token', '-w'],
+      expect.objectContaining({ encoding: 'utf8', timeout: 5000 }),
+    );
+  });
+
+  it('read returns undefined when security exits non-zero (not found)', () => {
+    const execFileSync = jest.fn().mockImplementationOnce(() => {
+      const err: NodeJS.ErrnoException & { status?: number } = new Error('not found');
+      err.status = 44;
+      throw err;
+    });
+    const source = new MacosKeychainSource(makeDeps({ execFileSync: execFileSync as any }));
+    expect(source.read(JIRA, 'token')).toBeUndefined();
+  });
+
+  it('read returns undefined when keychain is locked (non-44)', () => {
+    const execFileSync = jest.fn().mockImplementationOnce(() => {
+      const err: NodeJS.ErrnoException & { status?: number } = new Error('auth failed');
+      err.status = 128;
+      throw err;
+    });
+    const source = new MacosKeychainSource(makeDeps({ execFileSync: execFileSync as any }));
+    expect(source.read(JIRA, 'token')).toBeUndefined();
+  });
+
+  it('read returns undefined for non-token keys without invoking security', () => {
+    const execFileSync = jest.fn();
+    const source = new MacosKeychainSource(makeDeps({ execFileSync: execFileSync as any }));
+    expect(source.read(JIRA, 'host')).toBeUndefined();
+    expect(execFileSync).not.toHaveBeenCalled();
+  });
+
+  it('caches reads', () => {
+    const execFileSync = jest.fn().mockReturnValueOnce('cached\n');
+    const source = new MacosKeychainSource(makeDeps({ execFileSync: execFileSync as any }));
+    source.read(JIRA, 'token');
+    source.read(JIRA, 'token');
+    source.read(JIRA, 'token');
+    expect(execFileSync).toHaveBeenCalledTimes(1);
+  });
+
+  it('write uses -U flag', () => {
+    const execFileSync = jest.fn().mockReturnValueOnce('');
+    const source = new MacosKeychainSource(makeDeps({ execFileSync: execFileSync as any }));
+    source.write(JIRA, 'token', 'abc');
+    expect(execFileSync).toHaveBeenCalledWith(
+      SECURITY_BINARY,
+      ['add-generic-password', '-U', '-s', 'atlassian-dc-mcp', '-a', 'jira-token', '-w', 'abc'],
+      expect.objectContaining({ encoding: 'utf8' }),
+    );
+  });
+
+  it('write throws when the key is not token', () => {
+    const execFileSync = jest.fn();
+    const source = new MacosKeychainSource(makeDeps({ execFileSync: execFileSync as any }));
+    expect(() => source.write(JIRA, 'host', 'x')).toThrow(/only stores the token/);
+    expect(execFileSync).not.toHaveBeenCalled();
+  });
+
+  it('round-trips a token containing shell metacharacters', () => {
+    const tricky = 'a\'b"c$d`e';
+    const execFileSync = jest
+      .fn()
+      .mockImplementationOnce(() => '')
+      .mockImplementationOnce(() => `${tricky}\n`);
+    const source = new MacosKeychainSource(makeDeps({ execFileSync: execFileSync as any }));
+    source.write(JIRA, 'token', tricky);
+    expect(source.read(JIRA, 'token')).toBe(tricky);
+    const writeArgs = execFileSync.mock.calls[0][1] as string[];
+    expect(writeArgs[writeArgs.length - 1]).toBe(tricky);
+  });
+
+  it('clear invokes delete-generic-password and caches undefined', () => {
+    const execFileSync = jest.fn().mockImplementationOnce(() => '');
+    const source = new MacosKeychainSource(makeDeps({ execFileSync: execFileSync as any }));
+    source.clear(JIRA, 'token');
+    expect(execFileSync).toHaveBeenCalledWith(
+      SECURITY_BINARY,
+      ['delete-generic-password', '-s', 'atlassian-dc-mcp', '-a', 'jira-token'],
+      expect.any(Object),
+    );
+    expect(source.read(JIRA, 'token')).toBeUndefined();
+  });
+
+  it('clear swallows errors', () => {
+    const execFileSync = jest.fn().mockImplementationOnce(() => {
+      throw new Error('not found');
+    });
+    const source = new MacosKeychainSource(makeDeps({ execFileSync: execFileSync as any }));
+    expect(() => source.clear(JIRA, 'token')).not.toThrow();
+  });
+});

package/src/config/__tests__/sources/process-env.test.ts

@@ -0,0 +1,59 @@
+import { ProcessEnvSource } from '../../sources/process-env.js';
+import type { ProductDefinition } from '../../source.js';
+
+const JIRA: ProductDefinition = {
+  id: 'jira',
+  envVars: {
+    host: 'JIRA_HOST',
+    apiBasePath: 'JIRA_API_BASE_PATH',
+    token: 'JIRA_API_TOKEN',
+    defaultPageSize: 'JIRA_DEFAULT_PAGE_SIZE',
+  },
+};
+
+const CONFLUENCE: ProductDefinition = {
+  id: 'confluence',
+  envVars: {
+    host: 'CONFLUENCE_HOST',
+    apiBasePath: 'CONFLUENCE_API_BASE_PATH',
+    token: 'CONFLUENCE_API_TOKEN',
+    defaultPageSize: 'CONFLUENCE_DEFAULT_PAGE_SIZE',
+  },
+};
+
+describe('ProcessEnvSource', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+    delete process.env.JIRA_HOST;
+    delete process.env.JIRA_API_TOKEN;
+    delete process.env.CONFLUENCE_HOST;
+  });
+
+  afterAll(() => {
+    process.env = originalEnv;
+  });
+
+  it('maps product+key to the correct env var', () => {
+    process.env.JIRA_HOST = 'j-host';
+    process.env.JIRA_API_TOKEN = 'j-token';
+    process.env.CONFLUENCE_HOST = 'c-host';
+    const source = new ProcessEnvSource();
+    expect(source.read(JIRA, 'host')).toBe('j-host');
+    expect(source.read(JIRA, 'token')).toBe('j-token');
+    expect(source.read(CONFLUENCE, 'host')).toBe('c-host');
+  });
+
+  it('returns undefined for absent or whitespace-only values', () => {
+    const source = new ProcessEnvSource();
+    expect(source.read(JIRA, 'host')).toBeUndefined();
+    process.env.JIRA_HOST = '   ';
+    expect(source.read(JIRA, 'host')).toBeUndefined();
+  });
+
+  it('trims surrounding whitespace', () => {
+    process.env.JIRA_HOST = '  j-host  ';
+    expect(new ProcessEnvSource().read(JIRA, 'host')).toBe('j-host');
+  });
+});

package/src/config/index.ts

@@ -0,0 +1,7 @@
+export * from './source.js';
+export * from './registry.js';
+export * from './runtime-config.js';
+export { ProcessEnvSource } from './sources/process-env.js';
+export { EnvFileSource, ATLASSIAN_DC_MCP_CONFIG_FILE_ENV_VAR } from './sources/env-file.js';
+export { HomeFileSource, getHomeFilePath, HOME_DIR_NAME } from './sources/home-file.js';
+export { MacosKeychainSource, KEYCHAIN_SERVICE } from './sources/macos-keychain.js';

package/src/config/registry.ts

@@ -0,0 +1,79 @@
+import type {
+  ConfigKey,
+  ProductDefinition,
+  ReadableSource,
+  SourceLocation,
+  WritableSource,
+} from './source.js';
+import { isWritableSource } from './source.js';
+import { ProcessEnvSource } from './sources/process-env.js';
+import { EnvFileSource } from './sources/env-file.js';
+import { HomeFileSource } from './sources/home-file.js';
+import { MacosKeychainSource } from './sources/macos-keychain.js';
+
+export interface ResolvedValue {
+  value: string | undefined;
+  from?: SourceLocation;
+}
+
+export interface ConfigRegistry {
+  readonly sources: readonly ReadableSource[];
+  initialize(options?: { cwd?: string }): void;
+  resolve(product: ProductDefinition, key: ConfigKey): ResolvedValue;
+  locate(product: ProductDefinition, key: ConfigKey): SourceLocation[];
+  getWritableSource<T extends WritableSource>(predicate: (s: WritableSource) => s is T): T | undefined;
+}
+
+export class DefaultConfigRegistry implements ConfigRegistry {
+  readonly sources: readonly ReadableSource[];
+
+  constructor(sources: ReadableSource[]) {
+    this.sources = [...sources].sort((a, b) => b.priority - a.priority);
+  }
+
+  initialize(options?: { cwd?: string }): void {
+    for (const source of this.sources) {
+      source.initialize?.(options);
+    }
+  }
+
+  resolve(product: ProductDefinition, key: ConfigKey): ResolvedValue {
+    for (const source of this.sources) {
+      const value = source.read(product, key);
+      if (value !== undefined) {
+        return { value, from: { sourceId: source.id, detail: source.describe() } };
+      }
+    }
+    return { value: undefined };
+  }
+
+  locate(product: ProductDefinition, key: ConfigKey): SourceLocation[] {
+    const locations: SourceLocation[] = [];
+    for (const source of this.sources) {
+      if (source.read(product, key) !== undefined) {
+        locations.push({ sourceId: source.id, detail: source.describe() });
+      }
+    }
+    return locations;
+  }
+
+  getWritableSource<T extends WritableSource>(
+    predicate: (s: WritableSource) => s is T,
+  ): T | undefined {
+    for (const source of this.sources) {
+      if (isWritableSource(source) && predicate(source)) {
+        return source;
+      }
+    }
+    return undefined;
+  }
+}
+
+export function buildDefaultRegistry(): DefaultConfigRegistry {
+  return new DefaultConfigRegistry([
+    new ProcessEnvSource(),
+    new EnvFileSource(),
+    new HomeFileSource(),
+    new MacosKeychainSource(),
+  ]);
+}

package/src/config/runtime-config.ts

@@ -0,0 +1,60 @@
+import { buildDefaultRegistry, type ConfigRegistry } from './registry.js';
+import type { ConfigKey, ProductDefinition } from './source.js';
+
+const FALLBACK_PAGE_SIZE = 25;
+
+export type ProductRuntimeConfig = {
+  host?: string;
+  apiBasePath?: string;
+  token?: string;
+  defaultPageSize: number;
+};
+
+export { ATLASSIAN_DC_MCP_CONFIG_FILE_ENV_VAR } from './sources/env-file.js';
+
+let registry: ConfigRegistry = buildDefaultRegistry();
+
+export function initializeRuntimeConfig(options?: { cwd?: string }): void {
+  registry.initialize(options);
+}
+
+function resolveString(product: ProductDefinition, key: ConfigKey): string | undefined {
+  return registry.resolve(product, key).value;
+}
+
+function parsePositiveInteger(value: string | undefined): number | undefined {
+  if (!value) {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  if (!/^\d+$/.test(trimmed)) {
+    return undefined;
+  }
+  const parsed = Number.parseInt(trimmed, 10);
+  return parsed > 0 ? parsed : undefined;
+}
+
+export function getProductRuntimeConfig(product: ProductDefinition): ProductRuntimeConfig {
+  return {
+    host: resolveString(product, 'host'),
+    apiBasePath: resolveString(product, 'apiBasePath'),
+    token: resolveString(product, 'token'),
+    defaultPageSize:
+      parsePositiveInteger(resolveString(product, 'defaultPageSize')) ?? FALLBACK_PAGE_SIZE,
+  };
+}
+
+export function validateProductRuntimeConfig(product: ProductDefinition): string[] {
+  const config = getProductRuntimeConfig(product);
+  const missing: string[] = [];
+
+  if (!config.token) {
+    missing.push(product.envVars.token);
+  }
+
+  if (!config.host && !config.apiBasePath) {
+    missing.push(`${product.envVars.host} or ${product.envVars.apiBasePath}`);
+  }
+
+  return missing;
+}

package/src/config/source.ts

@@ -0,0 +1,37 @@
+export type ConfigKey = 'host' | 'apiBasePath' | 'token' | 'defaultPageSize';
+
+export type SourceId = 'process-env' | 'env-file' | 'home-file' | 'macos-keychain';
+
+export type SourceLocation = { sourceId: SourceId; detail?: string };
+
+export interface ProductDefinition {
+  readonly id: string;
+  readonly envVars: Record<ConfigKey, string>;
+  readonly defaultApiBasePath?: string;
+}
+
+export interface ReadableSource {
+  readonly id: SourceId;
+  readonly priority: number;
+  read(product: ProductDefinition, key: ConfigKey): string | undefined;
+  initialize?(options?: { cwd?: string }): void;
+  describe(): string;
+}
+
+export interface WritableSource extends ReadableSource {
+  isAvailable(): boolean;
+  write(product: ProductDefinition, key: ConfigKey, value: string): void;
+  clear(product: ProductDefinition, key: ConfigKey): void;
+}
+
+export function isWritableSource(source: ReadableSource): source is WritableSource {
+  return typeof (source as WritableSource).write === 'function';
+}
+
+export function getNonEmptyValue(value: string | undefined): string | undefined {
+  if (!value) {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}

package/src/config/sources/dotenv-file-cache.ts

@@ -0,0 +1,54 @@
+import fs from 'node:fs';
+import dotenv from 'dotenv';
+
+export type ParsedEnvironment = Record<string, string>;
+
+type CacheEntry = {
+  filePath: string;
+  mtimeMs: number;
+  values: ParsedEnvironment;
+};
+
+export class DotenvFileNotFoundError extends Error {
+  readonly filePath: string;
+  constructor(filePath: string) {
+    super(`Dotenv file not found: ${filePath}`);
+    this.name = 'DotenvFileNotFoundError';
+    this.filePath = filePath;
+  }
+}
+
+export class DotenvFileCache {
+  private entry?: CacheEntry;
+
+  get filePath(): string | undefined {
+    return this.entry?.filePath;
+  }
+
+  load(filePath: string): ParsedEnvironment {
+    let stats: fs.Stats;
+    try {
+      stats = fs.statSync(filePath);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+        if (this.entry?.filePath === filePath) {
+          this.entry = undefined;
+        }
+        throw new DotenvFileNotFoundError(filePath);
+      }
+      throw error;
+    }
+
+    if (this.entry && this.entry.filePath === filePath && this.entry.mtimeMs === stats.mtimeMs) {
+      return this.entry.values;
+    }
+
+    const values = dotenv.parse(fs.readFileSync(filePath));
+    this.entry = { filePath, mtimeMs: stats.mtimeMs, values };
+    return values;
+  }
+
+  invalidate(): void {
+    this.entry = undefined;
+  }
+}

package/src/config/sources/env-file.ts

@@ -0,0 +1,61 @@
+import path from 'node:path';
+import type { ConfigKey, ProductDefinition, ReadableSource, SourceId } from '../source.js';
+import { getNonEmptyValue } from '../source.js';
+import {
+  DotenvFileCache,
+  DotenvFileNotFoundError,
+  type ParsedEnvironment,
+} from './dotenv-file-cache.js';
+
+export const ATLASSIAN_DC_MCP_CONFIG_FILE_ENV_VAR = 'ATLASSIAN_DC_MCP_CONFIG_FILE';
+
+export class EnvFileSource implements ReadableSource {
+  readonly id: SourceId = 'env-file';
+  readonly priority = 80;
+
+  private cwd: string = process.cwd();
+  private cache = new DotenvFileCache();
+
+  initialize(options?: { cwd?: string }): void {
+    this.cwd = options?.cwd ?? process.cwd();
+    this.loadFile();
+  }
+
+  read(product: ProductDefinition, key: ConfigKey): string | undefined {
+    const values = this.loadFile();
+    return getNonEmptyValue(values[product.envVars[key]]);
+  }
+
+  describe(): string {
+    return this.cache.filePath ? `env-file (${this.cache.filePath})` : 'env-file';
+  }
+
+  private getExplicitFilePath(): string | undefined {
+    const filePath = getNonEmptyValue(process.env[ATLASSIAN_DC_MCP_CONFIG_FILE_ENV_VAR]);
+    if (!filePath) {
+      return undefined;
+    }
+    if (!path.isAbsolute(filePath)) {
+      throw new Error(`${ATLASSIAN_DC_MCP_CONFIG_FILE_ENV_VAR} must be an absolute path: ${filePath}`);
+    }
+    return filePath;
+  }
+
+  private loadFile(): ParsedEnvironment {
+    const explicitFilePath = this.getExplicitFilePath();
+    const filePath = explicitFilePath ?? path.join(this.cwd, '.env');
+    try {
+      return this.cache.load(filePath);
+    } catch (error) {
+      if (error instanceof DotenvFileNotFoundError) {
+        if (explicitFilePath) {
+          throw new Error(
+            `${ATLASSIAN_DC_MCP_CONFIG_FILE_ENV_VAR} points to a missing file: ${error.filePath}`,
+          );
+        }
+        return {};
+      }
+      throw error;
+    }
+  }
+}