@vulcn/engine 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -27,10 +27,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// index.ts
+// src/index.ts
 var index_exports = {};
 __export(index_exports, {
   BrowserNotFoundError: () => BrowserNotFoundError,
+  DRIVER_API_VERSION: () => DRIVER_API_VERSION,
+  DriverManager: () => DriverManager,
   PLUGIN_API_VERSION: () => PLUGIN_API_VERSION,
   PluginManager: () => PluginManager,
   Recorder: () => Recorder,
@@ -39,6 +41,7 @@ __export(index_exports, {
   StepSchema: () => StepSchema,
   checkBrowsers: () => checkBrowsers,
   createSession: () => createSession,
+  driverManager: () => driverManager,
   installBrowsers: () => installBrowsers,
   launchBrowser: () => launchBrowser,
   parseSession: () => parseSession,
@@ -47,221 +50,185 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// session.ts
-var import_zod = require("zod");
-var import_yaml = require("yaml");
-var StepSchema = import_zod.z.discriminatedUnion("type", [
-  import_zod.z.object({
-    id: import_zod.z.string(),
-    type: import_zod.z.literal("navigate"),
-    url: import_zod.z.string(),
-    timestamp: import_zod.z.number()
-  }),
-  import_zod.z.object({
-    id: import_zod.z.string(),
-    type: import_zod.z.literal("click"),
-    selector: import_zod.z.string(),
-    position: import_zod.z.object({ x: import_zod.z.number(), y: import_zod.z.number() }).optional(),
-    timestamp: import_zod.z.number()
-  }),
-  import_zod.z.object({
-    id: import_zod.z.string(),
-    type: import_zod.z.literal("input"),
-    selector: import_zod.z.string(),
-    value: import_zod.z.string(),
-    injectable: import_zod.z.boolean().optional().default(true),
-    timestamp: import_zod.z.number()
-  }),
-  import_zod.z.object({
-    id: import_zod.z.string(),
-    type: import_zod.z.literal("keypress"),
-    key: import_zod.z.string(),
-    modifiers: import_zod.z.array(import_zod.z.string()).optional(),
-    timestamp: import_zod.z.number()
-  }),
-  import_zod.z.object({
-    id: import_zod.z.string(),
-    type: import_zod.z.literal("scroll"),
-    selector: import_zod.z.string().optional(),
-    position: import_zod.z.object({ x: import_zod.z.number(), y: import_zod.z.number() }),
-    timestamp: import_zod.z.number()
-  }),
-  import_zod.z.object({
-    id: import_zod.z.string(),
-    type: import_zod.z.literal("wait"),
-    duration: import_zod.z.number(),
-    timestamp: import_zod.z.number()
-  })
-]);
-var SessionSchema = import_zod.z.object({
-  version: import_zod.z.string().default("1"),
-  name: import_zod.z.string(),
-  recordedAt: import_zod.z.string(),
-  browser: import_zod.z.enum(["chromium", "firefox", "webkit"]).default("chromium"),
-  viewport: import_zod.z.object({
-    width: import_zod.z.number(),
-    height: import_zod.z.number()
-  }),
-  startUrl: import_zod.z.string(),
-  steps: import_zod.z.array(StepSchema)
-});
-function createSession(options) {
-  return {
-    version: "1",
-    name: options.name,
-    recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    browser: options.browser ?? "chromium",
-    viewport: options.viewport ?? { width: 1280, height: 720 },
-    startUrl: options.startUrl,
-    steps: []
-  };
-}
-function parseSession(yaml) {
-  const data = (0, import_yaml.parse)(yaml);
-  return SessionSchema.parse(data);
-}
-function serializeSession(session) {
-  return (0, import_yaml.stringify)(session, { lineWidth: 0 });
-}
-
-// browser.ts
-var import_playwright = require("playwright");
-var import_node_child_process = require("child_process");
-var import_node_util = require("util");
-var execAsync = (0, import_node_util.promisify)(import_node_child_process.exec);
-var BrowserNotFoundError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "BrowserNotFoundError";
-  }
-};
-async function launchBrowser(options = {}) {
-  const browserType = options.browser ?? "chromium";
-  const headless = options.headless ?? false;
-  if (browserType === "chromium") {
-    try {
-      const browser = await import_playwright.chromium.launch({
-        channel: "chrome",
-        headless
-      });
-      return { browser, channel: "chrome" };
-    } catch {
-    }
-    try {
-      const browser = await import_playwright.chromium.launch({
-        channel: "msedge",
-        headless
-      });
-      return { browser, channel: "msedge" };
-    } catch {
+// src/driver-manager.ts
+var import_node_path = require("path");
+var DriverManager = class {
+  drivers = /* @__PURE__ */ new Map();
+  defaultDriver = null;
+  /**
+   * Register a driver
+   */
+  register(driver, source = "builtin") {
+    this.validateDriver(driver);
+    this.drivers.set(driver.name, { driver, source });
+    if (this.drivers.size === 1) {
+      this.defaultDriver = driver.name;
     }
-    try {
-      const browser = await import_playwright.chromium.launch({ headless });
-      return { browser, channel: "chromium" };
-    } catch {
-      throw new BrowserNotFoundError(
-        "No Chromium browser found. Install Chrome or run: vulcn install chromium"
-      );
+  }
+  /**
+   * Load a driver from npm or local path
+   */
+  async load(nameOrPath) {
+    let driver;
+    let source;
+    if (nameOrPath.startsWith("./") || nameOrPath.startsWith("../") || (0, import_node_path.isAbsolute)(nameOrPath)) {
+      const resolved = (0, import_node_path.isAbsolute)(nameOrPath) ? nameOrPath : (0, import_node_path.resolve)(process.cwd(), nameOrPath);
+      const module2 = await import(resolved);
+      driver = module2.default || module2;
+      source = "local";
+    } else {
+      const module2 = await import(nameOrPath);
+      driver = module2.default || module2;
+      source = "npm";
     }
+    this.register(driver, source);
   }
-  if (browserType === "firefox") {
-    try {
-      const browser = await import_playwright.firefox.launch({ headless });
-      return { browser, channel: "firefox" };
-    } catch {
-      throw new BrowserNotFoundError(
-        "Firefox not found. Run: vulcn install firefox"
-      );
+  /**
+   * Get a loaded driver by name
+   */
+  get(name) {
+    return this.drivers.get(name)?.driver;
+  }
+  /**
+   * Get the default driver
+   */
+  getDefault() {
+    if (!this.defaultDriver) return void 0;
+    return this.get(this.defaultDriver);
+  }
+  /**
+   * Set the default driver
+   */
+  setDefault(name) {
+    if (!this.drivers.has(name)) {
+      throw new Error(`Driver "${name}" is not registered`);
     }
+    this.defaultDriver = name;
   }
-  if (browserType === "webkit") {
-    try {
-      const browser = await import_playwright.webkit.launch({ headless });
-      return { browser, channel: "webkit" };
-    } catch {
-      throw new BrowserNotFoundError(
-        "WebKit not found. Run: vulcn install webkit"
+  /**
+   * Check if a driver is registered
+   */
+  has(name) {
+    return this.drivers.has(name);
+  }
+  /**
+   * Get all registered drivers
+   */
+  list() {
+    return Array.from(this.drivers.values());
+  }
+  /**
+   * Get driver for a session
+   */
+  getForSession(session) {
+    const driverName = session.driver;
+    const driver = this.get(driverName);
+    if (!driver) {
+      throw new Error(
+        `Driver "${driverName}" not found. Install @vulcn/driver-${driverName} or load it manually.`
       );
     }
+    return driver;
   }
-  throw new BrowserNotFoundError(`Unknown browser type: ${browserType}`);
-}
-async function installBrowsers(browsers = ["chromium"]) {
-  const browserArg = browsers.join(" ");
-  await execAsync(`npx playwright install ${browserArg}`);
-}
-async function checkBrowsers() {
-  const results = {
-    systemChrome: false,
-    systemEdge: false,
-    playwrightChromium: false,
-    playwrightFirefox: false,
-    playwrightWebkit: false
-  };
-  try {
-    const browser = await import_playwright.chromium.launch({
-      channel: "chrome",
-      headless: true
-    });
-    await browser.close();
-    results.systemChrome = true;
-  } catch {
-  }
-  try {
-    const browser = await import_playwright.chromium.launch({
-      channel: "msedge",
-      headless: true
-    });
-    await browser.close();
-    results.systemEdge = true;
-  } catch {
+  /**
+   * Start recording with a driver
+   */
+  async startRecording(driverName, config, options = {}) {
+    const driver = this.get(driverName);
+    if (!driver) {
+      throw new Error(`Driver "${driverName}" not found`);
+    }
+    return driver.recorder.start(config, options);
   }
-  try {
-    const browser = await import_playwright.chromium.launch({ headless: true });
-    await browser.close();
-    results.playwrightChromium = true;
-  } catch {
+  /**
+   * Execute a session
+   */
+  async execute(session, pluginManager2, options = {}) {
+    const driver = this.getForSession(session);
+    const findings = [];
+    const logger = this.createLogger(driver.name);
+    const ctx = {
+      session,
+      pluginManager: pluginManager2,
+      payloads: pluginManager2.getPayloads(),
+      findings,
+      addFinding: (finding) => {
+        findings.push(finding);
+        pluginManager2.addFinding(finding);
+        options.onFinding?.(finding);
+      },
+      logger,
+      options
+    };
+    return driver.runner.execute(session, ctx);
   }
-  try {
-    const browser = await import_playwright.firefox.launch({ headless: true });
-    await browser.close();
-    results.playwrightFirefox = true;
-  } catch {
+  /**
+   * Validate driver structure
+   */
+  validateDriver(driver) {
+    if (!driver || typeof driver !== "object") {
+      throw new Error("Driver must be an object");
+    }
+    const d = driver;
+    if (typeof d.name !== "string" || !d.name) {
+      throw new Error("Driver must have a name");
+    }
+    if (typeof d.version !== "string" || !d.version) {
+      throw new Error("Driver must have a version");
+    }
+    if (!Array.isArray(d.stepTypes) || d.stepTypes.length === 0) {
+      throw new Error("Driver must define stepTypes");
+    }
+    if (!d.recorder || typeof d.recorder !== "object") {
+      throw new Error("Driver must have a recorder");
+    }
+    if (!d.runner || typeof d.runner !== "object") {
+      throw new Error("Driver must have a runner");
+    }
   }
-  try {
-    const browser = await import_playwright.webkit.launch({ headless: true });
-    await browser.close();
-    results.playwrightWebkit = true;
-  } catch {
+  /**
+   * Create a scoped logger for a driver
+   */
+  createLogger(name) {
+    const prefix = `[driver:${name}]`;
+    return {
+      debug: (msg, ...args) => console.debug(prefix, msg, ...args),
+      info: (msg, ...args) => console.info(prefix, msg, ...args),
+      warn: (msg, ...args) => console.warn(prefix, msg, ...args),
+      error: (msg, ...args) => console.error(prefix, msg, ...args)
+    };
   }
-  return results;
-}
+};
+var driverManager = new DriverManager();
+
+// src/driver-types.ts
+var DRIVER_API_VERSION = 1;
 
-// plugin-manager.ts
+// src/plugin-manager.ts
 var import_promises = require("fs/promises");
 var import_node_fs = require("fs");
-var import_node_path = require("path");
-var import_yaml2 = __toESM(require("yaml"), 1);
-var import_zod2 = require("zod");
+var import_node_path2 = require("path");
+var import_yaml = __toESM(require("yaml"), 1);
+var import_zod = require("zod");
 
-// plugin-types.ts
+// src/plugin-types.ts
 var PLUGIN_API_VERSION = 1;
 
-// plugin-manager.ts
+// src/plugin-manager.ts
 var ENGINE_VERSION = "0.2.0";
-var VulcnConfigSchema = import_zod2.z.object({
-  version: import_zod2.z.string().default("1"),
-  plugins: import_zod2.z.array(
-    import_zod2.z.object({
-      name: import_zod2.z.string(),
-      config: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-      enabled: import_zod2.z.boolean().default(true)
+var VulcnConfigSchema = import_zod.z.object({
+  version: import_zod.z.string().default("1"),
+  plugins: import_zod.z.array(
+    import_zod.z.object({
+      name: import_zod.z.string(),
+      config: import_zod.z.record(import_zod.z.unknown()).optional(),
+      enabled: import_zod.z.boolean().default(true)
     })
   ).optional(),
-  settings: import_zod2.z.object({
-    browser: import_zod2.z.enum(["chromium", "firefox", "webkit"]).optional(),
-    headless: import_zod2.z.boolean().optional(),
-    timeout: import_zod2.z.number().optional()
+  settings: import_zod.z.object({
+    browser: import_zod.z.enum(["chromium", "firefox", "webkit"]).optional(),
+    headless: import_zod.z.boolean().optional(),
+    timeout: import_zod.z.number().optional()
   }).optional()
 });
 var PluginManager = class {
@@ -286,10 +253,10 @@ var PluginManager = class {
       ".vulcnrc.json"
     ];
     for (const path of paths) {
-      const resolved = (0, import_node_path.isAbsolute)(path) ? path : (0, import_node_path.resolve)(process.cwd(), path);
+      const resolved = (0, import_node_path2.isAbsolute)(path) ? path : (0, import_node_path2.resolve)(process.cwd(), path);
       if ((0, import_node_fs.existsSync)(resolved)) {
         const content = await (0, import_promises.readFile)(resolved, "utf-8");
-        const parsed = path.endsWith(".json") ? JSON.parse(content) : import_yaml2.default.parse(content);
+        const parsed = path.endsWith(".json") ? JSON.parse(content) : import_yaml.default.parse(content);
         this.config = VulcnConfigSchema.parse(parsed);
         return this.config;
       }
@@ -325,8 +292,8 @@ var PluginManager = class {
     const { name, config: pluginConfig = {} } = config;
     let plugin;
     let source;
-    if (name.startsWith("./") || name.startsWith("../") || (0, import_node_path.isAbsolute)(name)) {
-      const resolved = (0, import_node_path.isAbsolute)(name) ? name : (0, import_node_path.resolve)(process.cwd(), name);
+    if (name.startsWith("./") || name.startsWith("../") || (0, import_node_path2.isAbsolute)(name)) {
+      const resolved = (0, import_node_path2.isAbsolute)(name) ? name : (0, import_node_path2.resolve)(process.cwd(), name);
       const module2 = await import(resolved);
       plugin = module2.default || module2;
       source = "local";
@@ -566,7 +533,197 @@ var PluginManager = class {
 };
 var pluginManager = new PluginManager();
 
-// recorder.ts
+// src/session.ts
+var import_zod2 = require("zod");
+var import_yaml2 = require("yaml");
+var StepSchema = import_zod2.z.discriminatedUnion("type", [
+  import_zod2.z.object({
+    id: import_zod2.z.string(),
+    type: import_zod2.z.literal("navigate"),
+    url: import_zod2.z.string(),
+    timestamp: import_zod2.z.number()
+  }),
+  import_zod2.z.object({
+    id: import_zod2.z.string(),
+    type: import_zod2.z.literal("click"),
+    selector: import_zod2.z.string(),
+    position: import_zod2.z.object({ x: import_zod2.z.number(), y: import_zod2.z.number() }).optional(),
+    timestamp: import_zod2.z.number()
+  }),
+  import_zod2.z.object({
+    id: import_zod2.z.string(),
+    type: import_zod2.z.literal("input"),
+    selector: import_zod2.z.string(),
+    value: import_zod2.z.string(),
+    injectable: import_zod2.z.boolean().optional().default(true),
+    timestamp: import_zod2.z.number()
+  }),
+  import_zod2.z.object({
+    id: import_zod2.z.string(),
+    type: import_zod2.z.literal("keypress"),
+    key: import_zod2.z.string(),
+    modifiers: import_zod2.z.array(import_zod2.z.string()).optional(),
+    timestamp: import_zod2.z.number()
+  }),
+  import_zod2.z.object({
+    id: import_zod2.z.string(),
+    type: import_zod2.z.literal("scroll"),
+    selector: import_zod2.z.string().optional(),
+    position: import_zod2.z.object({ x: import_zod2.z.number(), y: import_zod2.z.number() }),
+    timestamp: import_zod2.z.number()
+  }),
+  import_zod2.z.object({
+    id: import_zod2.z.string(),
+    type: import_zod2.z.literal("wait"),
+    duration: import_zod2.z.number(),
+    timestamp: import_zod2.z.number()
+  })
+]);
+var SessionSchema = import_zod2.z.object({
+  version: import_zod2.z.string().default("1"),
+  name: import_zod2.z.string(),
+  recordedAt: import_zod2.z.string(),
+  browser: import_zod2.z.enum(["chromium", "firefox", "webkit"]).default("chromium"),
+  viewport: import_zod2.z.object({
+    width: import_zod2.z.number(),
+    height: import_zod2.z.number()
+  }),
+  startUrl: import_zod2.z.string(),
+  steps: import_zod2.z.array(StepSchema)
+});
+function createSession(options) {
+  return {
+    version: "1",
+    name: options.name,
+    recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    browser: options.browser ?? "chromium",
+    viewport: options.viewport ?? { width: 1280, height: 720 },
+    startUrl: options.startUrl,
+    steps: []
+  };
+}
+function parseSession(yaml) {
+  const data = (0, import_yaml2.parse)(yaml);
+  return SessionSchema.parse(data);
+}
+function serializeSession(session) {
+  return (0, import_yaml2.stringify)(session, { lineWidth: 0 });
+}
+
+// src/browser.ts
+var import_playwright = require("playwright");
+var import_node_child_process = require("child_process");
+var import_node_util = require("util");
+var execAsync = (0, import_node_util.promisify)(import_node_child_process.exec);
+var BrowserNotFoundError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BrowserNotFoundError";
+  }
+};
+async function launchBrowser(options = {}) {
+  const browserType = options.browser ?? "chromium";
+  const headless = options.headless ?? false;
+  if (browserType === "chromium") {
+    try {
+      const browser = await import_playwright.chromium.launch({
+        channel: "chrome",
+        headless
+      });
+      return { browser, channel: "chrome" };
+    } catch {
+    }
+    try {
+      const browser = await import_playwright.chromium.launch({
+        channel: "msedge",
+        headless
+      });
+      return { browser, channel: "msedge" };
+    } catch {
+    }
+    try {
+      const browser = await import_playwright.chromium.launch({ headless });
+      return { browser, channel: "chromium" };
+    } catch {
+      throw new BrowserNotFoundError(
+        "No Chromium browser found. Install Chrome or run: vulcn install chromium"
+      );
+    }
+  }
+  if (browserType === "firefox") {
+    try {
+      const browser = await import_playwright.firefox.launch({ headless });
+      return { browser, channel: "firefox" };
+    } catch {
+      throw new BrowserNotFoundError(
+        "Firefox not found. Run: vulcn install firefox"
+      );
+    }
+  }
+  if (browserType === "webkit") {
+    try {
+      const browser = await import_playwright.webkit.launch({ headless });
+      return { browser, channel: "webkit" };
+    } catch {
+      throw new BrowserNotFoundError(
+        "WebKit not found. Run: vulcn install webkit"
+      );
+    }
+  }
+  throw new BrowserNotFoundError(`Unknown browser type: ${browserType}`);
+}
+async function installBrowsers(browsers = ["chromium"]) {
+  const browserArg = browsers.join(" ");
+  await execAsync(`npx playwright install ${browserArg}`);
+}
+async function checkBrowsers() {
+  const results = {
+    systemChrome: false,
+    systemEdge: false,
+    playwrightChromium: false,
+    playwrightFirefox: false,
+    playwrightWebkit: false
+  };
+  try {
+    const browser = await import_playwright.chromium.launch({
+      channel: "chrome",
+      headless: true
+    });
+    await browser.close();
+    results.systemChrome = true;
+  } catch {
+  }
+  try {
+    const browser = await import_playwright.chromium.launch({
+      channel: "msedge",
+      headless: true
+    });
+    await browser.close();
+    results.systemEdge = true;
+  } catch {
+  }
+  try {
+    const browser = await import_playwright.chromium.launch({ headless: true });
+    await browser.close();
+    results.playwrightChromium = true;
+  } catch {
+  }
+  try {
+    const browser = await import_playwright.firefox.launch({ headless: true });
+    await browser.close();
+    results.playwrightFirefox = true;
+  } catch {
+  }
+  try {
+    const browser = await import_playwright.webkit.launch({ headless: true });
+    await browser.close();
+    results.playwrightWebkit = true;
+  } catch {
+  }
+  return results;
+}
+
+// src/recorder.ts
 var Recorder = class _Recorder {
   /**
    * Start a new recording session
@@ -872,7 +1029,7 @@ var Recorder = class _Recorder {
   }
 };
 
-// runner.ts
+// src/runner.ts
 var Runner = class _Runner {
   /**
    * Execute a session with security payloads from plugins
@@ -1148,6 +1305,8 @@ var Runner = class _Runner {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BrowserNotFoundError,
+  DRIVER_API_VERSION,
+  DriverManager,
   PLUGIN_API_VERSION,
   PluginManager,
   Recorder,
@@ -1156,6 +1315,7 @@ var Runner = class _Runner {
   StepSchema,
   checkBrowsers,
   createSession,
+  driverManager,
   installBrowsers,
   launchBrowser,
   parseSession,