@powerformer/refly-cli 0.1.5 → 0.1.7

package/dist/bin/refly.js

@@ -4040,30 +4040,15 @@ var OutputFormatter = class {
   }
   // === CLI Status Format (Phase 1: Charm-style cards) ===
   outputStatusPretty(payload) {
-    const { cli_version, api_endpoint, auth_status, auth_method, auth_details, user, skill } = payload;
+    const { cli_version, api_endpoint, auth_status, user, skill } = payload;
     const sym = this.useUnicode ? Symbols : AsciiSymbol;
     console.log(`${sym.DIAMOND} ${UI.bold("Refly CLI")} v${cli_version || "?"}`);
     console.log();
     const authOk = auth_status === "valid";
     const userObj = user;
-    const authDetailsObj = auth_details;
     const authLines = [];
     if (authOk && userObj?.email) {
       authLines.push({ text: String(userObj.email) });
-      const provider = authDetailsObj?.provider || auth_method;
-      if (provider) {
-        const providerDisplay = String(provider).charAt(0).toUpperCase() + String(provider).slice(1);
-        const exp = userObj?.exp;
-        let expiryText = "";
-        if (exp) {
-          expiryText = ` \xB7 ${UI.timeRemaining(exp)}`;
-        }
-        authLines.push({
-          text: `via ${providerDisplay}${expiryText}`,
-          indent: true,
-          muted: true
-        });
-      }
     } else if (auth_status === "expired") {
       authLines.push({ text: "Token expired", muted: true });
     } else {
@@ -4377,6 +4362,9 @@ function configureOutput(options) {
   };
   initFormatter(outputConfig);
 }
+function isPrettyOutput() {
+  return outputConfig.format !== "json";
+}
 function ok(type, payload) {
   const formatter = getFormatter();
   formatter.success(type, payload);
@@ -4436,6 +4424,7 @@ var ErrorCodes = {
   // Node
   INVALID_NODE_TYPE: "INVALID_NODE_TYPE",
   INVALID_NODE_INPUT: "INVALID_NODE_INPUT",
+  EXECUTION_FAILED: "EXECUTION_FAILED",
   // Network
   NETWORK_ERROR: "NETWORK_ERROR",
   TIMEOUT: "TIMEOUT",
@@ -8559,8 +8548,8 @@ var ConfigSchema = external_exports.object({
     installedAt: external_exports.string().optional()
   }).optional()
 });
-var DEFAULT_API_ENDPOINT = "https://api.refly.ai";
-var DEFAULT_WEB_URL = "https://refly.ai";
+var DEFAULT_API_ENDPOINT = "https://refly-api.powerformer.net";
+var DEFAULT_WEB_URL = "https://refly.powerformer.net";
 var DEFAULT_CONFIG = {
   version: 1,
   api: {
@@ -9655,7 +9644,40 @@ async function loginWithDeviceFlow() {
     },
     requireAuth: false
   });
-  const { deviceId, expiresAt } = initResponse;
+  const { deviceId, expiresAt, userCode } = initResponse;
+  const cleanup = async (deviceIdToCancel = deviceId) => {
+    try {
+      logger.debug("Cleaning up device session...");
+      await apiRequest("/v1/auth/cli/device/cancel", {
+        method: "POST",
+        body: { device_id: deviceIdToCancel },
+        requireAuth: false
+      });
+      logger.debug("Device session cancelled");
+    } catch (error) {
+      logger.debug("Failed to cancel device session during cleanup:", error);
+    }
+  };
+  process.on("SIGINT", async () => {
+    logger.debug("Received SIGINT, cleaning up...");
+    await cleanup();
+    process.exit(130);
+  });
+  process.on("SIGTERM", async () => {
+    logger.debug("Received SIGTERM, cleaning up...");
+    await cleanup();
+    process.exit(143);
+  });
+  process.on("uncaughtException", async (error) => {
+    logger.debug("Uncaught exception, cleaning up:", error);
+    await cleanup();
+    process.exit(1);
+  });
+  process.on("unhandledRejection", async (reason) => {
+    logger.debug("Unhandled rejection, cleaning up:", reason);
+    await cleanup();
+    process.exit(1);
+  });
   const webUrl = getWebUrl();
   const authUrl = `${webUrl}/cli/auth?device_id=${encodeURIComponent(deviceId)}&cli_version=${encodeURIComponent(CLI_VERSION)}&host=${encodeURIComponent(hostname2)}`;
   process.stderr.write("\n");
@@ -9664,6 +9686,10 @@ async function loginWithDeviceFlow() {
   process.stderr.write(`  ${authUrl}
 `);
   process.stderr.write("\n");
+  if (userCode) {
+    process.stderr.write(`Verification Code: ${styled(userCode, Style.TEXT_HIGHLIGHT_BOLD)}
+`);
+  }
   process.stderr.write(`Device ID: ${deviceId}
 `);
   process.stderr.write(`Expires: ${new Date(expiresAt).toLocaleTimeString()}
@@ -9678,55 +9704,67 @@ async function loginWithDeviceFlow() {
   }
   const pollInterval = 2e3;
   const maxAttempts = 150;
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    await sleep(pollInterval);
-    const statusResponse = await apiRequest("/v1/auth/cli/device/status", {
-      method: "GET",
-      query: { device_id: deviceId },
-      requireAuth: false
-    });
-    switch (statusResponse.status) {
-      case "authorized":
-        if (statusResponse.accessToken && statusResponse.refreshToken) {
-          const userInfo = await getUserInfoFromToken(statusResponse.accessToken);
-          setOAuthTokens({
-            accessToken: statusResponse.accessToken,
-            refreshToken: statusResponse.refreshToken,
-            expiresAt: new Date(Date.now() + 36e5).toISOString(),
-            // 1 hour
-            provider: "google",
-            // Device flow doesn't specify provider, default to google
-            user: userInfo
+  try {
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      await sleep(pollInterval);
+      const statusResponse = await apiRequest(
+        "/v1/auth/cli/device/status",
+        {
+          method: "GET",
+          query: { device_id: deviceId },
+          requireAuth: false
+        }
+      );
+      switch (statusResponse.status) {
+        case "authorized":
+          if (statusResponse.accessToken && statusResponse.refreshToken) {
+            const userInfo = await getUserInfoFromToken(statusResponse.accessToken);
+            setOAuthTokens({
+              accessToken: statusResponse.accessToken,
+              refreshToken: statusResponse.refreshToken,
+              expiresAt: new Date(Date.now() + 36e5).toISOString(),
+              // 1 hour
+              provider: "google",
+              // Device flow doesn't specify provider, default to google
+              user: userInfo
+            });
+            ok("login", {
+              message: "Successfully authenticated via device authorization",
+              user: userInfo,
+              method: "device"
+            });
+            return true;
+          }
+          break;
+        case "cancelled":
+          printError(ErrorCodes.AUTH_REQUIRED, "Authorization was cancelled", {
+            hint: "The authorization request was cancelled in the browser"
           });
-          ok("login", {
-            message: "Successfully authenticated via device authorization",
-            user: userInfo,
-            method: "device"
+          return false;
+        case "expired":
+          printError(ErrorCodes.AUTH_REQUIRED, "Authorization request expired", {
+            hint: "Run `refly login` again to start a new session"
           });
-          return true;
-        }
-        break;
-      case "cancelled":
-        printError(ErrorCodes.AUTH_REQUIRED, "Authorization was cancelled", {
-          hint: "The authorization request was cancelled in the browser"
-        });
-        return false;
-      case "expired":
-        printError(ErrorCodes.AUTH_REQUIRED, "Authorization request expired", {
-          hint: "Run `refly login` again to start a new session"
-        });
-        return false;
-      case "pending":
-        if (attempt % 5 === 0) {
-          process.stderr.write(".");
-        }
-        break;
+          return false;
+        case "pending":
+          if (attempt % 5 === 0) {
+            process.stderr.write(".");
+          }
+          break;
+      }
     }
+    logger.debug("Authorization timeout, updating device status...");
+    await cleanup(deviceId);
+    printError(ErrorCodes.TIMEOUT, "Authorization timeout", {
+      hint: "Complete authorization in the browser within 5 minutes"
+    });
+    return false;
+  } finally {
+    process.removeAllListeners("SIGINT");
+    process.removeAllListeners("SIGTERM");
+    process.removeAllListeners("uncaughtException");
+    process.removeAllListeners("unhandledRejection");
   }
-  printError(ErrorCodes.TIMEOUT, "Authorization timeout", {
-    hint: "Complete authorization in the browser within 5 minutes"
-  });
-  return false;
 }
 async function getUserInfoFromToken(accessToken) {
   try {
@@ -9759,15 +9797,66 @@ function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
+// src/utils/logo.ts
+init_cjs_shims();
+var REFLY_LOGO = `\u2588\u2580\u2588 \u2588\u2580\u2580 \u2588\u2580\u2580 \u2588   \u2588 \u2588   \u2588\u2580\u2588 \u2588
+\u2588\u2580\u2584 \u2588\u2580\u2580 \u2588\u2580\u2580 \u2588   \u2588\u2584\u2588 \u2580 \u2588\u2580\u2588 \u2588
+\u2580 \u2580 \u2580\u2580\u2580 \u2580   \u2580\u2580\u2580  \u2580    \u2580 \u2580 \u2580`;
+function printLogo(options) {
+  const useColor = options?.color ?? shouldUseColor();
+  const tty = isTTY();
+  if (!tty && !options?.force) {
+    return;
+  }
+  if (useColor) {
+    process.stderr.write(`${Style.TEXT_SUCCESS}${REFLY_LOGO}${Style.RESET}
+`);
+  } else {
+    process.stderr.write(`${REFLY_LOGO}
+`);
+  }
+}
+function printSuccess(message) {
+  process.stderr.write(`${UI.successMsg(message)}
+`);
+}
+function printError2(message) {
+  process.stderr.write(`${UI.errorMsg(message)}
+`);
+}
+function printDim(message) {
+  process.stderr.write(`${UI.dim(message)}
+`);
+}
+function println(message) {
+  process.stderr.write(`${message}
+`);
+}
+
 // src/commands/init.ts
-var DEFAULT_API_ENDPOINT2 = "https://api.refly.ai";
+var DEFAULT_API_ENDPOINT2 = "https://refly-api.powerformer.net";
 var initCommand = new Command("init").description("Initialize Refly CLI, install skill files, and authenticate").option("--force", "Force reinstall even if already installed").option("--host <url>", "API server URL", DEFAULT_API_ENDPOINT2).option("--skip-login", "Skip automatic login after initialization").action(async (options) => {
   try {
     const { force, host, skipLogin } = options;
     const apiEndpoint = host || DEFAULT_API_ENDPOINT2;
+    const pretty = isPrettyOutput();
+    const tty = isTTY();
+    const useColor = shouldUseColor();
     const skillStatus = isSkillInstalled();
     const isAuthenticated2 = !!(getAccessToken() || getApiKey());
     if (skillStatus.installed && skillStatus.upToDate && !force && isAuthenticated2) {
+      if (pretty && tty) {
+        printLogo({ color: useColor });
+        println("");
+        printSuccess("Already initialized and authenticated");
+        const user = getAuthUser();
+        if (user?.email) {
+          printDim(`  Logged in as ${user.email}`);
+        }
+        println("");
+        printDim("Run `refly status` for details.");
+        return;
+      }
       return ok("init", {
         message: "Refly CLI already initialized and authenticated",
         configDir: getReflyDir(),
@@ -9777,34 +9866,92 @@ var initCommand = new Command("init").description("Initialize Refly CLI, install
         authenticated: true
       });
     }
+    if (pretty && tty) {
+      printLogo({ color: useColor });
+      println("");
+      println("Initializing Refly CLI...");
+      println("");
+    }
     const config = loadConfig();
     config.api = {
       endpoint: apiEndpoint
     };
     saveConfig(config);
-    const result = installSkill();
-    print("init", {
-      message: "Refly CLI initialized successfully",
-      configDir: getReflyDir(),
-      apiEndpoint,
-      skillInstalled: result.skillInstalled,
-      skillPath: result.skillPath,
-      commandsInstalled: result.commandsInstalled,
-      commandsPath: result.commandsPath,
-      version: result.version
-    });
+    const installResult = installSkill();
+    if (pretty && tty) {
+      if (installResult.skillInstalled) {
+        printSuccess("Skill files installed");
+      } else {
+        printError2("Skill files installation failed");
+      }
+      if (installResult.commandsInstalled) {
+        printSuccess("Slash commands installed");
+      } else {
+        printError2("Slash commands installation failed");
+      }
+      println("");
+    } else if (!pretty) {
+      print("init", {
+        message: "Refly CLI initialized successfully",
+        configDir: getReflyDir(),
+        apiEndpoint,
+        skillInstalled: installResult.skillInstalled,
+        skillPath: installResult.skillPath,
+        commandsInstalled: installResult.commandsInstalled,
+        commandsPath: installResult.commandsPath,
+        version: installResult.version
+      });
+    }
     if (!skipLogin && !isAuthenticated2) {
-      process.stderr.write("\nStarting authentication...\n");
-      const loginSuccess = await loginWithDeviceFlow();
-      if (!loginSuccess) {
-        process.stderr.write(
-          "\nAuthentication was not completed. You can login later with `refly login`.\n"
-        );
+      if (pretty && tty) {
+        println("Starting authentication...");
+        printDim("A browser window will open for login.");
+        println("");
+      }
+      const loginResult = await loginWithDeviceFlow({ emitOutput: false });
+      if (pretty && tty) {
+        if (loginResult.ok) {
+          printSuccess("Authentication successful");
+          if (loginResult.user?.email) {
+            printDim(`  Welcome, ${loginResult.user.email}!`);
+          }
+        } else {
+          printError2("Authentication was not completed");
+          printDim("  Run `refly login` to authenticate later.");
+        }
+        println("");
+      } else if (!pretty && loginResult.ok) {
+        print("login", {
+          message: "Successfully authenticated",
+          user: loginResult.user
+        });
       }
-    } else if (isAuthenticated2) {
-      process.stderr.write("\nAlready authenticated.\n");
-    } else {
-      process.stderr.write("\nSkipped login. Run `refly login` to authenticate later.\n");
+    } else if (pretty && tty) {
+      if (isAuthenticated2) {
+        printSuccess("Already authenticated");
+        const user = getAuthUser();
+        if (user?.email) {
+          printDim(`  Logged in as ${user.email}`);
+        }
+      } else {
+        printDim("Skipped login. Run `refly login` to authenticate later.");
+      }
+      println("");
+    }
+    if (pretty && tty) {
+      println("Ready to use! Try `refly status` to verify.");
+      return;
+    }
+    if (!pretty) {
+      return ok("init", {
+        message: "Refly CLI initialized successfully",
+        configDir: getReflyDir(),
+        apiEndpoint,
+        skillInstalled: installResult.skillInstalled,
+        commandsInstalled: installResult.commandsInstalled,
+        version: installResult.version,
+        authenticated: !!(getAccessToken() || getApiKey())
+      });
     }
   } catch (error) {
     fail(
@@ -9933,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(
@@ -11465,7 +11731,7 @@ var workflowRunToolcallsCommand = new Command("toolcalls").description("Get all
 });
 
 // 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", "{}").action(async (workflowId, options) => {
+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;
@@ -11479,17 +11745,22 @@ var workflowRunCommand = new Command("run").description("Run workflows and get e
         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: { input }
+      body
     });
     ok("workflow.run", {
-      message: "Workflow run started",
+      message: options.fromNode ? `Workflow run started from node ${options.fromNode}` : "Workflow run started",
       runId: result.runId,
       workflowId: result.workflowId,
       status: result.status,
+      startNode: options.fromNode || void 0,
       createdAt: result.createdAt,
-      nextStep: `Check status with \`refly workflow run get ${result.runId}\``
+      nextStep: `Check status with \`refly workflow status ${result.runId}\``
     });
   } catch (error) {
     if (error instanceof CLIError) {
@@ -11709,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();
@@ -11788,29 +12159,56 @@ async function fetchAndCache() {
 
 // src/commands/node/run.ts
 init_cjs_shims();
-var nodeRunCommand = new Command("run").description("Run a single node for debugging").requiredOption("--type <nodeType>", "Node type to run").requiredOption("--input <json>", "Input data as JSON").action(async (options) => {
+var nodeRunCommand = new Command("run").description("Run a single node for debugging (currently supports skillResponse only)").requiredOption("--type <nodeType>", 'Node type to run (e.g., "skillResponse")').option("--query <query>", "Query text for skillResponse node").option("--input <json>", "Full input data as JSON (alternative to --query)").option("--config <json>", 'Node configuration as JSON (e.g., {"modelItemId": "..."})').action(async (options) => {
   try {
-    let input;
-    try {
-      input = JSON.parse(options.input);
-    } catch {
-      fail(ErrorCodes.INVALID_INPUT, "Invalid JSON in --input", {
-        hint: "Ensure the input is valid JSON"
-      });
+    let input = {};
+    if (options.query) {
+      input = { query: options.query };
+    } else if (options.input) {
+      try {
+        input = JSON.parse(options.input);
+      } catch {
+        fail(ErrorCodes.INVALID_INPUT, "Invalid JSON in --input", {
+          hint: "Ensure the input is valid JSON"
+        });
+        return;
+      }
+    }
+    let config = {};
+    if (options.config) {
+      try {
+        config = JSON.parse(options.config);
+      } catch {
+        fail(ErrorCodes.INVALID_INPUT, "Invalid JSON in --config", {
+          hint: "Ensure the config is valid JSON"
+        });
+        return;
+      }
     }
     const result = await apiRequest("/v1/cli/node/run", {
       method: "POST",
       body: {
-        type: options.type,
-        input
-      }
-    });
-    ok("node.run", {
-      type: options.type,
-      result: result.result,
-      metrics: result.metrics,
-      logs: result.logs ?? []
-    });
+        nodeType: options.type,
+        input,
+        config
+      }
+    });
+    if (result.status === "completed") {
+      ok("node.run", {
+        nodeType: result.nodeType,
+        status: result.status,
+        output: result.output,
+        duration: result.duration,
+        tokenUsage: result.tokenUsage
+      });
+    } else {
+      fail(ErrorCodes.EXECUTION_FAILED, result.error || "Node execution failed", {
+        details: {
+          nodeType: result.nodeType,
+          output: result.output
+        }
+      });
+    }
   } catch (error) {
     if (error instanceof CLIError) {
       fail(error.code, error.message, { details: error.details, hint: error.hint });
@@ -11827,24 +12225,65 @@ init_cjs_shims();
 var nodeResultCommand = new Command("result").description("Get node execution result").argument("<resultId>", "Node result ID").option("--include-steps", "Include detailed step information").option("--include-messages", "Include chat messages").option("--include-tool-calls", "Include tool call details").action(async (resultId, options) => {
   try {
     const result = await apiRequest(`/v1/cli/action/result?resultId=${resultId}`);
+    let totalTokenUsage;
+    if (result.steps?.length) {
+      totalTokenUsage = { input: 0, output: 0, reasoning: 0 };
+      for (const step of result.steps) {
+        if (step.tokenUsage?.length) {
+          for (const usage of step.tokenUsage) {
+            totalTokenUsage.input += usage.inputTokens || 0;
+            totalTokenUsage.output += usage.outputTokens || 0;
+            totalTokenUsage.reasoning += usage.reasoningTokens || 0;
+          }
+        }
+      }
+    }
+    const lastStep = result.steps?.[result.steps.length - 1];
+    const content = lastStep?.content;
     const output = {
       resultId: result.resultId,
+      version: result.version,
+      title: result.title,
       status: result.status,
-      content: result.content,
-      tokenUsage: result.tokenUsage
+      content,
+      tokenUsage: totalTokenUsage,
+      createdAt: result.createdAt,
+      updatedAt: result.updatedAt
     };
     if (options.includeSteps && result.steps) {
-      output.steps = result.steps.map((step) => ({
-        stepIndex: step.stepIndex,
+      output.steps = result.steps.map((step, index) => ({
+        stepIndex: index,
+        name: step.name,
         content: step.content,
+        reasoningContent: step.reasoningContent,
         toolCallsCount: step.toolCalls?.length ?? 0
       }));
     }
-    if (options.includeToolCalls && result.toolCalls) {
-      output.toolCalls = result.toolCalls;
+    if (options.includeToolCalls && result.steps) {
+      const allToolCalls = [];
+      for (const step of result.steps) {
+        if (step.toolCalls?.length) {
+          for (const tc of step.toolCalls) {
+            allToolCalls.push({
+              callId: tc.callId,
+              toolName: tc.toolName,
+              status: tc.status,
+              error: tc.error
+            });
+          }
+        }
+      }
+      output.toolCalls = allToolCalls;
     }
     if (options.includeMessages && result.messages) {
-      output.messages = result.messages;
+      output.messages = result.messages.map((msg) => ({
+        messageId: msg.messageId,
+        type: msg.type,
+        content: msg.content
+      }));
+    }
+    if (result.errors?.length) {
+      output.errors = result.errors;
     }
     ok("node.result", output);
   } catch (error) {
@@ -11858,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();
@@ -11872,7 +12338,7 @@ var toolCallsCommand = new Command("calls").description("Get tool execution resu
     if (options.version) {
       params.set("version", options.version);
     }
-    const result = await apiRequest(`/v1/cli/toolcall?${params}`);
+    const result = await apiRequest(`/v1/cli/tool-call?${params}`);
     ok("tool.calls", {
       resultId: options.resultId,
       version: result.version,
@@ -11909,7 +12375,7 @@ var toolGetCommand = new Command("get").description("Get full details for a sing
       params.set("sanitizeForDisplay", "false");
     }
     const queryString = params.toString();
-    const url = `/v1/cli/toolcall/${callId}${queryString ? `?${queryString}` : ""}`;
+    const url = `/v1/cli/tool-call/${callId}${queryString ? `?${queryString}` : ""}`;
     const result = await apiRequest(url);
     ok("tool.detail", {
       callId: result.callId,