@runtypelabs/cli 0.1.8 → 0.1.10

package/dist/index.js

@@ -6,6 +6,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -23,59 +30,196 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@1.21.7_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.5.1_jiti@1.21.7_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/auth/credential-store.ts
+var credential_store_exports = {};
+__export(credential_store_exports, {
+  CredentialStore: () => CredentialStore
+});
+function createConf(encryptionKey) {
+  return new import_conf.default({
+    projectName: "runtype-cli",
+    projectSuffix: "",
+    configName: "credentials",
+    encryptionKey,
+    cwd: CREDENTIALS_DIR
+  });
+}
+function isCorruptStoreError(error) {
+  if (error instanceof SyntaxError) return true;
+  const message = error instanceof Error ? error.message : String(error);
+  return typeof message === "string" && message.includes("JSON");
+}
+var import_conf, import_crypto2, import_fs, import_os, import_path, CREDENTIALS_DIR, CREDENTIALS_FILENAME, CREDENTIALS_PATH, CredentialStore;
+var init_credential_store = __esm({
+  "src/auth/credential-store.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_conf = __toESM(require("conf"));
+    import_crypto2 = __toESM(require("crypto"));
+    import_fs = __toESM(require("fs"));
+    import_os = __toESM(require("os"));
+    import_path = __toESM(require("path"));
+    CREDENTIALS_DIR = import_path.default.join(import_os.default.homedir(), ".runtype");
+    CREDENTIALS_FILENAME = "credentials.json";
+    CREDENTIALS_PATH = import_path.default.join(CREDENTIALS_DIR, CREDENTIALS_FILENAME);
+    CredentialStore = class {
+      config;
+      encryptionKey;
+      constructor() {
+        this.encryptionKey = this.getMachineKey();
+        try {
+          this.config = createConf(this.encryptionKey);
+        } catch (error) {
+          if (isCorruptStoreError(error)) {
+            try {
+              if (import_fs.default.existsSync(CREDENTIALS_PATH)) {
+                import_fs.default.unlinkSync(CREDENTIALS_PATH);
+              }
+            } catch {
+            }
+            this.config = createConf(this.encryptionKey);
+          } else {
+            throw error;
+          }
+        }
+      }
+      getMachineKey() {
+        const hostname = import_os.default.hostname();
+        const username = import_os.default.userInfo().username;
+        return import_crypto2.default.createHash("sha256").update(`runtype-cli-${hostname}-${username}`).digest("hex").substring(0, 32);
+      }
+      async saveCredentials(credentials) {
+        const configData = {
+          apiKey: this.encrypt(credentials.apiKey),
+          userId: credentials.userId,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          lastUsed: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        if (credentials.orgId !== void 0) {
+          configData.orgId = credentials.orgId;
+        }
+        if (credentials.apiUrl !== void 0) {
+          configData.apiUrl = credentials.apiUrl;
+        }
+        this.config.set(configData);
+      }
+      async getApiKey() {
+        const encrypted = this.config.get("apiKey");
+        if (!encrypted) return null;
+        this.config.set("lastUsed", (/* @__PURE__ */ new Date()).toISOString());
+        return this.decrypt(encrypted);
+      }
+      async getCredentials() {
+        const stored = this.config.store;
+        if (!stored.apiKey) return null;
+        return {
+          ...stored,
+          apiKey: this.decrypt(stored.apiKey)
+        };
+      }
+      async clearCredentials() {
+        this.config.clear();
+      }
+      async hasCredentials() {
+        return !!this.config.get("apiKey");
+      }
+      encrypt(text) {
+        const algorithm = "aes-256-cbc";
+        const key = Buffer.from(this.encryptionKey);
+        const iv = import_crypto2.default.randomBytes(16);
+        const cipher = import_crypto2.default.createCipheriv(algorithm, key, iv);
+        let encrypted = cipher.update(text, "utf8", "hex");
+        encrypted += cipher.final("hex");
+        return iv.toString("hex") + ":" + encrypted;
+      }
+      decrypt(text) {
+        const algorithm = "aes-256-cbc";
+        const key = Buffer.from(this.encryptionKey);
+        const [ivHex, encrypted] = text.split(":");
+        const iv = Buffer.from(ivHex, "hex");
+        const decipher = import_crypto2.default.createDecipheriv(algorithm, key, iv);
+        let decrypted = decipher.update(encrypted, "hex", "utf8");
+        decrypted += decipher.final("utf8");
+        return decrypted;
+      }
+    };
+  }
+});
+
 // src/index.ts
-var import_commander9 = require("commander");
-var import_chalk10 = __toESM(require("chalk"));
+init_cjs_shims();
+var import_commander20 = require("commander");
+var import_chalk24 = __toESM(require("chalk"));
 var import_dotenv = require("dotenv");
 
 // src/commands/auth.ts
+init_cjs_shims();
 var import_commander = require("commander");
 var import_chalk = __toESM(require("chalk"));
 var import_ora = __toESM(require("ora"));
 
 // src/auth/oauth-manager.ts
+init_cjs_shims();
 var import_open = __toESM(require("open"));
 var import_crypto = __toESM(require("crypto"));
 
 // src/auth/callback-server.ts
+init_cjs_shims();
 var import_express = __toESM(require("express"));
 var CallbackServer = class {
   server = null;
   app;
+  codeResolve;
+  codeReject;
+  codePromise;
   constructor() {
     this.app = (0, import_express.default)();
+    this.codePromise = new Promise((resolve, reject) => {
+      this.codeResolve = resolve;
+      this.codeReject = reject;
+    });
+    this.app.get("/callback", (req, res) => {
+      const { code, error } = req.query;
+      if (error) {
+        res.send(this.errorHTML(error));
+        this.codeReject(new Error(error));
+        return;
+      }
+      if (!code) {
+        res.send(this.errorHTML("No authorization code received"));
+        this.codeReject(new Error("No authorization code received"));
+        return;
+      }
+      res.send(this.successHTML());
+      this.codeResolve(code);
+      setTimeout(() => this.stop(), 1e3);
+    });
+    this.app.get("/health", (_req, res) => {
+      res.json({ status: "ok" });
+    });
   }
   async start(port = 8765) {
-    return new Promise((resolve, reject) => {
-      this.app.get("/callback", (req, res) => {
-        const { code, error } = req.query;
-        if (error) {
-          res.send(this.errorHTML(error));
-          reject(new Error(error));
-          return;
-        }
-        if (!code) {
-          res.send(this.errorHTML("No authorization code received"));
-          reject(new Error("No authorization code received"));
-          return;
-        }
-        res.send(this.successHTML());
-        resolve(code);
-        setTimeout(() => this.stop(), 1e3);
-      });
-      this.app.get("/health", (_req, res) => {
-        res.json({ status: "ok" });
-      });
+    return new Promise((resolveStart, rejectStart) => {
       this.server = this.app.listen(port, () => {
-        console.log(`Callback server listening on port ${port}`);
+        const address = this.server?.address();
+        const actualPort = address && typeof address === "object" && "port" in address ? address.port : port;
+        console.log(`Callback server listening on port ${actualPort}`);
+        resolveStart({ actualPort, codePromise: this.codePromise });
       });
       this.server.on("error", (error) => {
         if (error.code === "EADDRINUSE") {
           console.log(`Port ${port} is in use, trying ${port + 1}...`);
           this.server = null;
-          this.start(port + 1).then(resolve).catch(reject);
+          this.start(port + 1).then(resolveStart).catch(rejectStart);
         } else {
-          reject(error);
+          rejectStart(error);
         }
       });
     });
@@ -252,9 +396,9 @@ var OAuthManager = class {
     const codeVerifier = import_crypto.default.randomBytes(32).toString("base64url");
     const codeChallenge = import_crypto.default.createHash("sha256").update(codeVerifier).digest("base64url");
     const callbackServer = new CallbackServer();
-    const port = await this.findAvailablePort();
-    const codePromise = callbackServer.start(port);
-    const redirectUri = `http://localhost:${port}/callback`;
+    const requestedPort = await this.findAvailablePort();
+    const { actualPort, codePromise } = await callbackServer.start(requestedPort);
+    const redirectUri = `http://localhost:${actualPort}/callback`;
     const authUrl = new URL(`${this.dashboardUrl.replace(/\/$/, "")}/${mode}`);
     authUrl.searchParams.set("redirect_uri", redirectUri);
     authUrl.searchParams.set("cli", "true");
@@ -266,7 +410,7 @@ var OAuthManager = class {
     console.log(`If the browser doesn't open, visit: ${authUrl}`);
     try {
       await (0, import_open.default)(authUrl.toString());
-    } catch (error) {
+    } catch (_error) {
       console.log("Failed to open browser automatically. Please visit the URL above.");
     }
     console.log("\u23F3 Waiting for authentication...");
@@ -284,7 +428,11 @@ var OAuthManager = class {
   }
 };
 
+// src/auth/api-key-manager.ts
+init_cjs_shims();
+
 // src/config/env.ts
+init_cjs_shims();
 function getApiUrl() {
   return process.env.RUNTYPE_API_URL || "https://api.runtype.com";
 }
@@ -363,7 +511,7 @@ var ApiKeyManager = class {
   }
   async getCurrentUser(apiKey, apiUrl) {
     const baseUrl = apiUrl || getApiUrl();
-    const response = await fetch(`${baseUrl}/auth/me`, {
+    const response = await fetch(`${baseUrl}/${getApiVersion()}/auth/me`, {
       headers: {
         Authorization: `Bearer ${apiKey}`,
         "Content-Type": "application/json"
@@ -380,86 +528,8 @@ var ApiKeyManager = class {
   }
 };
 
-// src/auth/credential-store.ts
-var import_conf = __toESM(require("conf"));
-var import_crypto2 = __toESM(require("crypto"));
-var import_os = __toESM(require("os"));
-var import_path = __toESM(require("path"));
-var CredentialStore = class {
-  config;
-  encryptionKey;
-  constructor() {
-    this.encryptionKey = this.getMachineKey();
-    this.config = new import_conf.default({
-      projectName: "runtype-cli",
-      projectSuffix: "",
-      configName: "credentials",
-      encryptionKey: this.encryptionKey,
-      cwd: import_path.default.join(import_os.default.homedir(), ".runtype")
-    });
-  }
-  getMachineKey() {
-    const hostname = import_os.default.hostname();
-    const username = import_os.default.userInfo().username;
-    return import_crypto2.default.createHash("sha256").update(`runtype-cli-${hostname}-${username}`).digest("hex").substring(0, 32);
-  }
-  async saveCredentials(credentials) {
-    const configData = {
-      apiKey: this.encrypt(credentials.apiKey),
-      userId: credentials.userId,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      lastUsed: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    if (credentials.orgId !== void 0) {
-      configData.orgId = credentials.orgId;
-    }
-    if (credentials.apiUrl !== void 0) {
-      configData.apiUrl = credentials.apiUrl;
-    }
-    this.config.set(configData);
-  }
-  async getApiKey() {
-    const encrypted = this.config.get("apiKey");
-    if (!encrypted) return null;
-    this.config.set("lastUsed", (/* @__PURE__ */ new Date()).toISOString());
-    return this.decrypt(encrypted);
-  }
-  async getCredentials() {
-    const stored = this.config.store;
-    if (!stored.apiKey) return null;
-    return {
-      ...stored,
-      apiKey: this.decrypt(stored.apiKey)
-    };
-  }
-  async clearCredentials() {
-    this.config.clear();
-  }
-  async hasCredentials() {
-    return !!this.config.get("apiKey");
-  }
-  encrypt(text) {
-    const algorithm = "aes-256-cbc";
-    const key = Buffer.from(this.encryptionKey);
-    const iv = import_crypto2.default.randomBytes(16);
-    const cipher = import_crypto2.default.createCipheriv(algorithm, key, iv);
-    let encrypted = cipher.update(text, "utf8", "hex");
-    encrypted += cipher.final("hex");
-    return iv.toString("hex") + ":" + encrypted;
-  }
-  decrypt(text) {
-    const algorithm = "aes-256-cbc";
-    const key = Buffer.from(this.encryptionKey);
-    const [ivHex, encrypted] = text.split(":");
-    const iv = Buffer.from(ivHex, "hex");
-    const decipher = import_crypto2.default.createDecipheriv(algorithm, key, iv);
-    let decrypted = decipher.update(encrypted, "hex", "utf8");
-    decrypted += decipher.final("utf8");
-    return decrypted;
-  }
-};
-
 // src/commands/auth.ts
+init_credential_store();
 var authCommand = new import_commander.Command("auth").description("Manage authentication");
 authCommand.command("signup").description("Create a new Runtype account").option("--api-url <url>", "Custom API URL").action(async (options) => {
   const spinner = (0, import_ora.default)("Initializing authentication...").start();
@@ -492,8 +562,9 @@ authCommand.command("signup").description("Create a new Runtype account").option
     console.log("  runtype records create --help");
     console.log("  runtype talk");
   } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
     spinner.fail("Authentication failed");
-    console.error(import_chalk.default.red(error.message));
+    console.error(import_chalk.default.red(message));
     process.exit(1);
   }
 });
@@ -512,14 +583,17 @@ authCommand.command("login").description("Login to existing account").option("--
       await store.saveCredentials({
         apiKey: options.apiKey,
         userId: userData.user_id,
+        // @snake-case-ok: API auth/me response
         orgId: userData.org_id ?? void 0,
+        // @snake-case-ok: API auth/me response
         apiUrl: options.apiUrl || getApiUrl()
       });
       spinner2.succeed("Logged in successfully!");
       console.log(import_chalk.default.green(`Welcome back! User ID: ${userData.user_id}`));
     } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
       spinner2.fail("Login failed");
-      console.error(import_chalk.default.red(error.message));
+      console.error(import_chalk.default.red(message));
       process.exit(1);
     }
     return;
@@ -548,8 +622,9 @@ authCommand.command("login").description("Login to existing account").option("--
     spinner.succeed("Logged in successfully!");
     console.log(import_chalk.default.green(`Welcome back! User ID: ${userId}`));
   } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
     spinner.fail("Login failed");
-    console.error(import_chalk.default.red(error.message));
+    console.error(import_chalk.default.red(message));
     process.exit(1);
   }
 });
@@ -573,7 +648,8 @@ authCommand.command("status").description("Show authentication status").action(a
       console.log(`Org ID: ${credentials.orgId || "none"}`);
     }
   } catch (error) {
-    console.error(import_chalk.default.red("Error checking auth status:"), error.message);
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(import_chalk.default.red("Error checking auth status:"), message);
   }
 });
 authCommand.command("logout").description("Remove stored credentials").action(async () => {
@@ -586,7 +662,7 @@ authCommand.command("logout").description("Remove stored credentials").action(as
   await store.clearCredentials();
   console.log(import_chalk.default.green("\u2713 Logged out successfully"));
 });
-authCommand.command("whoami").description("Display current user information").action(async () => {
+authCommand.command("whoami").description("Display current user information").option("--json", "Output as JSON").action(async (options) => {
   const store = new CredentialStore();
   const credentials = await store.getCredentials();
   if (!credentials || !credentials.apiKey) {
@@ -598,7 +674,38 @@ authCommand.command("whoami").description("Display current user information").ac
   try {
     const apiKeyManager = new ApiKeyManager();
     const user = await apiKeyManager.getCurrentUser(credentials.apiKey, credentials.apiUrl);
+    let billingInfo = null;
+    try {
+      const baseUrl = credentials.apiUrl || getApiUrl();
+      const billingResponse = await fetch(`${baseUrl}/${getApiVersion()}/billing/status`, {
+        headers: {
+          Authorization: `Bearer ${credentials.apiKey}`,
+          "Content-Type": "application/json"
+        }
+      });
+      if (billingResponse.ok) {
+        billingInfo = await billingResponse.json();
+      }
+    } catch {
+    }
     spinner.stop();
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            // @snake-case-ok: API auth/me response uses snake_case
+            userId: user.user_id,
+            // @snake-case-ok: API auth/me response uses snake_case
+            orgId: user.org_id,
+            apiUrl: credentials.apiUrl || getApiUrl(),
+            billing: billingInfo
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
     console.log(import_chalk.default.cyan("Current User:"));
     console.log(`  User ID: ${user.user_id}`);
     console.log(`  Organization: ${user.org_id || "Personal"}`);
@@ -606,207 +713,609 @@ authCommand.command("whoami").description("Display current user information").ac
     console.log(`  API URL: ${credentials.apiUrl || getApiUrl()}`);
     console.log(`  Created: ${credentials.createdAt}`);
     console.log(`  Last Used: ${credentials.lastUsed}`);
+    if (billingInfo) {
+      const plan = billingInfo.planName || billingInfo.plan;
+      if (plan) {
+        console.log(`  Plan: ${import_chalk.default.green(plan)}`);
+      }
+      const usage = billingInfo.usage;
+      if (usage) {
+        const limit = usage.executionsLimit ? `/${usage.executionsLimit}` : "";
+        console.log(`  Executions: ${usage.executionsUsed ?? 0}${limit}`);
+      }
+    }
   } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
     spinner.fail("Failed to get user information");
-    console.error(import_chalk.default.red(error.message));
+    console.error(import_chalk.default.red(message));
     console.log("\nYou may need to login again: runtype auth login");
     process.exit(1);
   }
 });
 
 // src/commands/flows.ts
+init_cjs_shims();
 var import_commander2 = require("commander");
-var import_chalk2 = __toESM(require("chalk"));
+var import_chalk5 = __toESM(require("chalk"));
+var import_ora3 = __toESM(require("ora"));
+var import_fs2 = require("fs");
+var import_sdk = require("@runtypelabs/sdk");
+
+// src/lib/ensure-auth.ts
+init_cjs_shims();
+var import_chalk3 = __toESM(require("chalk"));
 var import_ora2 = __toESM(require("ora"));
-var isFlowSummary = (value) => {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const record = value;
-  return typeof record.id === "string" && typeof record.name === "string";
-};
-var isFlowListResponse = (value) => {
-  if (!value || typeof value !== "object") {
-    return false;
+init_credential_store();
+
+// src/lib/interactive.ts
+init_cjs_shims();
+var import_readline = __toESM(require("readline"));
+var import_chalk2 = __toESM(require("chalk"));
+async function promptText(message, options) {
+  const rl = import_readline.default.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+  const suffix = options?.default ? ` (${options.default})` : "";
+  return new Promise((resolve) => {
+    rl.question(import_chalk2.default.cyan(`${message}${suffix}: `), (answer) => {
+      rl.close();
+      const trimmed = answer.trim();
+      resolve(trimmed || options?.default || "");
+    });
+  });
+}
+async function promptConfirm(message, options) {
+  const defaultYes = options?.default !== false;
+  const hint = defaultYes ? "Y/n" : "y/N";
+  const rl = import_readline.default.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+  return new Promise((resolve) => {
+    rl.question(import_chalk2.default.cyan(`${message} (${hint}): `), (answer) => {
+      rl.close();
+      const trimmed = answer.trim().toLowerCase();
+      if (trimmed === "") {
+        resolve(defaultYes);
+      } else {
+        resolve(trimmed === "y" || trimmed === "yes");
+      }
+    });
+  });
+}
+async function promptSelect(message, choices) {
+  console.log(import_chalk2.default.cyan(`
+${message}`));
+  choices.forEach((choice, index) => {
+    const desc = choice.description ? import_chalk2.default.gray(` - ${choice.description}`) : "";
+    console.log(`  ${import_chalk2.default.green(`${index + 1})`)} ${choice.label}${desc}`);
+  });
+  const rl = import_readline.default.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+  return new Promise((resolve) => {
+    const ask = () => {
+      rl.question(import_chalk2.default.cyan(`
+Select (1-${choices.length}): `), (answer) => {
+        const num = parseInt(answer.trim(), 10);
+        if (num >= 1 && num <= choices.length) {
+          rl.close();
+          resolve(choices[num - 1].value);
+        } else {
+          console.log(import_chalk2.default.red(`Please enter a number between 1 and ${choices.length}`));
+          ask();
+        }
+      });
+    };
+    ask();
+  });
+}
+
+// src/lib/ensure-auth.ts
+async function ensureAuth(options) {
+  const store = new CredentialStore();
+  const apiKey = await store.getApiKey();
+  if (apiKey) {
+    return apiKey;
   }
-  const record = value;
-  if (record.data !== void 0) {
-    if (!Array.isArray(record.data) || !record.data.every(isFlowSummary)) {
-      return false;
+  console.log(import_chalk3.default.yellow("\nAuthentication required."));
+  const shouldLogin = await promptConfirm("Would you like to log in now?", { default: true });
+  if (!shouldLogin) {
+    console.log(import_chalk3.default.gray(`Run "runtype auth login" when you're ready.`));
+    if (options?.exitOnFailure !== false) {
+      process.exit(1);
     }
+    return null;
   }
-  if (record.pagination !== void 0 && (typeof record.pagination !== "object" || record.pagination === null)) {
-    return false;
+  const method = await promptSelect("How would you like to authenticate?", [
+    { label: "Browser login", value: "browser", description: "Sign in via your browser" },
+    { label: "API key", value: "apikey", description: "Paste an existing API key" }
+  ]);
+  if (method === "apikey") {
+    return handleApiKeyLogin(store, options?.apiUrl);
   }
-  return true;
-};
-var flowsCommand = new import_commander2.Command("flows").description("Manage flows");
-flowsCommand.command("list").description("List all flows").option("--json", "Output as JSON").action(async (options) => {
-  const store = new CredentialStore();
-  const apiKey = await store.getApiKey();
-  if (!apiKey) {
-    console.log(import_chalk2.default.yellow("Not authenticated. Please run: runtype auth login"));
-    process.exit(1);
+  return handleBrowserLogin(store, options?.apiUrl);
+}
+async function handleApiKeyLogin(store, apiUrl) {
+  const key = await promptText("Enter your API key");
+  if (!key) {
+    console.log(import_chalk3.default.red("No API key provided."));
+    return null;
   }
-  const spinner = (0, import_ora2.default)("Fetching flows...").start();
+  const spinner = (0, import_ora2.default)("Validating API key...").start();
   try {
-    const response = await fetch(`${getApiUrl()}/flows`, {
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-        "Content-Type": "application/json"
-      }
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to fetch flows: ${response.statusText}`);
-    }
-    const data = await response.json();
-    spinner.stop();
-    if (options.json) {
-      console.log(JSON.stringify(data, null, 2));
-    } else {
-      if (!isFlowListResponse(data)) {
-        throw new Error("Unexpected flows response format");
-      }
-      console.log(import_chalk2.default.cyan("Your Flows:"));
-      const flowsArray = data.data ?? [];
-      if (flowsArray.length > 0) {
-        flowsArray.forEach((flow) => {
-          console.log(`  ${import_chalk2.default.green(flow.id)} - ${flow.name}`);
-          if (flow.description) {
-            console.log(`    ${import_chalk2.default.gray(flow.description)}`);
-          }
-        });
-        const total = data.pagination?.total_count ?? data.pagination?.total;
-        if (typeof total === "number") {
-          console.log(import_chalk2.default.dim(`
-  Total: ${total} flows`));
-        }
-      } else {
-        console.log(import_chalk2.default.gray("  No flows found"));
-      }
+    const apiKeyManager = new ApiKeyManager();
+    const isValid = await apiKeyManager.validateApiKey(key, apiUrl);
+    if (!isValid) {
+      spinner.fail("Invalid API key");
+      return null;
     }
+    const userData = await apiKeyManager.getCurrentUser(key, apiUrl);
+    await store.saveCredentials({
+      apiKey: key,
+      // @snake-case-ok: API auth/me response uses snake_case
+      userId: userData.user_id,
+      // @snake-case-ok: API auth/me response uses snake_case
+      orgId: userData.org_id ?? void 0,
+      apiUrl: apiUrl || getApiUrl()
+    });
+    spinner.succeed("Logged in successfully!");
+    return key;
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
-    spinner.fail("Failed to fetch flows");
-    console.error(import_chalk2.default.red(message));
-    process.exit(1);
+    spinner.fail("Login failed");
+    console.error(import_chalk3.default.red(message));
+    return null;
   }
-});
-flowsCommand.command("run <id>").description("Execute a flow").option("-r, --record <id>", "Record ID to run with").option("--stream", "Stream the response", true).action(async (flowId, options) => {
-  void options;
-  const store = new CredentialStore();
-  const apiKey = await store.getApiKey();
-  if (!apiKey) {
-    console.log(import_chalk2.default.yellow("Not authenticated. Please run: runtype auth login"));
-    process.exit(1);
+}
+async function handleBrowserLogin(store, apiUrl) {
+  const spinner = (0, import_ora2.default)("Initializing authentication...").start();
+  try {
+    const oauth = new OAuthManager({
+      clerkPublishableKey: getClerkPublishableKey(),
+      dashboardUrl: getDashboardUrl()
+    });
+    spinner.text = "Waiting for browser authentication...";
+    const sessionToken = await oauth.authenticate("sign-in");
+    spinner.text = "Getting API key...";
+    const apiKeyManager = new ApiKeyManager();
+    const { key, userId, orgId } = await apiKeyManager.exchangeSessionForApiKey(
+      sessionToken,
+      apiUrl || getApiUrl()
+    );
+    spinner.text = "Storing credentials...";
+    await store.saveCredentials({
+      apiKey: key,
+      userId,
+      orgId,
+      apiUrl: apiUrl || getApiUrl()
+    });
+    spinner.succeed("Logged in successfully!");
+    return key;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Login failed");
+    console.error(import_chalk3.default.red(message));
+    return null;
   }
-  console.log(import_chalk2.default.cyan(`Running flow ${flowId}...`));
-  console.log(import_chalk2.default.gray("Implementation coming soon"));
-});
-flowsCommand.command("create").description("Create a new flow").action(async () => {
-  console.log(import_chalk2.default.cyan("Interactive flow creation coming soon"));
-});
-flowsCommand.command("delete <id>").description("Delete a flow").action(async (flowId) => {
-  console.log(import_chalk2.default.cyan(`Deleting flow ${flowId}...`));
-  console.log(import_chalk2.default.gray("Implementation coming soon"));
-});
+}
 
-// src/commands/records.ts
-var import_commander3 = require("commander");
-var import_chalk3 = __toESM(require("chalk"));
-var import_ora3 = __toESM(require("ora"));
-var isRecordSummary = (value) => {
-  if (!value || typeof value !== "object") {
-    return false;
+// src/lib/api-client.ts
+init_cjs_shims();
+var ApiError = class extends Error {
+  constructor(statusCode, message) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "ApiError";
   }
-  const record = value;
-  return typeof record.id === "string" && typeof record.name === "string" && typeof record.type === "string";
 };
-var isRecordListResponse = (value) => {
-  if (!value || typeof value !== "object") {
-    return false;
+var ApiClient = class {
+  baseUrl;
+  apiKey;
+  constructor(apiKey, baseUrl) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl || getApiUrl();
   }
-  const record = value;
-  if (record.data !== void 0) {
-    if (!Array.isArray(record.data) || !record.data.every(isRecordSummary)) {
-      return false;
+  /** Prefix path with API version (e.g. /v1) so all requests hit versioned routes. */
+  path(path5) {
+    const version = getApiVersion();
+    const p = path5.startsWith("/") ? path5 : `/${path5}`;
+    return p.startsWith(`/${version}/`) ? p : `/${version}${p}`;
+  }
+  headers(extra) {
+    return {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json",
+      ...extra
+    };
+  }
+  async handleResponse(response) {
+    if (!response.ok) {
+      let message = `${response.status} ${response.statusText}`;
+      try {
+        const contentType = response.headers.get("content-type") || "";
+        if (contentType.includes("application/json")) {
+          const body = await response.json();
+          message = body.error || body.message || message;
+        } else {
+          const text = await response.text();
+          if (text) message = text;
+        }
+      } catch {
+      }
+      throw new ApiError(response.status, message);
     }
+    return response.json();
   }
-  if (record.pagination !== void 0 && (typeof record.pagination !== "object" || record.pagination === null)) {
-    return false;
+  async get(path5, params) {
+    const url = new URL(this.path(path5), this.baseUrl);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== "") {
+          url.searchParams.append(key, value);
+        }
+      }
+    }
+    const response = await fetch(url.toString(), {
+      headers: this.headers()
+    });
+    return this.handleResponse(response);
   }
-  return true;
-};
-var isRecordCreateResponse = (value) => {
-  if (!value || typeof value !== "object") {
-    return false;
+  async post(path5, body) {
+    const response = await fetch(new URL(this.path(path5), this.baseUrl).toString(), {
+      method: "POST",
+      headers: this.headers(),
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    return this.handleResponse(response);
   }
-  const record = value;
-  return typeof record.id === "string" && typeof record.name === "string" && typeof record.type === "string";
-};
-var recordsCommand = new import_commander3.Command("records").description("Manage records");
-recordsCommand.command("list").description("List all records").option("--type <type>", "Filter by record type").option("--limit <n>", "Limit number of results", "20").option("--json", "Output as JSON").action(async (options) => {
-  const store = new CredentialStore();
-  const apiKey = await store.getApiKey();
-  if (!apiKey) {
-    console.log(import_chalk3.default.yellow("Not authenticated. Please run: runtype auth login"));
-    process.exit(1);
+  async put(path5, body) {
+    const response = await fetch(new URL(this.path(path5), this.baseUrl).toString(), {
+      method: "PUT",
+      headers: this.headers(),
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    return this.handleResponse(response);
   }
-  const spinner = (0, import_ora3.default)("Fetching records...").start();
-  try {
-    const params = new URLSearchParams();
-    if (options.type) params.append("type", options.type);
-    params.append("limit", options.limit);
-    const response = await fetch(`${getApiUrl()}/${getApiVersion()}/records?${params}`, {
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-        "Content-Type": "application/json"
+  async patch(path5, body) {
+    const response = await fetch(new URL(this.path(path5), this.baseUrl).toString(), {
+      method: "PATCH",
+      headers: this.headers(),
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    return this.handleResponse(response);
+  }
+  async delete(path5) {
+    const response = await fetch(new URL(this.path(path5), this.baseUrl).toString(), {
+      method: "DELETE",
+      headers: this.headers()
+    });
+    if (!response.ok) {
+      let message = `${response.status} ${response.statusText}`;
+      try {
+        const body = await response.json();
+        message = body.error || body.message || message;
+      } catch {
       }
+      throw new ApiError(response.status, message);
+    }
+  }
+  async stream(path5, body) {
+    const response = await fetch(new URL(this.path(path5), this.baseUrl).toString(), {
+      method: "POST",
+      headers: this.headers({ Accept: "text/event-stream" }),
+      body: body !== void 0 ? JSON.stringify(body) : void 0
     });
     if (!response.ok) {
-      throw new Error(`Failed to fetch records: ${response.statusText}`);
+      let message = `${response.status} ${response.statusText}`;
+      try {
+        const text = await response.text();
+        if (text) message = text;
+      } catch {
+      }
+      throw new ApiError(response.status, message);
     }
-    const data = await response.json();
+    return response;
+  }
+};
+
+// src/lib/output.ts
+init_cjs_shims();
+var import_chalk4 = __toESM(require("chalk"));
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function printList(items, options) {
+  console.log(import_chalk4.default.cyan(`${options.title}:`));
+  if (items.length === 0) {
+    console.log(import_chalk4.default.gray(`  ${options.emptyMessage || "None found"}`));
+    return;
+  }
+  for (const item of items) {
+    const parts = [];
+    for (const col of options.columns) {
+      const value = item[col.key];
+      if (value === void 0 || value === null) continue;
+      const str = String(value);
+      const colorFn = col.color ? import_chalk4.default[col.color] : (s) => s;
+      if (col.label) {
+        parts.push(`${col.label}: ${colorFn(str)}`);
+      } else {
+        parts.push(colorFn(str));
+      }
+    }
+    console.log(`  ${parts.join(" - ")}`);
+  }
+  if (options.total !== void 0) {
+    console.log(import_chalk4.default.dim(`
+  Total: ${options.total}`));
+  }
+}
+function printDetail(title, fields) {
+  console.log(import_chalk4.default.cyan(`${title}:`));
+  for (const field of fields) {
+    if (field.value === void 0 || field.value === null) continue;
+    const str = typeof field.value === "object" ? JSON.stringify(field.value) : String(field.value);
+    console.log(`  ${import_chalk4.default.gray(field.label + ":")} ${str}`);
+  }
+}
+function getTotalCount(pagination) {
+  return pagination?.totalCount ?? pagination?.total ?? void 0;
+}
+
+// src/commands/flows.ts
+var flowsCommand = new import_commander2.Command("flows").description("Manage flows");
+flowsCommand.command("list").description("List all flows").option("--json", "Output as JSON").action(async (options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora3.default)("Fetching flows...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.get("/flows");
+    spinner.stop();
+    if (options.json) {
+      printJson(data);
+    } else {
+      const flows = data.data ?? [];
+      printList(flows, {
+        title: "Your Flows",
+        columns: [
+          { key: "id", color: "green" },
+          { key: "name" },
+          { key: "description", color: "gray" }
+        ],
+        emptyMessage: "No flows found",
+        total: getTotalCount(data.pagination)
+      });
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to fetch flows");
+    console.error(import_chalk5.default.red(message));
+    process.exit(1);
+  }
+});
+flowsCommand.command("get <id>").description("Get flow details").option("--json", "Output as JSON").action(async (id, options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora3.default)("Fetching flow...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.get(`/flows/${id}`);
     spinner.stop();
     if (options.json) {
-      console.log(JSON.stringify(data, null, 2));
+      printJson(data);
     } else {
-      if (!isRecordListResponse(data)) {
-        throw new Error("Unexpected records response format");
-      }
-      console.log(import_chalk3.default.cyan("Your Records:"));
-      const recordsArray = data.data ?? [];
-      if (recordsArray.length > 0) {
-        recordsArray.forEach((record) => {
-          console.log(`  ${import_chalk3.default.green(record.id)} - ${record.name} (${record.type})`);
-          if (record.metadata && Object.keys(record.metadata).length > 0) {
-            console.log(`    ${import_chalk3.default.gray(JSON.stringify(record.metadata))}`);
+      printDetail("Flow", [
+        { label: "ID", value: data.id },
+        { label: "Name", value: data.name },
+        { label: "Description", value: data.description },
+        { label: "Steps", value: data.steps?.length }
+      ]);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to fetch flow");
+    console.error(import_chalk5.default.red(message));
+    process.exit(1);
+  }
+});
+flowsCommand.command("run <id>").description("Execute a flow via dispatch").option("-r, --record <id>", "Record ID to run with").option("-m, --message <text>", "Message to send").option("--stream", "Stream the response (default)", true).option("--no-stream", "Wait for complete response").option("--json", "Output as JSON").action(
+  async (flowId, options) => {
+    const apiKey = await ensureAuth();
+    if (!apiKey) return;
+    const client = new ApiClient(apiKey);
+    const payload = {
+      flow: { id: flowId }
+    };
+    if (options.record) {
+      payload.record = { id: options.record };
+    }
+    if (options.message) {
+      payload.messages = [{ role: "user", content: options.message }];
+    }
+    if (options.stream) {
+      const spinner = (0, import_ora3.default)("Starting flow...").start();
+      try {
+        const response = await client.stream("/dispatch", payload);
+        spinner.stop();
+        const callbacks = {
+          onStepChunk: (chunk) => {
+            process.stdout.write(chunk);
+          },
+          onFlowComplete: (event) => {
+            if (options.json) {
+              console.log();
+              printJson(event);
+            }
+          },
+          onError: (err) => {
+            console.error(import_chalk5.default.red(`
+Error: ${err.message}`));
           }
-        });
-        const total = data.pagination?.total_count ?? data.pagination?.total;
-        if (typeof total === "number") {
-          console.log(import_chalk3.default.dim(`
-  Total: ${total} records`));
+        };
+        await (0, import_sdk.processStream)(response, callbacks);
+        console.log();
+      } catch (error) {
+        spinner.fail("Flow execution failed");
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error(import_chalk5.default.red(message));
+        process.exit(1);
+      }
+    } else {
+      const spinner = (0, import_ora3.default)("Executing flow...").start();
+      try {
+        payload.streamResponse = false;
+        const result = await client.post("/dispatch", payload);
+        spinner.succeed("Flow execution complete");
+        printJson(result);
+      } catch (error) {
+        spinner.fail("Flow execution failed");
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error(import_chalk5.default.red(message));
+        process.exit(1);
+      }
+    }
+  }
+);
+flowsCommand.command("create").description("Create a new flow").requiredOption("-n, --name <name>", "Flow name").option("-d, --description <desc>", "Flow description").option("--from-file <file>", "Import flow from JSON file").option("--json", "Output as JSON").action(
+  async (options) => {
+    const apiKey = await ensureAuth();
+    if (!apiKey) return;
+    const spinner = (0, import_ora3.default)("Creating flow...").start();
+    try {
+      const client = new ApiClient(apiKey);
+      let body = {
+        name: options.name,
+        description: options.description
+      };
+      if (options.fromFile) {
+        try {
+          const fileContent = JSON.parse((0, import_fs2.readFileSync)(options.fromFile, "utf-8"));
+          if (fileContent.flow) {
+            body = { ...fileContent.flow, name: options.name || fileContent.flow.name };
+          } else {
+            body = { ...fileContent, name: options.name || fileContent.name };
+          }
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : "Unknown error";
+          spinner.fail("Failed to read flow file");
+          console.error(import_chalk5.default.red(msg));
+          process.exit(1);
         }
+      }
+      const data = await client.post("/flows", body);
+      spinner.succeed("Flow created");
+      if (options.json) {
+        printJson(data);
       } else {
-        console.log(import_chalk3.default.gray("  No records found"));
+        console.log(`  ID: ${import_chalk5.default.green(data.id)}`);
+        console.log(`  Name: ${data.name}`);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      spinner.fail("Failed to create flow");
+      console.error(import_chalk5.default.red(message));
+      process.exit(1);
+    }
+  }
+);
+flowsCommand.command("delete <id>").description("Delete a flow").action(async (id) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora3.default)("Deleting flow...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    await client.delete(`/flows/${id}`);
+    spinner.succeed("Flow deleted");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to delete flow");
+    console.error(import_chalk5.default.red(message));
+    process.exit(1);
+  }
+});
+
+// src/commands/records.ts
+init_cjs_shims();
+var import_commander3 = require("commander");
+var import_chalk6 = __toESM(require("chalk"));
+var import_ora4 = __toESM(require("ora"));
+var import_fs3 = require("fs");
+var recordsCommand = new import_commander3.Command("records").description("Manage records");
+recordsCommand.command("list").description("List all records").option("--type <type>", "Filter by record type").option("--limit <n>", "Limit number of results", "20").option("--json", "Output as JSON").action(async (options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora4.default)("Fetching records...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const params = { limit: options.limit };
+    if (options.type) params.type = options.type;
+    const data = await client.get("/records", params);
+    spinner.stop();
+    if (options.json) {
+      printJson(data);
+    } else {
+      const records = data.data ?? [];
+      if (records.length === 0) {
+        console.log(import_chalk6.default.gray("No records found"));
+        return;
+      }
+      console.log(import_chalk6.default.cyan("Your Records:"));
+      for (const record of records) {
+        console.log(`  ${import_chalk6.default.green(record.id)} - ${record.name} (${record.type})`);
+        if (record.metadata && Object.keys(record.metadata).length > 0) {
+          console.log(`    ${import_chalk6.default.gray(JSON.stringify(record.metadata))}`);
+        }
+      }
+      const total = getTotalCount(data.pagination);
+      if (total !== void 0) {
+        console.log(import_chalk6.default.dim(`
+  Total: ${total} records`));
       }
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
     spinner.fail("Failed to fetch records");
-    console.error(import_chalk3.default.red(message));
+    console.error(import_chalk6.default.red(message));
     process.exit(1);
   }
 });
-recordsCommand.command("create").description("Create a new record").requiredOption("-n, --name <name>", "Record name").requiredOption("-t, --type <type>", "Record type").option("-m, --metadata <json>", "Metadata as JSON string").action(async (options) => {
-  const store = new CredentialStore();
-  const apiKey = await store.getApiKey();
-  if (!apiKey) {
-    console.log(import_chalk3.default.yellow("Not authenticated. Please run: runtype auth login"));
+recordsCommand.command("get <id>").description("Get record details").option("--json", "Output as JSON").action(async (id, options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora4.default)("Fetching record...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.get(`/records/${id}`);
+    spinner.stop();
+    if (options.json) {
+      printJson(data);
+    } else {
+      console.log(import_chalk6.default.cyan("Record:"));
+      console.log(`  ID: ${import_chalk6.default.green(data.id)}`);
+      console.log(`  Name: ${data.name}`);
+      console.log(`  Type: ${data.type}`);
+      if (data.metadata) {
+        console.log(`  Metadata: ${JSON.stringify(data.metadata, null, 2)}`);
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to fetch record");
+    console.error(import_chalk6.default.red(message));
     process.exit(1);
   }
-  const spinner = (0, import_ora3.default)("Creating record...").start();
+});
+recordsCommand.command("create").description("Create a new record").requiredOption("-n, --name <name>", "Record name").requiredOption("-t, --type <type>", "Record type").option("-m, --metadata <json>", "Metadata as JSON string").option("--json", "Output as JSON").action(async (options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora4.default)("Creating record...").start();
   try {
     let metadata = {};
     if (options.metadata) {
@@ -816,235 +1325,317 @@ recordsCommand.command("create").description("Create a new record").requiredOpti
         throw new Error("Invalid JSON in metadata");
       }
     }
-    const response = await fetch(`${getApiUrl()}/${getApiVersion()}/records`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        name: options.name,
-        type: options.type,
-        metadata
-      })
+    const client = new ApiClient(apiKey);
+    const data = await client.post("/records", {
+      name: options.name,
+      type: options.type,
+      metadata
     });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Failed to create record: ${error}`);
-    }
-    const data = await response.json();
-    if (!isRecordCreateResponse(data)) {
-      throw new Error("Unexpected create record response format");
+    spinner.succeed("Record created");
+    if (options.json) {
+      printJson(data);
+    } else {
+      console.log(`  ID: ${import_chalk6.default.green(data.id)}`);
+      console.log(`  Name: ${data.name}`);
+      console.log(`  Type: ${data.type}`);
     }
-    spinner.succeed("Record created successfully!");
-    console.log(import_chalk3.default.green(`Record ID: ${data.id}`));
-    console.log(import_chalk3.default.gray(`Name: ${data.name}`));
-    console.log(import_chalk3.default.gray(`Type: ${data.type}`));
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
     spinner.fail("Failed to create record");
-    console.error(import_chalk3.default.red(message));
+    console.error(import_chalk6.default.red(message));
     process.exit(1);
   }
 });
-recordsCommand.command("bulk").description("Bulk operations on records").action(async () => {
-  console.log(import_chalk3.default.cyan("Bulk operations coming soon"));
-});
-recordsCommand.command("export").description("Export records").option("--format <format>", "Export format (json, csv)", "json").action(async (options) => {
-  console.log(import_chalk3.default.cyan(`Exporting records as ${options.format}...`));
-  console.log(import_chalk3.default.gray("Implementation coming soon"));
-});
-
-// src/commands/prompts.ts
-var import_commander4 = require("commander");
-var import_chalk4 = __toESM(require("chalk"));
-var import_ora4 = __toESM(require("ora"));
-var isPromptSummary = (value) => {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const record = value;
-  return typeof record.id === "string" && typeof record.name === "string";
-};
-var isPromptListResponse = (value) => {
-  if (!value || typeof value !== "object") {
-    return false;
+recordsCommand.command("delete <id>").description("Delete a record").action(async (id) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora4.default)("Deleting record...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    await client.delete(`/records/${id}`);
+    spinner.succeed("Record deleted");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to delete record");
+    console.error(import_chalk6.default.red(message));
+    process.exit(1);
   }
-  const record = value;
-  if (record.data !== void 0) {
-    if (!Array.isArray(record.data) || !record.data.every(isPromptSummary)) {
-      return false;
+});
+recordsCommand.command("export").description("Export records to a file").option("--type <type>", "Filter by record type").option("--limit <n>", "Maximum records to export", "100").option("-o, --output <file>", "Output file path").option("--format <format>", "Export format (json, csv)", "json").action(
+  async (options) => {
+    const apiKey = await ensureAuth();
+    if (!apiKey) return;
+    const spinner = (0, import_ora4.default)("Exporting records...").start();
+    try {
+      const client = new ApiClient(apiKey);
+      const params = { limit: options.limit };
+      if (options.type) params.type = options.type;
+      const data = await client.get("/records", params);
+      const records = data.data ?? [];
+      if (records.length === 0) {
+        spinner.warn("No records to export");
+        return;
+      }
+      let content;
+      if (options.format === "csv") {
+        const headers = ["id", "name", "type", "metadata"];
+        const rows = records.map((r) => [
+          r.id,
+          r.name,
+          r.type,
+          r.metadata ? JSON.stringify(r.metadata) : ""
+        ]);
+        content = [headers.join(","), ...rows.map((r) => r.map(csvEscape).join(","))].join("\n");
+      } else {
+        content = JSON.stringify(records, null, 2);
+      }
+      const filename = options.output || `records-export-${Date.now()}.${options.format === "csv" ? "csv" : "json"}`;
+      (0, import_fs3.writeFileSync)(filename, content);
+      spinner.succeed(`Exported ${records.length} records to ${filename}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      spinner.fail("Failed to export records");
+      console.error(import_chalk6.default.red(message));
+      process.exit(1);
     }
   }
-  if (record.pagination !== void 0 && (typeof record.pagination !== "object" || record.pagination === null)) {
-    return false;
+);
+function csvEscape(value) {
+  if (value.includes(",") || value.includes('"') || value.includes("\n")) {
+    return `"${value.replace(/"/g, '""')}"`;
   }
-  return true;
-};
+  return value;
+}
+
+// src/commands/prompts.ts
+init_cjs_shims();
+var import_commander4 = require("commander");
+var import_chalk7 = __toESM(require("chalk"));
+var import_ora5 = __toESM(require("ora"));
+var import_sdk2 = require("@runtypelabs/sdk");
 var promptsCommand = new import_commander4.Command("prompts").description("Manage prompts");
 promptsCommand.command("list").description("List all prompts").option("--json", "Output as JSON").action(async (options) => {
-  const store = new CredentialStore();
-  const apiKey = await store.getApiKey();
-  if (!apiKey) {
-    console.log(import_chalk4.default.yellow("Not authenticated. Please run: runtype auth login"));
-    process.exit(1);
-  }
-  const spinner = (0, import_ora4.default)("Fetching prompts...").start();
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora5.default)("Fetching prompts...").start();
   try {
-    const response = await fetch(`${getApiUrl()}/prompts`, {
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-        "Content-Type": "application/json"
-      }
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to fetch prompts: ${response.statusText}`);
-    }
-    const data = await response.json();
+    const client = new ApiClient(apiKey);
+    const data = await client.get("/prompts");
     spinner.stop();
     if (options.json) {
-      console.log(JSON.stringify(data, null, 2));
+      printJson(data);
     } else {
-      if (!isPromptListResponse(data)) {
-        throw new Error("Unexpected prompts response format");
-      }
-      console.log(import_chalk4.default.cyan("Your Prompts:"));
-      const promptsArray = data.data ?? [];
-      if (promptsArray.length > 0) {
-        promptsArray.forEach((prompt) => {
-          console.log(`  ${import_chalk4.default.green(prompt.id)} - ${prompt.name}`);
-          if (prompt.description) {
-            console.log(`    ${import_chalk4.default.gray(prompt.description)}`);
-          }
-          if (prompt.model) {
-            console.log(`    Model: ${import_chalk4.default.blue(prompt.model)}`);
-          }
-        });
-        const total = data.pagination?.total_count;
-        if (typeof total === "number") {
-          console.log(import_chalk4.default.dim(`
-  Total: ${total} prompts`));
+      const prompts = data.data ?? [];
+      if (prompts.length === 0) {
+        console.log(import_chalk7.default.gray("No prompts found"));
+        return;
+      }
+      console.log(import_chalk7.default.cyan("Your Prompts:"));
+      for (const prompt of prompts) {
+        console.log(`  ${import_chalk7.default.green(prompt.id)} - ${prompt.name}`);
+        if (prompt.description) {
+          console.log(`    ${import_chalk7.default.gray(prompt.description)}`);
+        }
+        if (prompt.model) {
+          console.log(`    Model: ${import_chalk7.default.blue(prompt.model)}`);
         }
-      } else {
-        console.log(import_chalk4.default.gray("  No prompts found"));
+      }
+      const total = getTotalCount(data.pagination);
+      if (total !== void 0) {
+        console.log(import_chalk7.default.dim(`
+  Total: ${total} prompts`));
       }
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
     spinner.fail("Failed to fetch prompts");
-    console.error(import_chalk4.default.red(message));
+    console.error(import_chalk7.default.red(message));
     process.exit(1);
   }
 });
-promptsCommand.command("test <id>").description("Test a prompt").option("-i, --input <text>", "Input text for the prompt").action(async (promptId, options) => {
-  void options;
-  const store = new CredentialStore();
-  const apiKey = await store.getApiKey();
-  if (!apiKey) {
-    console.log(import_chalk4.default.yellow("Not authenticated. Please run: runtype auth login"));
+promptsCommand.command("get <id>").description("Get prompt details").option("--json", "Output as JSON").action(async (id, options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora5.default)("Fetching prompt...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.get(`/prompts/${id}`);
+    spinner.stop();
+    if (options.json) {
+      printJson(data);
+    } else {
+      printDetail("Prompt", [
+        { label: "ID", value: data.id },
+        { label: "Name", value: data.name },
+        { label: "Description", value: data.description },
+        { label: "Model", value: data.model }
+      ]);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to fetch prompt");
+    console.error(import_chalk7.default.red(message));
     process.exit(1);
   }
-  console.log(import_chalk4.default.cyan(`Testing prompt ${promptId}...`));
-  console.log(import_chalk4.default.gray("Implementation coming soon"));
 });
+promptsCommand.command("test <id>").description("Test a prompt with input").option("-i, --input <text>", "Input text for the prompt").option("--stream", "Stream the response (default)", true).option("--no-stream", "Wait for complete response").option("--json", "Output as JSON").action(
+  async (promptId, options) => {
+    const apiKey = await ensureAuth();
+    if (!apiKey) return;
+    const client = new ApiClient(apiKey);
+    const payload = {
+      flow: {
+        steps: [
+          {
+            name: "test",
+            type: "prompt",
+            config: {
+              promptId,
+              text: options.input || ""
+            }
+          }
+        ]
+      }
+    };
+    if (options.input) {
+      payload.messages = [{ role: "user", content: options.input }];
+    }
+    if (options.stream) {
+      const spinner = (0, import_ora5.default)("Testing prompt...").start();
+      try {
+        const response = await client.stream("/dispatch", payload);
+        spinner.stop();
+        const callbacks = {
+          onStepChunk: (chunk) => {
+            process.stdout.write(chunk);
+          },
+          onError: (err) => {
+            console.error(import_chalk7.default.red(`
+Error: ${err.message}`));
+          }
+        };
+        await (0, import_sdk2.processStream)(response, callbacks);
+        console.log();
+      } catch (error) {
+        spinner.fail("Prompt test failed");
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error(import_chalk7.default.red(message));
+        process.exit(1);
+      }
+    } else {
+      const spinner = (0, import_ora5.default)("Testing prompt...").start();
+      try {
+        payload.streamResponse = false;
+        const result = await client.post("/dispatch", payload);
+        spinner.succeed("Prompt test complete");
+        if (options.json) {
+          printJson(result);
+        } else {
+          printJson(result);
+        }
+      } catch (error) {
+        spinner.fail("Prompt test failed");
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error(import_chalk7.default.red(message));
+        process.exit(1);
+      }
+    }
+  }
+);
 
 // src/commands/batch.ts
+init_cjs_shims();
 var import_commander5 = require("commander");
-var import_chalk5 = __toESM(require("chalk"));
-var import_ora5 = __toESM(require("ora"));
-var isBatchStatusResponse = (value) => {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const record = value;
-  return typeof record.status === "string" && typeof record.processed_count === "number" && typeof record.total_count === "number" && typeof record.failed_count === "number";
-};
+var import_chalk8 = __toESM(require("chalk"));
+var import_ora6 = __toESM(require("ora"));
+var import_fs4 = require("fs");
 var batchCommand = new import_commander5.Command("batch").description("Manage batch operations");
-batchCommand.command("submit").description("Submit a batch job").requiredOption("-f, --flow <id>", "Flow ID to execute").requiredOption("-r, --records <file>", "JSON file with record IDs").action(async (options) => {
-  const store = new CredentialStore();
-  const apiKey = await store.getApiKey();
-  if (!apiKey) {
-    console.log(import_chalk5.default.yellow("Not authenticated. Please run: runtype auth login"));
-    process.exit(1);
-  }
-  console.log(import_chalk5.default.cyan("Submitting batch job..."));
-  console.log(import_chalk5.default.gray(`Flow: ${options.flow}`));
-  console.log(import_chalk5.default.gray(`Records file: ${options.records}`));
-  console.log(import_chalk5.default.gray("Implementation coming soon"));
-});
-batchCommand.command("status <id>").description("Check batch job status").option("--watch", "Watch for updates").action(async (batchId, options) => {
-  const store = new CredentialStore();
-  const apiKey = await store.getApiKey();
-  if (!apiKey) {
-    console.log(import_chalk5.default.yellow("Not authenticated. Please run: runtype auth login"));
+batchCommand.command("submit").description("Submit a batch job").requiredOption("-f, --flow <id>", "Flow ID to execute").requiredOption("-r, --records <file>", "JSON file with record IDs").option("--json", "Output as JSON").action(async (options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  let recordIds;
+  try {
+    const content = (0, import_fs4.readFileSync)(options.records, "utf-8");
+    const parsed = JSON.parse(content);
+    recordIds = Array.isArray(parsed) ? parsed : parsed.recordIds || parsed.records || [];
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : "Unknown error";
+    console.error(import_chalk8.default.red(`Failed to read records file: ${msg}`));
     process.exit(1);
   }
-  const spinner = (0, import_ora5.default)("Fetching batch status...").start();
+  const spinner = (0, import_ora6.default)(`Submitting batch with ${recordIds.length} records...`).start();
   try {
-    const response = await fetch(`${getApiUrl()}/${getApiVersion()}/batch/status/${batchId}`, {
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-        "Content-Type": "application/json"
-      }
+    const client = new ApiClient(apiKey);
+    const data = await client.post("/batch/submit", {
+      flowId: options.flow,
+      recordIds
     });
-    if (!response.ok) {
-      throw new Error(`Failed to fetch batch status: ${response.statusText}`);
-    }
-    const data = await response.json();
-    if (!isBatchStatusResponse(data)) {
-      throw new Error("Invalid batch status response received from the API");
+    spinner.succeed("Batch submitted");
+    if (options.json) {
+      printJson(data);
+    } else {
+      console.log(`  Batch ID: ${import_chalk8.default.green(data.id)}`);
+      console.log(`  Status: ${data.status}`);
     }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to submit batch");
+    console.error(import_chalk8.default.red(message));
+    process.exit(1);
+  }
+});
+batchCommand.command("status <id>").description("Check batch job status").option("--watch", "Watch for updates").option("--json", "Output as JSON").action(async (batchId, options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora6.default)("Fetching batch status...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.get(`/batch/status/${batchId}`);
     spinner.stop();
-    console.log(import_chalk5.default.cyan(`Batch Job: ${batchId}`));
-    console.log(`  Status: ${import_chalk5.default.green(data.status)}`);
-    console.log(`  Progress: ${data.processed_count}/${data.total_count}`);
-    if (data.failed_count > 0) {
-      console.log(`  Failed: ${import_chalk5.default.red(data.failed_count)}`);
-    }
-    if (options.watch && data.status === "processing") {
-      console.log(import_chalk5.default.gray("\nWatching for updates... (Ctrl+C to stop)"));
+    if (options.json) {
+      printJson(data);
+    } else {
+      console.log(import_chalk8.default.cyan(`Batch Job: ${batchId}`));
+      console.log(`  Status: ${import_chalk8.default.green(data.status)}`);
+      console.log(`  Progress: ${data.processedRecords}/${data.totalRecords}`);
+      if (data.failedRecords > 0) {
+        console.log(`  Failed: ${import_chalk8.default.red(data.failedRecords)}`);
+      }
+      if (options.watch && data.status === "processing") {
+        console.log(import_chalk8.default.gray("\nWatching for updates... (Ctrl+C to stop)"));
+      }
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
     spinner.fail("Failed to fetch batch status");
-    console.error(import_chalk5.default.red(message));
+    console.error(import_chalk8.default.red(message));
     process.exit(1);
   }
 });
 batchCommand.command("cancel <id>").description("Cancel a batch job").action(async (batchId) => {
-  const store = new CredentialStore();
-  const apiKey = await store.getApiKey();
-  if (!apiKey) {
-    console.log(import_chalk5.default.yellow("Not authenticated. Please run: runtype auth login"));
-    process.exit(1);
-  }
-  const spinner = (0, import_ora5.default)("Cancelling batch job...").start();
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora6.default)("Cancelling batch job...").start();
   try {
-    const response = await fetch(`${getApiUrl()}/${getApiVersion()}/batch/cancel/${batchId}`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-        "Content-Type": "application/json"
-      }
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to cancel batch: ${response.statusText}`);
-    }
-    spinner.succeed("Batch job cancelled successfully");
+    const client = new ApiClient(apiKey);
+    await client.post(`/batch/cancel/${batchId}`);
+    spinner.succeed("Batch job cancelled");
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
     spinner.fail("Failed to cancel batch job");
-    console.error(import_chalk5.default.red(message));
+    console.error(import_chalk8.default.red(message));
     process.exit(1);
   }
 });
 
 // src/commands/talk.ts
+init_cjs_shims();
 var import_commander6 = require("commander");
-var import_readline = __toESM(require("readline"));
-var import_chalk7 = __toESM(require("chalk"));
+var import_readline2 = __toESM(require("readline"));
+var import_chalk10 = __toESM(require("chalk"));
 
 // src/chat/session-manager.ts
+init_cjs_shims();
 var import_uuid = require("uuid");
 var import_promises = __toESM(require("fs/promises"));
 var import_path2 = __toESM(require("path"));
@@ -1104,7 +1695,6 @@ var ChatSession = class {
       flow: {
         name: "Chat Flow",
         description: "",
-        mode: "standalone",
         steps: [
           {
             id: "1",
@@ -1115,22 +1705,16 @@ var ChatSession = class {
             config: {
               text: this.buildPrompt(userInput),
               model: this.modelConfig.model,
-              output_format: "text",
-              output_variable: "chat_result",
-              response_format: "text"
-            },
-            prompt_id: null,
-            context_template_id: null,
-            item_type: "prompt",
-            prompt: null,
-            context_template: null
+              outputVariable: "chatResult",
+              responseFormat: "text"
+            }
           }
         ]
       },
       options: {
-        stream_response: true,
-        record_mode: "virtual",
-        flow_mode: "virtual"
+        streamResponse: true,
+        recordMode: "virtual",
+        flowMode: "virtual"
       }
     };
   }
@@ -1219,15 +1803,16 @@ ${userInput}`;
       id: this.sessionId,
       messageCount: this.messages.length,
       model: this.modelConfig.model,
-      temperature: this.modelConfig.temperature || 0.7,
+      temperature: this.modelConfig.temperature ?? 0.7,
       duration
     };
   }
 };
 
 // src/chat/stream-handler.ts
-var import_chalk6 = __toESM(require("chalk"));
-var import_sdk = require("@runtypelabs/sdk");
+init_cjs_shims();
+var import_chalk9 = __toESM(require("chalk"));
+var import_sdk3 = require("@runtypelabs/sdk");
 var StreamHandler = class {
   buffer = "";
   isStreaming = false;
@@ -1243,17 +1828,17 @@ var StreamHandler = class {
         this.appendOutput(chunk);
       },
       onError: (error) => {
-        console.error(import_chalk6.default.red(`
+        console.error(import_chalk9.default.red(`
 Error: ${error.message}`));
       }
       // All other events (step_start, step_complete, flow_start, etc.) are
       // silently ignored - processStream handles them but we don't need to display them
     };
     try {
-      await (0, import_sdk.processStream)(response, callbacks);
+      await (0, import_sdk3.processStream)(response, callbacks);
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
-      console.error(import_chalk6.default.red(`
+      console.error(import_chalk9.default.red(`
 Stream error: ${message}`));
       throw error;
     } finally {
@@ -1299,12 +1884,8 @@ var CHAT_COMMANDS = {
   "/exit": "Exit chat session"
 };
 var talkCommand = new import_commander6.Command("talk").description("Start an interactive chat session").option("-m, --model <model>", "AI model to use", getDefaultModel()).option("-t, --temperature <temp>", "Temperature (0-1)", getDefaultTemperature().toString()).option("--max-tokens <tokens>", "Max response tokens", "2000").option("--system <prompt>", "System prompt to prepend").option("--no-markdown", "Disable markdown rendering").option("--continue <file>", "Continue from saved session").action(async (options) => {
-  const store = new CredentialStore();
-  const apiKey = await store.getApiKey();
-  if (!apiKey) {
-    console.log(import_chalk7.default.yellow("Not authenticated. Please run: runtype auth login"));
-    process.exit(1);
-  }
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
   const session = new ChatSession({
     model: options.model,
     temperature: parseFloat(options.temperature),
@@ -1314,9 +1895,10 @@ var talkCommand = new import_commander6.Command("talk").description("Start an in
   if (options.continue) {
     try {
       await session.loadFromFile(options.continue);
-      console.log(import_chalk7.default.green(`Loaded session from: ${options.continue}`));
+      console.log(import_chalk10.default.green(`Loaded session from: ${options.continue}`));
     } catch (error) {
-      console.error(import_chalk7.default.red(`Failed to load session: ${error.message}`));
+      const message = error instanceof Error ? error.message : "Unknown error";
+      console.error(import_chalk10.default.red(`Failed to load session: ${message}`));
       process.exit(1);
     }
   }
@@ -1324,17 +1906,17 @@ var talkCommand = new import_commander6.Command("talk").description("Start an in
   const streamHandler = new StreamHandler({
     enableMarkdown: options.markdown !== false
   });
-  const rl = import_readline.default.createInterface({
+  const rl = import_readline2.default.createInterface({
     input: process.stdin,
     output: process.stdout,
-    prompt: import_chalk7.default.cyan("You> "),
+    prompt: import_chalk10.default.cyan("You> "),
     terminal: true,
     historySize: 100
   });
   console.clear();
-  console.log(import_chalk7.default.green("\u{1F916} Runtype Chat Session Started"));
-  console.log(import_chalk7.default.gray(`Model: ${options.model} | Temperature: ${options.temperature}`));
-  console.log(import_chalk7.default.gray('Type "/help" for commands or "exit" to quit\n'));
+  console.log(import_chalk10.default.green("\u{1F916} Runtype Chat Session Started"));
+  console.log(import_chalk10.default.gray(`Model: ${options.model} | Temperature: ${options.temperature}`));
+  console.log(import_chalk10.default.gray('Type "/help" for commands or "exit" to quit\n'));
   if (options.system) {
     session.addMessage("system", options.system);
   }
@@ -1344,67 +1926,71 @@ var talkCommand = new import_commander6.Command("talk").description("Start an in
     const args = parts.slice(1).join(" ");
     switch (command) {
       case "/help":
-        console.log(import_chalk7.default.cyan("\nAvailable commands:"));
+        console.log(import_chalk10.default.cyan("\nAvailable commands:"));
         for (const [cmd, desc] of Object.entries(CHAT_COMMANDS)) {
-          console.log(`  ${import_chalk7.default.green(cmd)} - ${desc}`);
+          console.log(`  ${import_chalk10.default.green(cmd)} - ${desc}`);
         }
         console.log();
         return true;
       case "/clear":
         session.clearHistory();
         console.clear();
-        console.log(import_chalk7.default.green("\u{1F916} Chat history cleared"));
+        console.log(import_chalk10.default.green("\u{1F916} Chat history cleared"));
         return true;
       case "/save":
         try {
           const filepath = await session.saveToFile(args || void 0);
-          console.log(import_chalk7.default.green(`Session saved to: ${filepath}`));
+          console.log(import_chalk10.default.green(`Session saved to: ${filepath}`));
         } catch (error) {
-          console.error(import_chalk7.default.red(`Failed to save: ${error.message}`));
+          const message = error instanceof Error ? error.message : "Unknown error";
+          console.error(import_chalk10.default.red(`Failed to save: ${message}`));
         }
         return true;
       case "/load":
         if (!args) {
-          console.log(import_chalk7.default.red("Please specify a filename"));
+          console.log(import_chalk10.default.red("Please specify a filename"));
           return true;
         }
         try {
           await session.loadFromFile(args);
-          console.log(import_chalk7.default.green(`Session loaded from: ${args}`));
+          console.log(import_chalk10.default.green(`Session loaded from: ${args}`));
         } catch (error) {
-          console.error(import_chalk7.default.red(`Failed to load: ${error.message}`));
+          const message = error instanceof Error ? error.message : "Unknown error";
+          console.error(import_chalk10.default.red(`Failed to load: ${message}`));
         }
         return true;
       case "/export":
         try {
           const filepath = await session.exportAsMarkdown();
-          console.log(import_chalk7.default.green(`Conversation exported to: ${filepath}`));
+          console.log(import_chalk10.default.green(`Conversation exported to: ${filepath}`));
         } catch (error) {
-          console.error(import_chalk7.default.red(`Failed to export: ${error.message}`));
+          const message = error instanceof Error ? error.message : "Unknown error";
+          console.error(import_chalk10.default.red(`Failed to export: ${message}`));
         }
         return true;
       case "/model":
         if (!args) {
-          console.log(import_chalk7.default.yellow("Please specify a model"));
+          console.log(import_chalk10.default.yellow("Please specify a model"));
           return true;
         }
         session.setModel(args);
         return true;
-      case "/temp":
+      case "/temp": {
         if (!args) {
-          console.log(import_chalk7.default.yellow("Please specify a temperature (0-1)"));
+          console.log(import_chalk10.default.yellow("Please specify a temperature (0-1)"));
           return true;
         }
         const temp = parseFloat(args);
         if (isNaN(temp) || temp < 0 || temp > 1) {
-          console.log(import_chalk7.default.red("Temperature must be between 0 and 1"));
+          console.log(import_chalk10.default.red("Temperature must be between 0 and 1"));
           return true;
         }
         session.setTemperature(temp);
         return true;
-      case "/info":
+      }
+      case "/info": {
         const info = session.getSessionInfo();
-        console.log(import_chalk7.default.cyan("\nSession Information:"));
+        console.log(import_chalk10.default.cyan("\nSession Information:"));
         console.log(`  Session ID: ${info.id}`);
         console.log(`  Messages: ${info.messageCount}`);
         console.log(`  Model: ${info.model}`);
@@ -1412,12 +1998,13 @@ var talkCommand = new import_commander6.Command("talk").description("Start an in
         console.log(`  Duration: ${info.duration}`);
         console.log();
         return true;
+      }
       case "/exit":
         return false;
       default:
         if (input.startsWith("/")) {
-          console.log(import_chalk7.default.red(`Unknown command: ${command}`));
-          console.log(import_chalk7.default.gray('Type "/help" for available commands'));
+          console.log(import_chalk10.default.red(`Unknown command: ${command}`));
+          console.log(import_chalk10.default.gray('Type "/help" for available commands'));
           return true;
         }
         return false;
@@ -1427,7 +2014,7 @@ var talkCommand = new import_commander6.Command("talk").description("Start an in
   rl.on("line", async (input) => {
     const trimmed = input.trim();
     if (trimmed.toLowerCase() === "exit" || trimmed.toLowerCase() === "quit") {
-      console.log(import_chalk7.default.green("\n\u{1F44B} Goodbye!"));
+      console.log(import_chalk10.default.green("\n\u{1F44B} Goodbye!"));
       rl.close();
       process.exit(0);
     }
@@ -1438,14 +2025,14 @@ var talkCommand = new import_commander6.Command("talk").description("Start an in
     if (trimmed.startsWith("/")) {
       const shouldContinue = await handleCommand(trimmed);
       if (!shouldContinue) {
-        console.log(import_chalk7.default.green("\n\u{1F44B} Goodbye!"));
+        console.log(import_chalk10.default.green("\n\u{1F44B} Goodbye!"));
         rl.close();
         process.exit(0);
       }
       rl.prompt();
       return;
     }
-    console.log(import_chalk7.default.gray("\nAssistant> ") + import_chalk7.default.gray("Thinking..."));
+    console.log(import_chalk10.default.gray("\nAssistant> ") + import_chalk10.default.gray("Thinking..."));
     try {
       const payload = session.buildDispatchPayload(trimmed);
       const response = await fetch(`${apiUrl}/dispatch`, {
@@ -1462,34 +2049,36 @@ var talkCommand = new import_commander6.Command("talk").description("Start an in
         throw new Error(`API error: ${response.status} - ${error}`);
       }
       process.stdout.write("\x1B[1A\x1B[2K");
-      process.stdout.write(import_chalk7.default.gray("Assistant> "));
+      process.stdout.write(import_chalk10.default.gray("Assistant> "));
       const fullResponse = await streamHandler.handleStream(response);
       session.addMessage("assistant", fullResponse);
       console.log();
       rl.prompt();
     } catch (error) {
       process.stdout.write("\x1B[1A\x1B[2K");
-      console.error(import_chalk7.default.red(`Error: ${error.message}`));
+      const message = error instanceof Error ? error.message : "Unknown error";
+      console.error(import_chalk10.default.red(`Error: ${message}`));
       rl.prompt();
     }
   });
   rl.on("SIGINT", () => {
-    console.log(import_chalk7.default.green("\n\n\u{1F44B} Goodbye!"));
+    console.log(import_chalk10.default.green("\n\n\u{1F44B} Goodbye!"));
     const info = session.getSessionInfo();
     if (info.messageCount > 0) {
-      console.log(import_chalk7.default.gray('Tip: Use "/save" to save your conversation before exiting'));
+      console.log(import_chalk10.default.gray('Tip: Use "/save" to save your conversation before exiting'));
     }
     process.exit(0);
   });
   rl.on("error", (error) => {
-    console.error(import_chalk7.default.red(`Readline error: ${error.message}`));
+    console.error(import_chalk10.default.red(`Readline error: ${error.message}`));
     process.exit(1);
   });
 });
 
 // src/commands/config.ts
+init_cjs_shims();
 var import_commander7 = require("commander");
-var import_chalk8 = __toESM(require("chalk"));
+var import_chalk11 = __toESM(require("chalk"));
 var import_conf2 = __toESM(require("conf"));
 var import_path3 = __toESM(require("path"));
 var import_os3 = __toESM(require("os"));
@@ -1513,31 +2102,31 @@ var config = new import_conf2.default({
 configCommand.command("get [key]").description("Get configuration value").action((key) => {
   if (key) {
     if (!isCliConfigKey(key)) {
-      console.log(import_chalk8.default.yellow(`Configuration key '${key}' not found`));
+      console.log(import_chalk11.default.yellow(`Configuration key '${key}' not found`));
       return;
     }
     const value = config.get(key);
     if (value !== void 0) {
       console.log(value);
     } else {
-      console.log(import_chalk8.default.yellow(`Configuration key '${key}' not found`));
+      console.log(import_chalk11.default.yellow(`Configuration key '${key}' not found`));
     }
   } else {
     const allConfig = config.store;
     if (Object.keys(allConfig).length > 0) {
-      console.log(import_chalk8.default.cyan("Current Configuration:"));
+      console.log(import_chalk11.default.cyan("Current Configuration:"));
       for (const [k, v] of Object.entries(allConfig)) {
-        console.log(`  ${import_chalk8.default.green(k)}: ${v}`);
+        console.log(`  ${import_chalk11.default.green(k)}: ${v}`);
       }
     } else {
-      console.log(import_chalk8.default.gray("No configuration set"));
+      console.log(import_chalk11.default.gray("No configuration set"));
     }
   }
 });
 configCommand.command("set <key> <value>").description("Set configuration value").action((key, value) => {
   if (!isCliConfigKey(key)) {
-    console.log(import_chalk8.default.red(`Invalid configuration key: ${key}`));
-    console.log(import_chalk8.default.gray(`Valid keys: ${CLI_CONFIG_KEYS.join(", ")}`));
+    console.log(import_chalk11.default.red(`Invalid configuration key: ${key}`));
+    console.log(import_chalk11.default.gray(`Valid keys: ${CLI_CONFIG_KEYS.join(", ")}`));
     process.exit(1);
   }
   let parsedValue;
@@ -1546,7 +2135,7 @@ configCommand.command("set <key> <value>").description("Set configuration value"
       {
         const temperature = parseFloat(value);
         if (isNaN(temperature) || temperature < 0 || temperature > 1) {
-          console.log(import_chalk8.default.red("Temperature must be a number between 0 and 1"));
+          console.log(import_chalk11.default.red("Temperature must be a number between 0 and 1"));
           process.exit(1);
         }
         parsedValue = temperature;
@@ -1557,7 +2146,7 @@ configCommand.command("set <key> <value>").description("Set configuration value"
       break;
     case "outputFormat":
       if (!["table", "json", "plain"].includes(value)) {
-        console.log(import_chalk8.default.red("Output format must be: table, json, or plain"));
+        console.log(import_chalk11.default.red("Output format must be: table, json, or plain"));
         process.exit(1);
       }
       parsedValue = value;
@@ -1567,33 +2156,34 @@ configCommand.command("set <key> <value>").description("Set configuration value"
       break;
   }
   config.set(key, parsedValue);
-  console.log(import_chalk8.default.green(`Configuration updated: ${key} = ${parsedValue}`));
+  console.log(import_chalk11.default.green(`Configuration updated: ${key} = ${parsedValue}`));
 });
 configCommand.command("reset").description("Reset all configuration to defaults").action(() => {
   config.clear();
-  console.log(import_chalk8.default.green("Configuration reset to defaults"));
+  console.log(import_chalk11.default.green("Configuration reset to defaults"));
 });
 configCommand.command("path").description("Show configuration file path").action(() => {
   console.log(config.path);
 });
 
 // src/commands/products.ts
+init_cjs_shims();
 var import_commander8 = require("commander");
-var import_chalk9 = __toESM(require("chalk"));
-var import_ora6 = __toESM(require("ora"));
+var import_chalk12 = __toESM(require("chalk"));
+var import_ora7 = __toESM(require("ora"));
 var import_open2 = __toESM(require("open"));
 function displayAgentCard(agentCard) {
-  console.log(`
-Name:        ${agentCard.name}`);
+  console.log(import_chalk12.default.cyan("\nAgent Details:"));
+  console.log(`  Name:        ${agentCard.name}`);
   if (agentCard.description) {
-    console.log(`Description: ${agentCard.description}`);
+    console.log(`  Description: ${agentCard.description}`);
   }
-  console.log(`URL:         ${agentCard.url}`);
+  console.log(`  URL:         ${agentCard.url}`);
   if (agentCard.skills && agentCard.skills.length > 0) {
-    console.log("Skills:");
+    console.log("  Skills:");
     agentCard.skills.forEach((skill) => {
       const desc = skill.description ? ` - ${skill.description}` : "";
-      console.log(`  ${import_chalk9.default.cyan("\u2022")} ${skill.name}${desc}`);
+      console.log(`    ${import_chalk12.default.cyan("\u2022")} ${skill.name}${desc}`);
     });
   }
 }
@@ -1643,7 +2233,7 @@ function displayCreationSuccess(result, agentCard, dashboardBaseUrl, jsonOutput)
 Product ID:  ${result.product.id}`);
   console.log(`Name:        ${result.product.name}`);
   console.log(`Dashboard:   ${productUrl}`);
-  console.log(import_chalk9.default.cyan("\nNext steps:"));
+  console.log(import_chalk12.default.cyan("\nNext steps:"));
   console.log("  1. Visit the dashboard to configure surfaces");
   console.log("  2. Or run: runtype products init --from <another-url>");
 }
@@ -1665,59 +2255,61 @@ async function validateUrl(url, apiUrl) {
   return response.json();
 }
 var productsCommand = new import_commander8.Command("products").description("Manage products");
-productsCommand.command("init").description("Initialize a product from an external resource").requiredOption("--from <url>", "URL to validate and import").option("--name <name>", "Custom product name (defaults to agent name)").option("--open", "Open browser to dashboard instead of creating via API").option("--json", "Output in JSON format").option("--api-url <url>", "Override API URL").action(async (options) => {
-  const spinner = (0, import_ora6.default)("Validating URL...").start();
+productsCommand.command("init").description("Initialize a product from an external resource").option("--from <url>", "URL to validate and import").option("--name <name>", "Custom product name (defaults to agent name)").option("--open", "Open browser to dashboard instead of creating via API").option("--json", "Output in JSON format").option("--api-url <url>", "Override API URL").action(async (options) => {
+  const isJsonMode = !!options.json;
+  let sourceUrl = options.from;
+  if (!sourceUrl) {
+    if (isJsonMode) {
+      console.log(JSON.stringify({ status: "error", error: "Missing --from URL", code: "MISSING_URL" }, null, 2));
+      process.exit(1);
+    }
+    console.log(import_chalk12.default.cyan("Create a product from an A2A agent URL.\n"));
+    sourceUrl = await promptText("Enter the agent URL");
+    if (!sourceUrl) {
+      console.log(import_chalk12.default.red("A URL is required to create a product."));
+      process.exit(1);
+    }
+  }
+  const spinner = (0, import_ora7.default)("Validating URL...").start();
   try {
-    const result = await validateUrl(options.from, options.apiUrl);
+    const result = await validateUrl(sourceUrl, options.apiUrl);
     if (!result.valid) {
       spinner.fail("Validation failed");
-      if (options.json) {
+      if (isJsonMode) {
         console.log(
           JSON.stringify(
-            {
-              status: "error",
-              error: result.error,
-              code: result.code
-            },
+            { status: "error", error: result.error, code: result.code },
             null,
             2
           )
         );
       } else {
-        console.error(import_chalk9.default.red(result.error));
+        console.error(import_chalk12.default.red(result.error));
       }
       process.exit(1);
     }
     spinner.succeed("A2A Agent Detected");
     displayAgentCard(result.agentCard);
-    const store = new CredentialStore();
-    const apiKey = await store.getApiKey();
-    if (!apiKey) {
-      if (options.json) {
-        console.log(
-          JSON.stringify(
-            {
-              status: "unauthenticated",
-              agentCard: result.agentCard,
-              message: "Authentication required to create product"
-            },
-            null,
-            2
-          )
-        );
-      } else {
-        console.log(import_chalk9.default.yellow("\nAuthentication required to create product."));
-        console.log("Run: runtype auth login");
-        console.log(`
-Then retry: runtype products init --from ${options.from}`);
+    if (!isJsonMode) {
+      const shouldCreate = await promptConfirm("\nCreate a product from this agent?", { default: true });
+      if (!shouldCreate) {
+        console.log(import_chalk12.default.gray("Product creation cancelled."));
+        return;
       }
-      process.exit(0);
+    }
+    let productName = options.name;
+    if (!productName && !isJsonMode) {
+      productName = await promptText("Product name", { default: result.agentCard.name });
+    }
+    const apiKey = isJsonMode ? await getApiKeyOrExit(isJsonMode, result.agentCard) : await ensureAuth({ apiUrl: options.apiUrl });
+    if (!apiKey) {
+      process.exit(1);
     }
     if (options.open) {
       const dashboardUrl = getDashboardUrl();
-      const encodedUrl = encodeURIComponent(options.from);
+      const encodedUrl = encodeURIComponent(sourceUrl);
       const targetUrl = `${dashboardUrl}/now?from=${encodedUrl}&cli=true`;
-      if (options.json) {
+      if (isJsonMode) {
         console.log(
           JSON.stringify(
             {
@@ -1730,38 +2322,34 @@ Then retry: runtype products init --from ${options.from}`);
           )
         );
       } else {
-        console.log(import_chalk9.default.cyan("\nOpening browser to complete setup..."));
-        console.log(import_chalk9.default.gray(targetUrl));
+        console.log(import_chalk12.default.cyan("\nOpening browser to complete setup..."));
+        console.log(import_chalk12.default.gray(targetUrl));
       }
       await (0, import_open2.default)(targetUrl);
       return;
     }
-    const createSpinner = (0, import_ora6.default)("Creating product...").start();
+    const createSpinner = (0, import_ora7.default)("Creating product...").start();
     try {
       const createResult = await createProduct(
         apiKey,
         result.templateId,
         result.agentCard,
-        options.from,
-        options.name,
+        sourceUrl,
+        productName,
         options.apiUrl
       );
       if (!createResult.success) {
         createSpinner.fail("Failed to create product");
-        if (options.json) {
+        if (isJsonMode) {
           console.log(
             JSON.stringify(
-              {
-                status: "error",
-                error: createResult.error,
-                code: createResult.code
-              },
+              { status: "error", error: createResult.error, code: createResult.code },
               null,
               2
             )
           );
         } else {
-          console.error(import_chalk9.default.red(createResult.error));
+          console.error(import_chalk12.default.red(createResult.error));
         }
         process.exit(1);
       }
@@ -1770,60 +2358,1769 @@ Then retry: runtype products init --from ${options.from}`);
         createResult,
         result.agentCard,
         getDashboardUrl(),
-        options.json || false
+        isJsonMode
       );
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
       createSpinner.fail("Failed to create product");
-      console.error(import_chalk9.default.red(message));
+      console.error(import_chalk12.default.red(message));
       process.exit(1);
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
     spinner.fail("Failed to validate URL");
-    console.error(import_chalk9.default.red(message));
+    console.error(import_chalk12.default.red(message));
     process.exit(1);
   }
 });
+async function getApiKeyOrExit(isJsonMode, agentCard) {
+  const { CredentialStore: CredentialStore2 } = await Promise.resolve().then(() => (init_credential_store(), credential_store_exports));
+  const store = new CredentialStore2();
+  const apiKey = await store.getApiKey();
+  if (!apiKey) {
+    if (isJsonMode) {
+      console.log(
+        JSON.stringify(
+          {
+            status: "unauthenticated",
+            agentCard,
+            message: "Authentication required to create product"
+          },
+          null,
+          2
+        )
+      );
+    }
+    return null;
+  }
+  return apiKey;
+}
 
-// src/index.ts
-(0, import_dotenv.config)();
-var program = new import_commander9.Command();
-program.name("runtype").description("CLI for Runtype AI Platform").version("0.1.0").option("-v, --verbose", "Enable verbose output").option("--api-url <url>", "Override API URL").option("--json", "Output in JSON format");
-program.addCommand(authCommand);
-program.addCommand(flowsCommand);
-program.addCommand(recordsCommand);
-program.addCommand(promptsCommand);
-program.addCommand(batchCommand);
-program.addCommand(talkCommand);
-program.addCommand(configCommand);
-program.addCommand(productsCommand);
-program.exitOverride();
-try {
-  program.parse(process.argv);
-} catch (error) {
-  if (error.code === "commander.missingArgument") {
-    console.error(import_chalk10.default.red(`Error: ${error.message}`));
+// src/commands/init.ts
+init_cjs_shims();
+var import_commander9 = require("commander");
+var import_chalk13 = __toESM(require("chalk"));
+var import_ora8 = __toESM(require("ora"));
+init_credential_store();
+var initCommand = new import_commander9.Command("init").description("Set up Runtype CLI with guided onboarding").option("--api-url <url>", "Custom API URL").action(async (options) => {
+  console.log(import_chalk13.default.cyan("\nWelcome to Runtype!\n"));
+  console.log("This will walk you through setting up the CLI.\n");
+  const store = new CredentialStore();
+  const existingKey = await store.getApiKey();
+  if (existingKey) {
+    console.log(import_chalk13.default.green("You are already authenticated."));
+    const apiKeyManager = new ApiKeyManager();
+    try {
+      const isValid = await apiKeyManager.validateApiKey(existingKey, options.apiUrl);
+      if (isValid) {
+        console.log(import_chalk13.default.green("Your credentials are valid.\n"));
+        const continueSetup = await promptConfirm("Continue with product setup?", { default: true });
+        if (!continueSetup) {
+          showNextSteps();
+          return;
+        }
+        await productSetupFlow(existingKey, options.apiUrl);
+        return;
+      } else {
+        console.log(import_chalk13.default.yellow("Your stored credentials are no longer valid."));
+        console.log(import_chalk13.default.gray("Let's set up fresh credentials.\n"));
+      }
+    } catch {
+      console.log(import_chalk13.default.yellow("Could not validate stored credentials."));
+      console.log(import_chalk13.default.gray("Let's set up fresh credentials.\n"));
+    }
+  }
+  console.log(import_chalk13.default.cyan("Step 1: Authentication\n"));
+  const authMethod = await promptSelect("How would you like to get started?", [
+    { label: "Create a new account", value: "signup", description: "Sign up via browser" },
+    { label: "Log in to existing account", value: "login", description: "Sign in via browser" },
+    { label: "Use an API key", value: "apikey", description: "Paste an existing API key" }
+  ]);
+  let apiKey = null;
+  if (authMethod === "apikey") {
+    apiKey = await handleApiKeyAuth(store, options.apiUrl);
+  } else {
+    const mode = authMethod === "signup" ? "sign-up" : "sign-in";
+    apiKey = await handleBrowserAuth(store, mode, options.apiUrl);
+  }
+  if (!apiKey) {
+    console.log(import_chalk13.default.red('\nAuthentication was not completed. Run "runtype init" to try again.'));
     process.exit(1);
-  } else if (error.code === "commander.unknownOption") {
-    console.error(import_chalk10.default.red(`Error: ${error.message}`));
+  }
+  console.log();
+  const wantsProduct = await promptConfirm("Would you like to create a product now?", { default: true });
+  if (wantsProduct) {
+    await productSetupFlow(apiKey, options.apiUrl);
+  } else {
+    showNextSteps();
+  }
+});
+async function handleApiKeyAuth(store, apiUrl) {
+  const key = await promptText("Enter your API key");
+  if (!key) {
+    console.log(import_chalk13.default.red("No API key provided."));
+    return null;
+  }
+  const spinner = (0, import_ora8.default)("Validating API key...").start();
+  try {
+    const apiKeyManager = new ApiKeyManager();
+    const isValid = await apiKeyManager.validateApiKey(key, apiUrl);
+    if (!isValid) {
+      spinner.fail("Invalid API key");
+      return null;
+    }
+    const userData = await apiKeyManager.getCurrentUser(key, apiUrl);
+    await store.saveCredentials({
+      apiKey: key,
+      // @snake-case-ok: API auth/me response uses snake_case
+      userId: userData.user_id,
+      // @snake-case-ok: API auth/me response uses snake_case
+      orgId: userData.org_id ?? void 0,
+      apiUrl: apiUrl || getApiUrl()
+    });
+    spinner.succeed("Authenticated successfully!");
+    return key;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Authentication failed");
+    console.error(import_chalk13.default.red(message));
+    return null;
+  }
+}
+async function handleBrowserAuth(store, mode, apiUrl) {
+  const spinner = (0, import_ora8.default)("Opening browser for authentication...").start();
+  try {
+    const oauth = new OAuthManager({
+      clerkPublishableKey: getClerkPublishableKey(),
+      dashboardUrl: getDashboardUrl()
+    });
+    spinner.text = "Waiting for browser authentication...";
+    const sessionToken = await oauth.authenticate(mode);
+    spinner.text = "Exchanging credentials...";
+    const apiKeyManager = new ApiKeyManager();
+    const { key, userId, orgId } = await apiKeyManager.exchangeSessionForApiKey(
+      sessionToken,
+      apiUrl || getApiUrl()
+    );
+    await store.saveCredentials({
+      apiKey: key,
+      userId,
+      orgId,
+      apiUrl: apiUrl || getApiUrl()
+    });
+    spinner.succeed("Authenticated successfully!");
+    return key;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Authentication failed");
+    console.error(import_chalk13.default.red(message));
+    return null;
+  }
+}
+async function productSetupFlow(apiKey, apiUrl) {
+  console.log(import_chalk13.default.cyan("\nStep 2: Create a product\n"));
+  const sourceType = await promptSelect("What would you like to import?", [
+    { label: "A2A agent URL", value: "url", description: "Import from an agent endpoint" },
+    { label: "Skip for now", value: "skip", description: "Set up a product later" }
+  ]);
+  if (sourceType === "skip") {
+    showNextSteps();
+    return;
+  }
+  const url = await promptText("Enter the agent URL");
+  if (!url) {
+    console.log(import_chalk13.default.yellow("No URL provided. You can create a product later with:"));
+    console.log(import_chalk13.default.gray("  runtype products init"));
+    return;
+  }
+  const spinner = (0, import_ora8.default)("Validating URL...").start();
+  try {
+    const baseUrl = apiUrl || getApiUrl();
+    const response = await fetch(`${baseUrl}/${getApiVersion()}/quick-start/validate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ url })
+    });
+    const contentType = response.headers.get("content-type") || "";
+    if (!contentType.includes("application/json")) {
+      spinner.fail("Validation failed");
+      console.error(import_chalk13.default.red(`API error: ${response.status} ${response.statusText}`));
+      return;
+    }
+    const result = await response.json();
+    if (!result.valid) {
+      spinner.fail("Validation failed");
+      console.error(import_chalk13.default.red(result.error));
+      return;
+    }
+    spinner.succeed("A2A Agent Detected");
+    console.log(import_chalk13.default.cyan("\nAgent Details:"));
+    console.log(`  Name:        ${result.agentCard.name}`);
+    if (result.agentCard.description) {
+      console.log(`  Description: ${result.agentCard.description}`);
+    }
+    console.log(`  URL:         ${result.agentCard.url}`);
+    if (result.agentCard.skills?.length > 0) {
+      console.log("  Skills:");
+      for (const skill of result.agentCard.skills) {
+        const desc = skill.description ? ` - ${skill.description}` : "";
+        console.log(`    ${import_chalk13.default.cyan("\u2022")} ${skill.name}${desc}`);
+      }
+    }
+    const shouldCreate = await promptConfirm("\nCreate this product?", { default: true });
+    if (!shouldCreate) {
+      console.log(import_chalk13.default.gray("Product creation cancelled."));
+      showNextSteps();
+      return;
+    }
+    const productName = await promptText("Product name", { default: result.agentCard.name });
+    const createSpinner = (0, import_ora8.default)("Creating product...").start();
+    const createResponse = await fetch(`${baseUrl}/${getApiVersion()}/quick-start/create`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        templateId: result.templateId,
+        agentCard: result.agentCard,
+        productName,
+        sourceUrl: url
+      })
+    });
+    const createContentType = createResponse.headers.get("content-type") || "";
+    if (!createContentType.includes("application/json")) {
+      createSpinner.fail("Failed to create product");
+      console.error(import_chalk13.default.red(`API error: ${createResponse.status} ${createResponse.statusText}`));
+      return;
+    }
+    const createResult = await createResponse.json();
+    if (!createResult.success) {
+      createSpinner.fail("Failed to create product");
+      console.error(import_chalk13.default.red(createResult.error));
+      return;
+    }
+    createSpinner.succeed("Product Created");
+    const dashboardUrl = getDashboardUrl();
+    const productUrl = `${dashboardUrl}/products/${createResult.product.id}?launch=true`;
+    console.log(`
+Product ID:  ${createResult.product.id}`);
+    console.log(`Name:        ${createResult.product.name}`);
+    console.log(`Dashboard:   ${productUrl}`);
+    console.log(import_chalk13.default.green("\nSetup complete!"));
+    showNextSteps();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to validate URL");
+    console.error(import_chalk13.default.red(message));
+  }
+}
+function showNextSteps() {
+  console.log(import_chalk13.default.cyan("\nWhat you can do next:"));
+  console.log(`  ${import_chalk13.default.green("runtype products init")}     Create a product from an agent URL`);
+  console.log(`  ${import_chalk13.default.green("runtype flows list")}        List your flows`);
+  console.log(`  ${import_chalk13.default.green("runtype dispatch -f <id>")}  Execute a flow`);
+  console.log(`  ${import_chalk13.default.green("runtype agents list")}       List your agents`);
+  console.log(`  ${import_chalk13.default.green("runtype models list")}       View enabled models`);
+  console.log(`  ${import_chalk13.default.green("runtype talk")}              Start an interactive chat session`);
+  console.log(`  ${import_chalk13.default.green("runtype --help")}            See all available commands`);
+}
+
+// src/commands/dispatch.ts
+init_cjs_shims();
+var import_commander10 = require("commander");
+var import_chalk14 = __toESM(require("chalk"));
+var import_ora9 = __toESM(require("ora"));
+var import_fs5 = require("fs");
+var import_sdk4 = require("@runtypelabs/sdk");
+var dispatchCommand = new import_commander10.Command("dispatch").description("Execute a flow or agent via the dispatch API").option("-f, --flow <id>", "Flow ID to execute").option("-a, --agent <id>", "Agent ID to execute").option("-r, --record <id>", "Existing record ID").option("--record-json <file>", "JSON file with record data").option("-m, --message <text>", "Message to send").option("-v, --variable <key=value>", "Set a variable (repeatable)", collectVariables, []).option("--stream", "Stream the response (default)", true).option("--no-stream", "Wait for complete response").option("--json", "Output as JSON").option("--debug", "Show step-level details").action(async (options) => {
+  if (!options.flow && !options.agent) {
+    console.error(import_chalk14.default.red("Error: Either --flow or --agent is required"));
     process.exit(1);
-  } else if (error.code === "commander.help") {
-    process.exit(0);
+  }
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const client = new ApiClient(apiKey);
+  const payload = {};
+  if (options.flow) {
+    payload.flow = { id: options.flow };
+  }
+  if (options.agent) {
+    payload.agent = { id: options.agent };
+  }
+  if (options.record) {
+    payload.record = { id: options.record };
+  } else if (options.recordJson) {
+    try {
+      const data = JSON.parse((0, import_fs5.readFileSync)(options.recordJson, "utf-8"));
+      payload.record = { metadata: data };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      console.error(import_chalk14.default.red(`Failed to read record JSON: ${message}`));
+      process.exit(1);
+    }
+  }
+  if (options.message) {
+    payload.messages = [{ role: "user", content: options.message }];
+  }
+  if (options.variable && options.variable.length > 0) {
+    const variables = {};
+    for (const v of options.variable) {
+      const [key, ...rest] = v.split("=");
+      variables[key] = rest.join("=");
+    }
+    payload.variables = variables;
+  }
+  if (options.stream) {
+    await handleStreaming(client, payload, options);
   } else {
-    console.error(import_chalk10.default.red("An unexpected error occurred:"));
-    console.error(error);
+    await handleNonStreaming(client, payload, options);
+  }
+});
+function collectVariables(value, previous) {
+  return previous.concat([value]);
+}
+async function handleStreaming(client, payload, options) {
+  const spinner = (0, import_ora9.default)("Starting execution...").start();
+  let spinnerStopped = false;
+  try {
+    const response = await client.stream("/dispatch", payload);
+    const callbacks = {
+      onFlowStart: (event) => {
+        if (!spinnerStopped) {
+          spinner.stop();
+          spinnerStopped = true;
+        }
+        if (options.debug) {
+          console.log(import_chalk14.default.cyan(`Flow: ${event.flowName} (${event.totalSteps} steps)`));
+        }
+      },
+      onStepStart: (event) => {
+        if (!spinnerStopped) {
+          spinner.stop();
+          spinnerStopped = true;
+        }
+        if (options.debug) {
+          console.log(import_chalk14.default.gray(`
+[${event.name}] Running...`));
+        }
+      },
+      onStepChunk: (chunk) => {
+        if (!spinnerStopped) {
+          spinner.stop();
+          spinnerStopped = true;
+        }
+        process.stdout.write(chunk);
+      },
+      onStepComplete: (_result, event) => {
+        if (options.debug) {
+          console.log(import_chalk14.default.gray(`
+[${event.name}] Complete`));
+        }
+      },
+      onFlowComplete: (event) => {
+        if (options.json) {
+          console.log();
+          printJson(event);
+        }
+      },
+      onError: (err) => {
+        if (!spinnerStopped) {
+          spinner.fail("Execution failed");
+          spinnerStopped = true;
+        }
+        console.error(import_chalk14.default.red(`
+Error: ${err.message}`));
+      }
+    };
+    await (0, import_sdk4.processStream)(response, callbacks);
+    console.log();
+  } catch (error) {
+    if (!spinnerStopped) {
+      spinner.fail("Execution failed");
+    }
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(import_chalk14.default.red(message));
     process.exit(1);
   }
 }
-if (!process.argv.slice(2).length) {
+async function handleNonStreaming(client, payload, options) {
+  const spinner = (0, import_ora9.default)("Executing...").start();
   try {
-    program.outputHelp();
+    payload.streamResponse = false;
+    const result = await client.post("/dispatch", payload);
+    spinner.succeed("Execution complete");
+    if (options.json) {
+      printJson(result);
+    } else {
+      const steps = result.steps;
+      if (steps) {
+        for (const step of steps) {
+          console.log(import_chalk14.default.cyan(`
+[${step.name}]`));
+          if (typeof step.result === "string") {
+            console.log(step.result);
+          } else {
+            console.log(JSON.stringify(step.result, null, 2));
+          }
+        }
+      } else {
+        printJson(result);
+      }
+    }
   } catch (error) {
-    if (error.code === "commander.help") {
-      process.exit(0);
+    spinner.fail("Execution failed");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(import_chalk14.default.red(message));
+    process.exit(1);
+  }
+}
+
+// src/commands/agents.ts
+init_cjs_shims();
+var import_commander12 = require("commander");
+var import_chalk16 = __toESM(require("chalk"));
+var import_ora11 = __toESM(require("ora"));
+var import_sdk6 = require("@runtypelabs/sdk");
+
+// src/commands/agents-run-task.ts
+init_cjs_shims();
+var import_commander11 = require("commander");
+var import_chalk15 = __toESM(require("chalk"));
+var import_ora10 = __toESM(require("ora"));
+var fs3 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+var import_sdk5 = require("@runtypelabs/sdk");
+function defaultStateDir() {
+  return path4.join(process.cwd(), ".runtype", "tasks");
+}
+function stateFilePath(name, stateDir) {
+  const dir = stateDir || defaultStateDir();
+  const safeName = name.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return path4.join(dir, `${safeName}.json`);
+}
+function loadState(filePath) {
+  try {
+    const raw = fs3.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveState(filePath, state) {
+  const dir = path4.dirname(filePath);
+  fs3.mkdirSync(dir, { recursive: true });
+  state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  fs3.writeFileSync(filePath, JSON.stringify(state, null, 2));
+}
+var runTaskCommand = new import_commander11.Command("run-task").description("Run a long-task agent with local state persistence").argument("<agent>", "Agent ID or name").requiredOption("-m, --message <text>", "Task message for the agent").option("--max-sessions <n>", "Maximum sessions", "50").option("--max-cost <n>", "Budget in USD").option("--name <name>", "Task name (used for state file, defaults to agent ID)").option("--state-dir <path>", "Directory for state files (default: .runtype/tasks/)").option("--resume", "Resume from existing local state").option("--track-progress", "Also sync progress to the Runtype dashboard").option("--debug", "Show debug output from each session").option("--json", "Output final result as JSON").action(
+  async (agent, options) => {
+    const apiKey = await ensureAuth();
+    if (!apiKey) return;
+    const client = new import_sdk5.RuntypeClient({
+      apiKey,
+      baseUrl: getApiUrl()
+    });
+    let agentId = agent;
+    if (!agent.startsWith("agent_")) {
+      const spinner = (0, import_ora10.default)("Looking up agent by name...").start();
+      try {
+        const list = await client.agents.list();
+        const found = list.data.find(
+          (a) => a.name.toLowerCase() === agent.toLowerCase()
+        );
+        if (found) {
+          agentId = found.id;
+          spinner.succeed(`Found agent: ${import_chalk15.default.green(agentId)}`);
+        } else {
+          spinner.fail(`No agent found with name "${agent}"`);
+          console.log(import_chalk15.default.gray(`  Create one with: runtype agents create -n "${agent}"`));
+          process.exit(1);
+        }
+      } catch (error) {
+        spinner.fail("Failed to look up agent");
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error(import_chalk15.default.red(message));
+        process.exit(1);
+      }
+    }
+    const taskName = options.name || agentId;
+    const filePath = stateFilePath(taskName, options.stateDir);
+    const maxSessions = parseInt(options.maxSessions, 10);
+    const maxCost = options.maxCost ? parseFloat(options.maxCost) : void 0;
+    let localState;
+    let priorSessionCount = 0;
+    let priorCost = 0;
+    if (options.resume) {
+      const existing = loadState(filePath);
+      if (!existing) {
+        console.error(import_chalk15.default.red(`No state file found at ${filePath}`));
+        console.log(import_chalk15.default.gray("  Run without --resume to start a new task."));
+        process.exit(1);
+      }
+      if (existing.status === "complete") {
+        console.log(import_chalk15.default.yellow("This task already completed."));
+        if (options.json) printJson(existing);
+        return;
+      }
+      localState = existing;
+      localState.status = "running";
+      priorSessionCount = localState.sessionCount;
+      priorCost = localState.totalCost;
+      console.log(
+        import_chalk15.default.cyan(
+          `Resuming from session ${priorSessionCount} ($${priorCost.toFixed(4)} spent)`
+        )
+      );
     } else {
-      throw error;
+      localState = {
+        agentId,
+        taskName,
+        message: options.message,
+        status: "running",
+        sessionCount: 0,
+        totalCost: 0,
+        context: {},
+        lastOutput: "",
+        sessions: [],
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    let interrupted = false;
+    const onSigint = () => {
+      if (interrupted) process.exit(1);
+      interrupted = true;
+      console.log(import_chalk15.default.yellow("\n\nInterrupted \u2014 saving state..."));
+      localState.status = "paused";
+      saveState(filePath, localState);
+      console.log(import_chalk15.default.green(`State saved to ${filePath}`));
+      console.log(
+        import_chalk15.default.gray(
+          `  Resume with: runtype agents run-task ${agent} -m "${options.message}" --resume${options.name ? ` --name ${options.name}` : ""}`
+        )
+      );
+      process.exit(0);
+    };
+    process.on("SIGINT", onSigint);
+    const remainingSessions = maxSessions - priorSessionCount;
+    console.log(import_chalk15.default.cyan(`
+Running task "${taskName}" on ${agentId}`));
+    console.log(
+      import_chalk15.default.gray(
+        `  Sessions: ${priorSessionCount > 0 ? `${priorSessionCount} done, ` : ""}${remainingSessions} remaining${maxCost ? ` | Budget: $${maxCost.toFixed(2)}` : ""}`
+      )
+    );
+    console.log(import_chalk15.default.gray(`  State: ${filePath}
+`));
+    try {
+      const result = await client.agents.runTask(agentId, {
+        buildMessages: (state) => {
+          const merged = { ...localState.context, ...state.context };
+          const isFirstSession = state.sessionCount === 1;
+          const totalSession = priorSessionCount + state.sessionCount;
+          if (isFirstSession && !options.resume) {
+            return [{ role: "user", content: options.message }];
+          }
+          const progress = merged.progressNotes || merged.progress;
+          const progressStr = progress ? typeof progress === "string" ? progress : JSON.stringify(progress) : "No structured progress captured yet";
+          const resumeCtx = options.resume && isFirstSession ? `
+
+Resuming from session ${priorSessionCount}. Previous context: ${JSON.stringify(localState.context)}` : "";
+          return [
+            {
+              role: "user",
+              content: `${options.message}${resumeCtx}
+
+Progress so far: ${progressStr}
+Session ${totalSession} of ${maxSessions}.`
+            }
+          ];
+        },
+        maxSessions: remainingSessions,
+        maxCost,
+        trackProgress: options.trackProgress ? taskName : void 0,
+        debugMode: options.debug,
+        onSession: (session) => {
+          const sessionCost = session.sessionCount > 1 ? session.totalCost - localState.sessions.slice(-session.sessionCount + 1).reduce((s, e) => s + e.cost, 0) : session.totalCost;
+          const thisCost = sessionCost > 0 ? sessionCost : session.totalCost / session.sessionCount;
+          localState.sessionCount = priorSessionCount + session.sessionCount;
+          localState.totalCost = priorCost + session.totalCost;
+          Object.assign(localState.context, session.context);
+          localState.lastOutput = session.lastOutput;
+          localState.status = session.status;
+          localState.sessions.push({
+            index: localState.sessionCount,
+            cost: thisCost,
+            stopReason: session.lastStopReason,
+            outputPreview: session.lastOutput.slice(0, 200),
+            at: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          saveState(filePath, localState);
+          const total = localState.sessionCount;
+          const costStr = import_chalk15.default.yellow(`$${localState.totalCost.toFixed(4)}`);
+          const reasonColor = session.lastStopReason === "complete" ? import_chalk15.default.green : import_chalk15.default.gray;
+          console.log(
+            `  ${import_chalk15.default.dim(`[${total}/${maxSessions}]`)} ${reasonColor(session.lastStopReason)} | total: ${costStr}`
+          );
+          if (session.lastOutput) {
+            const preview = session.lastOutput.slice(0, 120).replace(/\n/g, " ");
+            console.log(
+              `    ${import_chalk15.default.dim(preview)}${session.lastOutput.length > 120 ? "..." : ""}`
+            );
+          }
+        }
+      });
+      localState.status = result.status;
+      localState.totalCost = priorCost + result.totalCost;
+      Object.assign(localState.context, result.context);
+      saveState(filePath, localState);
+      process.removeListener("SIGINT", onSigint);
+      console.log();
+      const statusColor = result.status === "complete" ? import_chalk15.default.green : result.status === "budget_exceeded" ? import_chalk15.default.red : import_chalk15.default.yellow;
+      console.log(`Status:     ${statusColor(localState.status)}`);
+      console.log(`Sessions:   ${localState.sessionCount}`);
+      console.log(`Total cost: ${import_chalk15.default.yellow(`$${localState.totalCost.toFixed(4)}`)}`);
+      console.log(`State:      ${import_chalk15.default.gray(filePath)}`);
+      if (localState.status === "paused" || localState.status === "max_sessions") {
+        console.log(
+          import_chalk15.default.gray(
+            `
+Resume: runtype agents run-task ${agent} -m "${options.message}" --resume${options.name ? ` --name ${options.name}` : ""}`
+          )
+        );
+      }
+      if (options.json) {
+        console.log();
+        printJson(localState);
+      }
+    } catch (error) {
+      localState.status = "paused";
+      saveState(filePath, localState);
+      process.removeListener("SIGINT", onSigint);
+      const message = error instanceof Error ? error.message : "Unknown error";
+      console.error(import_chalk15.default.red(`
+Task failed: ${message}`));
+      console.log(import_chalk15.default.gray(`State saved to ${filePath} \u2014 resume with --resume`));
+      process.exit(1);
+    }
+  }
+);
+
+// src/commands/agents.ts
+var agentsCommand = new import_commander12.Command("agents").description("Manage agents");
+agentsCommand.addCommand(runTaskCommand);
+agentsCommand.command("list").description("List all agents").option("--json", "Output as JSON").option("--limit <n>", "Limit results", "20").action(async (options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora11.default)("Fetching agents...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.get("/agents", {
+      limit: options.limit
+    });
+    spinner.stop();
+    if (options.json) {
+      printJson(data);
+    } else {
+      const agents = data.data ?? [];
+      if (agents.length === 0) {
+        console.log(import_chalk16.default.gray("No agents found"));
+        return;
+      }
+      console.log(import_chalk16.default.cyan("Your Agents:"));
+      for (const agent of agents) {
+        const desc = agent.description ? import_chalk16.default.gray(` - ${agent.description}`) : "";
+        console.log(`  ${import_chalk16.default.green(agent.id)} ${agent.name}${desc}`);
+      }
+      const total = getTotalCount(data.pagination);
+      if (total !== void 0) {
+        console.log(import_chalk16.default.dim(`
+  Total: ${total} agents`));
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to fetch agents");
+    console.error(import_chalk16.default.red(message));
+    process.exit(1);
+  }
+});
+agentsCommand.command("get <id>").description("Get agent details").option("--json", "Output as JSON").action(async (id, options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora11.default)("Fetching agent...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.get(
+      `/agents/${id}`
+    );
+    spinner.stop();
+    if (options.json) {
+      printJson(data);
+    } else {
+      printDetail("Agent", [
+        { label: "ID", value: data.id },
+        { label: "Name", value: data.name },
+        { label: "Description", value: data.description },
+        { label: "Status", value: data.status },
+        { label: "Model", value: data.model }
+      ]);
+      if (data.capabilities && data.capabilities.length > 0) {
+        console.log(import_chalk16.default.cyan("\n  Capabilities:"));
+        for (const cap of data.capabilities) {
+          console.log(`    ${import_chalk16.default.gray("-")} ${cap.name || cap.type || cap.id}`);
+        }
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to fetch agent");
+    console.error(import_chalk16.default.red(message));
+    process.exit(1);
+  }
+});
+agentsCommand.command("create").description("Create a new agent").requiredOption("-n, --name <name>", "Agent name").option("-d, --description <desc>", "Agent description").option("--json", "Output as JSON").action(async (options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora11.default)("Creating agent...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.post("/agents", {
+      name: options.name,
+      description: options.description
+    });
+    spinner.succeed("Agent created");
+    if (options.json) {
+      printJson(data);
+    } else {
+      console.log(`  ID: ${import_chalk16.default.green(data.id)}`);
+      console.log(`  Name: ${data.name}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to create agent");
+    console.error(import_chalk16.default.red(message));
+    process.exit(1);
+  }
+});
+agentsCommand.command("delete <id>").description("Delete an agent").action(async (id) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora11.default)("Deleting agent...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    await client.delete(`/agents/${id}`);
+    spinner.succeed("Agent deleted");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to delete agent");
+    console.error(import_chalk16.default.red(message));
+    process.exit(1);
+  }
+});
+agentsCommand.command("execute <id>").description("Execute an agent").requiredOption("-m, --message <text>", "Message to send").option("--stream", "Stream the response (default)", true).option("--no-stream", "Wait for complete response").option("--json", "Output as JSON").action(async (id, options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const client = new ApiClient(apiKey);
+  const payload = {
+    messages: [{ role: "user", content: options.message }]
+  };
+  if (options.stream) {
+    const spinner = (0, import_ora11.default)("Starting agent...").start();
+    try {
+      const response = await client.stream(`/agents/${id}/execute`, payload);
+      spinner.stop();
+      const callbacks = {
+        onStepChunk: (chunk) => {
+          process.stdout.write(chunk);
+        },
+        onError: (err) => {
+          console.error(import_chalk16.default.red(`
+Error: ${err.message}`));
+        }
+      };
+      await (0, import_sdk6.processStream)(response, callbacks);
+      console.log();
+    } catch (error) {
+      spinner.fail("Execution failed");
+      const message = error instanceof Error ? error.message : "Unknown error";
+      console.error(import_chalk16.default.red(message));
+      process.exit(1);
+    }
+  } else {
+    const spinner = (0, import_ora11.default)("Executing agent...").start();
+    try {
+      const result = await client.post(`/agents/${id}/execute`, {
+        ...payload,
+        streamResponse: false
+      });
+      spinner.succeed("Execution complete");
+      if (options.json) {
+        printJson(result);
+      } else {
+        printJson(result);
+      }
+    } catch (error) {
+      spinner.fail("Execution failed");
+      const message = error instanceof Error ? error.message : "Unknown error";
+      console.error(import_chalk16.default.red(message));
+      process.exit(1);
+    }
+  }
+});
+
+// src/commands/models.ts
+init_cjs_shims();
+var import_commander13 = require("commander");
+var import_chalk17 = __toESM(require("chalk"));
+var import_ora12 = __toESM(require("ora"));
+var modelsCommand = new import_commander13.Command("models").description("Manage model configurations");
+modelsCommand.command("list").description("List your enabled model configurations").option("--json", "Output as JSON").action(async (options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora12.default)("Fetching model configurations...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.get("/model-configs");
+    spinner.stop();
+    if (options.json) {
+      printJson(data);
+    } else {
+      const models = data.data ?? [];
+      if (models.length === 0) {
+        console.log(import_chalk17.default.gray("No model configurations found"));
+        return;
+      }
+      console.log(import_chalk17.default.cyan("Your Models:"));
+      for (const model of models) {
+        const defaultTag = model.isDefault ? import_chalk17.default.yellow(" (default)") : "";
+        const statusTag = model.enabled === false ? import_chalk17.default.red(" [disabled]") : "";
+        console.log(`  ${import_chalk17.default.green(model.id)} ${model.modelId}${defaultTag}${statusTag}`);
+      }
+      const total = getTotalCount(data.pagination);
+      if (total !== void 0) {
+        console.log(import_chalk17.default.dim(`
+  Total: ${total} models`));
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to fetch models");
+    console.error(import_chalk17.default.red(message));
+    process.exit(1);
+  }
+});
+modelsCommand.command("available").description("List all available models grouped by provider").option("--json", "Output as JSON").action(async (options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora12.default)("Fetching available models...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.get("/model-configs/grouped");
+    spinner.stop();
+    if (options.json) {
+      printJson(data);
+    } else {
+      const groups = data.data ?? [];
+      if (groups.length === 0) {
+        console.log(import_chalk17.default.gray("No models available"));
+        return;
+      }
+      console.log(import_chalk17.default.cyan("Available Models:"));
+      for (const group of groups) {
+        console.log(`
+  ${import_chalk17.default.blue(group.provider)} / ${import_chalk17.default.green(group.baseModel)}`);
+        for (const variant of group.variants) {
+          const configuredTag = variant.configured ? import_chalk17.default.green(" [configured]") : "";
+          console.log(`    ${variant.modelId}${configuredTag}`);
+        }
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to fetch available models");
+    console.error(import_chalk17.default.red(message));
+    process.exit(1);
+  }
+});
+modelsCommand.command("enable <modelId>").description("Enable a model by creating a configuration").option("--json", "Output as JSON").action(async (modelId, options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora12.default)(`Enabling model ${modelId}...`).start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.post("/model-configs", { modelId });
+    spinner.succeed("Model enabled");
+    if (options.json) {
+      printJson(data);
+    } else {
+      console.log(`  Config ID: ${import_chalk17.default.green(data.id)}`);
+      console.log(`  Model: ${data.modelId}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to enable model");
+    console.error(import_chalk17.default.red(message));
+    process.exit(1);
+  }
+});
+modelsCommand.command("disable <id>").description("Disable a model configuration").action(async (id) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora12.default)("Disabling model...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    await client.patch(`/model-configs/${id}/status`, { enabled: false });
+    spinner.succeed("Model disabled");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to disable model");
+    console.error(import_chalk17.default.red(message));
+    process.exit(1);
+  }
+});
+modelsCommand.command("default <id>").description("Set a model configuration as default").action(async (id) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora12.default)("Setting default model...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    await client.patch(`/model-configs/${id}/default`, {});
+    spinner.succeed("Default model updated");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to set default model");
+    console.error(import_chalk17.default.red(message));
+    process.exit(1);
+  }
+});
+modelsCommand.command("usage").description("Show model usage statistics").option("--json", "Output as JSON").action(async (options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora12.default)("Fetching model usage...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.get("/model-configs/usage");
+    spinner.stop();
+    if (options.json) {
+      printJson(data);
+    } else {
+      printJson(data);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to fetch model usage");
+    console.error(import_chalk17.default.red(message));
+    process.exit(1);
+  }
+});
+
+// src/commands/schedules.ts
+init_cjs_shims();
+var import_commander14 = require("commander");
+var import_chalk18 = __toESM(require("chalk"));
+var import_ora13 = __toESM(require("ora"));
+var schedulesCommand = new import_commander14.Command("schedules").description("Manage schedules");
+schedulesCommand.command("list").description("List all schedules").option("--json", "Output as JSON").action(async (options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora13.default)("Fetching schedules...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.get("/schedules");
+    spinner.stop();
+    if (options.json) {
+      printJson(data);
+    } else {
+      const schedules = data.data ?? [];
+      if (schedules.length === 0) {
+        console.log(import_chalk18.default.gray("No schedules found"));
+        return;
+      }
+      console.log(import_chalk18.default.cyan("Your Schedules:"));
+      for (const s of schedules) {
+        const name = s.name || s.id;
+        const statusColor = s.status === "active" ? "green" : "yellow";
+        const statusTag = s.status ? import_chalk18.default[statusColor](` [${s.status}]`) : "";
+        console.log(`  ${import_chalk18.default.green(s.id)} ${name}${statusTag}`);
+        console.log(`    Flow: ${import_chalk18.default.gray(s.flowId)}`);
+        if (s.cronExpression) {
+          console.log(`    Cron: ${import_chalk18.default.gray(s.cronExpression)}`);
+        }
+        if (s.nextRunAt) {
+          console.log(`    Next run: ${import_chalk18.default.gray(s.nextRunAt)}`);
+        }
+      }
+      const total = getTotalCount(data.pagination);
+      if (total !== void 0) {
+        console.log(import_chalk18.default.dim(`
+  Total: ${total} schedules`));
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to fetch schedules");
+    console.error(import_chalk18.default.red(message));
+    process.exit(1);
+  }
+});
+schedulesCommand.command("get <id>").description("Get schedule details").option("--json", "Output as JSON").action(async (id, options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora13.default)("Fetching schedule...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.get(`/schedules/${id}`);
+    spinner.stop();
+    if (options.json) {
+      printJson(data);
+    } else {
+      printDetail("Schedule", [
+        { label: "ID", value: data.id },
+        { label: "Name", value: data.name },
+        { label: "Flow ID", value: data.flowId },
+        { label: "Cron", value: data.cronExpression },
+        { label: "Status", value: data.status },
+        { label: "Next run", value: data.nextRunAt },
+        { label: "Last run", value: data.lastRunAt }
+      ]);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to fetch schedule");
+    console.error(import_chalk18.default.red(message));
+    process.exit(1);
+  }
+});
+schedulesCommand.command("create").description("Create a new schedule").requiredOption("-f, --flow <id>", "Flow ID to schedule").requiredOption("-c, --cron <expression>", 'Cron expression (e.g. "0 9 * * *")').option("-n, --name <name>", "Schedule name").option("--json", "Output as JSON").action(async (options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora13.default)("Creating schedule...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.post("/schedules", {
+      flowId: options.flow,
+      cronExpression: options.cron,
+      name: options.name
+    });
+    spinner.succeed("Schedule created");
+    if (options.json) {
+      printJson(data);
+    } else {
+      console.log(`  ID: ${import_chalk18.default.green(data.id)}`);
+      if (data.name) console.log(`  Name: ${data.name}`);
+      console.log(`  Cron: ${data.cronExpression}`);
+      if (data.nextRunAt) console.log(`  Next run: ${data.nextRunAt}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to create schedule");
+    console.error(import_chalk18.default.red(message));
+    process.exit(1);
+  }
+});
+schedulesCommand.command("pause <id>").description("Pause a schedule").action(async (id) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora13.default)("Pausing schedule...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    await client.post(`/schedules/${id}/pause`);
+    spinner.succeed("Schedule paused");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to pause schedule");
+    console.error(import_chalk18.default.red(message));
+    process.exit(1);
+  }
+});
+schedulesCommand.command("resume <id>").description("Resume a paused schedule").action(async (id) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora13.default)("Resuming schedule...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    await client.post(`/schedules/${id}/resume`);
+    spinner.succeed("Schedule resumed");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to resume schedule");
+    console.error(import_chalk18.default.red(message));
+    process.exit(1);
+  }
+});
+schedulesCommand.command("run-now <id>").description("Trigger a schedule to run immediately").action(async (id) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora13.default)("Triggering schedule...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    await client.post(`/schedules/${id}/run-now`);
+    spinner.succeed("Schedule triggered");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to trigger schedule");
+    console.error(import_chalk18.default.red(message));
+    process.exit(1);
+  }
+});
+schedulesCommand.command("delete <id>").description("Delete a schedule").action(async (id) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora13.default)("Deleting schedule...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    await client.delete(`/schedules/${id}`);
+    spinner.succeed("Schedule deleted");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to delete schedule");
+    console.error(import_chalk18.default.red(message));
+    process.exit(1);
+  }
+});
+
+// src/commands/eval.ts
+init_cjs_shims();
+var import_commander15 = require("commander");
+var import_chalk19 = __toESM(require("chalk"));
+var import_ora14 = __toESM(require("ora"));
+var import_fs6 = require("fs");
+var evalCommand = new import_commander15.Command("eval").description("Manage evaluations");
+evalCommand.command("submit").description("Submit an eval batch").requiredOption("-f, --flow <id>", "Flow ID to evaluate").requiredOption("-r, --records <file>", "JSON file with record IDs").option("-n, --name <name>", "Eval batch name").option("--json", "Output as JSON").action(async (options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  let recordIds;
+  try {
+    const content = (0, import_fs6.readFileSync)(options.records, "utf-8");
+    const parsed = JSON.parse(content);
+    recordIds = Array.isArray(parsed) ? parsed : parsed.recordIds || parsed.records || [];
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(import_chalk19.default.red(`Failed to read records file: ${message}`));
+    process.exit(1);
+    return;
+  }
+  const spinner = (0, import_ora14.default)(`Submitting eval with ${recordIds.length} records...`).start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.post("/eval/submit", {
+      flowId: options.flow,
+      recordIds,
+      name: options.name
+    });
+    spinner.succeed("Eval submitted");
+    if (options.json) {
+      printJson(data);
+    } else {
+      console.log(`  Batch ID: ${import_chalk19.default.green(data.id)}`);
+      if (data.name) console.log(`  Name: ${data.name}`);
+      console.log(`  Status: ${data.status}`);
+      console.log(`  Records: ${data.totalRecords}`);
+      if (data.groupId) console.log(`  Group: ${data.groupId}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to submit eval");
+    console.error(import_chalk19.default.red(message));
+    process.exit(1);
+  }
+});
+evalCommand.command("list").description("List eval batches").option("--flow <id>", "Filter by flow ID").option("--limit <n>", "Limit results", "20").option("--json", "Output as JSON").action(async (options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora14.default)("Fetching eval batches...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const params = { limit: options.limit };
+    if (options.flow) params.flowId = options.flow;
+    const data = await client.get("/eval/batches", params);
+    spinner.stop();
+    if (options.json) {
+      printJson(data);
+    } else {
+      const batches = data.data ?? [];
+      if (batches.length === 0) {
+        console.log(import_chalk19.default.gray("No eval batches found"));
+        return;
+      }
+      console.log(import_chalk19.default.cyan("Eval Batches:"));
+      for (const batch of batches) {
+        const name = batch.name || batch.id;
+        const progress = batch.totalRecords ? `${batch.completedRecords ?? 0}/${batch.totalRecords}` : "";
+        const statusColor = batch.status === "completed" ? "green" : "yellow";
+        console.log(
+          `  ${import_chalk19.default.green(batch.id)} ${name} ${import_chalk19.default[statusColor](`[${batch.status}]`)} ${import_chalk19.default.gray(progress)}`
+        );
+      }
+      const total = getTotalCount(data.pagination);
+      if (total !== void 0) {
+        console.log(import_chalk19.default.dim(`
+  Total: ${total} batches`));
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to fetch eval batches");
+    console.error(import_chalk19.default.red(message));
+    process.exit(1);
+  }
+});
+evalCommand.command("results <id>").description("Get eval batch results").option("--json", "Output as JSON").action(async (id, options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora14.default)("Fetching eval results...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.get(`/eval/${id}/results`);
+    spinner.stop();
+    if (options.json) {
+      printJson(data);
+    } else {
+      if (data.batch) {
+        console.log(import_chalk19.default.cyan(`Eval: ${data.batch.name || data.batch.id}`));
+        console.log(`  Status: ${data.batch.status}`);
+        console.log(`  Progress: ${data.batch.completedRecords ?? 0}/${data.batch.totalRecords ?? 0}`);
+        console.log();
+      }
+      const results = data.data ?? [];
+      if (results.length === 0) {
+        console.log(import_chalk19.default.gray("No results yet"));
+        return;
+      }
+      console.log(import_chalk19.default.cyan("Results:"));
+      for (const result of results) {
+        const scoreStr = result.score !== void 0 ? import_chalk19.default.blue(` score=${result.score}`) : "";
+        const statusColor = result.status === "completed" ? "green" : "red";
+        console.log(
+          `  ${import_chalk19.default.gray(result.recordId)} ${import_chalk19.default[statusColor](`[${result.status}]`)}${scoreStr}`
+        );
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to fetch eval results");
+    console.error(import_chalk19.default.red(message));
+    process.exit(1);
+  }
+});
+evalCommand.command("compare <groupId>").description("Compare evals in a group").option("--json", "Output as JSON").action(async (groupId, options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora14.default)("Comparing evals...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.post("/eval/compare", { groupId });
+    spinner.stop();
+    if (options.json) {
+      printJson(data);
+    } else {
+      printJson(data);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to compare evals");
+    console.error(import_chalk19.default.red(message));
+    process.exit(1);
+  }
+});
+
+// src/commands/api-keys.ts
+init_cjs_shims();
+var import_commander16 = require("commander");
+var import_chalk20 = __toESM(require("chalk"));
+var import_ora15 = __toESM(require("ora"));
+var apiKeysCommand = new import_commander16.Command("api-keys").description("Manage API keys");
+apiKeysCommand.command("list").description("List your API keys").option("--json", "Output as JSON").action(async (options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora15.default)("Fetching API keys...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.get("/api-keys");
+    spinner.stop();
+    if (options.json) {
+      printJson(data);
+    } else {
+      const keys = data.data ?? [];
+      if (keys.length === 0) {
+        console.log(import_chalk20.default.gray("No API keys found"));
+        return;
+      }
+      console.log(import_chalk20.default.cyan("Your API Keys:"));
+      for (const key of keys) {
+        const prefix = key.prefix ? import_chalk20.default.gray(` (${key.prefix}...)`) : "";
+        const lastUsed = key.lastUsedAt ? import_chalk20.default.gray(` last used: ${key.lastUsedAt}`) : "";
+        console.log(`  ${import_chalk20.default.green(key.id)} ${key.name}${prefix}${lastUsed}`);
+      }
+      const total = getTotalCount(data.pagination);
+      if (total !== void 0) {
+        console.log(import_chalk20.default.dim(`
+  Total: ${total} keys`));
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to fetch API keys");
+    console.error(import_chalk20.default.red(message));
+    process.exit(1);
+  }
+});
+apiKeysCommand.command("get <id>").description("Get API key details").option("--json", "Output as JSON").action(async (id, options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora15.default)("Fetching API key...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.get(`/api-keys/${id}`);
+    spinner.stop();
+    if (options.json) {
+      printJson(data);
+    } else {
+      printDetail("API Key", [
+        { label: "ID", value: data.id },
+        { label: "Name", value: data.name },
+        { label: "Prefix", value: data.prefix },
+        { label: "Scopes", value: data.scopes?.join(", ") },
+        { label: "Last used", value: data.lastUsedAt },
+        { label: "Created", value: data.createdAt }
+      ]);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to fetch API key");
+    console.error(import_chalk20.default.red(message));
+    process.exit(1);
+  }
+});
+apiKeysCommand.command("create").description("Create a new API key").requiredOption("-n, --name <name>", "Key name").option("--json", "Output as JSON").action(async (options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora15.default)("Creating API key...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.post("/api-keys", {
+      name: options.name
+    });
+    spinner.succeed("API key created");
+    if (options.json) {
+      printJson(data);
+    } else {
+      console.log(`  ID: ${import_chalk20.default.green(data.id)}`);
+      console.log(`  Name: ${data.name}`);
+      if (data.key) {
+        console.log(`  Key: ${import_chalk20.default.yellow(data.key)}`);
+        console.log(import_chalk20.default.gray("  Save this key - it will not be shown again"));
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to create API key");
+    console.error(import_chalk20.default.red(message));
+    process.exit(1);
+  }
+});
+apiKeysCommand.command("delete <id>").description("Delete an API key").action(async (id) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora15.default)("Deleting API key...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    await client.delete(`/api-keys/${id}`);
+    spinner.succeed("API key deleted");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to delete API key");
+    console.error(import_chalk20.default.red(message));
+    process.exit(1);
+  }
+});
+apiKeysCommand.command("regenerate <id>").description("Regenerate an API key").option("--json", "Output as JSON").action(async (id, options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora15.default)("Regenerating API key...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.post(`/api-keys/${id}/regenerate`);
+    spinner.succeed("API key regenerated");
+    if (options.json) {
+      printJson(data);
+    } else {
+      if (data.key) {
+        console.log(`  New Key: ${import_chalk20.default.yellow(data.key)}`);
+        console.log(import_chalk20.default.gray("  Save this key - it will not be shown again"));
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to regenerate API key");
+    console.error(import_chalk20.default.red(message));
+    process.exit(1);
+  }
+});
+apiKeysCommand.command("analytics").description("Show API key usage analytics").option("--key <id>", "Specific key ID (defaults to all keys)").option("--json", "Output as JSON").action(async (options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora15.default)("Fetching analytics...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const path5 = options.key ? `/api-keys/${options.key}/analytics` : "/api-keys/analytics";
+    const data = await client.get(path5);
+    spinner.stop();
+    if (options.json) {
+      printJson(data);
+    } else {
+      printJson(data);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to fetch analytics");
+    console.error(import_chalk20.default.red(message));
+    process.exit(1);
+  }
+});
+
+// src/commands/analytics.ts
+init_cjs_shims();
+var import_commander17 = require("commander");
+var import_chalk21 = __toESM(require("chalk"));
+var import_ora16 = __toESM(require("ora"));
+var analyticsCommand = new import_commander17.Command("analytics").description("View analytics and execution results");
+analyticsCommand.command("stats").description("Show account statistics").option("--json", "Output as JSON").action(async (options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora16.default)("Fetching stats...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.get("/analytics/stats");
+    spinner.stop();
+    if (options.json) {
+      printJson(data);
+    } else {
+      printDetail("Account Statistics", [
+        { label: "Flows", value: data.flows },
+        { label: "Prompts", value: data.prompts },
+        { label: "Records", value: data.records },
+        { label: "Executions", value: data.executions }
+      ]);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to fetch stats");
+    console.error(import_chalk21.default.red(message));
+    process.exit(1);
+  }
+});
+analyticsCommand.command("results").description("List execution results").option("--flow <id>", "Filter by flow ID").option("--record <id>", "Filter by record ID").option("--status <status>", "Filter by status").option("--limit <n>", "Limit results", "20").option("--json", "Output as JSON").action(
+  async (options) => {
+    const apiKey = await ensureAuth();
+    if (!apiKey) return;
+    const spinner = (0, import_ora16.default)("Fetching results...").start();
+    try {
+      const client = new ApiClient(apiKey);
+      const params = { limit: options.limit };
+      if (options.flow) params.flowId = options.flow;
+      if (options.record) params.recordId = options.record;
+      if (options.status) params.status = options.status;
+      const data = await client.get(
+        "/analytics/record-results",
+        params
+      );
+      spinner.stop();
+      if (options.json) {
+        printJson(data);
+      } else {
+        const results = data.data ?? [];
+        if (results.length === 0) {
+          console.log(import_chalk21.default.gray("No results found"));
+          return;
+        }
+        console.log(import_chalk21.default.cyan("Execution Results:"));
+        for (const result of results) {
+          const statusColor = result.status === "completed" ? "green" : "red";
+          const date = result.createdAt ? import_chalk21.default.gray(` ${result.createdAt}`) : "";
+          console.log(
+            `  ${import_chalk21.default.green(result.id)} ${import_chalk21.default[statusColor](`[${result.status}]`)} flow=${import_chalk21.default.gray(result.flowId)} record=${import_chalk21.default.gray(result.recordId)}${date}`
+          );
+        }
+        const total = getTotalCount(data.pagination);
+        if (total !== void 0) {
+          console.log(import_chalk21.default.dim(`
+  Total: ${total} results`));
+        }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      spinner.fail("Failed to fetch results");
+      console.error(import_chalk21.default.red(message));
+      process.exit(1);
+    }
+  }
+);
+
+// src/commands/billing.ts
+init_cjs_shims();
+var import_commander18 = require("commander");
+var import_chalk22 = __toESM(require("chalk"));
+var import_ora17 = __toESM(require("ora"));
+var import_open3 = __toESM(require("open"));
+var billingCommand = new import_commander18.Command("billing").description("View billing and subscription info");
+billingCommand.command("status").description("Show current plan and usage").option("--json", "Output as JSON").action(async (options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora17.default)("Fetching billing status...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.get("/billing/status");
+    spinner.stop();
+    if (options.json) {
+      printJson(data);
+    } else {
+      printDetail("Billing Status", [
+        { label: "Plan", value: data.planName || data.plan },
+        { label: "Status", value: data.status },
+        { label: "Period start", value: data.currentPeriodStart },
+        { label: "Period end", value: data.currentPeriodEnd }
+      ]);
+      if (data.usage) {
+        console.log();
+        const limit = data.usage.executionsLimit;
+        const used = data.usage.executionsUsed ?? 0;
+        const limitStr = limit ? `/${limit}` : "";
+        printDetail("Usage", [
+          { label: "Executions", value: `${used}${limitStr}` }
+        ]);
+      }
+      if (data.limits) {
+        console.log();
+        printDetail("Limits", [
+          { label: "Daily", value: data.limits.dailyLimit },
+          { label: "Monthly", value: data.limits.monthlyLimit },
+          { label: "Rate limit", value: data.limits.rateLimit }
+        ]);
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to fetch billing status");
+    console.error(import_chalk22.default.red(message));
+    process.exit(1);
+  }
+});
+billingCommand.command("portal").description("Open the billing portal in your browser").action(async () => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora17.default)("Generating portal link...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.post("/billing/portal");
+    spinner.stop();
+    if (data.url) {
+      console.log(import_chalk22.default.cyan("Opening billing portal..."));
+      await (0, import_open3.default)(data.url);
+    } else {
+      console.log(import_chalk22.default.yellow("No portal URL returned. You may need to set up billing first."));
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to open billing portal");
+    console.error(import_chalk22.default.red(message));
+    process.exit(1);
+  }
+});
+billingCommand.command("refresh").description("Refresh plan data from billing provider").action(async () => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora17.default)("Refreshing plan data...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    await client.post("/billing/refresh");
+    spinner.succeed("Plan data refreshed");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to refresh plan data");
+    console.error(import_chalk22.default.red(message));
+    process.exit(1);
+  }
+});
+
+// src/commands/flow-versions.ts
+init_cjs_shims();
+var import_commander19 = require("commander");
+var import_chalk23 = __toESM(require("chalk"));
+var import_ora18 = __toESM(require("ora"));
+var flowVersionsCommand = new import_commander19.Command("flow-versions").description(
+  "Manage flow versions"
+);
+flowVersionsCommand.command("list <flowId>").description("List all versions for a flow").option("--json", "Output as JSON").action(async (flowId, options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora18.default)("Fetching versions...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.get(`/flow-versions/${flowId}`);
+    spinner.stop();
+    if (options.json) {
+      printJson(data);
+    } else {
+      const versions = data.data ?? [];
+      if (versions.length === 0) {
+        console.log(import_chalk23.default.gray("No versions found"));
+        return;
+      }
+      console.log(import_chalk23.default.cyan(`Versions for flow ${flowId}:`));
+      for (const v of versions) {
+        const publishedTag = v.published ? import_chalk23.default.green(" [published]") : "";
+        const versionNum = v.version !== void 0 ? `v${v.version}` : v.id;
+        const date = v.createdAt ? import_chalk23.default.gray(` ${v.createdAt}`) : "";
+        console.log(`  ${import_chalk23.default.green(v.id)} ${versionNum}${publishedTag}${date}`);
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to fetch versions");
+    console.error(import_chalk23.default.red(message));
+    process.exit(1);
+  }
+});
+flowVersionsCommand.command("get <flowId> <versionId>").description("Get a specific version").option("--json", "Output as JSON").action(async (flowId, versionId, options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora18.default)("Fetching version...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.get(`/flow-versions/${flowId}/${versionId}`);
+    spinner.stop();
+    if (options.json) {
+      printJson(data);
+    } else {
+      printDetail("Flow Version", [
+        { label: "ID", value: data.id },
+        { label: "Flow ID", value: data.flowId },
+        { label: "Version", value: data.version },
+        { label: "Published", value: data.published },
+        { label: "Created", value: data.createdAt },
+        { label: "Steps", value: data.steps?.length }
+      ]);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to fetch version");
+    console.error(import_chalk23.default.red(message));
+    process.exit(1);
+  }
+});
+flowVersionsCommand.command("published <flowId>").description("Get the published version for a flow").option("--json", "Output as JSON").action(async (flowId, options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora18.default)("Fetching published version...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    const data = await client.get(`/flow-versions/${flowId}/published`);
+    spinner.stop();
+    if (options.json) {
+      printJson(data);
+    } else {
+      printDetail("Published Version", [
+        { label: "ID", value: data.id },
+        { label: "Version", value: data.version },
+        { label: "Created", value: data.createdAt },
+        { label: "Steps", value: data.steps?.length }
+      ]);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to fetch published version");
+    console.error(import_chalk23.default.red(message));
+    process.exit(1);
+  }
+});
+flowVersionsCommand.command("publish <flowId>").description("Publish a version").requiredOption("-v, --version <versionId>", "Version ID to publish").action(async (flowId, options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const spinner = (0, import_ora18.default)("Publishing version...").start();
+  try {
+    const client = new ApiClient(apiKey);
+    await client.post(`/flow-versions/${flowId}/publish`, {
+      versionId: options.version
+    });
+    spinner.succeed("Version published");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to publish version");
+    console.error(import_chalk23.default.red(message));
+    process.exit(1);
+  }
+});
+
+// src/index.ts
+init_credential_store();
+(0, import_dotenv.config)();
+var program = new import_commander20.Command();
+program.name("runtype").description("CLI for Runtype AI Platform").version("0.1.0").option("-v, --verbose", "Enable verbose output").option("--api-url <url>", "Override API URL").option("--json", "Output in JSON format");
+program.addCommand(initCommand);
+program.addCommand(authCommand);
+program.addCommand(flowsCommand);
+program.addCommand(recordsCommand);
+program.addCommand(promptsCommand);
+program.addCommand(batchCommand);
+program.addCommand(talkCommand);
+program.addCommand(configCommand);
+program.addCommand(productsCommand);
+program.addCommand(dispatchCommand);
+program.addCommand(agentsCommand);
+program.addCommand(modelsCommand);
+program.addCommand(schedulesCommand);
+program.addCommand(evalCommand);
+program.addCommand(apiKeysCommand);
+program.addCommand(analyticsCommand);
+program.addCommand(billingCommand);
+program.addCommand(flowVersionsCommand);
+program.exitOverride();
+try {
+  if (!process.argv.slice(2).length) {
+    handleNoCommand();
+  } else {
+    program.parse(process.argv);
+  }
+} catch (error) {
+  const commanderError = error;
+  if (commanderError.code === "commander.missingArgument") {
+    console.error(import_chalk24.default.red(`Error: ${commanderError.message}`));
+    process.exit(1);
+  } else if (commanderError.code === "commander.unknownOption") {
+    console.error(import_chalk24.default.red(`Error: ${commanderError.message}`));
+    process.exit(1);
+  } else if (commanderError.code === "commander.help") {
+    process.exit(0);
+  } else {
+    console.error(import_chalk24.default.red("An unexpected error occurred:"));
+    console.error(error);
+    process.exit(1);
+  }
+}
+async function handleNoCommand() {
+  const store = new CredentialStore();
+  const hasCredentials = await store.hasCredentials();
+  if (!hasCredentials) {
+    console.log(import_chalk24.default.cyan("\nWelcome to Runtype CLI!\n"));
+    console.log("It looks like this is your first time. Run the setup wizard:");
+    console.log(`  ${import_chalk24.default.green("runtype init")}
+`);
+    console.log("Or see all available commands:");
+    console.log(`  ${import_chalk24.default.green("runtype --help")}
+`);
+  } else {
+    try {
+      program.outputHelp();
+    } catch (error) {
+      const commanderError = error;
+      if (commanderError.code === "commander.help") {
+        process.exit(0);
+      } else {
+        throw error;
+      }
     }
   }
 }