@powerformer/refly-cli 0.1.4 → 0.1.6

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",
@@ -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://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(
@@ -11465,7 +11612,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 +11626,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) {
@@ -11788,29 +11940,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 +12006,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) {
@@ -11872,7 +12092,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 +12129,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,