@workflow-code/cli 0.1.0 → 0.1.2

package/dist/chunk-FYS2JH42.js

@@ -0,0 +1,31 @@
+#!/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 __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,
+  __toESM
+};

package/dist/index.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
+import "./chunk-FYS2JH42.js";
 
 // 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");
+    const workspaceCli = await import("./workspace-QUP6RU65.js");
     await workspaceCli.main(argv.slice(1));
     return typeof process.exitCode === "number" ? process.exitCode : 0;
   }
@@ -16,7 +17,7 @@ async function main(argv = process.argv.slice(2)) {
   }
   const { register } = await import("tsx/esm/api");
   register();
-  const localCli = await import("./local-XBULJ25O.js");
+  const localCli = await import("./local-6VUUVT3C.js");
   return localCli.main(argv);
 }
 function formatHelp() {

package/dist/{local-XBULJ25O.js → local-6VUUVT3C.js}

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import "./chunk-FYS2JH42.js";
 
 // src/local.ts
 import path from "path";

package/dist/{workspace-WJOCEGA6.js → workspace-QUP6RU65.js}

@@ -1,11 +1,474 @@
 #!/usr/bin/env node
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-FYS2JH42.js";
+
+// ../../node_modules/.pnpm/ignore@7.0.6/node_modules/ignore/index.js
+var require_ignore = __commonJS({
+  "../../node_modules/.pnpm/ignore@7.0.6/node_modules/ignore/index.js"(exports, module) {
+    "use strict";
+    function makeArray(subject) {
+      return Array.isArray(subject) ? subject : [subject];
+    }
+    var UNDEFINED = void 0;
+    var EMPTY = "";
+    var SPACE = " ";
+    var ESCAPE = "\\";
+    var REGEX_TEST_BLANK_LINE = /^\s+$/;
+    var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+    var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+    var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+    var REGEX_SPLITALL_CRLF = /\r?\n/g;
+    var REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
+    var REGEX_TEST_TRAILING_SLASH = /\/$/;
+    var SLASH = "/";
+    var TMP_KEY_IGNORE = "node-ignore";
+    if (typeof Symbol !== "undefined") {
+      TMP_KEY_IGNORE = /* @__PURE__ */ Symbol.for("node-ignore");
+    }
+    var KEY_IGNORE = TMP_KEY_IGNORE;
+    var define = (object, key, value) => {
+      Object.defineProperty(object, key, { value });
+      return value;
+    };
+    var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+    var RETURN_FALSE = () => false;
+    var sanitizeRange = (range) => range.replace(
+      REGEX_REGEXP_RANGE,
+      (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY
+    );
+    var negateRange = (range) => range.startsWith("!") || range.startsWith("\\^") ? `^${range.slice(range[0] === "!" ? 1 : 2)}` : range;
+    var cleanRangeBackSlash = (slashes) => {
+      const { length } = slashes;
+      return slashes.slice(0, length - length % 2);
+    };
+    var REPLACERS = [
+      [
+        // Remove BOM
+        // TODO:
+        // Other similar zero-width characters?
+        /^\uFEFF/,
+        () => EMPTY
+      ],
+      // > Trailing spaces are ignored unless they are quoted with backslash ("\")
+      [
+        // (a\ ) -> (a )
+        // (a  ) -> (a)
+        // (a ) -> (a)
+        // (a \ ) -> (a  )
+        /((?:\\\\)*?)(\\?\s+)$/,
+        (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)
+      ],
+      // Replace (\ ) with ' '
+      // (\ ) -> ' '
+      // (\\ ) -> '\\ '
+      // (\\\ ) -> '\\ '
+      [
+        /(\\+?)\s/g,
+        (_, m1) => {
+          const { length } = m1;
+          return m1.slice(0, length - length % 2) + SPACE;
+        }
+      ],
+      // Escape metacharacters
+      // which is written down by users but means special for regular expressions.
+      // > There are 12 characters with special meanings:
+      // > - the backslash \,
+      // > - the caret ^,
+      // > - the dollar sign $,
+      // > - the period or dot .,
+      // > - the vertical bar or pipe symbol |,
+      // > - the question mark ?,
+      // > - the asterisk or star *,
+      // > - the plus sign +,
+      // > - the opening parenthesis (,
+      // > - the closing parenthesis ),
+      // > - and the opening square bracket [,
+      // > - the opening curly brace {,
+      // > These special characters are often called "metacharacters".
+      [
+        /[\\$.|*+(){^]/g,
+        (match) => `\\${match}`
+      ],
+      [
+        // > a question mark (?) matches a single character
+        /(?!\\)\?/g,
+        () => "[^/]"
+      ],
+      // leading slash
+      [
+        // > A leading slash matches the beginning of the pathname.
+        // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+        // A leading slash matches the beginning of the pathname
+        /^\//,
+        () => "^"
+      ],
+      // replace special metacharacter slash after the leading slash
+      [
+        /\//g,
+        () => "\\/"
+      ],
+      [
+        // > A leading "**" followed by a slash means match in all directories.
+        // > For example, "**/foo" matches file or directory "foo" anywhere,
+        // > the same as pattern "foo".
+        // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
+        // >   under directory "foo".
+        // Notice that the '*'s have been replaced as '\\*'
+        /^\^*(?:\\\*\\\*\\\/)+/,
+        // '**/foo' <-> 'foo'
+        () => "^(?:.*\\/)?"
+      ],
+      // starting
+      [
+        // there will be no leading '/'
+        //   (which has been replaced by section "leading slash")
+        // If starts with '**', adding a '^' to the regular expression also works
+        /^(?=[^^])/,
+        function startingReplacer() {
+          return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+        }
+      ],
+      // two globstars
+      [
+        // Use lookahead assertions so that we could match more than one `'/**'`
+        /\\\/\\\*\\\*(?=\\\/|$)/g,
+        // Zero, one or several directories
+        // should not use '*', or it will be replaced by the next replacer
+        // Check if it is not the last `'/**'`
+        (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+      ],
+      // normal intermediate wildcards
+      [
+        // Never replace escaped '*'
+        // ignore rule '\*' will match the path '*'
+        // 'abc.*/' -> go
+        // 'abc.*'  -> skip this rule,
+        //    coz trailing single wildcard will be handed by [trailing wildcard]
+        /(^|[^\\]+)(\\\*)+(?=.+)/g,
+        // '*.js' matches '.js'
+        // '*.js' doesn't match 'abc'
+        (_, p1, p2) => {
+          const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+          return p1 + unescaped;
+        }
+      ],
+      [
+        // unescape, revert step 3 except for back slash
+        // For example, if a user escape a '\\*',
+        // after step 3, the result will be '\\\\\\*'
+        /\\\\\\(?=[$.|*+(){^])/g,
+        () => ESCAPE
+      ],
+      [
+        // '\\\\' -> '\\'
+        /\\\\/g,
+        () => ESCAPE
+      ],
+      [
+        // > The range notation, e.g. [a-zA-Z],
+        // > can be used to match one of the characters in a range.
+        // `\` is escaped by step 3
+        /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+        (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${negateRange(sanitizeRange(range))}${endEscape}]` : "[]" : "[]"
+      ],
+      // ending
+      [
+        // 'js' will not match 'js.'
+        // 'ab' will not match 'abc'
+        /(?:[^*])$/,
+        // WTF!
+        // https://git-scm.com/docs/gitignore
+        // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
+        // which re-fixes #24, #38
+        // > If there is a separator at the end of the pattern then the pattern
+        // > will only match directories, otherwise the pattern can match both
+        // > files and directories.
+        // 'js*' will not match 'a.js'
+        // 'js/' will not match 'a.js'
+        // 'js' will match 'a.js' and 'a.js/'
+        (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+      ]
+    ];
+    var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
+    var MODE_IGNORE = "regex";
+    var MODE_CHECK_IGNORE = "checkRegex";
+    var UNDERSCORE = "_";
+    var TRAILING_WILD_CARD_REPLACERS = {
+      [MODE_IGNORE](_, p1) {
+        const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+        return `${prefix}(?=$|\\/$)`;
+      },
+      [MODE_CHECK_IGNORE](_, p1) {
+        const prefix = p1 ? `${p1}[^/]*` : "[^/]*";
+        return `${prefix}(?=$|\\/$)`;
+      }
+    };
+    var makeRegexPrefix = (pattern) => REPLACERS.reduce(
+      (prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)),
+      pattern
+    );
+    var isString = (subject) => typeof subject === "string";
+    var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+    var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
+    var IgnoreRule = class {
+      constructor(pattern, mark, body, ignoreCase, negative, prefix) {
+        this.pattern = pattern;
+        this.mark = mark;
+        this.negative = negative;
+        define(this, "body", body);
+        define(this, "ignoreCase", ignoreCase);
+        define(this, "regexPrefix", prefix);
+      }
+      get regex() {
+        const key = UNDERSCORE + MODE_IGNORE;
+        if (this[key]) {
+          return this[key];
+        }
+        return this._make(MODE_IGNORE, key);
+      }
+      get checkRegex() {
+        const key = UNDERSCORE + MODE_CHECK_IGNORE;
+        if (this[key]) {
+          return this[key];
+        }
+        return this._make(MODE_CHECK_IGNORE, key);
+      }
+      _make(mode, key) {
+        const str = this.regexPrefix.replace(
+          REGEX_REPLACE_TRAILING_WILDCARD,
+          // It does not need to bind pattern
+          TRAILING_WILD_CARD_REPLACERS[mode]
+        );
+        const regex = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
+        return define(this, key, regex);
+      }
+    };
+    var createRule = ({
+      pattern,
+      mark
+    }, ignoreCase) => {
+      let negative = false;
+      let body = pattern;
+      if (body.indexOf("!") === 0) {
+        negative = true;
+        body = body.substr(1);
+      }
+      body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+      const regexPrefix = makeRegexPrefix(body);
+      return new IgnoreRule(
+        pattern,
+        mark,
+        body,
+        ignoreCase,
+        negative,
+        regexPrefix
+      );
+    };
+    var RuleManager = class {
+      constructor(ignoreCase) {
+        this._ignoreCase = ignoreCase;
+        this._rules = [];
+      }
+      _add(pattern) {
+        if (pattern && pattern[KEY_IGNORE]) {
+          this._rules = this._rules.concat(pattern._rules._rules);
+          this._added = true;
+          return;
+        }
+        if (isString(pattern)) {
+          pattern = {
+            pattern
+          };
+        }
+        if (checkPattern(pattern.pattern)) {
+          const rule = createRule(pattern, this._ignoreCase);
+          this._added = true;
+          this._rules.push(rule);
+        }
+      }
+      // @param {Array<string> | string | Ignore} pattern
+      add(pattern) {
+        this._added = false;
+        makeArray(
+          isString(pattern) ? splitPattern(pattern) : pattern
+        ).forEach(this._add, this);
+        return this._added;
+      }
+      // Test one single path without recursively checking parent directories
+      //
+      // - checkUnignored `boolean` whether should check if the path is unignored,
+      //   setting `checkUnignored` to `false` could reduce additional
+      //   path matching.
+      // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
+      // @returns {TestResult} true if a file is ignored
+      test(path5, checkUnignored, mode) {
+        let ignored = false;
+        let unignored = false;
+        let matchedRule;
+        this._rules.forEach((rule) => {
+          const { negative } = rule;
+          if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+            return;
+          }
+          const matched = rule[mode].test(path5);
+          if (!matched) {
+            return;
+          }
+          ignored = !negative;
+          unignored = negative;
+          matchedRule = negative ? UNDEFINED : rule;
+        });
+        const ret = {
+          ignored,
+          unignored
+        };
+        if (matchedRule) {
+          ret.rule = matchedRule;
+        }
+        return ret;
+      }
+    };
+    var throwError = (message, Ctor) => {
+      throw new Ctor(message);
+    };
+    var checkPath = (path5, originalPath, doThrow) => {
+      if (!isString(path5)) {
+        return doThrow(
+          `path must be a string, but got \`${originalPath}\``,
+          TypeError
+        );
+      }
+      if (!path5) {
+        return doThrow(`path must not be empty`, TypeError);
+      }
+      if (checkPath.isNotRelative(path5)) {
+        const r = "`path.relative()`d";
+        return doThrow(
+          `path should be a ${r} string, but got "${originalPath}"`,
+          RangeError
+        );
+      }
+      return true;
+    };
+    var isNotRelative = (path5) => REGEX_TEST_INVALID_PATH.test(path5);
+    checkPath.isNotRelative = isNotRelative;
+    checkPath.convert = (p) => p;
+    var Ignore = class {
+      constructor({
+        ignorecase = true,
+        ignoreCase = ignorecase,
+        allowRelativePaths = false
+      } = {}) {
+        define(this, KEY_IGNORE, true);
+        this._rules = new RuleManager(ignoreCase);
+        this._strictPathCheck = !allowRelativePaths;
+        this._initCache();
+      }
+      _initCache() {
+        this._ignoreCache = /* @__PURE__ */ Object.create(null);
+        this._testCache = /* @__PURE__ */ Object.create(null);
+      }
+      add(pattern) {
+        if (this._rules.add(pattern)) {
+          this._initCache();
+        }
+        return this;
+      }
+      // legacy
+      addPattern(pattern) {
+        return this.add(pattern);
+      }
+      // @returns {TestResult}
+      _test(originalPath, cache, checkUnignored, slices) {
+        const path5 = originalPath && checkPath.convert(originalPath);
+        checkPath(
+          path5,
+          originalPath,
+          this._strictPathCheck ? throwError : RETURN_FALSE
+        );
+        return this._t(path5, cache, checkUnignored, slices);
+      }
+      checkIgnore(path5) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path5)) {
+          return this.test(path5);
+        }
+        const slices = path5.split(SLASH).filter(Boolean);
+        slices.pop();
+        if (slices.length) {
+          const parent = this._t(
+            slices.join(SLASH) + SLASH,
+            this._testCache,
+            true,
+            slices
+          );
+          if (parent.ignored) {
+            return parent;
+          }
+        }
+        return this._rules.test(path5, false, MODE_CHECK_IGNORE);
+      }
+      _t(path5, cache, checkUnignored, slices) {
+        if (path5 in cache) {
+          return cache[path5];
+        }
+        if (!slices) {
+          slices = path5.split(SLASH).filter(Boolean);
+        }
+        slices.pop();
+        if (!slices.length) {
+          return cache[path5] = this._rules.test(path5, checkUnignored, MODE_IGNORE);
+        }
+        const parent = this._t(
+          slices.join(SLASH) + SLASH,
+          cache,
+          checkUnignored,
+          slices
+        );
+        return cache[path5] = parent.ignored ? parent : this._rules.test(path5, checkUnignored, MODE_IGNORE);
+      }
+      ignores(path5) {
+        return this._test(path5, this._ignoreCache, false).ignored;
+      }
+      createFilter() {
+        return (path5) => !this.ignores(path5);
+      }
+      filter(paths) {
+        return makeArray(paths).filter(this.createFilter());
+      }
+      // @returns {TestResult}
+      test(path5) {
+        return this._test(path5, this._testCache, true);
+      }
+    };
+    var factory = (options) => new Ignore(options);
+    var isPathValid = (path5) => checkPath(path5 && checkPath.convert(path5), path5, RETURN_FALSE);
+    var setupWindows = () => {
+      const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+      checkPath.convert = makePosix;
+      const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+      checkPath.isNotRelative = (path5) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path5) || isNotRelative(path5);
+    };
+    if (
+      // Detect `process` so that it can run in browsers.
+      typeof process !== "undefined" && process.platform === "win32"
+    ) {
+      setupWindows();
+    }
+    module.exports = factory;
+    factory.default = factory;
+    module.exports.isPathValid = isPathValid;
+    define(module.exports, /* @__PURE__ */ Symbol.for("setupWindows"), setupWindows);
+  }
+});
 
 // src/workspace.ts
 import { spawn } from "child_process";
 import { randomUUID } from "crypto";
 import { existsSync as existsSync2 } from "fs";
-import { cp, mkdir as mkdir2, readFile as readFile2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
-import path3 from "path";
+import { mkdir as mkdir3, readFile as readFile3, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import path4 from "path";
 import { fileURLToPath, pathToFileURL } from "url";
 
 // ../../shared/auth-config/index.ts
@@ -120,12 +583,267 @@ function isWorkflowUuid(value) {
   return WORKFLOW_UUID_PATTERN.test(value.trim());
 }
 
+// ../../shared/project-upload/node.ts
+import { copyFile, lstat, mkdir, readFile, readdir } from "fs/promises";
+import path2 from "path";
+
+// ../../shared/project-upload/index.ts
+var import_ignore = __toESM(require_ignore(), 1);
+
+// ../../shared/kanban-project/index.ts
+var KANBAN_MANIFEST_FILE = "kanban.json";
+var KANBAN_ENTRY_FILE = "index.html";
+var KANBAN_ARTIFACT_DIR = ".";
+function readPackageProjectType(value) {
+  if (!isRecord2(value)) return void 0;
+  const workflowCode = value["workflowCode"];
+  if (!isRecord2(workflowCode)) return void 0;
+  return workflowCode["projectType"] === "kanban" ? "kanban" : void 0;
+}
+function readKanbanArtifactConfig(value) {
+  if (!isRecord2(value)) {
+    throw new Error("package.json root must be an object.");
+  }
+  const workflowCode = value["workflowCode"];
+  if (!isRecord2(workflowCode)) {
+    throw new Error("package.json workflowCode must be an object for a Kanban project.");
+  }
+  const rawConfig = workflowCode["kanban"];
+  if (rawConfig !== void 0 && !isRecord2(rawConfig)) {
+    throw new Error("package.json workflowCode.kanban must be an object.");
+  }
+  return {
+    artifactDir: readKanbanRelativePath(
+      rawConfig?.["artifactDir"],
+      "workflowCode.kanban.artifactDir",
+      KANBAN_ARTIFACT_DIR,
+      true
+    ),
+    entry: readKanbanRelativePath(
+      rawConfig?.["entry"],
+      "workflowCode.kanban.entry",
+      KANBAN_ENTRY_FILE,
+      false
+    )
+  };
+}
+function createKanbanArtifactEntryPath(config) {
+  return config.artifactDir === KANBAN_ARTIFACT_DIR ? config.entry : `${config.artifactDir}/${config.entry}`;
+}
+function readKanbanRelativePath(value, field, fallback, allowDot) {
+  const raw = value === void 0 ? fallback : value;
+  if (typeof raw !== "string" || raw.trim() === "") {
+    throw new Error(`package.json ${field} must be a non-empty string.`);
+  }
+  const normalized = raw.trim().replaceAll("\\", "/").replace(/\/+$/, "");
+  if (allowDot && normalized === ".") return normalized;
+  if (normalized === "" || normalized === "." || normalized.startsWith("/") || normalized.startsWith("//") || /^[a-zA-Z]:/.test(normalized) || normalized.includes("\0") || normalized.split("/").some((part) => part === "" || part === "." || part === "..")) {
+    throw new Error(`package.json ${field} must be a safe project-relative path.`);
+  }
+  const reservedDirectory = normalized.split("/").find((part) => [".git", ".hg", ".svn", "node_modules"].includes(part.toLowerCase()));
+  if (reservedDirectory !== void 0) {
+    throw new Error(
+      `package.json ${field} must not use reserved directory ${JSON.stringify(reservedDirectory)}.`
+    );
+  }
+  if (!allowDot && !/\.html?$/i.test(normalized)) {
+    throw new Error(`package.json ${field} must point to an HTML file.`);
+  }
+  return normalized;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// ../../shared/project-upload/index.ts
+var WORKFLOW_IGNORE_FILE = ".workflowignore";
+function hasWorkflowIgnoreRules(content) {
+  if (content === void 0) return false;
+  return content.split(/\r?\n/).some((line) => {
+    const trimmed = line.trim();
+    return trimmed !== "" && !trimmed.startsWith("#");
+  });
+}
+function resolveWorkflowUploadRequiredPaths(packageJson, availablePaths) {
+  const normalizedAvailablePaths = new Set(
+    Array.from(availablePaths, (filePath) => normalizeWorkflowUploadPath(filePath))
+  );
+  if (readPackageProjectType(packageJson) === "kanban") {
+    const artifact = readKanbanArtifactConfig(packageJson);
+    return [
+      "package.json",
+      createKanbanArtifactEntryPath(artifact),
+      ...normalizedAvailablePaths.has(KANBAN_MANIFEST_FILE) ? [KANBAN_MANIFEST_FILE] : []
+    ];
+  }
+  return ["package.json", "index.ts"];
+}
+function createWorkflowUploadMatcher(content) {
+  const ruleLines = content === void 0 ? [] : content.split(/\r?\n/);
+  const matcher = (0, import_ignore.default)().add(ruleLines);
+  return {
+    ignores(relativePath, options) {
+      const normalized = normalizeWorkflowUploadPath(relativePath, options);
+      return normalized === WORKFLOW_IGNORE_FILE ? false : matcher.ignores(normalized);
+    },
+    explain(relativePath, options) {
+      const normalized = normalizeWorkflowUploadPath(relativePath, options);
+      if (normalized === WORKFLOW_IGNORE_FILE) return void 0;
+      return findEffectiveWorkflowIgnoreRule(normalized, ruleLines);
+    },
+    assertRequiredPaths(relativePaths) {
+      for (const relativePath of relativePaths) {
+        const normalized = normalizeWorkflowUploadPath(relativePath);
+        if (!matcher.ignores(normalized)) continue;
+        const rule = findEffectiveWorkflowIgnoreRule(normalized, ruleLines);
+        const suffix = rule === void 0 ? "" : ` by rule ${JSON.stringify(rule)}`;
+        throw new Error(
+          `Required upload path ${JSON.stringify(normalized)} is excluded by ${WORKFLOW_IGNORE_FILE}${suffix}.`
+        );
+      }
+    }
+  };
+}
+function normalizeWorkflowUploadPath(relativePath, options = {}) {
+  const normalized = relativePath.replaceAll("\\", "/").replace(/^\.\/+/, "");
+  const withoutTrailingSlash = normalized.replace(/\/+$/, "");
+  if (withoutTrailingSlash === "" || withoutTrailingSlash.startsWith("/") || /^[a-zA-Z]:/.test(withoutTrailingSlash) || withoutTrailingSlash.includes("\0") || withoutTrailingSlash.split("/").some((part) => part === "" || part === "." || part === "..")) {
+    throw new Error(`Invalid workflow upload path ${JSON.stringify(relativePath)}.`);
+  }
+  return options.directory === true ? `${withoutTrailingSlash}/` : withoutTrailingSlash;
+}
+function createWorkflowUploadPortablePathKey(relativePath) {
+  return normalizeWorkflowUploadPath(relativePath).normalize("NFC").toLowerCase();
+}
+function findEffectiveWorkflowIgnoreRule(normalizedPath, ruleLines) {
+  const matcher = (0, import_ignore.default)();
+  let ignored = false;
+  let effectiveRule;
+  for (const ruleLine of ruleLines) {
+    matcher.add(ruleLine);
+    const nextIgnored = matcher.ignores(normalizedPath);
+    if (nextIgnored !== ignored) {
+      ignored = nextIgnored;
+      effectiveRule = ruleLine;
+    }
+  }
+  return ignored ? effectiveRule : void 0;
+}
+
+// ../../shared/project-upload/node.ts
+async function createWorkflowUploadPlan(rootDir) {
+  const projectRoot = path2.resolve(rootDir);
+  const workflowIgnorePath = path2.join(projectRoot, WORKFLOW_IGNORE_FILE);
+  const workflowIgnoreStat = await lstat(workflowIgnorePath).catch(() => void 0);
+  if (workflowIgnoreStat?.isSymbolicLink()) {
+    throw new Error(`${WORKFLOW_IGNORE_FILE} must be a regular file.`);
+  }
+  const workflowIgnorePresent = workflowIgnoreStat?.isFile() === true;
+  if (workflowIgnoreStat !== void 0 && !workflowIgnorePresent) {
+    throw new Error(`${WORKFLOW_IGNORE_FILE} must be a regular file.`);
+  }
+  const workflowIgnoreContent = workflowIgnorePresent ? await readWorkflowUploadUtf8File(workflowIgnorePath, WORKFLOW_IGNORE_FILE) : void 0;
+  const matcher = createWorkflowUploadMatcher(
+    workflowIgnoreContent
+  );
+  const files = [];
+  const availableRegularPaths = /* @__PURE__ */ new Set();
+  const portablePaths = /* @__PURE__ */ new Map();
+  const ignoredPaths = [];
+  const walk = async (currentDir) => {
+    const entries = await readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const absolutePath = path2.join(currentDir, entry.name);
+      const relativePath = normalizeWorkflowUploadPath(path2.relative(projectRoot, absolutePath));
+      const portablePath = createWorkflowUploadPortablePathKey(relativePath);
+      const conflictingPath = portablePaths.get(portablePath);
+      if (conflictingPath !== void 0 && conflictingPath !== relativePath) {
+        throw new Error(
+          `Workflow upload paths ${JSON.stringify(conflictingPath)} and ${JSON.stringify(relativePath)} conflict on a case-insensitive filesystem.`
+        );
+      }
+      portablePaths.set(portablePath, relativePath);
+      if (entry.isDirectory()) {
+        if (matcher.ignores(relativePath, { directory: true })) {
+          ignoredPaths.push(`${relativePath}/`);
+          continue;
+        }
+        await walk(absolutePath);
+        continue;
+      }
+      if (!entry.isFile()) {
+        throw new Error(`Workflow upload path ${JSON.stringify(relativePath)} must be a regular file or directory.`);
+      }
+      availableRegularPaths.add(relativePath);
+      if (matcher.ignores(relativePath)) {
+        ignoredPaths.push(relativePath);
+        continue;
+      }
+      const fileStat = await lstat(absolutePath);
+      files.push({ path: relativePath, absolutePath, size: fileStat.size });
+    }
+  };
+  await walk(projectRoot);
+  files.sort((left, right) => left.path.localeCompare(right.path));
+  ignoredPaths.sort((left, right) => left.localeCompare(right));
+  if (!availableRegularPaths.has("package.json")) {
+    throw new Error("Workflow package must contain package.json.");
+  }
+  const packageJson = parsePackageJson(await readWorkflowUploadUtf8File(
+    path2.join(projectRoot, "package.json"),
+    "package.json"
+  ));
+  const requiredPaths = resolveWorkflowUploadRequiredPaths(
+    packageJson,
+    availableRegularPaths
+  );
+  matcher.assertRequiredPaths(requiredPaths);
+  for (const requiredPath of requiredPaths) {
+    if (!availableRegularPaths.has(requiredPath)) {
+      throw new Error(`Workflow package must contain required upload path ${JSON.stringify(requiredPath)}.`);
+    }
+  }
+  return {
+    workflowIgnorePresent,
+    workflowIgnoreConfigured: hasWorkflowIgnoreRules(workflowIgnoreContent),
+    files,
+    ignoredPaths,
+    totalBytes: files.reduce((total, file) => total + file.size, 0),
+    requiredPaths
+  };
+}
+async function copyWorkflowUploadFiles(sourceDir, targetDir) {
+  const plan = await createWorkflowUploadPlan(sourceDir);
+  await mkdir(targetDir, { recursive: true });
+  for (const file of plan.files) {
+    const targetPath = path2.join(targetDir, ...file.path.split("/"));
+    await mkdir(path2.dirname(targetPath), { recursive: true });
+    await copyFile(file.absolutePath, targetPath);
+  }
+  return plan;
+}
+function parsePackageJson(content) {
+  try {
+    return JSON.parse(content);
+  } catch {
+    throw new Error("Workflow package.json is invalid JSON.");
+  }
+}
+async function readWorkflowUploadUtf8File(filePath, label) {
+  const content = await readFile(filePath);
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(content);
+  } catch {
+    throw new Error(`Workflow ${label} must be a UTF-8 text file.`);
+  }
+}
+
 // src/auth-config.ts
 import { readFileSync } from "fs";
-import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { mkdir as mkdir2, readFile as readFile2, rm, writeFile } from "fs/promises";
 async function readCliAuthConfig(env = process.env) {
   try {
-    const raw = await readFile(resolveWorkflowCliAuthFilePath(env), "utf8");
+    const raw = await readFile2(resolveWorkflowCliAuthFilePath(env), "utf8");
     return normalizeWorkflowAuthConfig(JSON.parse(raw));
   } catch {
     return createEmptyWorkflowAuthConfig();
@@ -140,7 +858,7 @@ function readCliAuthConfigSync(env = process.env) {
   }
 }
 async function writeCliAuthConfig(config, env = process.env) {
-  await mkdir(resolveWorkflowCliAuthDir(env), { recursive: true });
+  await mkdir2(resolveWorkflowCliAuthDir(env), { recursive: true });
   await writeFile(
     resolveWorkflowCliAuthFilePath(env),
     `${JSON.stringify(normalizeWorkflowAuthConfig(config), null, 2)}
@@ -154,28 +872,28 @@ async function clearCliAuthConfig(env = process.env) {
 
 // src/env.ts
 import { existsSync, readFileSync as readFileSync2 } from "fs";
-import path2 from "path";
+import path3 from "path";
 import { parse } from "dotenv";
 function loadCliEnv() {
   const cliRoot = process.cwd();
   const defaultRepoRoot = findRepoRoot(cliRoot) ?? cliRoot;
-  const initialRepoRoot = process.env.WORKFLOW_REPO_ROOT ? path2.resolve(process.env.WORKFLOW_REPO_ROOT) : defaultRepoRoot;
+  const initialRepoRoot = process.env.WORKFLOW_REPO_ROOT ? path3.resolve(process.env.WORKFLOW_REPO_ROOT) : defaultRepoRoot;
   loadEnvFiles([
-    path2.join(cliRoot, ".env"),
-    path2.join(initialRepoRoot, ".env")
+    path3.join(cliRoot, ".env"),
+    path3.join(initialRepoRoot, ".env")
   ]);
-  const resolvedRepoRoot = process.env.WORKFLOW_REPO_ROOT ? path2.resolve(process.env.WORKFLOW_REPO_ROOT) : initialRepoRoot;
+  const resolvedRepoRoot = process.env.WORKFLOW_REPO_ROOT ? path3.resolve(process.env.WORKFLOW_REPO_ROOT) : initialRepoRoot;
   if (resolvedRepoRoot !== initialRepoRoot) {
-    loadEnvFiles([path2.join(resolvedRepoRoot, ".env")]);
+    loadEnvFiles([path3.join(resolvedRepoRoot, ".env")]);
   }
 }
 function findRepoRoot(startDir) {
-  let current = path2.resolve(startDir);
+  let current = path3.resolve(startDir);
   while (true) {
-    if (existsSync(path2.join(current, "pnpm-workspace.yaml")) && existsSync(path2.join(current, "packages", "cli", "package.json"))) {
+    if (existsSync(path3.join(current, "pnpm-workspace.yaml")) && existsSync(path3.join(current, "packages", "cli", "package.json"))) {
       return current;
     }
-    const parent = path2.dirname(current);
+    const parent = path3.dirname(current);
     if (parent === current) return void 0;
     current = parent;
   }
@@ -199,7 +917,7 @@ function unique(values) {
 
 // src/workspace.ts
 var DEFAULT_SERVER_URL = "http://localhost:7125";
-var CLI_MODULE_DIR = path3.dirname(fileURLToPath(import.meta.url));
+var CLI_MODULE_DIR = path4.dirname(fileURLToPath(import.meta.url));
 var DEFAULT_DEVICE_FLOW_CLIENT_NAME = "Workflow Workspace CLI";
 loadCliEnv();
 async function main(argv = process.argv.slice(2)) {
@@ -349,7 +1067,7 @@ async function commandUpload(parsed) {
   if (!workflowId) {
     throw new Error("Workflow package.json must include a UUID id. Use `workflow-code workspace upload <workflow> --create` after login to create and bind a server project.");
   }
-  const archivePath = parsed.options.file ? path3.resolve(parsed.options.file) : await packWorkflow(workflowArg, parsed.options.output, parsed.options.path);
+  const archivePath = parsed.options.file ? path4.resolve(parsed.options.file) : await packWorkflow(workflowArg, parsed.options.output, parsed.options.path);
   const uploadResult = await uploadPackage({
     workflowId,
     archivePath,
@@ -458,7 +1176,7 @@ async function commandDownload(parsed) {
   const result = await fetchApi({
     server: parsed.options.server,
     token: parsed.options.token,
-    path: `/api/workflows/${encodeURIComponent(workflowId)}/files?target=${encodeURIComponent(target)}`
+    path: `/api/workflows/${encodeURIComponent(workflowId)}/files?target=${encodeURIComponent(target)}&includeBinary=true`
   });
   printApiResponse(result);
   assertApiOk(result);
@@ -466,14 +1184,14 @@ async function commandDownload(parsed) {
     return;
   }
   const repoRoot = resolveRepoRoot();
-  const targetDir = parsed.options.path ? path3.resolve(parsed.options.path) : path3.join(repoRoot, "workspace", "workflow", workflowArg);
+  const targetDir = parsed.options.path ? path4.resolve(parsed.options.path) : path4.join(repoRoot, "workspace", "workflow", workflowArg);
   await rm2(targetDir, { recursive: true, force: true });
-  await mkdir2(targetDir, { recursive: true });
+  await mkdir3(targetDir, { recursive: true });
   for (const file of result.data.files) {
     const safePath = normalizeWorkflowFilePath(file.path);
-    const targetPath = path3.join(targetDir, safePath);
-    await mkdir2(path3.dirname(targetPath), { recursive: true });
-    await writeFile2(targetPath, file.content);
+    const targetPath = path4.join(targetDir, safePath);
+    await mkdir3(path4.dirname(targetPath), { recursive: true });
+    await writeFile2(targetPath, decodeWorkflowFileContent(file));
   }
 }
 async function commandPublish(parsed) {
@@ -504,27 +1222,25 @@ async function commandHealth(parsed) {
 }
 async function packWorkflow(workflowName, outputPath, sourcePath) {
   const repoRoot = resolveRepoRoot();
-  const workflowDir = sourcePath === void 0 ? path3.join(repoRoot, "workspace", "workflow", workflowName) : path3.resolve(sourcePath);
-  if (!existsSync2(path3.join(workflowDir, "README.md"))) {
-    throw new Error(`Workflow project "${workflowDir}" must contain README.md before upload.`);
-  }
-  const packsDir = process.env.WORKFLOW_WORKSPACE_PACKS_DIR ? path3.resolve(process.env.WORKFLOW_WORKSPACE_PACKS_DIR) : path3.join(repoRoot, "workspace", ".packs");
-  const stagingDir = path3.join(packsDir, "tmp", randomUUID(), workflowName);
-  const archivePath = outputPath ? path3.resolve(outputPath) : path3.join(packsDir, `${workflowName}-${createTimestamp()}.tgz`);
-  const workspaceRoot = sourcePath === void 0 ? path3.join(repoRoot, "workspace", "workflow") : path3.dirname(workflowDir);
-  await rm2(path3.dirname(stagingDir), { recursive: true, force: true });
-  await mkdir2(path3.join(stagingDir, "workspace", "workflow"), { recursive: true });
-  await mkdir2(path3.dirname(archivePath), { recursive: true });
+  const workflowDir = sourcePath === void 0 ? path4.join(repoRoot, "workspace", "workflow", workflowName) : path4.resolve(sourcePath);
+  await readPackageJsonFile(path4.join(workflowDir, "package.json"));
+  const packsDir = process.env.WORKFLOW_WORKSPACE_PACKS_DIR ? path4.resolve(process.env.WORKFLOW_WORKSPACE_PACKS_DIR) : path4.join(repoRoot, "workspace", ".packs");
+  const stagingDir = path4.join(packsDir, "tmp", randomUUID(), workflowName);
+  const archivePath = outputPath ? path4.resolve(outputPath) : path4.join(packsDir, `${workflowName}-${createTimestamp()}.tgz`);
+  const workspaceRoot = sourcePath === void 0 ? path4.join(repoRoot, "workspace", "workflow") : path4.dirname(workflowDir);
+  await rm2(path4.dirname(stagingDir), { recursive: true, force: true });
+  await mkdir3(path4.join(stagingDir, "workspace", "workflow"), { recursive: true });
+  await mkdir3(path4.dirname(archivePath), { recursive: true });
   await stageWorkflowWithLocalDependencies({
     workspaceRoot,
     workflowDir,
     workflowName,
-    stagingRoot: path3.join(stagingDir, "workspace", "workflow")
+    stagingRoot: path4.join(stagingDir, "workspace", "workflow")
   });
   const result = await runCommand("tar", ["-czf", archivePath, "-C", stagingDir, "."], {
     cwd: repoRoot
   });
-  await rm2(path3.dirname(stagingDir), { recursive: true, force: true });
+  await rm2(path4.dirname(stagingDir), { recursive: true, force: true });
   if (result.exitCode !== 0) {
     throw new Error(`Failed to create archive: ${result.stderr || result.stdout}`);
   }
@@ -543,8 +1259,8 @@ async function resolveRemoteWorkflowId(parsed) {
 }
 async function readWorkflowPackageContext(workflowArg, sourcePath) {
   const repoRoot = resolveRepoRoot();
-  const workflowDir = sourcePath === void 0 ? path3.join(repoRoot, "workspace", "workflow", workflowArg) : path3.resolve(sourcePath);
-  const packageJsonPath = path3.join(workflowDir, "package.json");
+  const workflowDir = sourcePath === void 0 ? path4.join(repoRoot, "workspace", "workflow", workflowArg) : path4.resolve(sourcePath);
+  const packageJsonPath = path4.join(workflowDir, "package.json");
   const packageJson = await readPackageJsonFile(packageJsonPath);
   const workflowId = typeof packageJson.id === "string" && isWorkflowUuid(packageJson.id) ? packageJson.id.trim() : void 0;
   const workflowName = readRequiredPackageString(packageJson, "name");
@@ -580,7 +1296,7 @@ async function ensureWorkflowProjectCreated(options) {
 }
 async function readPackageJsonFile(packageJsonPath) {
   try {
-    const raw = JSON.parse(await readFile2(packageJsonPath, "utf8"));
+    const raw = JSON.parse(await readFile3(packageJsonPath, "utf8"));
     if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
       throw new Error(`Workflow package "${packageJsonPath}" must contain a JSON object.`);
     }
@@ -611,8 +1327,8 @@ async function writeWorkflowPackageId(packageJsonPath, workflowId) {
   );
 }
 async function uploadPackage(options) {
-  const archiveBuffer = await readFile2(options.archivePath);
-  const archiveName = path3.basename(options.archivePath);
+  const archiveBuffer = await readFile3(options.archivePath);
+  const archiveName = path4.basename(options.archivePath);
   const response = await fetch(
     `${trimTrailingSlash(options.server)}/api/workflows/${encodeURIComponent(options.workflowId)}/package?fileName=${encodeURIComponent(archiveName)}`,
     {
@@ -683,13 +1399,7 @@ async function fetchApi(options) {
   return response.json();
 }
 async function copyWorkflowSource(sourceDir, targetDir) {
-  await cp(sourceDir, targetDir, {
-    recursive: true,
-    filter(source) {
-      const relative = path3.relative(sourceDir, source);
-      return relative === "" || !shouldExcludePackagePath(relative);
-    }
-  });
+  return copyWorkflowUploadFiles(sourceDir, targetDir);
 }
 async function stageWorkflowWithLocalDependencies(options) {
   const queue = [options.workflowName];
@@ -700,13 +1410,23 @@ async function stageWorkflowWithLocalDependencies(options) {
       continue;
     }
     visited.add(currentWorkflowName);
-    const sourceDir = currentWorkflowName === options.workflowName ? options.workflowDir : path3.join(options.workspaceRoot, currentWorkflowName);
-    if (!existsSync2(path3.join(sourceDir, "package.json"))) {
+    const sourceDir = currentWorkflowName === options.workflowName ? options.workflowDir : path4.join(options.workspaceRoot, currentWorkflowName);
+    if (!existsSync2(path4.join(sourceDir, "package.json"))) {
       throw new Error(
         `Workflow "${options.workflowName}" references local workflow "${currentWorkflowName}", but ${sourceDir} is missing package.json.`
       );
     }
-    await copyWorkflowSource(sourceDir, path3.join(options.stagingRoot, currentWorkflowName));
+    const uploadPlan = await copyWorkflowSource(
+      sourceDir,
+      path4.join(options.stagingRoot, currentWorkflowName)
+    );
+    if (currentWorkflowName === options.workflowName && !uploadPlan.workflowIgnoreConfigured) {
+      process.stderr.write([
+        "Warning: .workflowignore is missing or has no active rules; all regular project files will be uploaded.",
+        `.gitignore is not used. Files: ${uploadPlan.files.length}; bytes: ${uploadPlan.totalBytes}.`,
+        ""
+      ].join("\n"));
+    }
     for (const dependency of await findLocalWorkflowDependencies(sourceDir)) {
       if (!visited.has(dependency)) {
         queue.push(dependency);
@@ -717,11 +1437,11 @@ async function stageWorkflowWithLocalDependencies(options) {
 async function findLocalWorkflowDependencies(sourceDir) {
   const discovered = /* @__PURE__ */ new Set();
   for (const fileName of ["index.ts", "interface.ts", "globals.d.ts"]) {
-    const filePath = path3.join(sourceDir, fileName);
+    const filePath = path4.join(sourceDir, fileName);
     if (!existsSync2(filePath)) {
       continue;
     }
-    const source = await readFile2(filePath, "utf8");
+    const source = await readFile3(filePath, "utf8");
     for (const match of source.matchAll(/(?:from\s+|reference path=)\"(\.\.\/([^/\"']+)(?:\/[^\"']*)?)\"/g)) {
       const workflowName = match[2]?.trim();
       if (workflowName) {
@@ -737,39 +1457,30 @@ async function findLocalWorkflowDependencies(sourceDir) {
   }
   return [...discovered].sort((left, right) => left.localeCompare(right));
 }
-function shouldExcludePackagePath(relativePath) {
-  const parts = relativePath.split(/[\\/]/);
-  const name = parts.at(-1) ?? "";
-  const excludedDirectories = /* @__PURE__ */ new Set([
-    "node_modules",
-    "dist",
-    "build",
-    "out",
-    "coverage",
-    ".git",
-    ".hg",
-    ".svn",
-    ".cache",
-    ".turbo",
-    ".next",
-    ".nuxt",
-    ".pnpm-store"
-  ]);
-  if (parts.some((part) => excludedDirectories.has(part))) {
-    return true;
-  }
-  if (name === ".env" || name.startsWith(".env.")) {
-    return name !== ".env.example";
-  }
-  return name === ".DS_Store" || name === "Thumbs.db" || name.endsWith(".tmp") || name.endsWith(".log") || name.endsWith(".tsbuildinfo") || name.endsWith("~");
-}
 function normalizeWorkflowFilePath(filePath) {
   const normalized = filePath.replaceAll("\\", "/").replace(/^\.\/+/, "");
-  if (normalized === "" || normalized.startsWith("/") || /^[a-zA-Z]:/.test(normalized) || normalized.split("/").some((part) => part === "" || part === "." || part === "..") || shouldExcludePackagePath(normalized)) {
+  if (normalized === "" || normalized.startsWith("/") || /^[a-zA-Z]:/.test(normalized) || normalized.split("/").some((part) => part === "" || part === "." || part === "..")) {
     throw new Error(`Invalid workflow file path "${filePath}".`);
   }
   return normalized;
 }
+function decodeWorkflowFileContent(file) {
+  if (file.encoding === void 0) {
+    return file.content;
+  }
+  if (file.encoding !== "base64") {
+    throw new Error(`Unsupported encoding for workflow file "${file.path}".`);
+  }
+  const normalized = file.content.replace(/=+$/, "");
+  if (!/^[A-Za-z0-9+/]*={0,2}$/.test(file.content)) {
+    throw new Error(`Invalid base64 content for workflow file "${file.path}".`);
+  }
+  const decoded = Buffer.from(file.content, "base64");
+  if (decoded.toString("base64").replace(/=+$/, "") !== normalized) {
+    throw new Error(`Invalid base64 content for workflow file "${file.path}".`);
+  }
+  return decoded;
+}
 function parseArgs(argv) {
   const [command = "", ...rest] = argv;
   const positional = [];
@@ -927,7 +1638,7 @@ function printUsage() {
 }
 function resolveRepoRoot(startDir = process.cwd()) {
   if (process.env.WORKFLOW_REPO_ROOT !== void 0) {
-    return path3.resolve(process.env.WORKFLOW_REPO_ROOT);
+    return path4.resolve(process.env.WORKFLOW_REPO_ROOT);
   }
   for (const candidate of [startDir, CLI_MODULE_DIR]) {
     const repoRoot = findRepoRoot2(candidate);
@@ -938,12 +1649,12 @@ function resolveRepoRoot(startDir = process.cwd()) {
   return process.cwd();
 }
 function findRepoRoot2(startDir) {
-  let current = path3.resolve(startDir);
+  let current = path4.resolve(startDir);
   while (true) {
     if (isRepoRoot(current)) {
       return current;
     }
-    const parent = path3.dirname(current);
+    const parent = path4.dirname(current);
     if (parent === current) {
       return void 0;
     }
@@ -951,7 +1662,7 @@ function findRepoRoot2(startDir) {
   }
 }
 function isRepoRoot(candidate) {
-  return existsSync2(path3.join(candidate, "pnpm-workspace.yaml")) && existsSync2(path3.join(candidate, "package.json")) && existsSync2(path3.join(candidate, "workspace", "package.json")) && existsSync2(path3.join(candidate, "packages", "cli", "package.json"));
+  return existsSync2(path4.join(candidate, "pnpm-workspace.yaml")) && existsSync2(path4.join(candidate, "package.json")) && existsSync2(path4.join(candidate, "workspace", "package.json")) && existsSync2(path4.join(candidate, "packages", "cli", "package.json"));
 }
 function trimTrailingSlash(value) {
   return value.replace(/\/+$/, "");
@@ -1018,13 +1729,14 @@ function readRetryAfterSeconds(data) {
   const value = data.retryAfterSeconds;
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
 }
-if (process.argv[1] !== void 0 && import.meta.url === pathToFileURL(path3.resolve(process.argv[1])).href) {
+if (process.argv[1] !== void 0 && import.meta.url === pathToFileURL(path4.resolve(process.argv[1])).href) {
   main().catch((error) => {
     console.error(error instanceof Error ? error.message : String(error));
     process.exitCode = 1;
   });
 }
 export {
+  decodeWorkflowFileContent,
   ensureWorkflowProjectCreated,
   findLocalWorkflowDependencies,
   formatForbiddenMessage,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflow-code/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "bin": {
     "workflow-code": "./dist/index.js"