validpilot-oss 1.1.0

package/core/artifacts.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { loadConfig } = require('./config');
+
+function ensureDir(dirPath = loadConfig().artifactDir) {
+  fs.mkdirSync(dirPath, { recursive: true });
+  return dirPath;
+}
+
+function listArtifacts(rootDir = loadConfig().artifactDir) {
+  if (!fs.existsSync(rootDir)) return [];
+  const entries = [];
+  for (const name of fs.readdirSync(rootDir)) {
+    const fullPath = path.join(rootDir, name);
+    const stat = fs.statSync(fullPath);
+    if (stat.isDirectory()) {
+      entries.push(...listArtifacts(fullPath));
+    } else {
+      entries.push({ path: fullPath, size: stat.size, mtimeMs: stat.mtimeMs });
+    }
+  }
+  return entries.sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+
+function cleanupOld(rootDir = loadConfig().artifactDir, retentionDays = 7) {
+  if (!fs.existsSync(rootDir)) return { removed: 0, files: [] };
+  const cutoff = Date.now() - Number(retentionDays) * 24 * 60 * 60 * 1000;
+  const removed = [];
+  for (const artifact of listArtifacts(rootDir)) {
+    if (artifact.mtimeMs < cutoff) {
+      fs.unlinkSync(artifact.path);
+      removed.push(artifact.path);
+    }
+  }
+  return { removed: removed.length, files: removed };
+}
+
+module.exports = {
+  ensureDir,
+  listArtifacts,
+  cleanupOld
+};

package/core/config.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const path = require('path');
+
+const DEFAULT_CONFIG = {
+  artifactDir: path.join(__dirname, '..', 'artifacts'),
+  redaction: true,
+  allowlist: ['localhost', '127.0.0.1', '::1'],
+  blockedHosts: [],
+  headless: true
+};
+
+function parseList(value) {
+  if (!value) return [];
+  return String(value).split(',').map(item => item.trim()).filter(Boolean);
+}
+
+function parseBool(value, fallback) {
+  if (value === undefined) return fallback;
+  return !/^(false|0|no)$/i.test(String(value));
+}
+
+function loadConfig(overrides = {}) {
+  const envConfig = {
+    artifactDir: process.env.VALIDPILOT_ARTIFACT_DIR || DEFAULT_CONFIG.artifactDir,
+    redaction: parseBool(process.env.VALIDPILOT_REDACTION, DEFAULT_CONFIG.redaction),
+    allowlist: parseList(process.env.VALIDPILOT_ALLOWLIST).length ? parseList(process.env.VALIDPILOT_ALLOWLIST) : DEFAULT_CONFIG.allowlist,
+    blockedHosts: parseList(process.env.VALIDPILOT_BLOCKED_HOSTS),
+    headless: parseBool(process.env.VALIDPILOT_HEADLESS, DEFAULT_CONFIG.headless)
+  };
+  return { ...DEFAULT_CONFIG, ...envConfig, ...overrides };
+}
+
+module.exports = {
+  DEFAULT_CONFIG,
+  loadConfig
+};

package/core/redaction.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const SENSITIVE_KEY_RE = /(password|passwd|pwd|token|secret|authorization|cookie|apikey|api_key|api-key|key)$/i;
+const SENSITIVE_TEXT_PATTERNS = [
+  /Bearer\s+[A-Za-z0-9._~+\/-]+=*/gi,
+  /ark-[A-Za-z0-9-]{20,}/gi,
+  /(api[_-]?key\s*[:=]\s*)[A-Za-z0-9._~+\/-]{8,}/gi,
+  /(token\s*[:=]\s*)[A-Za-z0-9._~+\/-]{8,}/gi
+];
+
+function redactString(value) {
+  let text = String(value ?? '');
+  for (const pattern of SENSITIVE_TEXT_PATTERNS) {
+    text = text.replace(pattern, match => {
+      const prefix = match.match(/^(api[_-]?key\s*[:=]\s*|token\s*[:=]\s*)/i)?.[0] || '';
+      return `${prefix}******`;
+    });
+  }
+  return text;
+}
+
+function isSensitiveKey(key = '') {
+  return SENSITIVE_KEY_RE.test(String(key));
+}
+
+function redact(value, key = '') {
+  if (value == null) return value;
+  if (isSensitiveKey(key)) return '******';
+  if (typeof value === 'string') return redactString(value);
+  if (typeof value !== 'object') return value;
+  if (Array.isArray(value)) return value.map(item => redact(item));
+  return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, redact(v, k)]));
+}
+
+module.exports = {
+  redactString,
+  isSensitiveKey,
+  redact
+};

package/core/report.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const { redact } = require('./redaction');
+
+function buildJsonReport(data = {}) {
+  return {
+    generatedAt: new Date().toISOString(),
+    ok: data.ok ?? data.pass ?? data.passed ?? false,
+    passed: data.passed ?? data.pass ?? data.ok ?? false,
+    summary: data.summary || '',
+    data: redact(data.data || data),
+    artifacts: Array.isArray(data.artifacts) ? data.artifacts : [],
+    errors: Array.isArray(data.errors) ? data.errors : []
+  };
+}
+
+function escapeHtml(value) {
+  return String(value ?? '')
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+function buildHtmlReport(data = {}) {
+  const report = buildJsonReport(data);
+  return `<!doctype html>
+<html lang="zh-CN">
+<head><meta charset="utf-8"><title>ValidPilot Report</title></head>
+<body>
+  <h1>ValidPilot Report</h1>
+  <p>Status: ${report.passed ? 'pass' : 'fail'}</p>
+  <p>${escapeHtml(report.summary)}</p>
+  <pre>${escapeHtml(JSON.stringify(report, null, 2))}</pre>
+</body>
+</html>`;
+}
+
+module.exports = {
+  buildJsonReport,
+  buildHtmlReport
+};

package/core/result.js

@@ -0,0 +1,29 @@
+'use strict';
+
+function buildResult(options = {}) {
+  const ok = options.ok ?? options.passed ?? false;
+  const passed = options.passed ?? ok;
+  return {
+    ok: Boolean(ok),
+    passed: Boolean(passed),
+    summary: options.summary || (passed ? 'pass' : 'fail'),
+    data: options.data || null,
+    artifacts: Array.isArray(options.artifacts) ? options.artifacts : [],
+    errors: Array.isArray(options.errors) ? options.errors : []
+  };
+}
+
+function pass(summary = 'pass', data = null, artifacts = []) {
+  return buildResult({ ok: true, passed: true, summary, data, artifacts });
+}
+
+function fail(summary = 'fail', errors = [], data = null, artifacts = []) {
+  return buildResult({ ok: false, passed: false, summary, errors: Array.isArray(errors) ? errors : [errors], data, artifacts });
+}
+
+module.exports = {
+  buildResult,
+  result: buildResult,
+  pass,
+  fail
+};

package/core/security.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const { loadConfig } = require('./config');
+
+function hostMatches(hostname, pattern) {
+  const host = String(hostname || '').toLowerCase();
+  const rule = String(pattern || '').toLowerCase();
+  if (!rule) return false;
+  return host === rule || host.endsWith(`.${rule}`);
+}
+
+function checkUrl(url, config = loadConfig()) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch (error) {
+    return { allowed: false, reason: `invalid url: ${error.message}` };
+  }
+
+  if (!['http:', 'https:', 'file:'].includes(parsed.protocol)) {
+    return { allowed: false, reason: `unsupported protocol: ${parsed.protocol}` };
+  }
+
+  if (parsed.protocol === 'file:') {
+    return { allowed: true, reason: 'file protocol allowed' };
+  }
+
+  const hostname = parsed.hostname;
+  if ((config.blockedHosts || []).some(host => hostMatches(hostname, host))) {
+    return { allowed: false, reason: `blocked host: ${hostname}` };
+  }
+
+  const allowlist = config.allowlist || [];
+  if (allowlist.length && !allowlist.some(host => hostMatches(hostname, host))) {
+    return { allowed: false, reason: `host not in allowlist: ${hostname}` };
+  }
+
+  return { allowed: true, reason: 'allowed' };
+}
+
+function safeUrlLog(url) {
+  try {
+    const parsed = new URL(url);
+    parsed.username = '';
+    parsed.password = '';
+    parsed.search = parsed.search ? '?…' : '';
+    parsed.hash = '';
+    return parsed.toString();
+  } catch (_) {
+    return String(url || '').slice(0, 200);
+  }
+}
+
+module.exports = {
+  checkUrl,
+  safeUrlLog
+};

package/engines/chrome_mcp_adapter.js

@@ -0,0 +1,319 @@
+'use strict';
+
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+
+class ChromeMCPAdapter {
+  constructor(options = {}) {
+    this.browser = null;
+    this.pages = new Map();
+    this.defaultPage = null;
+    this._engine = null; // 'puppeteer' or 'playwright'
+    this.options = {
+      headless: options.headless !== false,
+      executablePath: options.executablePath || null,
+      cdpPort: options.cdpPort || 9222,
+      ...options
+    };
+  }
+
+  async launch(options = {}) {
+    const mergedOptions = { ...this.options, ...options };
+
+    // Try puppeteer-core first
+    try {
+      const puppeteer = require('puppeteer-core');
+      this.browser = await puppeteer.launch({
+        headless: mergedOptions.headless !== false ? 'new' : false,
+        executablePath: mergedOptions.executablePath || undefined,
+        args: ['--no-sandbox', '--disable-setuid-sandbox']
+      });
+      this._engine = 'puppeteer';
+      return this.browser;
+    } catch (e) {
+      // Fall through to Playwright approach
+    }
+
+    // Fall back to Playwright Chromium (already available as a dependency)
+    try {
+      const { chromium } = require('playwright');
+      this.browser = await chromium.launch({
+        headless: mergedOptions.headless !== false,
+        executablePath: mergedOptions.executablePath || undefined
+      });
+      this._engine = 'playwright';
+      return this.browser;
+    } catch (e) {
+      throw new Error(
+        `ChromeMCPAdapter: Cannot launch browser. ` +
+        `Install puppeteer-core or ensure Playwright is available. Error: ${e.message}`
+      );
+    }
+  }
+
+  async newPage(options = {}) {
+    if (!this.browser) {
+      throw new Error('ChromeMCPAdapter: Browser not launched. Call launch() first.');
+    }
+
+    let page;
+
+    if (this._engine === 'puppeteer') {
+      page = await this.browser.newPage();
+      if (options.viewport) {
+        await page.setViewport(options.viewport);
+      }
+    } else {
+      // Playwright
+      page = await this.browser.newPage({
+        viewport: options.viewport || { width: 1440, height: 900 }
+      });
+    }
+
+    // Generate a unique page name if none provided
+    const pageName = options.name || `page_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    this.pages.set(pageName, { page, name: pageName, createdAt: new Date().toISOString() });
+
+    if (!this.defaultPage) {
+      this.defaultPage = page;
+    }
+
+    return page;
+  }
+
+  async close() {
+    // Close all pages
+    for (const [name, entry] of this.pages) {
+      try {
+        if (entry.page && typeof entry.page.close === 'function') {
+          await entry.page.close();
+        }
+      } catch (e) {
+        // Ignore errors closing individual pages
+      }
+    }
+    this.pages.clear();
+    this.defaultPage = null;
+
+    // Close browser
+    if (this.browser && typeof this.browser.close === 'function') {
+      try {
+        await this.browser.close();
+      } catch (e) {
+        // Ignore errors closing browser
+      }
+    }
+    this.browser = null;
+    this._engine = null;
+  }
+
+  getPage(name = null) {
+    if (!this.browser) {
+      throw new Error('ChromeMCPAdapter: Browser not launched. Call launch() first.');
+    }
+
+    if (name === null) {
+      if (!this.defaultPage) {
+        throw new Error('ChromeMCPAdapter: No default page. Call newPage() first.');
+      }
+      return this.defaultPage;
+    }
+
+    const entry = this.pages.get(name);
+    if (!entry || !entry.page) {
+      throw new Error(`ChromeMCPAdapter: Page '${name}' not found.`);
+    }
+    return entry.page;
+  }
+
+  async goto(url, options = {}) {
+    const page = this.getPage();
+    const waitUntil = options.waitUntil || 'domcontentloaded';
+
+    if (this._engine === 'puppeteer') {
+      await page.goto(url, { waitUntil, timeout: options.timeout || 30000 });
+    } else {
+      await page.goto(url, { waitUntil, timeout: options.timeout || 30000 });
+    }
+
+    return page;
+  }
+
+  async screenshot(options = {}) {
+    const page = this.getPage();
+    const screenshotOptions = { fullPage: options.fullPage !== false, type: options.type || 'png' };
+
+    if (options.path) {
+      screenshotOptions.path = options.path;
+    }
+
+    if (this._engine === 'puppeteer') {
+      return await page.screenshot(screenshotOptions);
+    } else {
+      // Playwright returns Buffer
+      return await page.screenshot(screenshotOptions);
+    }
+  }
+
+  async evaluate(pageFunction, ...args) {
+    const page = this.getPage();
+
+    if (this._engine === 'puppeteer') {
+      return await page.evaluate(pageFunction, ...args);
+    } else {
+      return await page.evaluate(pageFunction, ...args);
+    }
+  }
+
+  async waitForSelector(selector, options = {}) {
+    const page = this.getPage();
+    const timeout = options.timeout || 10000;
+
+    if (this._engine === 'puppeteer') {
+      return await page.waitForSelector(selector, { timeout, visible: options.visible !== false });
+    } else {
+      return await page.waitForSelector(selector, {
+        timeout,
+        state: options.visible !== false ? 'visible' : 'attached'
+      });
+    }
+  }
+
+  async click(selector, options = {}) {
+    const page = this.getPage();
+
+    if (this._engine === 'puppeteer') {
+      await page.waitForSelector(selector, { timeout: options.timeout || 10000 });
+      return await page.click(selector);
+    } else {
+      await page.waitForSelector(selector, {
+        timeout: options.timeout || 10000,
+        state: 'visible'
+      });
+      return await page.click(selector);
+    }
+  }
+
+  async type(selector, text, options = {}) {
+    const page = this.getPage();
+
+    if (this._engine === 'puppeteer') {
+      await page.waitForSelector(selector, { timeout: options.timeout || 10000 });
+      await page.click(selector, { clickCount: 3 }); // Select all existing text
+      return await page.type(selector, text, { delay: options.delay || 0 });
+    } else {
+      await page.waitForSelector(selector, {
+        timeout: options.timeout || 10000,
+        state: 'visible'
+      });
+      await page.click(selector, { clickCount: 3 }); // Select all existing text
+      return await page.type(selector, text, { delay: options.delay || 0 });
+    }
+  }
+
+  isConnected() {
+    if (!this.browser) {
+      return false;
+    }
+
+    try {
+      // Playwright: browser.isConnected()
+      if (typeof this.browser.isConnected === 'function') {
+        return this.browser.isConnected();
+      }
+      // Puppeteer: browser.isConnected()
+      if (typeof this.browser.isConnected === 'function') {
+        return this.browser.isConnected();
+      }
+      // Fallback: if browser exists and no error thrown, assume connected
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  static detectChromePath() {
+    const platform = os.platform();
+
+    if (platform === 'win32') {
+      const winPaths = [
+        'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
+        'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
+        path.join(process.env.LOCALAPPDATA || '', 'Google', 'Chrome', 'Application', 'chrome.exe'),
+        'C:\\Program Files\\Chromium\\Application\\chrome.exe'
+      ];
+      for (const p of winPaths) {
+        if (fs.existsSync(p)) {
+          return p;
+        }
+      }
+
+      // Try registry lookup
+      try {
+        const { execSync } = require('child_process');
+        const regQuery = execSync(
+          'reg query "HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\chrome.exe" /ve 2>nul',
+          { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
+        );
+        const match = regQuery.match(/([A-Z]:\\[^\r\n]+\.exe)/i);
+        if (match && fs.existsSync(match[1])) {
+          return match[1];
+        }
+      } catch (e) {
+        // Registry query failed
+      }
+    }
+
+    if (platform === 'darwin') {
+      const macPaths = [
+        '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+        '/Applications/Chromium.app/Contents/MacOS/Chromium'
+      ];
+      for (const p of macPaths) {
+        if (fs.existsSync(p)) {
+          return p;
+        }
+      }
+    }
+
+    if (platform === 'linux') {
+      const linuxPaths = [
+        '/usr/bin/google-chrome',
+        '/usr/bin/chromium-browser',
+        '/usr/bin/chromium',
+        '/snap/bin/chromium'
+      ];
+      for (const p of linuxPaths) {
+        if (fs.existsSync(p)) {
+          return p;
+        }
+      }
+
+      // Try which command
+      try {
+        const { execSync } = require('child_process');
+        const names = ['google-chrome', 'chromium-browser', 'chromium'];
+        for (const name of names) {
+          try {
+            const result = execSync(`which ${name} 2>/dev/null`, {
+              encoding: 'utf8',
+              stdio: ['pipe', 'pipe', 'pipe']
+            }).trim();
+            if (result && fs.existsSync(result)) {
+              return result;
+            }
+          } catch (e) {
+            // Command not found
+          }
+        }
+      } catch (e) {
+        // which command failed
+      }
+    }
+
+    return null;
+  }
+}
+
+module.exports = { ChromeMCPAdapter };