@riddledc/openclaw-riddledc 0.9.2 → 0.9.4

package/dist/core.cjs

@@ -0,0 +1,897 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core.ts
+var core_exports = {};
+__export(core_exports, {
+  applySafetySpec: () => applySafetySpec,
+  assertAllowedBaseUrl: () => assertAllowedBaseUrl,
+  configFromOpenClawApi: () => configFromOpenClawApi,
+  createBuildPreview: () => createBuildPreview,
+  createServerPreview: () => createServerPreview,
+  createStaticPreview: () => createStaticPreview,
+  deleteStaticPreview: () => deleteStaticPreview,
+  describeError: () => describeError,
+  fetchArtifactsAndBuild: () => fetchArtifactsAndBuild,
+  fetchWithRetry: () => fetchWithRetry,
+  fetchWithTimeout: () => fetchWithTimeout,
+  isAlreadyStartedResponse: () => isAlreadyStartedResponse,
+  pollJobStatus: () => pollJobStatus,
+  riddleApiFetch: () => riddleApiFetch,
+  runWithDefaults: () => runWithDefaults,
+  writeArtifactBinary: () => writeArtifactBinary
+});
+module.exports = __toCommonJS(core_exports);
+var import_node_child_process = require("child_process");
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var import_node_util = require("util");
+var execFile = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var INLINE_CAP = 50 * 1024;
+var PREVIEW_REQUEST_TIMEOUT_MS = 3e4;
+var PREVIEW_UPLOAD_TIMEOUT_MS = 5 * 6e4;
+var PREVIEW_ARTIFACT_TIMEOUT_MS = 6e4;
+var PREVIEW_RETRY_ATTEMPTS = 3;
+var PREVIEW_RETRY_BASE_DELAY_MS = 750;
+function configFromOpenClawApi(api) {
+  const cfg = api?.config ?? {};
+  const pluginCfg = cfg?.plugins?.entries?.["openclaw-riddledc"]?.config ?? {};
+  return {
+    apiKey: process.env.RIDDLE_API_KEY || pluginCfg.apiKey,
+    baseUrl: pluginCfg.baseUrl || "https://api.riddledc.com",
+    workspace: api?.workspacePath ?? process.cwd()
+  };
+}
+function requireConfig(config) {
+  const apiKey = config.apiKey || process.env.RIDDLE_API_KEY;
+  const baseUrl = config.baseUrl || "https://api.riddledc.com";
+  if (!apiKey) {
+    throw new Error("Missing Riddle API key. Set RIDDLE_API_KEY env var or configure a Riddle API key.");
+  }
+  assertAllowedBaseUrl(baseUrl);
+  return { apiKey, baseUrl, workspace: config.workspace || process.cwd() };
+}
+function assertAllowedBaseUrl(baseUrl) {
+  const url = new URL(baseUrl);
+  if (url.protocol !== "https:") throw new Error(`Riddle baseUrl must be https: (${baseUrl})`);
+  if (url.hostname !== "api.riddledc.com") {
+    throw new Error(`Refusing to use non-official Riddle host: ${url.hostname}`);
+  }
+}
+function detectMode(payload) {
+  if (payload.url) return "url";
+  if (payload.urls) return "urls";
+  if (payload.steps) return "steps";
+  if (payload.script) return "script";
+  return void 0;
+}
+async function postRun(baseUrl, apiKey, payload) {
+  const res = await fetch(`${baseUrl.replace(/\/$/, "")}/v1/run`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(payload)
+  });
+  const body = await res.arrayBuffer();
+  return {
+    contentType: res.headers.get("content-type"),
+    body,
+    headers: res.headers,
+    status: res.status
+  };
+}
+function abToBase64(ab) {
+  return Buffer.from(ab).toString("base64");
+}
+function describeError(err) {
+  const anyErr = err;
+  const parts = [];
+  if (err instanceof Error) parts.push(err.message);
+  else parts.push(String(err));
+  const cause = anyErr?.cause;
+  if (cause) {
+    const causeParts = [
+      cause.code ? `code=${cause.code}` : "",
+      cause.name ? `name=${cause.name}` : "",
+      cause.message ? `message=${cause.message}` : ""
+    ].filter(Boolean);
+    if (causeParts.length) parts.push(`cause: ${causeParts.join(" ")}`);
+  }
+  return parts.join("; ");
+}
+async function fetchWithTimeout(url, init, timeoutMs, label) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } catch (err) {
+    if (err?.name === "AbortError") {
+      throw new Error(`${label} timed out after ${Math.round(timeoutMs / 1e3)}s`);
+    }
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function isTransientFetchError(err) {
+  const text = describeError(err).toLowerCase();
+  return [
+    "fetch failed",
+    "timed out",
+    "timeout",
+    "econnreset",
+    "econnrefused",
+    "etimedout",
+    "eai_again",
+    "socket",
+    "network",
+    "und_err",
+    "terminated"
+  ].some((needle) => text.includes(needle));
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function fetchWithRetry(url, init, timeoutMs, label, opts = {}) {
+  const attempts = Math.max(1, opts.attempts ?? PREVIEW_RETRY_ATTEMPTS);
+  const baseDelayMs = opts.baseDelayMs ?? PREVIEW_RETRY_BASE_DELAY_MS;
+  let lastErr;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    try {
+      return await fetchWithTimeout(url, init, timeoutMs, label);
+    } catch (err) {
+      lastErr = err;
+      if (attempt >= attempts || !isTransientFetchError(err)) break;
+      const jitterMs = Math.floor(Math.random() * 250);
+      const delayMs = Math.min(baseDelayMs * Math.pow(2, attempt - 1) + jitterMs, 5e3);
+      console.warn(`[openclaw-riddledc] ${label} attempt ${attempt}/${attempts} failed: ${describeError(err)}; retrying in ${delayMs}ms`);
+      await sleep(delayMs);
+    }
+  }
+  throw new Error(`${label} failed after ${attempts} attempts: ${describeError(lastErr)}`);
+}
+function isAlreadyStartedResponse(status, body) {
+  return status === 409 && /already in status:\s*(queued|running|complete|completed)/i.test(body);
+}
+function previewTimeoutResult(jobId, timeoutMs, lastStatusData, resultExtras = () => ({})) {
+  const lastStatus = lastStatusData?.status ?? "unknown";
+  const lastPhase = lastStatusData?.phase ?? lastStatus;
+  const result = {
+    ok: false,
+    job_id: jobId,
+    status: lastStatus,
+    phase: lastPhase,
+    phase_updated_at: lastStatusData?.phase_updated_at,
+    phase_details: lastStatusData?.phase_details,
+    outputs: lastStatusData?.outputs || [],
+    compute_seconds: lastStatusData?.compute_seconds,
+    egress_bytes: lastStatusData?.egress_bytes,
+    error: `Job did not complete within ${timeoutMs / 1e3}s; last status was ${lastStatus}, phase was ${lastPhase}`,
+    ...resultExtras(lastStatusData ?? {})
+  };
+  if (lastStatusData?.error) result.server_error = lastStatusData.error;
+  return result;
+}
+async function writeArtifact(workspace, subdir, filename, content) {
+  const dir = (0, import_node_path.join)(workspace, "riddle", subdir);
+  await (0, import_promises.mkdir)(dir, { recursive: true });
+  const filePath = (0, import_node_path.join)(dir, filename);
+  const buf = Buffer.from(content, "utf8");
+  await (0, import_promises.writeFile)(filePath, buf);
+  return { path: filePath, sizeBytes: buf.byteLength };
+}
+async function writeArtifactBinary(workspace, subdir, filename, base64Content) {
+  const dir = (0, import_node_path.join)(workspace, "riddle", subdir);
+  await (0, import_promises.mkdir)(dir, { recursive: true });
+  const filePath = (0, import_node_path.join)(dir, filename);
+  const buf = Buffer.from(base64Content, "base64");
+  await (0, import_promises.writeFile)(filePath, buf);
+  return { path: filePath, sizeBytes: buf.byteLength };
+}
+async function applySafetySpec(result, opts) {
+  const jobId = result.job_id ?? "unknown";
+  if (result.screenshot != null) {
+    let base64Data = null;
+    if (typeof result.screenshot === "string") {
+      base64Data = result.screenshot.replace(/^data:image\/\w+;base64,/, "");
+    } else if (typeof result.screenshot === "object" && result.screenshot.data) {
+      base64Data = result.screenshot.data.replace(/^data:image\/\w+;base64,/, "");
+    }
+    if (base64Data) {
+      const ref = await writeArtifactBinary(opts.workspace, "screenshots", `${jobId}.png`, base64Data);
+      const cdnUrl = typeof result.screenshot === "object" ? result.screenshot.url : void 0;
+      result.screenshot = { saved: ref.path, sizeBytes: ref.sizeBytes, ...cdnUrl ? { url: cdnUrl } : {} };
+    }
+  }
+  if (Array.isArray(result.screenshots)) {
+    const savedRefs = [];
+    for (let i = 0; i < result.screenshots.length; i++) {
+      const ss = result.screenshots[i];
+      let base64Data = null;
+      const cdnUrl = typeof ss === "object" ? ss.url : void 0;
+      if (typeof ss === "string") {
+        base64Data = ss;
+      } else if (typeof ss === "object" && ss.data) {
+        base64Data = ss.data.replace(/^data:image\/\w+;base64,/, "");
+      }
+      if (base64Data) {
+        const ref = await writeArtifactBinary(opts.workspace, "screenshots", `${jobId}-${i}.png`, base64Data);
+        savedRefs.push({ saved: ref.path, sizeBytes: ref.sizeBytes, ...cdnUrl ? { url: cdnUrl } : {} });
+      }
+    }
+    result.screenshots = savedRefs;
+  }
+  if (result.rawPngBase64 != null) {
+    const ref = await writeArtifactBinary(opts.workspace, "screenshots", `${jobId}.png`, result.rawPngBase64);
+    result.screenshot = { saved: ref.path, sizeBytes: ref.sizeBytes };
+    delete result.rawPngBase64;
+  }
+  if (result.har != null) {
+    const harStr = typeof result.har === "string" ? result.har : JSON.stringify(result.har);
+    const harBytes = Buffer.byteLength(harStr, "utf8");
+    if (opts.harInline && harBytes <= INLINE_CAP) {
+    } else {
+      const ref = await writeArtifact(opts.workspace, "har", `${jobId}.har.json`, harStr);
+      if (opts.harInline && harBytes > INLINE_CAP) {
+        result.har = { saved: ref.path, sizeBytes: ref.sizeBytes, warning: "Exceeded 50KB inline cap; wrote to file" };
+      } else {
+        result.har = { saved: ref.path, sizeBytes: ref.sizeBytes };
+      }
+    }
+  }
+  if (result.console != null) {
+    const consoleStr = typeof result.console === "string" ? result.console : JSON.stringify(result.console);
+    const consoleBytes = Buffer.byteLength(consoleStr, "utf8");
+    if (consoleBytes > INLINE_CAP) {
+      const ref = await writeArtifact(opts.workspace, "console", `${jobId}.log`, consoleStr);
+      result.console = { saved: ref.path, sizeBytes: ref.sizeBytes };
+    }
+  }
+}
+async function pollJobStatus(config, jobId, maxWaitMs) {
+  const { apiKey, baseUrl } = requireConfig(config);
+  const start = Date.now();
+  const pollIntervalMs = 2e3;
+  while (Date.now() - start < maxWaitMs) {
+    const res = await fetch(`${baseUrl.replace(/\/$/, "")}/v1/jobs/${jobId}`, {
+      headers: { Authorization: `Bearer ${apiKey}` }
+    });
+    if (!res.ok) {
+      return { status: "poll_error", error: `HTTP ${res.status}` };
+    }
+    const data = await res.json();
+    if (data.status === "completed" || data.status === "completed_timeout" || data.status === "completed_error" || data.status === "failed") {
+      return data;
+    }
+    await sleep(pollIntervalMs);
+  }
+  return { status: "poll_timeout", error: `Job ${jobId} did not complete within ${maxWaitMs}ms` };
+}
+async function fetchArtifactsAndBuild(config, jobId, include) {
+  const { apiKey, baseUrl } = requireConfig(config);
+  const res = await fetch(
+    `${baseUrl.replace(/\/$/, "")}/v1/jobs/${jobId}/artifacts?include=${include.join(",")}`,
+    { headers: { Authorization: `Bearer ${apiKey}` } }
+  );
+  if (!res.ok) {
+    return { error: `Artifacts fetch failed: HTTP ${res.status}` };
+  }
+  const data = await res.json();
+  const artifacts = data.artifacts || [];
+  const result = {};
+  if (data.status) result._artifactsStatus = data.status;
+  if (data.timeout) result._timeout = data.timeout;
+  if (data.error) result._error = data.error;
+  const screenshots = artifacts.filter((a) => a.name && /\.(png|jpg|jpeg)$/i.test(a.name));
+  if (screenshots.length > 0) {
+    result.screenshots = [];
+    for (const ss of screenshots) {
+      if (!ss.url) continue;
+      try {
+        const imgRes = await fetch(ss.url);
+        if (imgRes.ok) {
+          const buf = await imgRes.arrayBuffer();
+          result.screenshots.push({
+            name: ss.name,
+            data: `data:image/png;base64,${Buffer.from(buf).toString("base64")}`,
+            size: buf.byteLength,
+            url: ss.url
+          });
+        }
+      } catch {
+      }
+    }
+    if (result.screenshots.length > 0) {
+      result.screenshot = result.screenshots[0];
+    }
+  }
+  const consoleArtifact = artifacts.find((a) => a.name === "console.json");
+  if (consoleArtifact?.url) {
+    try {
+      const cRes = await fetch(consoleArtifact.url);
+      if (cRes.ok) {
+        result.console = await cRes.json();
+      }
+    } catch {
+    }
+  }
+  const resultArtifact = artifacts.find((a) => a.name === "result.json");
+  if (resultArtifact?.url) {
+    try {
+      const rRes = await fetch(resultArtifact.url);
+      if (rRes.ok) {
+        result.result = await rRes.json();
+      }
+    } catch {
+    }
+  }
+  if (include.includes("har")) {
+    const harArtifact = artifacts.find((a) => a.name === "network.har");
+    if (harArtifact?.url) {
+      try {
+        const hRes = await fetch(harArtifact.url);
+        if (hRes.ok) {
+          result.har = await hRes.json();
+        }
+      } catch {
+      }
+    }
+  }
+  return result;
+}
+async function runWithDefaults(config, payload, defaults) {
+  let cfg;
+  try {
+    cfg = requireConfig(config);
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+  const mode = detectMode(payload);
+  const userInclude = payload.include ?? [];
+  const userRequestedHar = userInclude.includes("har");
+  const harInline = !!payload.harInline;
+  const returnAsync = !!defaults?.returnAsync;
+  const merged = { ...payload };
+  delete merged.harInline;
+  if (returnAsync) {
+    merged.sync = false;
+  }
+  const defaultInc = defaults?.include ?? ["screenshot", "console"];
+  merged.include = Array.from(/* @__PURE__ */ new Set([...userInclude, ...defaultInc]));
+  merged.inlineConsole = merged.inlineConsole ?? true;
+  merged.inlineResult = merged.inlineResult ?? true;
+  if (userRequestedHar) {
+    merged.inlineHar = true;
+  }
+  const out = { ok: true, mode };
+  const { contentType, body, headers, status } = await postRun(cfg.baseUrl, cfg.apiKey, merged);
+  out.rawContentType = contentType ?? void 0;
+  if (status === 408) {
+    let jobIdFrom408;
+    try {
+      const json408 = JSON.parse(Buffer.from(body).toString("utf8"));
+      jobIdFrom408 = json408.job_id;
+    } catch {
+    }
+    if (!jobIdFrom408) {
+      out.ok = false;
+      out.error = "Sync poll timed out but no job_id in 408 response";
+      return out;
+    }
+    out.job_id = jobIdFrom408;
+    if (returnAsync) {
+      out.status = "submitted";
+      return out;
+    }
+    const scriptTimeoutMs = (payload.timeout_sec ?? 60) * 1e3;
+    const jobStatus = await pollJobStatus(cfg, jobIdFrom408, scriptTimeoutMs + 3e4);
+    if (jobStatus.status === "poll_timeout" || jobStatus.status === "poll_error" || jobStatus.status === "failed") {
+      out.ok = false;
+      out.status = jobStatus.status;
+      out.error = jobStatus.error || `Job ${jobStatus.status}`;
+      return out;
+    }
+    const artifacts = await fetchArtifactsAndBuild(cfg, jobIdFrom408, merged.include);
+    Object.assign(out, artifacts);
+    out.job_id = jobIdFrom408;
+    out.status = jobStatus.status;
+    out.duration_ms = jobStatus.duration_ms;
+    if (jobStatus.status !== "completed") {
+      out.ok = false;
+      if (jobStatus.timeout) out.timeout = jobStatus.timeout;
+      if (jobStatus.error) out.error = jobStatus.error;
+    }
+    await applySafetySpec(out, { workspace: cfg.workspace, harInline });
+    return out;
+  }
+  if (status >= 400) {
+    try {
+      const txt2 = Buffer.from(body).toString("utf8");
+      out.ok = false;
+      out.error = JSON.parse(txt2);
+      return out;
+    } catch {
+      out.ok = false;
+      out.error = `HTTP ${status}`;
+      return out;
+    }
+  }
+  if (contentType && contentType.includes("image/png")) {
+    out.rawPngBase64 = abToBase64(body);
+    out.job_id = headers.get("x-job-id") ?? void 0;
+    const duration = headers.get("x-duration-ms");
+    out.duration_ms = duration ? Number(duration) : void 0;
+    out.sync = true;
+    await applySafetySpec(out, { workspace: cfg.workspace, harInline });
+    return out;
+  }
+  const txt = Buffer.from(body).toString("utf8");
+  const json = JSON.parse(txt);
+  Object.assign(out, json);
+  out.job_id = json.job_id ?? json.jobId ?? out.job_id;
+  if (status === 202 && out.job_id && json.status_url) {
+    if (returnAsync) {
+      out.status = "submitted";
+      return out;
+    }
+    const scriptTimeoutMs = (payload.timeout_sec ?? 60) * 1e3;
+    const jobStatus = await pollJobStatus(cfg, out.job_id, scriptTimeoutMs + 3e4);
+    if (jobStatus.status === "poll_timeout" || jobStatus.status === "poll_error" || jobStatus.status === "failed") {
+      out.ok = false;
+      out.status = jobStatus.status;
+      out.error = jobStatus.error || `Job ${jobStatus.status}`;
+      return out;
+    }
+    const artifacts = await fetchArtifactsAndBuild(cfg, out.job_id, merged.include);
+    Object.assign(out, artifacts);
+    out.status = jobStatus.status;
+    out.duration_ms = jobStatus.duration_ms;
+    if (jobStatus.status !== "completed") {
+      out.ok = false;
+      if (jobStatus.timeout) out.timeout = jobStatus.timeout;
+      if (jobStatus.error) out.error = jobStatus.error;
+    }
+    await applySafetySpec(out, { workspace: cfg.workspace, harInline });
+    return out;
+  }
+  if (json.status === "completed_timeout" || json.status === "completed_error") {
+    out.ok = false;
+  }
+  await applySafetySpec(out, { workspace: cfg.workspace, harInline });
+  return out;
+}
+async function riddleApiFetch(config, method, path, body) {
+  const { apiKey, baseUrl } = requireConfig(config);
+  const url = `${baseUrl.replace(/\/$/, "")}${path}`;
+  const res = await fetch(url, {
+    method,
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      ...body ? { "Content-Type": "application/json" } : {}
+    },
+    ...body ? { body: JSON.stringify(body) } : {}
+  });
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error?.message || data.error || `HTTP ${res.status}`);
+  return data;
+}
+async function assertDirectory(dir) {
+  if (!dir || typeof dir !== "string") throw new Error("directory must be an absolute path");
+  try {
+    const st = await (0, import_promises.stat)(dir);
+    if (!st.isDirectory()) throw new Error(`Not a directory: ${dir}`);
+  } catch (e) {
+    return { ok: false, error: `Cannot access directory: ${e.message}` };
+  }
+  return null;
+}
+async function tarDirectory(dir, tarball, excludes, timeout) {
+  const excludeArgs = excludes.flatMap((p) => ["--exclude", p]);
+  await execFile("tar", ["czf", tarball, ...excludeArgs, "-C", dir, "."], { timeout });
+  return (0, import_promises.readFile)(tarball);
+}
+async function saveImageOutputs(workspace, jobId, outputs, label) {
+  for (const output of outputs) {
+    if (output.name && /\.(png|jpg|jpeg)$/i.test(output.name) && output.url) {
+      try {
+        const imgRes = await fetchWithTimeout(output.url, {}, PREVIEW_ARTIFACT_TIMEOUT_MS, `${label} artifact download`);
+        if (imgRes.ok) {
+          const buf = await imgRes.arrayBuffer();
+          const base64 = Buffer.from(buf).toString("base64");
+          const ref = await writeArtifactBinary(workspace, "screenshots", `${jobId}-${output.name}`, base64);
+          output.saved = ref.path;
+          output.sizeBytes = ref.sizeBytes;
+        }
+      } catch {
+      }
+    }
+  }
+}
+async function pollPreviewJob(config, pathPrefix, jobId, timeoutMs, resultExtras) {
+  const endpoint = config.baseUrl.replace(/\/$/, "");
+  const pollStart = Date.now();
+  const pollIntervalMs = 3e3;
+  let lastStatusData = null;
+  while (Date.now() - pollStart < timeoutMs) {
+    let statusRes;
+    try {
+      statusRes = await fetchWithRetry(`${endpoint}${pathPrefix}/${jobId}`, {
+        headers: { Authorization: `Bearer ${config.apiKey}` }
+      }, PREVIEW_REQUEST_TIMEOUT_MS, `${pathPrefix.slice(1)} poll`, { attempts: 2 });
+    } catch (e) {
+      return { ok: false, job_id: jobId, error: `Poll failed: ${describeError(e)}` };
+    }
+    if (!statusRes.ok) {
+      return { ok: false, job_id: jobId, error: `Poll failed: HTTP ${statusRes.status}` };
+    }
+    const statusData = await statusRes.json();
+    lastStatusData = statusData;
+    if (statusData.status === "complete" || statusData.status === "completed" || statusData.status === "failed") {
+      const result = {
+        ok: statusData.status === "complete" || statusData.status === "completed",
+        job_id: jobId,
+        status: statusData.status,
+        phase: statusData.phase ?? statusData.status,
+        phase_updated_at: statusData.phase_updated_at,
+        phase_details: statusData.phase_details,
+        outputs: statusData.outputs || [],
+        compute_seconds: statusData.compute_seconds,
+        egress_bytes: statusData.egress_bytes,
+        ...resultExtras(statusData)
+      };
+      if (statusData.error) result.error = statusData.error;
+      if (statusData.script_error) result.script_error = statusData.script_error;
+      await saveImageOutputs(config.workspace, jobId, result.outputs, pathPrefix.slice(1));
+      result.screenshots = result.outputs.filter((o) => /\.(png|jpg|jpeg)$/i.test(o.name));
+      return result;
+    }
+    await sleep(pollIntervalMs);
+  }
+  return previewTimeoutResult(jobId, timeoutMs, lastStatusData, resultExtras);
+}
+async function createStaticPreview(config, params) {
+  let cfg;
+  try {
+    cfg = requireConfig(config);
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+  const dirError = await assertDirectory(params.directory);
+  if (dirError) return dirError;
+  const endpoint = cfg.baseUrl.replace(/\/$/, "");
+  let createRes;
+  try {
+    createRes = await fetchWithRetry(`${endpoint}/v1/preview`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${cfg.apiKey}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ framework: params.framework || "spa" })
+    }, PREVIEW_REQUEST_TIMEOUT_MS, "preview create");
+  } catch (e) {
+    return { ok: false, error: `Create failed: ${describeError(e)}` };
+  }
+  if (!createRes.ok) {
+    const err = await createRes.text();
+    return { ok: false, error: `Create failed: HTTP ${createRes.status} ${err}` };
+  }
+  const created = await createRes.json();
+  const tarball = `/tmp/riddle-preview-${created.id}.tar.gz`;
+  try {
+    const tarData = await tarDirectory(params.directory, tarball, [], 6e4);
+    let uploadRes;
+    try {
+      uploadRes = await fetchWithRetry(created.upload_url, {
+        method: "PUT",
+        headers: { "Content-Type": "application/gzip" },
+        body: tarData
+      }, PREVIEW_UPLOAD_TIMEOUT_MS, "preview upload");
+    } catch (e) {
+      return { ok: false, id: created.id, error: `Upload failed: ${describeError(e)}` };
+    }
+    if (!uploadRes.ok) {
+      return { ok: false, id: created.id, error: `Upload failed: HTTP ${uploadRes.status}` };
+    }
+  } finally {
+    try {
+      await (0, import_promises.rm)(tarball, { force: true });
+    } catch {
+    }
+  }
+  let publishRes;
+  try {
+    publishRes = await fetchWithTimeout(`${endpoint}/v1/preview/${created.id}/publish`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${cfg.apiKey}` }
+    }, PREVIEW_REQUEST_TIMEOUT_MS, "preview publish");
+  } catch (e) {
+    return { ok: false, id: created.id, error: `Publish failed: ${describeError(e)}` };
+  }
+  if (!publishRes.ok) {
+    const err = await publishRes.text();
+    return { ok: false, id: created.id, error: `Publish failed: HTTP ${publishRes.status} ${err}` };
+  }
+  const published = await publishRes.json();
+  return {
+    ok: true,
+    id: published.id,
+    preview_url: published.preview_url,
+    file_count: published.file_count,
+    total_bytes: published.total_bytes,
+    expires_at: created.expires_at
+  };
+}
+async function deleteStaticPreview(config, id) {
+  let cfg;
+  try {
+    cfg = requireConfig(config);
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+  let res;
+  try {
+    res = await fetchWithTimeout(`${cfg.baseUrl.replace(/\/$/, "")}/v1/preview/${id}`, {
+      method: "DELETE",
+      headers: { Authorization: `Bearer ${cfg.apiKey}` }
+    }, PREVIEW_REQUEST_TIMEOUT_MS, "preview delete");
+  } catch (e) {
+    return { ok: false, error: `Delete failed: ${describeError(e)}` };
+  }
+  if (!res.ok) {
+    const err = await res.text();
+    return { ok: false, error: `Delete failed: HTTP ${res.status} ${err}` };
+  }
+  const data = await res.json();
+  return { ok: true, deleted: true, files_removed: data.files_removed };
+}
+async function storePreviewEnv(cfg, endpointPath, params) {
+  const hasSensitiveEnv = params.sensitive_env && Object.keys(params.sensitive_env).length > 0;
+  const hasLocalStorage = params.localStorage && Object.keys(params.localStorage).length > 0;
+  if (!hasSensitiveEnv && !hasLocalStorage) return { envRef: null };
+  const envBody = {};
+  if (hasSensitiveEnv) envBody.env = params.sensitive_env;
+  if (hasLocalStorage) envBody.localStorage = params.localStorage;
+  let envRes;
+  try {
+    envRes = await fetchWithTimeout(`${cfg.baseUrl.replace(/\/$/, "")}${endpointPath}/env`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${cfg.apiKey}`, "Content-Type": "application/json" },
+      body: JSON.stringify(envBody)
+    }, PREVIEW_REQUEST_TIMEOUT_MS, `${endpointPath.slice(1)} env store`);
+  } catch (e) {
+    return { envRef: null, error: { ok: false, error: `Store env failed: ${describeError(e)}` } };
+  }
+  if (!envRes.ok) {
+    const err = await envRes.text();
+    return { envRef: null, error: { ok: false, error: `Store env failed: HTTP ${envRes.status} ${err}` } };
+  }
+  const envData = await envRes.json();
+  return { envRef: envData.env_ref };
+}
+async function createServerPreview(config, params) {
+  let cfg;
+  try {
+    cfg = requireConfig(config);
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+  const dirError = await assertDirectory(params.directory);
+  if (dirError) return dirError;
+  const endpoint = cfg.baseUrl.replace(/\/$/, "");
+  const env = await storePreviewEnv(cfg, "/v1/server-preview", params);
+  if (env.error) return env.error;
+  const createBody = {
+    image: params.image,
+    command: params.command,
+    port: params.port
+  };
+  for (const key of [
+    "path",
+    "env",
+    "timeout",
+    "readiness_path",
+    "readiness_timeout",
+    "script",
+    "steps",
+    "wait_until",
+    "wait_for_selector",
+    "navigation_timeout",
+    "color_scheme",
+    "viewport"
+  ]) {
+    if (params[key]) createBody[key] = params[key];
+  }
+  if (env.envRef) createBody.env_ref = env.envRef;
+  let createRes;
+  try {
+    createRes = await fetchWithRetry(`${endpoint}/v1/server-preview`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${cfg.apiKey}`, "Content-Type": "application/json" },
+      body: JSON.stringify(createBody)
+    }, PREVIEW_REQUEST_TIMEOUT_MS, "server preview create");
+  } catch (e) {
+    return { ok: false, error: `Create failed: ${describeError(e)}` };
+  }
+  if (!createRes.ok) {
+    const err = await createRes.text();
+    return { ok: false, error: `Create failed: HTTP ${createRes.status} ${err}` };
+  }
+  const created = await createRes.json();
+  const tarball = `/tmp/riddle-sp-${created.job_id}.tar.gz`;
+  try {
+    const tarData = await tarDirectory(params.directory, tarball, params.exclude || [".git", "*.log"], 12e4);
+    let uploadRes;
+    try {
+      uploadRes = await fetchWithRetry(created.upload_url, {
+        method: "PUT",
+        headers: { "Content-Type": "application/gzip" },
+        body: tarData
+      }, PREVIEW_UPLOAD_TIMEOUT_MS, "server preview upload");
+    } catch (e) {
+      return { ok: false, job_id: created.job_id, error: `Upload failed: ${describeError(e)}` };
+    }
+    if (!uploadRes.ok) {
+      return { ok: false, job_id: created.job_id, error: `Upload failed: HTTP ${uploadRes.status}` };
+    }
+  } finally {
+    try {
+      await (0, import_promises.rm)(tarball, { force: true });
+    } catch {
+    }
+  }
+  let startRes;
+  try {
+    startRes = await fetchWithRetry(`${endpoint}/v1/server-preview/${created.job_id}/start`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${cfg.apiKey}` }
+    }, PREVIEW_REQUEST_TIMEOUT_MS, "server preview start");
+  } catch (e) {
+    return { ok: false, job_id: created.job_id, error: `Start failed: ${describeError(e)}` };
+  }
+  if (!startRes.ok) {
+    const err = await startRes.text();
+    if (isAlreadyStartedResponse(startRes.status, err)) {
+      console.warn(`[openclaw-riddledc] server preview start returned ${startRes.status} for ${created.job_id}; continuing to poll`);
+    } else {
+      return { ok: false, job_id: created.job_id, error: `Start failed: HTTP ${startRes.status} ${err}` };
+    }
+  }
+  return pollPreviewJob(cfg, "/v1/server-preview", created.job_id, ((params.timeout || 120) + 60) * 1e3, () => ({}));
+}
+async function createBuildPreview(config, params) {
+  let cfg;
+  try {
+    cfg = requireConfig(config);
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+  const dirError = await assertDirectory(params.directory);
+  if (dirError) return dirError;
+  try {
+    await (0, import_promises.stat)(`${params.directory}/Dockerfile`);
+  } catch {
+    return { ok: false, error: `No Dockerfile found at ${params.directory}/Dockerfile. riddle_build_preview requires a Dockerfile at the root of the directory.` };
+  }
+  const endpoint = cfg.baseUrl.replace(/\/$/, "");
+  const env = await storePreviewEnv(cfg, "/v1/build-preview", params);
+  if (env.error) return env.error;
+  const createBody = {
+    command: params.command,
+    port: params.port
+  };
+  for (const key of [
+    "path",
+    "env",
+    "build_args",
+    "keep_image_minutes",
+    "timeout",
+    "readiness_path",
+    "readiness_timeout",
+    "script",
+    "steps",
+    "wait_until",
+    "wait_for_selector",
+    "navigation_timeout",
+    "color_scheme",
+    "viewport",
+    "audit"
+  ]) {
+    if (params[key] !== void 0) createBody[key] = params[key];
+  }
+  if (env.envRef) createBody.env_ref = env.envRef;
+  let createRes;
+  try {
+    createRes = await fetchWithRetry(`${endpoint}/v1/build-preview`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${cfg.apiKey}`, "Content-Type": "application/json" },
+      body: JSON.stringify(createBody)
+    }, PREVIEW_REQUEST_TIMEOUT_MS, "build preview create");
+  } catch (e) {
+    return { ok: false, error: `Create failed: ${describeError(e)}` };
+  }
+  if (!createRes.ok) {
+    const err = await createRes.text();
+    return { ok: false, error: `Create failed: HTTP ${createRes.status} ${err}` };
+  }
+  const created = await createRes.json();
+  const tarball = `/tmp/riddle-bp-${created.job_id}.tar.gz`;
+  try {
+    const tarData = await tarDirectory(params.directory, tarball, params.exclude || [".git", "*.log"], 12e4);
+    let uploadRes;
+    try {
+      uploadRes = await fetchWithRetry(created.upload_url, {
+        method: "PUT",
+        headers: { "Content-Type": "application/gzip" },
+        body: tarData
+      }, PREVIEW_UPLOAD_TIMEOUT_MS, "build preview upload");
+    } catch (e) {
+      return { ok: false, job_id: created.job_id, error: `Upload failed: ${describeError(e)}` };
+    }
+    if (!uploadRes.ok) {
+      return { ok: false, job_id: created.job_id, error: `Upload failed: HTTP ${uploadRes.status}` };
+    }
+  } finally {
+    try {
+      await (0, import_promises.rm)(tarball, { force: true });
+    } catch {
+    }
+  }
+  let startRes;
+  try {
+    startRes = await fetchWithRetry(`${endpoint}/v1/build-preview/${created.job_id}/start`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${cfg.apiKey}` }
+    }, PREVIEW_REQUEST_TIMEOUT_MS, "build preview start");
+  } catch (e) {
+    return { ok: false, job_id: created.job_id, error: `Start failed: ${describeError(e)}` };
+  }
+  if (!startRes.ok) {
+    const err = await startRes.text();
+    if (isAlreadyStartedResponse(startRes.status, err)) {
+      console.warn(`[openclaw-riddledc] build preview start returned ${startRes.status} for ${created.job_id}; continuing to poll`);
+    } else {
+      return { ok: false, job_id: created.job_id, error: `Start failed: HTTP ${startRes.status} ${err}` };
+    }
+  }
+  return pollPreviewJob(cfg, "/v1/build-preview", created.job_id, ((params.timeout || 180) + 120) * 1e3, (statusData) => ({
+    build_duration_ms: statusData.build_duration_ms,
+    ...statusData.build_log ? { build_log: statusData.build_log } : {},
+    ...statusData.container_log ? { container_log: statusData.container_log } : {},
+    ...statusData.audit ? { audit: statusData.audit } : {}
+  }));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applySafetySpec,
+  assertAllowedBaseUrl,
+  configFromOpenClawApi,
+  createBuildPreview,
+  createServerPreview,
+  createStaticPreview,
+  deleteStaticPreview,
+  describeError,
+  fetchArtifactsAndBuild,
+  fetchWithRetry,
+  fetchWithTimeout,
+  isAlreadyStartedResponse,
+  pollJobStatus,
+  riddleApiFetch,
+  runWithDefaults,
+  writeArtifactBinary
+});