stuntdouble 0.0.0-stage → 0.1.0

package/dist/chunk-JAB46QV7.js

@@ -0,0 +1,506 @@
+// src/files.ts
+import { randomUUID } from "crypto";
+import { appendFile, lstat, mkdir, readdir, readFile, rename, writeFile } from "fs/promises";
+import { dirname, join, sep } from "path";
+import { z } from "zod";
+
+// src/vendor/scoring/conditions.ts
+var CHECKLIST_RUN_CONDITIONS = [
+  "always",
+  "if_previous_passed",
+  "if_previous_failed"
+];
+function quote(description) {
+  const trimmed = description.trim();
+  return trimmed ? `"${trimmed}"` : "the check before it";
+}
+function checkRunIsSkipped(check, previous) {
+  if (check.runCondition === "always") return null;
+  if (!previous) return null;
+  const status = previous.status;
+  if (status === void 0 || status === "error" || status === "informational") return null;
+  if (check.runCondition === "if_previous_passed") {
+    if (status === "passed") return null;
+    return {
+      checkId: check.id,
+      reason: status === "skipped" ? `Skipped: this check runs only when ${quote(previous.description)} passes, and that check was skipped too.` : `Skipped: this check runs only when ${quote(previous.description)} passes, and it failed.`
+    };
+  }
+  if (status === "failed") return null;
+  return {
+    checkId: check.id,
+    reason: status === "skipped" ? `Skipped: this check runs only when ${quote(previous.description)} fails, and that check was skipped.` : `Skipped: this check runs only when ${quote(previous.description)} fails, and it passed.`
+  };
+}
+function resolveSkippedChecks(input) {
+  const effective = new Map(input.statuses);
+  const skipped = [];
+  input.checks.forEach((check, index) => {
+    if (effective.has(check.id)) return;
+    const previousCheck = index > 0 ? input.checks[index - 1] : null;
+    const decision = checkRunIsSkipped(
+      check,
+      previousCheck ? { description: previousCheck.description, status: effective.get(previousCheck.id) } : null
+    );
+    if (!decision) return;
+    skipped.push(decision);
+    effective.set(check.id, "skipped");
+  });
+  return skipped;
+}
+
+// src/vendor/scoring/failure.ts
+var CHECKLIST_FAILURE_ACTIONS = ["continue", "stop"];
+function isChecklistFailureAction(value) {
+  return typeof value === "string" && CHECKLIST_FAILURE_ACTIONS.includes(value);
+}
+function resolveFailureAction(value) {
+  return isChecklistFailureAction(value) ? value : "continue";
+}
+function findHaltingCheck(input) {
+  return input.checks.find(
+    (check) => check.onFailure === "stop" && input.statuses.get(check.id) === "failed"
+  ) ?? null;
+}
+function quote2(description) {
+  const trimmed = description.trim();
+  return trimmed ? `"${trimmed}"` : "a required check";
+}
+function haltedReason(halting) {
+  return `Skipped: the run stopped when ${quote2(halting.description)} failed.`;
+}
+function resolveHaltedChecks(input) {
+  const halting = findHaltingCheck(input);
+  if (!halting) return [];
+  const reason = haltedReason(halting);
+  return input.checks.filter((check) => !input.statuses.has(check.id)).map((check) => ({ checkId: check.id, reason }));
+}
+
+// src/vendor/scoring/scoring.ts
+var CHECKLIST_CHECK_TYPES = ["pass_fail", "weighted", "informational"];
+function isChecklistCheckType(value) {
+  return typeof value === "string" && CHECKLIST_CHECK_TYPES.includes(value);
+}
+function resolveCheckType(value) {
+  return isChecklistCheckType(value) ? value : "pass_fail";
+}
+var CHECKLIST_SCORE_TYPES = ["percent", "points"];
+function isChecklistScoreType(value) {
+  return typeof value === "string" && CHECKLIST_SCORE_TYPES.includes(value);
+}
+function resolveScoreType(value) {
+  return isChecklistScoreType(value) ? value : "percent";
+}
+var DEFAULT_SCORE_UNIT = "points";
+var MAX_SCORE_UNIT_LENGTH = 24;
+function resolveScoreUnit(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim().slice(0, MAX_SCORE_UNIT_LENGTH);
+  return trimmed || null;
+}
+function runScoreUnit(scoreType, scoreUnit) {
+  return resolveScoreType(scoreType) === "points" ? resolveScoreUnit(scoreUnit) ?? DEFAULT_SCORE_UNIT : null;
+}
+function formatScoreValue(value, unit) {
+  if (unit == null) return `${formatScore(value)}%`;
+  const label = Math.abs(value) === 1 && /[^s]s$/i.test(unit) ? unit.slice(0, -1) : unit;
+  return `${formatScore(value)} ${label}`;
+}
+var DEFAULT_CHECK_WEIGHT = 1;
+var MIN_CHECK_WEIGHT = -100;
+var MAX_CHECK_WEIGHT = 100;
+function resolveCheckWeight(value) {
+  const parsed = typeof value === "string" ? Number(value) : value;
+  if (typeof parsed !== "number" || !Number.isFinite(parsed)) return DEFAULT_CHECK_WEIGHT;
+  return Math.min(MAX_CHECK_WEIGHT, Math.max(MIN_CHECK_WEIGHT, parsed));
+}
+function checklistPossibleWeight(checks) {
+  let total = 0;
+  for (const check of checks) {
+    if (typeof check === "string" || resolveCheckType(check.checkType) !== "weighted") continue;
+    const weight = resolveCheckWeight(check.weight);
+    if (weight > 0) total += weight;
+  }
+  return total;
+}
+var DEFAULT_PASS_THRESHOLD = 100;
+var MAX_POINTS_SCORE = 1e5;
+function scoreCeiling(scoreType) {
+  return resolveScoreType(scoreType) === "points" ? MAX_POINTS_SCORE : 100;
+}
+function resolvePassThreshold(value, scoreType) {
+  const parsed = typeof value === "string" ? Number(value) : value;
+  if (typeof parsed !== "number" || !Number.isFinite(parsed)) return DEFAULT_PASS_THRESHOLD;
+  return Math.min(scoreCeiling(scoreType), Math.max(0, parsed));
+}
+function defaultPassThreshold(scoreType, possibleWeight) {
+  return resolveScoreType(scoreType) === "points" ? possibleWeight : DEFAULT_PASS_THRESHOLD;
+}
+function newChecklistScoring(input) {
+  const scoreType = resolveScoreType(input.scoreType);
+  return {
+    score_type: scoreType,
+    score_unit: resolveScoreUnit(input.scoreUnit),
+    pass_threshold: input.passThreshold == null ? resolvePassThreshold(
+      defaultPassThreshold(scoreType, checklistPossibleWeight(input.checks)),
+      scoreType
+    ) : resolvePassThreshold(input.passThreshold, scoreType),
+    score_bands: resolveScoreBands(input.scoreBands, scoreType)
+  };
+}
+var MAX_SCORE_BANDS = 6;
+var MAX_SCORE_BAND_LABEL_LENGTH = 40;
+function resolveScoreBands(value, scoreType) {
+  if (!Array.isArray(value)) return null;
+  const bands = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of value) {
+    if (!entry || typeof entry !== "object") continue;
+    const { label, min } = entry;
+    if (typeof label !== "string") continue;
+    const trimmed = label.trim().slice(0, MAX_SCORE_BAND_LABEL_LENGTH);
+    if (!trimmed) continue;
+    const parsed = typeof min === "string" ? Number(min) : min;
+    if (typeof parsed !== "number" || !Number.isFinite(parsed)) continue;
+    const clamped = Math.min(scoreCeiling(scoreType), Math.max(0, parsed));
+    if (seen.has(clamped)) continue;
+    seen.add(clamped);
+    bands.push({ label: trimmed, min: clamped });
+    if (bands.length === MAX_SCORE_BANDS) break;
+  }
+  if (bands.length === 0) return null;
+  bands.sort((a, b) => b.min - a.min);
+  return bands;
+}
+function gradeForScore(bands, score) {
+  if (score == null || !bands || bands.length === 0) return null;
+  const rank = bands.findIndex((band) => score >= band.min);
+  const index = rank === -1 ? bands.length - 1 : rank;
+  return { label: bands[index].label, rank: index, count: bands.length };
+}
+function scoreChecklistRun(input) {
+  const scoreType = resolveScoreType(input.scoreType);
+  const passThreshold = resolvePassThreshold(
+    input.passThreshold ?? DEFAULT_PASS_THRESHOLD,
+    scoreType
+  );
+  const scoreBands = resolveScoreBands(input.scoreBands, scoreType);
+  const byCheckId = /* @__PURE__ */ new Map();
+  for (const result of input.results) {
+    if (!byCheckId.has(result.checkId)) byCheckId.set(result.checkId, result.status);
+  }
+  let earnedWeight = 0;
+  let possibleWeight = 0;
+  let penaltyWeight = 0;
+  let blockingFailures = 0;
+  let blockingPasses = 0;
+  let inconclusiveCount = 0;
+  let informationalCount = 0;
+  let skippedCount = 0;
+  let weighted = false;
+  let weightedErrored = 0;
+  let stoppedByCheckId = null;
+  for (const check of input.checks) {
+    const status = byCheckId.get(check.id) ?? "error";
+    if (status === "skipped") {
+      skippedCount++;
+      continue;
+    }
+    if (check.checkType === "informational") {
+      if (status !== "error") informationalCount++;
+      continue;
+    }
+    const halted = status === "failed" && resolveFailureAction(check.onFailure) === "stop";
+    if (halted && !stoppedByCheckId) stoppedByCheckId = check.id;
+    if (check.checkType === "weighted") {
+      weighted = true;
+      if (status === "error" || status === "informational") {
+        inconclusiveCount++;
+        weightedErrored++;
+        continue;
+      }
+      const weight = resolveCheckWeight(check.weight);
+      if (weight < 0) {
+        if (status === "failed") {
+          penaltyWeight += -weight;
+          earnedWeight += weight;
+        }
+      } else {
+        possibleWeight += weight;
+        if (status === "passed") earnedWeight += weight;
+      }
+      if (halted) blockingFailures++;
+      continue;
+    }
+    if (status === "passed") blockingPasses++;
+    else if (status === "failed") blockingFailures++;
+    else inconclusiveCount++;
+  }
+  const nothingToScore = possibleWeight === 0 && penaltyWeight === 0;
+  const score = nothingToScore ? null : scoreType === "points" ? Math.round(earnedWeight * 10) / 10 : possibleWeight > 0 ? Math.max(0, Math.round(earnedWeight / possibleWeight * 1e3) / 10) : 0;
+  const nothingJudged = possibleWeight === 0 && penaltyWeight === 0 && blockingPasses === 0 && blockingFailures === 0 && inconclusiveCount > 0;
+  const scoreUnreached = weighted && score === null && weightedErrored > 0;
+  const outcome = blockingFailures > 0 || score !== null && score < passThreshold ? "failed" : nothingJudged || scoreUnreached ? "inconclusive" : "passed";
+  return {
+    score,
+    scoreUnit: runScoreUnit(scoreType, input.scoreUnit),
+    earnedWeight,
+    possibleWeight,
+    penaltyWeight,
+    grade: gradeForScore(scoreBands, score)?.label ?? null,
+    outcome,
+    blockingFailures,
+    blockingPasses,
+    inconclusiveCount,
+    informationalCount,
+    skippedCount,
+    weighted,
+    passThreshold,
+    stoppedByCheckId
+  };
+}
+function describeRunScore(score, counts) {
+  const scored = counts.totalCount - score.informationalCount - score.skippedCount;
+  if (score.weighted && score.score !== null) {
+    const graded = score.grade ? ` (${score.grade})` : "";
+    const unit = score.scoreUnit;
+    const parts = [
+      unit == null ? `Scored ${formatScore(score.score)}%${graded} against a ${formatScore(score.passThreshold)}% threshold` : `Scored ${formatScore(score.score)} of ${formatScoreValue(score.possibleWeight, unit)}${graded} against a threshold of ${formatScore(score.passThreshold)}`
+    ];
+    if (score.penaltyWeight > 0) {
+      parts.push(`${formatScoreValue(score.penaltyWeight, unit ?? DEFAULT_SCORE_UNIT)} deducted`);
+    }
+    if (score.blockingFailures > 0) {
+      parts.push(
+        `${score.blockingFailures} required ${score.blockingFailures === 1 ? "check" : "checks"} failed`
+      );
+    }
+    if (score.informationalCount > 0) {
+      parts.push(`${score.informationalCount} informational`);
+    }
+    if (score.skippedCount > 0) {
+      parts.push(`${score.skippedCount} skipped`);
+    }
+    return parts.join(", ");
+  }
+  const base = score.outcome !== "inconclusive" ? `${counts.passedCount}/${scored} checks passed` : score.weighted && score.blockingPasses > 0 ? `No weighted checks could be evaluated, ${score.blockingPasses} required ${score.blockingPasses === 1 ? "check" : "checks"} passed` : "No checks could be evaluated";
+  const notes = [];
+  if (score.informationalCount > 0) notes.push(`${score.informationalCount} informational`);
+  if (score.skippedCount > 0) notes.push(`${score.skippedCount} skipped`);
+  return notes.length > 0 ? `${base}, ${notes.join(", ")}` : base;
+}
+function formatScore(value) {
+  return Number.isInteger(value) ? String(value) : value.toFixed(1);
+}
+
+// src/files.ts
+var projectDir = () => process.env.STUNTDOUBLE_PROJECT_DIR || process.cwd();
+var sdDir = (project) => join(project, ".stuntdouble");
+var slug = z.string().regex(
+  /^[a-z0-9][a-z0-9-]*$/,
+  'Use lowercase letters, digits and hyphens, e.g. "guest-checkout"'
+);
+var cloud = z.record(z.string(), z.unknown()).nullable().optional();
+var ConfigSchema = z.strictObject({
+  format: z.literal("stuntdouble/1"),
+  /** Local runs swap the checklist URL's origin for this one. */
+  local_base_url: z.url({ protocol: /^https?$/ }).nullable().optional(),
+  headless: z.boolean().default(false),
+  /** Whether screenshots go to the model on every action or only from `screenshot`. */
+  model_screenshots: z.enum(["on_request", "every_action"]).default("on_request"),
+  /** `third_party`: no paying, signing up or secrets on hosts other than the app under test. */
+  safety: z.enum(["third_party", "off"]).default("third_party"),
+  cloud
+});
+var ACTOR_INSTRUCTIONS_MAX_LENGTH = 1e3;
+var ACTOR_KNOWLEDGE_TITLE_MAX_LENGTH = 120;
+var ACTOR_KNOWLEDGE_CONTENT_MAX_LENGTH = 8e3;
+var ActorSchema = z.strictObject({
+  name: z.string().min(1),
+  description: z.string().optional(),
+  system_prompt: z.string().max(ACTOR_INSTRUCTIONS_MAX_LENGTH).optional(),
+  knowledge: z.array(
+    z.strictObject({
+      kind: z.enum(["expertise", "process", "reference", "account"]).default("reference"),
+      title: z.string().min(1).max(ACTOR_KNOWLEDGE_TITLE_MAX_LENGTH),
+      content: z.string().min(1).max(ACTOR_KNOWLEDGE_CONTENT_MAX_LENGTH)
+    })
+  ).default([]),
+  /** Keep this actor's cookies between runs, in ~/.stuntdouble/profiles/<actor>. */
+  persist_login: z.boolean().default(false),
+  cloud
+});
+var CheckSchema = z.strictObject({
+  key: slug,
+  description: z.string().min(1),
+  type: z.enum(CHECKLIST_CHECK_TYPES).default("pass_fail"),
+  weight: z.number().min(MIN_CHECK_WEIGHT).max(MAX_CHECK_WEIGHT).optional(),
+  run_condition: z.enum(CHECKLIST_RUN_CONDITIONS).default("always"),
+  on_failure: z.enum(CHECKLIST_FAILURE_ACTIONS).default("continue")
+});
+var ChecklistSchema = z.strictObject({
+  name: z.string().min(1).max(200),
+  actor: slug,
+  url: z.url({ protocol: /^https?$/ }),
+  instructions: z.string().min(1),
+  checks: z.array(CheckSchema).min(1).refine((checks) => new Set(checks.map((c) => c.key)).size === checks.length, {
+    message: "Every check needs its own key"
+  }),
+  pass_threshold: z.number().min(0).max(MAX_POINTS_SCORE).optional(),
+  score_type: z.enum(CHECKLIST_SCORE_TYPES).default("percent"),
+  score_unit: z.string().max(MAX_SCORE_UNIT_LENGTH).nullable().optional(),
+  score_bands: z.array(
+    z.strictObject({
+      label: z.string().min(1).max(MAX_SCORE_BAND_LABEL_LENGTH),
+      min: z.number().min(0).max(MAX_POINTS_SCORE)
+    })
+  ).max(MAX_SCORE_BANDS).optional(),
+  browser_config: z.strictObject({
+    preset: z.enum(["desktop", "tablet", "mobile"]).optional(),
+    viewport: z.strictObject({
+      width: z.int().min(320).max(2560),
+      height: z.int().min(320).max(2560)
+    }).optional(),
+    touch: z.boolean().optional(),
+    locale: z.string().optional()
+  }).optional(),
+  // Cloud run settings, accepted so the file stays a valid hosted input. Unused locally.
+  record_session: z.boolean().optional(),
+  run_mode: z.enum(["code", "agentic"]).optional(),
+  cloud
+});
+var RUN_STATUSES = ["running", "completed", "stopped", "interrupted", "failed"];
+var RESULT_STATUSES = ["passed", "failed", "informational", "error", "skipped"];
+var LocatorSchema = z.strictObject({
+  text: z.string().optional(),
+  selector: z.string().optional()
+});
+var ResultSchema = z.object({
+  check: z.string(),
+  status: z.enum(RESULT_STATUSES),
+  evidence: z.string(),
+  locator: LocatorSchema.optional(),
+  screenshot: z.string().optional(),
+  at: z.string().optional()
+});
+var RunSchema = z.object({
+  format: z.literal("stuntdouble.run/1"),
+  id: z.string(),
+  runner: z.object({
+    kind: z.enum(["local", "cloud"]),
+    package: z.string().optional(),
+    /** False for a local run: the actor judged its own verdicts. */
+    judged: z.boolean(),
+    run_id: z.string().optional(),
+    url: z.string().optional()
+  }),
+  status: z.enum(RUN_STATUSES),
+  pid: z.number().optional(),
+  url: z.string(),
+  started_at: z.string(),
+  finished_at: z.string().nullable(),
+  checklist: z.string(),
+  actor: z.string(),
+  checklist_snapshot: z.object({ checks: z.array(CheckSchema) }).loose(),
+  results: z.array(ResultSchema),
+  score: z.object({
+    score: z.number().nullable(),
+    outcome: z.enum(["passed", "failed", "inconclusive"]),
+    // A local run writes all three; a cloud run written by hand may leave them out.
+    unit: z.string().nullish(),
+    pass_threshold: z.number().nullish(),
+    grade: z.string().nullish()
+  }).nullable(),
+  summary: z.string().nullable(),
+  cloud: z.unknown().nullable()
+});
+function describeIssues(file, error) {
+  return error.issues.map((issue) => `${file}: ${issue.path.join(".") || "(top level)"}: ${issue.message}`).join("\n");
+}
+async function readJson(path, schema, label = path) {
+  let raw;
+  try {
+    raw = await readFile(path, "utf8");
+  } catch {
+    throw new Error(`${label}: file not found`);
+  }
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`${label}: not valid JSON (${err.message})`, { cause: err });
+  }
+  const parsed = schema.safeParse(data);
+  if (!parsed.success) throw new Error(describeIssues(label, parsed.error));
+  return parsed.data;
+}
+async function writeJsonAtomic(path, data) {
+  await writeFileAtomic(path, `${JSON.stringify(data, null, 2)}
+`);
+}
+async function writeFileAtomic(path, data) {
+  await mkdir(dirname(path), { recursive: true });
+  await refuseLinks(path);
+  const tmp = `${path}.${randomUUID()}.tmp`;
+  await writeFile(tmp, data, { mode: 384 });
+  await rename(tmp, path);
+}
+async function appendJsonl(path, line) {
+  await refuseLinks(path);
+  await appendFile(path, `${JSON.stringify(line)}
+`);
+}
+async function refuseLinks(path) {
+  const parts = path.split(sep);
+  const from = parts.lastIndexOf(".stuntdouble");
+  if (from < 0) return;
+  for (let i = from + 1; i <= parts.length; i++) {
+    const info = await lstat(parts.slice(0, i).join(sep)).catch(() => null);
+    if (info?.isSymbolicLink())
+      throw new Error(`Refusing to write through a symlink: ${parts.slice(0, i).join(sep)}`);
+  }
+}
+function isAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+var effectiveStatus = (run) => run.status === "running" && !isAlive(run.pid) ? "interrupted" : run.status;
+async function readRuns(root) {
+  const ids = await readdir(join(root, "runs")).catch(() => []);
+  const entries = await Promise.all(
+    ids.filter((id) => !id.startsWith(".")).map(async (id) => {
+      try {
+        return { id, run: await readJson(join(root, "runs", id, "run.json"), RunSchema) };
+      } catch (err) {
+        return { id, error: err.message };
+      }
+    })
+  );
+  return entries.sort((a, b) => a.id < b.id ? 1 : -1);
+}
+
+export {
+  resolveSkippedChecks,
+  resolveHaltedChecks,
+  newChecklistScoring,
+  scoreChecklistRun,
+  describeRunScore,
+  projectDir,
+  sdDir,
+  ConfigSchema,
+  ActorSchema,
+  ChecklistSchema,
+  readJson,
+  writeJsonAtomic,
+  writeFileAtomic,
+  appendJsonl,
+  isAlive,
+  effectiveStatus,
+  readRuns
+};
+//# sourceMappingURL=chunk-JAB46QV7.js.map