@powerformer/refly-cli 0.1.17 → 0.1.18

package/dist/bin/refly.js

@@ -989,7 +989,7 @@ var require_command = __commonJS({
     init_cjs_shims();
     var EventEmitter = require("events").EventEmitter;
     var childProcess2 = require("child_process");
-    var path22 = require("path");
+    var path23 = require("path");
     var fs27 = require("fs");
     var process8 = require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
@@ -1922,9 +1922,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path22.resolve(baseDir, baseName);
+          const localBin = path23.resolve(baseDir, baseName);
           if (fs27.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path22.extname(baseName))) return void 0;
+          if (sourceExt.includes(path23.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
             (ext) => fs27.existsSync(`${localBin}${ext}`)
           );
@@ -1942,17 +1942,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path22.resolve(
-            path22.dirname(resolvedScriptPath),
+          executableDir = path23.resolve(
+            path23.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path22.basename(
+            const legacyName = path23.basename(
               this._scriptPath,
-              path22.extname(this._scriptPath)
+              path23.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1963,7 +1963,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path22.extname(executableFile));
+        launchWithNode = sourceExt.includes(path23.extname(executableFile));
         let proc;
         if (process8.platform !== "win32") {
           if (launchWithNode) {
@@ -2803,7 +2803,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path22.basename(filename, path22.extname(filename));
+        this._name = path23.basename(filename, path23.extname(filename));
         return this;
       }
       /**
@@ -2817,9 +2817,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path23) {
-        if (path23 === void 0) return this._executableDir;
-        this._executableDir = path23;
+      executableDir(path24) {
+        if (path24 === void 0) return this._executableDir;
+        this._executableDir = path24;
         return this;
       }
       /**
@@ -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,12 +4887,14 @@ 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
 var fs26 = __toESM(require("fs"));
-var path21 = __toESM(require("path"));
+var path22 = __toESM(require("path"));
 
 // src/commands/init.ts
 init_cjs_shims();
@@ -5391,8 +5399,8 @@ function getErrorMap() {
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 init_cjs_shims();
 var makeIssue = (params) => {
-  const { data, path: path22, errorMaps, issueData } = params;
-  const fullPath = [...path22, ...issueData.path || []];
+  const { data, path: path23, errorMaps, issueData } = params;
+  const fullPath = [...path23, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -5512,11 +5520,11 @@ var errorUtil;
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path22, key) {
+  constructor(parent, value, path23, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path22;
+    this._path = path23;
     this._key = key;
   }
   get path() {
@@ -9878,10 +9886,10 @@ var NetworkError = class extends CLIError {
 // src/api/client.ts
 init_logger();
 var DEFAULT_TIMEOUT = 3e4;
-async function apiRequest(path22, options = {}) {
+async function apiRequest(path23, options = {}) {
   const { method = "GET", body, query, timeout = DEFAULT_TIMEOUT, requireAuth = true } = options;
   const endpoint = getApiEndpoint();
-  let url = `${endpoint}${path22}`;
+  let url = `${endpoint}${path23}`;
   if (query && Object.keys(query).length > 0) {
     const params = new URLSearchParams(query);
     url = `${url}?${params.toString()}`;
@@ -9919,7 +9927,7 @@ async function apiRequest(path22, options = {}) {
   const controller = new AbortController();
   const timeoutId = setTimeout(() => controller.abort(), timeout);
   try {
-    logger.debug(`API Request: ${method} ${path22}`);
+    logger.debug(`API Request: ${method} ${path23}`);
     const response = await fetch(url, {
       method,
       headers,
@@ -10034,10 +10042,10 @@ function mapAPIError(status, response) {
   }
   return new CLIError(errCode, errMsg);
 }
-async function apiRequestStream(path22, options = {}) {
+async function apiRequestStream(path23, options = {}) {
   const { timeout = 3e5 } = options;
   const endpoint = getApiEndpoint();
-  const url = `${endpoint}${path22}`;
+  const url = `${endpoint}${path23}`;
   const headers = {
     "User-Agent": "refly-cli/0.1.0"
   };
@@ -10068,7 +10076,7 @@ async function apiRequestStream(path22, options = {}) {
   const controller = new AbortController();
   const timeoutId = setTimeout(() => controller.abort(), timeout);
   try {
-    logger.debug(`API Stream Request: GET ${path22}`);
+    logger.debug(`API Stream Request: GET ${path23}`);
     const response = await fetch(url, {
       method: "GET",
       headers,
@@ -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.18";
 var NPM_TAG = "test";
 function compareSemver(a, b) {
   const parseVersion = (v) => {
@@ -10982,16 +11006,16 @@ configCommand.action(() => {
   };
   ok("config", safeConfig);
 });
-function getNestedValue(obj, path22) {
-  return path22.split(".").reduce((current, key) => {
+function getNestedValue(obj, path23) {
+  return path23.split(".").reduce((current, key) => {
     if (current && typeof current === "object" && key in current) {
       return current[key];
     }
     return void 0;
   }, obj);
 }
-function setNestedValue(obj, path22, value) {
-  const keys = path22.split(".");
+function setNestedValue(obj, path23, value) {
+  const keys = path23.split(".");
   const lastKey = keys.pop();
   let current = obj;
   for (const key of keys) {
@@ -11441,6 +11465,77 @@ function determineFileType(filePath, mimeType) {
   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>";
+      }
+    }
+  }
+  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 result;
+}
+
 // src/commands/workflow/run.ts
 async function confirmAction(question) {
   const rl = readline2.createInterface({ input: import_node_process8.stdin, output: import_node_process8.stdout });
@@ -11511,6 +11606,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 +11618,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 [];
@@ -11693,6 +11795,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,
@@ -12659,132 +12779,389 @@ var workflowNodeOutputCommand = new Command("node-output").description("Get node
 
 // 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();
+function getFileTypeCategory(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";
+}
+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 ? getFileTypeCategory(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, {
@@ -12792,17 +13169,39 @@ 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 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, {
+        details: error.details,
+        hint: error.hint,
+        suggestedFix: error.suggestedFix
+      });
+    }
+    fail(
+      ErrorCodes.INTERNAL_ERROR,
+      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(workflowNodesCommand).addCommand(workflowNodeGetCommand).addCommand(workflowNodeAddCommand).addCommand(workflowNodeUpdateCommand).addCommand(workflowNodeDeleteCommand).addCommand(workflowNodeOutputCommand).addCommand(workflowEditCommand).addCommand(workflowVariablesCommand).addCommand(workflowSessionCommand).addCommand(workflowResultCommand);
 
 // src/commands/tool/index.ts
 init_cjs_shims();
@@ -12982,7 +13381,7 @@ var fileGetCommand = new Command("get").description("Get file details").argument
 
 // src/commands/file/download.ts
 init_cjs_shims();
-var fs15 = __toESM(require("fs"));
+var fs14 = __toESM(require("fs"));
 var path11 = __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 {
@@ -12991,7 +13390,7 @@ var fileDownloadCommand = new Command("download").description("Download file to
     );
     const outputPath = options.output || filename || `${fileId}`;
     const resolvedPath = path11.resolve(outputPath);
-    fs15.writeFileSync(resolvedPath, data);
+    fs14.writeFileSync(resolvedPath, data);
     ok("file.download", {
       fileId,
       path: resolvedPath,
@@ -13016,7 +13415,7 @@ var fileDownloadCommand = new Command("download").description("Download file to
 
 // src/commands/file/upload.ts
 init_cjs_shims();
-var fs16 = __toESM(require("fs"));
+var fs15 = __toESM(require("fs"));
 var path12 = __toESM(require("path"));
 var MAX_FILES = 10;
 function formatSize(bytes) {
@@ -13028,7 +13427,7 @@ var fileUploadCommand = new Command("upload").description("Upload file(s) to a c
   const formatter = getFormatter();
   try {
     const resolvedPath = path12.resolve(inputPath);
-    if (!fs16.existsSync(resolvedPath)) {
+    if (!fs15.existsSync(resolvedPath)) {
       fail(ErrorCodes.NOT_FOUND, `Path not found: ${inputPath}`, {
         hint: "Check if the file or directory exists"
       });
@@ -13047,7 +13446,7 @@ var fileUploadCommand = new Command("upload").description("Upload file(s) to a c
     for (let i = 0; i < files.length; i++) {
       const filePath = files[i];
       const filename = path12.basename(filePath);
-      const fileStats = fs16.statSync(filePath);
+      const fileStats = fs15.statSync(filePath);
       const sizeStr = formatSize(fileStats.size);
       let currentStage = "presign";
       const updateProgress = () => {
@@ -13128,7 +13527,7 @@ 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());
@@ -13140,11 +13539,11 @@ 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) => {
       try {
-        return fs16.statSync(p).isFile();
+        return fs15.statSync(p).isFile();
       } catch {
         return false;
       }
@@ -13154,7 +13553,7 @@ function resolveFilesToUpload(inputPath, filter) {
       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 +13657,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 +13703,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 +13727,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 +13737,16 @@ 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,
       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,7 +13770,7 @@ 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 fs17 = __toESM(require("fs"));
 var path13 = __toESM(require("path"));
 init_paths();
 init_symlink();
@@ -13405,7 +13802,7 @@ var skillUpdateCommand = new Command("update").description("Update skill install
     const name = options.name;
     const skillDir = getReflyDomainSkillDir(name);
     const skillMdPath = path13.join(skillDir, "SKILL.md");
-    if (!fs18.existsSync(skillMdPath)) {
+    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 +13811,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,7 +13894,7 @@ To see installed skills: refly skill list`
 
 // src/commands/skill/publish.ts
 init_cjs_shims();
-var fs19 = __toESM(require("fs"));
+var fs18 = __toESM(require("fs"));
 var path14 = __toESM(require("path"));
 init_symlink();
 init_paths();
@@ -13521,7 +13918,7 @@ To find your skill name:
     const name = options.name;
     const skillDir = getReflyDomainSkillDir(name);
     const skillMdPath = path14.join(skillDir, "SKILL.md");
-    if (!fs19.existsSync(skillMdPath)) {
+    if (!fs18.existsSync(skillMdPath)) {
       fail(ErrorCodes.NOT_FOUND, `SKILL.md not found at ${skillMdPath}`, {
         hint: `Make sure the skill '${name}' exists in ${skillsDir}/
 
@@ -13530,7 +13927,7 @@ 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);
@@ -13561,8 +13958,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,7 +13980,7 @@ 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 fs19 = __toESM(require("fs"));
 var path15 = __toESM(require("path"));
 init_symlink();
 init_paths();
@@ -13610,7 +14005,7 @@ To find your skill name:
       name = options.name;
       const skillDir = getReflyDomainSkillDir(name);
       const skillMdPath = path15.join(skillDir, "SKILL.md");
-      if (!fs20.existsSync(skillMdPath)) {
+      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 +14013,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 +14057,11 @@ To see installed skills: refly skill list`
 
 // src/commands/skill/run.ts
 init_cjs_shims();
-var fs21 = __toESM(require("fs"));
+var fs20 = __toESM(require("fs"));
 var path16 = __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 +14079,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 skillDir = getReflyDomainSkillDir(options.name);
       const skillMdPath = path16.join(skillDir, "SKILL.md");
-      if (!fs21.existsSync(skillMdPath)) {
+      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 +14093,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 +14150,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 +14209,87 @@ To install: refly skill install ${meta.skillId}`
   }
 });
 
+// src/commands/skill/stop.ts
+init_cjs_shims();
+var fs21 = __toESM(require("fs"));
+var path17 = __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 = path17.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 +14336,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 +14383,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;
@@ -13923,7 +14427,7 @@ var skillInstallCommand = new Command("install").description("Install a skill pa
 // src/commands/skill/uninstall.ts
 init_cjs_shims();
 var fs22 = __toESM(require("fs"));
-var path17 = __toESM(require("path"));
+var path18 = __toESM(require("path"));
 init_symlink();
 init_paths();
 init_logger();
@@ -13948,7 +14452,7 @@ To find your skill name:
     if (options.name) {
       name = options.name;
       const skillDir = getReflyDomainSkillDir(name);
-      const skillMdPath = path17.join(skillDir, "SKILL.md");
+      const skillMdPath = path18.join(skillDir, "SKILL.md");
       if (!fs22.existsSync(skillMdPath)) {
         fail(ErrorCodes.NOT_FOUND, `SKILL.md not found at ${skillMdPath}`, {
           hint: `Make sure the skill '${name}' exists in ${skillsDir}/
@@ -14074,7 +14578,7 @@ init_cjs_shims();
 // src/skill/loader.ts
 init_cjs_shims();
 var fs23 = __toESM(require("fs"));
-var path18 = __toESM(require("path"));
+var path19 = __toESM(require("path"));
 var import_gray_matter = __toESM(require("gray-matter"));
 init_logger();
 
@@ -14255,13 +14759,13 @@ function extractSkillMetadata(content) {
 // src/commands/skill/validate.ts
 init_paths();
 var fs24 = __toESM(require("fs"));
-var path19 = __toESM(require("path"));
+var path20 = __toESM(require("path"));
 var skillValidateCommand = new Command("validate").description("Validate local skill files").argument("[skillPath]", "Path to skill file or directory (defaults to ~/.refly/skills)").option("--fix", "Attempt to fix common issues").action(async (skillPath, _options) => {
   try {
     const results = [];
     let targetPath;
     if (skillPath) {
-      targetPath = path19.resolve(skillPath);
+      targetPath = path20.resolve(skillPath);
     } else {
       await ensureSkillsDir();
       targetPath = getSkillsDir();
@@ -14331,7 +14835,7 @@ function validateSkillFile(filePath) {
 function findSkillFiles(dir, files = []) {
   const entries = fs24.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path19.join(dir, entry.name);
+    const fullPath = path20.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (!entry.name.startsWith(".")) {
         findSkillFiles(fullPath, files);
@@ -14348,7 +14852,7 @@ init_cjs_shims();
 init_symlink();
 init_paths();
 var fs25 = __toESM(require("fs"));
-var path20 = __toESM(require("path"));
+var path21 = __toESM(require("path"));
 var skillSyncCommand = new Command("sync").description("Validate and repair skill symlinks").option("--dry-run", "Show issues without making changes").option("--fix", "Attempt to repair broken symlinks").option("--prune", "Remove orphan symlinks (symlinks without source directory)").action(async (options) => {
   try {
     const symlinks = listSkillSymlinks();
@@ -14382,7 +14886,7 @@ var skillSyncCommand = new Command("sync").description("Validate and repair skil
         if (entry.isDirectory() && entry.name !== "base") {
           if (!symlinkNames.has(entry.name)) {
             orphans += 1;
-            warnings.push(`Orphan directory (no symlink): ${path20.join(skillsDir, entry.name)}`);
+            warnings.push(`Orphan directory (no symlink): ${path21.join(skillsDir, entry.name)}`);
             if (options.prune && !options.dryRun) {
               const result = createSkillSymlink(entry.name);
               if (result.success) {
@@ -14427,12 +14931,12 @@ 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() {
   try {
-    const pkgPath = path21.join(__dirname, "..", "..", "package.json");
+    const pkgPath = path22.join(__dirname, "..", "..", "package.json");
     const pkg = JSON.parse(fs26.readFileSync(pkgPath, "utf-8"));
     return pkg.version || "0.1.0";
   } catch {