@guanlin4924/devflow-pi 0.1.94 → 0.1.96

package/plugins/devflow-quality/runtime/playwright/playwright.config.mjs

@@ -0,0 +1,46 @@
+// plugins/devflow-quality/runtime/playwright/src/playwright.config.ts
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var here = path.dirname(fileURLToPath(import.meta.url));
+var resultFile = process.env.DEVFLOW_RESULT_FILE;
+var runDir = resultFile && path.isAbsolute(resultFile) ? path.dirname(resultFile) : path.join(os.tmpdir(), "devflow-runtime-unbound");
+function traceMode() {
+  try {
+    const profile = JSON.parse(fs.readFileSync(process.env.DEVFLOW_ENVIRONMENT_FILE ?? "", "utf8"));
+    if (profile?.trace === "off")
+      return "off";
+    return "retain-on-failure";
+  } catch {
+    return "off";
+  }
+}
+var playwright_config_default = {
+  testDir: here,
+  testMatch: /[\\/]runner\.spec\.mjs$/,
+  outputDir: path.join(runDir, ".pw-output"),
+  fullyParallel: false,
+  workers: 1,
+  retries: 0,
+  maxFailures: 1,
+  forbidOnly: true,
+  timeout: 30 * 60 * 1000,
+  updateSnapshots: "none",
+  reporter: [[path.join(here, "reporter.mjs")]],
+  use: {
+    browserName: "chromium",
+    headless: true,
+    trace: traceMode(),
+    screenshot: "only-on-failure",
+    video: "off",
+    serviceWorkers: "block",
+    acceptDownloads: false,
+    ignoreHTTPSErrors: false,
+    actionTimeout: 1e4,
+    navigationTimeout: 30000
+  }
+};
+export {
+  playwright_config_default as default
+};

package/plugins/devflow-quality/runtime/playwright/reporter.mjs

@@ -0,0 +1,311 @@
+// plugins/devflow-quality/runtime/playwright/src/reporter.ts
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path2 from "node:path";
+
+// plugins/devflow-quality/runtime/playwright/src/env.ts
+import path from "node:path";
+var NAMES = {
+  dslFile: "DEVFLOW_DSL_FILE",
+  dslSha256: "DEVFLOW_DSL_SHA256",
+  tcId: "DEVFLOW_TC_ID",
+  tcSha256: "DEVFLOW_TC_SHA256",
+  executionId: "DEVFLOW_EXECUTION_ID",
+  nonce: "DEVFLOW_EXECUTION_NONCE",
+  resultFile: "DEVFLOW_RESULT_FILE",
+  artifactDir: "DEVFLOW_ARTIFACT_DIR",
+  environmentFile: "DEVFLOW_ENVIRONMENT_FILE"
+};
+
+class EnvError extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+}
+function rawEnv(env = process.env) {
+  const out = {};
+  for (const [key, name] of Object.entries(NAMES)) {
+    const value = env[name];
+    if (typeof value === "string" && value.length > 0)
+      out[key] = value;
+  }
+  return out;
+}
+function readRuntimeEnv(env = process.env) {
+  const raw = rawEnv(env);
+  const missing = Object.entries(NAMES).filter(([key]) => !raw[key]).map(([, name]) => name);
+  if (missing.length)
+    throw new EnvError(`missing reserved environment variables: ${missing.join(", ")}`, "runtime_env_missing");
+  const r = raw;
+  for (const key of ["dslFile", "resultFile", "artifactDir", "environmentFile"]) {
+    if (!path.isAbsolute(r[key]))
+      throw new EnvError(`${NAMES[key]} must be an absolute path`, "runtime_env_invalid");
+  }
+  if (!/^[0-9a-f]{64}$/.test(r.dslSha256))
+    throw new EnvError("DEVFLOW_DSL_SHA256 must be 64 lowercase hex", "runtime_env_invalid");
+  if (!/^[0-9a-f]{64}$/.test(r.tcSha256))
+    throw new EnvError("DEVFLOW_TC_SHA256 must be 64 lowercase hex", "runtime_env_invalid");
+  if (path.basename(r.resultFile) !== "result.json")
+    throw new EnvError("DEVFLOW_RESULT_FILE must be <run_dir>/result.json", "runtime_env_invalid");
+  const runDir = path.dirname(path.resolve(r.resultFile));
+  if (path.resolve(r.artifactDir) !== path.join(runDir, "artifacts")) {
+    throw new EnvError("DEVFLOW_ARTIFACT_DIR must be <run_dir>/artifacts next to DEVFLOW_RESULT_FILE", "runtime_env_invalid");
+  }
+  return { ...r, runDir };
+}
+
+// plugins/devflow-quality/runtime/playwright/src/redact.ts
+var REDACTED = "***";
+var SENSITIVE_KEY = /(pass(word|wd)?|secret|token|auth|session|cookie|api[-_]?key|signature|sig|credential|private)/i;
+var MAX_ERROR_LENGTH = 2000;
+var ANSI = /\u001b\[[0-9;]*[A-Za-z]/g;
+
+class Redactor {
+  values = [];
+  add(value) {
+    if (value === undefined || value === null)
+      return;
+    const text = typeof value === "string" ? value : JSON.stringify(value);
+    if (!text)
+      return;
+    if (!this.values.includes(text)) {
+      this.values.push(text);
+      this.values.sort((a, b) => b.length - a.length);
+    }
+    for (const encoded of [encodeURIComponent(text), new URLSearchParams({ v: text }).toString().slice(2)]) {
+      if (encoded !== text && !this.values.includes(encoded))
+        this.values.push(encoded);
+    }
+    this.values.sort((a, b) => b.length - a.length);
+  }
+  list() {
+    return [...this.values];
+  }
+  text(input) {
+    let out = input;
+    for (const v of this.values)
+      out = out.split(v).join(REDACTED);
+    return out;
+  }
+  url(input) {
+    let masked = input;
+    try {
+      const u = new URL(input);
+      if (u.username || u.password) {
+        u.username = u.username ? REDACTED : "";
+        u.password = u.password ? REDACTED : "";
+      }
+      for (const key of [...u.searchParams.keys()]) {
+        if (SENSITIVE_KEY.test(key))
+          u.searchParams.set(key, REDACTED);
+      }
+      masked = u.toString();
+    } catch {}
+    return this.text(masked);
+  }
+  value(input) {
+    if (typeof input === "string")
+      return this.text(input);
+    if (Array.isArray(input))
+      return input.map((v) => this.value(v));
+    if (input && typeof input === "object") {
+      return Object.fromEntries(Object.entries(input).map(([k, v]) => [k, SENSITIVE_KEY.test(k) ? REDACTED : this.value(v)]));
+    }
+    if (input !== undefined && input !== null && this.values.includes(String(input)))
+      return REDACTED;
+    return input;
+  }
+  error(err) {
+    const raw = err instanceof Error ? err.message : String(err);
+    const text = this.text(raw.replace(ANSI, ""));
+    return text.length > MAX_ERROR_LENGTH ? `${text.slice(0, MAX_ERROR_LENGTH)}…` : text;
+  }
+}
+
+// plugins/devflow-quality/runtime/playwright/src/version.ts
+var RUNTIME_VERSION = "0.1.0";
+var RESULT_ORIGIN = "devflow_playwright_runtime";
+var RESULT_SCHEMA_VERSION = 1;
+var DSL_SCHEMA_FILE = "devflow-test-dsl-v1.schema.json";
+var RESULT_ATTACHMENT = "devflow-runtime-result";
+
+// plugins/devflow-quality/runtime/playwright/src/reporter.ts
+var now = () => new Date().toISOString();
+function sha256File(file) {
+  const data = fs.readFileSync(file);
+  return { bytes: data.length, sha256: crypto.createHash("sha256").update(data).digest("hex") };
+}
+function writeAtomic(file, content) {
+  const dir = path2.dirname(file);
+  const tmp = path2.join(dir, `.${path2.basename(file)}.${process.pid}.${crypto.randomBytes(6).toString("hex")}.tmp`);
+  const fd = fs.openSync(tmp, "wx", 384);
+  try {
+    fs.writeSync(fd, content);
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+  fs.renameSync(tmp, file);
+}
+function inside(parent, child) {
+  const rel = path2.relative(parent, child);
+  return rel !== "" && !rel.startsWith("..") && !path2.isAbsolute(rel);
+}
+function stripStep(step) {
+  const { error_code: _ignored, ...rest } = step;
+  return rest;
+}
+
+class DevflowReporter {
+  startedAt = now();
+  outcome = null;
+  testStatus = null;
+  attachments = [];
+  errors = [];
+  preexisting = false;
+  testCount = 0;
+  printsToStdio() {
+    return true;
+  }
+  onBegin() {
+    const env = rawEnv();
+    if (env.resultFile && fs.existsSync(env.resultFile))
+      this.preexisting = true;
+    if (env.artifactDir && path2.isAbsolute(env.artifactDir))
+      fs.mkdirSync(env.artifactDir, { recursive: true, mode: 448 });
+  }
+  onTestEnd(_test, result) {
+    this.testCount += 1;
+    this.testStatus = result.status;
+    this.attachments = result.attachments;
+    const attachment = result.attachments.find((a) => a.name === RESULT_ATTACHMENT && a.body);
+    if (attachment?.body) {
+      try {
+        this.outcome = JSON.parse(attachment.body.toString("utf8"));
+      } catch {
+        this.outcome = null;
+      }
+    }
+    for (const error of result.errors)
+      this.errors.push(error.message ?? String(error.value ?? "error"));
+  }
+  onError(error) {
+    this.errors.push(error.message ?? String(error.value ?? "error"));
+  }
+  async onExit() {
+    const env = rawEnv();
+    if (env.resultFile && path2.isAbsolute(env.resultFile)) {
+      fs.rmSync(path2.join(path2.dirname(env.resultFile), ".pw-output"), { recursive: true, force: true });
+    }
+  }
+  baselineRedactor() {
+    const redactor = new Redactor;
+    const env = rawEnv();
+    try {
+      const profile = JSON.parse(fs.readFileSync(env.environmentFile ?? "", "utf8"));
+      for (const envName of Object.values(profile?.secret_env ?? {})) {
+        if (typeof envName === "string" && process.env[envName])
+          redactor.add(process.env[envName]);
+      }
+    } catch {}
+    for (const value of this.outcome?.redact_values ?? [])
+      redactor.add(value);
+    return redactor;
+  }
+  async onEnd(_full) {
+    const env = rawEnv();
+    if (!env.resultFile || !path2.isAbsolute(env.resultFile) || path2.basename(env.resultFile) !== "result.json") {
+      console.error("devflow runtime: DEVFLOW_RESULT_FILE missing or invalid; no result written");
+      return;
+    }
+    const runDir = path2.dirname(env.resultFile);
+    const artifactDir = path2.join(runDir, "artifacts");
+    const redactor = this.baselineRedactor();
+    let status = this.outcome?.status ?? "blocked";
+    let errorCode = this.outcome ? this.outcome.error_code : this.testCount === 0 ? "runner_not_executed" : "runner_incomplete";
+    if (this.outcome?.status === "passed" && this.testStatus !== "passed") {
+      status = "blocked";
+      errorCode = "runner_error";
+    }
+    if (this.preexisting) {
+      status = "blocked";
+      errorCode = "result_file_preexisting";
+    }
+    if (!this.outcome && this.errors.length) {
+      const joined = this.errors.join(`
+`);
+      if (/Executable doesn't exist|browserType\.launch/i.test(joined))
+        errorCode = "browser_unavailable";
+      console.error(`devflow runtime: ${redactor.error(joined)}`);
+    }
+    const files = [];
+    for (const f of this.outcome?.artifact_files ?? [])
+      files.push({ abs: path2.resolve(runDir, f.path), kind: f.kind });
+    if (status !== "passed") {
+      let traceIndex = 0;
+      let shotIndex = 0;
+      for (const a of this.attachments) {
+        if (!a.path || !fs.existsSync(a.path))
+          continue;
+        if (a.name === "trace") {
+          const dest = path2.join(artifactDir, traceIndex === 0 ? "trace.zip" : `trace-${traceIndex}.zip`);
+          traceIndex += 1;
+          fs.mkdirSync(artifactDir, { recursive: true, mode: 448 });
+          fs.copyFileSync(a.path, dest);
+          files.push({ abs: dest, kind: "trace" });
+        } else if (a.name === "screenshot" || a.contentType === "image/png") {
+          const dir = path2.join(artifactDir, "screenshots");
+          fs.mkdirSync(dir, { recursive: true, mode: 448 });
+          const dest = path2.join(dir, `failure-${++shotIndex}.png`);
+          fs.copyFileSync(a.path, dest);
+          files.push({ abs: dest, kind: "screenshot" });
+        }
+      }
+    }
+    const artifacts = [];
+    for (const f of files) {
+      let real;
+      try {
+        real = fs.realpathSync(f.abs);
+      } catch {
+        continue;
+      }
+      const stat = fs.lstatSync(f.abs);
+      if (!stat.isFile() || !inside(fs.realpathSync(runDir), real))
+        continue;
+      artifacts.push({ path: path2.relative(runDir, f.abs).split(path2.sep).join("/"), kind: f.kind, ...sha256File(f.abs) });
+    }
+    const result = {
+      schema_version: RESULT_SCHEMA_VERSION,
+      origin: RESULT_ORIGIN,
+      execution_id: env.executionId ?? null,
+      nonce: env.nonce ?? null,
+      tc_id: env.tcId ?? null,
+      tc_sha256: env.tcSha256 ?? null,
+      dsl_sha256: this.outcome?.dsl_sha256 ?? null,
+      runtime_version: RUNTIME_VERSION,
+      status,
+      error_code: errorCode,
+      started_at: this.outcome?.started_at ?? this.startedAt,
+      finished_at: this.outcome?.finished_at ?? now(),
+      steps: (this.outcome?.steps ?? []).map(stripStep),
+      cleanup: this.outcome?.cleanup ?? { status: "skipped", errors: [] },
+      artifacts
+    };
+    const text = redactor.text(JSON.stringify(result, null, 2));
+    try {
+      writeAtomic(env.resultFile, `${text}
+`);
+    } catch (err) {
+      console.error(`devflow runtime: failed to write result: ${redactor.error(err)}`);
+      return;
+    }
+    console.log(`devflow runtime: status=${status}${errorCode ? ` error_code=${errorCode}` : ""}`);
+  }
+}
+export {
+  writeAtomic,
+  DevflowReporter as default
+};