@vulcn/engine 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,218 +1,182 @@
-// session.ts
-import { z } from "zod";
-import { parse, stringify } from "yaml";
-var StepSchema = z.discriminatedUnion("type", [
-  z.object({
-    id: z.string(),
-    type: z.literal("navigate"),
-    url: z.string(),
-    timestamp: z.number()
-  }),
-  z.object({
-    id: z.string(),
-    type: z.literal("click"),
-    selector: z.string(),
-    position: z.object({ x: z.number(), y: z.number() }).optional(),
-    timestamp: z.number()
-  }),
-  z.object({
-    id: z.string(),
-    type: z.literal("input"),
-    selector: z.string(),
-    value: z.string(),
-    injectable: z.boolean().optional().default(true),
-    timestamp: z.number()
-  }),
-  z.object({
-    id: z.string(),
-    type: z.literal("keypress"),
-    key: z.string(),
-    modifiers: z.array(z.string()).optional(),
-    timestamp: z.number()
-  }),
-  z.object({
-    id: z.string(),
-    type: z.literal("scroll"),
-    selector: z.string().optional(),
-    position: z.object({ x: z.number(), y: z.number() }),
-    timestamp: z.number()
-  }),
-  z.object({
-    id: z.string(),
-    type: z.literal("wait"),
-    duration: z.number(),
-    timestamp: z.number()
-  })
-]);
-var SessionSchema = z.object({
-  version: z.string().default("1"),
-  name: z.string(),
-  recordedAt: z.string(),
-  browser: z.enum(["chromium", "firefox", "webkit"]).default("chromium"),
-  viewport: z.object({
-    width: z.number(),
-    height: z.number()
-  }),
-  startUrl: z.string(),
-  steps: 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 = parse(yaml);
-  return SessionSchema.parse(data);
-}
-function serializeSession(session) {
-  return stringify(session, { lineWidth: 0 });
-}
-
-// browser.ts
-import { chromium, firefox, webkit } from "playwright";
-import { exec } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(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 chromium.launch({
-        channel: "chrome",
-        headless
-      });
-      return { browser, channel: "chrome" };
-    } catch {
-    }
-    try {
-      const browser = await chromium.launch({
-        channel: "msedge",
-        headless
-      });
-      return { browser, channel: "msedge" };
-    } catch {
+// src/driver-manager.ts
+import { isAbsolute, resolve } from "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 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("../") || isAbsolute(nameOrPath)) {
+      const resolved = isAbsolute(nameOrPath) ? nameOrPath : resolve(process.cwd(), nameOrPath);
+      const module = await import(resolved);
+      driver = module.default || module;
+      source = "local";
+    } else {
+      const module = await import(nameOrPath);
+      driver = module.default || module;
+      source = "npm";
     }
+    this.register(driver, source);
   }
-  if (browserType === "firefox") {
-    try {
-      const browser = await 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 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 chromium.launch({
-      channel: "chrome",
-      headless: true
-    });
-    await browser.close();
-    results.systemChrome = true;
-  } catch {
-  }
-  try {
-    const browser = await 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 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 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 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
 import { readFile } from "fs/promises";
 import { existsSync } from "fs";
-import { resolve, isAbsolute } from "path";
+import { resolve as resolve2, isAbsolute as isAbsolute2 } from "path";
 import YAML from "yaml";
-import { z as z2 } from "zod";
+import { z } from "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 = z2.object({
-  version: z2.string().default("1"),
-  plugins: z2.array(
-    z2.object({
-      name: z2.string(),
-      config: z2.record(z2.unknown()).optional(),
-      enabled: z2.boolean().default(true)
+var VulcnConfigSchema = z.object({
+  version: z.string().default("1"),
+  plugins: z.array(
+    z.object({
+      name: z.string(),
+      config: z.record(z.unknown()).optional(),
+      enabled: z.boolean().default(true)
     })
   ).optional(),
-  settings: z2.object({
-    browser: z2.enum(["chromium", "firefox", "webkit"]).optional(),
-    headless: z2.boolean().optional(),
-    timeout: z2.number().optional()
+  settings: z.object({
+    browser: z.enum(["chromium", "firefox", "webkit"]).optional(),
+    headless: z.boolean().optional(),
+    timeout: z.number().optional()
   }).optional()
 });
 var PluginManager = class {
@@ -237,7 +201,7 @@ var PluginManager = class {
       ".vulcnrc.json"
     ];
     for (const path of paths) {
-      const resolved = isAbsolute(path) ? path : resolve(process.cwd(), path);
+      const resolved = isAbsolute2(path) ? path : resolve2(process.cwd(), path);
       if (existsSync(resolved)) {
         const content = await readFile(resolved, "utf-8");
         const parsed = path.endsWith(".json") ? JSON.parse(content) : YAML.parse(content);
@@ -276,8 +240,8 @@ var PluginManager = class {
     const { name, config: pluginConfig = {} } = config;
     let plugin;
     let source;
-    if (name.startsWith("./") || name.startsWith("../") || isAbsolute(name)) {
-      const resolved = isAbsolute(name) ? name : resolve(process.cwd(), name);
+    if (name.startsWith("./") || name.startsWith("../") || isAbsolute2(name)) {
+      const resolved = isAbsolute2(name) ? name : resolve2(process.cwd(), name);
       const module = await import(resolved);
       plugin = module.default || module;
       source = "local";
@@ -517,7 +481,197 @@ var PluginManager = class {
 };
 var pluginManager = new PluginManager();
 
-// recorder.ts
+// src/session.ts
+import { z as z2 } from "zod";
+import { parse, stringify } from "yaml";
+var StepSchema = z2.discriminatedUnion("type", [
+  z2.object({
+    id: z2.string(),
+    type: z2.literal("navigate"),
+    url: z2.string(),
+    timestamp: z2.number()
+  }),
+  z2.object({
+    id: z2.string(),
+    type: z2.literal("click"),
+    selector: z2.string(),
+    position: z2.object({ x: z2.number(), y: z2.number() }).optional(),
+    timestamp: z2.number()
+  }),
+  z2.object({
+    id: z2.string(),
+    type: z2.literal("input"),
+    selector: z2.string(),
+    value: z2.string(),
+    injectable: z2.boolean().optional().default(true),
+    timestamp: z2.number()
+  }),
+  z2.object({
+    id: z2.string(),
+    type: z2.literal("keypress"),
+    key: z2.string(),
+    modifiers: z2.array(z2.string()).optional(),
+    timestamp: z2.number()
+  }),
+  z2.object({
+    id: z2.string(),
+    type: z2.literal("scroll"),
+    selector: z2.string().optional(),
+    position: z2.object({ x: z2.number(), y: z2.number() }),
+    timestamp: z2.number()
+  }),
+  z2.object({
+    id: z2.string(),
+    type: z2.literal("wait"),
+    duration: z2.number(),
+    timestamp: z2.number()
+  })
+]);
+var SessionSchema = z2.object({
+  version: z2.string().default("1"),
+  name: z2.string(),
+  recordedAt: z2.string(),
+  browser: z2.enum(["chromium", "firefox", "webkit"]).default("chromium"),
+  viewport: z2.object({
+    width: z2.number(),
+    height: z2.number()
+  }),
+  startUrl: z2.string(),
+  steps: z2.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 = parse(yaml);
+  return SessionSchema.parse(data);
+}
+function serializeSession(session) {
+  return stringify(session, { lineWidth: 0 });
+}
+
+// src/browser.ts
+import { chromium, firefox, webkit } from "playwright";
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(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 chromium.launch({
+        channel: "chrome",
+        headless
+      });
+      return { browser, channel: "chrome" };
+    } catch {
+    }
+    try {
+      const browser = await chromium.launch({
+        channel: "msedge",
+        headless
+      });
+      return { browser, channel: "msedge" };
+    } catch {
+    }
+    try {
+      const browser = await 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 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 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 chromium.launch({
+      channel: "chrome",
+      headless: true
+    });
+    await browser.close();
+    results.systemChrome = true;
+  } catch {
+  }
+  try {
+    const browser = await chromium.launch({
+      channel: "msedge",
+      headless: true
+    });
+    await browser.close();
+    results.systemEdge = true;
+  } catch {
+  }
+  try {
+    const browser = await chromium.launch({ headless: true });
+    await browser.close();
+    results.playwrightChromium = true;
+  } catch {
+  }
+  try {
+    const browser = await firefox.launch({ headless: true });
+    await browser.close();
+    results.playwrightFirefox = true;
+  } catch {
+  }
+  try {
+    const browser = await 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
@@ -823,7 +977,7 @@ var Recorder = class _Recorder {
   }
 };
 
-// runner.ts
+// src/runner.ts
 var Runner = class _Runner {
   /**
    * Execute a session with security payloads from plugins
@@ -1098,6 +1252,8 @@ var Runner = class _Runner {
 };
 export {
   BrowserNotFoundError,
+  DRIVER_API_VERSION,
+  DriverManager,
   PLUGIN_API_VERSION,
   PluginManager,
   Recorder,
@@ -1106,6 +1262,7 @@ export {
   StepSchema,
   checkBrowsers,
   createSession,
+  driverManager,
   installBrowsers,
   launchBrowser,
   parseSession,