@powerformer/refly-cli 0.1.13 → 0.1.14

package/dist/bin/refly.js

@@ -521,10 +521,10 @@ var require_help = __commonJS({
         function formatList(textArray) {
           return textArray.join("\n").replace(/^/gm, " ".repeat(itemIndentWidth));
         }
-        let output = [`Usage: ${helper.commandUsage(cmd)}`, ""];
+        let output2 = [`Usage: ${helper.commandUsage(cmd)}`, ""];
         const commandDescription = helper.commandDescription(cmd);
         if (commandDescription.length > 0) {
-          output = output.concat([
+          output2 = output2.concat([
             helper.wrap(commandDescription, helpWidth, 0),
             ""
           ]);
@@ -536,7 +536,7 @@ var require_help = __commonJS({
           );
         });
         if (argumentList.length > 0) {
-          output = output.concat(["Arguments:", formatList(argumentList), ""]);
+          output2 = output2.concat(["Arguments:", formatList(argumentList), ""]);
         }
         const optionList = helper.visibleOptions(cmd).map((option) => {
           return formatItem(
@@ -545,7 +545,7 @@ var require_help = __commonJS({
           );
         });
         if (optionList.length > 0) {
-          output = output.concat(["Options:", formatList(optionList), ""]);
+          output2 = output2.concat(["Options:", formatList(optionList), ""]);
         }
         if (this.showGlobalOptions) {
           const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => {
@@ -555,7 +555,7 @@ var require_help = __commonJS({
             );
           });
           if (globalOptionList.length > 0) {
-            output = output.concat([
+            output2 = output2.concat([
               "Global Options:",
               formatList(globalOptionList),
               ""
@@ -569,9 +569,9 @@ var require_help = __commonJS({
           );
         });
         if (commandList.length > 0) {
-          output = output.concat(["Commands:", formatList(commandList), ""]);
+          output2 = output2.concat(["Commands:", formatList(commandList), ""]);
         }
-        return output.join("\n");
+        return output2.join("\n");
       }
       /**
        * Calculate the pad width from the maximum term length.
@@ -3060,21 +3060,11 @@ __export(paths_exports, {
   getCacheDir: () => getCacheDir,
   getClaudeCommandsDir: () => getClaudeCommandsDir,
   getClaudeSkillDir: () => getClaudeSkillDir,
-  getCliVersion: () => getCliVersion,
   getConfigPath: () => getConfigPath,
   getCurrentSessionPath: () => getCurrentSessionPath,
   getReflyDir: () => getReflyDir,
   getSessionPath: () => getSessionPath
 });
-function getCliVersion() {
-  try {
-    const pkgPath = path.join(__dirname, "..", "..", "package.json");
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-    return pkg.version || "0.1.0";
-  } catch {
-    return "0.1.0";
-  }
-}
 function getReflyDir() {
   const dir = path.join(os.homedir(), ".refly");
   ensureDir(dir);
@@ -3141,13 +3131,13 @@ function redact(message) {
   }
   return result;
 }
-var fs3, path3, LOG_FILE, MAX_LOG_SIZE, LOG_LEVELS, SENSITIVE_PATTERNS, Logger, logger;
+var fs9, path5, LOG_FILE, MAX_LOG_SIZE, LOG_LEVELS, SENSITIVE_PATTERNS, Logger, logger;
 var init_logger = __esm({
   "src/utils/logger.ts"() {
     "use strict";
     init_cjs_shims();
-    fs3 = __toESM(require("fs"));
-    path3 = __toESM(require("path"));
+    fs9 = __toESM(require("fs"));
+    path5 = __toESM(require("path"));
     init_paths();
     LOG_FILE = "cli.log";
     MAX_LOG_SIZE = 5 * 1024 * 1024;
@@ -3183,15 +3173,15 @@ var init_logger = __esm({
       writeToFile(formatted) {
         if (!this.logToFile) return;
         try {
-          const logPath = path3.join(getReflyDir(), LOG_FILE);
+          const logPath = path5.join(getReflyDir(), LOG_FILE);
           try {
-            const stats = fs3.statSync(logPath);
+            const stats = fs9.statSync(logPath);
             if (stats.size > MAX_LOG_SIZE) {
-              fs3.renameSync(logPath, `${logPath}.old`);
+              fs9.renameSync(logPath, `${logPath}.old`);
             }
           } catch {
           }
-          fs3.appendFileSync(logPath, `${formatted}
+          fs9.appendFileSync(logPath, `${formatted}
 `);
         } catch {
         }
@@ -4050,42 +4040,55 @@ var OutputFormatter = class {
   }
   // === CLI Status Format (Phase 1: Charm-style cards) ===
   outputStatusPretty(payload) {
-    const { cli_version, auth_status, user, skill } = payload;
+    const { cli_version, api_endpoint, auth_status, user, skill } = payload;
     const sym = this.useUnicode ? Symbols : AsciiSymbol;
     console.log(`${sym.DIAMOND} ${UI.bold("Refly CLI")} v${cli_version || "?"}`);
     console.log();
     const authOk = auth_status === "valid";
     const userObj = user;
-    let authText = "";
+    const authLines = [];
     if (authOk && userObj?.email) {
-      authText = String(userObj.email);
+      authLines.push({ text: String(userObj.email) });
     } else if (auth_status === "expired") {
-      authText = "Token expired";
+      authLines.push({ text: "Token expired", muted: true });
     } else {
-      authText = "Not authenticated";
+      authLines.push({ text: "Not authenticated", muted: true });
     }
+    console.log(
+      UI.card({
+        title: "Auth",
+        status: authOk ? "success" : "error",
+        lines: authLines,
+        width: 45
+      })
+    );
+    console.log();
+    const endpoint = String(api_endpoint || "\u2014");
+    console.log(
+      UI.card({
+        title: "Connection",
+        status: authOk ? "success" : "pending",
+        lines: [{ text: endpoint }],
+        width: 45
+      })
+    );
+    console.log();
     const skillObj = skill;
     const skillInstalled = skillObj?.installed === true;
     const skillVersion = skillObj?.version ? `v${skillObj.version}` : "";
     const skillUpToDate = skillObj?.up_to_date === true;
-    let skillText = "";
+    const skillLines = [];
     if (skillInstalled) {
-      skillText = skillVersion + (skillUpToDate ? " (up to date)" : " (update available)");
+      const versionText = skillVersion + (skillUpToDate ? " (up to date)" : " (update available)");
+      skillLines.push({ text: versionText });
     } else {
-      skillText = "Not installed";
+      skillLines.push({ text: "Not installed", muted: true });
     }
-    const authIcon = authOk ? styled(sym.SUCCESS, Style.TEXT_SUCCESS) : styled(sym.FAILURE, Style.TEXT_DANGER);
-    const connIcon = authOk ? styled(sym.SUCCESS, Style.TEXT_SUCCESS) : styled(sym.PENDING, Style.TEXT_DIM);
-    const skillIcon = skillInstalled ? styled(sym.SUCCESS, Style.TEXT_SUCCESS) : styled(sym.PENDING, Style.TEXT_DIM);
-    const lines = [
-      { text: `${authIcon} Account    ${authOk ? authText : authText}`, muted: !authOk },
-      { text: `${connIcon} Link       https://refly.ai/` },
-      { text: `${skillIcon} Version    ${skillText}`, muted: !skillInstalled }
-    ];
     console.log(
       UI.card({
-        title: "Status",
-        lines,
+        title: "Skill",
+        status: skillInstalled ? "success" : "pending",
+        lines: skillLines,
         width: 45
       })
     );
@@ -4441,6 +4444,12 @@ var path10 = __toESM(require("path"));
 // src/commands/init.ts
 init_cjs_shims();
 
+// src/skill/installer.ts
+init_cjs_shims();
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+init_paths();
+
 // src/config/config.ts
 init_cjs_shims();
 var fs2 = __toESM(require("fs"));
@@ -5126,41 +5135,41 @@ var ZodType = class {
   get description() {
     return this._def.description;
   }
-  _getType(input) {
-    return getParsedType(input.data);
+  _getType(input2) {
+    return getParsedType(input2.data);
   }
-  _getOrReturnCtx(input, ctx) {
+  _getOrReturnCtx(input2, ctx) {
     return ctx || {
-      common: input.parent.common,
-      data: input.data,
-      parsedType: getParsedType(input.data),
+      common: input2.parent.common,
+      data: input2.data,
+      parsedType: getParsedType(input2.data),
       schemaErrorMap: this._def.errorMap,
-      path: input.path,
-      parent: input.parent
+      path: input2.path,
+      parent: input2.parent
     };
   }
-  _processInputParams(input) {
+  _processInputParams(input2) {
     return {
       status: new ParseStatus(),
       ctx: {
-        common: input.parent.common,
-        data: input.data,
-        parsedType: getParsedType(input.data),
+        common: input2.parent.common,
+        data: input2.data,
+        parsedType: getParsedType(input2.data),
         schemaErrorMap: this._def.errorMap,
-        path: input.path,
-        parent: input.parent
+        path: input2.path,
+        parent: input2.parent
       }
     };
   }
-  _parseSync(input) {
-    const result = this._parse(input);
+  _parseSync(input2) {
+    const result = this._parse(input2);
     if (isAsync(result)) {
       throw new Error("Synchronous parse encountered promise.");
     }
     return result;
   }
-  _parseAsync(input) {
-    const result = this._parse(input);
+  _parseAsync(input2) {
+    const result = this._parse(input2);
     return Promise.resolve(result);
   }
   parse(data, params) {
@@ -5486,13 +5495,13 @@ function isValidCidr(ip, version) {
   return false;
 }
 var ZodString = class _ZodString extends ZodType {
-  _parse(input) {
+  _parse(input2) {
     if (this._def.coerce) {
-      input.data = String(input.data);
+      input2.data = String(input2.data);
     }
-    const parsedType = this._getType(input);
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.string) {
-      const ctx2 = this._getOrReturnCtx(input);
+      const ctx2 = this._getOrReturnCtx(input2);
       addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.string,
@@ -5504,8 +5513,8 @@ var ZodString = class _ZodString extends ZodType {
     let ctx = void 0;
     for (const check of this._def.checks) {
       if (check.kind === "min") {
-        if (input.data.length < check.value) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (input2.data.length < check.value) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_small,
             minimum: check.value,
@@ -5517,8 +5526,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "max") {
-        if (input.data.length > check.value) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (input2.data.length > check.value) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_big,
             maximum: check.value,
@@ -5530,10 +5539,10 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "length") {
-        const tooBig = input.data.length > check.value;
-        const tooSmall = input.data.length < check.value;
+        const tooBig = input2.data.length > check.value;
+        const tooSmall = input2.data.length < check.value;
         if (tooBig || tooSmall) {
-          ctx = this._getOrReturnCtx(input, ctx);
+          ctx = this._getOrReturnCtx(input2, ctx);
           if (tooBig) {
             addIssueToContext(ctx, {
               code: ZodIssueCode.too_big,
@@ -5556,8 +5565,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "email") {
-        if (!emailRegex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!emailRegex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "email",
             code: ZodIssueCode.invalid_string,
@@ -5569,8 +5578,8 @@ var ZodString = class _ZodString extends ZodType {
         if (!emojiRegex) {
           emojiRegex = new RegExp(_emojiRegex, "u");
         }
-        if (!emojiRegex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!emojiRegex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "emoji",
             code: ZodIssueCode.invalid_string,
@@ -5579,8 +5588,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "uuid") {
-        if (!uuidRegex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!uuidRegex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "uuid",
             code: ZodIssueCode.invalid_string,
@@ -5589,8 +5598,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "nanoid") {
-        if (!nanoidRegex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!nanoidRegex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "nanoid",
             code: ZodIssueCode.invalid_string,
@@ -5599,8 +5608,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "cuid") {
-        if (!cuidRegex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!cuidRegex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "cuid",
             code: ZodIssueCode.invalid_string,
@@ -5609,8 +5618,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "cuid2") {
-        if (!cuid2Regex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!cuid2Regex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "cuid2",
             code: ZodIssueCode.invalid_string,
@@ -5619,8 +5628,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "ulid") {
-        if (!ulidRegex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!ulidRegex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "ulid",
             code: ZodIssueCode.invalid_string,
@@ -5630,9 +5639,9 @@ var ZodString = class _ZodString extends ZodType {
         }
       } else if (check.kind === "url") {
         try {
-          new URL(input.data);
+          new URL(input2.data);
         } catch {
-          ctx = this._getOrReturnCtx(input, ctx);
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "url",
             code: ZodIssueCode.invalid_string,
@@ -5642,9 +5651,9 @@ var ZodString = class _ZodString extends ZodType {
         }
       } else if (check.kind === "regex") {
         check.regex.lastIndex = 0;
-        const testResult = check.regex.test(input.data);
+        const testResult = check.regex.test(input2.data);
         if (!testResult) {
-          ctx = this._getOrReturnCtx(input, ctx);
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "regex",
             code: ZodIssueCode.invalid_string,
@@ -5653,10 +5662,10 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "trim") {
-        input.data = input.data.trim();
+        input2.data = input2.data.trim();
       } else if (check.kind === "includes") {
-        if (!input.data.includes(check.value, check.position)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!input2.data.includes(check.value, check.position)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: { includes: check.value, position: check.position },
@@ -5665,12 +5674,12 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "toLowerCase") {
-        input.data = input.data.toLowerCase();
+        input2.data = input2.data.toLowerCase();
       } else if (check.kind === "toUpperCase") {
-        input.data = input.data.toUpperCase();
+        input2.data = input2.data.toUpperCase();
       } else if (check.kind === "startsWith") {
-        if (!input.data.startsWith(check.value)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!input2.data.startsWith(check.value)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: { startsWith: check.value },
@@ -5679,8 +5688,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "endsWith") {
-        if (!input.data.endsWith(check.value)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!input2.data.endsWith(check.value)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: { endsWith: check.value },
@@ -5690,8 +5699,8 @@ var ZodString = class _ZodString extends ZodType {
         }
       } else if (check.kind === "datetime") {
         const regex = datetimeRegex(check);
-        if (!regex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!regex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: "datetime",
@@ -5701,8 +5710,8 @@ var ZodString = class _ZodString extends ZodType {
         }
       } else if (check.kind === "date") {
         const regex = dateRegex;
-        if (!regex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!regex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: "date",
@@ -5712,8 +5721,8 @@ var ZodString = class _ZodString extends ZodType {
         }
       } else if (check.kind === "time") {
         const regex = timeRegex(check);
-        if (!regex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!regex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: "time",
@@ -5722,8 +5731,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "duration") {
-        if (!durationRegex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!durationRegex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "duration",
             code: ZodIssueCode.invalid_string,
@@ -5732,8 +5741,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "ip") {
-        if (!isValidIP(input.data, check.version)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!isValidIP(input2.data, check.version)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "ip",
             code: ZodIssueCode.invalid_string,
@@ -5742,8 +5751,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "jwt") {
-        if (!isValidJWT(input.data, check.alg)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!isValidJWT(input2.data, check.alg)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "jwt",
             code: ZodIssueCode.invalid_string,
@@ -5752,8 +5761,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "cidr") {
-        if (!isValidCidr(input.data, check.version)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!isValidCidr(input2.data, check.version)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "cidr",
             code: ZodIssueCode.invalid_string,
@@ -5762,8 +5771,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "base64") {
-        if (!base64Regex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!base64Regex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "base64",
             code: ZodIssueCode.invalid_string,
@@ -5772,8 +5781,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "base64url") {
-        if (!base64urlRegex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!base64urlRegex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "base64url",
             code: ZodIssueCode.invalid_string,
@@ -5785,7 +5794,7 @@ var ZodString = class _ZodString extends ZodType {
         util.assertNever(check);
       }
     }
-    return { status: status.value, value: input.data };
+    return { status: status.value, value: input2.data };
   }
   _regex(regex, validation, message) {
     return this.refinement((data) => regex.test(data), {
@@ -6046,13 +6055,13 @@ var ZodNumber = class _ZodNumber extends ZodType {
     this.max = this.lte;
     this.step = this.multipleOf;
   }
-  _parse(input) {
+  _parse(input2) {
     if (this._def.coerce) {
-      input.data = Number(input.data);
+      input2.data = Number(input2.data);
     }
-    const parsedType = this._getType(input);
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.number) {
-      const ctx2 = this._getOrReturnCtx(input);
+      const ctx2 = this._getOrReturnCtx(input2);
       addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.number,
@@ -6064,8 +6073,8 @@ var ZodNumber = class _ZodNumber extends ZodType {
     const status = new ParseStatus();
     for (const check of this._def.checks) {
       if (check.kind === "int") {
-        if (!util.isInteger(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!util.isInteger(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_type,
             expected: "integer",
@@ -6075,9 +6084,9 @@ var ZodNumber = class _ZodNumber extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "min") {
-        const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
+        const tooSmall = check.inclusive ? input2.data < check.value : input2.data <= check.value;
         if (tooSmall) {
-          ctx = this._getOrReturnCtx(input, ctx);
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_small,
             minimum: check.value,
@@ -6089,9 +6098,9 @@ var ZodNumber = class _ZodNumber extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "max") {
-        const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
+        const tooBig = check.inclusive ? input2.data > check.value : input2.data >= check.value;
         if (tooBig) {
-          ctx = this._getOrReturnCtx(input, ctx);
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_big,
             maximum: check.value,
@@ -6103,8 +6112,8 @@ var ZodNumber = class _ZodNumber extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "multipleOf") {
-        if (floatSafeRemainder(input.data, check.value) !== 0) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (floatSafeRemainder(input2.data, check.value) !== 0) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.not_multiple_of,
             multipleOf: check.value,
@@ -6113,8 +6122,8 @@ var ZodNumber = class _ZodNumber extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "finite") {
-        if (!Number.isFinite(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!Number.isFinite(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.not_finite,
             message: check.message
@@ -6125,7 +6134,7 @@ var ZodNumber = class _ZodNumber extends ZodType {
         util.assertNever(check);
       }
     }
-    return { status: status.value, value: input.data };
+    return { status: status.value, value: input2.data };
   }
   gte(value, message) {
     return this.setLimit("min", value, true, errorUtil.toString(message));
@@ -6277,25 +6286,25 @@ var ZodBigInt = class _ZodBigInt extends ZodType {
     this.min = this.gte;
     this.max = this.lte;
   }
-  _parse(input) {
+  _parse(input2) {
     if (this._def.coerce) {
       try {
-        input.data = BigInt(input.data);
+        input2.data = BigInt(input2.data);
       } catch {
-        return this._getInvalidInput(input);
+        return this._getInvalidInput(input2);
       }
     }
-    const parsedType = this._getType(input);
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.bigint) {
-      return this._getInvalidInput(input);
+      return this._getInvalidInput(input2);
     }
     let ctx = void 0;
     const status = new ParseStatus();
     for (const check of this._def.checks) {
       if (check.kind === "min") {
-        const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
+        const tooSmall = check.inclusive ? input2.data < check.value : input2.data <= check.value;
         if (tooSmall) {
-          ctx = this._getOrReturnCtx(input, ctx);
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_small,
             type: "bigint",
@@ -6306,9 +6315,9 @@ var ZodBigInt = class _ZodBigInt extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "max") {
-        const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
+        const tooBig = check.inclusive ? input2.data > check.value : input2.data >= check.value;
         if (tooBig) {
-          ctx = this._getOrReturnCtx(input, ctx);
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_big,
             type: "bigint",
@@ -6319,8 +6328,8 @@ var ZodBigInt = class _ZodBigInt extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "multipleOf") {
-        if (input.data % check.value !== BigInt(0)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (input2.data % check.value !== BigInt(0)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.not_multiple_of,
             multipleOf: check.value,
@@ -6332,10 +6341,10 @@ var ZodBigInt = class _ZodBigInt extends ZodType {
         util.assertNever(check);
       }
     }
-    return { status: status.value, value: input.data };
+    return { status: status.value, value: input2.data };
   }
-  _getInvalidInput(input) {
-    const ctx = this._getOrReturnCtx(input);
+  _getInvalidInput(input2) {
+    const ctx = this._getOrReturnCtx(input2);
     addIssueToContext(ctx, {
       code: ZodIssueCode.invalid_type,
       expected: ZodParsedType.bigint,
@@ -6444,13 +6453,13 @@ ZodBigInt.create = (params) => {
   });
 };
 var ZodBoolean = class extends ZodType {
-  _parse(input) {
+  _parse(input2) {
     if (this._def.coerce) {
-      input.data = Boolean(input.data);
+      input2.data = Boolean(input2.data);
     }
-    const parsedType = this._getType(input);
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.boolean) {
-      const ctx = this._getOrReturnCtx(input);
+      const ctx = this._getOrReturnCtx(input2);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.boolean,
@@ -6458,7 +6467,7 @@ var ZodBoolean = class extends ZodType {
       });
       return INVALID;
     }
-    return OK(input.data);
+    return OK(input2.data);
   }
 };
 ZodBoolean.create = (params) => {
@@ -6469,13 +6478,13 @@ ZodBoolean.create = (params) => {
   });
 };
 var ZodDate = class _ZodDate extends ZodType {
-  _parse(input) {
+  _parse(input2) {
     if (this._def.coerce) {
-      input.data = new Date(input.data);
+      input2.data = new Date(input2.data);
     }
-    const parsedType = this._getType(input);
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.date) {
-      const ctx2 = this._getOrReturnCtx(input);
+      const ctx2 = this._getOrReturnCtx(input2);
       addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.date,
@@ -6483,8 +6492,8 @@ var ZodDate = class _ZodDate extends ZodType {
       });
       return INVALID;
     }
-    if (Number.isNaN(input.data.getTime())) {
-      const ctx2 = this._getOrReturnCtx(input);
+    if (Number.isNaN(input2.data.getTime())) {
+      const ctx2 = this._getOrReturnCtx(input2);
       addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_date
       });
@@ -6494,8 +6503,8 @@ var ZodDate = class _ZodDate extends ZodType {
     let ctx = void 0;
     for (const check of this._def.checks) {
       if (check.kind === "min") {
-        if (input.data.getTime() < check.value) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (input2.data.getTime() < check.value) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_small,
             message: check.message,
@@ -6507,8 +6516,8 @@ var ZodDate = class _ZodDate extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "max") {
-        if (input.data.getTime() > check.value) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (input2.data.getTime() > check.value) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_big,
             message: check.message,
@@ -6525,7 +6534,7 @@ var ZodDate = class _ZodDate extends ZodType {
     }
     return {
       status: status.value,
-      value: new Date(input.data.getTime())
+      value: new Date(input2.data.getTime())
     };
   }
   _addCheck(check) {
@@ -6578,10 +6587,10 @@ ZodDate.create = (params) => {
   });
 };
 var ZodSymbol = class extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
+  _parse(input2) {
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.symbol) {
-      const ctx = this._getOrReturnCtx(input);
+      const ctx = this._getOrReturnCtx(input2);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.symbol,
@@ -6589,7 +6598,7 @@ var ZodSymbol = class extends ZodType {
       });
       return INVALID;
     }
-    return OK(input.data);
+    return OK(input2.data);
   }
 };
 ZodSymbol.create = (params) => {
@@ -6599,10 +6608,10 @@ ZodSymbol.create = (params) => {
   });
 };
 var ZodUndefined = class extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
+  _parse(input2) {
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.undefined) {
-      const ctx = this._getOrReturnCtx(input);
+      const ctx = this._getOrReturnCtx(input2);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.undefined,
@@ -6610,7 +6619,7 @@ var ZodUndefined = class extends ZodType {
       });
       return INVALID;
     }
-    return OK(input.data);
+    return OK(input2.data);
   }
 };
 ZodUndefined.create = (params) => {
@@ -6620,10 +6629,10 @@ ZodUndefined.create = (params) => {
   });
 };
 var ZodNull = class extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
+  _parse(input2) {
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.null) {
-      const ctx = this._getOrReturnCtx(input);
+      const ctx = this._getOrReturnCtx(input2);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.null,
@@ -6631,7 +6640,7 @@ var ZodNull = class extends ZodType {
       });
       return INVALID;
     }
-    return OK(input.data);
+    return OK(input2.data);
   }
 };
 ZodNull.create = (params) => {
@@ -6645,8 +6654,8 @@ var ZodAny = class extends ZodType {
     super(...arguments);
     this._any = true;
   }
-  _parse(input) {
-    return OK(input.data);
+  _parse(input2) {
+    return OK(input2.data);
   }
 };
 ZodAny.create = (params) => {
@@ -6660,8 +6669,8 @@ var ZodUnknown = class extends ZodType {
     super(...arguments);
     this._unknown = true;
   }
-  _parse(input) {
-    return OK(input.data);
+  _parse(input2) {
+    return OK(input2.data);
   }
 };
 ZodUnknown.create = (params) => {
@@ -6671,8 +6680,8 @@ ZodUnknown.create = (params) => {
   });
 };
 var ZodNever = class extends ZodType {
-  _parse(input) {
-    const ctx = this._getOrReturnCtx(input);
+  _parse(input2) {
+    const ctx = this._getOrReturnCtx(input2);
     addIssueToContext(ctx, {
       code: ZodIssueCode.invalid_type,
       expected: ZodParsedType.never,
@@ -6688,10 +6697,10 @@ ZodNever.create = (params) => {
   });
 };
 var ZodVoid = class extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
+  _parse(input2) {
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.undefined) {
-      const ctx = this._getOrReturnCtx(input);
+      const ctx = this._getOrReturnCtx(input2);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.void,
@@ -6699,7 +6708,7 @@ var ZodVoid = class extends ZodType {
       });
       return INVALID;
     }
-    return OK(input.data);
+    return OK(input2.data);
   }
 };
 ZodVoid.create = (params) => {
@@ -6709,8 +6718,8 @@ ZodVoid.create = (params) => {
   });
 };
 var ZodArray = class _ZodArray extends ZodType {
-  _parse(input) {
-    const { ctx, status } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx, status } = this._processInputParams(input2);
     const def = this._def;
     if (ctx.parsedType !== ZodParsedType.array) {
       addIssueToContext(ctx, {
@@ -6850,10 +6859,10 @@ var ZodObject = class _ZodObject extends ZodType {
     this._cached = { shape, keys };
     return this._cached;
   }
-  _parse(input) {
-    const parsedType = this._getType(input);
+  _parse(input2) {
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.object) {
-      const ctx2 = this._getOrReturnCtx(input);
+      const ctx2 = this._getOrReturnCtx(input2);
       addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.object,
@@ -6861,7 +6870,7 @@ var ZodObject = class _ZodObject extends ZodType {
       });
       return INVALID;
     }
-    const { status, ctx } = this._processInputParams(input);
+    const { status, ctx } = this._processInputParams(input2);
     const { shape, keys: shapeKeys } = this._getCached();
     const extraKeys = [];
     if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) {
@@ -7174,8 +7183,8 @@ ZodObject.lazycreate = (shape, params) => {
   });
 };
 var ZodUnion = class extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx } = this._processInputParams(input2);
     const options = this._def.options;
     function handleResults(results) {
       for (const result of results) {
@@ -7296,8 +7305,8 @@ var getDiscriminator = (type) => {
   }
 };
 var ZodDiscriminatedUnion = class _ZodDiscriminatedUnion extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx } = this._processInputParams(input2);
     if (ctx.parsedType !== ZodParsedType.object) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -7410,8 +7419,8 @@ function mergeValues(a, b) {
   }
 }
 var ZodIntersection = class extends ZodType {
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { status, ctx } = this._processInputParams(input2);
     const handleParsed = (parsedLeft, parsedRight) => {
       if (isAborted(parsedLeft) || isAborted(parsedRight)) {
         return INVALID;
@@ -7463,8 +7472,8 @@ ZodIntersection.create = (left, right, params) => {
   });
 };
 var ZodTuple = class _ZodTuple extends ZodType {
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { status, ctx } = this._processInputParams(input2);
     if (ctx.parsedType !== ZodParsedType.array) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -7536,8 +7545,8 @@ var ZodRecord = class _ZodRecord extends ZodType {
   get valueSchema() {
     return this._def.valueType;
   }
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { status, ctx } = this._processInputParams(input2);
     if (ctx.parsedType !== ZodParsedType.object) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -7589,8 +7598,8 @@ var ZodMap = class extends ZodType {
   get valueSchema() {
     return this._def.valueType;
   }
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { status, ctx } = this._processInputParams(input2);
     if (ctx.parsedType !== ZodParsedType.map) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -7649,8 +7658,8 @@ ZodMap.create = (keyType, valueType, params) => {
   });
 };
 var ZodSet = class _ZodSet extends ZodType {
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { status, ctx } = this._processInputParams(input2);
     if (ctx.parsedType !== ZodParsedType.set) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -7738,8 +7747,8 @@ var ZodFunction = class _ZodFunction extends ZodType {
     super(...arguments);
     this.validate = this.implement;
   }
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx } = this._processInputParams(input2);
     if (ctx.parsedType !== ZodParsedType.function) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -7842,8 +7851,8 @@ var ZodLazy = class extends ZodType {
   get schema() {
     return this._def.getter();
   }
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx } = this._processInputParams(input2);
     const lazySchema = this._def.getter();
     return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
   }
@@ -7856,9 +7865,9 @@ ZodLazy.create = (getter, params) => {
   });
 };
 var ZodLiteral = class extends ZodType {
-  _parse(input) {
-    if (input.data !== this._def.value) {
-      const ctx = this._getOrReturnCtx(input);
+  _parse(input2) {
+    if (input2.data !== this._def.value) {
+      const ctx = this._getOrReturnCtx(input2);
       addIssueToContext(ctx, {
         received: ctx.data,
         code: ZodIssueCode.invalid_literal,
@@ -7866,7 +7875,7 @@ var ZodLiteral = class extends ZodType {
       });
       return INVALID;
     }
-    return { status: "valid", value: input.data };
+    return { status: "valid", value: input2.data };
   }
   get value() {
     return this._def.value;
@@ -7887,9 +7896,9 @@ function createZodEnum(values, params) {
   });
 }
 var ZodEnum = class _ZodEnum extends ZodType {
-  _parse(input) {
-    if (typeof input.data !== "string") {
-      const ctx = this._getOrReturnCtx(input);
+  _parse(input2) {
+    if (typeof input2.data !== "string") {
+      const ctx = this._getOrReturnCtx(input2);
       const expectedValues = this._def.values;
       addIssueToContext(ctx, {
         expected: util.joinValues(expectedValues),
@@ -7901,8 +7910,8 @@ var ZodEnum = class _ZodEnum extends ZodType {
     if (!this._cache) {
       this._cache = new Set(this._def.values);
     }
-    if (!this._cache.has(input.data)) {
-      const ctx = this._getOrReturnCtx(input);
+    if (!this._cache.has(input2.data)) {
+      const ctx = this._getOrReturnCtx(input2);
       const expectedValues = this._def.values;
       addIssueToContext(ctx, {
         received: ctx.data,
@@ -7911,7 +7920,7 @@ var ZodEnum = class _ZodEnum extends ZodType {
       });
       return INVALID;
     }
-    return OK(input.data);
+    return OK(input2.data);
   }
   get options() {
     return this._def.values;
@@ -7952,9 +7961,9 @@ var ZodEnum = class _ZodEnum extends ZodType {
 };
 ZodEnum.create = createZodEnum;
 var ZodNativeEnum = class extends ZodType {
-  _parse(input) {
+  _parse(input2) {
     const nativeEnumValues = util.getValidEnumValues(this._def.values);
-    const ctx = this._getOrReturnCtx(input);
+    const ctx = this._getOrReturnCtx(input2);
     if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
       const expectedValues = util.objectValues(nativeEnumValues);
       addIssueToContext(ctx, {
@@ -7967,7 +7976,7 @@ var ZodNativeEnum = class extends ZodType {
     if (!this._cache) {
       this._cache = new Set(util.getValidEnumValues(this._def.values));
     }
-    if (!this._cache.has(input.data)) {
+    if (!this._cache.has(input2.data)) {
       const expectedValues = util.objectValues(nativeEnumValues);
       addIssueToContext(ctx, {
         received: ctx.data,
@@ -7976,7 +7985,7 @@ var ZodNativeEnum = class extends ZodType {
       });
       return INVALID;
     }
-    return OK(input.data);
+    return OK(input2.data);
   }
   get enum() {
     return this._def.values;
@@ -7993,8 +8002,8 @@ var ZodPromise = class extends ZodType {
   unwrap() {
     return this._def.type;
   }
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx } = this._processInputParams(input2);
     if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -8026,8 +8035,8 @@ var ZodEffects = class extends ZodType {
   sourceType() {
     return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
   }
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { status, ctx } = this._processInputParams(input2);
     const effect = this._def.effect || null;
     const checkCtx = {
       addIssue: (arg) => {
@@ -8159,12 +8168,12 @@ ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
   });
 };
 var ZodOptional = class extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
+  _parse(input2) {
+    const parsedType = this._getType(input2);
     if (parsedType === ZodParsedType.undefined) {
       return OK(void 0);
     }
-    return this._def.innerType._parse(input);
+    return this._def.innerType._parse(input2);
   }
   unwrap() {
     return this._def.innerType;
@@ -8178,12 +8187,12 @@ ZodOptional.create = (type, params) => {
   });
 };
 var ZodNullable = class extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
+  _parse(input2) {
+    const parsedType = this._getType(input2);
     if (parsedType === ZodParsedType.null) {
       return OK(null);
     }
-    return this._def.innerType._parse(input);
+    return this._def.innerType._parse(input2);
   }
   unwrap() {
     return this._def.innerType;
@@ -8197,8 +8206,8 @@ ZodNullable.create = (type, params) => {
   });
 };
 var ZodDefault = class extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx } = this._processInputParams(input2);
     let data = ctx.data;
     if (ctx.parsedType === ZodParsedType.undefined) {
       data = this._def.defaultValue();
@@ -8222,8 +8231,8 @@ ZodDefault.create = (type, params) => {
   });
 };
 var ZodCatch = class extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx } = this._processInputParams(input2);
     const newCtx = {
       ...ctx,
       common: {
@@ -8275,10 +8284,10 @@ ZodCatch.create = (type, params) => {
   });
 };
 var ZodNaN = class extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
+  _parse(input2) {
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.nan) {
-      const ctx = this._getOrReturnCtx(input);
+      const ctx = this._getOrReturnCtx(input2);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.nan,
@@ -8286,7 +8295,7 @@ var ZodNaN = class extends ZodType {
       });
       return INVALID;
     }
-    return { status: "valid", value: input.data };
+    return { status: "valid", value: input2.data };
   }
 };
 ZodNaN.create = (params) => {
@@ -8297,8 +8306,8 @@ ZodNaN.create = (params) => {
 };
 var BRAND = /* @__PURE__ */ Symbol("zod_brand");
 var ZodBranded = class extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx } = this._processInputParams(input2);
     const data = ctx.data;
     return this._def.type._parse({
       data,
@@ -8311,8 +8320,8 @@ var ZodBranded = class extends ZodType {
   }
 };
 var ZodPipeline = class _ZodPipeline extends ZodType {
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { status, ctx } = this._processInputParams(input2);
     if (ctx.common.async) {
       const handleAsync = async () => {
         const inResult = await this._def.in._parseAsync({
@@ -8366,8 +8375,8 @@ var ZodPipeline = class _ZodPipeline extends ZodType {
   }
 };
 var ZodReadonly = class extends ZodType {
-  _parse(input) {
-    const result = this._def.innerType._parse(input);
+  _parse(input2) {
+    const result = this._def.innerType._parse(input2);
     const freeze = (data) => {
       if (isValid(data)) {
         data.value = Object.freeze(data.value);
@@ -8539,8 +8548,8 @@ var ConfigSchema = external_exports.object({
     installedAt: external_exports.string().optional()
   }).optional()
 });
-var DEFAULT_API_ENDPOINT = "https://api.refly.ai";
-var DEFAULT_WEB_URL = "https://refly.ai";
+var DEFAULT_API_ENDPOINT = "https://refly-api.powerformer.net";
+var DEFAULT_WEB_URL = "https://refly.powerformer.net";
 var DEFAULT_CONFIG = {
   version: 1,
   api: {
@@ -8669,34 +8678,20 @@ function getApiKeyInfo() {
   return void 0;
 }
 
-// src/commands/init.ts
-init_paths();
-
 // src/skill/installer.ts
-init_cjs_shims();
-var fs4 = __toESM(require("fs"));
-var path4 = __toESM(require("path"));
-init_paths();
-init_logger();
 function getPackageSkillDir() {
   const possiblePaths = [
-    path4.join(__dirname, "..", "..", "skill"),
-    // Built package: dist/bin/../../skill
-    path4.join(__dirname, "..", "..", "..", "skill"),
-    // Development: dist/bin/../../../skill
-    path4.join(__dirname, "..", "skill")
-    // Alternative: dist/../skill
+    path3.join(__dirname, "..", "..", "skill"),
+    // Built package
+    path3.join(__dirname, "..", "..", "..", "skill")
+    // Development
   ];
-  logger.debug("Looking for skill files, __dirname:", __dirname);
   for (const p of possiblePaths) {
-    const resolved = path4.resolve(p);
-    const exists = fs4.existsSync(resolved);
-    logger.debug(`  Checking path: ${resolved} - exists: ${exists}`);
-    if (exists) {
-      return resolved;
+    if (fs3.existsSync(p)) {
+      return p;
     }
   }
-  throw new Error(`Skill files not found in package. Searched paths from __dirname=${__dirname}`);
+  throw new Error("Skill files not found in package");
 }
 function installSkill() {
   const result = {
@@ -8707,62 +8702,43 @@ function installSkill() {
     version: getSkillVersion()
   };
   const sourceDir = getPackageSkillDir();
-  logger.debug("Source skill directory:", sourceDir);
   const targetDir = getClaudeSkillDir();
-  logger.debug("Target skill directory:", targetDir);
-  try {
-    ensureDir(targetDir);
-    ensureDir(path4.join(targetDir, "references"));
-    logger.debug("Created target directories");
-  } catch (err) {
-    logger.error("Failed to create target directories:", err);
-    throw err;
-  }
-  const skillSource = path4.join(sourceDir, "SKILL.md");
-  const skillTarget = path4.join(targetDir, "SKILL.md");
-  logger.debug(`Copying SKILL.md: ${skillSource} -> ${skillTarget}`);
-  if (fs4.existsSync(skillSource)) {
-    fs4.copyFileSync(skillSource, skillTarget);
+  ensureDir(targetDir);
+  ensureDir(path3.join(targetDir, "references"));
+  const skillSource = path3.join(sourceDir, "SKILL.md");
+  const skillTarget = path3.join(targetDir, "SKILL.md");
+  if (fs3.existsSync(skillSource)) {
+    fs3.copyFileSync(skillSource, skillTarget);
     result.skillInstalled = true;
     result.skillPath = targetDir;
-    logger.debug("SKILL.md copied successfully");
-  } else {
-    logger.warn("SKILL.md source not found:", skillSource);
   }
-  const refsSource = path4.join(sourceDir, "references");
-  const refsTarget = path4.join(targetDir, "references");
-  if (fs4.existsSync(refsSource)) {
-    const files = fs4.readdirSync(refsSource);
-    logger.debug(`Copying ${files.length} reference files`);
+  const refsSource = path3.join(sourceDir, "references");
+  const refsTarget = path3.join(targetDir, "references");
+  if (fs3.existsSync(refsSource)) {
+    const files = fs3.readdirSync(refsSource);
     for (const file of files) {
-      fs4.copyFileSync(path4.join(refsSource, file), path4.join(refsTarget, file));
+      fs3.copyFileSync(path3.join(refsSource, file), path3.join(refsTarget, file));
     }
   }
   const commandsDir = getClaudeCommandsDir();
-  logger.debug("Commands directory:", commandsDir);
   ensureDir(commandsDir);
   result.commandsInstalled = installSlashCommands(sourceDir, commandsDir);
   if (result.commandsInstalled) {
     result.commandsPath = commandsDir;
   }
-  logger.debug("Commands installed:", result.commandsInstalled);
   updateSkillInfo(result.version);
-  logger.info("Skill installation complete:", {
-    skillInstalled: result.skillInstalled,
-    commandsInstalled: result.commandsInstalled
-  });
   return result;
 }
 function installSlashCommands(sourceDir, targetDir) {
-  const commandsSource = path4.join(sourceDir, "..", "commands");
-  if (!fs4.existsSync(commandsSource)) {
+  const commandsSource = path3.join(sourceDir, "..", "commands");
+  if (!fs3.existsSync(commandsSource)) {
     return false;
   }
   try {
-    const files = fs4.readdirSync(commandsSource);
+    const files = fs3.readdirSync(commandsSource);
     for (const file of files) {
       if (file.endsWith(".md")) {
-        fs4.copyFileSync(path4.join(commandsSource, file), path4.join(targetDir, file));
+        fs3.copyFileSync(path3.join(commandsSource, file), path3.join(targetDir, file));
       }
     }
     return files.length > 0;
@@ -8772,8 +8748,8 @@ function installSlashCommands(sourceDir, targetDir) {
 }
 function getSkillVersion() {
   try {
-    const skillPath = path4.join(getPackageSkillDir(), "SKILL.md");
-    const content = fs4.readFileSync(skillPath, "utf-8");
+    const skillPath = path3.join(getPackageSkillDir(), "SKILL.md");
+    const content = fs3.readFileSync(skillPath, "utf-8");
     const versionMatch = content.match(/version:\s*(\d+\.\d+\.\d+)/);
     if (versionMatch) {
       return versionMatch[1];
@@ -8781,16 +8757,16 @@ function getSkillVersion() {
   } catch {
   }
   try {
-    const pkgPath = path4.join(__dirname, "..", "..", "package.json");
-    const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path3.join(__dirname, "..", "..", "package.json");
+    const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
     return pkg.version;
   } catch {
     return "0.1.0";
   }
 }
 function isSkillInstalled() {
-  const skillPath = path4.join(getClaudeSkillDir(), "SKILL.md");
-  if (!fs4.existsSync(skillPath)) {
+  const skillPath = path3.join(getClaudeSkillDir(), "SKILL.md");
+  if (!fs3.existsSync(skillPath)) {
     return { installed: false, upToDate: false };
   }
   const currentVersion = getSkillVersion();
@@ -8801,41 +8777,8 @@ function isSkillInstalled() {
   };
 }
 
-// src/utils/logo.ts
-init_cjs_shims();
-var REFLY_LOGO = `\u2588\u2580\u2588 \u2588\u2580\u2580 \u2588\u2580\u2580 \u2588   \u2588 \u2588   \u2588\u2580\u2588 \u2588
-\u2588\u2580\u2584 \u2588\u2580\u2580 \u2588\u2580\u2580 \u2588   \u2588\u2584\u2588 \u2580 \u2588\u2580\u2588 \u2588
-\u2580 \u2580 \u2580\u2580\u2580 \u2580   \u2580\u2580\u2580  \u2580    \u2580 \u2580 \u2580`;
-function printLogo(options) {
-  const useColor = options?.color ?? shouldUseColor();
-  const tty = isTTY();
-  if (!tty && !options?.force) {
-    return;
-  }
-  if (useColor) {
-    process.stderr.write(`${Style.TEXT_SUCCESS}${REFLY_LOGO}${Style.RESET}
-`);
-  } else {
-    process.stderr.write(`${REFLY_LOGO}
-`);
-  }
-}
-function printSuccess(message) {
-  process.stderr.write(`${UI.successMsg(message)}
-`);
-}
-function printError2(message) {
-  process.stderr.write(`${UI.errorMsg(message)}
-`);
-}
-function printDim(message) {
-  process.stderr.write(`${UI.dim(message)}
-`);
-}
-function println(message) {
-  process.stderr.write(`${message}
-`);
-}
+// src/commands/init.ts
+init_paths();
 
 // src/commands/login.ts
 init_cjs_shims();
@@ -9282,14 +9225,14 @@ var baseOpen = async (options) => {
   }
   const subprocess = import_node_child_process5.default.spawn(command, cliArguments, childProcessOptions);
   if (options.wait) {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve2, reject) => {
       subprocess.once("error", reject);
       subprocess.once("close", (exitCode) => {
         if (!options.allowNonzeroExitCode && exitCode > 0) {
           reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
-        resolve3(subprocess);
+        resolve2(subprocess);
       });
     });
   }
@@ -9640,7 +9583,7 @@ async function verifyConnection() {
 
 // src/commands/login.ts
 init_logger();
-init_paths();
+var CLI_VERSION = "0.1.0";
 var loginCommand = new Command("login").description("Authenticate with Refly").option("-k, --api-key <key>", "Authenticate using an API key").action(async (options) => {
   try {
     if (options.apiKey) {
@@ -9696,7 +9639,7 @@ async function loginWithDeviceFlow() {
   const initResponse = await apiRequest("/v1/auth/cli/device/init", {
     method: "POST",
     body: {
-      cliVersion: getCliVersion(),
+      cliVersion: CLI_VERSION,
       host: hostname2
     },
     requireAuth: false
@@ -9736,7 +9679,7 @@ async function loginWithDeviceFlow() {
     process.exit(1);
   });
   const webUrl = getWebUrl();
-  const authUrl = `${webUrl}/cli/auth?device_id=${encodeURIComponent(deviceId)}&cli_version=${encodeURIComponent(getCliVersion())}&host=${encodeURIComponent(hostname2)}`;
+  const authUrl = `${webUrl}/cli/auth?device_id=${encodeURIComponent(deviceId)}&cli_version=${encodeURIComponent(CLI_VERSION)}&host=${encodeURIComponent(hostname2)}`;
   process.stderr.write("\n");
   process.stderr.write("To authorize this device, open the following URL in your browser:\n");
   process.stderr.write("\n");
@@ -9851,11 +9794,47 @@ async function getUserInfoFromToken(accessToken) {
   };
 }
 function sleep(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+// src/utils/logo.ts
+init_cjs_shims();
+var REFLY_LOGO = `\u2588\u2580\u2588 \u2588\u2580\u2580 \u2588\u2580\u2580 \u2588   \u2588 \u2588   \u2588\u2580\u2588 \u2588
+\u2588\u2580\u2584 \u2588\u2580\u2580 \u2588\u2580\u2580 \u2588   \u2588\u2584\u2588 \u2580 \u2588\u2580\u2588 \u2588
+\u2580 \u2580 \u2580\u2580\u2580 \u2580   \u2580\u2580\u2580  \u2580    \u2580 \u2580 \u2580`;
+function printLogo(options) {
+  const useColor = options?.color ?? shouldUseColor();
+  const tty = isTTY();
+  if (!tty && !options?.force) {
+    return;
+  }
+  if (useColor) {
+    process.stderr.write(`${Style.TEXT_SUCCESS}${REFLY_LOGO}${Style.RESET}
+`);
+  } else {
+    process.stderr.write(`${REFLY_LOGO}
+`);
+  }
+}
+function printSuccess(message) {
+  process.stderr.write(`${UI.successMsg(message)}
+`);
+}
+function printError2(message) {
+  process.stderr.write(`${UI.errorMsg(message)}
+`);
+}
+function printDim(message) {
+  process.stderr.write(`${UI.dim(message)}
+`);
+}
+function println(message) {
+  process.stderr.write(`${message}
+`);
 }
 
 // src/commands/init.ts
-var DEFAULT_API_ENDPOINT2 = "https://api.refly.ai";
+var DEFAULT_API_ENDPOINT2 = "https://refly-api.powerformer.net";
 var initCommand = new Command("init").description("Initialize Refly CLI, install skill files, and authenticate").option("--force", "Force reinstall even if already installed").option("--host <url>", "API server URL", DEFAULT_API_ENDPOINT2).option("--skip-login", "Skip automatic login after initialization").action(async (options) => {
   try {
     const { force, host, skipLogin } = options;
@@ -9929,23 +9908,22 @@ var initCommand = new Command("init").description("Initialize Refly CLI, install
         printDim("A browser window will open for login.");
         println("");
       }
-      const loginSuccess = await loginWithDeviceFlow();
+      const loginResult = await loginWithDeviceFlow({ emitOutput: false });
       if (pretty && tty) {
-        if (loginSuccess) {
+        if (loginResult.ok) {
           printSuccess("Authentication successful");
-          const user = getAuthUser();
-          if (user?.email) {
-            printDim(`  Welcome, ${user.email}!`);
+          if (loginResult.user?.email) {
+            printDim(`  Welcome, ${loginResult.user.email}!`);
           }
         } else {
           printError2("Authentication was not completed");
           printDim("  Run `refly login` to authenticate later.");
         }
         println("");
-      } else if (!pretty && loginSuccess) {
+      } else if (!pretty && loginResult.ok) {
         print("login", {
           message: "Successfully authenticated",
-          user: getAuthUser()
+          user: loginResult.user
         });
       }
     } else if (pretty && tty) {
@@ -10015,6 +9993,7 @@ var logoutCommand = new Command("logout").description("Logout and remove stored
 // src/commands/status.ts
 init_cjs_shims();
 init_paths();
+var CLI_VERSION2 = "0.1.0";
 var statusCommand = new Command("status").description("Check CLI configuration and authentication status").action(async () => {
   try {
     loadConfig();
@@ -10041,7 +10020,7 @@ var statusCommand = new Command("status").description("Check CLI configuration a
       }
     }
     const payload = {
-      cli_version: getCliVersion(),
+      cli_version: CLI_VERSION2,
       config_dir: getReflyDir(),
       api_endpoint: getApiEndpoint(),
       auth_status: authStatus,
@@ -11319,86 +11298,6 @@ init_cjs_shims();
 
 // src/commands/workflow/create.ts
 init_cjs_shims();
-var SUPPORTED_NODE_TYPES = ["skill", "agent"];
-var UNSUPPORTED_NODE_FIELDS = ["prompt", "instruction", "content", "input"];
-var VARIABLE_PATTERN = /\{\{[^}]+\}\}/;
-function validateSimplifiedSpec(spec) {
-  if (spec.version !== void 0) {
-    return 'Field "version" is not supported in simplified format';
-  }
-  if (spec.metadata !== void 0) {
-    return 'Field "metadata" is not supported in simplified format';
-  }
-  const nodes = spec.nodes;
-  if (!nodes || !Array.isArray(nodes)) {
-    return 'Spec must contain a "nodes" array';
-  }
-  if (nodes.length === 0) {
-    return "Spec must contain at least one node";
-  }
-  for (const node of nodes) {
-    if (!node.id || typeof node.id !== "string") {
-      return 'Each node must have a string "id" field';
-    }
-    if (!node.type || typeof node.type !== "string") {
-      return `Node "${node.id}": must have a string "type" field`;
-    }
-    if (node.type.startsWith("tool:")) {
-      return `Node "${node.id}": type "tool:xxx" is not supported. Use type "skill" with toolsetKeys instead. Example: {"type":"skill","toolsetKeys":["${node.type.replace("tool:", "")}"]}`;
-    }
-    if (node.type === "start") {
-      return `Node "${node.id}": type "start" is not supported. Start node is automatically created`;
-    }
-    if (!SUPPORTED_NODE_TYPES.includes(node.type)) {
-      return `Node "${node.id}": type "${node.type}" is not supported. Use one of: ${SUPPORTED_NODE_TYPES.join(", ")}`;
-    }
-    for (const field of UNSUPPORTED_NODE_FIELDS) {
-      if (node[field] !== void 0) {
-        if (field === "prompt") {
-          return `Node "${node.id}": field "prompt" is not supported. Use "query" instead`;
-        }
-        if (field === "input") {
-          return `Node "${node.id}": field "input" is not supported. Use top-level "query" and "toolsetKeys" instead`;
-        }
-        return `Node "${node.id}": field "${field}" is not supported in simplified format`;
-      }
-    }
-    if (node.query && typeof node.query === "string" && VARIABLE_PATTERN.test(node.query)) {
-      return `Node "${node.id}": variable syntax "{{...}}" is not supported in query field`;
-    }
-    if (node.toolsetKeys !== void 0) {
-      if (!Array.isArray(node.toolsetKeys)) {
-        return `Node "${node.id}": "toolsetKeys" must be an array`;
-      }
-      for (const key of node.toolsetKeys) {
-        if (typeof key !== "string") {
-          return `Node "${node.id}": each item in "toolsetKeys" must be a string`;
-        }
-      }
-    }
-    if (node.dependsOn !== void 0) {
-      if (!Array.isArray(node.dependsOn)) {
-        return `Node "${node.id}": "dependsOn" must be an array`;
-      }
-      for (const dep of node.dependsOn) {
-        if (typeof dep !== "string") {
-          return `Node "${node.id}": each item in "dependsOn" must be a string`;
-        }
-      }
-    }
-  }
-  const nodeIds = new Set(nodes.map((n) => n.id));
-  for (const node of nodes) {
-    if (node.dependsOn) {
-      for (const dep of node.dependsOn) {
-        if (!nodeIds.has(dep)) {
-          return `Node "${node.id}": dependsOn references unknown node "${dep}"`;
-        }
-      }
-    }
-  }
-  return null;
-}
 var workflowCreateCommand = new Command("create").description("Create a workflow from a spec").requiredOption("--name <name>", "Workflow name").requiredOption("--spec <json>", "Workflow spec as JSON").option("--description <description>", "Workflow description").action(async (options) => {
   try {
     let spec;
@@ -11409,14 +11308,6 @@ var workflowCreateCommand = new Command("create").description("Create a workflow
       fail(ErrorCodes.INVALID_INPUT, "Invalid JSON in --spec", {
         hint: "Ensure the spec is valid JSON"
       });
-      return;
-    }
-    const validationError = validateSimplifiedSpec(spec);
-    if (validationError) {
-      fail(ErrorCodes.INVALID_INPUT, validationError, {
-        hint: 'Use simplified format: [{"id":"node1","type":"skill","query":"...","toolsetKeys":["tool_name"],"dependsOn":["other_node"]}]'
-      });
-      return;
     }
     const result = await apiRequest("/v1/cli/workflow", {
       method: "POST",
@@ -11699,33 +11590,159 @@ var workflowDeleteCommand = new Command("delete").description("Delete a workflow
 
 // src/commands/workflow/run.ts
 init_cjs_shims();
-var workflowRunCommand = new Command("run").description("Start a workflow execution").argument("<workflowId>", "Workflow ID to run").option("--input <json>", "Input variables as JSON", "{}").option("--from-node <nodeId>", "Start workflow execution from a specific node (Run From Here)").action(async (workflowId, options) => {
+var readline = __toESM(require("readline/promises"));
+var import_node_process7 = require("process");
+async function confirmAction(question) {
+  const rl = readline.createInterface({ input: import_node_process7.stdin, output: import_node_process7.stdout });
   try {
-    let input;
+    const answer = await rl.question(`${question} (y/N): `);
+    return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function pollToolsStatus(workflowId, maxWaitTime = 15 * 60 * 1e3, pollInterval = 2e3) {
+  const startTime = Date.now();
+  console.log("\nWaiting for tool authorization...");
+  console.log("This may take a few minutes. You can complete the authorization in your browser.");
+  let previousRemainingCount = -1;
+  while (Date.now() - startTime < maxWaitTime) {
     try {
-      input = JSON.parse(options.input);
-    } catch {
-      fail(ErrorCodes.INVALID_INPUT, "Invalid JSON in --input", {
-        hint: "Ensure the input is valid JSON"
-      });
-    }
-    const body = { input };
-    if (options.fromNode) {
-      body.startNodes = [options.fromNode];
+      const result = await apiRequest(
+        `/v1/cli/workflow/${workflowId}/tools-status`
+      );
+      if (result.authorized) {
+        console.log("\n\u2705 All required tools are now authorized!");
+        return true;
+      }
+      const remainingCount = result.unauthorizedTools.length;
+      if (remainingCount !== previousRemainingCount) {
+        console.log(
+          `\u23F3 Still waiting... ${remainingCount} tool${remainingCount > 1 ? "s" : ""} remaining to authorize.`
+        );
+        previousRemainingCount = remainingCount;
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+    } catch (error) {
+      console.log(`
+\u26A0\uFE0F  Failed to check authorization status: ${error.message}`);
+      console.log("Continuing to wait...");
+      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
     }
-    const result = await apiRequest(`/v1/cli/workflow/${workflowId}/run`, {
-      method: "POST",
-      body
+  }
+  console.log("\n\u23F0 Timeout waiting for tool authorization.");
+  return false;
+}
+var promptToOpenBrowser = async (installUrl) => {
+  const isInteractive = process.stdin?.isTTY ?? false;
+  if (!isInteractive) {
+    return false;
+  }
+  const rl = readline.createInterface({ input: import_node_process7.stdin, output: import_node_process7.stdout });
+  try {
+    const answer = await rl.question(
+      `${installUrl}
+Open browser to view workflow tools? (y/N) > `
+    );
+    const normalized = answer.trim().toLowerCase();
+    return normalized === "y" || normalized === "yes";
+  } finally {
+    rl.close();
+  }
+};
+var buildInstallUrl = (workflowId) => {
+  const webUrl = getWebUrl();
+  return `${webUrl}/workflow/${workflowId}/install-tools`;
+};
+async function runWorkflow(workflowId, options) {
+  let input2;
+  try {
+    input2 = JSON.parse(options?.input ?? "{}");
+  } catch {
+    fail(ErrorCodes.INVALID_INPUT, "Invalid JSON in --input", {
+      hint: "Ensure the input is valid JSON"
     });
-    ok("workflow.run", {
-      message: options.fromNode ? `Workflow run started from node ${options.fromNode}` : "Workflow run started",
-      runId: result.runId,
-      workflowId: result.workflowId,
-      status: result.status,
-      startNode: options.fromNode || void 0,
-      createdAt: result.createdAt,
-      nextStep: `Check status with \`refly workflow status ${workflowId}\``
+  }
+  const body = { input: input2 };
+  if (options?.fromNode) {
+    body.startNodes = [options?.fromNode];
+  }
+  const result = await apiRequest(`/v1/cli/workflow/${workflowId}/run`, {
+    method: "POST",
+    body
+  });
+  const unauthorizedTools = Array.isArray(result?.unauthorizedTools) ? result.unauthorizedTools : [];
+  if (unauthorizedTools.length > 0) {
+    const toolNames = unauthorizedTools.map((tool) => tool.toolset?.name ?? "Unknown tool").join(", ");
+    const installUrl = buildInstallUrl(workflowId);
+    const shouldOpenBrowser = await promptToOpenBrowser(installUrl);
+    if (shouldOpenBrowser) {
+      try {
+        await open_default(installUrl);
+        console.log("\u2705 Browser opened successfully!");
+        console.log("");
+        console.log("Please install any required tools in your browser.");
+        console.log("You can close the browser tab and return here when done.");
+        console.log("");
+        const allAuthorized = await pollToolsStatus(workflowId);
+        if (allAuthorized) {
+          console.log("");
+          const shouldRunNow = await confirmAction(
+            "All required tools are authorized now. Run workflow now?"
+          );
+          if (shouldRunNow) {
+            console.log("");
+            console.log("Running workflow...");
+            return await runWorkflow(workflowId, options);
+          } else {
+            console.log("");
+            console.log("Workflow is ready to run. You can run it later with:");
+            console.log(`  refly workflow run ${workflowId}`);
+            return;
+          }
+        } else {
+          console.log("");
+          console.log(
+            "Authorization timed out. You can try again later or install tools manually:"
+          );
+          console.log(`  ${installUrl}`);
+          console.log("");
+          console.log("Then run the workflow with:");
+          console.log(`  refly workflow run ${workflowId}`);
+          process.exit(1);
+        }
+      } catch {
+        console.log("\u274C Could not open browser automatically.");
+        console.log("Please visit this URL manually:");
+        console.log(`  ${installUrl}`);
+        process.exit(1);
+      }
+    }
+    fail(ErrorCodes.EXECUTION_FAILED, `Workflow contains unauthorized tools: ${toolNames}`, {
+      hint: "Open browser to view all workflow tools and install the ones you need",
+      details: {
+        installUrl,
+        unauthorizedTools: unauthorizedTools.map((tool) => ({
+          name: tool.toolset?.name ?? "Unknown tool",
+          type: tool.toolset?.type ?? "unknown",
+          referencedNodes: Array.isArray(tool.referencedNodes) ? tool.referencedNodes.length : 0
+        }))
+      }
     });
+  }
+  ok("workflow.run", {
+    message: options?.fromNode ? `Workflow run started from node ${options?.fromNode}` : "Workflow run started",
+    runId: result.runId,
+    workflowId: result.workflowId,
+    status: result.status,
+    startNode: options?.fromNode || void 0,
+    startedAt: result.startedAt,
+    nextStep: `Check status with \`refly workflow status ${workflowId}\``
+  });
+}
+var workflowRunCommand = new Command("run").description("Start a workflow execution").argument("<workflowId>", "Workflow ID to run").option("--input <json>", "Input variables as JSON", "{}").option("--from-node <nodeId>", "Start workflow execution from a specific node (Run From Here)").action(async (workflowId, options) => {
+  try {
+    await runWorkflow(workflowId, options);
   } catch (error) {
     if (error instanceof CLIError) {
       fail(error.code, error.message, { details: error.details, hint: error.hint });
@@ -11867,7 +11884,7 @@ var workflowStatusCommand = new Command("status").description("Get detailed work
       });
       prevStatus = status;
       while (status.status === "init" || status.status === "executing") {
-        await new Promise((resolve3) => setTimeout(resolve3, pollInterval));
+        await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
         status = await fetchStatus();
         if (options.full || hasStatusChanged(prevStatus, status)) {
           if (options.full) {
@@ -12084,36 +12101,36 @@ var workflowNodesCommand = new Command("nodes").description("List all nodes in a
   try {
     const result = await apiRequest(`/v1/cli/workflow/${workflowId}`);
     const nodes = result.nodes.map((node) => {
-      const output2 = {
+      const output3 = {
         id: node.id,
         type: node.type,
         title: node.data?.title || node.data?.metadata?.title || void 0
       };
       if (options.includePosition && node.position) {
-        output2.position = node.position;
+        output3.position = node.position;
       }
       if (options.includeMetadata && node.data?.metadata) {
-        output2.metadata = node.data.metadata;
+        output3.metadata = node.data.metadata;
       }
-      return output2;
+      return output3;
     });
-    const output = {
+    const output2 = {
       workflowId: result.workflowId,
       workflowName: result.name,
       nodeCount: nodes.length,
       nodes
     };
     if (options.includeEdges && result.edges?.length) {
-      output.edges = result.edges.map((edge) => ({
+      output2.edges = result.edges.map((edge) => ({
         id: edge.id,
         source: edge.source,
         target: edge.target,
         sourceHandle: edge.sourceHandle,
         targetHandle: edge.targetHandle
       }));
-      output.edgeCount = result.edges.length;
+      output2.edgeCount = result.edges.length;
     }
-    ok("workflow.nodes", output);
+    ok("workflow.nodes", output2);
   } catch (error) {
     if (error instanceof CLIError) {
       fail(error.code, error.message, { details: error.details, hint: error.hint });
@@ -12136,7 +12153,7 @@ var workflowNodeGetCommand = new Command("node").description("Get single node in
         hint: `Use 'refly workflow nodes ${workflowId}' to list all nodes`
       });
     }
-    const output = {
+    const output2 = {
       workflowId: result.workflowId,
       workflowName: result.name,
       node: {
@@ -12159,14 +12176,14 @@ var workflowNodeGetCommand = new Command("node").description("Get single node in
         sourceHandle: e.sourceHandle,
         targetHandle: e.targetHandle
       }));
-      output.connections = {
+      output2.connections = {
         incoming,
         outgoing,
         incomingCount: incoming.length,
         outgoingCount: outgoing.length
       };
     }
-    ok("workflow.node", output);
+    ok("workflow.node", output2);
   } catch (error) {
     if (error instanceof CLIError) {
       fail(error.code, error.message, { details: error.details, hint: error.hint });
@@ -12259,12 +12276,12 @@ async function fetchAndCache() {
 init_cjs_shims();
 var nodeRunCommand = new Command("run").description("Run a single node for debugging (currently supports skillResponse only)").requiredOption("--type <nodeType>", 'Node type to run (e.g., "skillResponse")').option("--query <query>", "Query text for skillResponse node").option("--input <json>", "Full input data as JSON (alternative to --query)").option("--config <json>", 'Node configuration as JSON (e.g., {"modelItemId": "..."})').action(async (options) => {
   try {
-    let input = {};
+    let input2 = {};
     if (options.query) {
-      input = { query: options.query };
+      input2 = { query: options.query };
     } else if (options.input) {
       try {
-        input = JSON.parse(options.input);
+        input2 = JSON.parse(options.input);
       } catch {
         fail(ErrorCodes.INVALID_INPUT, "Invalid JSON in --input", {
           hint: "Ensure the input is valid JSON"
@@ -12287,7 +12304,7 @@ var nodeRunCommand = new Command("run").description("Run a single node for debug
       method: "POST",
       body: {
         nodeType: options.type,
-        input,
+        input: input2,
         config
       }
     });
@@ -12338,7 +12355,7 @@ var nodeResultCommand = new Command("result").description("Get node execution re
     }
     const lastStep = result.steps?.[result.steps.length - 1];
     const content = lastStep?.content;
-    const output = {
+    const output2 = {
       resultId: result.resultId,
       version: result.version,
       title: result.title,
@@ -12349,7 +12366,7 @@ var nodeResultCommand = new Command("result").description("Get node execution re
       updatedAt: result.updatedAt
     };
     if (options.includeSteps && result.steps) {
-      output.steps = result.steps.map((step, index) => ({
+      output2.steps = result.steps.map((step, index) => ({
         stepIndex: index,
         name: step.name,
         content: step.content,
@@ -12371,19 +12388,19 @@ var nodeResultCommand = new Command("result").description("Get node execution re
           }
         }
       }
-      output.toolCalls = allToolCalls;
+      output2.toolCalls = allToolCalls;
     }
     if (options.includeMessages && result.messages) {
-      output.messages = result.messages.map((msg) => ({
+      output2.messages = result.messages.map((msg) => ({
         messageId: msg.messageId,
         type: msg.type,
         content: msg.content
       }));
     }
     if (result.errors?.length) {
-      output.errors = result.errors;
+      output2.errors = result.errors;
     }
-    ok("node.result", output);
+    ok("node.result", output2);
   } catch (error) {
     if (error instanceof CLIError) {
       fail(error.code, error.message, { details: error.details, hint: error.hint });