@workflow-code/cli 0.1.0

package/.env.example

@@ -0,0 +1,5 @@
+WORKFLOW_SERVER_URL=http://localhost:7125
+WORKFLOW_SERVER_ADMIN_KEY=replace-with-admin-key
+WORKFLOW_BOOTSTRAP_ADMIN_EMAIL=admin@example.com
+WORKFLOW_BOOTSTRAP_ADMIN_PASSWORD=replace-with-admin-password
+WORKFLOW_REPO_ROOT=

package/README.md

@@ -0,0 +1,8 @@
+# @workflow-code/cli
+
+Unified local and server workspace CLI for Workflow Code projects.
+
+```bash
+pnpm add -D workflow-code @workflow-code/cli
+workflow-code --help
+```

package/dist/index.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import path from "path";
+import { pathToFileURL } from "url";
+async function main(argv = process.argv.slice(2)) {
+  if (argv[0] === "workspace") {
+    const workspaceCli = await import("./workspace-WJOCEGA6.js");
+    await workspaceCli.main(argv.slice(1));
+    return typeof process.exitCode === "number" ? process.exitCode : 0;
+  }
+  if (argv.length === 0 || argv[0] === "help" || argv[0] === "--help" || argv[0] === "-h") {
+    process.stdout.write(`${formatHelp()}
+`);
+    return 0;
+  }
+  const { register } = await import("tsx/esm/api");
+  register();
+  const localCli = await import("./local-XBULJ25O.js");
+  return localCli.main(argv);
+}
+function formatHelp() {
+  return [
+    "Usage:",
+    "  workflow-code <run|json|structure|resolve-params> [workflow-dir] [args]",
+    "  workflow-code workspace <command> [args]",
+    "",
+    "Local commands:",
+    "  run             Run a workflow locally",
+    "  json            Run locally and print the JSON report",
+    "  structure       Inspect workflow structure",
+    "  resolve-params  Resolve dynamic workflow parameters",
+    "",
+    "Workspace commands:",
+    "  login, logout, status, health, pack, upload, preparation,",
+    "  download, publish, run, debug-node, versions",
+    "",
+    "Run `workflow-code workspace --help` for workspace command details."
+  ].join("\n");
+}
+if (process.argv[1] !== void 0 && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
+  main().then((exitCode) => {
+    process.exitCode = exitCode;
+  }).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  });
+}
+export {
+  main
+};

package/dist/local-XBULJ25O.js

@@ -0,0 +1,337 @@
+#!/usr/bin/env node
+
+// src/local.ts
+import path from "path";
+import { readFileSync } from "fs";
+import { pathToFileURL } from "url";
+import {
+  createCliOutputStreamHooks,
+  createWorkflowFailure,
+  formatWorkflowExecutionJson,
+  inspectLocalWorkflowStructure,
+  parseToolPermissionPoliciesJson,
+  resolveLocalWorkflowParams,
+  runLocalWorkflowWithReport
+} from "workflow-code";
+var WORKFLOW_APP_RUNTIME_EVENTS_ENV = "WORKFLOW_APP_RUNTIME_EVENTS";
+var WORKFLOW_APP_RUNTIME_EVENT_PREFIX = "__WORKFLOW_CODE_RUNTIME_EVENT__";
+var RESUME_RUNTIME_EVENT_AFTER_REQUEST_ID = "__workflowResumeRuntimeEventAfterRequestId";
+async function main(argv = process.argv.slice(2)) {
+  disableAiSdkWarningLogs();
+  const abortController = createProcessAbortController();
+  const command = parseCommand(argv[0]);
+  const args = command === "help" ? argv.slice(1) : argv.slice(1);
+  if (command === "help") {
+    console.log(formatHelp());
+    return 0;
+  }
+  if (command === "structure") {
+    return runStructureCommand(args);
+  }
+  if (command === "resolve-params") {
+    return runResolveParamsCommand(args, abortController.signal);
+  }
+  const parsed = parseWorkflowArgs(args, {
+    json: command === "json"
+  });
+  const report = await runLocalWorkflowWithReport({
+    workflowDir: parsed.workflowDir,
+    args: parsed.args,
+    runId: parsed.runId,
+    conversationId: parsed.conversationId,
+    kvStoreDir: process.env.WORKFLOW_KV_STORE_DIR,
+    persistentValueStoreDir: process.env.WORKFLOW_PERSISTENT_VALUE_STORE_DIR,
+    persistentValueWorkflowName: process.env.WORKFLOW_PERSISTENT_VALUE_WORKFLOW_NAME,
+    fileStoreDir: parsed.fileStoreDir ?? process.env.WORKFLOW_FILE_STORE_DIR,
+    userInput: createCliUserInputContext(parsed.resolvedUserInputs),
+    toolPermissionPolicies: parsed.toolPermissionPolicies,
+    fileCreateStoreDir: process.env.WORKFLOW_FILE_CREATE_STORE_DIR,
+    nodeHooks: parsed.json ? void 0 : createCliOutputStreamHooks(),
+    onRuntimeEvent: parsed.json ? createAppRuntimeEventEmitter() : void 0,
+    abortSignal: abortController.signal
+  });
+  if (parsed.json) {
+    console.log(formatWorkflowExecutionJson(report));
+  } else if (report.status === "failed") {
+    console.error(formatWorkflowExecutionJson(report));
+  }
+  return getReportExitCode(report);
+}
+function createProcessAbortController() {
+  const controller = new AbortController();
+  let forcedExit;
+  const abort = () => {
+    if (!controller.signal.aborted) {
+      controller.abort(new Error("Workflow CLI process was interrupted."));
+      forcedExit = setTimeout(() => {
+        process.exit(130);
+      }, 5e3);
+      forcedExit.unref?.();
+    }
+  };
+  process.once("SIGINT", abort);
+  process.once("SIGTERM", abort);
+  process.once("beforeExit", () => clearTimeout(forcedExit));
+  return controller;
+}
+function parseCommand(value) {
+  if (value === void 0 || value === "--help" || value === "-h" || value === "help") {
+    return "help";
+  }
+  if (value === "run" || value === "json" || value === "structure" || value === "resolve-params") {
+    return value;
+  }
+  throw new Error(`Unknown workflow-code command: ${value}`);
+}
+async function runResolveParamsCommand(argv, abortSignal) {
+  const parsed = parseWorkflowArgs(argv, { json: true });
+  const request = parseParamResolveRequest(readFileSync(0, "utf8"));
+  const result = await resolveLocalWorkflowParams({
+    workflowDir: parsed.workflowDir,
+    request,
+    abortSignal
+  });
+  console.log(JSON.stringify(result));
+  return 0;
+}
+function parseParamResolveRequest(value) {
+  const parsed = JSON.parse(value);
+  if (typeof parsed !== "object" || parsed === null || typeof parsed.draftText !== "string" || !Array.isArray(parsed.args) || !parsed.args.every((arg) => typeof arg === "string") || parsed.inputMode !== "form" && parsed.inputMode !== "raw" || typeof parsed.trigger !== "object" || parsed.trigger === null || parsed.trigger.kind !== "init" && parsed.trigger.kind !== "input" && parsed.trigger.kind !== "param" || parsed.trigger.kind === "param" && typeof parsed.trigger.paramName !== "string") {
+    throw new Error("resolve-params stdin must contain a valid WorkflowParamResolveRequest JSON object.");
+  }
+  return parsed;
+}
+function parseWorkflowArgs(argv, options) {
+  let json = options.json;
+  let runId;
+  let conversationId;
+  let fileStoreDir;
+  let resolvedUserInputs = [];
+  let toolPermissionPolicies;
+  const filteredArgv = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--") {
+      filteredArgv.push(...argv.slice(index));
+      break;
+    }
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (arg === "--conversation-id") {
+      conversationId = readWorkflowArgValue(argv, ++index, "--conversation-id");
+      continue;
+    }
+    if (arg === "--run-id") {
+      runId = readWorkflowArgValue(argv, ++index, "--run-id");
+      continue;
+    }
+    if (arg === "--file-store-dir") {
+      fileStoreDir = readWorkflowArgValue(argv, ++index, "--file-store-dir");
+      continue;
+    }
+    if (arg === "--resolved-user-inputs-json") {
+      resolvedUserInputs = parseResolvedUserInputs(
+        readWorkflowArgValue(argv, ++index, "--resolved-user-inputs-json")
+      );
+      continue;
+    }
+    if (arg === "--tool-permissions-json") {
+      toolPermissionPolicies = parseToolPermissionPoliciesJson(
+        readWorkflowArgValue(argv, ++index, "--tool-permissions-json")
+      );
+      continue;
+    }
+    filteredArgv.push(arg);
+  }
+  const [workflowDirArg, ...rest] = filteredArgv;
+  if (workflowDirArg !== void 0 && workflowDirArg !== "--" && !workflowDirArg.startsWith("-")) {
+    return {
+      workflowDir: path.resolve(process.cwd(), workflowDirArg),
+      args: removePnpmRunSeparator(rest),
+      json,
+      runId,
+      conversationId,
+      fileStoreDir,
+      resolvedUserInputs,
+      toolPermissionPolicies
+    };
+  }
+  return {
+    workflowDir: process.cwd(),
+    args: removePnpmRunSeparator(filteredArgv),
+    json,
+    runId,
+    conversationId,
+    fileStoreDir,
+    resolvedUserInputs,
+    toolPermissionPolicies
+  };
+}
+function createCliUserInputContext(resolvedInputs) {
+  return {
+    [RESUME_RUNTIME_EVENT_AFTER_REQUEST_ID]: resolvedInputs.at(-1)?.requestId,
+    getResolvedInput(requestId) {
+      return resolvedInputs.find((input) => input.requestId === requestId);
+    },
+    requestInput() {
+      throw new Error(
+        "Workflow is waiting for user input. Re-run with --run-id and --resolved-user-inputs-json to resume."
+      );
+    }
+  };
+}
+function parseResolvedUserInputs(value) {
+  const parsed = JSON.parse(value);
+  if (!Array.isArray(parsed)) {
+    throw new Error("--resolved-user-inputs-json must be an array.");
+  }
+  return parsed.map((item) => {
+    if (typeof item !== "object" || item === null || typeof item.requestId !== "string" || typeof item.nodeName !== "string" || typeof item.values !== "object" || item.values === null || typeof item.submittedAt !== "string") {
+      throw new Error("Invalid resolved user input item.");
+    }
+    return {
+      requestId: item.requestId,
+      nodeName: item.nodeName,
+      values: item.values,
+      submittedAt: new Date(item.submittedAt)
+    };
+  });
+}
+function createAppRuntimeEventEmitter() {
+  if (process.env[WORKFLOW_APP_RUNTIME_EVENTS_ENV] !== "1") {
+    return void 0;
+  }
+  return (event) => {
+    process.stdout.write(
+      `${WORKFLOW_APP_RUNTIME_EVENT_PREFIX}${JSON.stringify(event, createRuntimeEventJsonReplacer())}
+`
+    );
+  };
+}
+function createRuntimeEventJsonReplacer() {
+  const ancestors = [];
+  return function replacer(_key, value) {
+    if (typeof value === "bigint") {
+      return `${value.toString()}n`;
+    }
+    if (typeof value === "function") {
+      return `[Function ${value.name || "anonymous"}]`;
+    }
+    if (typeof value === "symbol") {
+      return value.toString();
+    }
+    if (typeof value === "object" && value !== null) {
+      while (ancestors.length > 0 && ancestors.at(-1) !== this) {
+        ancestors.pop();
+      }
+      if (ancestors.includes(value)) {
+        return "[Circular]";
+      }
+      ancestors.push(value);
+    }
+    return value;
+  };
+}
+function readWorkflowArgValue(argv, index, name) {
+  const value = argv[index];
+  if (value === void 0) {
+    throw new Error(`Missing value for ${name}.`);
+  }
+  return value;
+}
+function runStructureCommand(argv) {
+  const parsed = parseWorkflowArgs(argv, { json: true });
+  try {
+    const report = inspectLocalWorkflowStructure({
+      workflowDir: parsed.workflowDir
+    });
+    console.log(JSON.stringify(report, null, 2));
+    return 0;
+  } catch (error) {
+    console.log(formatWorkflowStructureError(error));
+    return 1;
+  }
+}
+function removePnpmRunSeparator(argv) {
+  const separatorIndex = argv.indexOf("--");
+  if (separatorIndex < 0) {
+    return argv;
+  }
+  return [
+    ...argv.slice(0, separatorIndex),
+    ...argv.slice(separatorIndex + 1)
+  ];
+}
+function getReportExitCode(report) {
+  if (report.status === "failed") {
+    return 1;
+  }
+  const result = report.result;
+  if (result.ok && typeof result.data === "object" && result.data !== null && "errCode" in result.data && typeof result.data.errCode === "number") {
+    return result.data.errCode === 0 ? 0 : 1;
+  }
+  return 0;
+}
+function formatWorkflowStructureError(error) {
+  return JSON.stringify(
+    {
+      workflow: {
+        name: ""
+      },
+      definitions: {
+        nodes: {},
+        apiCalls: [],
+        variables: {}
+      },
+      execution: {
+        kind: "sequence",
+        children: []
+      },
+      diagnostics: {
+        warnings: [],
+        violations: [],
+        error: createWorkflowFailure(error).error
+      }
+    },
+    null,
+    2
+  );
+}
+function formatHelp() {
+  return [
+    "Usage:",
+    "  workflow-code run [workflow-dir] [--] [...args]",
+    "  workflow-code json [workflow-dir] [--] [...args]",
+    "  workflow-code json [workflow-dir] --conversation-id <id> [--] [...args]",
+    "  workflow-code structure [workflow-dir]",
+    "  workflow-code resolve-params [workflow-dir] < request.json",
+    "",
+    "Examples:",
+    "  workflow-code run .",
+    "  workflow-code run . -- --target aliyun --dry-run",
+    "  workflow-code json . -- --target aliyun --dry-run",
+    "  workflow-code json . --run-id <id> --resolved-user-inputs-json <json> -- [...args]",
+    "  workflow-code structure .",
+    "  workflow-code resolve-params . < request.json"
+  ].join("\n");
+}
+function disableAiSdkWarningLogs() {
+  globalThis.AI_SDK_LOG_WARNINGS = false;
+}
+if (isCliEntrypoint()) {
+  main().then((exitCode) => {
+    process.exitCode = exitCode;
+  }).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  });
+}
+function isCliEntrypoint() {
+  return process.argv[1] !== void 0 && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href;
+}
+export {
+  main,
+  parseWorkflowArgs
+};