@powerformer/refly-cli 0.1.6 → 0.1.7

package/dist/bin/refly.js

@@ -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");
+init_logger();
+var PACKAGE_NAME = "@powerformer/refly-cli";
+function getCurrentVersion() {
   try {
-    const beforeStatus = isSkillInstalled();
-    const result = installSkill();
+    const pkgPath = new URL("../../package.json", importMetaUrl);
+    const pkg = JSON.parse(
+      (0, import_node_child_process6.execSync)(`cat "${pkgPath.pathname}"`, { encoding: "utf-8" })
+    );
+    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 { 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) {
+      const beforeStatus = isSkillInstalled();
+      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(
@@ -11861,8 +11980,108 @@ 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(workflowAbortCommand).addCommand(workflowStatusCommand).addCommand(workflowToolsetKeysCommand).addCommand(workflowLayoutCommand).addCommand(workflowNodesCommand).addCommand(workflowNodeGetCommand);
 
 // src/commands/node/index.ts
 init_cjs_shims();
@@ -12078,8 +12297,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();