@ps-neko/nekowork 0.1.0-alpha.0

package/scripts/daemon/wait.js

@@ -0,0 +1,278 @@
+#!/usr/bin/env node
+// Persistent wait daemon. It watches wakeup.json files created by the
+// persistent-mode hook and resumes only sessions that declare a safe engine.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawnSync } from 'node:child_process';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '..', '..');
+const PIDFILE = path.join(ROOT, '.harness', 'wait.pid');
+const POLL_MS = Number(process.env.HARNESS_WAIT_POLL_MS || 10_000);
+const BACKOFF_MS = Number(process.env.HARNESS_WAIT_BACKOFF_MS || 60_000);
+
+if (isMain()) main(process.argv.slice(2));
+
+function main(argv) {
+  const verb = argv[0] || 'status';
+  if (verb === 'start') start({ root: ROOT });
+  else if (verb === 'stop') stop({ root: ROOT });
+  else if (verb === 'status') status({ root: ROOT });
+  else { console.error(`unknown wait command: ${verb}. start | stop | status`); process.exit(2); }
+}
+
+function start({ root = ROOT } = {}) {
+  if (fs.existsSync(PIDFILE)) {
+    const pid = Number(fs.readFileSync(PIDFILE, 'utf8'));
+    if (alive(pid)) { console.error(`already running: pid=${pid}`); process.exit(1); }
+    fs.unlinkSync(PIDFILE);
+  }
+  fs.mkdirSync(path.dirname(PIDFILE), { recursive: true });
+  fs.writeFileSync(PIDFILE, String(process.pid));
+  console.log(`[harness wait] start pid=${process.pid} poll=${POLL_MS}ms`);
+
+  const interval = setInterval(() => tick({ root }), POLL_MS);
+  process.on('SIGTERM', cleanup);
+  process.on('SIGINT', cleanup);
+  function cleanup() {
+    clearInterval(interval);
+    try { fs.unlinkSync(PIDFILE); } catch {}
+    console.log('[harness wait] stop');
+    process.exit(0);
+  }
+  tick({ root });
+}
+
+function stop() {
+  if (!fs.existsSync(PIDFILE)) { console.log('(daemon not running)'); return; }
+  const pid = Number(fs.readFileSync(PIDFILE, 'utf8'));
+  if (alive(pid)) {
+    try { process.kill(pid, 'SIGTERM'); console.log(`SIGTERM pid=${pid}`); }
+    catch (e) { console.error('kill failed:', e.message); }
+  } else {
+    console.log(`stale pidfile (pid=${pid}). cleaning.`);
+  }
+  try { fs.unlinkSync(PIDFILE); } catch {}
+}
+
+function status({ root = ROOT } = {}) {
+  if (!fs.existsSync(PIDFILE)) console.log('daemon stopped');
+  else {
+    const pid = Number(fs.readFileSync(PIDFILE, 'utf8'));
+    console.log(`pid=${pid} alive=${alive(pid)}`);
+  }
+  console.log(`pending wakeup: ${countWakeups(sessionsDir(root))}`);
+}
+
+function alive(pid) {
+  try { process.kill(pid, 0); return true; }
+  catch { return false; }
+}
+
+function tick({ root = ROOT, runner = spawnSync, now = new Date() } = {}) {
+  const decisions = processWakeups({ root, runner, now });
+  for (const d of decisions) {
+    if (d.action === 'resumed') console.log(`[wait] ${d.sessionId}: resumed ${d.command.join(' ')}`);
+    else if (d.action === 'backoff') console.log(`[wait] ${d.sessionId}: resume failed; backoff until ${d.notBefore}`);
+    else if (d.action === 'blocked-human-gate') console.log(`[wait] ${d.sessionId}: HUMAN_GATE; skipped`);
+    else if (d.action === 'blocked') console.log(`[wait] ${d.sessionId}: blocked (${d.reason})`);
+    else if (d.action === 'cleared-inactive') console.log(`[wait] ${d.sessionId}: inactive; wakeup cleared`);
+  }
+  return decisions;
+}
+
+function processWakeups({ root = ROOT, runner = spawnSync, now = new Date() } = {}) {
+  const dir = sessionsDir(root);
+  if (!fs.existsSync(dir)) return [];
+  const decisions = [];
+  for (const sessionId of fs.readdirSync(dir).sort()) {
+    const sessionDir = path.join(dir, sessionId);
+    if (!fs.statSync(sessionDir).isDirectory()) continue;
+    const wakeupPath = path.join(sessionDir, 'wakeup.json');
+    if (!fs.existsSync(wakeupPath)) continue;
+
+    const wakeup = readJson(wakeupPath) || {};
+    if (wakeup.not_before && new Date(wakeup.not_before) > now) {
+      decisions.push(writeDecision(sessionDir, { sessionId, action: 'waiting-backoff', notBefore: wakeup.not_before }));
+      continue;
+    }
+
+    const activePath = path.join(sessionDir, 'active');
+    if (!fs.existsSync(activePath)) {
+      removeFile(wakeupPath);
+      decisions.push(writeDecision(sessionDir, { sessionId, action: 'cleared-inactive', reason: 'active file missing' }));
+      continue;
+    }
+
+    if (fs.existsSync(path.join(sessionDir, 'HUMAN_GATE'))) {
+      removeFile(wakeupPath);
+      decisions.push(writeDecision(sessionDir, { sessionId, action: 'blocked-human-gate', reason: 'HUMAN_GATE exists' }));
+      continue;
+    }
+
+    const active = parseActiveFile(fs.readFileSync(activePath, 'utf8'));
+    const plan = buildResumePlan({ root, sessionId, active });
+    if (!plan.ok) {
+      removeFile(wakeupPath);
+      decisions.push(writeDecision(sessionDir, { sessionId, action: 'blocked', reason: plan.reason, active }));
+      continue;
+    }
+
+    const result = runner(process.execPath, plan.args, {
+      cwd: root,
+      encoding: 'utf8',
+      windowsHide: true,
+      env: { ...process.env, HARNESS_WAIT_RESUME: '1' },
+    });
+
+    if ((result.status ?? 1) === 0) {
+      removeFile(wakeupPath);
+      decisions.push(writeDecision(sessionDir, {
+        sessionId,
+        action: 'resumed',
+        command: [process.execPath, ...plan.args],
+        status: result.status ?? 0,
+        stdout: trimOutput(result.stdout),
+        stderr: trimOutput(result.stderr),
+      }));
+    } else {
+      const notBefore = new Date(now.getTime() + BACKOFF_MS).toISOString();
+      fs.writeFileSync(wakeupPath, JSON.stringify({ ...wakeup, not_before: notBefore, last_error: trimOutput(result.stderr || result.stdout) }, null, 2));
+      decisions.push(writeDecision(sessionDir, {
+        sessionId,
+        action: 'backoff',
+        command: [process.execPath, ...plan.args],
+        status: result.status ?? 1,
+        notBefore,
+        stdout: trimOutput(result.stdout),
+        stderr: trimOutput(result.stderr),
+      }));
+    }
+  }
+  return decisions;
+}
+
+function buildResumePlan({ root = ROOT, sessionId, active }) {
+  const mode = normalizeMode(active.mode);
+  const task = active.task || active.prompt || active.request;
+  if (!mode) return { ok: false, reason: 'active mode is missing or unsupported' };
+  if (!task) return { ok: false, reason: 'active task is missing' };
+
+  const cli = path.join('scripts', 'cli.js');
+  if (mode === 'ralph') {
+    const engine = active.engine || 'review';
+    if (!['review', 'legacy-review', 'run'].includes(engine)) return { ok: false, reason: `unsupported ralph engine: ${engine}` };
+    const args = [cli, 'ralph', task, '--session', sessionId, '--engine', engine];
+    if (active.max_iter || active.maxIter) args.push('--max-iter', String(active.max_iter || active.maxIter));
+    appendCommonFlags(args, active);
+    return { ok: true, args };
+  }
+
+  if (mode === 'run') {
+    const args = [cli, 'run', task, '--session', sessionId];
+    appendCommonFlags(args, active);
+    return { ok: true, args };
+  }
+
+  if (mode === 'review-cycle') {
+    const args = [cli, 'review-cycle', task, '--session', sessionId];
+    appendCommonFlags(args, active);
+    if (truthy(active.no_ship) || truthy(active.noShip)) args.push('--no-ship');
+    if (truthy(active.no_codex) || truthy(active.noCodex)) args.push('--no-codex');
+    return { ok: true, args };
+  }
+
+  return { ok: false, reason: `unsupported active mode: ${active.mode}` };
+}
+
+function appendCommonFlags(args, active) {
+  if (truthy(active.live)) args.push('--live');
+  if (truthy(active.secure)) args.push('--secure');
+}
+
+function normalizeMode(mode) {
+  if (mode === 'review') return 'review-cycle';
+  if (mode === 'review-cycle' || mode === 'run' || mode === 'ralph') return mode;
+  return null;
+}
+
+function parseActiveFile(content) {
+  const text = String(content || '').trim();
+  if (!text) return {};
+  if (text.startsWith('{')) {
+    try { return JSON.parse(text); } catch {}
+  }
+
+  const data = {};
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const idx = trimmed.indexOf(':');
+    if (idx === -1) continue;
+    const key = trimmed.slice(0, idx).trim();
+    const rawValue = trimmed.slice(idx + 1).trim();
+    data[key] = parseActiveValue(rawValue);
+  }
+  return data;
+}
+
+function parseActiveValue(value) {
+  if (value === 'true') return true;
+  if (value === 'false') return false;
+  if (/^-?\d+$/.test(value)) return Number(value);
+  if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith('[') && value.endsWith(']'))) {
+    try { return JSON.parse(value); } catch {}
+  }
+  return value;
+}
+
+function truthy(value) {
+  return value === true || value === 'true' || value === '1' || value === 1;
+}
+
+function sessionsDir(root) {
+  return path.join(root, '.harness', 'state', 'sessions');
+}
+
+function countWakeups(dir) {
+  if (!fs.existsSync(dir)) return 0;
+  return fs.readdirSync(dir)
+    .filter(s => fs.existsSync(path.join(dir, s, 'wakeup.json')))
+    .length;
+}
+
+function writeDecision(sessionDir, decision) {
+  const full = {
+    ...decision,
+    at: new Date().toISOString(),
+  };
+  fs.writeFileSync(path.join(sessionDir, 'wait-summary.json'), JSON.stringify(full, null, 2));
+  fs.appendFileSync(path.join(sessionDir, 'wait-events.jsonl'), JSON.stringify(full) + '\n');
+  return full;
+}
+
+function readJson(file) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; }
+}
+
+function removeFile(file) {
+  try { fs.unlinkSync(file); } catch {}
+}
+
+function trimOutput(value, max = 2000) {
+  const text = String(value || '').trim();
+  return text.length > max ? `${text.slice(0, max)}...` : text;
+}
+
+function isMain() {
+  return path.resolve(process.argv[1] || '') === fileURLToPath(import.meta.url);
+}
+
+export {
+  parseActiveFile,
+  buildResumePlan,
+  processWakeups,
+  tick,
+};

package/scripts/demo-external-project.js

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+// Create a tiny target project and run the repository-based NEKOWORK porting path.
+
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '..');
+
+function parseArgs(argv) {
+  const args = {
+    cleanup: false,
+    force: false,
+    profile: 'developer',
+    session: 'demo-external-project',
+    target: null,
+    task: 'demo external project smoke',
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--cleanup') args.cleanup = true;
+    else if (arg === '--force') args.force = true;
+    else if (arg === '--profile') args.profile = takeValue(argv, ++i, arg);
+    else if (arg.startsWith('--profile=')) args.profile = arg.slice('--profile='.length);
+    else if (arg === '--session') args.session = takeValue(argv, ++i, arg);
+    else if (arg.startsWith('--session=')) args.session = arg.slice('--session='.length);
+    else if (arg === '--target') args.target = takeValue(argv, ++i, arg);
+    else if (arg.startsWith('--target=')) args.target = arg.slice('--target='.length);
+    else if (arg === '--task') args.task = takeValue(argv, ++i, arg);
+    else if (arg.startsWith('--task=')) args.task = arg.slice('--task='.length);
+    else if (arg === '--help' || arg === '-h') {
+      printHelp();
+      process.exit(0);
+    } else {
+      throw new Error(`unknown option: ${arg}`);
+    }
+  }
+
+  return args;
+}
+
+function takeValue(argv, index, flag) {
+  const value = argv[index];
+  if (!value || value.startsWith('--')) throw new Error(`${flag} requires a value`);
+  return value;
+}
+
+function printHelp() {
+  console.log(`NEKOWORK external project demo
+
+Usage:
+  node scripts/demo-external-project.js [--target <dir>] [--profile developer] [--session <id>] [--task <text>] [--cleanup] [--force]
+
+What it does:
+  1. Creates a tiny target project.
+  2. Runs the porting preflight.
+  3. Applies generated harness outputs into the target.
+  4. Runs doctor in the target context.
+  5. Runs a planning-only smoke session.
+
+The demo uses mock providers by default and does not call paid APIs.
+`);
+}
+
+function ensureUsableTarget(target, force) {
+  fs.mkdirSync(target, { recursive: true });
+  const entries = fs.readdirSync(target).filter(name => name !== '.git');
+  if (entries.length && !force) {
+    throw new Error(`target is not empty: ${target}. Use --force or choose an empty directory.`);
+  }
+}
+
+function writeSampleProject(target) {
+  fs.mkdirSync(path.join(target, 'src'), { recursive: true });
+  writeFile(path.join(target, 'README.md'), [
+    '# NEKOWORK Demo Target',
+    '',
+    'This tiny project is generated by `scripts/demo-external-project.js`.',
+    '',
+  ].join('\n'));
+  writeFile(path.join(target, 'package.json'), JSON.stringify({
+    name: 'nekowork-demo-target',
+    version: '0.0.0',
+    private: true,
+    type: 'module',
+    scripts: {
+      test: 'node src/index.js',
+    },
+  }, null, 2) + '\n');
+  writeFile(path.join(target, 'src', 'index.js'), [
+    'export function greet(name = "NEKOWORK") {',
+    '  return `hello ${name}`;',
+    '}',
+    '',
+    'if (import.meta.url === `file://${process.argv[1]}`) {',
+    '  console.log(greet());',
+    '}',
+    '',
+  ].join('\n'));
+}
+
+function writeFile(file, content) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, content);
+}
+
+function runStep(label, command, args, options = {}) {
+  process.stdout.write(`${label} ... `);
+  const result = spawnSync(command, args, {
+    cwd: options.cwd || ROOT,
+    env: { ...process.env, FORCE_COLOR: '0', ...(options.env || {}) },
+    encoding: 'utf8',
+    timeout: options.timeoutMs || 120000,
+  });
+
+  if (result.status !== 0) {
+    process.stdout.write('FAIL\n');
+    const detail = [result.stdout, result.stderr].filter(Boolean).join('\n').trim();
+    throw new Error(`${label} failed with exit ${result.status}\n${detail}`);
+  }
+
+  process.stdout.write('OK\n');
+  return result;
+}
+
+function maybeInitGit(target) {
+  const result = spawnSync('git', ['init'], {
+    cwd: target,
+    encoding: 'utf8',
+    timeout: 10000,
+  });
+  return result.status === 0;
+}
+
+function assertExists(target, relativePath) {
+  const file = path.join(target, relativePath);
+  if (!fs.existsSync(file)) throw new Error(`expected output missing: ${relativePath}`);
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const target = path.resolve(args.target || fs.mkdtempSync(path.join(os.tmpdir(), 'nekowork-demo-target-')));
+
+  console.log('NEKOWORK external project demo');
+  console.log(`target : ${target}`);
+  console.log(`profile: ${args.profile}`);
+  console.log('');
+
+  try {
+    ensureUsableTarget(target, args.force);
+    writeSampleProject(target);
+    const gitReady = maybeInitGit(target);
+    console.log(`git    : ${gitReady ? 'initialized' : 'not available; continuing without git'}`);
+
+    runStep('preflight', process.execPath, [
+      path.join(ROOT, 'scripts/portability/simulate-port.js'),
+      target,
+      '--profile',
+      args.profile,
+      '--json',
+    ]);
+    runStep('install apply', process.execPath, [
+      path.join(ROOT, 'scripts/install-apply.js'),
+      '--profile',
+      args.profile,
+      '--project-root',
+      target,
+    ]);
+    runStep('doctor', process.execPath, [
+      path.join(ROOT, 'scripts/cli.js'),
+      'doctor',
+      '--project-root',
+      target,
+      '--quick',
+    ]);
+    runStep('plan smoke', process.execPath, [
+      path.join(ROOT, 'scripts/cli.js'),
+      'plan',
+      args.task,
+      '--project-root',
+      target,
+      '--session',
+      args.session,
+    ]);
+
+    for (const file of [
+      '.harness/install-state.json',
+      `.harness/state/sessions/${args.session}/handoffs/02-plan.json`,
+      '.claude/CLAUDE.md',
+      '.codex/config.toml',
+      '.cursor/hooks.json',
+      '.gemini/GEMINI.md',
+      '.opencode/config.json',
+    ]) {
+      assertExists(target, file);
+    }
+
+    console.log('');
+    console.log('Demo completed.');
+    console.log(`Inspect target: ${target}`);
+    if (args.cleanup) {
+      fs.rmSync(target, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+      console.log('Target removed because --cleanup was set.');
+    }
+  } catch (error) {
+    if (args.cleanup && fs.existsSync(target)) {
+      fs.rmSync(target, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+    }
+    throw error;
+  }
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(error.message);
+  process.exit(1);
+}

package/scripts/demo-quick-run.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+// Run the shortest NEKOWORK experience against a disposable target project.
+
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '..');
+
+function parseArgs(argv) {
+  const args = {
+    cleanup: false,
+    profile: 'quality',
+    session: 'demo-quick-run',
+    target: null,
+    task: 'demo quick run: prepare a safe quality smoke change',
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--cleanup') args.cleanup = true;
+    else if (arg === '--profile') args.profile = takeValue(argv, ++i, arg);
+    else if (arg.startsWith('--profile=')) args.profile = arg.slice('--profile='.length);
+    else if (arg === '--session') args.session = takeValue(argv, ++i, arg);
+    else if (arg.startsWith('--session=')) args.session = arg.slice('--session='.length);
+    else if (arg === '--target') args.target = takeValue(argv, ++i, arg);
+    else if (arg.startsWith('--target=')) args.target = arg.slice('--target='.length);
+    else if (arg === '--task') args.task = takeValue(argv, ++i, arg);
+    else if (arg.startsWith('--task=')) args.task = arg.slice('--task='.length);
+    else if (arg === '--help' || arg === '-h') {
+      printHelp();
+      process.exit(0);
+    } else {
+      throw new Error(`unknown option: ${arg}`);
+    }
+  }
+
+  return args;
+}
+
+function takeValue(argv, index, flag) {
+  const value = argv[index];
+  if (!value || value.startsWith('--')) throw new Error(`${flag} requires a value`);
+  return value;
+}
+
+function printHelp() {
+  console.log(`NEKOWORK quick run demo
+
+Usage:
+  node scripts/demo-quick-run.js [--profile quality] [--session <id>] [--target <dir>] [--task <text>] [--cleanup]
+
+What it does:
+  1. Creates a tiny disposable target project.
+  2. Runs doctor --quick.
+  3. Runs the compact workflow: run = work -> verify -> ship.
+  4. Prints gate status and the generated session path.
+
+The demo uses mock providers by default and does not call paid APIs.
+`);
+}
+
+function writeSampleProject(target) {
+  fs.mkdirSync(path.join(target, 'src'), { recursive: true });
+  fs.writeFileSync(path.join(target, 'README.md'), [
+    '# NEKOWORK Quick Demo Target',
+    '',
+    'Generated by `scripts/demo-quick-run.js`.',
+    '',
+  ].join('\n'));
+  fs.writeFileSync(path.join(target, 'package.json'), JSON.stringify({
+    name: 'nekowork-quick-demo-target',
+    version: '0.0.0',
+    private: true,
+    type: 'module',
+    scripts: {
+      test: 'node src/index.js',
+    },
+  }, null, 2) + '\n');
+  fs.writeFileSync(path.join(target, 'src', 'index.js'), [
+    'export function status() {',
+    '  return "ready";',
+    '}',
+    '',
+    'console.log(status());',
+    '',
+  ].join('\n'));
+}
+
+function runStep(label, args, options = {}) {
+  process.stdout.write(`${label} ... `);
+  const result = spawnSync(process.execPath, args, {
+    cwd: ROOT,
+    env: { ...process.env, FORCE_COLOR: '0', ...(options.env || {}) },
+    encoding: 'utf8',
+    timeout: options.timeoutMs || 120000,
+    windowsHide: true,
+  });
+
+  if (result.status !== 0) {
+    process.stdout.write('FAIL\n');
+    const detail = [result.stdout, result.stderr].filter(Boolean).join('\n').trim();
+    throw new Error(`${label} failed with exit ${result.status}\n${detail}`);
+  }
+
+  process.stdout.write('OK\n');
+  return result;
+}
+
+function assertExists(file) {
+  if (!fs.existsSync(file)) throw new Error(`expected output missing: ${file}`);
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const target = path.resolve(args.target || fs.mkdtempSync(path.join(os.tmpdir(), 'nekowork-quick-run-')));
+  const sessionDir = path.join(target, '.harness', 'state', 'sessions', args.session);
+
+  console.log('NEKOWORK quick run demo');
+  console.log(`target : ${target}`);
+  console.log(`session: ${args.session}`);
+  console.log(`profile: ${args.profile}`);
+  console.log('');
+
+  try {
+    fs.mkdirSync(target, { recursive: true });
+    writeSampleProject(target);
+
+    runStep('doctor', [
+      path.join(ROOT, 'scripts/cli.js'),
+      'doctor',
+      '--quick',
+      '--project-root',
+      target,
+    ]);
+    runStep('run workflow', [
+      path.join(ROOT, 'scripts/cli.js'),
+      'run',
+      args.task,
+      '--profile',
+      args.profile,
+      '--session',
+      args.session,
+      '--project-root',
+      target,
+      '--json',
+    ]);
+    runStep('gate status', [
+      path.join(ROOT, 'scripts/cli.js'),
+      'gate',
+      'status',
+      '--session',
+      args.session,
+      '--project-root',
+      target,
+      '--json',
+    ]);
+
+    for (const file of [
+      path.join(sessionDir, 'work-summary.json'),
+      path.join(sessionDir, 'verify-summary.json'),
+      path.join(sessionDir, 'ship-summary.json'),
+      path.join(sessionDir, 'run-summary.json'),
+    ]) {
+      assertExists(file);
+    }
+
+    const runSummary = JSON.parse(fs.readFileSync(path.join(sessionDir, 'run-summary.json'), 'utf8'));
+    console.log('');
+    console.log(`Demo completed: verdict=${runSummary.verdict}, ship_ready=${runSummary.ship_ready}, applied=${runSummary.applied}`);
+    console.log(`Inspect session: ${sessionDir}`);
+
+    if (args.cleanup) {
+      fs.rmSync(target, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+      console.log('Target removed because --cleanup was set.');
+    }
+  } catch (error) {
+    if (args.cleanup && fs.existsSync(target)) {
+      fs.rmSync(target, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+    }
+    throw error;
+  }
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(error.message);
+  process.exit(1);
+}