elsabro 5.2.0 → 6.0.1

package/flow-engine/tests/graph.test.js

@@ -0,0 +1,161 @@
+'use strict';
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+const { buildGraph, validateGraph, getNode, getNextNodes, GraphError } = require('../src/graph');
+
+// Minimal valid flow for testing
+const minimalFlow = {
+  id: 'test_flow',
+  version: '1.0.0',
+  config: {},
+  nodes: [
+    { id: 'start', type: 'entry', next: 'end' },
+    { id: 'end', type: 'exit', status: 'success', outputs: {} }
+  ]
+};
+
+describe('buildGraph', () => {
+  it('builds a graph from a valid flow definition', () => {
+    const graph = buildGraph(minimalFlow);
+    assert.equal(graph.nodes.size, 2);
+    assert.equal(graph.entryNode, 'start');
+    assert.equal(graph.meta.version, '1.0.0');
+  });
+
+  it('throws on missing nodes array', () => {
+    assert.throws(() => buildGraph({}), GraphError);
+    assert.throws(() => buildGraph({ nodes: 'not-array' }), GraphError);
+  });
+
+  it('throws on duplicate node IDs', () => {
+    assert.throws(() => buildGraph({
+      nodes: [
+        { id: 'start', type: 'entry', next: 'start' },
+        { id: 'start', type: 'exit' }
+      ]
+    }), /Duplicate node id/);
+  });
+
+  it('throws on missing entry node', () => {
+    assert.throws(() => buildGraph({
+      nodes: [{ id: 'a', type: 'sequence', next: 'a' }]
+    }), /No entry node/);
+  });
+
+  it('throws on multiple entry nodes', () => {
+    assert.throws(() => buildGraph({
+      nodes: [
+        { id: 'a', type: 'entry', next: 'b' },
+        { id: 'b', type: 'entry', next: 'a' }
+      ]
+    }), /Multiple entry nodes/);
+  });
+
+  it('preserves sync_metadata from flow definition', () => {
+    const flow = {
+      ...minimalFlow,
+      sync_metadata: { last_audit: '2026-02-07', audit_result: { total_nodes: 2 } }
+    };
+    const graph = buildGraph(flow);
+    assert.equal(graph.meta.sync_metadata.last_audit, '2026-02-07');
+  });
+});
+
+describe('validateGraph', () => {
+  it('validates a correct graph', () => {
+    const graph = buildGraph(minimalFlow);
+    const result = validateGraph(graph);
+    assert.equal(result.valid, true);
+    assert.equal(result.errors.length, 0);
+  });
+
+  it('detects dangling references', () => {
+    const graph = buildGraph({
+      nodes: [
+        { id: 'start', type: 'entry', next: 'missing_node' }
+      ]
+    });
+    // Override entryNode since we forced it
+    const result = validateGraph(graph);
+    assert.equal(result.valid, false);
+    assert.ok(result.errors[0].includes('missing_node'));
+  });
+
+  it('validates router routes', () => {
+    const graph = buildGraph({
+      nodes: [
+        { id: 'start', type: 'entry', next: 'router' },
+        { id: 'router', type: 'router', routes: { a: 'end', b: 'orphan' }, default: 'end' },
+        { id: 'end', type: 'exit', status: 'success', outputs: {} }
+      ]
+    });
+    const result = validateGraph(graph);
+    assert.equal(result.valid, false);
+    assert.ok(result.errors.some(e => e.includes('orphan')));
+  });
+
+  it('validates condition true/false branches', () => {
+    const graph = buildGraph({
+      nodes: [
+        { id: 'start', type: 'entry', next: 'cond' },
+        { id: 'cond', type: 'condition', true: 'end', false: 'ghost' },
+        { id: 'end', type: 'exit', status: 'success', outputs: {} }
+      ]
+    });
+    const result = validateGraph(graph);
+    assert.equal(result.valid, false);
+    assert.ok(result.errors.some(e => e.includes('ghost')));
+  });
+});
+
+describe('getNode', () => {
+  it('returns a node by ID', () => {
+    const graph = buildGraph(minimalFlow);
+    const node = getNode(graph, 'start');
+    assert.equal(node.type, 'entry');
+  });
+
+  it('throws on missing node ID', () => {
+    const graph = buildGraph(minimalFlow);
+    assert.throws(() => getNode(graph, 'nope'), /not found/);
+  });
+});
+
+describe('getNextNodes', () => {
+  it('collects next from a simple node', () => {
+    const refs = getNextNodes({ id: 'a', next: 'b' });
+    assert.deepEqual(refs, ['b']);
+  });
+
+  it('collects from condition node (true/false)', () => {
+    const refs = getNextNodes({ id: 'c', type: 'condition', true: 'yes', false: 'no' });
+    assert.deepEqual(refs.sort(), ['no', 'yes']);
+  });
+
+  it('collects from router routes', () => {
+    const refs = getNextNodes({ id: 'r', routes: { a: 'x', b: 'y' }, default: 'y' });
+    // 'y' appears in both routes and default — deduplication
+    assert.deepEqual(refs.sort(), ['x', 'y']);
+  });
+
+  it('collects onMaxIterations and onError', () => {
+    const refs = getNextNodes({ id: 'p', next: 'a', onMaxIterations: 'b', onError: 'c' });
+    assert.deepEqual(refs.sort(), ['a', 'b', 'c']);
+  });
+
+  it('returns empty for exit node', () => {
+    const refs = getNextNodes({ id: 'end', type: 'exit', status: 'success' });
+    assert.deepEqual(refs, []);
+  });
+});
+
+describe('real flow loading', () => {
+  it('loads the full development-flow.json', () => {
+    const flow = require('../../flows/development-flow.json');
+    const graph = buildGraph(flow);
+    assert.equal(graph.nodes.size, 42);
+    assert.equal(graph.entryNode, 'start');
+    assert.equal(graph.meta.version, '5.3.0');
+  });
+});

package/flow-engine/tests/integration.test.js

@@ -0,0 +1,251 @@
+'use strict';
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+const { FlowEngine, NotImplementedError } = require('../src/index');
+const { resolveTemplate } = require('../src/template');
+
+// Load the REAL flow
+const flow = require('../../flows/development-flow.json');
+
+// Mock callbacks that simulate command behavior
+function makeMockCallbacks() {
+  const log = [];
+
+  return {
+    log,
+    onBash: async (cmd) => {
+      log.push({ type: 'bash', cmd });
+      return { output: '{}', exitCode: 0 };
+    },
+    onReadFiles: async (files) => {
+      log.push({ type: 'read_files', files });
+      return { content: 'mock file content' };
+    },
+    onAgent: async (config) => {
+      log.push({ type: 'agent', id: config.id, agent: config.agent });
+      return { result: 'mock agent output' };
+    },
+    onNodeStart: async (id, type) => {
+      log.push({ type: 'node_start', id, nodeType: type });
+    },
+    onNodeComplete: async (id, result) => {
+      log.push({ type: 'node_complete', id, next: result.next });
+    },
+    onCheckpoint: async (data) => {
+      log.push({ type: 'checkpoint', node: data.currentNode, next: data.nextNode });
+    },
+    onInterrupt: async (display) => {
+      log.push({ type: 'interrupt', nodeId: display.nodeId });
+      // Auto-approve first option
+      const options = display.display.options || [];
+      return options.length > 0 ? options[0].id : 'approve';
+    },
+    onParallel: async ({ branches }) => {
+      log.push({ type: 'parallel', branchCount: branches.length });
+      return branches.map(b => ({ id: b.id, result: 'mock parallel result' }));
+    },
+    onTeamRequired: async ({ nodeId }) => {
+      log.push({ type: 'team_required', nodeId });
+    }
+  };
+}
+
+describe('Integration: Graph loading', () => {
+  it('loads all 42 nodes from development-flow.json', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    assert.equal(engine.getNodeCount(), 42);
+  });
+
+  it('finds the entry node at "start"', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    assert.equal(engine.graph.entryNode, 'start');
+  });
+
+  it('verifies sync_metadata matches audit', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const meta = engine.getFlowMetadata();
+    assert.equal(meta.sync_metadata.audit_result.total_nodes, 42);
+    assert.equal(meta.sync_metadata.audit_result.implemented, 19);
+    assert.equal(meta.sync_metadata.audit_result.partial, 3);
+    assert.equal(meta.sync_metadata.audit_result.not_implemented, 20);
+  });
+
+  it('counts implemented nodes correctly', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const implemented = engine.getNodesWhere(n => n.runtime_status === 'implemented');
+    assert.equal(implemented.length, 19);
+  });
+
+  it('counts not_implemented nodes correctly', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const notImpl = engine.getNodesWhere(n => n.runtime_status === 'not_implemented');
+    assert.equal(notImpl.length, 20);
+  });
+
+  it('counts partial nodes correctly', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const partial = engine.getNodesWhere(n => n.runtime_status === 'partial');
+    assert.equal(partial.length, 3);
+  });
+
+  it('validates graph has no orphaned references', () => {
+    const engine = new FlowEngine();
+    // loadFlow already validates — this would throw if invalid
+    engine.loadFlow(flow);
+    assert.ok(engine.graph);
+  });
+});
+
+describe('Integration: Template resolution with real flow data', () => {
+  it('resolves {{inputs.task}}', () => {
+    const ctx = { inputs: { task: 'add auth', profile: 'default', complexity: 'medium' } };
+    assert.equal(resolveTemplate('{{inputs.task}}', ctx), 'add auth');
+  });
+
+  it('resolves router condition: {{inputs.profile}}', () => {
+    const ctx = { inputs: { profile: 'bmad' } };
+    assert.equal(resolveTemplate('{{inputs.profile}}', ctx), 'bmad');
+  });
+
+  it('resolves quality_check condition from real flow', () => {
+    const ctx = {
+      nodes: {
+        quality_gate: {
+          outputs: {
+            tests: { exitCode: 0 },
+            typescript: { exitCode: 0 },
+            lint: { exitCode: 0 }
+          }
+        }
+      }
+    };
+    const condition = '{{nodes.quality_gate.outputs.tests.exitCode === 0 && nodes.quality_gate.outputs.typescript.exitCode === 0 && nodes.quality_gate.outputs.lint.exitCode === 0}}';
+    assert.equal(resolveTemplate(condition, ctx), true);
+  });
+
+  it('resolves team config name with slugify from real flow', () => {
+    const ctx = { inputs: { task: 'Build User Dashboard' } };
+    const template = 'elsabro-{{inputs.task | slugify}}';
+    assert.equal(resolveTemplate(template, ctx), 'elsabro-build-user-dashboard');
+  });
+
+  it('resolves fallback from skill discovery outputs', () => {
+    const ctx = {
+      steps: { discovery: { output: { recommended: { skills: ['context7', 'stitch'] } } } }
+    };
+    assert.deepEqual(
+      resolveTemplate('{{steps.discovery.output.recommended.skills || []}}', ctx),
+      ['context7', 'stitch']
+    );
+  });
+});
+
+describe('Integration: Default profile path (stops at interview_default)', () => {
+  it('traverses start → skill_discovery → load_context → profile_router → interview_default (NOT_IMPLEMENTED)', async () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const { log } = makeMockCallbacks();
+    const callbacks = makeMockCallbacks();
+
+    await assert.rejects(
+      engine.run(
+        { task: 'test integration', profile: 'default', complexity: 'medium' },
+        callbacks
+      ),
+      (err) => {
+        assert.equal(err.name, 'NotImplementedError');
+        assert.ok(err.message.includes('interview_default'));
+        assert.ok(err.message.includes('not yet implemented'));
+        return true;
+      }
+    );
+
+    // Verify the traversal path via callbacks log
+    const nodeStarts = callbacks.log.filter(e => e.type === 'node_start').map(e => e.id);
+    assert.deepEqual(nodeStarts, ['start', 'skill_discovery', 'load_context', 'profile_router', 'interview_default']);
+  });
+});
+
+describe('Integration: Yolo profile path (stops at interview_yolo)', () => {
+  it('routes to yolo interview via profile_router', async () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const callbacks = makeMockCallbacks();
+
+    await assert.rejects(
+      engine.run(
+        { task: 'quick fix', profile: 'yolo', complexity: 'low' },
+        callbacks
+      ),
+      (err) => {
+        assert.ok(err.message.includes('interview_yolo'));
+        return true;
+      }
+    );
+
+    const nodeStarts = callbacks.log.filter(e => e.type === 'node_start').map(e => e.id);
+    assert.deepEqual(nodeStarts, ['start', 'skill_discovery', 'load_context', 'profile_router', 'interview_yolo']);
+  });
+});
+
+describe('Integration: BMAD profile path (stops at bmad_interview_analysis)', () => {
+  it('routes to BMAD interview via profile_router', async () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const callbacks = makeMockCallbacks();
+
+    await assert.rejects(
+      engine.run(
+        { task: 'build app', profile: 'bmad', complexity: 'high' },
+        callbacks
+      ),
+      (err) => {
+        assert.ok(err.message.includes('bmad_interview_analysis'));
+        return true;
+      }
+    );
+
+    const nodeStarts = callbacks.log.filter(e => e.type === 'node_start').map(e => e.id);
+    assert.deepEqual(nodeStarts, ['start', 'skill_discovery', 'load_context', 'profile_router', 'bmad_interview_analysis']);
+  });
+});
+
+describe('Integration: Node type coverage', () => {
+  it('has executors for all node types in the flow', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const { getExecutor } = require('../src/executors');
+
+    const types = new Set();
+    for (const node of engine.graph.nodes.values()) {
+      types.add(node.type);
+    }
+
+    // All types in the flow should have executors
+    for (const type of types) {
+      assert.doesNotThrow(
+        () => getExecutor(type),
+        `No executor for node type "${type}" used in flow`
+      );
+    }
+
+    // Verify all 9 types are present
+    assert.ok(types.has('entry'));
+    assert.ok(types.has('exit'));
+    assert.ok(types.has('condition'));
+    assert.ok(types.has('router'));
+    assert.ok(types.has('sequence'));
+    assert.ok(types.has('agent'));
+    assert.ok(types.has('parallel'));
+    assert.ok(types.has('interrupt'));
+    assert.ok(types.has('team'));
+    assert.equal(types.size, 9);
+  });
+});

package/flow-engine/tests/runner.test.js

@@ -0,0 +1,289 @@
+'use strict';
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+const { FlowEngine, NotImplementedError, CheckpointManager } = require('../src/index');
+const { serializeContext, deserializeContext } = require('../src/runner');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// ---------- Mini flow definitions ----------
+
+const miniFlow = {
+  id: 'mini',
+  version: '1.0.0',
+  config: {},
+  inputs: {},
+  nodes: [
+    { id: 'start', type: 'entry', runtime_status: 'implemented', next: 'check' },
+    {
+      id: 'check',
+      type: 'condition',
+      runtime_status: 'implemented',
+      condition: '{{inputs.go}}',
+      true: 'end_ok',
+      false: 'end_cancel'
+    },
+    {
+      id: 'end_ok',
+      type: 'exit',
+      runtime_status: 'implemented',
+      status: 'success',
+      outputs: { result: 'completed', task: '{{inputs.task}}' }
+    },
+    {
+      id: 'end_cancel',
+      type: 'exit',
+      runtime_status: 'implemented',
+      status: 'cancelled',
+      outputs: { result: 'cancelled' }
+    }
+  ]
+};
+
+const flowWithNotImplemented = {
+  id: 'blocked',
+  version: '1.0.0',
+  config: {},
+  nodes: [
+    { id: 'start', type: 'entry', runtime_status: 'implemented', next: 'blocker' },
+    {
+      id: 'blocker',
+      type: 'agent',
+      runtime_status: 'not_implemented',
+      gaps: ['No interview command exists'],
+      next: 'end'
+    },
+    { id: 'end', type: 'exit', runtime_status: 'implemented', status: 'success', outputs: {} }
+  ]
+};
+
+const flowWithSequence = {
+  id: 'seq_flow',
+  version: '1.0.0',
+  config: {},
+  nodes: [
+    { id: 'start', type: 'entry', runtime_status: 'implemented', next: 'seq' },
+    {
+      id: 'seq',
+      type: 'sequence',
+      runtime_status: 'implemented',
+      errorPolicy: 'continue',
+      steps: [
+        { action: 'bash', command: 'echo hello', as: 'greeting' }
+      ],
+      outputs: { msg: '{{steps.greeting.output.output}}' },
+      next: 'end'
+    },
+    { id: 'end', type: 'exit', runtime_status: 'implemented', status: 'success', outputs: { final: '{{nodes.seq.outputs.msg}}' } }
+  ]
+};
+
+describe('runFlow — basic traversal', () => {
+  it('traverses entry → condition(true) → exit(success)', async () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(miniFlow);
+
+    const nodesStarted = [];
+    const nodesCompleted = [];
+
+    const result = await engine.run(
+      { task: 'test', go: true },
+      {
+        onNodeStart: async (id, type) => nodesStarted.push(id),
+        onNodeComplete: async (id) => nodesCompleted.push(id)
+      }
+    );
+
+    assert.equal(result.success, true);
+    assert.equal(result.outputs.result, 'completed');
+    assert.equal(result.outputs.task, 'test');
+    assert.deepEqual(result.nodesVisited, ['start', 'check', 'end_ok']);
+    assert.deepEqual(nodesStarted, ['start', 'check', 'end_ok']);
+    assert.deepEqual(nodesCompleted, ['start', 'check', 'end_ok']);
+  });
+
+  it('traverses entry → condition(false) → exit(cancelled)', async () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(miniFlow);
+
+    const result = await engine.run({ task: 'test', go: false }, {});
+
+    assert.equal(result.success, false);
+    assert.equal(result.outputs.result, 'cancelled');
+    assert.deepEqual(result.nodesVisited, ['start', 'check', 'end_cancel']);
+  });
+});
+
+describe('runFlow — not_implemented handling', () => {
+  it('throws NotImplementedError with node info', async () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flowWithNotImplemented);
+
+    const allCheckpoints = [];
+
+    await assert.rejects(
+      engine.run({}, {
+        onCheckpoint: async (data) => { allCheckpoints.push(data); }
+      }),
+      (err) => {
+        assert.equal(err.name, 'NotImplementedError');
+        assert.ok(err.message.includes('blocker'));
+        assert.ok(err.message.includes('No interview command exists'));
+        return true;
+      }
+    );
+
+    // Should have checkpoint from start node + blocked checkpoint
+    assert.ok(allCheckpoints.length >= 1);
+    const lastCheckpoint = allCheckpoints[allCheckpoints.length - 1];
+    assert.equal(lastCheckpoint.stoppedAt, 'blocker');
+  });
+});
+
+describe('runFlow — checkpoint saving', () => {
+  it('saves a checkpoint after each node', async () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(miniFlow);
+
+    const checkpoints = [];
+
+    await engine.run(
+      { task: 'cp-test', go: true },
+      { onCheckpoint: async (data) => checkpoints.push(data) }
+    );
+
+    // 3 nodes → 3 checkpoints
+    assert.equal(checkpoints.length, 3);
+    assert.equal(checkpoints[0].currentNode, 'start');
+    assert.equal(checkpoints[0].nextNode, 'check');
+    assert.equal(checkpoints[1].currentNode, 'check');
+    assert.equal(checkpoints[1].nextNode, 'end_ok');
+    assert.equal(checkpoints[2].currentNode, 'end_ok');
+    assert.equal(checkpoints[2].nextNode, null);
+  });
+});
+
+describe('runFlow — resume from checkpoint', () => {
+  it('resumes from a checkpoint at a specific node', async () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(miniFlow);
+
+    // Create a checkpoint as if we stopped after 'start'
+    const checkpoint = {
+      nextNode: 'check',
+      context: {
+        inputs: { task: 'resumed', go: true },
+        nodes: { start: { outputs: {} } },
+        steps: {},
+        state: {},
+        _iterations: {}
+      },
+      nodesVisited: ['start']
+    };
+
+    const result = await engine.resume(checkpoint, {});
+
+    assert.equal(result.success, true);
+    assert.equal(result.outputs.task, 'resumed');
+    assert.deepEqual(result.nodesVisited, ['start', 'check', 'end_ok']);
+  });
+});
+
+describe('runFlow — sequence with callbacks', () => {
+  it('executes a sequence step and passes output through', async () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flowWithSequence);
+
+    const result = await engine.run(
+      {},
+      {
+        onBash: async (cmd) => ({ output: 'hello world', exitCode: 0 })
+      }
+    );
+
+    assert.equal(result.success, true);
+    assert.equal(result.outputs.final, 'hello world');
+  });
+});
+
+describe('serializeContext / deserializeContext', () => {
+  it('round-trips a context through serialize/deserialize', () => {
+    const original = {
+      inputs: { task: 'test' },
+      nodes: { a: { outputs: { x: 1 } } },
+      steps: { s: { output: 'data' } },
+      state: { counter: 5 },
+      _iterations: { a: 2 }
+    };
+
+    const serialized = serializeContext(original);
+    const deserialized = deserializeContext(serialized);
+
+    assert.deepEqual(deserialized.inputs, original.inputs);
+    assert.deepEqual(deserialized.nodes, original.nodes);
+    assert.deepEqual(deserialized.steps, original.steps);
+    assert.deepEqual(deserialized.state, original.state);
+    assert.deepEqual(deserialized._iterations, original._iterations);
+  });
+});
+
+describe('CheckpointManager', () => {
+  const tmpDir = path.join(os.tmpdir(), `elsabro-test-cp-${Date.now()}`);
+
+  it('saves and loads a checkpoint', () => {
+    const mgr = new CheckpointManager({ dir: tmpDir });
+    const filename = mgr.save('test_flow', {
+      currentNode: 'start',
+      nextNode: 'check',
+      context: { inputs: { task: 'save test' } }
+    });
+
+    assert.ok(filename.startsWith('test_flow-'));
+    assert.ok(filename.endsWith('.json'));
+
+    const loaded = mgr.load('test_flow');
+    assert.equal(loaded.flowId, 'test_flow');
+    assert.equal(loaded.currentNode, 'start');
+    assert.equal(loaded.nextNode, 'check');
+  });
+
+  it('lists checkpoints in reverse chronological order', () => {
+    const mgr = new CheckpointManager({ dir: tmpDir });
+    mgr.save('list_flow', { currentNode: 'a' });
+    mgr.save('list_flow', { currentNode: 'b' });
+
+    const list = mgr.list('list_flow');
+    assert.equal(list.length, 2);
+    assert.ok(list[0].timestamp >= list[1].timestamp);
+  });
+
+  it('cleans old checkpoints keeping last N', () => {
+    const cleanDir = path.join(os.tmpdir(), `elsabro-clean-${Date.now()}`);
+    const mgr = new CheckpointManager({ dir: cleanDir });
+
+    for (let i = 0; i < 8; i++) {
+      mgr.save('clean_flow', { currentNode: `node_${i}` });
+    }
+
+    const removed = mgr.clean('clean_flow', 3);
+    assert.equal(removed, 5);
+    assert.equal(mgr.list('clean_flow').length, 3);
+
+    // Cleanup
+    fs.rmSync(cleanDir, { recursive: true });
+  });
+
+  it('returns null when no checkpoint exists', () => {
+    const mgr = new CheckpointManager({ dir: path.join(os.tmpdir(), 'nonexistent-dir-xyz') });
+    assert.equal(mgr.load('missing_flow'), null);
+  });
+
+  // Cleanup
+  it('cleanup temp dir', () => {
+    if (fs.existsSync(tmpDir)) {
+      fs.rmSync(tmpDir, { recursive: true });
+    }
+  });
+});