@canaryai/cli 0.2.9 → 0.2.12

package/dist/workflow-HXIUXRFI.js

@@ -0,0 +1,613 @@
+import { createRequire as __cr } from "module"; const require = __cr(import.meta.url);
+import {
+  apiRequest
+} from "./chunk-ERSNYLMZ.js";
+import {
+  getArgValue,
+  hasFlag,
+  resolveConfig
+} from "./chunk-PWWQGYFG.js";
+import "./chunk-XAA5VQ5N.js";
+import "./chunk-VKVL7WBN.js";
+
+// src/workflow.ts
+import fs2 from "fs/promises";
+import process2 from "process";
+
+// src/workflow-create.ts
+import fs from "fs/promises";
+import process from "process";
+import { createParser } from "eventsource-parser";
+async function readFromStdin() {
+  const chunks = [];
+  const stdin = process.stdin;
+  if (stdin.isTTY) {
+    throw new Error("No input on stdin. Pipe workflow JSON or use --from-file.");
+  }
+  return new Promise((resolve, reject) => {
+    stdin.on("data", (chunk) => chunks.push(chunk));
+    stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+    stdin.on("error", reject);
+  });
+}
+async function readWorkflowInput(argv) {
+  let raw;
+  const fromFile = getArgValue(argv, "--from-file");
+  if (fromFile) {
+    try {
+      raw = await fs.readFile(fromFile, "utf-8");
+    } catch (err) {
+      throw new Error(`Failed to read file ${fromFile}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  } else {
+    raw = await readFromStdin();
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error("Invalid JSON input. Please provide valid workflow JSON.");
+  }
+  const input = parsed;
+  if (!input.name || typeof input.name !== "string") {
+    throw new Error('Workflow JSON must include a "name" string field.');
+  }
+  if (!Array.isArray(input.nodes) || input.nodes.length === 0) {
+    throw new Error('Workflow JSON must include a non-empty "nodes" array.');
+  }
+  const validNodeTypes = ["login", "navigate", "action", "assertion", "end", "setup", "seed", "wait"];
+  for (const node of input.nodes) {
+    if (!node.nodeType || !validNodeTypes.includes(node.nodeType)) {
+      throw new Error(
+        `Invalid nodeType "${node.nodeType}". Valid types: ${validNodeTypes.join(", ")}`
+      );
+    }
+  }
+  return input;
+}
+async function detectSessionContext(apiUrl, token) {
+  try {
+    const res = await fetch(`${apiUrl}/sessions/status`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!res.ok) return {};
+    const data = await res.json();
+    const sessions = data.sessions;
+    if (!sessions || sessions.length === 0) return {};
+    const session = sessions[0];
+    return {
+      propertyId: session.propertyId,
+      credentialId: session.credentialId
+    };
+  } catch {
+    return {};
+  }
+}
+async function runAndPublish(opts) {
+  const { apiUrl, token, workflowId, workflowName } = opts;
+  const body = {};
+  if (opts.propertyId) body.propertyId = opts.propertyId;
+  if (opts.environmentId) body.environmentId = opts.environmentId;
+  const triggerUrl = `${apiUrl}/workflows/test-runs?namePattern=${encodeURIComponent(workflowName)}`;
+  let triggerRes;
+  try {
+    triggerRes = await fetch(triggerUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+  } catch (err) {
+    console.error(`Failed to trigger test run: ${err}`);
+    return false;
+  }
+  if (!triggerRes.ok) {
+    const errorText = await triggerRes.text();
+    console.error(`Failed to trigger test run: ${triggerRes.status} ${errorText}`);
+    return false;
+  }
+  const triggerData = await triggerRes.json();
+  if (!triggerData.ok || !triggerData.suiteId) {
+    console.error(`Failed to trigger test run: ${triggerData.error ?? "Unknown error"}`);
+    return false;
+  }
+  const { suiteId } = triggerData;
+  console.log(`Test run started (suite: ${suiteId})`);
+  console.log("Streaming results...\n");
+  const streamUrl = `${apiUrl}/workflows/test-runs/stream?suiteId=${suiteId}`;
+  let streamRes;
+  try {
+    streamRes = await fetch(streamUrl, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "text/event-stream"
+      }
+    });
+  } catch (err) {
+    console.error(`Failed to connect to event stream: ${err}`);
+    return false;
+  }
+  if (!streamRes.ok || !streamRes.body) {
+    console.error(`Failed to connect to event stream: ${streamRes.status}`);
+    return false;
+  }
+  let success = false;
+  let hasCompleted = false;
+  const parser = createParser({
+    onEvent: (event) => {
+      if (!event.data) return;
+      try {
+        const data = JSON.parse(event.data);
+        if (event.event === "workflow-test") {
+          const testEvent = data;
+          if (testEvent.status === "success") {
+            console.log(`  \u2713 ${workflowName}`);
+            success = true;
+          } else if (testEvent.status === "failed") {
+            console.log(`  \u2717 ${workflowName}`);
+            if (testEvent.errorMessage) {
+              console.log(`    Error: ${testEvent.errorMessage.slice(0, 200)}`);
+            }
+            success = false;
+          } else if (testEvent.status === "running") {
+            console.log(`  \u25B6 Running ${workflowName}...`);
+          }
+        }
+        if (event.event === "workflow-test-suite") {
+          const suiteEvent = data;
+          if (suiteEvent.status === "completed") {
+            hasCompleted = true;
+          }
+        }
+      } catch {
+      }
+    }
+  });
+  const reader = streamRes.body.getReader();
+  const decoder = new TextDecoder();
+  try {
+    while (!hasCompleted) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      parser.feed(decoder.decode(value, { stream: true }));
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  if (success) {
+    try {
+      const publishRes = await fetch(`${apiUrl}/workflows/${workflowId}/publish`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json"
+        }
+      });
+      if (publishRes.ok) {
+        console.log(`
+\u2713 Workflow published successfully`);
+        return true;
+      } else {
+        console.error(`
+Failed to publish workflow: ${publishRes.status}`);
+        return false;
+      }
+    } catch (err) {
+      console.error(`
+Failed to publish workflow: ${err}`);
+      return false;
+    }
+  }
+  console.log(`
+\u2717 Test failed \u2014 workflow left in draft for manual review`);
+  return false;
+}
+async function handleWorkflowCreate(argv, apiUrl, token) {
+  const quarantine = hasFlag(argv, "--quarantine");
+  const runAndPublishFlag = hasFlag(argv, "--run-and-publish");
+  const propertyArg = getArgValue(argv, "--property");
+  const environmentArg = getArgValue(argv, "--environment");
+  if (quarantine && runAndPublishFlag) {
+    console.error("Error: --quarantine and --run-and-publish are mutually exclusive.");
+    process.exit(1);
+  }
+  let input;
+  try {
+    input = await readWorkflowInput(argv);
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  if (!input.propertyId && !input.credentialId) {
+    const sessionCtx = await detectSessionContext(apiUrl, token);
+    if (sessionCtx.propertyId) {
+      input.propertyId = sessionCtx.propertyId;
+      console.log(`Auto-linked property from active session`);
+    }
+    if (sessionCtx.credentialId) {
+      input.credentialId = sessionCtx.credentialId;
+      console.log(`Auto-linked credential from active session`);
+    }
+  }
+  if (quarantine) {
+    input.status = "quarantined";
+  }
+  input.createdVia = "cli";
+  const res = await fetch(`${apiUrl}/workflows/create-with-nodes`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(input)
+  });
+  if (res.status === 401) {
+    console.error("Error: Unauthorized. Your session may have expired.");
+    console.error("Run: canary login");
+    process.exit(1);
+  }
+  const result = await res.json();
+  if (!result.ok || !result.workflow) {
+    console.error(`Error: ${result.error ?? "Failed to create workflow"}`);
+    process.exit(1);
+  }
+  const { workflow, nodes, edges } = result;
+  console.log(`
+\u2713 Workflow created: ${workflow.name}`);
+  console.log(`  ID: ${workflow.id}`);
+  console.log(`  Status: ${workflow.status}`);
+  console.log(`  Nodes: ${nodes?.length ?? 0}`);
+  console.log(`  Edges: ${edges?.length ?? 0}`);
+  const webUrl = apiUrl.replace(/\/api\b|api\./, "app.").replace(/:\d+$/, ":5173");
+  console.log(`  URL: ${webUrl}/workflows/${workflow.id}`);
+  if (runAndPublishFlag) {
+    console.log("\nTriggering test run...");
+    const passed = await runAndPublish({
+      apiUrl,
+      token,
+      workflowId: workflow.id,
+      workflowName: workflow.name,
+      propertyId: propertyArg ?? input.propertyId,
+      environmentId: environmentArg
+    });
+    if (!passed) {
+      process.exit(1);
+    }
+  }
+}
+
+// src/workflow.ts
+function truncate(text, max) {
+  if (text.length <= max) return text;
+  return text.slice(0, max - 1) + "\u2026";
+}
+function getNodeTitle(node) {
+  const c = node.configJson;
+  switch (node.nodeType) {
+    case "login":
+      return c.credentialName || "Login";
+    case "navigate":
+      return c.pageTitle || truncate(c.pageUrl || "Navigate", 40);
+    case "action":
+      return c.customActionTitle || truncate(c.actionDescription || "Action", 50);
+    case "assertion":
+      return truncate(c.condition || "Assertion", 50);
+    case "setup":
+      return c.setupFlowName || "Setup";
+    case "seed":
+      return c.seedWorkflowName || "Seed";
+    case "wait":
+      return "Wait";
+    case "condition":
+      return truncate(c.conditionDescription || "Condition", 50);
+    case "end":
+      return "End";
+    case "api_sequence":
+      return "API Sequence";
+    default:
+      return node.nodeType;
+  }
+}
+function getCleanConfig(node) {
+  const c = node.configJson;
+  switch (node.nodeType) {
+    case "login":
+      return pick(c, ["credentialName", "performLogin"]);
+    case "navigate":
+      return {
+        ...pick(c, ["pageUrl", "pageTitle"]),
+        ...c.openInNewTab ? { openInNewTab: true } : {}
+      };
+    case "action":
+      return pick(c, [
+        "actionDescription",
+        "customActionInstructions",
+        "playbookSteps",
+        "inputValues",
+        "declaredOutputs"
+      ]);
+    case "assertion":
+      return pick(c, ["condition", "expectedOutcome", "strict", "alwaysUseAgent"]);
+    case "setup":
+      return pick(c, ["setupFlowId", "setupFlowName"]);
+    case "seed":
+      return pick(c, ["seedWorkflowId", "seedWorkflowName", "snapshotVersion"]);
+    case "end":
+      return pick(c, ["outcome"]);
+    case "wait":
+    case "condition":
+    case "api_sequence":
+      return c;
+    default:
+      return c;
+  }
+}
+function pick(obj, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (obj[key] !== void 0 && obj[key] !== null) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+function formatWorkflowMarkdown(workflow) {
+  const sections = [];
+  sections.push(`# ${workflow.name}`);
+  const meta = [`**ID:** ${workflow.id}`, `**Status:** ${workflow.status}`, `**Type:** ${workflow.flowType}`];
+  sections.push(meta.join(" | "));
+  if (workflow.description) {
+    sections.push(`**Description:** ${workflow.description}`);
+  }
+  sections.push("---");
+  const sorted = [...workflow.nodes].sort((a, b) => a.orderIndex - b.orderIndex);
+  for (let i = 0; i < sorted.length; i++) {
+    const node = sorted[i];
+    const title = getNodeTitle(node);
+    const stepLines = [];
+    stepLines.push(`## Step ${i + 1}: ${title}`);
+    stepLines.push(`**Type:** ${node.nodeType}`);
+    const c = node.configJson;
+    switch (node.nodeType) {
+      case "login": {
+        if (c.credentialName) stepLines.push(`**Credential:** ${c.credentialName}`);
+        if (c.performLogin !== void 0) stepLines.push(`**Perform Login:** ${c.performLogin ? "Yes" : "No"}`);
+        break;
+      }
+      case "navigate": {
+        if (c.pageUrl) stepLines.push(`**URL:** ${c.pageUrl}`);
+        if (c.openInNewTab) stepLines.push(`**Open in New Tab:** Yes`);
+        break;
+      }
+      case "action": {
+        const instructions = c.customActionInstructions || c.actionDescription;
+        if (instructions) stepLines.push(`**Instructions:** ${instructions}`);
+        const playbook = c.playbookSteps;
+        if (playbook && playbook.length > 0) {
+          stepLines.push("");
+          stepLines.push("**Playbook:**");
+          for (const step of playbook) {
+            stepLines.push(`${step.order}. [${step.action}] ${step.target}`);
+          }
+        }
+        break;
+      }
+      case "assertion": {
+        if (c.condition) stepLines.push(`**Condition:** ${c.condition}`);
+        if (c.strict) stepLines.push(`**Strict:** Yes`);
+        break;
+      }
+      case "setup": {
+        if (c.setupFlowName) stepLines.push(`**Setup Flow:** ${c.setupFlowName}`);
+        break;
+      }
+      case "seed": {
+        if (c.seedWorkflowName) stepLines.push(`**Seed Workflow:** ${c.seedWorkflowName}`);
+        break;
+      }
+      case "wait": {
+        if (c.waitDuration) stepLines.push(`**Duration:** ${c.waitDuration}`);
+        break;
+      }
+      case "condition": {
+        if (c.conditionDescription) stepLines.push(`**Condition:** ${c.conditionDescription}`);
+        break;
+      }
+      case "end": {
+        if (c.outcome) stepLines.push(`**Outcome:** ${c.outcome}`);
+        break;
+      }
+    }
+    sections.push(stepLines.join("\n"));
+  }
+  return sections.join("\n\n");
+}
+function formatWorkflowJson(workflow) {
+  const sorted = [...workflow.nodes].sort((a, b) => a.orderIndex - b.orderIndex);
+  return {
+    workflow: {
+      id: workflow.id,
+      name: workflow.name,
+      description: workflow.description,
+      status: workflow.status,
+      flowType: workflow.flowType
+    },
+    steps: sorted.map((node, i) => ({
+      index: i + 1,
+      nodeId: node.id,
+      nodeType: node.nodeType,
+      title: getNodeTitle(node),
+      config: getCleanConfig(node)
+    }))
+  };
+}
+async function handleList(argv, apiUrl, token) {
+  const jsonOutput = hasFlag(argv, "--json");
+  const params = new URLSearchParams();
+  const search = getArgValue(argv, "--search");
+  const flowType = getArgValue(argv, "--flow-type");
+  const status = getArgValue(argv, "--status");
+  const page = getArgValue(argv, "--page");
+  const pageSize = getArgValue(argv, "--page-size");
+  if (search) params.set("search", search);
+  if (flowType) params.set("flowType", flowType);
+  if (status) params.set("status", status);
+  if (page) params.set("page", page);
+  if (pageSize) params.set("pageSize", pageSize);
+  const qs = params.toString();
+  const path = `/workflows${qs ? `?${qs}` : ""}`;
+  const result = await apiRequest(apiUrl, token, "GET", path);
+  if (!result.ok) {
+    console.error(`Error: ${result.error}`);
+    process2.exit(1);
+  }
+  if (jsonOutput) {
+    console.log(JSON.stringify({ data: result.data, pagination: result.pagination }, null, 2));
+    return;
+  }
+  const { data, pagination } = result;
+  console.log(`Workflows: ${pagination.totalItems} total (page ${pagination.page}/${pagination.totalPages})
+`);
+  if (data.length === 0) {
+    console.log("No workflows found.");
+    return;
+  }
+  const idW = 36;
+  const nameW = 30;
+  const statusW = 12;
+  const typeW = 10;
+  const header = [
+    "ID".padEnd(idW),
+    "Name".padEnd(nameW),
+    "Status".padEnd(statusW),
+    "Type".padEnd(typeW)
+  ].join("  ");
+  console.log(header);
+  for (const w of data) {
+    const row = [
+      w.id.padEnd(idW),
+      truncate(w.name, nameW).padEnd(nameW),
+      w.status.padEnd(statusW),
+      w.flowType.padEnd(typeW)
+    ].join("  ");
+    console.log(row);
+  }
+}
+async function handleGet(argv, apiUrl, token) {
+  const workflowId = argv[0];
+  if (!workflowId || workflowId.startsWith("--")) {
+    console.error("Error: Missing workflow ID.");
+    console.error("Usage: canary workflow get <workflowId>");
+    process2.exit(1);
+  }
+  const jsonOutput = hasFlag(argv, "--json") || getArgValue(argv, "--format") === "json";
+  const markdownOutput = hasFlag(argv, "--markdown") || getArgValue(argv, "--format") === "markdown";
+  const outputFile = getArgValue(argv, "--output");
+  const res = await fetch(`${apiUrl}/workflows/${workflowId}`, {
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" }
+  });
+  if (res.status === 401) {
+    console.error("Error: Unauthorized. Your session may have expired.");
+    console.error("Run: canary login");
+    process2.exit(1);
+  }
+  const result = await res.json();
+  if (result.error === "WORKFLOW_NOT_FOUND") {
+    console.error("Error: Workflow not found.");
+    process2.exit(1);
+  }
+  if (result.error === "WORKFLOW_WRONG_ORG") {
+    console.error(`Error: Workflow belongs to another org: ${result.targetOrgName ?? result.targetOrgId}`);
+    process2.exit(1);
+  }
+  if (!result.workflow) {
+    console.error(`Error: ${result.error ?? "Unexpected response"}`);
+    process2.exit(1);
+  }
+  const workflow = result.workflow;
+  let output;
+  if (markdownOutput) {
+    output = formatWorkflowMarkdown(workflow);
+  } else {
+    output = JSON.stringify(formatWorkflowJson(workflow), null, 2);
+  }
+  if (outputFile) {
+    try {
+      await fs2.writeFile(outputFile, output, "utf-8");
+      console.log(`Written to ${outputFile}`);
+    } catch (err) {
+      console.error(`Error writing to ${outputFile}: ${err instanceof Error ? err.message : String(err)}`);
+      process2.exit(1);
+    }
+    return;
+  }
+  console.log(output);
+}
+function printWorkflowHelp() {
+  console.log(
+    [
+      "Usage: canary workflow <sub-command> [options]",
+      "",
+      "Sub-commands:",
+      "  list [options]                       List workflows",
+      "  get <workflowId> [options]           Get workflow definition with steps",
+      "  create [options]                     Create workflow from JSON (stdin or file)",
+      "",
+      "List options:",
+      "  --search <query>      Search by name",
+      "  --flow-type <type>    Filter: standard, setup, seed, teardown",
+      "  --status <status>     Filter: draft, published, archived",
+      "  --page <n>            Page number (default: 1)",
+      "  --page-size <n>       Page size (default: 25)",
+      "  --json                Output raw JSON",
+      "",
+      "Get options:",
+      "  --format json|markdown  Output format (default: json)",
+      "  --json                  Shorthand for --format json",
+      "  --markdown              Shorthand for --format markdown",
+      "  --output <file>         Write output to file",
+      "",
+      "Create options:",
+      "  --from-stdin            Read workflow JSON from stdin (default)",
+      "  --from-file <path>      Read workflow JSON from file",
+      "  --quarantine            Create with quarantined status (auto-promotes after 3 passes)",
+      "  --run-and-publish       Create as draft, run test, publish on success",
+      "  --property <name|id>    Property for run-and-publish",
+      "  --environment <name|id> Environment for run-and-publish",
+      "",
+      "Common options:",
+      "  --env <env>           Target environment (prod, dev, local)",
+      "  --api-url <url>       API URL override",
+      "  --token <key>         API token override"
+    ].join("\n")
+  );
+}
+async function runWorkflow(argv) {
+  const [subCommand, ...rest] = argv;
+  if (!subCommand || subCommand === "help" || hasFlag(argv, "--help", "-h")) {
+    printWorkflowHelp();
+    return;
+  }
+  const { apiUrl, token } = await resolveConfig(argv);
+  switch (subCommand) {
+    case "list":
+      await handleList(rest, apiUrl, token);
+      break;
+    case "get":
+      await handleGet(rest, apiUrl, token);
+      break;
+    case "create":
+      await handleWorkflowCreate(rest, apiUrl, token);
+      break;
+    default:
+      console.error(`Unknown sub-command: ${subCommand}`);
+      printWorkflowHelp();
+      process2.exit(1);
+  }
+}
+export {
+  runWorkflow
+};
+//# sourceMappingURL=workflow-HXIUXRFI.js.map