@runcofactor/cli 0.52.0 → 0.53.0

package/dist/perf-CCHWHCSR.js

@@ -0,0 +1,961 @@
+import { createRequire as __cr } from "module"; import { fileURLToPath as __fup } from "url"; import { dirname as __dn } from "path"; const require = __cr(import.meta.url); const __filename = __fup(import.meta.url); const __dirname = __dn(__filename);
+import {
+  RULES_PATH,
+  buildScheduleTriggerConfig
+} from "./chunk-OQFCZERZ.js";
+import "./chunk-LJFVRJCA.js";
+import {
+  resolveApplicationId
+} from "./chunk-JEHHEMUL.js";
+import "./chunk-RVD6J6IZ.js";
+import "./chunk-EJ3ZPH5U.js";
+import "./chunk-DEK6B6LX.js";
+import {
+  apiRequest,
+  getGuideSectionArg,
+  getPositionalArg,
+  getScalarArgValue
+} from "./chunk-VKZOHJCE.js";
+import "./chunk-S3Q7MDCS.js";
+import "./chunk-4UZN6TVT.js";
+import {
+  GLOBAL_VALUE_FLAGS,
+  hasFlag,
+  resolveConfig
+} from "./chunk-WRBU6TX7.js";
+import {
+  PERF_GUIDE_SECTIONS,
+  printGuide,
+  writeRawOutput
+} from "./chunk-MJVUMVLO.js";
+import "./chunk-TOWZAG3I.js";
+
+// src/perf.ts
+import { readFile } from "fs/promises";
+import { dirname, resolve } from "path";
+import { setTimeout as sleep } from "timers/promises";
+import { parse } from "yaml";
+
+// ../ids/src/registry.ts
+var EntityPrefix = {
+  agentEval: "aeval",
+  agentEvalCase: "aecase",
+  agentEvalRun: "aerun",
+  agentEvalAttempt: "aeatt",
+  organization: "org",
+  workflow: "wf",
+  workflowTestExecution: "exec",
+  workflowTestRun: "trun",
+  workflowRun: "wrun",
+  adhocTest: "adhoc",
+  exploratoryTest: "expt",
+  perfTest: "ptest",
+  perfRun: "prun",
+  issue: "iss",
+  property: "prop",
+  credential: "cred",
+  credentialTemplate: "ctpl",
+  syntheticUniverse: "su",
+  syntheticUser: "sp",
+  syntheticUserRun: "sr",
+  userEvent: "uev",
+  userEventDashboard: "ued",
+  userEventDashboardCard: "uedc",
+  triageRun: "trg",
+  triageFinding: "trgf",
+  phoneNumber: "phn",
+  textMessage: "sms",
+  productArea: "parea",
+  productCapability: "pcap",
+  productCapabilityRule: "prule",
+  landingPage: "lp",
+  prReview: "prr",
+  digest: "dig",
+  explorationCycle: "excy",
+  explorationLead: "exld",
+  testSignInProvider: "tsp",
+  testSignInClient: "tsc",
+  testSignInGrant: "tsg",
+  pullRequestProofRecord: "proof"
+};
+var ENTITY_REGISTRY = {
+  aeval: { tableName: "agent_evals", orgIdColumn: "org_id", idColumn: "id" },
+  aecase: { tableName: "agent_eval_cases", orgIdColumn: "org_id", idColumn: "id" },
+  aerun: { tableName: "agent_eval_runs", orgIdColumn: "org_id", idColumn: "id" },
+  aeatt: { tableName: "agent_eval_attempts", orgIdColumn: "org_id", idColumn: "id" },
+  org: {
+    tableName: "organizations",
+    orgIdColumn: null,
+    idColumn: "id"
+  },
+  wf: {
+    tableName: "workflows",
+    orgIdColumn: "org_id",
+    idColumn: "id",
+    buildUrl: ({ prefixedId }) => `/flows/${prefixedId}`
+  },
+  exec: {
+    tableName: "workflow_test_executions",
+    orgIdColumn: "org_id",
+    idColumn: "id",
+    buildUrl: ({ prefixedId }) => `/runs/test/${prefixedId}`
+  },
+  trun: {
+    tableName: "workflow_test_runs",
+    orgIdColumn: "org_id",
+    idColumn: "id",
+    buildUrl: ({ parentPrefixedId }) => `/runs/test/${parentPrefixedId}`,
+    parentLookup: {
+      foreignKey: "execution_id",
+      parentPrefix: "exec"
+    }
+  },
+  wrun: {
+    tableName: "workflow_runs",
+    orgIdColumn: "org_id",
+    idColumn: "id"
+    // Needs propertyId parent — not yet implemented
+  },
+  adhoc: {
+    tableName: "adhoc_tests",
+    orgIdColumn: "org_id",
+    idColumn: "id",
+    buildUrl: ({ prefixedId }) => `/exploratory/${prefixedId}`
+  },
+  expt: {
+    tableName: "exploratory_tests",
+    orgIdColumn: "org_id",
+    idColumn: "id"
+  },
+  ptest: {
+    tableName: "perf_tests",
+    orgIdColumn: "org_id",
+    idColumn: "id"
+  },
+  prun: {
+    tableName: "perf_runs",
+    orgIdColumn: "org_id",
+    idColumn: "id"
+  },
+  iss: {
+    tableName: "issues",
+    orgIdColumn: "org_id",
+    idColumn: "id",
+    buildUrl: ({ prefixedId }) => `/issues?issueId=${prefixedId}`
+  },
+  prop: {
+    tableName: "org_properties",
+    orgIdColumn: "org_id",
+    idColumn: "id",
+    buildUrl: ({ prefixedId }) => `/properties/${prefixedId}`
+  },
+  cred: {
+    tableName: "org_property_credentials",
+    orgIdColumn: "org_id",
+    idColumn: "id"
+  },
+  ctpl: {
+    tableName: "credential_templates",
+    orgIdColumn: "org_id",
+    idColumn: "id"
+  },
+  su: {
+    tableName: "synthetic_universes",
+    orgIdColumn: "org_id",
+    idColumn: "id",
+    buildUrl: ({ prefixedId }) => `/synthetic-users/${prefixedId}`
+  },
+  sp: {
+    tableName: "synthetic_users",
+    orgIdColumn: "org_id",
+    idColumn: "id"
+  },
+  sr: {
+    tableName: "synthetic_user_runs",
+    orgIdColumn: "org_id",
+    idColumn: "id"
+  },
+  uev: {
+    tableName: "user_events",
+    orgIdColumn: "org_id",
+    idColumn: "id"
+  },
+  ued: {
+    tableName: "user_event_dashboards",
+    orgIdColumn: null,
+    idColumn: "id"
+  },
+  uedc: {
+    tableName: "user_event_dashboard_cards",
+    orgIdColumn: null,
+    idColumn: "id"
+  },
+  trg: {
+    tableName: "triage_runs",
+    orgIdColumn: "org_id",
+    idColumn: "id",
+    buildUrl: ({ parentPrefixedId }) => parentPrefixedId ? `/runs/test/${parentPrefixedId}?tab=triage` : "/runs/test",
+    parentLookup: {
+      foreignKey: "workflow_test_execution_id",
+      parentPrefix: "exec"
+    }
+  },
+  trgf: {
+    tableName: "triage_findings",
+    orgIdColumn: "org_id",
+    idColumn: "id"
+  },
+  phn: {
+    tableName: "messaging_phone_numbers",
+    orgIdColumn: "owner_org_id",
+    idColumn: "id"
+  },
+  sms: {
+    tableName: "text_messages",
+    orgIdColumn: "org_id",
+    idColumn: "id"
+  },
+  parea: {
+    tableName: "product_areas",
+    orgIdColumn: "org_id",
+    idColumn: "id",
+    buildUrl: ({ prefixedId }) => `/product-map?area=${prefixedId}`,
+    naturalCodePrefix: "ARE"
+  },
+  pcap: {
+    tableName: "product_capabilities",
+    orgIdColumn: "org_id",
+    idColumn: "id",
+    buildUrl: ({ prefixedId }) => `/product-map?capability=${prefixedId}`,
+    naturalCodePrefix: "CAP"
+  },
+  prule: {
+    tableName: "product_capability_rules",
+    orgIdColumn: "org_id",
+    idColumn: "id"
+  },
+  // No buildUrl: landing pages are authored from the CLI and served at
+  // runcofactor.com/lp/<slug> — there is no in-app detail route to link to.
+  //
+  // Deliberately NO `lpv` prefix for landing_page_variants. That table has no
+  // org_id column, and `orgIdColumn: null` does not mean "child table" here —
+  // resolveEntityOrg (apps/api/src/middleware/resolve-entity-org.ts) reads it
+  // as "the ID *is* the orgId" and compares the UUID against the caller's org,
+  // so a variant routed through the generic middleware would be rejected for
+  // the wrong reason. Variants are addressed by (page slug, variant name);
+  // add a prefix only together with real parent-resolving lookup support.
+  lp: {
+    tableName: "landing_pages",
+    orgIdColumn: "org_id",
+    idColumn: "id"
+  },
+  prr: {
+    tableName: "pr_reviews",
+    orgIdColumn: "org_id",
+    idColumn: "id",
+    buildUrl: ({ prefixedId }) => `/pr-reviews/${prefixedId}`
+  },
+  dig: {
+    tableName: "org_digests",
+    orgIdColumn: "org_id",
+    idColumn: "id",
+    buildUrl: ({ prefixedId }) => `/digests/${prefixedId}`
+  },
+  excy: {
+    tableName: "exploration_cycles",
+    orgIdColumn: "org_id",
+    idColumn: "id",
+    buildUrl: ({ prefixedId }) => `/explore/cycles/${prefixedId}`
+  },
+  exld: {
+    tableName: "exploration_leads",
+    orgIdColumn: "org_id",
+    idColumn: "id"
+  },
+  tsp: {
+    tableName: "test_sign_in_providers",
+    orgIdColumn: "org_id",
+    idColumn: "id"
+  },
+  tsc: {
+    tableName: "test_sign_in_clients",
+    orgIdColumn: "org_id",
+    idColumn: "id"
+  },
+  tsg: {
+    tableName: "test_sign_in_grants",
+    orgIdColumn: "org_id",
+    idColumn: "id"
+  },
+  proof: {
+    tableName: "pull_request_proof_records",
+    orgIdColumn: "org_id",
+    idColumn: "id",
+    buildUrl: ({ prefixedId }) => `/proofs/${prefixedId}`
+  }
+};
+Object.freeze(ENTITY_REGISTRY);
+var SAFE_IDENT = /^[a-z_][a-z0-9_]*$/;
+for (const [prefix, entry] of Object.entries(ENTITY_REGISTRY)) {
+  for (const field of [entry.tableName, entry.orgIdColumn, entry.idColumn].filter(
+    Boolean
+  )) {
+    if (!SAFE_IDENT.test(field)) {
+      throw new Error(`Invalid identifier in ENTITY_REGISTRY['${prefix}']: "${field}"`);
+    }
+  }
+}
+var VALID_PREFIXES = new Set(Object.keys(ENTITY_REGISTRY));
+
+// ../ids/src/base58.ts
+var ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var BASE = 58;
+var ALPHABET_MAP = /* @__PURE__ */ new Map();
+for (let i = 0; i < ALPHABET.length; i++) {
+  ALPHABET_MAP.set(ALPHABET[i], i);
+}
+function decodeBase58(str) {
+  if (str.length === 0) return new Uint8Array(0);
+  let leadingOnes = 0;
+  while (leadingOnes < str.length && str[leadingOnes] === ALPHABET[0]) {
+    leadingOnes++;
+  }
+  const bytes = [];
+  for (let i = leadingOnes; i < str.length; i++) {
+    const value = ALPHABET_MAP.get(str[i]);
+    if (value === void 0) return null;
+    let carry = value;
+    for (let j = 0; j < bytes.length; j++) {
+      carry += bytes[j] * BASE;
+      bytes[j] = carry & 255;
+      carry >>= 8;
+    }
+    while (carry > 0) {
+      bytes.push(carry & 255);
+      carry >>= 8;
+    }
+  }
+  const result = new Uint8Array(leadingOnes + bytes.length);
+  for (let i = 0; i < bytes.length; i++) {
+    result[leadingOnes + i] = bytes[bytes.length - 1 - i];
+  }
+  return result;
+}
+
+// ../ids/src/prefixed-id.ts
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var PREFIXED_RE = /^([a-z]{2,6})_([1-9A-HJ-NP-Za-km-z]+)$/;
+function bytesToUuid(bytes) {
+  const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function decodePrefixedId(id) {
+  const match = id.match(PREFIXED_RE);
+  if (!match) return null;
+  const prefix = match[1];
+  if (!VALID_PREFIXES.has(prefix)) return null;
+  const decoded = decodeBase58(match[2]);
+  if (!decoded || decoded.length < 16 || decoded.length > 17) return null;
+  let normalized = decoded;
+  if (decoded.length === 17) {
+    if (decoded[0] !== 0) return null;
+    normalized = decoded.slice(1);
+  }
+  return { prefix, uuid: bytesToUuid(normalized) };
+}
+function parseAnyId(input) {
+  const decoded = decodePrefixedId(input);
+  if (decoded) return { kind: "prefixed", ...decoded };
+  if (UUID_RE.test(input)) return { kind: "raw_uuid", uuid: input.toLowerCase() };
+  return { kind: "invalid" };
+}
+
+// ../ids/src/entity-link.ts
+var prefixAlternation = Object.values(EntityPrefix).sort((left, right) => right.length - left.length).join("|");
+var BARE_ENTITY_ID = new RegExp(
+  `(^|[^A-Za-z0-9_])((?:${prefixAlternation})_[1-9A-HJ-NP-Za-km-z]+)(?![A-Za-z0-9_])`,
+  "g"
+);
+
+// ../ids/src/types.ts
+function extractUuid(raw) {
+  if (!raw) return null;
+  const parsed = parseAnyId(raw);
+  if (parsed.kind === "prefixed") return parsed.uuid.toLowerCase();
+  if (parsed.kind === "raw_uuid") return parsed.uuid.toLowerCase();
+  return null;
+}
+
+// ../types/src/perf-config.ts
+import { z } from "zod";
+var k6Load = {
+  vus: z.number().int().min(1).max(200),
+  durationSeconds: z.number().int().min(10).max(300),
+  as: z.string().min(1).optional()
+};
+var estimatePerfSeconds = (config) => (config.rounds + 1) * ((config.lighthouse?.pages.length ?? 0) * 45 + (config.k6?.durationSeconds ?? 0) + 30) * 2 + 600;
+var perfBase = {
+  rounds: z.number().int().min(5).max(15).default(7),
+  lighthouse: z.strictObject({
+    formFactor: z.enum(["desktop", "mobile"]),
+    pages: z.array(z.strictObject({
+      name: z.string().min(1).max(40).regex(/^[a-z0-9-]+$/),
+      path: z.string().startsWith("/").refine((path) => !path.startsWith("//"), "path must be relative, not protocol-relative").refine((path) => !path.includes("\\"), "path must not contain backslashes"),
+      as: z.string().min(1).optional()
+    })).min(1).max(10)
+  }).optional()
+};
+var withPerfRules = (schema) => schema.refine((config) => config.lighthouse !== void 0 || config.k6 !== void 0, {
+  message: "configure at least one of lighthouse or k6"
+}).refine((config) => estimatePerfSeconds(config) <= 5400, {
+  message: "estimated run time exceeds 90 minutes; reduce rounds, pages or duration"
+});
+var PerfConfigSchema = withPerfRules(
+  z.strictObject({
+    ...perfBase,
+    k6: z.strictObject({ script: z.string().min(1), ...k6Load }).optional()
+  })
+);
+var StoredPerfConfigSchema = withPerfRules(
+  z.strictObject({
+    ...perfBase,
+    k6: z.strictObject({ scriptSource: z.string().min(1).max(2e5), ...k6Load }).optional()
+  })
+);
+
+// ../types/src/perf-result.ts
+import { z as z2 } from "zod";
+var PerfArmSchema = z2.enum(["base", "head"]);
+var PerfVerdictSchema = z2.enum(["faster", "slower", "no_change"]);
+var PerfRunStatusSchema = z2.enum(["queued", "running", "completed", "failed"]);
+function usesAbsoluteDifference(row) {
+  return row.unit === "ratio" || row.base.values.includes(0);
+}
+
+// ../types/src/perf-round.ts
+import { z as z3 } from "zod";
+var RunnerConfigSchema = StoredPerfConfigSchema.safeExtend({
+  /** HTTPS URL for the claimed sandbox's public app port. */
+  baseUrl: z3.url({ protocol: /^https$/ }),
+  otelExpected: z3.boolean()
+});
+var LighthousePageRoundSchema = z3.strictObject({
+  name: z3.string().min(1),
+  lcpMs: z3.number().nonnegative(),
+  tbtMs: z3.number().nonnegative(),
+  fcpMs: z3.number().nonnegative(),
+  cls: z3.number().nonnegative(),
+  speedIndexMs: z3.number().nonnegative(),
+  bytes: z3.number().nonnegative(),
+  finalUrl: z3.string().min(1),
+  documentStatus: z3.number().int()
+});
+var K6RoundSchema = z3.strictObject({
+  p50Ms: z3.number().nonnegative(),
+  p95Ms: z3.number().nonnegative(),
+  requestsPerSecond: z3.number().nonnegative(),
+  errorRate: z3.number().nonnegative()
+});
+var OtelEndpointRoundSchema = z3.strictObject({
+  endpoint: z3.string().min(1),
+  count: z3.number().int().nonnegative(),
+  p50Ms: z3.number().nonnegative(),
+  p95Ms: z3.number().nonnegative()
+});
+var PerfRoundSlowSpanSchema = z3.strictObject({
+  name: z3.string().min(1),
+  count: z3.number().int().nonnegative(),
+  p95Ms: z3.number().nonnegative(),
+  totalMs: z3.number().nonnegative()
+});
+var RoundSummarySchema = z3.strictObject({
+  round: z3.number().int().positive(),
+  arm: PerfArmSchema,
+  lighthouse: z3.array(LighthousePageRoundSchema).optional(),
+  k6: K6RoundSchema.optional(),
+  otel: z3.strictObject({
+    endpoints: z3.array(OtelEndpointRoundSchema),
+    topSlowSpans: z3.array(PerfRoundSlowSpanSchema)
+  }).optional()
+});
+
+// ../types/src/perf-render.ts
+function renderPerfResult(input) {
+  const heading = input.verdict === "slower" ? "SLOWER" : input.verdict === "faster" ? "faster" : "no change";
+  const visibleRows = input.result.rows.filter(
+    (row) => row.gated || row.flavor === "otel" && row.id.endsWith(":p95") && (row.base.values.length < input.result.rounds || row.head.values.length < input.result.rounds)
+  );
+  const omittedUngatedRows = input.result.rows.filter((row) => !visibleRows.includes(row));
+  const lines = [
+    `## Perf: ${heading} (head ${shortSha(input.headSha)} vs base ${shortSha(input.baseSha)}, ${input.result.rounds} rounds)`,
+    "",
+    "| Metric | Base | Head | Delta | 95% CI | Verdict |",
+    "|---|---|---|---|---|---|",
+    ...visibleRows.map((row) => renderRow(row, input.result.rounds))
+  ];
+  const ungated = omittedUngatedRows.length;
+  if (ungated > 0)
+    lines.push(
+      "",
+      `Not gated: ${ungated} more rows (${ungatedLabels(omittedUngatedRows)}). \`--json\` for all rows.`
+    );
+  const tools = [
+    input.result.tools.lighthouse && `lighthouse ${input.result.tools.lighthouse}`,
+    input.result.tools.k6 && `k6 ${input.result.tools.k6}`,
+    input.result.tools.otelcol && `otelcol-contrib ${input.result.tools.otelcol}`
+  ].filter((tool) => tool !== void 0);
+  if (ungated === 0) lines.push("");
+  lines.push(`Tools: ${tools.length > 0 ? tools.join(", ") : "none"}. Run: ${input.id}.`);
+  if (input.verdict === "slower" && input.result.otel) {
+    lines.push(
+      "",
+      "### Slowest server spans (head)",
+      "",
+      ...renderSpans(input.result.otel.topSlowSpans.head.slice(0, 5))
+    );
+    const baseByName = new Map(
+      input.result.otel.topSlowSpans.base.map((span) => [span.name, span])
+    );
+    const slower = input.result.otel.topSlowSpans.head.filter((span) => {
+      const base = baseByName.get(span.name);
+      return !base || span.p95Ms > base.p95Ms;
+    });
+    if (slower.length > 0)
+      lines.push("", "### New or slower than base", "", ...renderSpans(slower));
+  }
+  return lines.join("\n");
+}
+function ungatedLabels(rows) {
+  const labels = rows.map((row) => {
+    if (row.id.endsWith(":fcp")) return "FCP";
+    if (row.id.endsWith(":cls")) return "CLS";
+    if (row.id.endsWith(":speed-index")) return "speed index";
+    if (row.id.endsWith(":bytes")) return "bytes";
+    if (row.id.endsWith(":p50")) return "p50s";
+    return row.label;
+  });
+  const order = ["FCP", "CLS", "speed index", "bytes", "p50s"];
+  const standard = order.filter((label) => labels.includes(label));
+  const extra = [...new Set(labels.filter((label) => !order.includes(label)))];
+  return [...standard, ...extra].join(", ");
+}
+function renderRow(row, rounds) {
+  const sparseEndpoint = row.flavor === "otel" && row.id.endsWith(":p95") && (row.base.values.length < rounds || row.head.values.length < rounds);
+  const verdict = row.verdict === "slower" ? "SLOWER" : row.verdict.replace("_", " ");
+  const label = sparseEndpoint ? `${row.label} (not gated)` : row.label;
+  return `| ${escapeCell(label)} | ${formatArmValue(row.base, row.unit)} | ${formatArmValue(row.head, row.unit)} | ${formatDelta(row)} | ${formatInterval(row)} | ${verdict} |`;
+}
+function formatArmValue(arm, unit) {
+  return arm.values.length === 0 ? "-" : formatValue(arm.median, unit);
+}
+function formatValue(value, unit) {
+  switch (unit) {
+    case "ms":
+      return `${round(value)} ms`;
+    case "rps":
+      return `${round(value)}`;
+    case "ratio":
+      return `${(value * 100).toFixed(1)}%`;
+    case "bytes":
+      return `${round(value)} bytes`;
+    case "count":
+      return `${round(value)}`;
+  }
+}
+function formatDelta(row) {
+  const missingBase = row.base.values.length === 0;
+  const missingHead = row.head.values.length === 0;
+  if (missingBase) return "new";
+  if (missingHead) return "removed";
+  if (row.unit === "ratio") return `${signed(row.deltaPct, 1)} pt`;
+  const displayedDelta = row.unit === "rps" ? -row.deltaPct : row.deltaPct;
+  if (usesAbsoluteDifference(row)) {
+    return `${signed(displayedDelta, 0)}${unitSuffix(row.unit)}`;
+  }
+  return `${signed(displayedDelta * 100, 1)}%`;
+}
+function formatInterval(row) {
+  const missingBase = row.base.values.length === 0;
+  const missingHead = row.head.values.length === 0;
+  if (missingBase || missingHead) return "-";
+  const absolute = usesAbsoluteDifference(row);
+  const suffix = row.unit === "ratio" ? " pt" : absolute ? unitSuffix(row.unit) : "%";
+  const scale = row.unit === "ratio" || absolute ? 1 : 100;
+  const precision = suffix === "%" || row.unit === "ratio" ? 1 : 0;
+  const lowerBound = row.unit === "rps" ? -row.ci95[1] : row.ci95[0];
+  const upperBound = row.unit === "rps" ? -row.ci95[0] : row.ci95[1];
+  const lower = signed(lowerBound * scale, precision);
+  const upper = signed(upperBound * scale, precision);
+  return suffix === "%" ? `${lower}% .. ${upper}%` : `${lower} .. ${upper}${suffix}`;
+}
+function unitSuffix(unit) {
+  switch (unit) {
+    case "ms":
+      return " ms";
+    case "rps":
+      return " rps";
+    case "ratio":
+      return " pt";
+    case "bytes":
+      return " bytes";
+    case "count":
+      return "";
+  }
+}
+function renderSpans(spans) {
+  if (spans.length === 0) return ["No server spans."];
+  return [
+    "| Name | Count | Worst round p95 | Total duration |",
+    "|---|---:|---:|---:|",
+    ...spans.map(
+      (span) => `| ${escapeCell(span.name)} | ${span.count} | ${round(span.p95Ms)} ms | ${round(span.totalMs)} ms |`
+    )
+  ];
+}
+function shortSha(sha) {
+  return sha.slice(0, 7);
+}
+function signed(value, precision = 1) {
+  const rounded = Number(value.toFixed(precision));
+  return `${rounded >= 0 ? "+" : ""}${rounded.toFixed(precision)}`;
+}
+function round(value) {
+  return Number(value.toFixed(1));
+}
+function escapeCell(value) {
+  return value.replaceAll("|", "\\|").replaceAll("\n", " ");
+}
+
+// src/perf.ts
+var TESTS = "/org/perf/tests";
+var RUNS = "/org/perf/runs";
+var ACTION = "perf-test.run";
+var TIMING_FLAGS = ["--schedule", "--cron", "--at", "--every", "--timezone"];
+var VALUE_FLAGS = [
+  ...GLOBAL_VALUE_FLAGS,
+  ...TIMING_FLAGS,
+  "--config",
+  "--application",
+  "--environment",
+  "--test",
+  "--base",
+  "--head",
+  "--name",
+  "--limit"
+];
+var USAGE = {
+  run: "run (--config perf.yaml --application <app> [--environment E] | --test <name|id>) [--base <version>] --head <version>",
+  save: "save --config perf.yaml --name <n> --application <app> [--environment E] [--on-merge] [<timing flag>]",
+  guide: "guide",
+  list: "list",
+  get: "get <test-name|ptest_id|prun_id>",
+  runs: "runs <test-name|ptest_id> [--limit N]",
+  delete: "delete <test-name|ptest_id>"
+};
+function printHelp(command) {
+  const usage = Object.hasOwn(USAGE, command ?? "") ? USAGE[command] : void 0;
+  console.log(
+    [
+      `Usage: cofactor perf ${usage ?? "<sub-command>"} [--json]`,
+      "",
+      ...Object.values(USAGE).map((line) => `  cofactor perf ${line}`),
+      "",
+      "guide: prints the offline performance-test guide (no login needed).",
+      "run: validates YAML, inlines k6.script relative to perf.yaml, and waits for the run.",
+      "  --head and --base take a commit SHA, a push id or a tag.",
+      "  Base defaults to the environment head for GitHub apps, or the ready push before head for uploaded apps.",
+      "  Polls every 5 seconds for at most 4 hours. A timeout leaves the run available via get.",
+      "save: replaces the test and its schedule by name. Without a timing flag or --on-merge, it is manual.",
+      "  --on-merge runs the test for merges into the repository default branch (GitHub applications only).",
+      "  Leaving --on-merge off clears the marker.",
+      "  One timing flag: --schedule <text> | --cron <expr> | --at <HH:mm> | --every <30m|2h>",
+      "  --timezone <zone> applies to the schedule (default UTC).",
+      "  Scheduling requires the server automation action perf-test.run.",
+      "list: saved tests. get: a prun_ id selects a run; a ptest_ id or name selects a test.",
+      "runs: recent runs for a test, newest first; --limit defaults to 20 (1..100).",
+      "delete: deletes the test, its automation rules, and its runs (API cascade).",
+      "",
+      "Common options:",
+      "  --org <name|id>    Logged-in organization; required explicitly for run, save, delete",
+      "  --env <env>        API environment (prod, dev, local); distinct from --environment",
+      "  --api-url <url>    API URL override",
+      "  --token <key>      API token override",
+      "  --json             Raw JSON on every sub-command; runs flatten PerfResult into run metadata",
+      "  --help, -h         Show help without authentication",
+      "",
+      "Requires the sandbox-v2 organization flag. API-key scopes:",
+      "  run/save: sandbox:create + sandbox:exec; run/get/runs reads: sandbox:read; delete: sandbox:edit.",
+      "  save/list/delete also use automation rules routes and require full API-key access (*).",
+      "",
+      "Exit codes (run):",
+      "  0  no_change or faster",
+      "  3  slower",
+      "  1  Failed run, polling timeout, or any error",
+      "Other sub-commands exit 0 on success, 1 on error."
+    ].join("\n")
+  );
+}
+function required(argv, flag) {
+  const value = getScalarArgValue(argv, flag);
+  if (!value) throw new Error(`${flag} is required.`);
+  return value;
+}
+async function readConfig(file) {
+  const config = PerfConfigSchema.parse(parse(await readFile(file, "utf8")));
+  const { k6, ...rest } = config;
+  if (!k6) return StoredPerfConfigSchema.parse(rest);
+  const { script, ...load } = k6;
+  const scriptSource = await readFile(resolve(dirname(file), script), "utf8");
+  return StoredPerfConfigSchema.parse({ ...rest, k6: { ...load, scriptSource } });
+}
+async function request(apiUrl, token, method, path, body) {
+  const response = await apiRequest(apiUrl, token, method, path, body);
+  if (!response.ok || response.data === void 0) {
+    throw new Error(
+      `${response.code ? `${response.code}: ` : ""}${response.error ?? `${method} ${path} failed`}`
+    );
+  }
+  return response.data;
+}
+async function resolveTest(apiUrl, token, name) {
+  if (name.startsWith("ptest_"))
+    return request(apiUrl, token, "GET", `${TESTS}/${encodeURIComponent(name)}`);
+  const tests = await request(apiUrl, token, "GET", TESTS);
+  const test = tests.find((test2) => test2.name === name);
+  if (!test) throw new Error(`Perf test "${name}" not found.`);
+  return test;
+}
+function testUuid(test) {
+  const id = extractUuid(test.id);
+  if (!id) throw new Error(`Invalid perf test id: ${test.id}`);
+  return id;
+}
+async function listRules(apiUrl, token) {
+  const rules = [];
+  let page = 1;
+  let totalPages;
+  do {
+    const response = await apiRequest(apiUrl, token, "GET", `${RULES_PATH}?actionType=${ACTION}&pageSize=100&page=${page}`);
+    if (!response.ok || !response.data)
+      throw new Error(response.error ?? "Could not list perf automation rules.");
+    rules.push(...response.data);
+    totalPages = response.pagination.totalPages;
+    page++;
+  } while (page <= totalPages);
+  return rules;
+}
+function rulesForTest(rules, test) {
+  const id = testUuid(test);
+  return rules.filter((rule) => rule.actionConfig.perf_test_id === id);
+}
+async function deletePaths(paths, apiUrl, token) {
+  for (const path of paths) {
+    const response = await apiRequest(
+      apiUrl,
+      token,
+      "DELETE",
+      path
+    );
+    if (!response.ok) throw new Error(response.error ?? `DELETE ${path} failed`);
+  }
+}
+function printRun(run2, json) {
+  if (json) {
+    const { result, ...metadata } = run2;
+    writeRawOutput(JSON.stringify({ ...metadata, ...result, rows: result?.rows ?? [] }, null, 2));
+  } else if (run2.status === "completed" && run2.result && run2.verdict) {
+    writeRawOutput(renderPerfResult({ ...run2, result: run2.result, verdict: run2.verdict }));
+  } else {
+    writeRawOutput(`${run2.id}  ${run2.status}${run2.error ? `  ${run2.error}` : ""}`);
+  }
+}
+async function run(argv, apiUrl, token) {
+  const configFile = getScalarArgValue(argv, "--config");
+  const test = getScalarArgValue(argv, "--test");
+  if (Boolean(configFile) === Boolean(test))
+    throw new Error("Use exactly one of --config or --test.");
+  if (test && (getScalarArgValue(argv, "--application") || getScalarArgValue(argv, "--environment"))) {
+    throw new Error("--application and --environment are only valid with --config.");
+  }
+  const head = required(argv, "--head");
+  const base = getScalarArgValue(argv, "--base");
+  const target = test ? { perfTestId: (await resolveTest(apiUrl, token, test)).id } : {
+    config: await readConfig(configFile),
+    applicationId: await resolveApplicationId(argv, apiUrl, token),
+    environment: getScalarArgValue(argv, "--environment")
+  };
+  const { id } = await request(apiUrl, token, "POST", RUNS, {
+    ...target,
+    head,
+    ...base ? { base } : {}
+  });
+  const deadline = Date.now() + 4 * 60 * 60 * 1e3;
+  while (Date.now() < deadline) {
+    const current = await request(
+      apiUrl,
+      token,
+      "GET",
+      `${RUNS}/${encodeURIComponent(id)}`
+    );
+    if (current.status === "failed") {
+      printRun(current, hasFlag(argv, "--json"));
+      return 1;
+    }
+    if (current.status === "completed") {
+      if (!current.result || !current.verdict)
+        throw new Error(`Completed perf run ${id} has no result or verdict.`);
+      printRun(current, hasFlag(argv, "--json"));
+      return current.verdict === "slower" ? 3 : 0;
+    }
+    await sleep(5e3);
+  }
+  throw new Error(`Timed out waiting for ${id}. Inspect it with cofactor perf get ${id}.`);
+}
+async function save(argv, apiUrl, token) {
+  const name = required(argv, "--name");
+  const config = await readConfig(required(argv, "--config"));
+  const applicationId = await resolveApplicationId(argv, apiUrl, token);
+  const triggerConfig = await buildScheduleTriggerConfig(argv, apiUrl, token);
+  const test = await request(apiUrl, token, "POST", TESTS, {
+    name,
+    config,
+    applicationId,
+    environment: getScalarArgValue(argv, "--environment"),
+    ...hasFlag(argv, "--on-merge") ? { onMerge: true } : {}
+  });
+  const rules = rulesForTest(await listRules(apiUrl, token), test);
+  await deletePaths(
+    rules.map((rule2) => `${RULES_PATH}/${encodeURIComponent(rule2.id)}`),
+    apiUrl,
+    token
+  );
+  let rule;
+  if (triggerConfig) {
+    const response = await apiRequest(
+      apiUrl,
+      token,
+      "POST",
+      RULES_PATH,
+      {
+        name,
+        enabled: true,
+        triggerSource: "schedule",
+        triggerEvent: "scheduled",
+        triggerConfig,
+        actionType: ACTION,
+        actionConfig: { perf_test_id: testUuid(test) }
+      }
+    );
+    if (!response.ok || !response.data) {
+      throw new Error(
+        `Saved ${test.id}, but could not create its schedule: ${response.error ?? "rule creation failed"}`
+      );
+    }
+    rule = response.data;
+  }
+  if (hasFlag(argv, "--json"))
+    writeRawOutput(JSON.stringify({ ...test, ...rule ? { rule } : {} }, null, 2));
+  else writeRawOutput(`Saved ${test.id}  ${test.name}${rule ? `  schedule ${rule.id}` : ""}`);
+}
+async function remove(test, apiUrl, token) {
+  const rules = rulesForTest(await listRules(apiUrl, token), test);
+  await deletePaths(
+    [
+      `${TESTS}/${encodeURIComponent(test.id)}`,
+      ...rules.map((rule) => `${RULES_PATH}/${encodeURIComponent(rule.id)}`)
+    ],
+    apiUrl,
+    token
+  );
+}
+async function runPerf(argv) {
+  const [command, ...rest] = argv;
+  if (!command || command === "help" || hasFlag(argv, "--help", "-h")) {
+    printHelp(command);
+    return;
+  }
+  if (command === "guide") {
+    printGuide(PERF_GUIDE_SECTIONS, getGuideSectionArg(rest), hasFlag(rest, "--json"));
+    return;
+  }
+  let code = 0;
+  try {
+    if (!Object.hasOwn(USAGE, command)) throw new Error(`Unknown perf command: ${command}`);
+    if (["run", "save", "delete"].includes(command)) required(rest, "--org");
+    for (const flag of VALUE_FLAGS) {
+      const value = getScalarArgValue(rest, flag);
+      if (rest.includes(flag) && value === void 0) throw new Error(`${flag} requires a value.`);
+    }
+    const { apiUrl, token } = await resolveConfig(rest);
+    const json = hasFlag(rest, "--json");
+    if (command === "run") code = await run(rest, apiUrl, token);
+    else if (command === "save") await save(rest, apiUrl, token);
+    else if (command === "list") {
+      const [tests, rules] = await Promise.all([
+        request(apiUrl, token, "GET", TESTS),
+        listRules(apiUrl, token)
+      ]);
+      const listed = tests.map((test) => ({
+        ...test,
+        schedules: rulesForTest(rules, test)
+      }));
+      writeRawOutput(
+        json ? JSON.stringify(listed, null, 2) : listed.map((test) => {
+          const schedules = test.schedules.map(
+            (rule) => `${rule.id} [${rule.enabled ? "enabled" : "paused"}] ${JSON.stringify(rule.triggerConfig)}`
+          ).join("; ");
+          const modes = [
+            ...test.onMerge ? ["on-merge"] : [],
+            ...schedules ? [schedules] : []
+          ];
+          return `${test.id}  ${test.name}  ${test.environment}  ${modes.join("  ") || "manual"}`;
+        }).join("\n") || "No perf tests found."
+      );
+    } else {
+      const target = getPositionalArg(rest, VALUE_FLAGS);
+      if (!target) throw new Error(`Usage: cofactor perf ${USAGE[command]}`);
+      if (command === "get" && target.startsWith("prun_")) {
+        printRun(
+          await request(apiUrl, token, "GET", `${RUNS}/${encodeURIComponent(target)}`),
+          json
+        );
+      } else {
+        const test = await resolveTest(apiUrl, token, target);
+        if (command === "get")
+          writeRawOutput(
+            json ? JSON.stringify(test, null, 2) : `${test.id}  ${test.name}
+on-merge: ${test.onMerge}
+${JSON.stringify(test.config, null, 2)}`
+          );
+        else if (command === "delete") {
+          await remove(test, apiUrl, token);
+          writeRawOutput(
+            json ? JSON.stringify({ id: test.id, deleted: true }) : `Deleted ${test.id}`
+          );
+        } else {
+          const limit = getScalarArgValue(rest, "--limit") ?? "20";
+          if (!/^\d+$/.test(limit) || Number(limit) < 1 || Number(limit) > 100)
+            throw new Error("--limit must be an integer from 1 to 100.");
+          const query = new URLSearchParams({ perfTestId: test.id, limit });
+          const page = await request(
+            apiUrl,
+            token,
+            "GET",
+            `${RUNS}?${query}`
+          );
+          writeRawOutput(
+            json ? JSON.stringify(page, null, 2) : page.items.map((run2) => `${run2.id}  ${run2.status}  ${run2.verdict ?? "-"}  ${run2.headSha}`).join("\n") || "No perf runs found."
+          );
+        }
+      }
+    }
+  } catch (error) {
+    console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    code = 1;
+  }
+  if (code !== 0) process.exit(code);
+}
+export {
+  runPerf
+};
+//# sourceMappingURL=perf-CCHWHCSR.js.map