@powerformer/refly-cli 0.1.6 → 0.1.8

package/dist/bin/refly.js

@@ -989,8 +989,8 @@ var require_command = __commonJS({
     init_cjs_shims();
     var EventEmitter = require("events").EventEmitter;
     var childProcess2 = require("child_process");
-    var path10 = require("path");
-    var fs14 = require("fs");
+    var path11 = require("path");
+    var fs15 = require("fs");
     var process8 = require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1922,11 +1922,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path10.resolve(baseDir, baseName);
-          if (fs14.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path10.extname(baseName))) return void 0;
+          const localBin = path11.resolve(baseDir, baseName);
+          if (fs15.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path11.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs14.existsSync(`${localBin}${ext}`)
+            (ext) => fs15.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1938,21 +1938,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs14.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs15.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path10.resolve(
-            path10.dirname(resolvedScriptPath),
+          executableDir = path11.resolve(
+            path11.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path10.basename(
+            const legacyName = path11.basename(
               this._scriptPath,
-              path10.extname(this._scriptPath)
+              path11.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1963,7 +1963,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path10.extname(executableFile));
+        launchWithNode = sourceExt.includes(path11.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 = path10.basename(filename, path10.extname(filename));
+        this._name = path11.basename(filename, path11.extname(filename));
         return this;
       }
       /**
@@ -2817,9 +2817,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path11) {
-        if (path11 === void 0) return this._executableDir;
-        this._executableDir = path11;
+      executableDir(path12) {
+        if (path12 === void 0) return this._executableDir;
+        this._executableDir = path12;
         return this;
       }
       /**
@@ -4438,8 +4438,8 @@ var ErrorCodes = {
 };
 
 // src/bin/refly.ts
-var fs13 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
 
 // src/commands/init.ts
 init_cjs_shims();
@@ -4950,8 +4950,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: path10, errorMaps, issueData } = params;
-  const fullPath = [...path10, ...issueData.path || []];
+  const { data, path: path11, errorMaps, issueData } = params;
+  const fullPath = [...path11, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -5071,11 +5071,11 @@ var errorUtil;
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path10, key) {
+  constructor(parent, value, path11, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path10;
+    this._path = path11;
     this._key = key;
   }
   get path() {
@@ -9336,10 +9336,10 @@ var NetworkError = class extends CLIError {
 // src/api/client.ts
 init_logger();
 var DEFAULT_TIMEOUT = 3e4;
-async function apiRequest(path10, options = {}) {
+async function apiRequest(path11, options = {}) {
   const { method = "GET", body, query, timeout = DEFAULT_TIMEOUT, requireAuth = true } = options;
   const endpoint = getApiEndpoint();
-  let url = `${endpoint}${path10}`;
+  let url = `${endpoint}${path11}`;
   if (query && Object.keys(query).length > 0) {
     const params = new URLSearchParams(query);
     url = `${url}?${params.toString()}`;
@@ -9377,7 +9377,7 @@ async function apiRequest(path10, options = {}) {
   const controller = new AbortController();
   const timeoutId = setTimeout(() => controller.abort(), timeout);
   try {
-    logger.debug(`API Request: ${method} ${path10}`);
+    logger.debug(`API Request: ${method} ${path11}`);
     const response = await fetch(url, {
       method,
       headers,
@@ -9467,10 +9467,10 @@ function mapAPIError(status, response) {
   }
   return new CLIError(errCode, errMsg);
 }
-async function apiRequestStream(path10, options = {}) {
+async function apiRequestStream(path11, options = {}) {
   const { timeout = 3e5 } = options;
   const endpoint = getApiEndpoint();
-  const url = `${endpoint}${path10}`;
+  const url = `${endpoint}${path11}`;
   const headers = {
     "User-Agent": "refly-cli/0.1.0"
   };
@@ -9501,7 +9501,7 @@ async function apiRequestStream(path10, options = {}) {
   const controller = new AbortController();
   const timeoutId = setTimeout(() => controller.abort(), timeout);
   try {
-    logger.debug(`API Stream Request: GET ${path10}`);
+    logger.debug(`API Stream Request: GET ${path11}`);
     const response = await fetch(url, {
       method: "GET",
       headers,
@@ -10080,16 +10080,135 @@ var whoamiCommand = new Command("whoami").description("Show current authenticate
 
 // src/commands/upgrade.ts
 init_cjs_shims();
-var upgradeCommand = new Command("upgrade").description("Reinstall or upgrade skill files").action(async () => {
+var import_node_child_process6 = require("child_process");
+var import_node_fs4 = __toESM(require("fs"));
+var import_node_path2 = __toESM(require("path"));
+init_logger();
+var PACKAGE_NAME = "@powerformer/refly-cli";
+function getCurrentVersion() {
+  try {
+    const pkgPath = import_node_path2.default.join(__dirname, "..", "..", "package.json");
+    const pkgContent = import_node_fs4.default.readFileSync(pkgPath, { encoding: "utf-8" });
+    const pkg = JSON.parse(pkgContent);
+    return pkg.version;
+  } catch {
+    return "0.1.0";
+  }
+}
+async function getLatestVersion() {
+  try {
+    const result = (0, import_node_child_process6.execSync)(`npm view ${PACKAGE_NAME} version 2>/dev/null`, {
+      encoding: "utf-8",
+      timeout: 1e4
+    });
+    return result.trim();
+  } catch (error) {
+    logger.debug("Failed to get latest version from npm:", error);
+    return null;
+  }
+}
+async function checkVersion() {
+  const current = getCurrentVersion();
+  const latest = await getLatestVersion();
+  return {
+    current,
+    latest,
+    updateAvailable: latest !== null && latest !== current
+  };
+}
+function upgradeCli() {
+  try {
+    logger.info("Upgrading CLI via npm...");
+    (0, import_node_child_process6.execSync)(`npm install -g ${PACKAGE_NAME}@latest`, {
+      encoding: "utf-8",
+      stdio: "pipe",
+      timeout: 12e4
+      // 2 minutes
+    });
+    return { success: true };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    logger.error("Failed to upgrade CLI:", message);
+    return { success: false, error: message };
+  }
+}
+var upgradeCommand = new Command("upgrade").description("Upgrade CLI to latest version and reinstall skill files").option("--check", "Only check for updates without installing").option("--skill-only", "Only reinstall skill files without upgrading CLI").option("--cli-only", "Only upgrade CLI without reinstalling skill files").action(async (options) => {
   try {
-    const beforeStatus = isSkillInstalled();
-    const result = installSkill();
+    const { check, skillOnly, cliOnly } = options;
+    const versionInfo = await checkVersion();
+    if (check) {
+      return ok("upgrade.check", {
+        currentVersion: versionInfo.current,
+        latestVersion: versionInfo.latest,
+        updateAvailable: versionInfo.updateAvailable,
+        message: versionInfo.updateAvailable ? `Update available: ${versionInfo.current} \u2192 ${versionInfo.latest}` : "Already on latest version"
+      });
+    }
+    if (skillOnly) {
+      const beforeStatus = isSkillInstalled();
+      const result = installSkill();
+      return ok("upgrade", {
+        message: "Skill files updated successfully",
+        cliUpgraded: false,
+        skillUpdated: true,
+        previousVersion: beforeStatus.currentVersion ?? null,
+        newVersion: result.version,
+        skillPath: result.skillPath,
+        commandsInstalled: result.commandsInstalled
+      });
+    }
+    let cliUpgraded = false;
+    let cliError;
+    if (!cliOnly) {
+      print("upgrade.progress", {
+        step: "checking",
+        currentVersion: versionInfo.current,
+        latestVersion: versionInfo.latest
+      });
+    }
+    if (!skillOnly) {
+      if (versionInfo.updateAvailable) {
+        print("upgrade.progress", {
+          step: "upgrading",
+          from: versionInfo.current,
+          to: versionInfo.latest
+        });
+        const upgradeResult = upgradeCli();
+        cliUpgraded = upgradeResult.success;
+        cliError = upgradeResult.error;
+        if (!cliUpgraded) {
+          return fail(ErrorCodes.INTERNAL_ERROR, "Failed to upgrade CLI", {
+            hint: cliError || "Try running: npm install -g @powerformer/refly-cli@latest"
+          });
+        }
+      } else {
+        logger.info("CLI is already on latest version");
+      }
+    }
+    let skillResult = null;
+    if (!cliOnly) {
+      skillResult = installSkill();
+    }
+    const newVersionInfo = await checkVersion();
+    let message;
+    if (cliUpgraded && skillResult) {
+      message = "CLI and skill files updated successfully";
+    } else if (cliUpgraded) {
+      message = "CLI updated successfully";
+    } else if (skillResult) {
+      message = "Skill files updated (CLI already on latest version)";
+    } else {
+      message = "Already on latest version";
+    }
     ok("upgrade", {
-      message: "Skill files upgraded successfully",
-      previousVersion: beforeStatus.currentVersion ?? null,
-      newVersion: result.version,
-      skillPath: result.skillPath,
-      commandsInstalled: result.commandsInstalled
+      message,
+      cliUpgraded,
+      skillUpdated: !!skillResult,
+      previousVersion: versionInfo.current,
+      currentVersion: newVersionInfo.current,
+      latestVersion: newVersionInfo.latest,
+      skillPath: skillResult?.skillPath ?? null,
+      commandsInstalled: skillResult?.commandsInstalled ?? false
     });
   } catch (error) {
     return fail(
@@ -10185,16 +10304,16 @@ configCommand.action(() => {
   };
   ok("config", safeConfig);
 });
-function getNestedValue(obj, path10) {
-  return path10.split(".").reduce((current, key) => {
+function getNestedValue(obj, path11) {
+  return path11.split(".").reduce((current, key) => {
     if (current && typeof current === "object" && key in current) {
       return current[key];
     }
     return void 0;
   }, obj);
 }
-function setNestedValue(obj, path10, value) {
-  const keys = path10.split(".");
+function setNestedValue(obj, path11, value) {
+  const keys = path11.split(".");
   const lastKey = keys.pop();
   let current = obj;
   for (const key of keys) {
@@ -10214,8 +10333,8 @@ init_cjs_shims();
 
 // src/builder/store.ts
 init_cjs_shims();
-var fs10 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+var fs11 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
 var crypto2 = __toESM(require("crypto"));
 init_paths();
 
@@ -10292,21 +10411,21 @@ function createSession(name, description) {
 }
 function saveSession(session) {
   const sessionPath = getSessionPath(session.id);
-  const tempPath = path6.join(getBuilderDir(), `.session-${session.id}-${Date.now()}.tmp`);
+  const tempPath = path7.join(getBuilderDir(), `.session-${session.id}-${Date.now()}.tmp`);
   session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const validated = BuilderSessionSchema.parse(session);
-  fs10.writeFileSync(tempPath, JSON.stringify(validated, null, 2), {
+  fs11.writeFileSync(tempPath, JSON.stringify(validated, null, 2), {
     mode: 384
   });
-  fs10.renameSync(tempPath, sessionPath);
+  fs11.renameSync(tempPath, sessionPath);
 }
 function loadSession(sessionId) {
   const sessionPath = getSessionPath(sessionId);
   try {
-    if (!fs10.existsSync(sessionPath)) {
+    if (!fs11.existsSync(sessionPath)) {
       return null;
     }
-    const content = fs10.readFileSync(sessionPath, "utf-8");
+    const content = fs11.readFileSync(sessionPath, "utf-8");
     const parsed = JSON.parse(content);
     return BuilderSessionSchema.parse(parsed);
   } catch {
@@ -10316,8 +10435,8 @@ function loadSession(sessionId) {
 function deleteSession(sessionId) {
   const sessionPath = getSessionPath(sessionId);
   try {
-    if (fs10.existsSync(sessionPath)) {
-      fs10.unlinkSync(sessionPath);
+    if (fs11.existsSync(sessionPath)) {
+      fs11.unlinkSync(sessionPath);
     }
   } catch {
   }
@@ -10326,22 +10445,22 @@ function setCurrent(sessionId) {
   const currentPath = getCurrentSessionPath();
   if (sessionId === null) {
     try {
-      if (fs10.existsSync(currentPath)) {
-        fs10.unlinkSync(currentPath);
+      if (fs11.existsSync(currentPath)) {
+        fs11.unlinkSync(currentPath);
       }
     } catch {
     }
     return;
   }
-  fs10.writeFileSync(currentPath, sessionId, { mode: 384 });
+  fs11.writeFileSync(currentPath, sessionId, { mode: 384 });
 }
 function getCurrentSessionId() {
   const currentPath = getCurrentSessionPath();
   try {
-    if (!fs10.existsSync(currentPath)) {
+    if (!fs11.existsSync(currentPath)) {
       return null;
     }
-    return fs10.readFileSync(currentPath, "utf-8").trim();
+    return fs11.readFileSync(currentPath, "utf-8").trim();
   } catch {
     return null;
   }
@@ -11015,18 +11134,18 @@ function detectCycles(nodes) {
   }
   const visited = /* @__PURE__ */ new Set();
   const recursionStack = /* @__PURE__ */ new Set();
-  const path10 = [];
+  const path11 = [];
   function dfs(nodeId) {
     if (recursionStack.has(nodeId)) {
-      const cycleStart = path10.indexOf(nodeId);
-      return [...path10.slice(cycleStart), nodeId];
+      const cycleStart = path11.indexOf(nodeId);
+      return [...path11.slice(cycleStart), nodeId];
     }
     if (visited.has(nodeId)) {
       return null;
     }
     visited.add(nodeId);
     recursionStack.add(nodeId);
-    path10.push(nodeId);
+    path11.push(nodeId);
     const node = nodeMap.get(nodeId);
     if (node) {
       for (const depId of node.dependsOn) {
@@ -11036,7 +11155,7 @@ function detectCycles(nodes) {
         }
       }
     }
-    path10.pop();
+    path11.pop();
     recursionStack.delete(nodeId);
     return null;
   }
@@ -11470,85 +11589,32 @@ var workflowDeleteCommand = new Command("delete").description("Delete a workflow
 
 // src/commands/workflow/run.ts
 init_cjs_shims();
-
-// src/commands/workflow/run-detail.ts
-init_cjs_shims();
-var workflowRunDetailCommand = new Command("detail").description("Get detailed workflow run information including all node results").argument("<runId>", "Workflow run ID").option("--no-tool-calls", "Exclude tool call summaries").option("--preview-length <length>", "Output preview length (default: 500)", "500").action(async (runId, options) => {
+var workflowRunCommand = new Command("run").description("Start a workflow execution").argument("<workflowId>", "Workflow ID to run").option("--input <json>", "Input variables as JSON", "{}").option("--from-node <nodeId>", "Start workflow execution from a specific node (Run From Here)").action(async (workflowId, options) => {
   try {
-    const params = new URLSearchParams();
-    if (options.toolCalls === false) {
-      params.set("includeToolCalls", "false");
+    let input;
+    try {
+      input = JSON.parse(options.input);
+    } catch {
+      fail(ErrorCodes.INVALID_INPUT, "Invalid JSON in --input", {
+        hint: "Ensure the input is valid JSON"
+      });
     }
-    if (options.previewLength) {
-      params.set("outputPreviewLength", options.previewLength);
+    const body = { input };
+    if (options.fromNode) {
+      body.startNodes = [options.fromNode];
     }
-    const queryString = params.toString();
-    const url = `/v1/cli/workflow/run/${runId}/detail${queryString ? `?${queryString}` : ""}`;
-    const result = await apiRequest(url);
-    ok("workflow.run.detail", {
+    const result = await apiRequest(`/v1/cli/workflow/${workflowId}/run`, {
+      method: "POST",
+      body
+    });
+    ok("workflow.run", {
+      message: options.fromNode ? `Workflow run started from node ${options.fromNode}` : "Workflow run started",
       runId: result.runId,
       workflowId: result.workflowId,
-      title: result.title,
-      status: result.status,
-      progress: {
-        total: result.totalNodes,
-        executed: result.executedNodes,
-        failed: result.failedNodes
-      },
-      timing: {
-        startedAt: result.startedAt,
-        finishedAt: result.finishedAt,
-        durationMs: result.durationMs
-      },
-      nodes: result.nodes,
-      errors: result.errors
-    });
-  } catch (error) {
-    if (error instanceof CLIError) {
-      fail(error.code, error.message, { details: error.details, hint: error.hint });
-    }
-    fail(
-      ErrorCodes.INTERNAL_ERROR,
-      error instanceof Error ? error.message : "Failed to get workflow run detail"
-    );
-  }
-});
-
-// src/commands/workflow/run-node.ts
-init_cjs_shims();
-var workflowRunNodeCommand = new Command("node").description("Get detailed execution result for a specific node").argument("<runId>", "Workflow run ID").argument("<nodeId>", "Node ID").option("--include-messages", "Include AI conversation messages").option("--raw", "Disable output sanitization (show full tool outputs)").action(async (runId, nodeId, options) => {
-  try {
-    const params = new URLSearchParams();
-    if (options.includeMessages) {
-      params.set("includeMessages", "true");
-    }
-    if (options.raw) {
-      params.set("sanitizeForDisplay", "false");
-    }
-    const queryString = params.toString();
-    const url = `/v1/cli/workflow/run/${runId}/node/${nodeId}${queryString ? `?${queryString}` : ""}`;
-    const result = await apiRequest(url);
-    ok("workflow.node.result", {
-      nodeId: result.nodeId,
-      nodeExecutionId: result.nodeExecutionId,
-      nodeType: result.nodeType,
-      title: result.title,
       status: result.status,
-      timing: {
-        startTime: result.startTime,
-        endTime: result.endTime,
-        durationMs: result.durationMs
-      },
-      query: result.query,
-      originalQuery: result.originalQuery,
-      resultId: result.resultId,
-      resultVersion: result.resultVersion,
-      output: result.output,
-      tokenUsage: result.tokenUsage,
-      toolCallsCount: result.toolCalls?.length ?? 0,
-      toolCalls: result.toolCalls,
-      messages: result.messages,
-      error: result.error
+      startNode: options.fromNode || void 0,
+      createdAt: result.createdAt,
+      nextStep: `Check status with \`refly workflow status ${workflowId}\``
     });
   } catch (error) {
     if (error instanceof CLIError) {
@@ -11556,92 +11622,42 @@ var workflowRunNodeCommand = new Command("node").description("Get detailed execu
     }
     fail(
       ErrorCodes.INTERNAL_ERROR,
-      error instanceof Error ? error.message : "Failed to get node result"
+      error instanceof Error ? error.message : "Failed to run workflow"
     );
   }
 });
 
-// src/commands/workflow/run-toolcalls.ts
+// src/commands/workflow/runs.ts
 init_cjs_shims();
-var workflowRunToolcallsCommand = new Command("toolcalls").description("Get all tool calls for a workflow run").argument("<runId>", "Workflow run ID").option("--node-id <nodeId>", "Filter by node ID").option("--toolset-id <toolsetId>", "Filter by toolset ID").option("--tool-name <toolName>", "Filter by tool name").option("--status <status>", "Filter by status (executing, completed, failed)").option("--limit <limit>", "Maximum number of results (default: 100)", "100").option("--offset <offset>", "Pagination offset (default: 0)", "0").option("--raw", "Disable output sanitization (show full tool outputs)").action(async (runId, options) => {
+var workflowRunsCommand = new Command("runs").description("List workflow execution history").argument("<workflowId>", "Workflow ID").option("--limit <limit>", "Maximum number of runs to return (default: 20)", "20").option("--offset <offset>", "Pagination offset (default: 0)", "0").option("--status <status>", "Filter by status (init, executing, finish, failed)").action(async (workflowId, options) => {
   try {
     const params = new URLSearchParams();
-    if (options.nodeId) {
-      params.set("nodeId", options.nodeId);
-    }
-    if (options.toolsetId) {
-      params.set("toolsetId", options.toolsetId);
-    }
-    if (options.toolName) {
-      params.set("toolName", options.toolName);
-    }
-    if (options.status) {
-      params.set("status", options.status);
-    }
     if (options.limit) {
       params.set("limit", options.limit);
     }
     if (options.offset) {
       params.set("offset", options.offset);
     }
-    if (options.raw) {
-      params.set("sanitizeForDisplay", "false");
+    if (options.status) {
+      params.set("status", options.status);
     }
     const queryString = params.toString();
-    const url = `/v1/cli/workflow/run/${runId}/toolcalls${queryString ? `?${queryString}` : ""}`;
+    const url = `/v1/cli/workflow/${workflowId}/runs${queryString ? `?${queryString}` : ""}`;
     const result = await apiRequest(url);
-    ok("workflow.toolcalls", {
-      runId: result.runId,
-      totalCount: result.totalCount,
-      toolCalls: result.toolCalls,
-      summary: {
-        byStatus: result.byStatus,
-        byToolset: result.byToolset,
-        byTool: result.byTool
-      }
-    });
-  } catch (error) {
-    if (error instanceof CLIError) {
-      fail(error.code, error.message, { details: error.details, hint: error.hint });
-    }
-    fail(
-      ErrorCodes.INTERNAL_ERROR,
-      error instanceof Error ? error.message : "Failed to get workflow tool calls"
-    );
-  }
-});
-
-// src/commands/workflow/run.ts
-var workflowRunCommand = new Command("run").description("Run workflows and get execution results").argument("[workflowId]", "Workflow ID to run").option("--input <json>", "Input variables as JSON", "{}").option("--from-node <nodeId>", "Start workflow execution from a specific node (Run From Here)").action(async (workflowId, options) => {
-  if (!workflowId) {
-    workflowRunCommand.help();
-    return;
-  }
-  try {
-    let input;
-    try {
-      input = JSON.parse(options.input);
-    } catch {
-      fail(ErrorCodes.INVALID_INPUT, "Invalid JSON in --input", {
-        hint: "Ensure the input is valid JSON"
-      });
-    }
-    const body = { input };
-    if (options.fromNode) {
-      body.startNodes = [options.fromNode];
-    }
-    const result = await apiRequest(`/v1/cli/workflow/${workflowId}/run`, {
-      method: "POST",
-      body
-    });
-    ok("workflow.run", {
-      message: options.fromNode ? `Workflow run started from node ${options.fromNode}` : "Workflow run started",
-      runId: result.runId,
+    ok("workflow.runs", {
       workflowId: result.workflowId,
-      status: result.status,
-      startNode: options.fromNode || void 0,
-      createdAt: result.createdAt,
-      nextStep: `Check status with \`refly workflow status ${result.runId}\``
+      total: result.total,
+      hasActiveRun: result.hasActiveRun,
+      activeRunId: result.activeRunId,
+      runs: result.runs.map((run) => ({
+        runId: run.runId,
+        status: run.status,
+        progress: `${run.executedNodes}/${run.totalNodes}`,
+        failedNodes: run.failedNodes,
+        startedAt: run.startedAt,
+        finishedAt: run.finishedAt,
+        durationMs: run.durationMs
+      }))
     });
   } catch (error) {
     if (error instanceof CLIError) {
@@ -11649,24 +11665,21 @@ var workflowRunCommand = new Command("run").description("Run workflows and get e
     }
     fail(
       ErrorCodes.INTERNAL_ERROR,
-      error instanceof Error ? error.message : "Failed to run workflow"
+      error instanceof Error ? error.message : "Failed to get workflow runs"
     );
   }
 });
-workflowRunCommand.addCommand(workflowRunDetailCommand);
-workflowRunCommand.addCommand(workflowRunNodeCommand);
-workflowRunCommand.addCommand(workflowRunToolcallsCommand);
 
 // src/commands/workflow/abort.ts
 init_cjs_shims();
-var workflowAbortCommand = new Command("abort").description("Abort a running workflow").argument("<runId>", "Run ID").action(async (runId) => {
+var workflowAbortCommand = new Command("abort").description("Abort a running workflow").argument("<workflowId>", "Workflow ID").action(async (workflowId) => {
   try {
-    await apiRequest(`/v1/cli/workflow/run/${runId}/abort`, {
+    await apiRequest(`/v1/cli/workflow/${workflowId}/abort`, {
       method: "POST"
     });
     ok("workflow.abort", {
       message: "Workflow run aborted",
-      runId
+      workflowId
     });
   } catch (error) {
     if (error instanceof CLIError) {
@@ -11723,7 +11736,7 @@ function generateSummary(changedNodes) {
   }
   return summaries.join("; ") || `${changedNodes.length} node(s) updated`;
 }
-var workflowStatusCommand = new Command("status").description("Get detailed workflow execution status").argument("<runId>", "Workflow run ID").option("--watch", "Watch mode: continuously poll until completion").option("--interval <ms>", "Poll interval in ms (default: 2000)", "2000").option("--full", "In watch mode, output full status every time (not just changes)").action(async (runId, options) => {
+var workflowStatusCommand = new Command("status").description("Get detailed workflow execution status").argument("<workflowId>", "Workflow ID").option("--watch", "Watch mode: continuously poll until completion").option("--interval <ms>", "Poll interval in ms (default: 2000)", "2000").option("--full", "In watch mode, output full status every time (not just changes)").action(async (workflowId, options) => {
   try {
     const pollInterval = Number.parseInt(options.interval, 10);
     if (Number.isNaN(pollInterval) || pollInterval <= 0) {
@@ -11732,7 +11745,7 @@ var workflowStatusCommand = new Command("status").description("Get detailed work
       });
     }
     const fetchStatus = async () => {
-      return await apiRequest(`/v1/cli/workflow/run/${runId}`);
+      return await apiRequest(`/v1/cli/workflow/${workflowId}/status`);
     };
     if (options.watch) {
       let prevStatus = null;
@@ -11789,6 +11802,100 @@ var workflowStatusCommand = new Command("status").description("Get detailed work
   }
 });
 
+// src/commands/workflow/detail.ts
+init_cjs_shims();
+var workflowDetailCommand = new Command("detail").description("Get detailed workflow execution information including all node results").argument("<workflowId>", "Workflow ID").option("--no-tool-calls", "Exclude tool call summaries").option("--preview-length <length>", "Output preview length (default: 500)", "500").action(async (workflowId, options) => {
+  try {
+    const params = new URLSearchParams();
+    if (options.toolCalls === false) {
+      params.set("includeToolCalls", "false");
+    }
+    if (options.previewLength) {
+      params.set("outputPreviewLength", options.previewLength);
+    }
+    const queryString = params.toString();
+    const url = `/v1/cli/workflow/${workflowId}/detail${queryString ? `?${queryString}` : ""}`;
+    const result = await apiRequest(url);
+    ok("workflow.detail", {
+      runId: result.runId,
+      workflowId: result.workflowId,
+      title: result.title,
+      status: result.status,
+      progress: {
+        total: result.totalNodes,
+        executed: result.executedNodes,
+        failed: result.failedNodes
+      },
+      timing: {
+        startedAt: result.startedAt,
+        finishedAt: result.finishedAt,
+        durationMs: result.durationMs
+      },
+      nodes: result.nodes,
+      errors: result.errors
+    });
+  } catch (error) {
+    if (error instanceof CLIError) {
+      fail(error.code, error.message, { details: error.details, hint: error.hint });
+    }
+    fail(
+      ErrorCodes.INTERNAL_ERROR,
+      error instanceof Error ? error.message : "Failed to get workflow detail"
+    );
+  }
+});
+
+// src/commands/workflow/toolcalls.ts
+init_cjs_shims();
+var workflowToolcallsCommand = new Command("toolcalls").description("Get all tool calls for the current workflow execution").argument("<workflowId>", "Workflow ID").option("--node-id <nodeId>", "Filter by node ID").option("--toolset-id <toolsetId>", "Filter by toolset ID").option("--tool-name <toolName>", "Filter by tool name").option("--status <status>", "Filter by status (executing, completed, failed)").option("--limit <limit>", "Maximum number of results (default: 100)", "100").option("--offset <offset>", "Pagination offset (default: 0)", "0").option("--raw", "Disable output sanitization (show full tool outputs)").action(async (workflowId, options) => {
+  try {
+    const params = new URLSearchParams();
+    if (options.nodeId) {
+      params.set("nodeId", options.nodeId);
+    }
+    if (options.toolsetId) {
+      params.set("toolsetId", options.toolsetId);
+    }
+    if (options.toolName) {
+      params.set("toolName", options.toolName);
+    }
+    if (options.status) {
+      params.set("status", options.status);
+    }
+    if (options.limit) {
+      params.set("limit", options.limit);
+    }
+    if (options.offset) {
+      params.set("offset", options.offset);
+    }
+    if (options.raw) {
+      params.set("sanitizeForDisplay", "false");
+    }
+    const queryString = params.toString();
+    const url = `/v1/cli/workflow/${workflowId}/toolcalls${queryString ? `?${queryString}` : ""}`;
+    const result = await apiRequest(url);
+    ok("workflow.toolcalls", {
+      runId: result.runId,
+      workflowId: result.workflowId,
+      totalCount: result.totalCount,
+      toolCalls: result.toolCalls,
+      summary: {
+        byStatus: result.byStatus,
+        byToolset: result.byToolset,
+        byTool: result.byTool
+      }
+    });
+  } catch (error) {
+    if (error instanceof CLIError) {
+      fail(error.code, error.message, { details: error.details, hint: error.hint });
+    }
+    fail(
+      ErrorCodes.INTERNAL_ERROR,
+      error instanceof Error ? error.message : "Failed to get workflow tool calls"
+    );
+  }
+});
+
 // src/commands/workflow/toolset-keys.ts
 init_cjs_shims();
 var workflowToolsetKeysCommand = new Command("toolset-keys").description("List available toolset inventory keys for use with --toolsets").option("--type <type>", 'Filter by toolset type (e.g., "regular", "external_oauth")').action(async (options) => {
@@ -11861,16 +11968,116 @@ var workflowLayoutCommand = new Command("layout").description("Auto-layout workf
   }
 });
 
+// src/commands/workflow/nodes.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) => {
+  try {
+    const result = await apiRequest(`/v1/cli/workflow/${workflowId}`);
+    const nodes = result.nodes.map((node) => {
+      const output2 = {
+        id: node.id,
+        type: node.type,
+        title: node.data?.title || node.data?.metadata?.title || void 0
+      };
+      if (options.includePosition && node.position) {
+        output2.position = node.position;
+      }
+      if (options.includeMetadata && node.data?.metadata) {
+        output2.metadata = node.data.metadata;
+      }
+      return output2;
+    });
+    const output = {
+      workflowId: result.workflowId,
+      workflowName: result.name,
+      nodeCount: nodes.length,
+      nodes
+    };
+    if (options.includeEdges && result.edges?.length) {
+      output.edges = result.edges.map((edge) => ({
+        id: edge.id,
+        source: edge.source,
+        target: edge.target,
+        sourceHandle: edge.sourceHandle,
+        targetHandle: edge.targetHandle
+      }));
+      output.edgeCount = result.edges.length;
+    }
+    ok("workflow.nodes", output);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      fail(error.code, error.message, { details: error.details, hint: error.hint });
+    }
+    fail(
+      ErrorCodes.INTERNAL_ERROR,
+      error instanceof Error ? error.message : "Failed to get workflow nodes"
+    );
+  }
+});
+
+// src/commands/workflow/node-get.ts
+init_cjs_shims();
+var workflowNodeGetCommand = new Command("node").description("Get single node information from a workflow").argument("<workflowId>", "Workflow ID").argument("<nodeId>", "Node ID").option("--include-connections", "Include incoming and outgoing connections").action(async (workflowId, nodeId, options) => {
+  try {
+    const result = await apiRequest(`/v1/cli/workflow/${workflowId}`);
+    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 ${workflowId}' to list all nodes`
+      });
+    }
+    const output = {
+      workflowId: result.workflowId,
+      workflowName: result.name,
+      node: {
+        id: node.id,
+        type: node.type,
+        title: node.data?.title || node.data?.metadata?.title || void 0,
+        position: node.position,
+        metadata: node.data?.metadata || {},
+        data: node.data
+      }
+    };
+    if (options.includeConnections && result.edges?.length) {
+      const incoming = result.edges.filter((e) => e.target === nodeId).map((e) => ({
+        from: e.source,
+        sourceHandle: e.sourceHandle,
+        targetHandle: e.targetHandle
+      }));
+      const outgoing = result.edges.filter((e) => e.source === nodeId).map((e) => ({
+        to: e.target,
+        sourceHandle: e.sourceHandle,
+        targetHandle: e.targetHandle
+      }));
+      output.connections = {
+        incoming,
+        outgoing,
+        incomingCount: incoming.length,
+        outgoingCount: outgoing.length
+      };
+    }
+    ok("workflow.node", output);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      fail(error.code, error.message, { details: error.details, hint: error.hint });
+    }
+    fail(
+      ErrorCodes.INTERNAL_ERROR,
+      error instanceof Error ? error.message : "Failed to get node information"
+    );
+  }
+});
+
 // src/commands/workflow/index.ts
-var workflowCommand = new Command("workflow").description("Manage and run workflows").addCommand(workflowCreateCommand).addCommand(workflowGenerateCommand).addCommand(workflowListCommand).addCommand(workflowGetCommand).addCommand(workflowEditCommand).addCommand(workflowDeleteCommand).addCommand(workflowRunCommand).addCommand(workflowAbortCommand).addCommand(workflowStatusCommand).addCommand(workflowToolsetKeysCommand).addCommand(workflowLayoutCommand);
+var workflowCommand = new Command("workflow").description("Manage and run workflows").addCommand(workflowCreateCommand).addCommand(workflowGenerateCommand).addCommand(workflowListCommand).addCommand(workflowGetCommand).addCommand(workflowEditCommand).addCommand(workflowDeleteCommand).addCommand(workflowRunCommand).addCommand(workflowRunsCommand).addCommand(workflowStatusCommand).addCommand(workflowDetailCommand).addCommand(workflowToolcallsCommand).addCommand(workflowAbortCommand).addCommand(workflowToolsetKeysCommand).addCommand(workflowLayoutCommand).addCommand(workflowNodesCommand).addCommand(workflowNodeGetCommand);
 
 // src/commands/node/index.ts
 init_cjs_shims();
 
 // src/commands/node/types.ts
 init_cjs_shims();
-var fs11 = __toESM(require("fs"));
-var path7 = __toESM(require("path"));
+var fs12 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
 init_paths();
 var CACHE_FILE = "node-types.json";
 var CACHE_TTL = 24 * 60 * 60 * 1e3;
@@ -11909,20 +12116,20 @@ var nodeTypesCommand = new Command("types").description("List available node typ
   }
 });
 function getCachePath() {
-  return path7.join(getCacheDir(), CACHE_FILE);
+  return path8.join(getCacheDir(), CACHE_FILE);
 }
 function loadFromCache() {
   try {
     const cachePath = getCachePath();
-    if (!fs11.existsSync(cachePath)) {
+    if (!fs12.existsSync(cachePath)) {
       return null;
     }
-    const stat = fs11.statSync(cachePath);
+    const stat = fs12.statSync(cachePath);
     const age = Date.now() - stat.mtimeMs;
     if (age > CACHE_TTL) {
       return null;
     }
-    const content = fs11.readFileSync(cachePath, "utf-8");
+    const content = fs12.readFileSync(cachePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -11932,7 +12139,7 @@ async function fetchAndCache() {
   const data = await apiRequest("/v1/cli/node/types");
   try {
     const cachePath = getCachePath();
-    fs11.writeFileSync(cachePath, JSON.stringify(data, null, 2));
+    fs12.writeFileSync(cachePath, JSON.stringify(data, null, 2));
   } catch {
   }
   return data;
@@ -12078,8 +12285,35 @@ var nodeResultCommand = new Command("result").description("Get node execution re
   }
 });
 
+// src/commands/node/abort.ts
+init_cjs_shims();
+var nodeAbortCommand = new Command("abort").description("Abort a running node execution").argument("<resultId>", "Node result ID to abort").option("--version <number>", "Specific version to abort", Number.parseInt).action(async (resultId, options) => {
+  try {
+    const body = { resultId };
+    if (options.version !== void 0) {
+      body.version = options.version;
+    }
+    const result = await apiRequest("/v1/cli/action/abort", {
+      method: "POST",
+      body
+    });
+    ok("node.abort", {
+      message: result.message,
+      resultId: result.resultId
+    });
+  } catch (error) {
+    if (error instanceof CLIError) {
+      fail(error.code, error.message, { details: error.details, hint: error.hint });
+    }
+    fail(
+      ErrorCodes.INTERNAL_ERROR,
+      error instanceof Error ? error.message : "Failed to abort node execution"
+    );
+  }
+});
+
 // src/commands/node/index.ts
-var nodeCommand = new Command("node").description("Node operations: types, run, and execution results").addCommand(nodeTypesCommand).addCommand(nodeRunCommand).addCommand(nodeResultCommand);
+var nodeCommand = new Command("node").description("Node operations: types, run, abort, and execution results").addCommand(nodeTypesCommand).addCommand(nodeRunCommand).addCommand(nodeResultCommand).addCommand(nodeAbortCommand);
 
 // src/commands/tool/index.ts
 init_cjs_shims();
@@ -12243,16 +12477,16 @@ var fileGetCommand = new Command("get").description("Get file details").argument
 
 // src/commands/file/download.ts
 init_cjs_shims();
-var fs12 = __toESM(require("fs"));
-var path8 = __toESM(require("path"));
+var fs13 = __toESM(require("fs"));
+var path9 = __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 = path8.resolve(outputPath);
-    fs12.writeFileSync(resolvedPath, data);
+    const resolvedPath = path9.resolve(outputPath);
+    fs13.writeFileSync(resolvedPath, data);
     ok("file.download", {
       fileId,
       path: resolvedPath,
@@ -12277,8 +12511,8 @@ var fileCommand = new Command("file").description("Manage files and documents").
 // src/bin/refly.ts
 function getVersion() {
   try {
-    const pkgPath = path9.join(__dirname, "..", "..", "package.json");
-    const pkg = JSON.parse(fs13.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path10.join(__dirname, "..", "..", "package.json");
+    const pkg = JSON.parse(fs14.readFileSync(pkgPath, "utf-8"));
     return pkg.version || "0.1.0";
   } catch {
     return "0.1.0";