@runtypelabs/cli 2.6.2 → 2.7.0

package/dist/index.js

@@ -15401,8 +15401,8 @@ var require_provider_routing = __commonJS({
 });
 
 // src/index.ts
-import { Command as Command21 } from "commander";
-import chalk28 from "chalk";
+import { Command as Command22 } from "commander";
+import chalk29 from "chalk";
 import { config as loadEnv } from "dotenv";
 
 // src/commands/auth.ts
@@ -32858,11 +32858,254 @@ flowVersionsCommand.command("publish <flowId>").description("Publish a version")
   await waitUntilExit();
 });
 
+// src/commands/tail.ts
+import { Command as Command21 } from "commander";
+import chalk27 from "chalk";
+function abbreviateId(id) {
+  const underscoreIdx = id.lastIndexOf("_");
+  if (underscoreIdx === -1) {
+    return id.length > 8 ? `${id.slice(0, 8)}...` : id;
+  }
+  const prefix = id.slice(0, underscoreIdx);
+  const suffix = id.slice(underscoreIdx + 1);
+  return `${prefix}_${suffix.slice(0, 4)}...`;
+}
+function formatTime(ts) {
+  const d = new Date(ts);
+  const hh = String(d.getHours()).padStart(2, "0");
+  const mm = String(d.getMinutes()).padStart(2, "0");
+  const ss = String(d.getSeconds()).padStart(2, "0");
+  const ms = String(d.getMilliseconds()).padStart(3, "0");
+  return `${hh}:${mm}:${ss}.${ms}`;
+}
+var LEVEL_COLORS = {
+  debug: chalk27.gray,
+  info: chalk27.blue,
+  warn: chalk27.yellow,
+  error: chalk27.red
+};
+function levelBadge(level, useColor) {
+  const tag = level.toUpperCase().padEnd(5);
+  if (!useColor) return `[${tag}]`;
+  const colorFn = LEVEL_COLORS[level] || chalk27.white;
+  return colorFn(`[${tag}]`);
+}
+function categoryBadge(category, useColor) {
+  if (!useColor) return `[${category}]`;
+  return chalk27.magenta(`[${category}]`);
+}
+function formatTailData(data) {
+  return Object.entries(data).map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`).join(" ");
+}
+function formatContextIds(event, useColor) {
+  const ids = [];
+  if (event.executionId) ids.push(`exec=${abbreviateId(event.executionId)}`);
+  if (event.flowId) ids.push(`flow=${abbreviateId(event.flowId)}`);
+  if (event.agentId) ids.push(`agent=${abbreviateId(event.agentId)}`);
+  if (event.surfaceId) ids.push(`surface=${abbreviateId(event.surfaceId)}`);
+  if (event.requestId) ids.push(`req=${abbreviateId(event.requestId)}`);
+  if (event.conversationId) ids.push(`conv=${abbreviateId(event.conversationId)}`);
+  if (ids.length === 0) return "";
+  const text = ids.join(" ");
+  return useColor ? chalk27.gray(` ${text}`) : ` ${text}`;
+}
+function formatEvent(event, useColor) {
+  const time = useColor ? chalk27.gray(formatTime(event.timestamp)) : formatTime(event.timestamp);
+  const level = levelBadge(event.level, useColor);
+  const cat = categoryBadge(event.category, useColor);
+  const ctx = formatContextIds(event, useColor);
+  const data = event.tailData && Object.keys(event.tailData).length > 0 ? useColor ? chalk27.gray(` | ${formatTailData(event.tailData)}`) : ` | ${formatTailData(event.tailData)}` : "";
+  return `${time} ${level} ${cat} ${event.message}${data}${ctx}`;
+}
+async function consumeSSEStream(reader, options, signal) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const useColor = options.color;
+  while (!signal.aborted) {
+    const { done, value } = await reader.read();
+    if (done) return "eof";
+    buffer += decoder.decode(value, { stream: true });
+    let boundary;
+    while ((boundary = buffer.indexOf("\n\n")) !== -1) {
+      const chunk = buffer.slice(0, boundary);
+      buffer = buffer.slice(boundary + 2);
+      const dataLines = [];
+      for (const line of chunk.split("\n")) {
+        if (line.startsWith("data: ")) {
+          dataLines.push(line.slice(6));
+        }
+      }
+      if (dataLines.length === 0) continue;
+      const raw = dataLines.join("\n");
+      let msg;
+      try {
+        msg = JSON.parse(raw);
+      } catch {
+        continue;
+      }
+      switch (msg.type) {
+        case "tail_event":
+          if (options.json) {
+            process.stdout.write(JSON.stringify(msg.event) + "\n");
+          } else {
+            process.stdout.write(formatEvent(msg.event, useColor) + "\n");
+          }
+          break;
+        case "tail_gap":
+          process.stderr.write(
+            (useColor ? chalk27.yellow(`[warn] Dropped ${msg.droppedCount} event(s) between ${msg.fromTimestamp} and ${msg.toTimestamp}`) : `[warn] Dropped ${msg.droppedCount} event(s) between ${msg.fromTimestamp} and ${msg.toTimestamp}`) + "\n"
+          );
+          break;
+        case "tail_connected":
+          process.stderr.write(
+            (useColor ? chalk27.green(`Connected to tail session ${msg.sessionId}`) : `Connected to tail session ${msg.sessionId}`) + "\n"
+          );
+          break;
+        case "tail_error":
+          process.stderr.write(
+            (useColor ? chalk27.red(`[error] ${msg.error}`) : `[error] ${msg.error}`) + "\n"
+          );
+          break;
+      }
+    }
+  }
+  return "aborted";
+}
+async function createSession(apiUrl, apiKey, filters) {
+  const filter = {};
+  const arrayFields = {
+    flowId: "flowIds",
+    agentId: "agentIds",
+    surfaceId: "surfaceIds",
+    executionId: "executionIds",
+    level: "levels",
+    category: "categories"
+  };
+  for (const [k, v] of Object.entries(filters)) {
+    if (v !== void 0 && arrayFields[k]) {
+      filter[arrayFields[k]] = [v];
+    }
+  }
+  const body = Object.keys(filter).length > 0 ? { filter } : {};
+  const res = await fetch(`${apiUrl}/v1/tail/sessions`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+      "User-Agent": `Runtype-CLI/${getCliVersion()}`
+    },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`Failed to create tail session: ${res.status} ${res.statusText}${text ? ` \u2014 ${text}` : ""}`);
+  }
+  return await res.json();
+}
+async function connectAndStream(sseUrl, apiKey, options, signal) {
+  const res = await fetch(sseUrl, {
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      Accept: "text/event-stream",
+      "User-Agent": `Runtype-CLI/${getCliVersion()}`
+    },
+    signal
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`SSE connection failed: ${res.status} ${res.statusText}${text ? ` \u2014 ${text}` : ""}`);
+  }
+  if (!res.body) {
+    throw new Error("SSE response has no body");
+  }
+  const reader = res.body.getReader();
+  try {
+    return await consumeSSEStream(reader, options, signal);
+  } finally {
+    reader.releaseLock();
+  }
+}
+var BASE_DELAY_MS = 1e3;
+var MAX_DELAY_MS = 3e4;
+var MAX_ATTEMPTS = 10;
+async function runTail(options) {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const apiUrl = getApiUrl();
+  const filters = {
+    flowId: options.flow,
+    agentId: options.agent,
+    surfaceId: options.surface,
+    executionId: options.execution,
+    level: options.level,
+    category: options.category
+  };
+  const useColor = options.color;
+  const activeFilters = Object.entries(filters).filter(([, v]) => v !== void 0).map(([k, v]) => `${k}=${v}`);
+  process.stderr.write(
+    (useColor ? chalk27.gray(`Connecting to ${apiUrl}...${activeFilters.length ? ` filters: ${activeFilters.join(", ")}` : ""}`) : `Connecting to ${apiUrl}...${activeFilters.length ? ` filters: ${activeFilters.join(", ")}` : ""}`) + "\n"
+  );
+  const controller = new AbortController();
+  let shuttingDown = false;
+  const shutdown = () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    process.stderr.write(
+      (useColor ? chalk27.gray("\nDisconnecting...") : "\nDisconnecting...") + "\n"
+    );
+    controller.abort();
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  let attempt = 0;
+  while (!shuttingDown && attempt < MAX_ATTEMPTS) {
+    try {
+      const session = await createSession(apiUrl, apiKey, filters);
+      attempt = 0;
+      const result = await connectAndStream(session.sseUrl, apiKey, options, controller.signal);
+      if (result === "aborted" || shuttingDown) break;
+      process.stderr.write(
+        (useColor ? chalk27.yellow("Stream ended, reconnecting...") : "Stream ended, reconnecting...") + "\n"
+      );
+    } catch (err) {
+      if (shuttingDown || controller.signal.aborted) break;
+      attempt++;
+      const delay = Math.min(BASE_DELAY_MS * Math.pow(2, attempt - 1), MAX_DELAY_MS);
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(
+        (useColor ? chalk27.red(`Connection error: ${message}`) : `Connection error: ${message}`) + "\n"
+      );
+      if (attempt >= MAX_ATTEMPTS) {
+        process.stderr.write(
+          (useColor ? chalk27.red(`Max reconnect attempts (${MAX_ATTEMPTS}) reached. Exiting.`) : `Max reconnect attempts (${MAX_ATTEMPTS}) reached. Exiting.`) + "\n"
+        );
+        process.exit(1);
+      }
+      process.stderr.write(
+        (useColor ? chalk27.gray(`Retrying in ${delay / 1e3}s (attempt ${attempt}/${MAX_ATTEMPTS})...`) : `Retrying in ${delay / 1e3}s (attempt ${attempt}/${MAX_ATTEMPTS})...`) + "\n"
+      );
+      await new Promise((resolve8) => {
+        const timer = setTimeout(resolve8, delay);
+        const onAbort = () => {
+          clearTimeout(timer);
+          resolve8();
+        };
+        controller.signal.addEventListener("abort", onAbort, { once: true });
+      });
+    }
+  }
+  process.removeListener("SIGINT", shutdown);
+  process.removeListener("SIGTERM", shutdown);
+}
+var tailCommand = new Command21("tail").description("Stream live execution logs from the Runtype API").option("--flow <id>", "Filter by flow ID").option("--agent <id>", "Filter by agent ID").option("--surface <id>", "Filter by surface ID").option("--execution <id>", "Filter by execution ID").option("--level <level>", "Filter by level (debug/info/warn/error)").option("--category <category>", "Filter by category (execution/agent/tool/model/system/error)").option("--json", "Output raw JSON (one object per line)").option("--no-color", "Disable color output").action(async (options) => {
+  await runTail(options);
+});
+
 // src/index.ts
 init_credential_store();
 
 // src/lib/update-check.ts
-import chalk27 from "chalk";
+import chalk28 from "chalk";
 import Conf3 from "conf";
 var UPDATE_CHECK_INTERVAL_MS = 12 * 60 * 60 * 1e3;
 var UPDATE_NOTIFY_INTERVAL_MS = 24 * 60 * 60 * 1e3;
@@ -32956,7 +33199,7 @@ function notifyFromCachedCliUpdate(args, options = {}) {
     console.error(message);
   });
   notify(
-    `${chalk27.yellow("Update available:")} ${chalk27.red(currentVersion)} ${chalk27.gray("->")} ${chalk27.green(latestVersion)}  ${chalk27.gray(`(${getUpgradeCommand()})`)}`
+    `${chalk28.yellow("Update available:")} ${chalk28.red(currentVersion)} ${chalk28.gray("->")} ${chalk28.green(latestVersion)}  ${chalk28.gray(`(${getUpgradeCommand()})`)}`
   );
   store.set("lastNotifiedAt", now.toISOString());
   store.set("lastNotifiedVersion", latestVersion);
@@ -32998,7 +33241,7 @@ function maybeNotifyAboutCliUpdate(args, options = {}) {
 // src/index.ts
 loadEnv();
 setCliTitle();
-var program = new Command21();
+var program = new Command22();
 program.name("runtype").description("CLI for Runtype AI Platform").version(getCliVersion()).option("-v, --verbose", "Enable verbose output").option("--api-url <url>", "Override API URL").option("--json", "Output in JSON format");
 program.addCommand(initCommand);
 program.addCommand(loginCommand);
@@ -33021,6 +33264,7 @@ program.addCommand(analyticsCommand);
 program.addCommand(billingCommand);
 program.addCommand(flowVersionsCommand);
 program.addCommand(createMarathonCommand());
+program.addCommand(tailCommand);
 program.exitOverride();
 try {
   const userArgs = process.argv.slice(2);
@@ -33034,15 +33278,15 @@ try {
 } catch (error) {
   const commanderError = error;
   if (commanderError.code === "commander.missingArgument") {
-    console.error(chalk28.red(`Error: ${commanderError.message}`));
+    console.error(chalk29.red(`Error: ${commanderError.message}`));
     process.exit(1);
   } else if (commanderError.code === "commander.unknownOption") {
-    console.error(chalk28.red(`Error: ${commanderError.message}`));
+    console.error(chalk29.red(`Error: ${commanderError.message}`));
     process.exit(1);
   } else if (commanderError.code === "commander.help" || commanderError.code === "commander.version") {
     process.exit(0);
   } else {
-    console.error(chalk28.red("An unexpected error occurred:"));
+    console.error(chalk29.red("An unexpected error occurred:"));
     console.error(error);
     process.exit(1);
   }
@@ -33051,12 +33295,12 @@ async function handleNoCommand() {
   const store = new CredentialStore();
   const hasCredentials = await store.hasCredentials();
   if (!hasCredentials) {
-    console.log(chalk28.cyan("\nWelcome to Runtype CLI!\n"));
+    console.log(chalk29.cyan("\nWelcome to Runtype CLI!\n"));
     console.log("It looks like this is your first time. Run the setup wizard:");
-    console.log(`  ${chalk28.green("runtype init")}
+    console.log(`  ${chalk29.green("runtype init")}
 `);
     console.log("Or see all available commands:");
-    console.log(`  ${chalk28.green("runtype --help")}
+    console.log(`  ${chalk29.green("runtype --help")}
 `);
   } else {
     try {