doru 1.0.0

package/dist/cli.js

@@ -0,0 +1,940 @@
+#!/usr/bin/env node
+'use strict';
+
+var zod = require('zod');
+var fs5 = require('fs');
+var path2 = require('path');
+var child_process = require('child_process');
+var net = require('net');
+var url = require('url');
+var os = require('os');
+var http = require('http');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs5__namespace = /*#__PURE__*/_interopNamespace(fs5);
+var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
+var net__namespace = /*#__PURE__*/_interopNamespace(net);
+var os__namespace = /*#__PURE__*/_interopNamespace(os);
+var http__namespace = /*#__PURE__*/_interopNamespace(http);
+
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// package.json
+var package_default;
+var init_package = __esm({
+  "package.json"() {
+    package_default = {
+      name: "doru",
+      version: "1.0.0",
+      type: "commonjs",
+      main: "dist/index.js",
+      types: "dist/index.d.ts",
+      exports: {
+        ".": {
+          types: "./dist/index.d.ts",
+          import: "./dist/index.mjs",
+          require: "./dist/index.js"
+        }
+      },
+      bin: {
+        doru: "./dist/cli.js"
+      },
+      files: [
+        "dist",
+        "README.md"
+      ],
+      scripts: {
+        build: "tsup",
+        dev: "tsup --watch",
+        "dev:ui": "vite",
+        "type-check": "tsc --noEmit",
+        storybook: "storybook dev -p 6006",
+        "build-storybook": "storybook build"
+      },
+      devDependencies: {
+        "@vitejs/plugin-react": "^5.1.2",
+        "@storybook/react-vite": "^10.1.4",
+        vite: "^7.3.0",
+        "@types/node": "^25.0.3",
+        "@types/react": "^19.2.7",
+        "@types/react-dom": "^19.2.3",
+        react: "^19.2.3",
+        "react-dom": "^19.2.3",
+        storybook: "^10.1.4",
+        tsup: "^8.5.1",
+        typescript: "^5.9.3"
+      },
+      dependencies: {
+        "@mswjs/interceptors": "^0.40.0",
+        "@tanstack/react-virtual": "^3.13.13",
+        "@microlink/react-json-view": "^1.26.1",
+        "react-resizable-panels": "^4.0.13",
+        zod: "^4.2.1"
+      },
+      engines: {
+        node: ">=22"
+      }
+    };
+  }
+});
+
+// src/cli/argument-parser.ts
+var printHelp, parseArguments, parseFileSize;
+var init_argument_parser = __esm({
+  "src/cli/argument-parser.ts"() {
+    init_package();
+    printHelp = () => {
+      console.log(`
+doru v${package_default.version}
+Minimal network traffic interceptor for Node.js
+
+USAGE:
+  doru run [options] <script> [-- <script-args>]
+  doru --ui <capture.json|jsonl>         # Explore
+  doru --ui <script> [-- <script-args>]  # Live UI (run script + UI)
+
+OPTIONS:
+  -o, --output <file>     Output file (default: ./network-capture.jsonl)
+  -f, --format <fmt>      json | jsonl (default: jsonl)
+  -c, --config <file>     Config file path (JSON or JS)
+  --ui <path>             Explorer (capture file) or Live (script path)
+  --debug                 Enable debug logs
+  --max-file-size <size>  e.g. 10MB, 500KB
+  --include-hosts <list>  Comma-separated host filters (string or /regex/)
+  --exclude-hosts <list>  Comma-separated host filters
+  --include-paths <list>  Comma-separated regex patterns
+  --exclude-paths <list>  Comma-separated regex patterns
+  --methods <list>        Comma-separated HTTP methods (e.g. GET,POST)
+  --min-status <code>     Minimum status code
+  --max-status <code>     Maximum status code
+  -h, --help              Show help
+  -v, --version           Show version
+
+EXAMPLES:
+  doru run server.js
+  doru run app.mjs -- --port 3000
+  doru --ui capture.jsonl
+  doru --ui app.mjs -- --port 8080   # Live UI
+`);
+    };
+    parseArguments = (args) => {
+      const opts = {};
+      const sep = args.indexOf("--");
+      let doruArgs = args;
+      if (sep !== -1) {
+        doruArgs = args.slice(0, sep);
+        opts.scriptArgs = args.slice(sep + 1);
+      }
+      if (doruArgs[0] === "run") doruArgs = doruArgs.slice(1);
+      const takeNext = (i) => {
+        const n = doruArgs[i + 1];
+        if (!n || n.startsWith("-")) throw new Error(`Missing value for ${doruArgs[i]}`);
+        return n;
+      };
+      const setNumber = (s, flag) => {
+        const v = Number.parseInt(s);
+        if (Number.isNaN(v)) throw new Error(`${flag} must be a number`);
+        return v;
+      };
+      for (let i = 0; i < doruArgs.length; i++) {
+        const a = doruArgs[i];
+        switch (a) {
+          case "-h":
+          case "--help": {
+            opts.help = true;
+            break;
+          }
+          case "-v":
+          case "--version": {
+            opts.version = true;
+            break;
+          }
+          case "-o":
+          case "--output": {
+            opts.output = takeNext(i);
+            i++;
+            break;
+          }
+          case "-f":
+          case "--format": {
+            const n = takeNext(i);
+            if (n !== "json" && n !== "jsonl") throw new Error("--format must be json or jsonl");
+            opts.format = n;
+            i++;
+            break;
+          }
+          case "-c":
+          case "--config": {
+            opts.config = takeNext(i);
+            i++;
+            break;
+          }
+          case "--ui": {
+            const n = takeNext(i);
+            opts.ui = n;
+            if (/\.(json|jsonl)$/i.test(n)) opts.uiMode = "explorer";
+            else {
+              opts.uiMode = "live";
+              if (!opts.script) opts.script = n;
+            }
+            i++;
+            break;
+          }
+          case "--debug": {
+            opts.debug = true;
+            break;
+          }
+          case "--max-file-size": {
+            opts.maxFileSize = takeNext(i);
+            i++;
+            break;
+          }
+          case "--include-hosts": {
+            opts.includeHosts = takeNext(i).split(",").map((s) => s.trim());
+            i++;
+            break;
+          }
+          case "--exclude-hosts": {
+            opts.excludeHosts = takeNext(i).split(",").map((s) => s.trim());
+            i++;
+            break;
+          }
+          case "--include-paths": {
+            opts.includePaths = takeNext(i).split(",").map((s) => s.trim());
+            i++;
+            break;
+          }
+          case "--exclude-paths": {
+            opts.excludePaths = takeNext(i).split(",").map((s) => s.trim());
+            i++;
+            break;
+          }
+          case "--methods": {
+            opts.methods = takeNext(i).split(",").map((s) => s.trim().toUpperCase());
+            i++;
+            break;
+          }
+          case "--min-status": {
+            const v = setNumber(takeNext(i), "--min-status");
+            if (v < 100 || v > 599) throw new Error("--min-status must be 100..599");
+            opts.minStatusCode = v;
+            i++;
+            break;
+          }
+          case "--max-status": {
+            const v = setNumber(takeNext(i), "--max-status");
+            if (v < 100 || v > 599) throw new Error("--max-status must be 100..599");
+            opts.maxStatusCode = v;
+            i++;
+            break;
+          }
+          default: {
+            if (a.startsWith("-")) throw new Error(`Unknown option: ${a}`);
+            if (opts.script) throw new Error(`Unexpected argument: ${a}`);
+            opts.script = a;
+          }
+        }
+      }
+      return opts;
+    };
+    parseFileSize = (size) => {
+      const m = /^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/i.exec(size.trim());
+      if (!m) throw new Error(`Invalid size: ${size}. Use 10MB, 500KB, etc.`);
+      const value = Number.parseFloat(m[1]);
+      const unit = (m[2] || "b").toLowerCase();
+      const mul = { b: 1, kb: 1024, mb: 1024 * 1024, gb: 1024 * 1024 * 1024 };
+      return Math.floor(value * mul[unit]);
+    };
+  }
+});
+var statusCodesSchema, filtersSchema, performanceSchema, doruConfigSchema, deepMerge, envDebugDefault, normalizeConfig, createDefaultConfig;
+var init_config = __esm({
+  "src/core/config.ts"() {
+    statusCodesSchema = zod.z.object({
+      min: zod.z.number().int().min(100).max(599).nullable().default(null),
+      max: zod.z.number().int().min(100).max(599).nullable().default(null)
+    }).refine((s) => s.min === null || s.max === null || s.min <= s.max, {
+      message: "filters.statusCodes.min must be <= filters.statusCodes.max"
+    });
+    filtersSchema = zod.z.object({
+      includeHosts: zod.z.array(zod.z.string()).default([]),
+      excludeHosts: zod.z.array(zod.z.string()).default([]),
+      includePaths: zod.z.array(zod.z.string()).default([]),
+      excludePaths: zod.z.array(zod.z.string()).default([]),
+      methods: zod.z.array(zod.z.string()).default([]),
+      statusCodes: statusCodesSchema.default({ min: null, max: null }),
+      minSize: zod.z.number().int().nullable().default(null),
+      maxSize: zod.z.number().int().nullable().default(null)
+    });
+    performanceSchema = zod.z.object({
+      bufferSize: zod.z.number().int().positive().default(1024),
+      flushInterval: zod.z.number().int().positive().default(1e3),
+      compression: zod.z.boolean().default(false)
+      // minimal core: compression disabled by default
+    });
+    doruConfigSchema = zod.z.object({
+      enabled: zod.z.boolean().default(true),
+      outputFile: zod.z.string().default("./network-capture.jsonl"),
+      format: zod.z.enum(["json", "jsonl"]).default("jsonl"),
+      maxFileSize: zod.z.number().int().positive().default(10 * 1024 * 1024),
+      // 10MB
+      filters: filtersSchema.default({
+        includeHosts: [],
+        excludeHosts: [],
+        includePaths: [],
+        excludePaths: [],
+        methods: [],
+        statusCodes: { min: null, max: null },
+        minSize: null,
+        maxSize: null
+      }),
+      performance: performanceSchema.default({
+        bufferSize: 1024,
+        flushInterval: 1e3,
+        compression: false
+      }),
+      debug: zod.z.boolean().default(false)
+    });
+    deepMerge = (a, b) => {
+      const out = { ...a };
+      for (const [k, v] of Object.entries(b || {})) {
+        if (v === void 0) continue;
+        const key = k;
+        const av = a[key];
+        if (Array.isArray(v)) {
+          out[key] = v.slice();
+        } else if (v && typeof v === "object" && av && typeof av === "object" && !Array.isArray(av)) {
+          out[key] = deepMerge(
+            av,
+            v
+          );
+        } else out[key] = v;
+      }
+      return out;
+    };
+    envDebugDefault = () => {
+      const v = process.env.DORU_DEBUG;
+      if (v === "true") return true;
+      if (v === "false") return false;
+      const legacy = process.env.NETPEEK_DEBUG;
+      if (legacy === "true") return true;
+      if (legacy === "false") return false;
+      return false;
+    };
+    normalizeConfig = (c) => {
+      return {
+        ...c,
+        filters: {
+          ...c.filters,
+          methods: c.filters.methods.map((m) => m.toUpperCase())
+        }
+      };
+    };
+    createDefaultConfig = (user = {}) => {
+      const defaults = doruConfigSchema.parse({});
+      const merged = deepMerge(defaults, { ...user, debug: user.debug ?? envDebugDefault() });
+      const parsed = doruConfigSchema.parse(merged);
+      return normalizeConfig(parsed);
+    };
+  }
+});
+var loadConfig, buildConfig;
+var init_config_loader = __esm({
+  "src/cli/config-loader.ts"() {
+    init_config();
+    init_argument_parser();
+    loadConfig = async (configPath) => {
+      const candidates = configPath ? [configPath] : ["doru.config.json", "doru.config.js", ".dorurc.json", ".dorurc.js", "package.json"];
+      for (const file of candidates) {
+        try {
+          if (!fs5__namespace.existsSync(file)) continue;
+          if (file.endsWith(".json")) {
+            const txt = fs5__namespace.readFileSync(file, "utf8");
+            const parsed = JSON.parse(txt);
+            if (path2__namespace.basename(file) === "package.json") return parsed.doru || {};
+            return parsed;
+          }
+          if (file.endsWith(".js")) {
+            const full = path2__namespace.resolve(file);
+            const mod = await import(full);
+            const obj = mod;
+            const hasDefault = obj && typeof obj === "object" && "default" in obj;
+            return hasDefault ? obj.default : obj;
+          }
+        } catch (error) {
+          if (configPath) {
+            const msg = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to load config file ${file}: ${msg}`);
+          }
+        }
+      }
+      return {};
+    };
+    buildConfig = (opts, fileCfg) => {
+      const base = {
+        outputFile: opts.output ?? fileCfg.outputFile ?? "./network-capture.jsonl",
+        format: opts.format ?? fileCfg.format ?? "jsonl",
+        maxFileSize: fileCfg.maxFileSize ?? 10 * 1024 * 1024,
+        filters: {
+          includeHosts: opts.includeHosts ?? fileCfg.filters?.includeHosts ?? [],
+          excludeHosts: opts.excludeHosts ?? fileCfg.filters?.excludeHosts ?? [],
+          includePaths: opts.includePaths ?? fileCfg.filters?.includePaths ?? [],
+          excludePaths: opts.excludePaths ?? fileCfg.filters?.excludePaths ?? [],
+          methods: opts.methods ?? fileCfg.filters?.methods ?? [],
+          statusCodes: {
+            min: opts.minStatusCode ?? fileCfg.filters?.statusCodes?.min ?? null,
+            max: opts.maxStatusCode ?? fileCfg.filters?.statusCodes?.max ?? null
+          },
+          minSize: fileCfg.filters?.minSize ?? null,
+          maxSize: fileCfg.filters?.maxSize ?? null
+        },
+        performance: fileCfg.performance ?? {
+          bufferSize: 1024,
+          flushInterval: 1e3,
+          compression: false
+        },
+        debug: opts.debug ?? fileCfg.debug ?? false,
+        enabled: true
+      };
+      if (opts.maxFileSize) base.maxFileSize = parseFileSize(opts.maxFileSize);
+      return createDefaultConfig(base);
+    };
+  }
+});
+var tryRead, getPackageJsonType, detectModuleType;
+var init_module_detection = __esm({
+  "src/core/module-detection.ts"() {
+    tryRead = (filePath) => {
+      try {
+        if (!fs5__namespace.existsSync(filePath)) return null;
+        return fs5__namespace.readFileSync(filePath, "utf8");
+      } catch {
+        return null;
+      }
+    };
+    getPackageJsonType = (filePath) => {
+      let dir = path2__namespace.dirname(path2__namespace.resolve(filePath));
+      while (true) {
+        const parent = path2__namespace.dirname(dir);
+        const pj = path2__namespace.join(dir, "package.json");
+        try {
+          if (fs5__namespace.existsSync(pj)) {
+            const json = JSON.parse(fs5__namespace.readFileSync(pj, "utf8"));
+            if (json.type === "module") return "module";
+            if (json.type === "commonjs") return "commonjs";
+            return "commonjs";
+          }
+        } catch {
+        }
+        if (parent === dir) break;
+        dir = parent;
+      }
+      return null;
+    };
+    detectModuleType = (filePath) => {
+      const ext = path2__namespace.extname(filePath);
+      if (ext === ".mjs") return { type: "esm", confidence: "high", reason: "File extension .mjs" };
+      if (ext === ".cjs") return { type: "cjs", confidence: "high", reason: "File extension .cjs" };
+      if (ext === ".js") {
+        const t = getPackageJsonType(filePath);
+        if (t === "module") {
+          return { type: "esm", confidence: "high", reason: 'package.json has "type":"module"' };
+        }
+        if (t === "commonjs") {
+          return { type: "cjs", confidence: "high", reason: 'package.json has "type":"commonjs"' };
+        }
+        const content = tryRead(filePath);
+        if (content !== null) {
+          const hasESM = /(^|\s)import\s+|(^|\s)export\s+/m.test(content);
+          const hasCJS = /\brequire\s*\(|\bmodule\.exports\b|\bexports\./m.test(content);
+          if (hasESM && !hasCJS) return { type: "esm", confidence: "medium", reason: "ESM syntax only" };
+          if (hasCJS && !hasESM) return { type: "cjs", confidence: "medium", reason: "CommonJS syntax only" };
+          if (hasESM && hasCJS) {
+            return { type: "cjs", confidence: "low", reason: "Mixed syntax; defaulting to CJS" };
+          }
+        }
+      }
+      return { type: "cjs", confidence: "medium", reason: "Default (no explicit type)" };
+    };
+  }
+});
+var getFilename, getDirname, openBrowser, findPort, isDevMode, findUIAsset;
+var init_utils = __esm({
+  "src/cli/utils.ts"() {
+    getFilename = () => {
+      return typeof __filename === "undefined" ? url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.js', document.baseURI).href))) : __filename;
+    };
+    getDirname = () => {
+      return typeof __dirname === "undefined" ? path2__namespace.dirname(getFilename()) : __dirname;
+    };
+    openBrowser = (url) => {
+      try {
+        if (process.platform === "darwin") {
+          child_process.spawn("open", [url], { stdio: "ignore", detached: true }).unref();
+        } else if (process.platform === "win32") {
+          child_process.spawn("cmd", ["/c", "start", "", url], { stdio: "ignore", detached: true }).unref();
+        } else {
+          child_process.spawn("xdg-open", [url], { stdio: "ignore", detached: true }).unref();
+        }
+      } catch {
+      }
+    };
+    findPort = (start = 8333, attempts = 10) => new Promise((resolve6, reject) => {
+      let port = start;
+      let tried = 0;
+      const tryNext = () => {
+        const srv = net__namespace.createServer();
+        srv.unref();
+        srv.once("error", (e) => {
+          if (e.code === "EADDRINUSE" && ++tried < attempts) {
+            port++;
+            tryNext();
+          } else {
+            reject(e);
+          }
+        });
+        srv.listen(port, "127.0.0.1", () => {
+          srv.close(() => resolve6(port));
+        });
+      };
+      tryNext();
+    });
+    isDevMode = (dirname3) => {
+      return dirname3.includes("src/cli") || dirname3.includes("src\\cli");
+    };
+    findUIAsset = (dirname3) => {
+      const prodPath = path2__namespace.join(dirname3, "ui", "app.js");
+      if (fs5__namespace.existsSync(prodPath)) return prodPath;
+      const devPath = path2__namespace.resolve(dirname3, "../../dist/ui/app.js");
+      if (fs5__namespace.existsSync(devPath)) return devPath;
+      return null;
+    };
+  }
+});
+var __dirname_shim, writeTemp, genCjsPreload, genEsmPreload, findLibraryEntry, cleanupRegistered, pendingCleanupFiles, registerProcessCleanup, preparePreloadArtifacts, handle, runCJS, runESM, runScript;
+var init_script_executor = __esm({
+  "src/cli/script-executor.ts"() {
+    init_module_detection();
+    init_utils();
+    __dirname_shim = getDirname();
+    writeTemp = (name, content) => {
+      const p = path2__namespace.join(os__namespace.tmpdir(), `doru-${process.pid}-${name}`);
+      fs5__namespace.writeFileSync(p, content, "utf8");
+      return p;
+    };
+    genCjsPreload = () => `try {
+  const b64 = process.env.DORU_CONFIG_BASE64 || '';
+  const entry = process.env.DORU_ENTRY_CJS;
+  if (!entry) throw new Error('DORU_ENTRY_CJS not set');
+  const cfg = b64 ? JSON.parse(Buffer.from(b64, 'base64').toString('utf8')) : {};
+  const doru = require(entry);
+  const api = doru.createInterceptor(cfg);
+  globalThis.__doru__ = api;
+  api.start();
+  process.on('exit', () => { try { api.stop(); } catch {} });
+} catch (e) {
+  console.error('doru preload failed:', e && e.message ? e.message : e);
+}`;
+    genEsmPreload = () => `import { createRequire } from 'module';
+try {
+  const b64 = process.env.DORU_CONFIG_BASE64 || '';
+  const entry = process.env.DORU_ENTRY_CJS;
+  if (!entry) throw new Error('DORU_ENTRY_CJS not set');
+  const cfg = b64 ? JSON.parse(Buffer.from(b64, 'base64').toString('utf8')) : {};
+  const require = createRequire(import.meta.url);
+  const doru = require(entry);
+  const api = doru.createInterceptor(cfg);
+  globalThis.__doru__ = api;
+  api.start();
+  process.on('exit', () => { try { api.stop(); } catch {} });
+} catch (e) {
+  console.error('doru preload failed:', e && e.message ? e.message : e);
+}`;
+    findLibraryEntry = () => {
+      const prodEntry = path2__namespace.resolve(__dirname_shim, "index.js");
+      if (fs5__namespace.existsSync(prodEntry)) return prodEntry;
+      const devEntry = path2__namespace.resolve(__dirname_shim, "../../dist/index.js");
+      if (fs5__namespace.existsSync(devEntry)) return devEntry;
+      throw new Error(
+        `doru library not found. Checked:
+  - ${prodEntry}
+  - ${devEntry}
+Run "bun run build" first.`
+      );
+    };
+    cleanupRegistered = false;
+    pendingCleanupFiles = [];
+    registerProcessCleanup = (files) => {
+      pendingCleanupFiles = files;
+      if (cleanupRegistered) return;
+      cleanupRegistered = true;
+      const doCleanup = () => {
+        for (const f of pendingCleanupFiles) {
+          try {
+            fs5__namespace.unlinkSync(f);
+          } catch {
+          }
+        }
+        pendingCleanupFiles = [];
+      };
+      process.on("exit", doCleanup);
+      process.on("SIGTERM", () => {
+        doCleanup();
+        process.exit(143);
+      });
+      process.on("uncaughtException", (err) => {
+        doCleanup();
+        console.error("Uncaught exception:", err);
+        process.exit(1);
+      });
+    };
+    preparePreloadArtifacts = () => {
+      const entryCjs = findLibraryEntry();
+      const cjs = writeTemp("preload.cjs", genCjsPreload());
+      const esm = writeTemp("preload.mjs", genEsmPreload());
+      const tempFiles = [cjs, esm];
+      registerProcessCleanup(tempFiles);
+      return { cjs, esm, tempFiles, entryCjs };
+    };
+    handle = (child, temps) => new Promise((resolve6, reject) => {
+      let cleaned = false;
+      const cleanup = () => {
+        if (cleaned) return;
+        cleaned = true;
+        for (const f of temps) {
+          try {
+            fs5__namespace.unlinkSync(f);
+          } catch {
+          }
+        }
+        pendingCleanupFiles = pendingCleanupFiles.filter((f) => !temps.includes(f));
+      };
+      child.on("close", (code) => {
+        cleanup();
+        if (code === 0) resolve6();
+        else reject(new Error(`Script exited with code ${code}`));
+      });
+      child.on("error", (err) => {
+        cleanup();
+        reject(err);
+      });
+      process.on("SIGINT", () => {
+        if (cleaned) return;
+        console.log("\nReceived SIGINT, terminating...");
+        cleanup();
+        child.kill("SIGTERM");
+        setTimeout(() => {
+          child.kill("SIGKILL");
+        }, 1e3);
+      });
+    });
+    runCJS = async (script, env, pl, scriptArgs) => {
+      const args = ["--require", pl.cjs, script];
+      if (scriptArgs?.length) args.push(...scriptArgs);
+      const child = child_process.spawn("node", args, { stdio: "inherit", env });
+      await handle(child, pl.tempFiles);
+    };
+    runESM = async (script, env, pl, scriptArgs) => {
+      const args = ["--import", pl.esm, script];
+      if (scriptArgs?.length) args.push(...scriptArgs);
+      const child = child_process.spawn("node", args, { stdio: "inherit", env });
+      await handle(child, pl.tempFiles);
+    };
+    runScript = async (script, config, scriptArgs) => {
+      const detection = detectModuleType(script);
+      const artifacts = preparePreloadArtifacts();
+      const env = {
+        ...process.env,
+        DORU_CONFIG_BASE64: Buffer.from(JSON.stringify(config), "utf8").toString("base64"),
+        DORU_ENTRY_CJS: artifacts.entryCjs
+      };
+      if (detection.type === "esm") {
+        await runESM(script, env, artifacts, scriptArgs);
+      } else {
+        await runCJS(script, env, artifacts, scriptArgs);
+      }
+    };
+  }
+});
+var VITE_DEV_PORT, serveFile, findUIFile, createUIServer, startServer, createShutdownHandler;
+var init_server = __esm({
+  "src/cli/server.ts"() {
+    init_utils();
+    VITE_DEV_PORT = 5173;
+    serveFile = (res, filePath, contentType) => {
+      try {
+        if (!fs5__namespace.existsSync(filePath)) return false;
+        const content = fs5__namespace.readFileSync(filePath, "utf8");
+        res.writeHead(200, { "Content-Type": contentType, "Cache-Control": "no-cache" });
+        res.end(content);
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    findUIFile = (dirname3, filename) => {
+      const prodPath = path2__namespace.join(dirname3, "ui", filename);
+      if (fs5__namespace.existsSync(prodPath)) return prodPath;
+      const devPath = path2__namespace.resolve(dirname3, "../../src/ui", filename);
+      if (fs5__namespace.existsSync(devPath)) return devPath;
+      return null;
+    };
+    createUIServer = (config) => {
+      const { captureFile, dirname: dirname3 } = config;
+      const devMode = isDevMode(dirname3);
+      return http__namespace.createServer((req, res) => {
+        if (!req.url) return;
+        if (devMode && (req.url === "/" || req.url.startsWith("/ui/") || req.url.startsWith("/src/"))) {
+          res.writeHead(302, { Location: `http://localhost:${VITE_DEV_PORT}${req.url}` });
+          res.end();
+          return;
+        }
+        if (req.url === "/") {
+          const htmlPath = findUIFile(dirname3, "index.html");
+          if (!htmlPath || !serveFile(res, htmlPath, "text/html; charset=utf-8")) {
+            res.writeHead(404, { "Content-Type": "text/plain" });
+            res.end("UI not found. Run 'bun run build' first.");
+          }
+          return;
+        }
+        if (req.url === "/styles.css") {
+          const cssPath = findUIFile(dirname3, "styles.css");
+          if (!cssPath || !serveFile(res, cssPath, "text/css; charset=utf-8")) {
+            res.writeHead(404, { "Content-Type": "text/plain" });
+            res.end("CSS not found");
+          }
+          return;
+        }
+        if (req.url === "/favicon.svg" || req.url === "/favicon-paused.svg") {
+          const filename = req.url.slice(1);
+          const faviconPath = findUIFile(dirname3, filename);
+          if (!faviconPath || !serveFile(res, faviconPath, "image/svg+xml")) {
+            res.writeHead(404, { "Content-Type": "text/plain" });
+            res.end("Favicon not found");
+          }
+          return;
+        }
+        if (req.url === "/app.js") {
+          const jsPath = findUIAsset(dirname3);
+          if (!jsPath || !serveFile(res, jsPath, "text/javascript; charset=utf-8")) {
+            res.writeHead(404, { "Content-Type": "text/plain" });
+            res.end("UI bundle not found. Run 'bun run build' first.");
+          }
+          return;
+        }
+        if (req.url === "/api/capture") {
+          try {
+            if (!fs5__namespace.existsSync(captureFile)) {
+              res.writeHead(200, { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" });
+              res.end("[]");
+              return;
+            }
+            const data = fs5__namespace.readFileSync(captureFile, "utf8");
+            res.writeHead(200, { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" });
+            res.end(data);
+          } catch {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Failed to read capture file" }));
+          }
+          return;
+        }
+        if (req.url?.startsWith("/api/capture/stream")) {
+          try {
+            const url = new URL(req.url, `http://${req.headers.host}`);
+            let offset = Number.parseInt(url.searchParams.get("offset") || "0");
+            if (!fs5__namespace.existsSync(captureFile)) {
+              res.writeHead(200, {
+                "Content-Type": "application/json",
+                "Access-Control-Allow-Origin": "*"
+              });
+              res.end(JSON.stringify({ offset: 0, size: 0, generation: 0, data: "" }));
+              return;
+            }
+            const stats = fs5__namespace.statSync(captureFile);
+            const fileSize = stats.size;
+            const generation = stats.ino;
+            if (offset > fileSize) {
+              offset = 0;
+            }
+            if (offset >= fileSize) {
+              res.writeHead(200, {
+                "Content-Type": "application/json",
+                "Access-Control-Allow-Origin": "*"
+              });
+              res.end(JSON.stringify({ offset: fileSize, size: fileSize, generation, data: "" }));
+              return;
+            }
+            const fd = fs5__namespace.openSync(captureFile, "r");
+            let data;
+            try {
+              const buffer = Buffer.alloc(fileSize - offset);
+              fs5__namespace.readSync(fd, buffer, 0, buffer.length, offset);
+              data = buffer.toString("utf8");
+            } finally {
+              fs5__namespace.closeSync(fd);
+            }
+            res.writeHead(200, {
+              "Content-Type": "application/json",
+              "Access-Control-Allow-Origin": "*"
+            });
+            res.end(JSON.stringify({ offset: fileSize, size: fileSize, generation, data }));
+          } catch {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Failed to read capture file" }));
+          }
+          return;
+        }
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not Found");
+      });
+    };
+    startServer = async (server, port) => {
+      await new Promise((resolve6) => {
+        server.listen(port, resolve6);
+      });
+      return `http://localhost:${port}`;
+    };
+    createShutdownHandler = (server) => {
+      let shutting = false;
+      return () => {
+        if (shutting) return;
+        shutting = true;
+        console.log("\n\u{1F44B} Shutting down UI...");
+        server.close(() => {
+          process.exit(0);
+        });
+        setTimeout(() => {
+          process.exit(0);
+        }, 2e3);
+      };
+    };
+  }
+});
+var require_cli = __commonJS({
+  "src/cli.ts"() {
+    init_package();
+    init_argument_parser();
+    init_config_loader();
+    init_script_executor();
+    init_server();
+    init_utils();
+    var __dirname_shim2 = getDirname();
+    var runScriptWithLiveUI = async (script, cfg, args) => {
+      const port = await findPort(8333, 10);
+      const server = createUIServer({ captureFile: cfg.outputFile, dirname: __dirname_shim2 });
+      const devMode = isDevMode(__dirname_shim2);
+      const url = await startServer(server, port);
+      if (devMode) {
+        console.log(`\u{1F310} doru API at ${url}`);
+        console.log(`\u{1F525} Dev mode: run 'bun run dev:ui' and open http://localhost:5173`);
+      } else {
+        console.log(`\u{1F310} doru Live UI at ${url}`);
+        openBrowser(url);
+      }
+      console.log(`\u{1F3AF} Script: ${script}`);
+      console.log(`\u{1F4C1} Capture: ${cfg.outputFile}`);
+      console.log("Press Ctrl+C to stop");
+      const stop = createShutdownHandler(server);
+      process.on("SIGINT", stop);
+      process.on("SIGTERM", stop);
+      try {
+        await runScript(script, cfg, args);
+        console.log("\n\u2705 Script finished. UI still running \u2014 Ctrl+C to exit.");
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.log("\n\u274C Script exited with error:", msg);
+        console.log("UI still running \u2014 Ctrl+C to exit.");
+      }
+      await new Promise(() => {
+      });
+    };
+    var startExplorer = async (captureFile) => {
+      const port = await findPort(8333, 10);
+      const server = createUIServer({ captureFile, dirname: __dirname_shim2 });
+      const devMode = isDevMode(__dirname_shim2);
+      const url = await startServer(server, port);
+      if (devMode) {
+        console.log(`\u{1F310} doru API at ${url}`);
+        console.log(`\u{1F525} Dev mode: run 'bun run dev:ui' and open http://localhost:5173`);
+      } else {
+        console.log(`\u{1F310} doru UI at ${url}`);
+        openBrowser(url);
+      }
+      console.log(`\u{1F4C1} Exploring: ${path2__namespace.resolve(captureFile)}`);
+      console.log("Press Ctrl+C to stop");
+      process.on("SIGINT", createShutdownHandler(server));
+    };
+    var main = async () => {
+      try {
+        const argv = process.argv.slice(2);
+        const opts = parseArguments(argv);
+        if (opts.help) {
+          printHelp();
+          return;
+        }
+        if (opts.version) {
+          console.log(package_default.version);
+          return;
+        }
+        if (opts.ui && opts.uiMode === "explorer") {
+          await startExplorer(opts.ui);
+          return;
+        }
+        if (!opts.script) {
+          console.error("Error: No script specified. Use --help.");
+          process.exitCode = 1;
+          return;
+        }
+        if (!fs5__namespace.existsSync(opts.script)) {
+          console.error(`Error: Script not found: ${opts.script}`);
+          process.exitCode = 1;
+          return;
+        }
+        const fileConfig = await loadConfig(opts.config);
+        const cfg = buildConfig(opts, fileConfig);
+        if (opts.uiMode === "live") {
+          await runScriptWithLiveUI(opts.script, cfg, opts.scriptArgs);
+        } else {
+          await runScript(opts.script, cfg, opts.scriptArgs);
+        }
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error("Error:", msg);
+        process.exitCode = 1;
+      }
+    };
+    main().catch((error) => {
+      console.error("Fatal:", error);
+      process.exitCode = 1;
+    });
+  }
+});
+var cli = require_cli();
+
+module.exports = cli;
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map