unbound-cli 1.13.0 → 1.15.0

package/test/chat-stream.test.js

@@ -0,0 +1,255 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const http = require('http');
+
+// A turn can run for minutes, and the proxy in front of the API closes a
+// connection that goes 60s without a byte. A buffered POST sends nothing until
+// the turn ends, so every long question died at 60s with the answer already
+// built server-side. These cover the streamed path that replaces it.
+
+function freshModules() {
+  for (const m of ['../src/commands/chat', '../src/api', '../src/config', '../src/auth', '../src/output', '../src/chartRender']) {
+    delete require.cache[require.resolve(m)];
+  }
+}
+
+// Serve `handler` on a loopback port and point the api module at it.
+async function withServer(handler, run) {
+  const server = http.createServer(handler);
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const port = server.address().port;
+  freshModules();
+  const config = require('../src/config');
+  config.getBaseUrl = () => `http://127.0.0.1:${port}`;
+  config.getApiKey = () => 'test-key';
+  const api = require('../src/api');
+  try {
+    return await run(api);
+  } finally {
+    server.close();
+  }
+}
+
+function sse(event, data) {
+  return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+}
+
+test('postStream: reassembles frames split across chunk boundaries', async () => {
+  const frames = sse('block', { type: 'text', text: 'one' })
+    + sse('block', { type: 'chart', title: 'two' })
+    + sse('done', { conversation_id: 'c-1' });
+
+  // Cut mid-JSON, then between the two newlines that terminate a frame — the
+  // two ways a real socket splits a 400 KB chart block. The awaits are what
+  // force separate 'data' events; without them Node coalesces the writes.
+  const midJson = 20;
+  const midSeparator = frames.indexOf('\n\n') + 1;
+  assert.ok(midJson < midSeparator);
+
+  const events = await withServer(async (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'text/event-stream' });
+    for (const part of [frames.slice(0, midJson), frames.slice(midJson, midSeparator), frames.slice(midSeparator)]) {
+      res.write(part);
+      await new Promise((r) => setTimeout(r, 5));
+    }
+    res.end();
+  }, async (api) => {
+    const seen = [];
+    const fallback = await api.postStream('/x', {
+      body: {}, onEvent: (event, data) => seen.push([event, data]),
+    });
+    assert.equal(fallback, null, 'a streamed reply resolves null');
+    return seen;
+  });
+
+  assert.deepEqual(events.map((e) => e[0]), ['block', 'block', 'done']);
+  assert.equal(events[0][1].text, 'one');
+  assert.equal(events[1][1].title, 'two');
+  assert.equal(events[2][1].conversation_id, 'c-1');
+});
+
+test('postStream: a server that answers with JSON resolves that body instead', async () => {
+  const resp = await withServer((req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ success: true, blocks: [{ type: 'text', text: 'buffered' }] }));
+  }, async (api) => {
+    let called = 0;
+    const out = await api.postStream('/x', { body: {}, onEvent: () => { called += 1; } });
+    assert.equal(called, 0, 'no frames to hand back');
+    return out;
+  });
+
+  assert.equal(resp.blocks[0].text, 'buffered');
+});
+
+test('postStream: a socket cut mid-stream is reported, not read as a finished turn', async () => {
+  await withServer(async (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'text/event-stream' });
+    res.write(sse('block', { type: 'text', text: 'partial' }));
+    await new Promise((r) => setTimeout(r, 5));
+    // What a proxy does when it gives up: headers are out, so it can only cut.
+    res.socket.destroy();
+  }, async (api) => {
+    const seen = [];
+    await assert.rejects(
+      () => api.postStream('/x', { body: {}, onEvent: (e) => seen.push(e) }),
+      /dropped before the reply finished/,
+    );
+    assert.deepEqual(seen, ['block'], 'what arrived before the cut still counts');
+  });
+});
+
+test('postStream: a non-2xx reply rejects with the status', async () => {
+  await withServer((req, res) => {
+    res.writeHead(403, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'nope' }));
+  }, async (api) => {
+    await assert.rejects(
+      () => api.postStream('/x', { body: {} }),
+      (err) => err.statusCode === 403 && err.message === 'nope',
+    );
+  });
+});
+
+function chatWithStream(postStream) {
+  freshModules();
+  const api = require('../src/api');
+  api.postStream = postStream;
+  return require('../src/commands/chat')._internals.converse;
+}
+
+test('converse: assembles blocks and done into the non-streaming shape', async () => {
+  const converse = chatWithStream(async (_p, { onEvent }) => {
+    onEvent('block', { type: 'text', text: 'hi' });
+    onEvent('done', { conversation_id: 'c-1', log_id: 'l-1', truncated: false, resumed: true });
+    return null;
+  });
+
+  const resp = await converse({ message: 'q' });
+  assert.equal(resp.success, true);
+  assert.equal(resp.blocks.length, 1);
+  assert.equal(resp.conversation_id, 'c-1');
+  assert.equal(resp.resumed, true);
+});
+
+test('converse: sets stream on the request', async () => {
+  let sent = null;
+  const converse = chatWithStream(async (_p, { body, onEvent }) => {
+    sent = body;
+    onEvent('done', { conversation_id: 'c-1' });
+    return null;
+  });
+
+  await converse({ message: 'q', conversation_id: 'c-1' });
+  assert.equal(sent.stream, true);
+  assert.equal(sent.message, 'q');
+  assert.equal(sent.conversation_id, 'c-1');
+});
+
+test('converse: an error event keeps the blocks already streamed', async () => {
+  const converse = chatWithStream(async (_p, { onEvent }) => {
+    onEvent('block', { type: 'text', text: 'built this much' });
+    onEvent('error', { error: 'The assistant is unavailable right now.' });
+    return null;
+  });
+
+  const resp = await converse({ message: 'q' });
+  assert.equal(resp.success, false);
+  assert.equal(resp.error, 'The assistant is unavailable right now.');
+  // They are on screen already — reporting an empty turn would contradict that.
+  assert.equal(resp.blocks.length, 1);
+});
+
+test('converse: a stream that ends without done is reported, not passed off as complete', async () => {
+  const converse = chatWithStream(async (_p, { onEvent }) => {
+    onEvent('block', { type: 'text', text: 'partial' });
+    return null;
+  });
+
+  await assert.rejects(() => converse({ message: 'q' }), /connection dropped/);
+});
+
+test('converse: a server that did not stream is returned untouched', async () => {
+  const buffered = { success: true, blocks: [{ type: 'text', text: 'old server' }], conversation_id: 'c-9' };
+  const converse = chatWithStream(async () => buffered);
+
+  assert.deepEqual(await converse({ message: 'q' }), buffered);
+});
+
+test('postStream: CRLF-delimited frames are read, not silently skipped', async () => {
+  const frames = 'event: block\r\ndata: {"type":"text","text":"crlf"}\r\n\r\n'
+    + 'event: done\r\ndata: {"conversation_id":"c-1"}\r\n\r\n';
+
+  const events = await withServer((req, res) => {
+    res.writeHead(200, { 'Content-Type': 'text/event-stream' });
+    res.end(frames);
+  }, async (api) => {
+    const seen = [];
+    await api.postStream('/x', { body: {}, onEvent: (e, d) => seen.push([e, d]) });
+    return seen;
+  });
+
+  assert.deepEqual(events.map((e) => e[0]), ['block', 'done']);
+  assert.equal(events[0][1].text, 'crlf');
+});
+
+test('converse: a socket that fails after the closing frame keeps the turn', async () => {
+  const converse = chatWithStream(async (_p, { onEvent }) => {
+    onEvent('block', { type: 'text', text: 'built' });
+    onEvent('done', { conversation_id: 'c-1', resumed: true });
+    // Teardown failure, after the turn already reported itself finished.
+    throw new Error('The connection to example dropped before the reply finished (ECONNRESET).');
+  });
+
+  const resp = await converse({ message: 'q' });
+  assert.equal(resp.success, true);
+  assert.equal(resp.blocks.length, 1);
+  assert.equal(resp.conversation_id, 'c-1');
+});
+
+test('converse: a socket that fails with no closing frame still reports the drop', async () => {
+  const converse = chatWithStream(async (_p, { onEvent }) => {
+    onEvent('block', { type: 'text', text: 'partial' });
+    throw new Error('The connection to example dropped before the reply finished (ECONNRESET).');
+  });
+
+  await assert.rejects(() => converse({ message: 'q' }), /dropped before the reply finished/);
+});
+
+test('postStream: CR-only frames are read, not collapsed into one line', async () => {
+  const frames = 'event: block\rdata: {"type":"text","text":"cr"}\r\r'
+    + 'event: done\rdata: {"conversation_id":"c-1"}\r\r';
+
+  const events = await withServer((req, res) => {
+    res.writeHead(200, { 'Content-Type': 'text/event-stream' });
+    res.end(frames);
+  }, async (api) => {
+    const seen = [];
+    await api.postStream('/x', { body: {}, onEvent: (e, d) => seen.push([e, d]) });
+    return seen;
+  });
+
+  assert.deepEqual(events.map((e) => e[0]), ['block', 'done']);
+  assert.equal(events[0][1].text, 'cr');
+});
+
+test('postStream: a CRLF split across two chunks does not cut a frame in half', async () => {
+  const frame = 'event: block\r\ndata: {"type":"text","text":"split"}\r\n\r\n';
+  const cut = frame.indexOf('\r\n') + 1; // between the CR and the LF
+
+  const events = await withServer(async (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'text/event-stream' });
+    res.write(frame.slice(0, cut));
+    await new Promise((r) => setTimeout(r, 5));
+    res.end(frame.slice(cut));
+  }, async (api) => {
+    const seen = [];
+    await api.postStream('/x', { body: {}, onEvent: (e, d) => seen.push([e, d]) });
+    return seen;
+  });
+
+  // Naively normalising CR to LF turns the split ending into a frame boundary,
+  // and the block is silently dropped as a frame with no data.
+  assert.deepEqual(events.map((e) => e[0]), ['block']);
+  assert.equal(events[0][1].text, 'split');
+});

package/test/download-flag-collision.test.js

@@ -0,0 +1,52 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const { Command } = require('commander');
+
+const download = require('../src/commands/download');
+
+// Commander binds a repeated flag on the PARENT and the child's copy is left
+// undefined. When the flag is `-o`, the export silently streams to stdout
+// instead of writing the file the user named, and the command still exits 0.
+// This repo has hit that once before, on `onboard mdm`.
+
+function flagNames(command) {
+  return command.options.flatMap((opt) => [opt.short, opt.long].filter(Boolean));
+}
+
+function build() {
+  const program = new Command();
+  program.exitOverride();
+  download.register(program);
+  return program.commands.find((c) => c.name() === 'download');
+}
+
+test('no subcommand of `download` declares a flag its parent also declares', () => {
+  const group = build();
+  const parentFlags = new Set(flagNames(group));
+
+  for (const sub of group.commands) {
+    const clashing = flagNames(sub).filter((flag) => parentFlags.has(flag));
+    assert.deepEqual(
+      clashing, [],
+      `\`download ${sub.name()}\` re-declares ${clashing.join(', ')} from its parent; ` +
+      'commander binds those on the parent and the subcommand reads undefined',
+    );
+  }
+});
+
+test('the `download` group itself takes no options, so nothing can be shadowed', () => {
+  // -h/--help is added by commander and is handled before any action runs.
+  const declared = flagNames(build()).filter((f) => f !== '-h' && f !== '--help');
+  assert.deepEqual(declared, [], 'keep the group option-free so subcommands own their flags');
+});
+
+test('`download` exposes the verbs an agent needs, each taking its own -o where relevant', () => {
+  const group = build();
+  const names = group.commands.map((c) => c.name()).sort();
+  assert.deepEqual(names, ['get', 'kinds', 'start']);
+
+  for (const verb of ['get', 'start']) {
+    const sub = group.commands.find((c) => c.name() === verb);
+    assert.ok(flagNames(sub).includes('-o'), `\`download ${verb}\` must accept -o`);
+  }
+});

package/test/download-query.test.js

@@ -0,0 +1,79 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+
+const { buildQueryString, resolveLast } = require('../src/commands/download');
+const { KINDS, isJobId } = require('../src/lib/downloads');
+
+const params = (opts) => new URLSearchParams(buildQueryString(opts));
+
+test('repeated --filter keys are appended, not collapsed to the last one', () => {
+  // Every list filter on the server reads getlist(). Collapsing duplicates
+  // would silently export one tool instead of two, and the file still looks
+  // fine — which is the failure mode worth a test.
+  const q = params({ filter: ['tool_types=CLAUDE_CODE', 'tool_types=CURSOR'] });
+  assert.deepEqual(q.getAll('tool_types'), ['CLAUDE_CODE', 'CURSOR']);
+});
+
+test('--filter keeps everything after the first = so values may contain one', () => {
+  const q = params({ filter: ['search=a=b'] });
+  assert.equal(q.get('search'), 'a=b');
+});
+
+test('--filter rejects a value with no key rather than sending a blank param', () => {
+  assert.throws(() => buildQueryString({ filter: ['=value'] }), /Use key=value/);
+  assert.throws(() => buildQueryString({ filter: ['novalue'] }), /Use key=value/);
+});
+
+test('--last resolves to an absolute window the server understands', () => {
+  const q = params({ last: '7d' });
+  const start = new Date(q.get('start_date'));
+  const end = new Date(q.get('end_date'));
+  const days = (end - start) / 86400000;
+  assert.ok(Math.abs(days - 7) < 0.01, `expected ~7 days, got ${days}`);
+});
+
+test('--last accepts hours as well as days', () => {
+  const { start, end } = resolveLast('24h');
+  const hours = (end - start) / 3600000;
+  assert.ok(Math.abs(hours - 24) < 0.01, `expected ~24 hours, got ${hours}`);
+});
+
+test('--last rejects junk instead of silently exporting the default window', () => {
+  for (const bad of ['7', 'week', '7 days', '-3d', '0d', '']) {
+    assert.throws(() => resolveLast(bad), /Invalid --last|at least 1/, `"${bad}" should be rejected`);
+  }
+});
+
+test('--last and --start/--end together is an error, not a silent winner', () => {
+  assert.throws(
+    () => buildQueryString({ last: '7d', start: '2026-07-01', end: '2026-07-31' }),
+    /not both/,
+  );
+});
+
+test('--start without --end is rejected (a half range would widen the export)', () => {
+  assert.throws(() => buildQueryString({ start: '2026-07-01' }), /must be used together/);
+  assert.throws(() => buildQueryString({ end: '2026-07-31' }), /must be used together/);
+});
+
+test('no range at all is allowed — the server applies its own default window', () => {
+  assert.equal(buildQueryString({}), '');
+});
+
+test('every advertised kind names the filters it accepts', () => {
+  // The help text is the agent's only map of what each kind takes, so an empty
+  // filter list would read as "takes nothing" rather than "nobody filled it in".
+  for (const [kind, meta] of Object.entries(KINDS)) {
+    assert.ok(meta.summary && meta.summary.length > 10, `${kind} needs a summary`);
+    assert.ok(Array.isArray(meta.filters) && meta.filters.length > 0, `${kind} needs filters`);
+  }
+});
+
+test('isJobId accepts a UUID and rejects anything else', () => {
+  assert.ok(isJobId('4f2a1c9e-1b2c-4d5e-8f90-a1b2c3d4e5f6'));
+  assert.ok(isJobId('4F2A1C9E-1B2C-4D5E-8F90-A1B2C3D4E5F6'));
+  assert.equal(isJobId('logs-export'), false);
+  assert.equal(isJobId('4f2a1c9e'), false);
+  assert.equal(isJobId(''), false);
+  assert.equal(isJobId(null), false);
+});

package/test/download-safety.test.js

@@ -0,0 +1,201 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const http = require('http');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const api = require('../src/api');
+const downloads = require('../src/lib/downloads');
+const output = require('../src/output');
+const { resolveLimit, MAX_LIMIT, MAX_TABLE_LIMIT } = require('../src/lib/analytics-query');
+
+function startServer(handler) {
+  const server = http.createServer(handler);
+  return new Promise((resolve) => {
+    server.listen(0, '127.0.0.1', () => resolve({ server, port: server.address().port }));
+  });
+}
+
+function freshDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'dl-safety-'));
+}
+
+// Analytics cells are commands and prompts recorded from agents, so their
+// contents are chosen by whoever ran the agent. Echoing them raw lets a
+// recorded command repaint the screen, set the window title, or drive OSC 52.
+test('logTable strips terminal control sequences out of backend cells', () => {
+  const lines = [];
+  const realLog = console.log;
+  console.log = (line) => lines.push(String(line));
+  try {
+    output.logTable(
+      ['Command'],
+      [[']52;c;aGF4git push]0;pwned']],
+      { wide: true },
+    );
+  } finally {
+    console.log = realLog;
+  }
+  const printed = lines.join('\n');
+  assert.ok(printed.includes('git push'), 'the real value must survive');
+  assert.ok(!printed.includes(']'), 'OSC sequences must not reach the terminal');
+  assert.ok(!printed.includes(''), 'CSI erase must not reach the terminal');
+  assert.ok(!printed.includes('pwned'), 'the title payload must be gone with its sequence');
+});
+
+test('logTable strips control sequences out of headers too', () => {
+  const lines = [];
+  const realLog = console.log;
+  console.log = (line) => lines.push(String(line));
+  try {
+    output.logTable(['Command'], [['ls']], { wide: true });
+  } finally {
+    console.log = realLog;
+  }
+  assert.ok(!lines.join('\n').includes(''), 'header colour codes must be stripped');
+});
+
+// The download used to stream straight into the path the user named. Opening
+// that stream truncates an existing file, so a transfer that died halfway left
+// the user with nothing where their file used to be.
+test('a failed download leaves an existing -o file untouched', async () => {
+  const { server, port } = await startServer((req, res) => {
+    res.writeHead(200, { 'Content-Type': 'text/csv', 'Content-Length': '999' });
+    res.write('partial');
+    // Cut the connection mid-body: the client sees a truncated transfer.
+    res.destroy();
+  });
+  const dir = freshDir();
+  const target = path.join(dir, 'important.csv');
+  fs.writeFileSync(target, 'MY,EXISTING,DATA\n1,2,3\n');
+  const partial = `${target}.part-${process.pid}`;
+
+  try {
+    await assert.rejects(() => api.fetchToStream(`http://127.0.0.1:${port}/x`, {
+      transport: http,
+      onHeaders: () => fs.createWriteStream(partial, { flags: 'wx', mode: 0o600 }),
+    }));
+    assert.equal(
+      fs.readFileSync(target, 'utf8'), 'MY,EXISTING,DATA\n1,2,3\n',
+      'the pre-existing file must be byte-identical after a failed download',
+    );
+  } finally {
+    try { fs.unlinkSync(partial); } catch { /* already gone */ }
+    fs.rmSync(dir, { recursive: true, force: true });
+    server.close();
+  }
+});
+
+test('the temp destination refuses to follow a symlink planted at its path', async () => {
+  const dir = freshDir();
+  const victim = path.join(dir, 'victim.txt');
+  const partial = path.join(dir, 'out.csv.part-1');
+  fs.writeFileSync(victim, 'do-not-touch\n');
+  fs.symlinkSync(victim, partial);
+  try {
+    assert.throws(
+      () => fs.createWriteStream(partial, { flags: 'wx' }).on('error', () => {}) && fs.openSync(partial, 'wx'),
+      (err) => err.code === 'EEXIST' || err.code === 'ELOOP',
+    );
+    assert.equal(fs.readFileSync(victim, 'utf8'), 'do-not-touch\n');
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('--limit is capped lower for the table than for json', () => {
+  assert.equal(resolveLimit({ limit: String(MAX_TABLE_LIMIT) }, 'table'), MAX_TABLE_LIMIT);
+  assert.throws(
+    () => resolveLimit({ limit: String(MAX_TABLE_LIMIT + 1) }, 'table'),
+    /cannot exceed 100 for table output/,
+  );
+  // json is parsed, not read, so mess is not a reason to cap it low.
+  assert.equal(resolveLimit({ limit: String(MAX_LIMIT) }, 'json'), MAX_LIMIT);
+  assert.throws(() => resolveLimit({ limit: String(MAX_LIMIT + 1) }, 'json'), /cannot exceed 1000/);
+});
+
+test('a download cut mid-transfer closes its file before the caller deletes it', async () => {
+  // The caller unlinks the .part file on rejection. On Windows that fails while
+  // a write handle is still open, leaving a truncated export behind.
+  const { server, port } = await startServer((req, res) => {
+    res.writeHead(200, { 'Content-Type': 'text/csv', 'Content-Length': '9999' });
+    res.write('partial');
+    // Cut it only once the client has taken the headers and opened its file.
+    // Destroying immediately kills the socket first, so onHeaders never runs
+    // and there is no writer to leak — a different case from the real one.
+    setTimeout(() => res.destroy(), 40);
+  });
+  const dir = freshDir();
+  const partial = path.join(dir, 'out.csv.part');
+  const stream = fs.createWriteStream(partial, { flags: 'wx', mode: 0o600 });
+
+  try {
+    await assert.rejects(() => api.fetchToStream(`http://127.0.0.1:${port}/x`, {
+      transport: http,
+      onHeaders: () => stream,
+    }));
+    assert.equal(stream.destroyed, true, 'the destination must be destroyed before the caller cleans up');
+    fs.unlinkSync(partial);
+    assert.equal(fs.existsSync(partial), false);
+  } finally {
+    try { fs.unlinkSync(partial); } catch { /* already gone */ }
+    fs.rmSync(dir, { recursive: true, force: true });
+    server.close();
+  }
+});
+
+test('a file that appears during the download is not overwritten by a server-chosen name', () => {
+  // The existence check runs before the transfer and the placement after it, so
+  // the whole download sits in between. rename() would replace whatever landed
+  // there; the guarantee has to be enforced at the moment of placement.
+  const dir = freshDir();
+  const target = path.join(dir, 'acme_logs.csv');
+  const partial = `${target}.part-test`;
+  fs.writeFileSync(partial, 'the,export\n1,2\n');
+  // Created after the check would have passed, while bytes were still arriving.
+  fs.writeFileSync(target, 'SOMEONE ELSE WROTE THIS\n');
+
+  try {
+    assert.throws(
+      () => downloads.placeFile(partial, target, { replace: false, name: 'acme_logs.csv' }),
+      /already exists here/,
+    );
+    assert.equal(fs.readFileSync(target, 'utf8'), 'SOMEONE ELSE WROTE THIS\n',
+      'the file that appeared mid-download must be untouched');
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('an explicit -o still replaces, because the user named that file', () => {
+  const dir = freshDir();
+  const target = path.join(dir, 'mine.csv');
+  const partial = `${target}.part-test`;
+  fs.writeFileSync(partial, 'new\n');
+  fs.writeFileSync(target, 'old\n');
+
+  try {
+    downloads.placeFile(partial, target, { replace: true, name: 'mine.csv' });
+    assert.equal(fs.readFileSync(target, 'utf8'), 'new\n');
+    assert.equal(fs.existsSync(partial), false, 'the temp file must not be left behind');
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('the normal case places the file and removes the temp copy', () => {
+  const dir = freshDir();
+  const target = path.join(dir, 'fresh.csv');
+  const partial = `${target}.part-test`;
+  fs.writeFileSync(partial, 'a,b\n');
+
+  try {
+    downloads.placeFile(partial, target, { replace: false, name: 'fresh.csv' });
+    assert.equal(fs.readFileSync(target, 'utf8'), 'a,b\n');
+    assert.equal(fs.existsSync(partial), false, 'link() leaves the temp name behind unless it is unlinked');
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+