@riddledc/riddle-proof 0.5.57 → 0.7.0

package/dist/cli.js

@@ -1,4 +1,15 @@
 #!/usr/bin/env node
+import {
+  assessRiddleProofProfileEvidence,
+  buildRiddleProofProfileScript,
+  collectRiddleProfileArtifactRefs,
+  createRiddleProofProfileEnvironmentBlockedResult,
+  createRiddleProofProfileInsufficientResult,
+  extractRiddleProofProfileResult,
+  normalizeRiddleProofProfile,
+  profileStatusExitCode,
+  resolveRiddleProofProfileTargetUrl
+} from "./chunk-7NMAU4DP.js";
 import {
   createRiddleApiClient,
   parseRiddleViewport
@@ -7,10 +18,10 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-2FBF2UDZ.js";
+} from "./chunk-D3M2FAYQ.js";
 import "./chunk-MO24D3PY.js";
-import "./chunk-RFJ5BQF6.js";
 import "./chunk-3UHWI3FO.js";
+import "./chunk-RFJ5BQF6.js";
 import {
   createCheckpointResponseTemplate
 } from "./chunk-33XO42CY.js";
@@ -22,7 +33,8 @@ import {
 import "./chunk-DUFDZJOF.js";
 
 // src/cli.ts
-import { existsSync, readFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import path from "path";
 function usage() {
   return [
     "Usage:",
@@ -31,6 +43,7 @@ function usage() {
     "  riddle-proof-loop respond --state-path <path> --response-json <file|json|->",
     "  riddle-proof-loop respond --state-path <path> --decision <decision> --summary <text> [--payload-json <file|json|->]",
     "  riddle-proof-loop status --state-path <path>",
+    "  riddle-proof-loop run-profile --profile <file|json|-> --url <base-url> [--runner riddle] [--output <dir>]",
     "  riddle-proof-loop riddle-preview-deploy <build-dir> <label>",
     "  riddle-proof-loop riddle-server-preview <directory> --script-file <file> [--path /route] [--wait-for-selector selector]",
     "  riddle-proof-loop riddle-run-script --url <url> --script-file <file> [--viewport 1280x720]",
@@ -222,6 +235,173 @@ function riddleClientConfig(options) {
     apiBaseUrl: optionString(options, "apiBaseUrl")
   };
 }
+function parseProfileViewports(value) {
+  if (!value) return void 0;
+  return value.split(",").map((part, index) => {
+    const trimmed = part.trim();
+    const named = /^([a-zA-Z0-9_-]+)=(\d+x\d+)$/.exec(trimmed);
+    const viewport = parseRiddleViewport(named ? named[2] : trimmed);
+    if (!viewport) throw new Error(`Invalid viewport ${trimmed}.`);
+    return {
+      name: named ? named[1] : `viewport-${index + 1}`,
+      width: viewport.width,
+      height: viewport.height
+    };
+  });
+}
+function normalizeProfileForCli(options) {
+  const rawProfile = readJsonValue(optionString(options, "profile"), "--profile");
+  return normalizeRiddleProofProfile(rawProfile, {
+    url: optionString(options, "url"),
+    route: optionString(options, "route"),
+    viewports: parseProfileViewports(optionString(options, "viewports") || optionString(options, "viewport"))
+  });
+}
+function profileResultMarkdown(result) {
+  const lines = [
+    `# Riddle Proof Profile: ${result.profile_name}`,
+    "",
+    `Status: ${result.status}`,
+    `Runner: ${result.runner}`,
+    `Captured: ${result.captured_at}`,
+    "",
+    result.summary,
+    "",
+    "## Checks",
+    ""
+  ];
+  for (const check of result.checks) {
+    lines.push(`- ${check.status}: ${check.label || check.type}`);
+    if (check.message) lines.push(`  ${check.message}`);
+  }
+  if (result.artifacts.riddle_artifacts?.length) {
+    lines.push("", "## Riddle Artifacts", "");
+    for (const artifact of result.artifacts.riddle_artifacts.slice(0, 40)) {
+      lines.push(`- ${artifact.name || artifact.kind || "artifact"}${artifact.url ? `: ${artifact.url}` : ""}`);
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+function writeProfileOutput(outputDir, result) {
+  if (!outputDir) return;
+  mkdirSync(outputDir, { recursive: true });
+  writeFileSync(path.join(outputDir, "profile-result.json"), `${JSON.stringify(result, null, 2)}
+`);
+  writeFileSync(path.join(outputDir, "summary.md"), profileResultMarkdown(result));
+  if (result.evidence) writeFileSync(path.join(outputDir, "proof.json"), `${JSON.stringify(result, null, 2)}
+`);
+  if (result.evidence?.console) writeFileSync(path.join(outputDir, "console.json"), `${JSON.stringify(result.evidence.console, null, 2)}
+`);
+  if (result.evidence?.dom_summary) writeFileSync(path.join(outputDir, "dom-summary.json"), `${JSON.stringify(result.evidence.dom_summary, null, 2)}
+`);
+}
+async function readArtifactJson(artifact) {
+  const target = artifact.url || artifact.path;
+  if (!target) return void 0;
+  try {
+    const raw = artifact.url ? await (await fetch(artifact.url)).text() : existsSync(target) ? readFileSync(target, "utf-8") : "";
+    if (!raw.trim()) return void 0;
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function profileResultFromRiddleArtifacts(profile, artifacts, fallbackInputs) {
+  for (const input of fallbackInputs) {
+    const result = extractRiddleProofProfileResult(input);
+    if (result) return result;
+  }
+  const proofArtifacts = artifacts.filter((artifact) => /(^|\/)proof\.json(?:\.json)?$/i.test(artifact.name || artifact.url || artifact.path || "")).sort((left, right) => {
+    const leftName = left.name || left.url || left.path || "";
+    const rightName = right.name || right.url || right.path || "";
+    return Number(/proof\.json\.json$/i.test(rightName)) - Number(/proof\.json\.json$/i.test(leftName));
+  });
+  for (const artifact of proofArtifacts) {
+    const parsed = await readArtifactJson(artifact);
+    const result = extractRiddleProofProfileResult(parsed);
+    if (result) return result;
+  }
+  const evidenceArtifacts = artifacts.filter((artifact) => /profile-evidence|evidence\.json/i.test(artifact.name || artifact.url || artifact.path || ""));
+  for (const artifact of evidenceArtifacts) {
+    const parsed = await readArtifactJson(artifact);
+    if (parsed?.version === "riddle-proof.profile-evidence.v1") {
+      return assessRiddleProofProfileEvidence(profile, parsed, { artifacts });
+    }
+  }
+  return void 0;
+}
+function withRiddleMetadata(result, input) {
+  return {
+    ...result,
+    riddle: {
+      ...result.riddle || {},
+      job_id: input.job_id || result.riddle?.job_id,
+      status: input.status ?? result.riddle?.status,
+      terminal: input.terminal ?? result.riddle?.terminal
+    },
+    artifacts: {
+      ...result.artifacts,
+      riddle_artifacts: input.artifacts || result.artifacts.riddle_artifacts
+    }
+  };
+}
+async function runProfileForCli(profile, options) {
+  const runner = optionString(options, "runner") || "riddle";
+  if (runner !== "riddle") {
+    throw new Error(`Unsupported --runner ${runner}. The current CLI supports --runner riddle.`);
+  }
+  const targetUrl = resolveRiddleProofProfileTargetUrl(profile);
+  const client = createRiddleApiClient(riddleClientConfig(options));
+  let created;
+  try {
+    created = await client.runScript({
+      url: targetUrl,
+      script: buildRiddleProofProfileScript(profile),
+      viewport: profile.target.viewports[0],
+      timeoutSec: optionString(options, "timeout") ? Number(optionString(options, "timeout")) : void 0,
+      sync: options.sync === true ? true : void 0
+    });
+  } catch (error) {
+    return createRiddleProofProfileEnvironmentBlockedResult({ profile, runner, error });
+  }
+  const jobId = typeof created.job_id === "string" ? created.job_id : typeof created.id === "string" ? created.id : "";
+  if (!jobId) {
+    const directResult = extractRiddleProofProfileResult(created);
+    return directResult ? withRiddleMetadata(directResult, { artifacts: collectRiddleProfileArtifactRefs(created) }) : createRiddleProofProfileInsufficientResult({ profile, runner, error: "Riddle run response was missing job_id.", artifacts: collectRiddleProfileArtifactRefs(created) });
+  }
+  const poll = await client.pollJob(jobId, {
+    wait: true,
+    attempts: optionString(options, "attempts") ? Number(optionString(options, "attempts")) : void 0,
+    intervalMs: optionString(options, "intervalMs") ? Number(optionString(options, "intervalMs")) : void 0
+  });
+  const artifacts = collectRiddleProfileArtifactRefs(poll.artifacts);
+  if (!poll.ok || !poll.terminal) {
+    return createRiddleProofProfileEnvironmentBlockedResult({
+      profile,
+      runner,
+      error: `Riddle job ${jobId} ended with status ${poll.status || "unknown"}.`,
+      riddle: { job_id: jobId, status: poll.status, terminal: poll.terminal },
+      artifacts
+    });
+  }
+  const artifactResult = await profileResultFromRiddleArtifacts(profile, artifacts, [poll.job, poll.artifacts, created]);
+  if (!artifactResult) {
+    return createRiddleProofProfileInsufficientResult({
+      profile,
+      runner,
+      riddle: { job_id: jobId, status: poll.status, terminal: poll.terminal },
+      artifacts
+    });
+  }
+  return withRiddleMetadata(artifactResult, {
+    job_id: jobId,
+    status: poll.status,
+    terminal: poll.terminal,
+    artifacts
+  });
+}
 function requestForRun(options) {
   const statePath = optionString(options, "statePath");
   const withEngineModuleUrl = (request) => {
@@ -268,6 +448,15 @@ async function main() {
 `);
     return;
   }
+  if (command === "run-profile") {
+    const profile = normalizeProfileForCli(options);
+    const result = await runProfileForCli(profile, options);
+    writeProfileOutput(optionString(options, "output"), result);
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    process.exitCode = profileStatusExitCode(profile, result.status);
+    return;
+  }
   if (command === "riddle-preview-deploy") {
     const buildDir = positional[1];
     const label = positional[2];

package/dist/engine-harness.js

@@ -2,10 +2,10 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-2FBF2UDZ.js";
+} from "./chunk-D3M2FAYQ.js";
 import "./chunk-MO24D3PY.js";
-import "./chunk-RFJ5BQF6.js";
 import "./chunk-3UHWI3FO.js";
+import "./chunk-RFJ5BQF6.js";
 import "./chunk-33XO42CY.js";
 import "./chunk-DUFDZJOF.js";
 export {