@scarn/sdk 0.0.0-stage → 0.0.0

package/dist/chunk-4361gxk0.js

@@ -0,0 +1,166 @@
+// @bun
+// src/scarn-config-parser.ts
+import { access, readFile } from "fs/promises";
+import path from "path";
+var SCARN_CONFIG_RELATIVE_PATH2 = ".scarn/scarn.jsonc";
+var stripJsoncComments = (content) => {
+  let result = "";
+  let inString = false;
+  let escapeNextCharacter = false;
+  let lineComment = false;
+  let blockComment = false;
+  for (let index = 0;index < content.length; index += 1) {
+    const character = content.charAt(index);
+    const nextCharacter = content.charAt(index + 1);
+    if (lineComment) {
+      if (character === `
+`) {
+        lineComment = false;
+        result += character;
+      }
+      continue;
+    }
+    if (blockComment) {
+      if (character === "*" && nextCharacter === "/") {
+        blockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (inString) {
+      result += character;
+      if (escapeNextCharacter) {
+        escapeNextCharacter = false;
+        continue;
+      }
+      if (character === "\\") {
+        escapeNextCharacter = true;
+        continue;
+      }
+      if (character === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (character === '"') {
+      inString = true;
+      result += character;
+      continue;
+    }
+    if (character === "/" && nextCharacter === "/") {
+      lineComment = true;
+      index += 1;
+      continue;
+    }
+    if (character === "/" && nextCharacter === "*") {
+      blockComment = true;
+      index += 1;
+      continue;
+    }
+    result += character;
+  }
+  return result;
+};
+var stripTrailingCommas = (content) => {
+  let result = "";
+  let inString = false;
+  let escapeNextCharacter = false;
+  for (let index = 0;index < content.length; index += 1) {
+    const character = content.charAt(index);
+    if (inString) {
+      result += character;
+      if (escapeNextCharacter) {
+        escapeNextCharacter = false;
+        continue;
+      }
+      if (character === "\\") {
+        escapeNextCharacter = true;
+        continue;
+      }
+      if (character === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (character === '"') {
+      inString = true;
+      result += character;
+      continue;
+    }
+    if (character === ",") {
+      let lookaheadIndex = index + 1;
+      while (lookaheadIndex < content.length) {
+        const lookaheadCharacter = content.charAt(lookaheadIndex);
+        if (/\s/u.test(lookaheadCharacter)) {
+          lookaheadIndex += 1;
+          continue;
+        }
+        if (lookaheadCharacter === "}" || lookaheadCharacter === "]") {
+          break;
+        }
+        result += character;
+        break;
+      }
+      if (lookaheadIndex >= content.length) {
+        continue;
+      }
+      const lookaheadCharacter = content.charAt(lookaheadIndex);
+      if (lookaheadCharacter === "}" || lookaheadCharacter === "]") {
+        continue;
+      }
+      continue;
+    }
+    result += character;
+  }
+  return result;
+};
+var parseJsonc = (content) => JSON.parse(stripTrailingCommas(stripJsoncComments(content)));
+var asString = (value) => typeof value === "string" ? value : null;
+var asNumber = (value) => typeof value === "number" ? value : null;
+var parseCommands = (raw) => {
+  if (!raw)
+    return [];
+  return Object.entries(raw).map(([name, entry]) => ({
+    name,
+    description: asString(entry.description) ?? "",
+    run: asString(entry.run) ?? "",
+    cwd: asString(entry.cwd) ?? null
+  }));
+};
+var parseServices = (raw) => {
+  if (!raw)
+    return [];
+  return Object.entries(raw).map(([name, entry]) => {
+    const expose = entry.expose ?? {};
+    const dependsOn = Array.isArray(entry.dependsOn) ? entry.dependsOn.filter((d) => typeof d === "string") : [];
+    return {
+      name,
+      description: asString(entry.description) ?? "",
+      run: asString(entry.run) ?? "",
+      cwd: asString(entry.cwd) ?? null,
+      dependsOn,
+      expose: {
+        targetPort: asNumber(expose.targetPort) ?? 0,
+        protocol: asString(expose.protocol) ?? "http"
+      }
+    };
+  });
+};
+async function parseScarnConfig2(workspacePath) {
+  const filePath = path.join(workspacePath, SCARN_CONFIG_RELATIVE_PATH2);
+  const exists = await access(filePath).then(() => true).catch(() => false);
+  if (!exists) {
+    return { found: false };
+  }
+  const content = await readFile(filePath, "utf8");
+  const raw = parseJsonc(content);
+  return {
+    found: true,
+    config: {
+      commands: parseCommands(raw.commands),
+      services: parseServices(raw.services)
+    }
+  };
+}
+
+export { SCARN_CONFIG_RELATIVE_PATH2, parseScarnConfig2 };

package/dist/chunk-4vehh3dq.js

@@ -0,0 +1,333 @@
+// @bun
+import {
+  toJSONSchema,
+  string,
+  number,
+  int,
+  array,
+  strictObject,
+  union,
+  discriminatedUnion,
+  record,
+  _enum,
+  literal,
+  json
+} from "./chunk-dnn39qt4.js";
+
+// src/contracts/pipeline-document/json.ts
+function isJsonObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function escapePointerSegment(segment) {
+  return String(segment).replaceAll("~", "~0").replaceAll("/", "~1");
+}
+function jsonPointer2(segments) {
+  return segments.map((segment) => `/${escapePointerSegment(segment)}`).join("");
+}
+function deepEqual2(left, right) {
+  if (left === right) {
+    return true;
+  }
+  if (Array.isArray(left)) {
+    return Array.isArray(right) && left.length === right.length && left.every((item, index) => deepEqual2(item, right[index]));
+  }
+  if (isJsonObject2(left) && isJsonObject2(right)) {
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    return leftKeys.length === rightKeys.length && leftKeys.every((key) => Object.hasOwn(right, key) && deepEqual2(left[key], right[key]));
+  }
+  return false;
+}
+// src/contracts/pipeline-document/conditions/operators.ts
+var COMPARISON_OPERATORS2 = [
+  "equal",
+  "notEqual",
+  "lessThan",
+  "lessThanInclusive",
+  "greaterThan",
+  "greaterThanInclusive"
+];
+var CONDITION_OPERATORS2 = [
+  ...COMPARISON_OPERATORS2,
+  "exists",
+  "isEmpty",
+  "contains",
+  "startsWith",
+  "endsWith",
+  "matches",
+  "before",
+  "after",
+  "some",
+  "every",
+  "none"
+];
+var COMPUTED_FUNCTIONS2 = [
+  "sum",
+  "avg",
+  "min",
+  "max",
+  "count"
+];
+var ORDERING_OPERATORS2 = new Set([
+  "lessThan",
+  "lessThanInclusive",
+  "greaterThan",
+  "greaterThanInclusive"
+]);
+var STRING_OPERATORS2 = new Set([
+  "startsWith",
+  "endsWith",
+  "matches"
+]);
+var DATE_OPERATORS2 = new Set(["before", "after"]);
+var LIST_OPERATORS2 = new Set(["some", "every", "none"]);
+
+// src/contracts/pipeline-document/schema.ts
+var NODE_ID_PATTERN2 = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+var ALIAS_PATTERN2 = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var nodeIdSchema = string().regex(NODE_ID_PATTERN2, "Node ids may only contain letters, digits, '_' and '-'");
+var jsonValueSchema = json();
+var literalSchema2 = strictObject({ value: jsonValueSchema });
+var scalarArgSchema = union([string().min(1), literalSchema2]);
+var listSchema2 = strictObject({ list: array(scalarArgSchema) });
+var argValueSchema2 = union([
+  string().min(1),
+  literalSchema2,
+  listSchema2
+]);
+var computedSourceSchema2 = union([
+  array(string().min(1)).min(1),
+  strictObject({
+    path: string().min(1),
+    field: string().min(1).optional(),
+    get where() {
+      return conditionSchema2.optional();
+    }
+  })
+]);
+var LIST_OPS = new Set(["some", "every", "none"]);
+var UNARY_OPS = new Set(["exists", "isEmpty"]);
+var conditionSchema2 = strictObject({
+  get all() {
+    return array(conditionSchema2).min(1).optional();
+  },
+  get any() {
+    return array(conditionSchema2).min(1).optional();
+  },
+  get not() {
+    return conditionSchema2.optional();
+  },
+  path: string().min(1).optional(),
+  sum: computedSourceSchema2.optional(),
+  avg: computedSourceSchema2.optional(),
+  min: computedSourceSchema2.optional(),
+  max: computedSourceSchema2.optional(),
+  count: computedSourceSchema2.optional(),
+  weights: array(number()).min(1).optional(),
+  op: _enum(CONDITION_OPERATORS2).optional(),
+  value: jsonValueSchema.optional(),
+  ref: string().min(1).optional(),
+  get where() {
+    return conditionSchema2.optional();
+  }
+}).superRefine((condition, ctx) => {
+  const combinators = ["all", "any", "not"].filter((key) => condition[key] !== undefined);
+  const lefts = ["path", ...COMPUTED_FUNCTIONS2].filter((key) => condition[key] !== undefined);
+  if (combinators.length > 0) {
+    const extras = Object.keys(condition).filter((key) => key !== combinators[0]);
+    if (combinators.length > 1 || extras.length > 0) {
+      ctx.addIssue({
+        code: "custom",
+        message: `A condition with "${String(combinators[0])}" can't have other keys (found ${[...combinators.slice(1), ...extras].map((key) => `"${key}"`).join(", ")})`
+      });
+    }
+    return;
+  }
+  if (lefts.length !== 1) {
+    ctx.addIssue({
+      code: "custom",
+      message: lefts.length === 0 ? 'A condition needs exactly one of "path", "sum", "avg", "min", "max", "count", or a combinator "all", "any", "not"' : `A condition can have only one of ${lefts.map((key) => `"${key}"`).join(", ")}`
+    });
+    return;
+  }
+  if (condition.op === undefined) {
+    ctx.addIssue({
+      code: "custom",
+      message: 'A condition needs "op"',
+      path: ["op"]
+    });
+    return;
+  }
+  const isList = LIST_OPS.has(condition.op);
+  const isUnary = UNARY_OPS.has(condition.op);
+  if (isList && condition.where === undefined) {
+    ctx.addIssue({
+      code: "custom",
+      message: `"${condition.op}" needs a "where" condition`,
+      path: ["where"]
+    });
+  }
+  if (!isList && condition.where !== undefined) {
+    ctx.addIssue({
+      code: "custom",
+      message: `"where" is only allowed with "some", "every" or "none", not "${condition.op}"`,
+      path: ["where"]
+    });
+  }
+  const hasValue = condition.value !== undefined;
+  const hasRef = condition.ref !== undefined;
+  if ((isList || isUnary) && (hasValue || hasRef)) {
+    ctx.addIssue({
+      code: "custom",
+      message: `"${condition.op}" takes no "value" or "ref"`,
+      path: [hasValue ? "value" : "ref"]
+    });
+  }
+  if (!isList && !isUnary && hasValue === hasRef) {
+    ctx.addIssue({
+      code: "custom",
+      message: `"${condition.op}" needs exactly one of "value" or "ref"`
+    });
+  }
+  if (condition.weights !== undefined && condition.avg === undefined) {
+    ctx.addIssue({
+      code: "custom",
+      message: '"weights" is only allowed with "avg"',
+      path: ["weights"]
+    });
+  }
+});
+var toleratedFailuresSchema2 = union([
+  strictObject({ count: int().nonnegative() }),
+  strictObject({ percent: number().min(0).max(100) })
+]);
+var eachSchema2 = strictObject({
+  over: string().min(1),
+  maxConcurrency: int().positive().optional(),
+  toleratedFailures: toleratedFailuresSchema2.optional()
+});
+var routeShape = {
+  when: conditionSchema2.optional(),
+  to: nodeIdSchema,
+  pipeline: string().min(1).optional(),
+  args: record(string().min(1), argValueSchema2).optional(),
+  each: eachSchema2.optional(),
+  partial: literal(true).optional()
+};
+function noPartialWithEach(route, ctx) {
+  if (route.each !== undefined && route.partial !== undefined) {
+    ctx.addIssue({
+      code: "custom",
+      message: `A route can't have both "each" and "partial"`,
+      path: ["partial"]
+    });
+  }
+}
+var routeSchema2 = strictObject(routeShape).superRefine(noPartialWithEach);
+var otherwiseSchema2 = strictObject(routeShape).omit({ when: true }).superRefine(noPartialWithEach);
+var startSchema2 = strictObject(routeShape).omit({ partial: true });
+var MATCH_MODES2 = ["first", "all"];
+var nextSchema2 = strictObject({
+  match: _enum(MATCH_MODES2).optional(),
+  routes: array(routeSchema2).min(1),
+  otherwise: otherwiseSchema2.optional()
+});
+var retrySchema2 = strictObject({
+  on: array(string().min(1)).min(1),
+  maxAttempts: int().positive(),
+  intervalSeconds: number().nonnegative().optional(),
+  backoffRate: number().positive().optional(),
+  maxDelaySeconds: number().nonnegative().optional()
+});
+var catchSchema2 = strictObject({
+  on: array(string().min(1)).min(1),
+  to: nodeIdSchema,
+  pipeline: string().min(1).optional(),
+  args: record(string().min(1), argValueSchema2).optional()
+});
+var stepNodeSchema2 = strictObject({
+  kind: literal("step"),
+  title: string().optional(),
+  step: string().min(1),
+  next: nextSchema2.optional(),
+  retry: array(retrySchema2).optional(),
+  catch: array(catchSchema2).optional(),
+  timeoutSeconds: int().positive().optional(),
+  heartbeatSeconds: int().positive().optional(),
+  maxRuns: int().positive().optional(),
+  maxTurns: int().nonnegative().optional()
+});
+var DEFAULT_MAX_TURNS2 = 2;
+var DECISION_BODY_MODES2 = ["optional", "required"];
+var decisionActionSchema2 = strictObject({
+  key: string().min(1),
+  label: string().min(1),
+  body: _enum(DECISION_BODY_MODES2).optional()
+});
+var waitNodeSchema2 = strictObject({
+  kind: literal("wait"),
+  title: string().optional(),
+  for: _enum(["decision", "reply", "event", "timer"]),
+  actions: array(decisionActionSchema2).optional(),
+  next: nextSchema2.optional(),
+  catch: array(catchSchema2).optional(),
+  timeoutSeconds: int().positive().optional(),
+  maxRuns: int().positive().optional()
+});
+var succeedNodeSchema2 = strictObject({
+  kind: literal("succeed"),
+  title: string().optional()
+});
+var failNodeSchema2 = strictObject({
+  kind: literal("fail"),
+  title: string().optional(),
+  error: string().min(1).optional(),
+  cause: string().optional()
+});
+var nodeSchema2 = discriminatedUnion("kind", [
+  stepNodeSchema2,
+  waitNodeSchema2,
+  succeedNodeSchema2,
+  failNodeSchema2
+]);
+var pipelineDocumentSchema2 = strictObject({
+  $schema: string().optional(),
+  schemaVersion: literal(1),
+  key: string().min(1),
+  title: string().optional(),
+  timeoutSeconds: int().positive().optional(),
+  workItemFields: record(string().regex(ALIAS_PATTERN2, "Aliases must be identifiers (letters, digits, '_')"), string().min(1)).optional(),
+  start: startSchema2,
+  nodes: record(nodeIdSchema, nodeSchema2)
+});
+function pipelineDocumentJsonSchema2() {
+  return toJSONSchema(pipelineDocumentSchema2, { io: "input" });
+}
+// src/contracts/pipeline-document/routes.ts
+function routeEntries2(next) {
+  if (next === undefined) {
+    return [];
+  }
+  const entries = next.routes.map((route, index) => ({
+    kind: "route",
+    index,
+    route,
+    pointer: ["routes", index]
+  }));
+  if (next.otherwise !== undefined) {
+    entries.push({
+      kind: "otherwise",
+      index: 0,
+      route: next.otherwise,
+      pointer: ["otherwise"]
+    });
+  }
+  return entries;
+}
+function routeAt2(next, kind, index) {
+  if (next === undefined) {
+    return;
+  }
+  return kind === "otherwise" ? next.otherwise : next.routes[index];
+}
+export { isJsonObject2, jsonPointer2, deepEqual2, COMPARISON_OPERATORS2, CONDITION_OPERATORS2, COMPUTED_FUNCTIONS2, ORDERING_OPERATORS2, STRING_OPERATORS2, DATE_OPERATORS2, LIST_OPERATORS2, NODE_ID_PATTERN2, ALIAS_PATTERN2, literalSchema2, listSchema2, argValueSchema2, computedSourceSchema2, conditionSchema2, toleratedFailuresSchema2, eachSchema2, routeSchema2, otherwiseSchema2, startSchema2, MATCH_MODES2, nextSchema2, retrySchema2, catchSchema2, stepNodeSchema2, DEFAULT_MAX_TURNS2, DECISION_BODY_MODES2, decisionActionSchema2, waitNodeSchema2, succeedNodeSchema2, failNodeSchema2, nodeSchema2, pipelineDocumentSchema2, pipelineDocumentJsonSchema2, routeEntries2, routeAt2 };

package/dist/chunk-56e4kp0a.js

@@ -0,0 +1,162 @@
+// @bun
+import {
+  _enum
+} from "./chunk-dnn39qt4.js";
+
+// src/contracts/artifacts.ts
+var artifactKindSchema2 = _enum([
+  "generic",
+  "playwright-trace",
+  "video",
+  "image"
+]);
+var ARTIFACT_SCHEMA_KEYWORD2 = "x-scarn-artifact";
+var artifactPlatforms2 = ["github", "jira", "bitbucket"];
+var EMBEDDABLE_ARTIFACT_EXTENSIONS2 = {
+  jira: [".png", ".gif", ".mp4", ".webm"],
+  github: [],
+  bitbucket: []
+};
+function isEmbeddableArtifactExtension2(platform, extension) {
+  return EMBEDDABLE_ARTIFACT_EXTENSIONS2[platform].includes(extension.toLowerCase());
+}
+function artifactFileExtension2(fileName) {
+  const base = fileName.slice(fileName.lastIndexOf("/") + 1);
+  const dot = base.lastIndexOf(".");
+  if (dot <= 0)
+    return "";
+  return base.slice(dot).toLowerCase();
+}
+function artifactAcceptsFile2(accept, fileName) {
+  if (accept.length === 0)
+    return true;
+  return accept.includes(artifactFileExtension2(fileName));
+}
+function asRecord(node) {
+  return typeof node === "object" ? node : null;
+}
+function isNullSchema(node) {
+  return asRecord(node)?.["type"] === "null";
+}
+function schemaBranches(record, keyword) {
+  const value = record[keyword];
+  if (!Array.isArray(value))
+    return [];
+  return value.filter((entry) => typeof entry === "boolean" || typeof entry === "object" && entry !== null && !Array.isArray(entry));
+}
+function readArtifactKeyword2(node) {
+  const record = asRecord(node);
+  const keyword = asRecord(record?.[ARTIFACT_SCHEMA_KEYWORD2]);
+  if (!keyword)
+    return null;
+  const accept = keyword["accept"];
+  return {
+    accept: Array.isArray(accept) ? accept.filter((entry) => typeof entry === "string") : []
+  };
+}
+function readDescription(node) {
+  const description = asRecord(node)?.["description"];
+  return typeof description === "string" ? description : null;
+}
+function matchArtifactNode2(node) {
+  const direct = readArtifactKeyword2(node);
+  if (direct) {
+    const types = asRecord(node)?.["type"];
+    return {
+      ...direct,
+      nullable: Array.isArray(types) && types.includes("null"),
+      description: readDescription(node)
+    };
+  }
+  const record = asRecord(node);
+  if (!record)
+    return null;
+  for (const keyword of ["anyOf", "oneOf"]) {
+    const branches = schemaBranches(record, keyword);
+    const nonNull = branches.filter((branch) => !isNullSchema(branch));
+    const [only] = nonNull;
+    if (!only || nonNull.length !== 1 || branches.length !== 2)
+      continue;
+    const inner = readArtifactKeyword2(only);
+    if (!inner)
+      continue;
+    return {
+      ...inner,
+      nullable: true,
+      description: readDescription(node) ?? readDescription(only)
+    };
+  }
+  return null;
+}
+var MAX_REF_HOPS = 16;
+function resolveLocalRef(root, ref) {
+  if (!ref.startsWith("#"))
+    return null;
+  const pointer = ref.slice(1);
+  if (pointer === "" || pointer === "/")
+    return root;
+  let current = root;
+  for (const rawToken of pointer.slice(1).split("/")) {
+    const token = rawToken.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (typeof current !== "object" || current === null)
+      return null;
+    current = current[token];
+  }
+  return typeof current === "object" && current !== null ? current : null;
+}
+function findArtifactFields2(schema) {
+  if (schema === null || schema === undefined)
+    return [];
+  const root = schema;
+  const fields = new Map;
+  const visit = (node, path, inArray, hops) => {
+    if (hops > MAX_REF_HOPS)
+      return;
+    const record = asRecord(node);
+    if (!record)
+      return;
+    const ref = record["$ref"];
+    if (typeof ref === "string") {
+      const target = resolveLocalRef(root, ref);
+      if (target)
+        visit(target, path, inArray, hops + 1);
+      return;
+    }
+    const match = path ? matchArtifactNode2(node) : null;
+    if (match) {
+      if (!fields.has(path)) {
+        fields.set(path, {
+          path,
+          accept: match.accept,
+          nullable: match.nullable,
+          description: match.description,
+          inArray
+        });
+      }
+      return;
+    }
+    for (const keyword of ["anyOf", "oneOf", "allOf"]) {
+      for (const branch of schemaBranches(record, keyword)) {
+        visit(branch, path, inArray, hops + 1);
+      }
+    }
+    const properties = asRecord(record["properties"]);
+    for (const [key, child] of Object.entries(properties ?? {})) {
+      const childNode = child;
+      visit(childNode, path ? `${path}.${key}` : key, inArray, hops);
+    }
+    const items = record["items"];
+    if (items !== undefined)
+      visit(items, `${path}[]`, true, hops);
+    const prefixItems = record["prefixItems"];
+    if (Array.isArray(prefixItems)) {
+      for (const item of prefixItems) {
+        visit(item, `${path}[]`, true, hops);
+      }
+    }
+  };
+  visit(schema, "", false, 0);
+  return [...fields.values()];
+}
+
+export { artifactKindSchema2, ARTIFACT_SCHEMA_KEYWORD2, artifactPlatforms2, EMBEDDABLE_ARTIFACT_EXTENSIONS2, isEmbeddableArtifactExtension2, artifactFileExtension2, artifactAcceptsFile2, readArtifactKeyword2, matchArtifactNode2, findArtifactFields2 };