@tangle-network/sandbox-ui 0.75.0 → 0.77.0

package/dist/chunk-UEMWLVVY.js

@@ -0,0 +1,606 @@
+// src/workflows/format.ts
+function fmtDuration(ms) {
+  if (ms === void 0 || !Number.isFinite(ms) || ms < 0) return void 0;
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  const s = ms / 1e3;
+  if (s < 60) return `${s.toFixed(1)}s`;
+  const totalSeconds = Math.round(s);
+  return `${Math.floor(totalSeconds / 60)}m${totalSeconds % 60}s`;
+}
+function fmtCost(usd) {
+  if (usd === void 0 || !Number.isFinite(usd) || usd < 0) return void 0;
+  if (usd === 0) return "$0";
+  return usd < 0.01 ? `$${usd.toFixed(4)}` : `$${usd.toFixed(2)}`;
+}
+function clampPreview(text, max = 200) {
+  if (text.length <= max) return text;
+  const lastCode = text.charCodeAt(max - 1);
+  const end = lastCode >= 55296 && lastCode <= 56319 ? max - 1 : max;
+  return `${text.slice(0, end)}\u2026`;
+}
+function fmtTokens(input, output) {
+  const valid = (n) => n !== void 0 && Number.isFinite(n) && n >= 0 ? n : void 0;
+  const i = valid(input);
+  const o = valid(output);
+  if (i === void 0 && o === void 0) return void 0;
+  return `${i ?? 0}/${o ?? 0} tok`;
+}
+
+// src/workflows/naming.ts
+var ACRONYMS = /* @__PURE__ */ new Set([
+  "ai",
+  "api",
+  "cd",
+  "ci",
+  "cli",
+  "cpu",
+  "css",
+  "csv",
+  "db",
+  "dns",
+  "gpu",
+  "html",
+  "http",
+  "https",
+  "id",
+  "io",
+  "ip",
+  "json",
+  "llm",
+  "mcp",
+  "ml",
+  "pr",
+  "qa",
+  "sdk",
+  "sla",
+  "sql",
+  "ssh",
+  "ui",
+  "url",
+  "uuid",
+  "vm",
+  "yaml"
+]);
+function words(id) {
+  return id.replace(/[._\-/]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").trim().split(/\s+/).filter(Boolean);
+}
+function humanizeIdentifier(id, lead = "sentence") {
+  const parts = words(id);
+  if (parts.length === 0) return id;
+  return parts.map((word, i) => {
+    const lower = word.toLowerCase();
+    if (ACRONYMS.has(lower)) return lower.toUpperCase();
+    const capitalized = lower.charAt(0).toUpperCase() + lower.slice(1);
+    if (lead === "title") return capitalized;
+    if (i > 0) return lower;
+    return lead === "lower" ? lower : capitalized;
+  }).join(" ");
+}
+function shortModel(model) {
+  const slash = model.lastIndexOf("/");
+  return slash === -1 ? model : model.slice(slash + 1);
+}
+var ACTION_PATH = /^[a-z0-9_-]+(\.[a-z0-9_-]+)+$/i;
+function parseActionPath(path) {
+  if (!ACTION_PATH.test(path.trim())) return null;
+  const segments = path.trim().split(".");
+  const [provider, ...rest] = segments;
+  const operation = rest[rest.length - 1];
+  const resource = rest.length > 1 ? rest.slice(0, -1).join(".") : void 0;
+  return { provider, operation, resource };
+}
+function actionPathLabel(path) {
+  const parts = parseActionPath(path);
+  if (!parts) return path;
+  const operation = humanizeIdentifier(parts.operation, "lower");
+  return parts.resource ? `${operation}: ${parts.resource}` : operation;
+}
+
+// src/workflows/cron.ts
+var WEEKDAY_NAMES = [
+  "Sunday",
+  "Monday",
+  "Tuesday",
+  "Wednesday",
+  "Thursday",
+  "Friday",
+  "Saturday"
+];
+function evenStep(field, period) {
+  const m = /^\*\/(\d+)$/.exec(field);
+  if (!m) return null;
+  const n = Number.parseInt(m[1], 10);
+  if (n < 1 || n >= period || period % n !== 0) return null;
+  return n;
+}
+function plainInt(field) {
+  if (!/^\d+$/.test(field)) return null;
+  return Number.parseInt(field, 10);
+}
+function timeOfDay(minute, hour) {
+  const m = plainInt(minute);
+  const h = plainInt(hour);
+  if (m === null || h === null || m > 59 || h > 23) return null;
+  return `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}`;
+}
+function weekdays(field) {
+  if (field === "1-5") return "Weekdays";
+  if (field === "0,6" || field === "6,0" || field === "6-7") return "Weekends";
+  const dayName = (value) => {
+    if (value < 0 || value > 7) return null;
+    return WEEKDAY_NAMES[value === 7 ? 0 : value];
+  };
+  const single = plainInt(field);
+  if (single !== null) {
+    const name = dayName(single);
+    return name ? `${name}s` : null;
+  }
+  if (/^\d+(,\d+)+$/.test(field)) {
+    const names = field.split(",").map((d) => dayName(Number.parseInt(d, 10)));
+    if (names.some((n) => n === null)) return null;
+    const unique = [...new Set(names)];
+    return unique.map((n) => n.slice(0, 3)).join(", ");
+  }
+  return null;
+}
+function ordinal(day) {
+  const tens = day % 100;
+  if (tens >= 11 && tens <= 13) return `${day}th`;
+  switch (day % 10) {
+    case 1:
+      return `${day}st`;
+    case 2:
+      return `${day}nd`;
+    case 3:
+      return `${day}rd`;
+    default:
+      return `${day}th`;
+  }
+}
+function describeCron(expression) {
+  const raw = expression.trim();
+  const fields = raw.split(/\s+/);
+  if (fields.length !== 5) return raw;
+  const [minute, hour, dayOfMonth, month, dayOfWeek] = fields;
+  const anyDayOfMonth = dayOfMonth === "*";
+  const anyDayOfWeek = dayOfWeek === "*";
+  const anyMonth = month === "*";
+  if (!anyMonth) return raw;
+  if (!anyDayOfMonth && !anyDayOfWeek) return raw;
+  const everyDay = anyDayOfMonth && anyDayOfWeek;
+  if (everyDay) {
+    if (minute === "*" && hour === "*") return "Every minute";
+    const everyNMinutes = evenStep(minute, 60);
+    if (everyNMinutes !== null && hour === "*") {
+      return everyNMinutes === 1 ? "Every minute" : `Every ${everyNMinutes} minutes`;
+    }
+    const everyNHours = evenStep(hour, 24);
+    const atMinute = plainInt(minute);
+    const pastTheHour = atMinute !== null && atMinute <= 59 ? `:${String(atMinute).padStart(2, "0")}` : null;
+    if (everyNHours !== null && pastTheHour) {
+      return everyNHours === 1 ? `Hourly at ${pastTheHour}` : `Every ${everyNHours} hours at ${pastTheHour}`;
+    }
+    if (hour === "*" && pastTheHour) return `Hourly at ${pastTheHour}`;
+    const time2 = timeOfDay(minute, hour);
+    return time2 ? `Daily at ${time2}` : raw;
+  }
+  const time = timeOfDay(minute, hour);
+  if (!time) return raw;
+  if (!anyDayOfWeek) {
+    const days = weekdays(dayOfWeek);
+    return days ? `${days} at ${time}` : raw;
+  }
+  const day = plainInt(dayOfMonth);
+  if (day !== null && day >= 1 && day <= 31) {
+    return `Monthly on the ${ordinal(day)} at ${time}`;
+  }
+  return raw;
+}
+
+// src/workflows/provider-label.ts
+var PROVIDER_LABELS = {
+  github: "GitHub",
+  gitlab: "GitLab",
+  slack: "Slack",
+  stripe: "Stripe",
+  notion: "Notion",
+  linear: "Linear",
+  discord: "Discord"
+};
+function providerLabel(provider) {
+  const key = provider.toLowerCase();
+  return PROVIDER_LABELS[key] ?? humanizeIdentifier(provider, "title");
+}
+
+// src/workflows/model.ts
+import { parse as parseYaml } from "yaml";
+var NODE_W = 292;
+var RANK_SEP = 72;
+var CROSS_SEP = 24;
+var CARD_CHROME = 20;
+var HEADER_ROW = 34;
+var DESCRIPTION_ROW = 40;
+var META_ROW = 27;
+var OUTPUT_ROW = 72;
+var FOOTER_ROW = 28;
+var COMPACT_TILE = 76;
+var COMPACT_GAP = 8;
+var COMPACT_LABEL_W = 152;
+var COMPACT_NODE_SIZE = {
+  width: 168,
+  height: COMPACT_TILE + COMPACT_GAP + 34
+};
+var COMPACT_NODE_SIZE_RUN = {
+  width: 168,
+  height: COMPACT_TILE + COMPACT_GAP + 34 + 15
+};
+var COMPACT_NODE_SIZE_TB = {
+  width: COMPACT_TILE + COMPACT_GAP + COMPACT_LABEL_W,
+  height: COMPACT_TILE
+};
+function nodeHeight(data, withRunState) {
+  let h = CARD_CHROME + HEADER_ROW;
+  if (data.description) h += DESCRIPTION_ROW;
+  if (withRunState) h += META_ROW + OUTPUT_ROW + FOOTER_ROW;
+  return h;
+}
+function geometry(compact, runMode, direction) {
+  if (compact) {
+    if (direction === "TB") {
+      return { size: COMPACT_NODE_SIZE_TB, rankSep: 34, crossSep: 24 };
+    }
+    return {
+      size: runMode ? COMPACT_NODE_SIZE_RUN : COMPACT_NODE_SIZE,
+      rankSep: 20,
+      crossSep: 20
+    };
+  }
+  return { size: void 0, rankSep: RANK_SEP, crossSep: CROSS_SEP };
+}
+function asRecord(v) {
+  return v && typeof v === "object" && !Array.isArray(v) ? v : {};
+}
+function str(v) {
+  return typeof v === "string" && v.trim() !== "" ? v : void 0;
+}
+function describeText(v) {
+  const text = str(v);
+  return text ? clampPreview(text.trim(), 220) : void 0;
+}
+function urlHost(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return url;
+  }
+}
+var CONTROL_FLOW_KEYS = ["if", "retry", "onError"];
+var CONTROL_FLOW = new Set(CONTROL_FLOW_KEYS);
+function actionKind(rec) {
+  return Object.keys(rec).find((k) => !CONTROL_FLOW.has(k));
+}
+function agentTitle(profile) {
+  const named = str(profile);
+  return named ? humanizeIdentifier(named) : "AI Agent";
+}
+function describeActionBase(action) {
+  const rec = asRecord(action);
+  const kind = actionKind(rec);
+  const cfg = asRecord(kind ? rec[kind] : void 0);
+  switch (kind) {
+    case "sandbox.spawn":
+      return {
+        title: "Sandbox",
+        kind,
+        subtitle: str(cfg.template) ?? "Provision",
+        description: describeText(cfg.prompt),
+        isRoot: false,
+        tone: "action"
+      };
+    case "integration.invoke": {
+      const path = str(cfg.path);
+      const parts = path ? parseActionPath(path) : null;
+      return {
+        // The provider IS the node's identity, exactly as in n8n — its logo and
+        // its name. What it does with it goes in the subtitle.
+        title: parts ? providerLabel(parts.provider) : "Integration",
+        kind,
+        subtitle: path ? actionPathLabel(path) : void 0,
+        path,
+        provider: parts?.provider,
+        isRoot: false,
+        tone: "action"
+      };
+    }
+    case "notify": {
+      const url = str(cfg.url);
+      return {
+        title: "Notify",
+        kind,
+        subtitle: url ? urlHost(url) : void 0,
+        description: describeText(url),
+        isRoot: false,
+        tone: "action"
+      };
+    }
+    case "agent.run": {
+      const model = str(cfg.model);
+      return {
+        title: agentTitle(cfg.profile),
+        kind,
+        // The model is the agent's defining trait, so it names the step; the
+        // prompt — the long part — is the description the expanded card clamps.
+        subtitle: model ? shortModel(model) : "Agent",
+        description: describeText(cfg.prompt),
+        model,
+        isRoot: false,
+        tone: "action"
+      };
+    }
+    case "parallel": {
+      const branches = Array.isArray(cfg.branches) ? cfg.branches : [];
+      return {
+        title: "Parallel",
+        kind,
+        subtitle: `${branches.length} branch${branches.length === 1 ? "" : "es"}`,
+        badge: branches.length > 0 ? `\xD7${branches.length}` : void 0,
+        isRoot: false,
+        tone: "structural"
+      };
+    }
+    case "foreach":
+      return {
+        title: "For each",
+        kind,
+        subtitle: "Repeat per item",
+        description: typeof cfg.items === "string" ? cfg.items : "Literal list",
+        // Only fans out when a `do` template is actually present.
+        isRoot: false,
+        tone: "structural"
+      };
+    case "decision": {
+      const options = Array.isArray(cfg.options) ? cfg.options.filter((o) => typeof o === "string") : [];
+      return {
+        // A decision is the one step whose author already wrote it a human title.
+        title: str(cfg.title) ?? "Decision",
+        kind,
+        subtitle: options.length > 0 ? describeText(options.join(" / ")) : "Waits for a human",
+        description: describeText(cfg.prompt),
+        isRoot: false,
+        tone: "structural"
+      };
+    }
+    default:
+      return {
+        // An action kind this version doesn't model yet still gets a readable
+        // name ("agent.review" → "Agent review") rather than its raw identifier.
+        title: kind ? humanizeIdentifier(kind) : "Action",
+        kind: kind ?? "action",
+        isRoot: false,
+        tone: "action"
+      };
+  }
+}
+var MAX_CONFIG_DEPTH = 100;
+function toJsonSafe(value, seen = /* @__PURE__ */ new WeakSet(), depth = 0) {
+  if (value === null) return null;
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value !== "object") return void 0;
+  if (value instanceof Date) return value.toISOString();
+  if (seen.has(value)) return "[Circular]";
+  if (depth >= MAX_CONFIG_DEPTH) return "[Max depth exceeded]";
+  seen.add(value);
+  let out;
+  if (Array.isArray(value)) {
+    out = value.map((v) => {
+      const s = toJsonSafe(v, seen, depth + 1);
+      return s === void 0 ? null : s;
+    });
+  } else {
+    const obj = {};
+    for (const [k, v] of Object.entries(value)) {
+      const s = toJsonSafe(v, seen, depth + 1);
+      if (s !== void 0) obj[k] = s;
+    }
+    out = obj;
+  }
+  seen.delete(value);
+  return out;
+}
+function withConfig(base, cfg) {
+  return Object.keys(cfg).length > 0 ? { ...base, config: toJsonSafe(cfg) } : base;
+}
+function describeAction(action) {
+  const rec = asRecord(action);
+  const kind = actionKind(rec);
+  const base = describeActionBase(action);
+  const config = toJsonSafe(asRecord(kind ? rec[kind] : {}));
+  for (const key of CONTROL_FLOW_KEYS) {
+    if (rec[key] !== void 0) config[key] = toJsonSafe(rec[key]);
+  }
+  return Object.keys(config).length > 0 ? { ...base, config } : base;
+}
+function describeTrigger(on) {
+  const rec = asRecord(on);
+  if (rec.provider_event) {
+    const ev = asRecord(rec.provider_event);
+    const connection = str(ev.connection);
+    const event = str(ev.event);
+    const actions = Array.isArray(ev.actions) ? ev.actions.filter((a) => typeof a === "string") : [];
+    const repo = str(ev.repo);
+    const description = describeText(
+      [actions.length > 0 ? actions.join(", ") : void 0, repo].filter(Boolean).join(" \xB7 ")
+    );
+    return withConfig(
+      {
+        title: connection ? providerLabel(connection) : "Trigger",
+        kind: "provider_event",
+        subtitle: event ? `On ${humanizeIdentifier(event, "lower")}` : "On an event",
+        description,
+        provider: connection,
+        isRoot: true,
+        tone: "trigger"
+      },
+      ev
+    );
+  }
+  if (rec.schedule) {
+    const sch = asRecord(rec.schedule);
+    const cron = str(sch.cron);
+    const tz = str(sch.timezone);
+    return withConfig(
+      {
+        title: "Schedule",
+        kind: "schedule",
+        // The cron in English; the expression itself stays in the description (and
+        // in full in the config) so the exact timetable is never hidden.
+        subtitle: cron ? describeCron(cron) : "On a timetable",
+        description: cron ? tz ? `${cron} \xB7 ${tz}` : cron : void 0,
+        isRoot: true,
+        tone: "trigger"
+      },
+      sch
+    );
+  }
+  const [kind] = Object.keys(rec);
+  return withConfig(
+    {
+      title: "Trigger",
+      kind: "trigger",
+      subtitle: kind ? humanizeIdentifier(kind) : void 0,
+      isRoot: true,
+      tone: "trigger"
+    },
+    asRecord(kind ? rec[kind] : void 0)
+  );
+}
+function layoutLayers(nodes, direction, rankSep, crossSep) {
+  const isLR = direction === "LR";
+  const mainSize = (n) => isLR ? n.width : n.height;
+  const crossSize = (n) => isLR ? n.height : n.width;
+  const byRank = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    const arr = byRank.get(n.rank);
+    if (arr) arr.push(n);
+    else byRank.set(n.rank, [n]);
+  }
+  const ranks = [...byRank.keys()].sort((a, b) => a - b);
+  const mainStart = /* @__PURE__ */ new Map();
+  let cursor = 0;
+  for (const r of ranks) {
+    mainStart.set(r, cursor);
+    cursor += Math.max(...byRank.get(r).map(mainSize)) + rankSep;
+  }
+  const out = [];
+  for (const r of ranks) {
+    const layer = byRank.get(r);
+    const extent = Math.max(...layer.map(mainSize));
+    const span = layer.reduce((s, n) => s + crossSize(n), 0) + crossSep * (layer.length - 1);
+    let cross = -span / 2;
+    for (const n of layer) {
+      const main = mainStart.get(r) + (extent - mainSize(n)) / 2;
+      out.push({
+        id: n.id,
+        position: isLR ? { x: main, y: cross } : { x: cross, y: main },
+        width: n.width,
+        height: n.height,
+        data: n.data
+      });
+      cross += crossSize(n) + crossSep;
+    }
+  }
+  const minX = Math.min(...out.map((n) => n.position.x));
+  const minY = Math.min(...out.map((n) => n.position.y));
+  for (const n of out) {
+    n.position = { x: n.position.x - minX, y: n.position.y - minY };
+  }
+  return out;
+}
+function buildWorkflowGraph(yaml, options) {
+  const reserveRunState = options?.reserveRunState ?? false;
+  const direction = options?.direction ?? "LR";
+  const compact = options?.compact ?? false;
+  if (!yaml || yaml.trim() === "") {
+    return { nodes: [], edges: [], error: "No definition" };
+  }
+  let parsed;
+  try {
+    parsed = parseYaml(yaml);
+  } catch {
+    return { nodes: [], edges: [], error: "Invalid YAML" };
+  }
+  const def = asRecord(parsed);
+  const actions = Array.isArray(def.do) ? def.do : [];
+  if (!def.on && actions.length === 0) {
+    return { nodes: [], edges: [], error: "Empty workflow" };
+  }
+  const logical = [];
+  const edges = [];
+  const geo = geometry(compact, reserveRunState, direction);
+  const addNode = (id, data, rank2, withRunState) => {
+    const dims = geo.size ?? {
+      width: NODE_W,
+      height: nodeHeight(data, withRunState)
+    };
+    logical.push({ id, data, width: dims.width, height: dims.height, rank: rank2 });
+  };
+  const addEdge = (source, target, kind) => {
+    edges.push({ id: `${source}->${target}`, source, target, kind });
+  };
+  let rank = 0;
+  let prevExits = [];
+  const branchLeafIds = /* @__PURE__ */ new Set();
+  if (def.on) {
+    addNode("trigger", describeTrigger(def.on), rank, false);
+    prevExits = ["trigger"];
+    rank += 1;
+  }
+  actions.forEach((action, i) => {
+    const id = `a${i}`;
+    const data = describeAction(action);
+    if (i === 0 && !def.on) data.isRoot = true;
+    addNode(id, data, rank, reserveRunState);
+    for (const from of prevExits) {
+      addEdge(from, id, branchLeafIds.has(from) ? "join" : "spine");
+    }
+    const rec = asRecord(action);
+    const children = "parallel" in rec ? Array.isArray(asRecord(rec.parallel).branches) ? asRecord(rec.parallel).branches : [] : "foreach" in rec ? (
+      // A foreach with no `do` template has no child to render.
+      [asRecord(rec.foreach).do].filter(Boolean)
+    ) : [];
+    if (children.length > 0) {
+      const branchRank = rank + 1;
+      const branchIds = [];
+      children.forEach((child, j) => {
+        const cid = `${id}-b${j}`;
+        addNode(cid, describeAction(child), branchRank, reserveRunState);
+        addEdge(id, cid, "fork");
+        branchIds.push(cid);
+        branchLeafIds.add(cid);
+      });
+      prevExits = branchIds;
+      rank = branchRank + 1;
+    } else {
+      prevExits = [id];
+      rank += 1;
+    }
+  });
+  return {
+    nodes: layoutLayers(logical, direction, geo.rankSep, geo.crossSep),
+    edges,
+    error: null
+  };
+}
+
+export {
+  fmtDuration,
+  fmtCost,
+  clampPreview,
+  fmtTokens,
+  shortModel,
+  providerLabel,
+  COMPACT_TILE,
+  COMPACT_NODE_SIZE,
+  buildWorkflowGraph
+};