@workflow-code/cli 0.2.0 → 0.2.3-20260901001

package/dist/chunk-27OW6OJ3.js

@@ -0,0 +1,276 @@
+#!/usr/bin/env node
+
+// .shared/workflow-ids/index.ts
+import path from "path";
+var WORKFLOW_UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function isWorkflowUuid(value) {
+  return WORKFLOW_UUID_PATTERN.test(value.trim());
+}
+function assertWorkflowUuid(value, label = "workflow id") {
+  const normalized = value.trim();
+  if (!isWorkflowUuid(normalized)) {
+    throw new Error(`Invalid ${label} "${value}".`);
+  }
+  return normalized;
+}
+
+// .shared/project-info/index.ts
+var WORKFLOW_PROJECT_DATA_STORAGE_MODES = ["local", "server", "both"];
+var WORKFLOW_RELATED_PROJECT_ALIAS_PATTERN = /^[a-z][a-z0-9_-]{0,63}$/;
+var WORKFLOW_RELATED_PROJECT_LIMIT = 32;
+var WORKFLOW_RELATED_PROJECT_PREFIX_LIMIT = 32;
+var WORKFLOW_RELATED_PROJECT_KEY_LIMIT = 1024;
+var WORKFLOW_PROJECT_UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var PROJECT_INFO_ID_PATTERN = /^[a-z][a-z0-9-]*$/;
+function createUndeclaredWorkflowProjectInfo() {
+  return {
+    localizedNames: {},
+    declarations: [],
+    platformSupport: { mode: "agnostic" },
+    dataStorage: null,
+    relatedProjects: []
+  };
+}
+function normalizeWorkflowProjectInfo(value) {
+  if (!isRecord(value)) {
+    throw new Error("workflowCode.projectInfo must be an object.");
+  }
+  const localizedNames = normalizeLocalizedNames(value["localizedNames"]);
+  const declarations = normalizeIds(value["declarations"], "workflowCode.projectInfo.declarations");
+  const platformSupport = normalizePlatformSupport(value["platformSupport"]);
+  const dataStorage = normalizeDataStorage(value["dataStorage"]);
+  const relatedProjects = normalizeRelatedProjects(value["relatedProjects"]);
+  return { localizedNames, declarations, platformSupport, dataStorage, relatedProjects };
+}
+function readWorkflowProjectInfo(packageJson) {
+  if (!isRecord(packageJson)) return createUndeclaredWorkflowProjectInfo();
+  const workflowCode = packageJson["workflowCode"];
+  if (!isRecord(workflowCode) || workflowCode["projectInfo"] === void 0) {
+    return createUndeclaredWorkflowProjectInfo();
+  }
+  const projectInfo = normalizeWorkflowProjectInfo(workflowCode["projectInfo"]);
+  const projectId = typeof packageJson["id"] === "string" ? packageJson["id"].trim() : void 0;
+  if (projectId !== void 0 && projectId !== "") {
+    assertWorkflowRelatedProjects(projectInfo, projectId);
+  }
+  return projectInfo;
+}
+function assertWorkflowRelatedProjects(projectInfo, currentProjectId) {
+  if (projectInfo.relatedProjects.length === 0) return;
+  const normalizedProjectId = currentProjectId.trim();
+  if (!WORKFLOW_PROJECT_UUID_PATTERN.test(normalizedProjectId)) {
+    throw new Error("package.json.id must be a UUID before related projects can be declared.");
+  }
+  if (projectInfo.relatedProjects.some(
+    (relation) => relation.projectId.toLowerCase() === normalizedProjectId.toLowerCase()
+  )) {
+    throw new Error("workflowCode.projectInfo.relatedProjects cannot reference the current project.");
+  }
+}
+function findWorkflowRelatedProject(projectInfo, alias) {
+  const normalizedAlias = alias.trim();
+  return projectInfo.relatedProjects.find((relation) => relation.alias === normalizedAlias);
+}
+function resolveWorkflowRelatedProjectAccess(input) {
+  const consumer = findWorkflowRelatedProject(input.consumerProjectInfo, input.alias);
+  if (consumer?.projectId.toLowerCase() !== input.targetProjectId.trim().toLowerCase()) {
+    return void 0;
+  }
+  const target = input.targetProjectInfo.relatedProjects.find(
+    (relation) => relation.projectId.toLowerCase() === input.consumerProjectId.trim().toLowerCase()
+  );
+  if (target === void 0) return void 0;
+  return { consumer, target, grant: target.grantToRelatedProject };
+}
+function isWorkflowProjectDataStorageLocationAllowed(projectInfo, location) {
+  const mode = projectInfo.dataStorage?.mode;
+  return mode === "both" || mode === location;
+}
+function normalizeLocalizedNames(value) {
+  if (value === void 0) return {};
+  if (!isRecord(value)) {
+    throw new Error("workflowCode.projectInfo.localizedNames must be an object.");
+  }
+  const entries = [];
+  for (const [rawLocale, rawName] of Object.entries(value)) {
+    const locale = rawLocale.trim();
+    if (locale === "") {
+      throw new Error("workflowCode.projectInfo.localizedNames contains an empty locale.");
+    }
+    if (typeof rawName !== "string") {
+      throw new Error(`workflowCode.projectInfo.localizedNames.${locale} must be a string.`);
+    }
+    const name = rawName.trim();
+    if (name !== "") entries.push([locale, name]);
+  }
+  return Object.fromEntries(entries);
+}
+function normalizePlatformSupport(value) {
+  if (value === void 0) return { mode: "agnostic" };
+  if (!isRecord(value)) {
+    throw new Error("workflowCode.projectInfo.platformSupport must be an object.");
+  }
+  if (value["mode"] === "agnostic") {
+    if (value["platforms"] !== void 0) {
+      throw new Error("workflowCode.projectInfo.platformSupport.platforms is not allowed in agnostic mode.");
+    }
+    return { mode: "agnostic" };
+  }
+  if (value["mode"] !== "specific") {
+    throw new Error('workflowCode.projectInfo.platformSupport.mode must be "agnostic" or "specific".');
+  }
+  const platforms = normalizeIds(
+    value["platforms"],
+    "workflowCode.projectInfo.platformSupport.platforms"
+  );
+  if (platforms.length === 0) {
+    throw new Error("workflowCode.projectInfo.platformSupport.platforms must contain at least one platform.");
+  }
+  return { mode: "specific", platforms };
+}
+function normalizeDataStorage(value) {
+  if (value === void 0 || value === null) return null;
+  if (!isRecord(value)) {
+    throw new Error("workflowCode.projectInfo.dataStorage must be an object.");
+  }
+  const mode = value["mode"];
+  if (typeof mode !== "string" || !WORKFLOW_PROJECT_DATA_STORAGE_MODES.includes(
+    mode
+  )) {
+    throw new Error(
+      'workflowCode.projectInfo.dataStorage.mode must be "local", "server", or "both".'
+    );
+  }
+  return { mode };
+}
+function normalizeRelatedProjects(value) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) {
+    throw new Error("workflowCode.projectInfo.relatedProjects must be an array.");
+  }
+  if (value.length > WORKFLOW_RELATED_PROJECT_LIMIT) {
+    throw new Error(
+      `workflowCode.projectInfo.relatedProjects supports at most ${WORKFLOW_RELATED_PROJECT_LIMIT} items.`
+    );
+  }
+  const aliases = /* @__PURE__ */ new Set();
+  const projectIds = /* @__PURE__ */ new Set();
+  return value.map((item, index) => {
+    const field = `workflowCode.projectInfo.relatedProjects[${index}]`;
+    if (!isRecord(item)) throw new Error(`${field} must be an object.`);
+    const supportedFields = /* @__PURE__ */ new Set(["alias", "projectId", "grantToRelatedProject"]);
+    if (Object.keys(item).some((key) => !supportedFields.has(key))) {
+      throw new Error(`${field} contains unsupported fields.`);
+    }
+    const alias = readRelatedProjectString(item["alias"], `${field}.alias`);
+    if (!WORKFLOW_RELATED_PROJECT_ALIAS_PATTERN.test(alias)) {
+      throw new Error(`${field}.alias is invalid.`);
+    }
+    if (aliases.has(alias)) {
+      throw new Error(`workflowCode.projectInfo.relatedProjects contains duplicate alias "${alias}".`);
+    }
+    aliases.add(alias);
+    const projectId = readRelatedProjectString(item["projectId"], `${field}.projectId`);
+    if (!WORKFLOW_PROJECT_UUID_PATTERN.test(projectId)) {
+      throw new Error(`${field}.projectId must be a UUID.`);
+    }
+    const normalizedProjectId = projectId.toLowerCase();
+    if (projectIds.has(normalizedProjectId)) {
+      throw new Error(`workflowCode.projectInfo.relatedProjects contains duplicate projectId "${projectId}".`);
+    }
+    projectIds.add(normalizedProjectId);
+    return {
+      alias,
+      projectId,
+      grantToRelatedProject: normalizeRelatedProjectGrant(
+        item["grantToRelatedProject"],
+        `${field}.grantToRelatedProject`
+      )
+    };
+  });
+}
+function normalizeRelatedProjectGrant(value, field) {
+  if (!isRecord(value)) throw new Error(`${field} must be an object.`);
+  if (Object.keys(value).some((key) => key !== "read" && key !== "write")) {
+    throw new Error(`${field} contains unsupported fields.`);
+  }
+  return {
+    read: normalizeProjectKVAccessRule(value["read"], `${field}.read`),
+    write: normalizeProjectKVAccessRule(value["write"], `${field}.write`)
+  };
+}
+function normalizeProjectKVAccessRule(value, field) {
+  if (!isRecord(value)) throw new Error(`${field} must be an object.`);
+  const mode = value["mode"];
+  if (mode === "none" || mode === "all") {
+    if (Object.keys(value).some((key) => key !== "mode")) {
+      throw new Error(`${field} contains unsupported fields.`);
+    }
+    return { mode };
+  }
+  if (mode !== "prefixes") {
+    throw new Error(`${field}.mode must be "none", "all", or "prefixes".`);
+  }
+  if (Object.keys(value).some((key) => key !== "mode" && key !== "prefixes")) {
+    throw new Error(`${field} contains unsupported fields.`);
+  }
+  const rawPrefixes = value["prefixes"];
+  if (!Array.isArray(rawPrefixes) || rawPrefixes.length === 0 || rawPrefixes.length > WORKFLOW_RELATED_PROJECT_PREFIX_LIMIT) {
+    throw new Error(
+      `${field}.prefixes must contain 1 to ${WORKFLOW_RELATED_PROJECT_PREFIX_LIMIT} items.`
+    );
+  }
+  const prefixes = rawPrefixes.map((prefix, index) => {
+    const normalized = readRelatedProjectString(prefix, `${field}.prefixes[${index}]`);
+    if (normalized.length > WORKFLOW_RELATED_PROJECT_KEY_LIMIT || normalized.includes("\0")) {
+      throw new Error(`${field}.prefixes[${index}] is invalid.`);
+    }
+    return normalized;
+  });
+  if (new Set(prefixes).size !== prefixes.length) {
+    throw new Error(`${field}.prefixes contains duplicates.`);
+  }
+  return { mode: "prefixes", prefixes };
+}
+function readRelatedProjectString(value, field) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`${field} must be a non-empty string.`);
+  }
+  return value.trim();
+}
+function normalizeIds(value, field) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) throw new Error(`${field} must be an array.`);
+  const values = value.map((item, index) => {
+    if (typeof item !== "string" || !PROJECT_INFO_ID_PATTERN.test(item.trim())) {
+      throw new Error(`${field}[${index}] must be a lowercase identifier.`);
+    }
+    return item.trim();
+  });
+  return uniqueStrings(values, true);
+}
+function uniqueStrings(values, caseSensitive) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const rawValue of values) {
+    const value = rawValue.trim();
+    if (value === "") continue;
+    const key = caseSensitive ? value : value.toLocaleLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(value);
+  }
+  return result;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export {
+  isWorkflowUuid,
+  assertWorkflowUuid,
+  WORKFLOW_RELATED_PROJECT_ALIAS_PATTERN,
+  readWorkflowProjectInfo,
+  resolveWorkflowRelatedProjectAccess,
+  isWorkflowProjectDataStorageLocationAllowed
+};

package/dist/chunk-DPFPLLLT.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import {
+  i18n,
+  initI18n,
+  isSupportedLocale,
+  normalizeLocale
+} from "./chunk-TCYG46PO.js";
+
+// src/locale.ts
+import { WORKFLOW_RUNTIME_LOCALE_ENV } from "workflow-code";
+function prepareCliInvocation(argv) {
+  initI18n({ preference: resolveSystemLocalePreference() });
+  const extracted = extractLocaleOption(argv);
+  const requestedLocale = extracted.locale ?? readEnvironmentLocale();
+  if (requestedLocale !== void 0) {
+    if (!isSupportedLocale(requestedLocale)) {
+      throw new Error(i18n.t("invalidLocale", {
+        ns: "cli",
+        value: requestedLocale
+      }));
+    }
+    initI18n({ preference: requestedLocale });
+  }
+  const locale = normalizeLocale(i18n.language);
+  process.env[WORKFLOW_RUNTIME_LOCALE_ENV] = locale;
+  return {
+    argv: extracted.argv,
+    locale
+  };
+}
+function extractLocaleOption(argv) {
+  const filtered = [];
+  let locale;
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--") {
+      filtered.push(...argv.slice(index));
+      break;
+    }
+    if (arg === "--locale" || arg.startsWith("--locale=")) {
+      if (locale !== void 0) {
+        throw new Error(i18n.t("duplicateLocale", { ns: "cli" }));
+      }
+      const value = arg === "--locale" ? argv[++index] : arg.slice("--locale=".length);
+      if (value === void 0 || value.trim() === "") {
+        throw new Error(i18n.t("missingOptionValue", { ns: "cli", name: "--locale" }));
+      }
+      locale = value;
+      continue;
+    }
+    filtered.push(arg);
+  }
+  return { argv: filtered, locale };
+}
+function readEnvironmentLocale() {
+  const value = process.env.WORKFLOW_CODE_LOCALE?.trim();
+  return value === "" ? void 0 : value;
+}
+function resolveSystemLocalePreference() {
+  const systemLocale = process.env.LC_ALL ?? process.env.LANG;
+  return systemLocale?.trim() ? normalizeLocale(systemLocale) : "system";
+}
+
+export {
+  prepareCliInvocation
+};

package/dist/chunk-HZABRDJK.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+import {
+  WORKFLOW_RELATED_PROJECT_ALIAS_PATTERN,
+  assertWorkflowUuid,
+  isWorkflowProjectDataStorageLocationAllowed,
+  readWorkflowProjectInfo,
+  resolveWorkflowRelatedProjectAccess
+} from "./chunk-27OW6OJ3.js";
+
+// src/related-projects.ts
+import os from "os";
+import path from "path";
+import { readFileSync, realpathSync, statSync } from "fs";
+import * as workflowCode from "workflow-code";
+var targetStorageApi = workflowCode;
+function parseCliRelatedProjectSpec(value) {
+  const separatorIndex = value.indexOf("=");
+  if (separatorIndex <= 0 || separatorIndex === value.length - 1) {
+    throw new Error('--related-project must use the form "alias=/absolute/project/path".');
+  }
+  const alias = value.slice(0, separatorIndex).trim();
+  const projectDir = value.slice(separatorIndex + 1).trim();
+  if (!WORKFLOW_RELATED_PROJECT_ALIAS_PATTERN.test(alias)) {
+    throw new Error(`Invalid related project alias "${alias}".`);
+  }
+  if (!path.isAbsolute(projectDir)) {
+    throw new Error(`Related project "${alias}" must use an absolute directory path.`);
+  }
+  return { alias, projectDir };
+}
+function createCliRelatedProjectRuntime(options) {
+  if (options.relatedProjects.length === 0) return {};
+  const consumer = readProjectSnapshot(options.consumerProjectDir, "Current project");
+  const configuredByAlias = /* @__PURE__ */ new Map();
+  const configuredProjectIds = /* @__PURE__ */ new Set();
+  const configuredPaths = /* @__PURE__ */ new Set();
+  for (const spec of options.relatedProjects) {
+    if (configuredByAlias.has(spec.alias)) {
+      throw new Error(`Related project alias "${spec.alias}" was specified more than once.`);
+    }
+    const target = readProjectSnapshot(spec.projectDir, `Related project "${spec.alias}"`);
+    const targetProjectId = target.projectId.toLowerCase();
+    if (configuredProjectIds.has(targetProjectId)) {
+      throw new Error(`Related project UUID "${target.projectId}" was specified more than once.`);
+    }
+    if (configuredPaths.has(target.projectDir)) {
+      throw new Error(`Related project directory "${target.projectDir}" was specified more than once.`);
+    }
+    assertConfirmedRelationship(consumer, target, spec.alias);
+    configuredByAlias.set(spec.alias, target);
+    configuredProjectIds.add(targetProjectId);
+    configuredPaths.add(target.projectDir);
+  }
+  const localKvStore = targetStorageApi.createLocalWorkflowKVStore({
+    rootDir: options.localKvStoreDir ?? path.join(os.tmpdir(), "workflow-code-kv"),
+    storageKind: "kv"
+  });
+  return {
+    localKvStore,
+    localResolver: createResolver("local", localKvStore),
+    serverResolver: createResolver("server")
+  };
+  function createResolver(location, fixedStore) {
+    return {
+      resolve(alias) {
+        const configured = configuredByAlias.get(alias);
+        if (configured === void 0) return void 0;
+        const currentConsumer = readProjectSnapshot(consumer.projectDir, "Current project");
+        const currentTarget = readProjectSnapshot(
+          configured.projectDir,
+          `Related project "${alias}"`
+        );
+        if (currentTarget.projectId.toLowerCase() !== configured.projectId.toLowerCase()) {
+          return void 0;
+        }
+        const access = resolveWorkflowRelatedProjectAccess({
+          consumerProjectId: currentConsumer.projectId,
+          consumerProjectInfo: currentConsumer.projectInfo,
+          targetProjectId: currentTarget.projectId,
+          targetProjectInfo: currentTarget.projectInfo,
+          alias
+        });
+        if (access === void 0 || !isWorkflowProjectDataStorageLocationAllowed(currentTarget.projectInfo, location)) {
+          return void 0;
+        }
+        const createRemoteStore = targetStorageApi.createRemoteWorkflowRelatedProjectKVStoreFromEnv;
+        if (fixedStore === void 0 && typeof createRemoteStore !== "function") {
+          throw new Error("Installed workflow-code does not support related project storage.");
+        }
+        const store = fixedStore ?? createRemoteStore({
+          consumerProjectId: currentConsumer.projectId,
+          targetProjectId: currentTarget.projectId,
+          alias,
+          env: options.env
+        });
+        if (store === void 0) return void 0;
+        return {
+          projectId: currentTarget.projectId,
+          grant: access.grant,
+          kv: targetStorageApi.createWorkflowKVContext({
+            store,
+            projectId: currentTarget.projectId,
+            source: {
+              projectId: currentConsumer.projectId,
+              runId: options.runId,
+              conversationId: options.conversationId
+            }
+          })
+        };
+      }
+    };
+  }
+}
+function assertConfirmedRelationship(consumer, target, alias) {
+  const consumerRelation = consumer.projectInfo.relatedProjects.find(
+    (relation) => relation.alias === alias
+  );
+  if (consumerRelation?.projectId.toLowerCase() !== target.projectId.toLowerCase()) {
+    throw new Error(
+      `Current project does not declare related project "${alias}" with UUID "${target.projectId}".`
+    );
+  }
+  if (resolveWorkflowRelatedProjectAccess({
+    consumerProjectId: consumer.projectId,
+    consumerProjectInfo: consumer.projectInfo,
+    targetProjectId: target.projectId,
+    targetProjectInfo: target.projectInfo,
+    alias
+  }) === void 0) {
+    throw new Error(`Related project "${alias}" is not confirmed by both project manifests.`);
+  }
+}
+function readProjectSnapshot(projectDir, label) {
+  let canonicalDir;
+  try {
+    canonicalDir = realpathSync(projectDir);
+    if (!statSync(canonicalDir).isDirectory()) {
+      throw new Error("not a directory");
+    }
+  } catch (error) {
+    throw new Error(`${label} directory is unavailable: ${projectDir}`, { cause: error });
+  }
+  const packagePath = path.join(canonicalDir, "package.json");
+  let packageJson;
+  try {
+    packageJson = JSON.parse(readFileSync(packagePath, "utf8"));
+  } catch (error) {
+    throw new Error(`${label} must contain a readable package.json: ${canonicalDir}`, {
+      cause: error
+    });
+  }
+  if (!isRecord(packageJson) || typeof packageJson["id"] !== "string") {
+    throw new Error(`${label} package.json.id must be a UUID.`);
+  }
+  const projectId = assertWorkflowUuid(packageJson["id"], `${label} package.json.id`);
+  const projectInfo = readWorkflowProjectInfo(packageJson);
+  if (projectInfo.dataStorage === null) {
+    throw new Error(`${label} must declare workflowCode.projectInfo.dataStorage.mode.`);
+  }
+  return { projectDir: canonicalDir, projectId, projectInfo };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export {
+  parseCliRelatedProjectSpec,
+  createCliRelatedProjectRuntime
+};

package/dist/chunk-NSPRIPOP.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __export,
+  __toESM
+};

package/dist/chunk-OLNPMIEF.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+// src/openai-runner-stdio.ts
+function isolateOpenAIRunnerStdout(stdout = process.stdout, stderr = process.stderr) {
+  const protocolWrite = stdout.write.bind(stdout);
+  stdout.write = (...args) => stderr.write(...args);
+  return (line) => {
+    protocolWrite(line);
+  };
+}
+
+export {
+  isolateOpenAIRunnerStdout
+};