@powerformer/refly-cli 0.1.17 → 0.1.19

package/dist/bin/refly.js

@@ -3392,11 +3392,17 @@ function initializeBaseSkillSymlink() {
   ensureDir(path4.join(baseDir, "rules"));
   return createSkillSymlink("refly");
 }
-function createReflySkillWithSymlink(skillName, skillMdContent) {
+function createReflySkillWithSymlink(skillName, skillMdContent, options) {
   const skillDir = getReflyDomainSkillDir(skillName);
   try {
     ensureReflySkillsDir();
     if (fs4.existsSync(skillDir)) {
+      if (options?.force) {
+        const skillMdPath2 = path4.join(skillDir, "SKILL.md");
+        fs4.writeFileSync(skillMdPath2, skillMdContent, { encoding: "utf-8", mode: 420 });
+        logger.debug(`Updated SKILL.md (force): ${skillMdPath2}`);
+        return createSkillSymlink(skillName);
+      }
       return {
         success: false,
         skillName,
@@ -4881,7 +4887,9 @@ var ErrorCodes = {
   CONFLICT: "CONFLICT",
   PERMISSION_DENIED: "PERMISSION_DENIED",
   INVALID_INPUT: "INVALID_INPUT",
-  INTERNAL_ERROR: "INTERNAL_ERROR"
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+  // Variables
+  MISSING_VARIABLES: "MISSING_VARIABLES"
 };
 
 // src/bin/refly.ts
@@ -10252,6 +10260,22 @@ async function apiUploadDriveFile(filePath, canvasId, options) {
     throw error;
   }
 }
+async function apiGetWorkflowVariables(canvasId) {
+  return apiRequest("/v1/canvas/workflow/variables", {
+    query: { canvasId }
+  });
+}
+async function apiUpdateWorkflowVariables(canvasId, variables) {
+  return apiRequest("/v1/canvas/workflow/variables", {
+    method: "POST",
+    body: { canvasId, variables }
+  });
+}
+async function apiGetActionResult(resultId) {
+  return apiRequest("/v1/cli/action/result", {
+    query: { resultId }
+  });
+}
 
 // src/commands/login.ts
 init_logger();
@@ -10726,7 +10750,7 @@ var import_node_child_process6 = require("child_process");
 var import_node_fs5 = __toESM(require("fs"));
 init_logger();
 init_paths();
-var CLI_VERSION = "0.1.17";
+var CLI_VERSION = "0.1.19";
 var NPM_TAG = "test";
 function compareSemver(a, b) {
   const parseVersion = (v) => {
@@ -11362,7 +11386,7 @@ var workflowDeleteCommand = new Command("delete").description("Delete a workflow
 init_cjs_shims();
 var readline2 = __toESM(require("readline/promises"));
 var import_node_process8 = require("process");
-var path10 = __toESM(require("path"));
+var path9 = __toESM(require("path"));
 
 // src/utils/prompt.ts
 init_cjs_shims();
@@ -11412,33 +11436,157 @@ async function promptForFilePath(variableName, resourceTypes, isRequired) {
 
 // src/utils/file-type.ts
 init_cjs_shims();
-var path9 = __toESM(require("path"));
+var CODE_FILE_EXTENSIONS = [
+  // TypeScript/JavaScript
+  "ts",
+  "tsx",
+  "js",
+  "jsx",
+  "mjs",
+  "cjs",
+  // Web
+  "css",
+  "scss",
+  "sass",
+  "less",
+  // Other programming languages
+  "py",
+  "java",
+  "c",
+  "cpp",
+  "h",
+  "hpp",
+  "cs",
+  "go",
+  "rs",
+  "rb",
+  "php",
+  "swift",
+  "kt",
+  "scala",
+  "sh",
+  "bash",
+  "zsh",
+  // Config files
+  "json",
+  "yaml",
+  "yml",
+  "toml",
+  "xml",
+  "ini",
+  "env",
+  // Text and document files
+  "txt",
+  "md",
+  "markdown"
+];
 var IMAGE_EXTENSIONS = ["jpg", "jpeg", "png", "gif", "webp", "svg", "bmp", "ico", "tiff", "tif"];
 var VIDEO_EXTENSIONS = ["mp4", "webm", "mov", "avi", "mkv", "flv", "wmv", "m4v"];
-var AUDIO_EXTENSIONS = ["mp3", "wav", "ogg", "flac", "m4a", "aac", "wma", "opus"];
-function determineFileType(filePath, mimeType) {
-  const ext = path9.extname(filePath).slice(1).toLowerCase();
-  if (IMAGE_EXTENSIONS.includes(ext)) {
-    return "image";
-  }
-  if (VIDEO_EXTENSIONS.includes(ext)) {
-    return "video";
-  }
-  if (AUDIO_EXTENSIONS.includes(ext)) {
-    return "audio";
-  }
+var AUDIO_EXTENSIONS = ["mp3", "wav", "ogg", "flac", "m4a", "aac", "wma", "opus", "mpga"];
+function getFileExtension(filename) {
+  const lastDotIndex = filename.lastIndexOf(".");
+  if (lastDotIndex === -1 || lastDotIndex === filename.length - 1) {
+    return "";
+  }
+  return filename.slice(lastDotIndex + 1).toLowerCase();
+}
+function getFileCategoryByName(filename, mimeType) {
+  const extension = getFileExtension(filename);
+  if (CODE_FILE_EXTENSIONS.includes(extension)) {
+    return "document";
+  }
+  if (IMAGE_EXTENSIONS.includes(extension)) return "image";
+  if (VIDEO_EXTENSIONS.includes(extension)) return "video";
+  if (AUDIO_EXTENSIONS.includes(extension)) return "audio";
   if (mimeType) {
-    if (mimeType.startsWith("image/")) {
-      return "image";
-    }
-    if (mimeType.startsWith("video/")) {
-      return "video";
+    const mimeTypePrefix = mimeType.split("/")[0].toLowerCase();
+    if (mimeTypePrefix === "image") return "image";
+    if (mimeTypePrefix === "audio") return "audio";
+    if (mimeTypePrefix === "video") return "video";
+  }
+  return "document";
+}
+function getFileCategoryByMimeType(mimeType) {
+  if (mimeType.startsWith("image/")) return "image";
+  if (mimeType.startsWith("video/")) return "video";
+  if (mimeType.startsWith("audio/")) return "audio";
+  if (mimeType === "application/pdf") return "document";
+  if (mimeType.includes("word") || mimeType.includes("document")) return "document";
+  if (mimeType.includes("sheet") || mimeType.includes("excel")) return "document";
+  if (mimeType.includes("presentation") || mimeType.includes("powerpoint")) return "document";
+  if (mimeType.startsWith("text/")) return "document";
+  return "document";
+}
+
+// src/utils/variable-check.ts
+init_cjs_shims();
+function checkRequiredVariables(definitions, providedInput) {
+  const missing = [];
+  const suggestedInput = { ...providedInput };
+  for (const def of definitions) {
+    if (!def.required) continue;
+    const key = def.name;
+    const hasValue = key in providedInput && providedInput[key] !== void 0 && providedInput[key] !== null;
+    if (!hasValue) {
+      missing.push(def);
+      if (def.default !== void 0) {
+        suggestedInput[key] = def.default;
+      } else {
+        suggestedInput[key] = "<value>";
+      }
     }
-    if (mimeType.startsWith("audio/")) {
-      return "audio";
+  }
+  return {
+    valid: missing.length === 0,
+    missing,
+    suggestedInput
+  };
+}
+function buildMissingVariablesError(commandType, targetId, targetName, result) {
+  const displayName = targetName ? `"${targetName}"` : targetId;
+  const inputJson = JSON.stringify(result.suggestedInput);
+  const suggestedCommand = commandType === "workflow" ? `refly workflow run ${targetId} --input '${inputJson}'` : `refly skill run --name <name> --input '${inputJson}'`;
+  return {
+    code: "MISSING_VARIABLES",
+    message: `Missing required variables for ${commandType} ${displayName}`,
+    details: {
+      missingVariables: result.missing.map((v) => ({
+        name: v.name,
+        type: v.variableType || "string",
+        required: true,
+        default: v.default,
+        description: v.description
+      })),
+      suggestedInput: result.suggestedInput,
+      suggestedCommand
+    },
+    hint: "Provide the missing variables via --input. See suggestedInput for the expected format.",
+    suggestedFix: {
+      field: "--input",
+      format: "json-object",
+      example: inputJson
+    },
+    recoverable: true
+  };
+}
+function variablesToObject(variables) {
+  const result = {};
+  for (const v of variables) {
+    if (!v.value || v.value.length === 0) continue;
+    const firstValue = v.value[0];
+    if (typeof firstValue === "object" && firstValue !== null) {
+      if ("resource" in firstValue && typeof firstValue.resource === "object") {
+        result[v.name] = firstValue;
+      } else if ("text" in firstValue) {
+        result[v.name] = firstValue.text;
+      } else {
+        result[v.name] = firstValue;
+      }
+    } else {
+      result[v.name] = firstValue;
     }
   }
-  return "document";
+  return result;
 }
 
 // src/commands/workflow/run.ts
@@ -11511,6 +11659,11 @@ async function collectFileVariables(workflowId, existingInput, noPrompt) {
   } catch (_error) {
     return [];
   }
+  let savedVariables = [];
+  try {
+    savedVariables = await apiGetWorkflowVariables(workflowId);
+  } catch (_error) {
+  }
   const resourceVars = (workflow.variables ?? []).filter(
     (v) => v.variableType === "resource" && v.required === true
   );
@@ -11518,33 +11671,35 @@ async function collectFileVariables(workflowId, existingInput, noPrompt) {
     return [];
   }
   const invalidFormatVars = [];
+  const hasValidFileValue = (variable) => {
+    if (!variable) return false;
+    const values = variable.value;
+    if (!Array.isArray(values) || values.length === 0) return false;
+    return values.some((val) => {
+      const fileId = val?.resource?.fileId || val?.fileId;
+      return typeof fileId === "string" && fileId.length > 0;
+    });
+  };
   const missingVars = resourceVars.filter((v) => {
-    const provided = existingInput.find(
+    const providedInInput = existingInput.find(
       (input3) => v.variableId && input3.variableId === v.variableId || v.name && input3.name === v.name
     );
-    if (!provided) {
-      return true;
-    }
-    const values = provided.value;
-    if (!Array.isArray(values) || values.length === 0) {
+    const savedValue = savedVariables.find(
+      (saved) => v.variableId && saved.variableId === v.variableId || v.name && saved.name === v.name
+    );
+    if (providedInInput) {
+      if (hasValidFileValue(providedInInput)) {
+        return false;
+      }
       invalidFormatVars.push({
         name: v.name,
-        reason: "value must be an array with at least one file"
+        reason: "invalid format in --input"
       });
-      return true;
     }
-    const hasValidFileId = values.some((val) => {
-      const fileId = val?.resource?.fileId || val?.fileId;
-      return typeof fileId === "string" && fileId.length > 0;
-    });
-    if (!hasValidFileId) {
-      invalidFormatVars.push({
-        name: v.name,
-        reason: "no valid fileId found in value"
-      });
-      return true;
+    if (hasValidFileValue(savedValue)) {
+      return false;
     }
-    return false;
+    return true;
   });
   if (missingVars.length === 0) {
     return [];
@@ -11581,7 +11736,7 @@ ${details}`;
     if (!filePath) {
       continue;
     }
-    const filename = path10.basename(filePath);
+    const filename = path9.basename(filePath);
     process.stdout.write(`  Uploading ${filename}...`);
     try {
       const uploadResult = await apiUploadDriveFile(filePath, workflowId);
@@ -11590,7 +11745,7 @@ ${details}`;
         type: "resource",
         resource: {
           name: uploadResult.name,
-          fileType: determineFileType(filePath, uploadResult.type),
+          fileType: getFileCategoryByName(filePath, uploadResult.type),
           fileId: uploadResult.fileId,
           storageKey: uploadResult.storageKey
         }
@@ -11641,7 +11796,7 @@ function convertKeyValueToVariables(obj, workflow) {
       }
       variables.push({
         variableId: varDef?.variableId,
-        name,
+        name: varDef?.name || name,
         variableType: "resource",
         value: fileValues,
         required: varDef?.required
@@ -11655,7 +11810,7 @@ function convertKeyValueToVariables(obj, workflow) {
       }
       variables.push({
         variableId: varDef?.variableId,
-        name,
+        name: varDef?.name || name,
         variableType: "string",
         value,
         required: varDef?.required
@@ -11693,6 +11848,24 @@ async function runWorkflow(workflowId, options) {
     });
     return;
   }
+  if (options?.noPrompt && workflow?.variables) {
+    const inputObject = variablesToObject(inputVars);
+    const checkResult = checkRequiredVariables(workflow.variables, inputObject);
+    if (!checkResult.valid) {
+      const errorPayload = buildMissingVariablesError(
+        "workflow",
+        workflowId,
+        workflow.name,
+        checkResult
+      );
+      fail(ErrorCodes.MISSING_VARIABLES, errorPayload.message, {
+        details: errorPayload.details,
+        hint: errorPayload.hint,
+        suggestedFix: errorPayload.suggestedFix,
+        recoverable: errorPayload.recoverable
+      });
+    }
+  }
   const uploadedVars = await collectFileVariables(
     workflowId,
     inputVars,
@@ -12207,9 +12380,12 @@ var workflowLayoutCommand = new Command("layout").description("Auto-layout workf
   }
 });
 
-// src/commands/workflow/nodes.ts
+// src/commands/workflow/node/index.ts
 init_cjs_shims();
-var workflowNodesCommand = new Command("nodes").description("List all nodes in a workflow").argument("<workflowId>", "Workflow ID").option("--include-edges", "Include edge/connection information").option("--include-position", "Include node position coordinates").option("--include-metadata", "Include full node metadata").action(async (workflowId, options) => {
+
+// src/commands/workflow/node/list.ts
+init_cjs_shims();
+var nodeListCommand = new Command("list").description("List all nodes in a workflow").argument("<workflowId>", "Workflow ID").option("--include-edges", "Include edge/connection information").option("--include-position", "Include node position coordinates").option("--include-metadata", "Include full node metadata").action(async (workflowId, options) => {
   try {
     const result = await apiRequest(`/v1/cli/workflow/${workflowId}`);
     const nodes = result.nodes.map((node) => {
@@ -12242,12 +12418,13 @@ var workflowNodesCommand = new Command("nodes").description("List all nodes in a
       }));
       output3.edgeCount = result.edges.length;
     }
-    ok("workflow.nodes", output3);
+    ok("workflow.node.list", output3);
   } catch (error) {
     if (error instanceof CLIError) {
+      const hint = error.hint?.replace(/<workflowId>/g, workflowId);
       fail(error.code, error.message, {
         details: error.details,
-        hint: error.hint,
+        hint,
         suggestedFix: error.suggestedFix
       });
     }
@@ -12258,9 +12435,9 @@ var workflowNodesCommand = new Command("nodes").description("List all nodes in a
   }
 });
 
-// src/commands/workflow/node-get.ts
+// src/commands/workflow/node/get.ts
 init_cjs_shims();
-var workflowNodeGetCommand = new Command("node").description("Get single node information from a workflow").argument("<id>", "Workflow ID (c-xxx) or Run ID (we-xxx)").argument("<nodeId>", "Node ID").option("--include-connections", "Include incoming and outgoing connections").action(async (id, nodeId, options) => {
+var nodeGetCommand = new Command("get").description("Get single node information from a workflow").argument("<id>", "Workflow ID (c-xxx) or Run ID (we-xxx)").argument("<nodeId>", "Node ID").option("--include-connections", "Include incoming and outgoing connections").action(async (id, nodeId, options) => {
   try {
     const idType = detectIdType2(id);
     let workflowId = id;
@@ -12272,7 +12449,7 @@ var workflowNodeGetCommand = new Command("node").description("Get single node in
     const node = result.nodes.find((n) => n.id === nodeId);
     if (!node) {
       fail(ErrorCodes.NODE_NOT_FOUND, `Node ${nodeId} not found in workflow ${workflowId}`, {
-        hint: `Use 'refly workflow nodes ${id}' to list all nodes`
+        hint: `Use 'refly workflow node list ${id}' to list all nodes`
       });
     }
     const output3 = {
@@ -12307,12 +12484,13 @@ var workflowNodeGetCommand = new Command("node").description("Get single node in
         outgoingCount: outgoing.length
       };
     }
-    ok("workflow.node", output3);
+    ok("workflow.node.get", output3);
   } catch (error) {
     if (error instanceof CLIError) {
+      const hint = error.hint?.replace(/<workflowId>/g, id).replace(/<id>/g, id).replace(/<nodeId>/g, nodeId);
       fail(error.code, error.message, {
         details: error.details,
-        hint: error.hint,
+        hint,
         suggestedFix: error.suggestedFix
       });
     }
@@ -12323,9 +12501,9 @@ var workflowNodeGetCommand = new Command("node").description("Get single node in
   }
 });
 
-// src/commands/workflow/node-add.ts
+// src/commands/workflow/node/add.ts
 init_cjs_shims();
-var workflowNodeAddCommand = new Command("node-add").description("Add a node to a workflow").argument("<workflowId>", "Workflow ID (c-xxx)").requiredOption("--type <type>", "Node type (skillResponse, start, document, resource, memo)").option("--id <nodeId>", "Custom node ID (auto-generated if not provided)").option("--query <query>", "Query/prompt for the node").option("--title <title>", "Node title").option("--toolset-keys <keys>", 'Comma-separated toolset keys (e.g., "web_search,execute_code")').option("--position <x,y>", 'Node position as "x,y" (default: 0,0)').option("--connect-from <nodeId>", "Connect from this node (creates edge)").option("--connect-to <nodeId>", "Connect to this node (creates edge)").option("--resolve-toolset-keys", "Resolve toolset keys to full IDs").option("--auto-layout", "Enable auto-layout to prevent overlapping").action(async (workflowId, options) => {
+var nodeAddCommand = new Command("add").description("Add a node to a workflow").argument("<workflowId>", "Workflow ID (c-xxx)").requiredOption("--type <type>", "Node type (skillResponse, start, document, resource, memo)").option("--id <nodeId>", "Custom node ID (auto-generated if not provided)").option("--query <query>", "Query/prompt for the node").option("--title <title>", "Node title").option("--toolset-keys <keys>", 'Comma-separated toolset keys (e.g., "web_search,execute_code")').option("--position <x,y>", 'Node position as "x,y" (default: 0,0)').option("--connect-from <nodeId>", "Connect from this node (creates edge)").option("--connect-to <nodeId>", "Connect to this node (creates edge)").option("--resolve-toolset-keys", "Resolve toolset keys to full IDs").option("--auto-layout", "Enable auto-layout to prevent overlapping").action(async (workflowId, options) => {
   if (!workflowId.startsWith("c-")) {
     fail(ErrorCodes.INVALID_INPUT, `Invalid workflow ID: ${workflowId}`, {
       hint: 'Workflow ID should start with "c-"',
@@ -12424,15 +12602,16 @@ var workflowNodeAddCommand = new Command("node-add").description("Add a node to
       ...options.connectFrom && { connectedFrom: options.connectFrom },
       ...options.connectTo && { connectedTo: options.connectTo },
       nextSteps: [
-        `View node: \`refly workflow node ${workflowId} ${nodeId}\``,
-        `List all nodes: \`refly workflow nodes ${workflowId}\``
+        `View node: \`refly workflow node get ${workflowId} ${nodeId}\``,
+        `List all nodes: \`refly workflow node list ${workflowId}\``
       ]
     });
   } catch (error) {
     if (error instanceof CLIError) {
+      const hint = error.hint?.replace(/<workflowId>/g, workflowId);
       fail(error.code, error.message, {
         details: error.details,
-        hint: error.hint,
+        hint,
         suggestedFix: error.suggestedFix
       });
       return;
@@ -12444,9 +12623,9 @@ var workflowNodeAddCommand = new Command("node-add").description("Add a node to
   }
 });
 
-// src/commands/workflow/node-update.ts
+// src/commands/workflow/node/update.ts
 init_cjs_shims();
-var workflowNodeUpdateCommand = new Command("node-update").description("Update a node in a workflow").argument("<workflowId>", "Workflow ID (c-xxx)").argument("<nodeId>", "Node ID to update").option("--query <query>", "Update the query/prompt for the node").option("--title <title>", "Update the node title").option("--toolset-keys <keys>", 'Comma-separated toolset keys (e.g., "web_search,execute_code")').option("--data <json>", "Full node data as JSON (advanced usage)").option("--resolve-toolset-keys", "Resolve toolset keys to full IDs").action(async (workflowId, nodeId, options) => {
+var nodeUpdateCommand = new Command("update").description("Update a node in a workflow").argument("<workflowId>", "Workflow ID (c-xxx)").argument("<nodeId>", "Node ID to update").option("--query <query>", "Update the query/prompt for the node").option("--title <title>", "Update the node title").option("--toolset-keys <keys>", 'Comma-separated toolset keys (e.g., "web_search,execute_code")').option("--data <json>", "Full node data as JSON (advanced usage)").option("--resolve-toolset-keys", "Resolve toolset keys to full IDs").action(async (workflowId, nodeId, options) => {
   if (!workflowId.startsWith("c-")) {
     fail(ErrorCodes.INVALID_INPUT, `Invalid workflow ID: ${workflowId}`, {
       hint: 'Workflow ID should start with "c-"',
@@ -12536,15 +12715,16 @@ var workflowNodeUpdateCommand = new Command("node-update").description("Update a
         ...options.data && { data: "custom data applied" }
       },
       nextSteps: [
-        `View updated node: \`refly workflow node ${workflowId} ${nodeId}\``,
-        `List all nodes: \`refly workflow nodes ${workflowId}\``
+        `View updated node: \`refly workflow node get ${workflowId} ${nodeId}\``,
+        `List all nodes: \`refly workflow node list ${workflowId}\``
       ]
     });
   } catch (error) {
     if (error instanceof CLIError) {
+      const hint = error.hint?.replace(/<workflowId>/g, workflowId).replace(/<nodeId>/g, nodeId);
       fail(error.code, error.message, {
         details: error.details,
-        hint: error.hint,
+        hint,
         suggestedFix: error.suggestedFix
       });
       return;
@@ -12556,9 +12736,9 @@ var workflowNodeUpdateCommand = new Command("node-update").description("Update a
   }
 });
 
-// src/commands/workflow/node-delete.ts
+// src/commands/workflow/node/delete.ts
 init_cjs_shims();
-var workflowNodeDeleteCommand = new Command("node-delete").description("Delete a node from a workflow").argument("<workflowId>", "Workflow ID (c-xxx)").argument("<nodeId>", "Node ID to delete").action(async (workflowId, nodeId) => {
+var nodeDeleteCommand = new Command("delete").description("Delete a node from a workflow").argument("<workflowId>", "Workflow ID (c-xxx)").argument("<nodeId>", "Node ID to delete").action(async (workflowId, nodeId) => {
   if (!workflowId.startsWith("c-")) {
     fail(ErrorCodes.INVALID_INPUT, `Invalid workflow ID: ${workflowId}`, {
       hint: 'Workflow ID should start with "c-"',
@@ -12588,13 +12768,14 @@ var workflowNodeDeleteCommand = new Command("node-delete").description("Delete a
       workflowId,
       nodeId,
       note: "Connected edges were also removed",
-      nextSteps: [`List remaining nodes: \`refly workflow nodes ${workflowId}\``]
+      nextSteps: [`List remaining nodes: \`refly workflow node list ${workflowId}\``]
     });
   } catch (error) {
     if (error instanceof CLIError) {
+      const hint = error.hint?.replace(/<workflowId>/g, workflowId).replace(/<nodeId>/g, nodeId);
       fail(error.code, error.message, {
         details: error.details,
-        hint: error.hint,
+        hint,
         suggestedFix: error.suggestedFix
       });
       return;
@@ -12606,9 +12787,9 @@ var workflowNodeDeleteCommand = new Command("node-delete").description("Delete a
   }
 });
 
-// src/commands/workflow/node-output.ts
+// src/commands/workflow/node/output.ts
 init_cjs_shims();
-var workflowNodeOutputCommand = new Command("node-output").description("Get node execution output content").argument("<id>", "Workflow ID (c-xxx) or Run ID (we-xxx)").argument("<nodeId>", "Node ID").option("--include-tool-calls", "Include tool call details in output").option("--raw", "Output raw content without formatting").action(async (id, nodeId, options) => {
+var nodeOutputCommand = new Command("output").description("Get node execution output content").argument("<id>", "Workflow ID (c-xxx) or Run ID (we-xxx)").argument("<nodeId>", "Node ID").option("--include-tool-calls", "Include tool call details in output").option("--raw", "Output raw content without formatting").action(async (id, nodeId, options) => {
   try {
     const params = new URLSearchParams();
     if (options.includeToolCalls) {
@@ -12620,7 +12801,7 @@ var workflowNodeOutputCommand = new Command("node-output").description("Get node
     const idType = detectIdType2(id);
     const url = buildWorkflowApiUrl(id, `node/${nodeId}/output`, params);
     const result = await apiRequest(url);
-    ok("workflow.nodeOutput", {
+    ok("workflow.node.output", {
       runId: result.runId,
       workflowId: result.workflowId,
       idType,
@@ -12641,9 +12822,10 @@ var workflowNodeOutputCommand = new Command("node-output").description("Get node
     });
   } catch (error) {
     if (error instanceof CLIError) {
+      const hint = error.hint?.replace(/<workflowId>/g, id).replace(/<id>/g, id);
       fail(error.code, error.message, {
         details: error.details,
-        hint: error.hint,
+        hint,
         suggestedFix: error.suggestedFix
       });
     }
@@ -12651,140 +12833,412 @@ var workflowNodeOutputCommand = new Command("node-output").description("Get node
       ErrorCodes.INTERNAL_ERROR,
       error instanceof Error ? error.message : "Failed to get node output",
       {
-        hint: "Ensure the node has completed execution. Use `refly workflow status <id>` to check."
+        hint: `Ensure the node has completed execution. Use \`refly workflow status ${id}\` to check.`
       }
     );
   }
 });
 
+// src/commands/workflow/node/index.ts
+var workflowNodeCommand = new Command("node").description("Manage workflow nodes").addCommand(nodeListCommand).addCommand(nodeGetCommand).addCommand(nodeAddCommand).addCommand(nodeUpdateCommand).addCommand(nodeDeleteCommand).addCommand(nodeOutputCommand);
+
 // src/commands/workflow/edit.ts
 init_cjs_shims();
-var fs14 = __toESM(require("fs"));
-var workflowEditCommand = new Command("edit").description("Edit a workflow plan using semantic operations").argument("<planId>", "Workflow Plan ID").option("--ops <json>", "Operations array as JSON").option("--ops-file <path>", "Read operations from file").option("--update-title <title>", "Shortcut: update workflow title").option("--delete-task <taskId>", "Shortcut: delete a task").option("--delete-variable <variableId>", "Shortcut: delete a variable").action(async (planId, options) => {
+var workflowEditCommand = new Command("edit").description("Edit a workflow using natural language").argument("<id>", "Canvas ID (c-xxx)").option("--query <text>", "Edit instruction in natural language").option("--session-id <id>", "Session ID (cs-xxx) for context continuity").option("--timeout <ms>", "Timeout for AI processing", "60000").action(async (id, options) => {
   try {
-    const operations = [];
-    const opsFormatHint = `Operations format: '[{"op": "updateTitle", "title": "New Title"}]'
-Available ops: updateTitle, createTask, updateTask, deleteTask, createVariable, updateVariable, deleteVariable
-Examples:
-  - Update title: {"op": "updateTitle", "title": "New Title"}
-  - Delete task: {"op": "deleteTask", "taskId": "task-id"}
-  - Update task: {"op": "updateTask", "taskId": "task-id", "data": {"prompt": "new prompt"}}`;
-    if (options.opsFile) {
-      try {
-        const filePath = options.opsFile;
-        if (!fs14.existsSync(filePath)) {
-          fail(ErrorCodes.NOT_FOUND, `Operations file not found: ${filePath}`);
-        }
-        const fileContent = fs14.readFileSync(filePath, "utf-8");
-        const fileOps = JSON.parse(fileContent);
-        if (Array.isArray(fileOps)) {
-          operations.push(...fileOps);
-        } else {
-          fail(ErrorCodes.INVALID_INPUT, "Operations file must contain a JSON array", {
-            hint: opsFormatHint,
-            suggestedFix: {
-              field: "--ops-file",
-              format: "json-array",
-              example: '[{"op": "updateTitle", "title": "New Title"}]'
-            }
-          });
+    if (!options.query) {
+      fail(ErrorCodes.INVALID_INPUT, "--query is required", {
+        hint: "Provide a natural language description of the edit you want to make",
+        suggestedFix: {
+          field: "--query",
+          format: "string",
+          example: 'refly workflow edit c-xxx --query "\u6DFB\u52A0\u4E00\u4E2A\u7528 nano banana \u751F\u6210\u56FE\u7247\u7684\u4EFB\u52A1"'
         }
-      } catch (error) {
-        if (error instanceof CLIError) throw error;
-        fail(
-          ErrorCodes.INVALID_INPUT,
-          `Failed to parse operations file: ${error.message}`,
-          {
-            hint: opsFormatHint,
-            suggestedFix: {
-              field: "--ops-file",
-              format: "json-array",
-              example: '[{"op": "updateTitle", "title": "New Title"}]'
-            }
-          }
-        );
+      });
+    }
+    if (!id.startsWith("c-")) {
+      fail(ErrorCodes.INVALID_INPUT, "Only Canvas ID (c-xxx) is supported", {
+        hint: 'Use the Canvas ID format starting with "c-"',
+        suggestedFix: {
+          field: "id",
+          format: "canvas-id",
+          example: "c-abc123"
+        }
+      });
+    }
+    const timeout = Number.parseInt(options.timeout);
+    const response = await apiRequest(
+      "/v1/cli/workflow/edit",
+      {
+        method: "POST",
+        body: {
+          canvasId: id,
+          query: options.query,
+          sessionId: options.sessionId,
+          timeout
+        },
+        timeout: timeout + 5e3
+        // Add buffer for network
+      }
+    );
+    const result = response.data ?? response;
+    ok("workflow.edit", {
+      canvasId: result.canvasId,
+      planId: result.planId,
+      version: result.version,
+      toolUsed: result.toolUsed,
+      sessionId: result.sessionId,
+      plan: {
+        title: result.plan.title,
+        taskCount: result.plan.tasks?.length ?? 0,
+        variableCount: result.plan.variables?.length ?? 0,
+        tasks: result.plan.tasks?.map((t) => ({
+          id: t.id,
+          title: t.title
+        })),
+        variables: result.plan.variables?.map((v) => ({
+          variableId: v.variableId,
+          name: v.name
+        }))
       }
+    });
+  } catch (error) {
+    if (error instanceof CLIError) {
+      fail(error.code, error.message, {
+        details: error.details,
+        hint: error.hint,
+        suggestedFix: error.suggestedFix
+      });
     }
-    if (options.ops) {
-      try {
-        const jsonOps = JSON.parse(options.ops);
-        if (Array.isArray(jsonOps)) {
-          operations.push(...jsonOps);
-        } else {
-          fail(ErrorCodes.INVALID_INPUT, "--ops must be a JSON array", {
-            hint: opsFormatHint,
+    fail(
+      ErrorCodes.INTERNAL_ERROR,
+      error instanceof Error ? error.message : "Failed to edit workflow"
+    );
+  }
+});
+
+// src/commands/workflow/variables.ts
+init_cjs_shims();
+async function getFileMetadata(fileId) {
+  try {
+    return await apiRequest(`/v1/cli/drive/files/${fileId}?includeContent=false`);
+  } catch {
+    return null;
+  }
+}
+function parseVarArgs(varArgs) {
+  const result = {};
+  for (const arg of varArgs) {
+    const eqIndex = arg.indexOf("=");
+    if (eqIndex === -1) {
+      throw new CLIError(
+        ErrorCodes.INVALID_INPUT,
+        `Invalid --var format: "${arg}"`,
+        void 0,
+        "Use format: --var key=value"
+      );
+    }
+    const key = arg.slice(0, eqIndex);
+    const value = arg.slice(eqIndex + 1);
+    result[key] = value;
+  }
+  return result;
+}
+function formatVariable(v) {
+  const hasValue = Array.isArray(v.value) && v.value.length > 0;
+  return {
+    name: v.name,
+    variableId: v.variableId,
+    type: v.variableType || "string",
+    required: v.required ?? false,
+    hasValue,
+    value: hasValue ? v.value : void 0,
+    description: v.description
+  };
+}
+var variablesListCommand = new Command("list").description("List workflow variables with current values").argument("<workflowId>", "Workflow ID (canvas ID)").action(async (workflowId) => {
+  try {
+    const variables = await apiGetWorkflowVariables(workflowId);
+    const formatted = variables.map(formatVariable);
+    ok("workflow.variables.list", {
+      workflowId,
+      variables: formatted,
+      count: variables.length
+    });
+  } catch (error) {
+    if (error instanceof CLIError) {
+      fail(error.code, error.message, {
+        details: error.details,
+        hint: error.hint,
+        suggestedFix: error.suggestedFix
+      });
+    }
+    fail(
+      ErrorCodes.INTERNAL_ERROR,
+      error instanceof Error ? error.message : "Failed to list variables"
+    );
+  }
+});
+var variablesGetCommand = new Command("get").description("Get a single workflow variable by name").argument("<workflowId>", "Workflow ID (canvas ID)").argument("<varName>", "Variable name to get").action(async (workflowId, varName) => {
+  try {
+    const variables = await apiGetWorkflowVariables(workflowId);
+    const variable = variables.find((v) => v.name === varName || v.variableId === varName);
+    if (!variable) {
+      const availableNames = variables.map((v) => v.name).join(", ");
+      fail(ErrorCodes.NOT_FOUND, `Variable not found: ${varName}`, {
+        hint: `Available variables: ${availableNames}`
+      });
+      return;
+    }
+    ok("workflow.variables.get", {
+      workflowId,
+      variable: formatVariable(variable)
+    });
+  } catch (error) {
+    if (error instanceof CLIError) {
+      fail(error.code, error.message, {
+        details: error.details,
+        hint: error.hint,
+        suggestedFix: error.suggestedFix
+      });
+    }
+    fail(
+      ErrorCodes.INTERNAL_ERROR,
+      error instanceof Error ? error.message : "Failed to get variable"
+    );
+  }
+});
+var variablesSetCommand = new Command("set").description("Set variable values for a workflow").argument("<workflowId>", "Workflow ID (canvas ID)").option("--var <key=value...>", "Variable value in key=value format (can be repeated)").option("--input <json>", "Variable values as JSON object").option("--clear <name>", "Clear value for a specific variable").action(
+  async (workflowId, options) => {
+    try {
+      const currentVars = await apiGetWorkflowVariables(workflowId);
+      let newValues = {};
+      if (options.input) {
+        try {
+          const parsed = JSON.parse(options.input);
+          if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            fail(ErrorCodes.INVALID_INPUT, "Input must be a JSON object", {
+              hint: `Use format: '{"varName": "value"}'`,
+              suggestedFix: {
+                field: "--input",
+                format: "json-object",
+                example: '{"varName": "value"}'
+              }
+            });
+          }
+          newValues = { ...parsed };
+        } catch {
+          fail(ErrorCodes.INVALID_INPUT, "Invalid JSON in --input", {
+            hint: "Ensure the input is valid JSON",
             suggestedFix: {
-              field: "--ops",
-              format: "json-array",
-              example: '[{"op": "updateTitle", "title": "New Title"}]'
+              field: "--input",
+              format: "json-object",
+              example: '{"varName": "value"}'
             }
           });
         }
-      } catch (error) {
-        fail(ErrorCodes.INVALID_INPUT, `Invalid JSON in --ops: ${error.message}`, {
-          hint: opsFormatHint,
-          suggestedFix: {
-            field: "--ops",
-            format: "json-array",
-            example: '[{"op": "updateTitle", "title": "New Title"}]'
+      }
+      if (options.var && options.var.length > 0) {
+        const varBindings = parseVarArgs(options.var);
+        newValues = { ...newValues, ...varBindings };
+      }
+      if (options.clear) {
+        newValues[options.clear] = null;
+      }
+      if (Object.keys(newValues).length === 0) {
+        fail(ErrorCodes.INVALID_INPUT, "No variables specified", {
+          hint: `Use --var key=value, --input '{"key": "value"}', or --clear <name>`
+        });
+      }
+      const fileIds = Object.values(newValues).filter(
+        (v) => typeof v === "string" && v.startsWith("df-")
+      );
+      const fileMetadataMap = /* @__PURE__ */ new Map();
+      for (const fileId of fileIds) {
+        const metadata = await getFileMetadata(fileId);
+        if (metadata) {
+          fileMetadataMap.set(fileId, metadata);
+        }
+      }
+      const updatedVars = currentVars.map((v) => {
+        const name = v.name;
+        if (name in newValues) {
+          const newValue = newValues[name];
+          if (newValue === null) {
+            return { ...v, value: [] };
+          }
+          if (typeof newValue === "string") {
+            if (newValue.startsWith("df-")) {
+              const metadata = fileMetadataMap.get(newValue);
+              return {
+                ...v,
+                value: [
+                  {
+                    type: "resource",
+                    resource: {
+                      fileId: newValue,
+                      name: metadata?.name || "",
+                      fileType: metadata ? getFileCategoryByMimeType(metadata.type) : "document",
+                      storageKey: metadata?.storageKey || ""
+                    }
+                  }
+                ]
+              };
+            }
+            return {
+              ...v,
+              value: [{ type: "text", text: newValue }]
+            };
+          }
+          if (Array.isArray(newValue)) {
+            return { ...v, value: newValue };
           }
+          return v;
+        }
+        return v;
+      });
+      const definedNames = new Set(currentVars.map((v) => v.name));
+      const unknownVars = Object.keys(newValues).filter((k) => !definedNames.has(k));
+      if (unknownVars.length > 0) {
+        fail(ErrorCodes.INVALID_INPUT, `Unknown variables: ${unknownVars.join(", ")}`, {
+          hint: `Available variables: ${Array.from(definedNames).join(", ")}`
         });
       }
-    }
-    if (options.updateTitle) {
-      operations.push({
-        op: "updateTitle",
-        title: options.updateTitle
+      const result = await apiUpdateWorkflowVariables(workflowId, updatedVars);
+      ok("workflow.variables.set", {
+        workflowId,
+        updated: Object.keys(newValues),
+        variables: result.map(formatVariable)
       });
+    } catch (error) {
+      if (error instanceof CLIError) {
+        fail(error.code, error.message, {
+          details: error.details,
+          hint: error.hint,
+          suggestedFix: error.suggestedFix
+        });
+      }
+      fail(
+        ErrorCodes.INTERNAL_ERROR,
+        error instanceof Error ? error.message : "Failed to set variables"
+      );
     }
-    if (options.deleteTask) {
-      operations.push({
-        op: "deleteTask",
-        taskId: options.deleteTask
-      });
+  }
+);
+var workflowVariablesCommand = new Command("variables").description("Manage workflow variable values").addCommand(variablesListCommand).addCommand(variablesGetCommand).addCommand(variablesSetCommand);
+
+// src/commands/workflow/result.ts
+init_cjs_shims();
+function formatResult(result, options) {
+  const output3 = {
+    resultId: result.resultId,
+    version: result.version,
+    title: result.title,
+    type: result.type,
+    status: result.status
+  };
+  if (result.workflowExecutionId) {
+    output3.workflowExecutionId = result.workflowExecutionId;
+  }
+  if (result.workflowNodeExecutionId) {
+    output3.workflowNodeExecutionId = result.workflowNodeExecutionId;
+  }
+  output3.timing = {
+    createdAt: result.createdAt,
+    updatedAt: result.updatedAt
+  };
+  if (result.errors && result.errors.length > 0) {
+    output3.errors = result.errors;
+  }
+  if (result.errorType) {
+    output3.errorType = result.errorType;
+  }
+  if (result.outputUrl) {
+    output3.outputUrl = result.outputUrl;
+  }
+  if (result.files && result.files.length > 0) {
+    output3.files = result.files;
+  }
+  if (result.modelInfo) {
+    output3.modelInfo = result.modelInfo;
+  }
+  if (options.includeSteps && result.steps) {
+    if (options.raw) {
+      output3.steps = result.steps;
+    } else {
+      output3.steps = result.steps.map((step) => ({
+        name: step.name,
+        contentPreview: step.content?.substring(0, 200) + (step.content && step.content.length > 200 ? "..." : ""),
+        toolCallsCount: step.toolCalls?.length || 0,
+        ...options.includeToolCalls && step.toolCalls ? {
+          toolCalls: step.toolCalls.map((tc) => ({
+            callId: tc.callId,
+            toolName: tc.toolName,
+            status: tc.status,
+            ...options.raw ? { input: tc.input, output: tc.output } : {},
+            ...tc.error ? { error: tc.error } : {}
+          }))
+        } : {}
+      }));
     }
-    if (options.deleteVariable) {
-      operations.push({
-        op: "deleteVariable",
-        variableId: options.deleteVariable
-      });
+  }
+  if (options.includeMessages && result.messages) {
+    if (options.raw) {
+      output3.messages = result.messages;
+    } else {
+      output3.messages = result.messages.map((msg) => ({
+        messageId: msg.messageId,
+        type: msg.type,
+        contentPreview: msg.content?.substring(0, 200) + (msg.content && msg.content.length > 200 ? "..." : ""),
+        createdAt: msg.createdAt
+      }));
     }
-    if (operations.length === 0) {
-      fail(ErrorCodes.INVALID_INPUT, "No operations provided", {
-        hint: "Use --ops, --ops-file, or shortcut options (--update-title, --delete-task, --delete-variable)",
+  }
+  return output3;
+}
+var workflowResultCommand = new Command("result").description("Get action result by resultId").argument("<resultId>", "Action result ID (ar-xxx)").option("--include-steps", "Include execution steps").option("--include-messages", "Include action messages").option("--include-tool-calls", "Include tool call details (requires --include-steps)").option("--raw", "Show full content without truncation").action(async (resultId, options) => {
+  try {
+    if (!resultId.startsWith("ar-") && !resultId.startsWith("start-")) {
+      return fail(ErrorCodes.INVALID_INPUT, `Invalid resultId format: ${resultId}`, {
+        hint: 'Result ID should start with "ar-" or "start-"',
         suggestedFix: {
-          field: "--ops",
-          format: "json-array",
-          example: '[{"op": "updateTitle", "title": "New Title"}]'
+          field: "resultId",
+          format: "ar-xxx or start-xxx",
+          example: "ar-cq18zd4qr97nbla1tu1rqqmd"
         }
       });
     }
-    const body = {
-      planId,
-      operations
-    };
-    const response = await apiRequest("/v1/cli/workflow-plan/patch", {
-      method: "POST",
-      body
-    });
-    const plan = response.data ?? response;
-    ok("workflow.edit", {
-      planId,
-      operationsApplied: operations.length,
-      plan: {
-        title: plan.title,
-        taskCount: plan.tasks?.length ?? 0,
-        variableCount: plan.variables?.length ?? 0,
-        tasks: plan.tasks?.map((t) => ({
-          id: t.id,
-          title: t.title
-        })),
-        variables: plan.variables?.map((v) => ({
-          variableId: v.variableId,
-          name: v.name
-        }))
-      }
+    const result = await apiGetActionResult(resultId);
+    const formattedResult = formatResult(result, {
+      includeSteps: options.includeSteps,
+      includeMessages: options.includeMessages,
+      includeToolCalls: options.includeToolCalls,
+      raw: options.raw
     });
+    ok("workflow.result", formattedResult);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      fail(error.code, error.message, {
+        details: error.details,
+        hint: error.hint,
+        suggestedFix: error.suggestedFix
+      });
+    }
+    fail(
+      ErrorCodes.INTERNAL_ERROR,
+      error instanceof Error ? error.message : "Failed to get action result"
+    );
+  }
+});
+
+// src/commands/workflow/session.ts
+init_cjs_shims();
+var workflowSessionCommand = new Command("session").description("Get the latest copilot session for a workflow").argument("<workflowId>", "Workflow ID (canvas ID)").action(async (workflowId) => {
+  try {
+    const result = await apiRequest(
+      `/v1/cli/workflow/${workflowId}/session`
+    );
+    ok("workflow.session", result);
   } catch (error) {
     if (error instanceof CLIError) {
       fail(error.code, error.message, {
@@ -12792,17 +13246,16 @@ Examples:
         hint: error.hint,
         suggestedFix: error.suggestedFix
       });
-      return;
     }
     fail(
       ErrorCodes.INTERNAL_ERROR,
-      error instanceof Error ? error.message : "Failed to edit workflow plan"
+      error instanceof Error ? error.message : "Failed to get workflow session"
     );
   }
 });
 
 // src/commands/workflow/index.ts
-var workflowCommand = new Command("workflow").description("Manage and run workflows").addCommand(workflowCreateCommand).addCommand(workflowGenerateCommand).addCommand(workflowListCommand).addCommand(workflowGetCommand).addCommand(workflowDeleteCommand).addCommand(workflowRunCommand).addCommand(workflowRunsCommand).addCommand(workflowStatusCommand).addCommand(workflowDetailCommand).addCommand(workflowToolcallsCommand).addCommand(workflowAbortCommand).addCommand(workflowToolsetKeysCommand).addCommand(workflowLayoutCommand).addCommand(workflowNodesCommand).addCommand(workflowNodeGetCommand).addCommand(workflowNodeAddCommand).addCommand(workflowNodeUpdateCommand).addCommand(workflowNodeDeleteCommand).addCommand(workflowNodeOutputCommand).addCommand(workflowEditCommand);
+var workflowCommand = new Command("workflow").description("Manage and run workflows").addCommand(workflowCreateCommand).addCommand(workflowGenerateCommand).addCommand(workflowListCommand).addCommand(workflowGetCommand).addCommand(workflowDeleteCommand).addCommand(workflowRunCommand).addCommand(workflowRunsCommand).addCommand(workflowStatusCommand).addCommand(workflowDetailCommand).addCommand(workflowToolcallsCommand).addCommand(workflowAbortCommand).addCommand(workflowToolsetKeysCommand).addCommand(workflowLayoutCommand).addCommand(workflowNodeCommand).addCommand(workflowEditCommand).addCommand(workflowVariablesCommand).addCommand(workflowSessionCommand).addCommand(workflowResultCommand);
 
 // src/commands/tool/index.ts
 init_cjs_shims();
@@ -12982,16 +13435,16 @@ var fileGetCommand = new Command("get").description("Get file details").argument
 
 // src/commands/file/download.ts
 init_cjs_shims();
-var fs15 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
 var fileDownloadCommand = new Command("download").description("Download file to local filesystem").argument("<fileId>", "File ID").option("-o, --output <path>", "Output file path (defaults to original filename)").action(async (fileId, options) => {
   try {
     const { data, filename, contentType, size } = await apiRequestStream(
       `/v1/cli/drive/files/${fileId}/download`
     );
     const outputPath = options.output || filename || `${fileId}`;
-    const resolvedPath = path11.resolve(outputPath);
-    fs15.writeFileSync(resolvedPath, data);
+    const resolvedPath = path10.resolve(outputPath);
+    fs14.writeFileSync(resolvedPath, data);
     ok("file.download", {
       fileId,
       path: resolvedPath,
@@ -13016,8 +13469,8 @@ var fileDownloadCommand = new Command("download").description("Download file to
 
 // src/commands/file/upload.ts
 init_cjs_shims();
-var fs16 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var fs15 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
 var MAX_FILES = 10;
 function formatSize(bytes) {
   if (bytes < 1024) return `${bytes}B`;
@@ -13027,8 +13480,8 @@ function formatSize(bytes) {
 var fileUploadCommand = new Command("upload").description("Upload file(s) to a canvas").argument("<path>", "File or directory path").requiredOption("--canvas-id <id>", "Canvas ID (required)").option("--filter <extensions>", "Filter by extensions (e.g., pdf,docx,png)").action(async (inputPath, options) => {
   const formatter = getFormatter();
   try {
-    const resolvedPath = path12.resolve(inputPath);
-    if (!fs16.existsSync(resolvedPath)) {
+    const resolvedPath = path11.resolve(inputPath);
+    if (!fs15.existsSync(resolvedPath)) {
       fail(ErrorCodes.NOT_FOUND, `Path not found: ${inputPath}`, {
         hint: "Check if the file or directory exists"
       });
@@ -13046,8 +13499,8 @@ var fileUploadCommand = new Command("upload").description("Upload file(s) to a c
     const errors = [];
     for (let i = 0; i < files.length; i++) {
       const filePath = files[i];
-      const filename = path12.basename(filePath);
-      const fileStats = fs16.statSync(filePath);
+      const filename = path11.basename(filePath);
+      const fileStats = fs15.statSync(filePath);
       const sizeStr = formatSize(fileStats.size);
       let currentStage = "presign";
       const updateProgress = () => {
@@ -13128,11 +13581,11 @@ var fileUploadCommand = new Command("upload").description("Upload file(s) to a c
   }
 });
 function resolveFilesToUpload(inputPath, filter) {
-  const stats = fs16.statSync(inputPath);
+  const stats = fs15.statSync(inputPath);
   if (stats.isFile()) {
     if (filter) {
       const filterExts = filter.split(",").map((e) => e.trim().toLowerCase());
-      const ext = path12.extname(inputPath).slice(1).toLowerCase();
+      const ext = path11.extname(inputPath).slice(1).toLowerCase();
       if (!filterExts.includes(ext)) {
         return [];
       }
@@ -13140,21 +13593,21 @@ function resolveFilesToUpload(inputPath, filter) {
     return [inputPath];
   }
   if (stats.isDirectory()) {
-    const entries = fs16.readdirSync(inputPath);
+    const entries = fs15.readdirSync(inputPath);
     const filterExts = filter?.split(",").map((e) => e.trim().toLowerCase());
-    const files = entries.map((e) => path12.join(inputPath, e)).filter((p) => {
+    const files = entries.map((e) => path11.join(inputPath, e)).filter((p) => {
       try {
-        return fs16.statSync(p).isFile();
+        return fs15.statSync(p).isFile();
       } catch {
         return false;
       }
     }).filter((p) => {
       if (!filterExts) return true;
-      const ext = path12.extname(p).slice(1).toLowerCase();
+      const ext = path11.extname(p).slice(1).toLowerCase();
       return filterExts.includes(ext);
     }).sort((a, b) => {
       try {
-        return fs16.statSync(a).size - fs16.statSync(b).size;
+        return fs15.statSync(a).size - fs15.statSync(b).size;
       } catch {
         return 0;
       }
@@ -13258,7 +13711,7 @@ var skillGetCommand = new Command("get").description("Get skill package details"
 
 // src/commands/skill/create.ts
 init_cjs_shims();
-var fs17 = __toESM(require("fs"));
+var fs16 = __toESM(require("fs"));
 init_symlink();
 init_paths();
 init_logger();
@@ -13304,13 +13757,13 @@ var skillCreateCommand = new Command("create").description("Create a new skill p
     });
     const result = response.payload;
     let localPath;
-    let symlinkPath;
+    let _symlinkPath;
     if (result.workflowId) {
       try {
         const localName = options.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
         const skillDir = getReflyDomainSkillDir(localName);
         const symlinkStatus = isSkillSymlinkValid(localName);
-        if (fs17.existsSync(skillDir) || symlinkStatus.exists) {
+        if (fs16.existsSync(skillDir) || symlinkStatus.exists) {
           logger.debug(`Local skill '${localName}' already exists, skipping sync`);
         } else {
           const skillMdContent = generateReflySkillMd({
@@ -13328,7 +13781,7 @@ var skillCreateCommand = new Command("create").description("Create a new skill p
           const symlinkResult = createReflySkillWithSymlink(localName, skillMdContent);
           if (symlinkResult.success) {
             localPath = symlinkResult.reflyPath;
-            symlinkPath = symlinkResult.claudePath;
+            _symlinkPath = symlinkResult.claudePath;
             logger.info(`Created local domain skill: ${localName}`);
           } else {
             logger.warn(`Failed to create local skill: ${symlinkResult.error}`);
@@ -13338,18 +13791,17 @@ var skillCreateCommand = new Command("create").description("Create a new skill p
         logger.warn(`Failed to sync to local: ${syncError.message}`);
       }
     }
+    const webUrl = getWebUrl();
     const payload = {
       skillId: result.skillId,
+      installationId: result.installationId,
       name: result.name,
       status: result.status,
       createdAt: result.createdAt,
       workflowId: result.workflowId,
-      url: `${getWebUrl()}/skill/${result.skillId}`
+      workflowUrl: result.workflowId ? `${webUrl}/workflow/${result.workflowId}` : void 0,
+      localPath
     };
-    if (localPath) {
-      payload.localPath = localPath;
-      payload.symlinkPath = symlinkPath;
-    }
     if (options.verbose) {
       payload.workflowIds = result.workflowIds;
       payload.workflows = result.workflows;
@@ -13373,8 +13825,8 @@ var skillCreateCommand = new Command("create").description("Create a new skill p
 
 // src/commands/skill/update.ts
 init_cjs_shims();
-var fs18 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
+var fs17 = __toESM(require("fs"));
+var path12 = __toESM(require("path"));
 init_paths();
 init_symlink();
 var MIN_DESCRIPTION_WORDS = 20;
@@ -13404,8 +13856,8 @@ var skillUpdateCommand = new Command("update").description("Update skill install
   try {
     const name = options.name;
     const skillDir = getReflyDomainSkillDir(name);
-    const skillMdPath = path13.join(skillDir, "SKILL.md");
-    if (!fs18.existsSync(skillMdPath)) {
+    const skillMdPath = path12.join(skillDir, "SKILL.md");
+    if (!fs17.existsSync(skillMdPath)) {
       const skillsDir = getReflySkillsDir();
       fail(ErrorCodes.NOT_FOUND, `SKILL.md not found at ${skillMdPath}`, {
         hint: `Make sure the skill '${name}' exists in ${skillsDir}/
@@ -13414,7 +13866,7 @@ To see installed skills: refly skill list`
       });
       return;
     }
-    const skillContent = fs18.readFileSync(skillMdPath, "utf-8");
+    const skillContent = fs17.readFileSync(skillMdPath, "utf-8");
     let meta;
     try {
       const parsed = parseReflySkillMd(skillContent);
@@ -13497,31 +13949,17 @@ To see installed skills: refly skill list`
 
 // src/commands/skill/publish.ts
 init_cjs_shims();
-var fs19 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
+var fs18 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
 init_symlink();
 init_paths();
-var skillPublishCommand = new Command("publish").description("Publish a skill package using local SKILL.md").option("--id <skillId>", "Skill ID (skp-xxx) - overrides ID from SKILL.md").option("--name <name>", "Local skill name (directory in ~/.refly/skills/)").action(async (options) => {
+var skillPublishCommand = new Command("publish").description("Publish a skill package using local SKILL.md").requiredOption("--name <name>", "Local skill name (directory in ~/.refly/skills/)").action(async (options) => {
   try {
     const skillsDir = getReflySkillsDir();
-    if (!options.name) {
-      fail(ErrorCodes.INVALID_INPUT, "Missing required option: --name", {
-        hint: `The publish command requires --name to locate the local SKILL.md.
-
-Usage:
-  refly skill publish --name <name>
-  refly skill publish --name <name> --id <skillId>  # override skillId
-
-To find your skill name:
-  refly skill list
-  ls ${skillsDir}/`
-      });
-      return;
-    }
     const name = options.name;
     const skillDir = getReflyDomainSkillDir(name);
-    const skillMdPath = path14.join(skillDir, "SKILL.md");
-    if (!fs19.existsSync(skillMdPath)) {
+    const skillMdPath = path13.join(skillDir, "SKILL.md");
+    if (!fs18.existsSync(skillMdPath)) {
       fail(ErrorCodes.NOT_FOUND, `SKILL.md not found at ${skillMdPath}`, {
         hint: `Make sure the skill '${name}' exists in ${skillsDir}/
 
@@ -13530,22 +13968,31 @@ To create a new skill: refly skill create --name "${name}" --workflow-query "...
       });
       return;
     }
-    const skillContent = fs19.readFileSync(skillMdPath, "utf-8");
+    const skillContent = fs18.readFileSync(skillMdPath, "utf-8");
     let parsedSkill;
     try {
       parsedSkill = parseReflySkillMd(skillContent);
     } catch (parseError) {
-      fail(
-        ErrorCodes.INVALID_INPUT,
-        `Failed to parse SKILL.md: ${parseError.message}`,
-        {
-          hint: "Make sure SKILL.md has valid frontmatter with required fields: name, description, skillId, workflowId"
-        }
-      );
+      const errorMessage = parseError.message;
+      if (errorMessage.includes("skillId")) {
+        fail(ErrorCodes.INVALID_INPUT, "SKILL.md is missing skillId", {
+          hint: `The skill "${name}" has no skillId. This may happen if the skill was created manually.
+
+To fix this:
+  1. Reinstall the skill: refly skill install <skillId> --force
+  2. Or create a new skill: refly skill create --name "${name}" --workflow <workflowId>
+
+To find available skills: refly skill list`
+        });
+        return;
+      }
+      fail(ErrorCodes.INVALID_INPUT, `Failed to parse SKILL.md: ${errorMessage}`, {
+        hint: "Make sure SKILL.md has valid frontmatter with required fields: name, description, skillId, workflowId"
+      });
       return;
     }
     const { meta } = parsedSkill;
-    const skillId = options.id || meta.skillId;
+    const skillId = meta.skillId;
     const result = await apiRequest(
       `/v1/skill-packages/${skillId}/publish`,
       {
@@ -13561,8 +14008,6 @@ To create a new skill: refly skill create --name "${name}" --workflow-query "...
       version: result.version,
       status: result.status,
       isPublic: result.isPublic,
-      shareId: result.shareId,
-      shareUrl: result.shareId ? `https://refly.ai/skill/${result.shareId}` : void 0,
       githubPrUrl: result.githubPrUrl,
       githubPrNumber: result.githubPrNumber,
       localPath: skillMdPath
@@ -13585,8 +14030,8 @@ To create a new skill: refly skill create --name "${name}" --workflow-query "...
 
 // src/commands/skill/unpublish.ts
 init_cjs_shims();
-var fs20 = __toESM(require("fs"));
-var path15 = __toESM(require("path"));
+var fs19 = __toESM(require("fs"));
+var path14 = __toESM(require("path"));
 init_symlink();
 init_paths();
 var skillUnpublishCommand = new Command("unpublish").description("Unpublish a skill package to make it private").option("--id <skillId>", "Skill ID (skp-xxx)").option("--name <name>", "Local skill name (directory in ~/.refly/skills/)").action(async (options) => {
@@ -13608,9 +14053,21 @@ To find your skill name:
     let name;
     if (options.name) {
       name = options.name;
+      if (!name) {
+        fail(ErrorCodes.INVALID_INPUT, "Skill name cannot be empty", {
+          hint: `Usage:
+  refly skill unpublish --name <name>
+  refly skill unpublish --id <skillId>
+
+To find your skill name:
+  refly skill list
+  ls ${skillsDir}/`
+        });
+        return;
+      }
       const skillDir = getReflyDomainSkillDir(name);
-      const skillMdPath = path15.join(skillDir, "SKILL.md");
-      if (!fs20.existsSync(skillMdPath)) {
+      const skillMdPath = path14.join(skillDir, "SKILL.md");
+      if (!fs19.existsSync(skillMdPath)) {
         fail(ErrorCodes.NOT_FOUND, `SKILL.md not found at ${skillMdPath}`, {
           hint: `Make sure the skill '${name}' exists in ${skillsDir}/
 
@@ -13618,7 +14075,7 @@ To see installed skills: refly skill list`
         });
         return;
       }
-      const skillContent = fs20.readFileSync(skillMdPath, "utf-8");
+      const skillContent = fs19.readFileSync(skillMdPath, "utf-8");
       try {
         const { meta } = parseReflySkillMd(skillContent);
         skillId = options.id || meta.skillId;
@@ -13662,11 +14119,11 @@ To see installed skills: refly skill list`
 
 // src/commands/skill/run.ts
 init_cjs_shims();
-var fs21 = __toESM(require("fs"));
-var path16 = __toESM(require("path"));
+var fs20 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
 init_symlink();
 init_paths();
-var skillRunCommand = new Command("run").description("Run an installed skill").option("--id <installationId>", "Installation ID (skpi-xxx)").option("--name <name>", "Local skill name (directory in ~/.refly/skills/)").option("--input <json>", "Input JSON for the skill").option("--workflow <skillWorkflowId>", "Run specific workflow only").option("--async", "Run asynchronously").action(async (options) => {
+var skillRunCommand = new Command("run").description("Run an installed skill").option("--id <installationId>", "Installation ID (skpi-xxx)").option("--name <name>", "Local skill name (directory in ~/.refly/skills/)").option("--input <json>", "Input JSON for the skill").option("--workflow <skillWorkflowId>", "Run specific workflow only").option("--async", "Run asynchronously").option("--no-prompt", "Disable interactive prompts (fail if required variables are missing)").action(async (options) => {
   try {
     const skillsDir = getReflySkillsDir();
     if (!options.id && !options.name) {
@@ -13684,11 +14141,12 @@ To find your skill name:
     let installationId;
     let name;
     let skillId;
+    let workflowId;
     if (options.name) {
       name = options.name;
-      const skillDir = getReflyDomainSkillDir(name);
-      const skillMdPath = path16.join(skillDir, "SKILL.md");
-      if (!fs21.existsSync(skillMdPath)) {
+      const skillDir = getReflyDomainSkillDir(options.name);
+      const skillMdPath = path15.join(skillDir, "SKILL.md");
+      if (!fs20.existsSync(skillMdPath)) {
         fail(ErrorCodes.NOT_FOUND, `SKILL.md not found at ${skillMdPath}`, {
           hint: `Make sure the skill '${name}' exists in ${skillsDir}/
 
@@ -13697,10 +14155,11 @@ To install a skill: refly skill install <skillId>`
         });
         return;
       }
-      const skillContent = fs21.readFileSync(skillMdPath, "utf-8");
+      const skillContent = fs20.readFileSync(skillMdPath, "utf-8");
       try {
         const { meta } = parseReflySkillMd(skillContent);
         skillId = meta.skillId;
+        workflowId = meta.workflowId;
         if (options.id) {
           installationId = options.id;
         } else if (meta.installationId) {
@@ -13753,6 +14212,29 @@ To install: refly skill install ${meta.skillId}`
         return;
       }
     }
+    if (options.noPrompt && workflowId) {
+      try {
+        const workflow = await apiGetWorkflow(workflowId);
+        if (workflow?.variables) {
+          const checkResult = checkRequiredVariables(workflow.variables, input3);
+          if (!checkResult.valid) {
+            const errorPayload = buildMissingVariablesError(
+              "skill",
+              name || installationId,
+              name,
+              checkResult
+            );
+            fail(ErrorCodes.MISSING_VARIABLES, errorPayload.message, {
+              details: errorPayload.details,
+              hint: errorPayload.hint,
+              suggestedFix: errorPayload.suggestedFix,
+              recoverable: errorPayload.recoverable
+            });
+          }
+        }
+      } catch {
+      }
+    }
     const body = { input: input3 };
     if (options.workflow) body.workflowId = options.workflow;
     if (options.async) body.async = true;
@@ -13789,6 +14271,87 @@ To install: refly skill install ${meta.skillId}`
   }
 });
 
+// src/commands/skill/stop.ts
+init_cjs_shims();
+var fs21 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
+init_symlink();
+init_paths();
+function getLocalSkillNames() {
+  const skillsDir = getReflySkillsDir();
+  if (!fs21.existsSync(skillsDir)) {
+    return [];
+  }
+  return fs21.readdirSync(skillsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+}
+var skillStopCommand = new Command("stop").description("Stop running skill executions").requiredOption("--name <name>", "Local skill name (directory in ~/.refly/skills/)").action(async (options) => {
+  try {
+    const skillsDir = getReflySkillsDir();
+    const name = options.name;
+    const skillDir = getReflyDomainSkillDir(name);
+    const skillMdPath = path16.join(skillDir, "SKILL.md");
+    if (!fs21.existsSync(skillMdPath)) {
+      const availableSkills = getLocalSkillNames();
+      const skillList = availableSkills.length > 0 ? availableSkills.join(", ") : "(no skills installed)";
+      fail(ErrorCodes.NOT_FOUND, `Skill "${name}" not found`, {
+        hint: `Available skills: ${skillList}
+
+Skills directory: ${skillsDir}`
+      });
+    }
+    const skillContent = fs21.readFileSync(skillMdPath, "utf-8");
+    let installationId;
+    try {
+      const { meta } = parseReflySkillMd(skillContent);
+      if (!meta.installationId) {
+        fail(ErrorCodes.INVALID_INPUT, `Skill "${name}" does not have an installationId`, {
+          hint: `This skill may have been created locally but not installed.
+
+To install: refly skill install ${meta.skillId}`
+        });
+      }
+      installationId = meta.installationId;
+    } catch (parseError) {
+      fail(
+        ErrorCodes.INVALID_INPUT,
+        `Failed to parse SKILL.md: ${parseError.message}`,
+        {
+          hint: "Make sure SKILL.md has valid frontmatter with required fields"
+        }
+      );
+    }
+    const result = await apiRequest(
+      `/v1/skill-installations/${installationId}/stop`,
+      {
+        method: "POST"
+      }
+    );
+    ok("skill.stop", {
+      name,
+      installationId,
+      message: result.message,
+      stoppedExecutions: result.stoppedExecutions
+    });
+  } catch (error) {
+    if (error instanceof CLIError) {
+      if (error.code === "NOT_FOUND") {
+        fail(ErrorCodes.NOT_FOUND, `No running executions for skill "${options.name}"`, {
+          hint: "The skill is not currently running"
+        });
+      }
+      fail(error.code, error.message, {
+        details: error.details,
+        hint: error.hint,
+        suggestedFix: error.suggestedFix
+      });
+    }
+    fail(
+      ErrorCodes.INTERNAL_ERROR,
+      error instanceof Error ? error.message : "Failed to stop skill"
+    );
+  }
+});
+
 // src/commands/skill/search.ts
 init_cjs_shims();
 var skillSearchCommand = new Command("search").description("Search public skill packages").argument("<query>", "Search query").option("--tags <tags>", "Filter by tags (comma-separated)").option("--page <number>", "Page number", "1").option("--page-size <number>", "Page size", "20").action(async (query, options) => {
@@ -13835,11 +14398,12 @@ var skillSearchCommand = new Command("search").description("Search public skill
 init_cjs_shims();
 init_symlink();
 init_logger();
-var skillInstallCommand = new Command("install").description("Install a skill package").argument("<skillId>", "Skill package ID to install").option("--version <version>", "Specific version to install").option("--share-id <shareId>", "Share ID for private skills").option("--config <json>", "Installation config JSON").action(async (skillId, options) => {
+var skillInstallCommand = new Command("install").description("Install a skill package").argument("<skillId>", "Skill package ID to install").option("--version <version>", "Specific version to install").option("--share-id <shareId>", "Share ID for private skills").option("--config <json>", "Installation config JSON").option("--force", "Force reinstall if already installed").action(async (skillId, options) => {
   try {
     const body = { skillId };
     if (options.version) body.version = options.version;
     if (options.shareId) body.shareId = options.shareId;
+    if (options.force) body.force = true;
     if (options.config) {
       try {
         body.config = JSON.parse(options.config);
@@ -13881,7 +14445,9 @@ var skillInstallCommand = new Command("install").description("Install a skill pa
           inputSchema: result.skillPackage?.inputSchema,
           outputSchema: result.skillPackage?.outputSchema
         });
-        const symlinkResult = createReflySkillWithSymlink(skillName, skillMdContent);
+        const symlinkResult = createReflySkillWithSymlink(skillName, skillMdContent, {
+          force: options.force
+        });
         if (symlinkResult.success) {
           localPath = symlinkResult.reflyPath;
           symlinkPath = symlinkResult.claudePath;
@@ -13947,6 +14513,18 @@ To find your skill name:
     let name;
     if (options.name) {
       name = options.name;
+      if (!name) {
+        fail(ErrorCodes.INVALID_INPUT, "Skill name cannot be empty", {
+          hint: `Usage:
+  refly skill uninstall --name <name>
+  refly skill uninstall --id <installationId>
+
+To find your skill name:
+  refly skill list
+  ls ${skillsDir}/`
+        });
+        return;
+      }
       const skillDir = getReflyDomainSkillDir(name);
       const skillMdPath = path17.join(skillDir, "SKILL.md");
       if (!fs22.existsSync(skillMdPath)) {
@@ -14427,7 +15005,7 @@ var skillSyncCommand = new Command("sync").description("Validate and repair skil
 });
 
 // src/commands/skill/index.ts
-var skillCommand = new Command("skill").description("Manage skill packages and local skills").addCommand(skillListCommand).addCommand(skillGetCommand).addCommand(skillCreateCommand).addCommand(skillUpdateCommand).addCommand(skillPublishCommand).addCommand(skillUnpublishCommand).addCommand(skillSearchCommand).addCommand(skillInstallCommand).addCommand(skillUninstallCommand).addCommand(skillInstallationsCommand).addCommand(skillRunCommand).addCommand(skillValidateCommand).addCommand(skillSyncCommand);
+var skillCommand = new Command("skill").description("Manage skill packages and local skills").addCommand(skillListCommand).addCommand(skillGetCommand).addCommand(skillCreateCommand).addCommand(skillUpdateCommand).addCommand(skillPublishCommand).addCommand(skillUnpublishCommand).addCommand(skillSearchCommand).addCommand(skillInstallCommand).addCommand(skillUninstallCommand).addCommand(skillInstallationsCommand).addCommand(skillRunCommand).addCommand(skillStopCommand).addCommand(skillValidateCommand).addCommand(skillSyncCommand);
 
 // src/bin/refly.ts
 function getVersion() {