npm - @runtypelabs/cli - Versions diffs - 0.1.0 → 0.1.1 - Mend

@runtypelabs/cli 0.1.0 → 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/index.js ADDED Viewed

@@ -0,0 +1,1628 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+// src/index.ts
+var import_commander8 = require("commander");
+var import_chalk9 = __toESM(require("chalk"));
+var import_dotenv = require("dotenv");
+var import_shared = require("@travrse/shared");
+// src/commands/auth.ts
+var import_commander = require("commander");
+var import_chalk = __toESM(require("chalk"));
+var import_ora = __toESM(require("ora"));
+// src/auth/oauth-manager.ts
+var import_open = __toESM(require("open"));
+var import_crypto = __toESM(require("crypto"));
+// src/auth/callback-server.ts
+var import_express = __toESM(require("express"));
+var CallbackServer = class {
+  server = null;
+  app;
+  constructor() {
+    this.app = (0, import_express.default)();
+  }
+  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" });
+      });
+      this.server = this.app.listen(port, () => {
+        console.log(`Callback server listening on port ${port}`);
+      });
+      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);
+        } else {
+          reject(error);
+        }
+      });
+    });
+  }
+  stop() {
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+    }
+  }
+  successHTML() {
+    return `
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <title>Authentication Successful</title>
+          <style>
+            * {
+              margin: 0;
+              padding: 0;
+              box-sizing: border-box;
+            }
+            body {
+              font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+              display: flex;
+              align-items: center;
+              justify-content: center;
+              height: 100vh;
+              background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            }
+            .container {
+              background: white;
+              padding: 3rem;
+              border-radius: 12px;
+              text-align: center;
+              box-shadow: 0 20px 40px rgba(0,0,0,0.1);
+              max-width: 400px;
+              animation: slideUp 0.3s ease-out;
+            }
+            @keyframes slideUp {
+              from {
+                opacity: 0;
+                transform: translateY(20px);
+              }
+              to {
+                opacity: 1;
+                transform: translateY(0);
+              }
+            }
+            .checkmark {
+              color: #10b981;
+              font-size: 64px;
+              margin-bottom: 1rem;
+              animation: scaleIn 0.3s ease-out 0.1s both;
+            }
+            @keyframes scaleIn {
+              from {
+                transform: scale(0);
+              }
+              to {
+                transform: scale(1);
+              }
+            }
+            h1 {
+              color: #1f2937;
+              margin-bottom: 0.5rem;
+              font-size: 1.5rem;
+            }
+            p {
+              color: #6b7280;
+              font-size: 1rem;
+            }
+            .progress {
+              margin-top: 1.5rem;
+              color: #9ca3af;
+              font-size: 0.875rem;
+            }
+          </style>
+        </head>
+        <body>
+          <div class="container">
+            <div class="checkmark">\u2713</div>
+            <h1>Authentication Successful!</h1>
+            <p>You can close this window and return to your terminal.</p>
+            <p class="progress">Closing automatically in 3 seconds...</p>
+            <script>
+              setTimeout(() => {
+                window.close();
+                // Fallback if window.close() doesn't work
+                document.body.innerHTML = '<div class="container"><h1>You can now close this window</h1></div>';
+              }, 3000);
+            </script>
+          </div>
+        </body>
+      </html>
+    `;
+  }
+  errorHTML(error) {
+    return `
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <title>Authentication Failed</title>
+          <style>
+            * {
+              margin: 0;
+              padding: 0;
+              box-sizing: border-box;
+            }
+            body {
+              font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+              display: flex;
+              align-items: center;
+              justify-content: center;
+              height: 100vh;
+              background: linear-gradient(135deg, #ef4444 0%, #dc2626 100%);
+            }
+            .container {
+              background: white;
+              padding: 3rem;
+              border-radius: 12px;
+              text-align: center;
+              box-shadow: 0 20px 40px rgba(0,0,0,0.1);
+              max-width: 400px;
+            }
+            .error-icon {
+              color: #ef4444;
+              font-size: 64px;
+              margin-bottom: 1rem;
+            }
+            h1 {
+              color: #1f2937;
+              margin-bottom: 0.5rem;
+              font-size: 1.5rem;
+            }
+            p {
+              color: #6b7280;
+              font-size: 1rem;
+              margin-bottom: 1rem;
+            }
+            .error-details {
+              background: #fef2f2;
+              color: #991b1b;
+              padding: 0.75rem;
+              border-radius: 6px;
+              font-size: 0.875rem;
+              font-family: monospace;
+            }
+          </style>
+        </head>
+        <body>
+          <div class="container">
+            <div class="error-icon">\u2715</div>
+            <h1>Authentication Failed</h1>
+            <p>There was an error during authentication.</p>
+            <div class="error-details">${error}</div>
+          </div>
+        </body>
+      </html>
+    `;
+  }
+};
+// src/auth/oauth-manager.ts
+var OAuthManager = class {
+  clerkPublishableKey;
+  dashboardUrl;
+  constructor(config3) {
+    this.clerkPublishableKey = config3.clerkPublishableKey;
+    this.dashboardUrl = config3.dashboardUrl;
+  }
+  async authenticate(mode) {
+    const state = import_crypto.default.randomBytes(32).toString("base64url");
+    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 authUrl = new URL(`${this.dashboardUrl.replace(/\/$/, "")}/${mode}`);
+    authUrl.searchParams.set("redirect_uri", redirectUri);
+    authUrl.searchParams.set("cli", "true");
+    authUrl.searchParams.set("state", state);
+    authUrl.searchParams.set("code_challenge", codeChallenge);
+    authUrl.searchParams.set("code_challenge_method", "S256");
+    authUrl.searchParams.set("publishable_key", this.clerkPublishableKey);
+    console.log("\u{1F310} Opening browser for authentication...");
+    console.log(`If the browser doesn't open, visit: ${authUrl}`);
+    try {
+      await (0, import_open.default)(authUrl.toString());
+    } catch (error) {
+      console.log("Failed to open browser automatically. Please visit the URL above.");
+    }
+    console.log("\u23F3 Waiting for authentication...");
+    const code = await codePromise;
+    return this.exchangeCodeForSession(code, codeVerifier, redirectUri);
+  }
+  async findAvailablePort() {
+    const defaultPort = 8765;
+    return defaultPort;
+  }
+  async exchangeCodeForSession(code, codeVerifier, redirectUri) {
+    void codeVerifier;
+    void redirectUri;
+    return code;
+  }
+};
+// src/config/env.ts
+function getApiUrl() {
+  return process.env.RUNTYPE_API_URL || "https://api.runtype.com";
+}
+function getApiVersion() {
+  return process.env.RUNTYPE_API_VERSION || "v1";
+}
+function getDashboardUrl() {
+  return process.env.RUNTYPE_DASHBOARD_URL || "https://dashboard.runtype.com";
+}
+function getClerkPublishableKey() {
+  return process.env.CLERK_PUBLISHABLE_KEY || "pk_live_default_key";
+}
+function getDefaultModel() {
+  return process.env.RUNTYPE_DEFAULT_MODEL || "meta/llama3.1-8b-instruct-free";
+}
+function getDefaultTemperature() {
+  const temp = process.env.RUNTYPE_DEFAULT_TEMPERATURE;
+  return temp ? parseFloat(temp) : 0.7;
+}
+// src/auth/api-key-manager.ts
+var isDashboardAuthResponse = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.apiKey === "string" && typeof record.userId === "string";
+};
+var isAuthMeResponse = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.user_id === "string";
+};
+var ApiKeyManager = class {
+  async exchangeSessionForApiKey(authCode, apiUrl) {
+    void apiUrl;
+    const dashboardUrl = process.env.RUNTYPE_DASHBOARD_URL || "http://localhost:3001";
+    const authResponse = await fetch(`${dashboardUrl}/api/cli/auth?code=${authCode}`, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    if (!authResponse.ok) {
+      const error = await authResponse.text();
+      throw new Error(`Authentication failed: ${error}`);
+    }
+    const authData = await authResponse.json();
+    if (!isDashboardAuthResponse(authData)) {
+      throw new Error("Invalid authentication response format");
+    }
+    const result = {
+      key: authData.apiKey,
+      userId: authData.userId
+    };
+    if (authData.orgId) {
+      result.orgId = authData.orgId;
+    }
+    return result;
+  }
+  async validateApiKey(apiKey, apiUrl) {
+    const baseUrl = apiUrl || getApiUrl();
+    try {
+      const response = await fetch(`${baseUrl}/${getApiVersion()}/auth/me`, {
+        headers: {
+          "Authorization": `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        }
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  async getCurrentUser(apiKey, apiUrl) {
+    const baseUrl = apiUrl || getApiUrl();
+    const response = await fetch(`${baseUrl}/auth/me`, {
+      headers: {
+        "Authorization": `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error("Failed to get user information");
+    }
+    const data = await response.json();
+    if (!isAuthMeResponse(data)) {
+      throw new Error("Invalid user response format");
+    }
+    return data;
+  }
+};
+// 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
+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();
+  try {
+    const oauth = new OAuthManager({
+      clerkPublishableKey: getClerkPublishableKey(),
+      dashboardUrl: options.dashboardUrl || getDashboardUrl()
+    });
+    spinner.text = "Waiting for browser authentication...";
+    const sessionToken = await oauth.authenticate("sign-up");
+    spinner.text = "Creating API key...";
+    const apiKeyManager = new ApiKeyManager();
+    const { key, userId, orgId } = await apiKeyManager.exchangeSessionForApiKey(
+      sessionToken,
+      options.apiUrl || getApiUrl()
+    );
+    spinner.text = "Storing credentials securely...";
+    const store = new CredentialStore();
+    await store.saveCredentials({
+      apiKey: key,
+      userId,
+      orgId,
+      apiUrl: options.apiUrl || getApiUrl()
+    });
+    spinner.succeed("Authentication successful!");
+    console.log(import_chalk.default.green("\n\u2728 Welcome to Runtype!"));
+    console.log(import_chalk.default.gray("Your API key has been saved securely."));
+    console.log(import_chalk.default.cyan("\nGet started with:"));
+    console.log("  runtype flows list");
+    console.log("  runtype records create --help");
+    console.log("  runtype talk");
+  } catch (error) {
+    spinner.fail("Authentication failed");
+    console.error(import_chalk.default.red(error.message));
+    process.exit(1);
+  }
+});
+authCommand.command("login").description("Login to existing account").option("--api-url <url>", "Custom API URL").option("--api-key <key>", "Use API key directly").action(async (options) => {
+  const store = new CredentialStore();
+  if (options.apiKey) {
+    const spinner2 = (0, import_ora.default)("Validating API key...").start();
+    try {
+      const apiKeyManager = new ApiKeyManager();
+      const isValid = await apiKeyManager.validateApiKey(
+        options.apiKey,
+        options.apiUrl
+      );
+      if (!isValid) {
+        spinner2.fail("Invalid API key");
+        process.exit(1);
+      }
+      const userData = await apiKeyManager.getCurrentUser(
+        options.apiKey,
+        options.apiUrl
+      );
+      await store.saveCredentials({
+        apiKey: options.apiKey,
+        userId: userData.user_id,
+        orgId: userData.org_id ?? void 0,
+        apiUrl: options.apiUrl || getApiUrl()
+      });
+      spinner2.succeed("Logged in successfully!");
+      console.log(import_chalk.default.green(`Welcome back! User ID: ${userData.user_id}`));
+    } catch (error) {
+      spinner2.fail("Login failed");
+      console.error(import_chalk.default.red(error.message));
+      process.exit(1);
+    }
+    return;
+  }
+  const spinner = (0, import_ora.default)("Initializing authentication...").start();
+  try {
+    const oauth = new OAuthManager({
+      clerkPublishableKey: getClerkPublishableKey(),
+      dashboardUrl: options.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,
+      options.apiUrl || getApiUrl()
+    );
+    spinner.text = "Storing credentials...";
+    await store.saveCredentials({
+      apiKey: key,
+      userId,
+      orgId,
+      apiUrl: options.apiUrl || getApiUrl()
+    });
+    spinner.succeed("Logged in successfully!");
+    console.log(import_chalk.default.green(`Welcome back! User ID: ${userId}`));
+  } catch (error) {
+    spinner.fail("Login failed");
+    console.error(import_chalk.default.red(error.message));
+    process.exit(1);
+  }
+});
+authCommand.command("status").description("Show authentication status").action(async () => {
+  const store = new CredentialStore();
+  try {
+    const hasCredentials = await store.hasCredentials();
+    if (!hasCredentials) {
+      console.log(import_chalk.default.yellow("Not authenticated"));
+      console.log("Run runtype auth signup or runtype auth login to get started");
+      return;
+    }
+    const credentials = await store.getCredentials();
+    if (credentials) {
+      console.log(import_chalk.default.green("\u2713 Authenticated"));
+      console.log(`User ID: ${credentials.userId}`);
+      console.log(`API URL: ${credentials.apiUrl || "default"}`);
+      console.log(`API Key: ${credentials.apiKey ? credentials.apiKey.substring(0, 12) + "..." : "missing"}`);
+      console.log(`Org ID: ${credentials.orgId || "none"}`);
+    }
+  } catch (error) {
+    console.error(import_chalk.default.red("Error checking auth status:"), error.message);
+  }
+});
+authCommand.command("logout").description("Remove stored credentials").action(async () => {
+  const store = new CredentialStore();
+  const hasCredentials = await store.hasCredentials();
+  if (!hasCredentials) {
+    console.log(import_chalk.default.yellow("No stored credentials found"));
+    return;
+  }
+  await store.clearCredentials();
+  console.log(import_chalk.default.green("\u2713 Logged out successfully"));
+});
+authCommand.command("whoami").description("Display current user information").action(async () => {
+  const store = new CredentialStore();
+  const credentials = await store.getCredentials();
+  if (!credentials || !credentials.apiKey) {
+    console.log(import_chalk.default.yellow("Not logged in"));
+    console.log("Run: runtype auth login");
+    return;
+  }
+  const spinner = (0, import_ora.default)("Fetching user information...").start();
+  try {
+    const apiKeyManager = new ApiKeyManager();
+    const user = await apiKeyManager.getCurrentUser(
+      credentials.apiKey,
+      credentials.apiUrl
+    );
+    spinner.stop();
+    console.log(import_chalk.default.cyan("Current User:"));
+    console.log(`  User ID: ${user.user_id}`);
+    console.log(`  Organization: ${user.org_id || "Personal"}`);
+    console.log(`  API Key: ${credentials.apiKey.substring(0, 10)}...`);
+    console.log(`  API URL: ${credentials.apiUrl || getApiUrl()}`);
+    console.log(`  Created: ${credentials.createdAt}`);
+    console.log(`  Last Used: ${credentials.lastUsed}`);
+  } catch (error) {
+    spinner.fail("Failed to get user information");
+    console.error(import_chalk.default.red(error.message));
+    console.log("\nYou may need to login again: runtype auth login");
+    process.exit(1);
+  }
+});
+// src/commands/flows.ts
+var import_commander2 = require("commander");
+var import_chalk2 = __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;
+  }
+  const record = value;
+  if (record.data !== void 0) {
+    if (!Array.isArray(record.data) || !record.data.every(isFlowSummary)) {
+      return false;
+    }
+  }
+  if (record.pagination !== void 0 && (typeof record.pagination !== "object" || record.pagination === null)) {
+    return false;
+  }
+  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);
+  }
+  const spinner = (0, import_ora2.default)("Fetching flows...").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"));
+      }
+    }
+  } 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);
+  }
+});
+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);
+  }
+  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;
+  }
+  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;
+  }
+  const record = value;
+  if (record.data !== void 0) {
+    if (!Array.isArray(record.data) || !record.data.every(isRecordSummary)) {
+      return false;
+    }
+  }
+  if (record.pagination !== void 0 && (typeof record.pagination !== "object" || record.pagination === null)) {
+    return false;
+  }
+  return true;
+};
+var isRecordCreateResponse = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  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);
+  }
+  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"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch records: ${response.statusText}`);
+    }
+    const data = await response.json();
+    spinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify(data, null, 2));
+    } 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))}`);
+          }
+        });
+        const total = data.pagination?.total_count ?? data.pagination?.total;
+        if (typeof total === "number") {
+          console.log(import_chalk3.default.dim(`
+  Total: ${total} records`));
+        }
+      } else {
+        console.log(import_chalk3.default.gray("  No records found"));
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to fetch records");
+    console.error(import_chalk3.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"));
+    process.exit(1);
+  }
+  const spinner = (0, import_ora3.default)("Creating record...").start();
+  try {
+    let metadata = {};
+    if (options.metadata) {
+      try {
+        metadata = JSON.parse(options.metadata);
+      } catch {
+        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
+      })
+    });
+    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 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));
+    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;
+  }
+  const record = value;
+  if (record.data !== void 0) {
+    if (!Array.isArray(record.data) || !record.data.every(isPromptSummary)) {
+      return false;
+    }
+  }
+  if (record.pagination !== void 0 && (typeof record.pagination !== "object" || record.pagination === null)) {
+    return false;
+  }
+  return true;
+};
+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();
+  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();
+    spinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify(data, null, 2));
+    } 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`));
+        }
+      } else {
+        console.log(import_chalk4.default.gray("  No prompts found"));
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail("Failed to fetch prompts");
+    console.error(import_chalk4.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"));
+    process.exit(1);
+  }
+  console.log(import_chalk4.default.cyan(`Testing prompt ${promptId}...`));
+  console.log(import_chalk4.default.gray("Implementation coming soon"));
+});
+// src/commands/batch.ts
+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 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"));
+    process.exit(1);
+  }
+  const spinner = (0, import_ora5.default)("Fetching batch status...").start();
+  try {
+    const response = await fetch(`${getApiUrl()}/${getApiVersion()}/batch/status/${batchId}`, {
+      headers: {
+        "Authorization": `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+    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.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)"));
+    }
+  } 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));
+    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();
+  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");
+  } 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));
+    process.exit(1);
+  }
+});
+// src/commands/talk.ts
+var import_commander6 = require("commander");
+var import_readline = __toESM(require("readline"));
+var import_chalk7 = __toESM(require("chalk"));
+// src/chat/session-manager.ts
+var import_uuid = require("uuid");
+var import_promises = __toESM(require("fs/promises"));
+var import_path2 = __toESM(require("path"));
+var import_os2 = __toESM(require("os"));
+var ChatSession = class {
+  sessionId;
+  messages = [];
+  modelConfig;
+  sessionDir;
+  constructor(modelConfig) {
+    this.sessionId = (0, import_uuid.v4)();
+    this.modelConfig = {
+      model: modelConfig?.model || "meta/llama3.1-8b-instruct-free",
+      temperature: modelConfig?.temperature ?? 0.7,
+      maxOutputTokens: modelConfig?.maxOutputTokens || 2e3,
+      systemPrompt: modelConfig?.systemPrompt
+    };
+    this.sessionDir = import_path2.default.join(import_os2.default.homedir(), ".runtype", "chat-sessions");
+  }
+  addMessage(role, content) {
+    this.messages.push({
+      role,
+      content,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  getMessages() {
+    return this.messages;
+  }
+  clearHistory() {
+    this.messages = [];
+    console.log("Chat history cleared");
+  }
+  setModel(model) {
+    this.modelConfig.model = model;
+    console.log(`Model changed to: ${model}`);
+  }
+  setTemperature(temperature) {
+    this.modelConfig.temperature = Math.max(0, Math.min(1, temperature));
+    console.log(`Temperature set to: ${this.modelConfig.temperature}`);
+  }
+  getConversationContext() {
+    return this.messages.map((m) => {
+      const role = m.role === "user" ? "User" : m.role === "assistant" ? "Assistant" : "System";
+      return `${role}: ${m.content}`;
+    }).join("\n\n");
+  }
+  buildDispatchPayload(userInput) {
+    this.addMessage("user", userInput);
+    const metadata = {};
+    return {
+      record: {
+        name: "Chat session",
+        type: "standalone",
+        metadata
+      },
+      flow: {
+        name: "Chat Flow",
+        description: "",
+        mode: "standalone",
+        steps: [
+          {
+            id: "1",
+            type: "prompt",
+            name: "Chat Response",
+            order: 1,
+            enabled: true,
+            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
+          }
+        ]
+      },
+      options: {
+        stream_response: true,
+        record_mode: "virtual",
+        flow_mode: "virtual"
+      }
+    };
+  }
+  buildPrompt(userInput) {
+    const systemContext = this.modelConfig.systemPrompt || `You are a helpful AI assistant. Provide clear, concise, and helpful responses to user questions. Use markdown formatting when appropriate.`;
+    if (this.messages.length > 1) {
+      const history = this.messages.slice(0, -1).slice(-10).map((m) => `${m.role}: ${m.content}`).join("\n");
+      return `${systemContext}
+Conversation history:
+${history}
+${userInput}`;
+    } else {
+      return `${systemContext}
+${userInput}`;
+    }
+  }
+  async saveToFile(filename) {
+    await import_promises.default.mkdir(this.sessionDir, { recursive: true });
+    const file = filename || `session-${Date.now()}.json`;
+    const filepath = import_path2.default.join(this.sessionDir, file);
+    const sessionData = {
+      sessionId: this.sessionId,
+      modelConfig: this.modelConfig,
+      messages: this.messages,
+      savedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await import_promises.default.writeFile(filepath, JSON.stringify(sessionData, null, 2));
+    return filepath;
+  }
+  async loadFromFile(filename) {
+    const filepath = import_path2.default.join(this.sessionDir, filename);
+    const data = await import_promises.default.readFile(filepath, "utf-8");
+    const sessionData = JSON.parse(data);
+    this.sessionId = sessionData.sessionId;
+    this.modelConfig = sessionData.modelConfig;
+    this.messages = sessionData.messages;
+  }
+  async exportAsMarkdown() {
+    await import_promises.default.mkdir(this.sessionDir, { recursive: true });
+    const filename = `export-${Date.now()}.md`;
+    const filepath = import_path2.default.join(this.sessionDir, filename);
+    let content = `# Runtype Chat Session
+`;
+    content += `**Session ID:** ${this.sessionId}
+`;
+    content += `**Model:** ${this.modelConfig.model}
+`;
+    content += `**Date:** ${(/* @__PURE__ */ new Date()).toISOString()}
+`;
+    content += `---
+`;
+    for (const message of this.messages) {
+      const role = message.role === "user" ? "**User**" : message.role === "assistant" ? "**Assistant**" : "**System**";
+      content += `${role} *(${new Date(message.timestamp).toLocaleString()})*
+`;
+      content += `${message.content}
+`;
+      content += `---
+`;
+    }
+    await import_promises.default.writeFile(filepath, content);
+    return filepath;
+  }
+  getSessionInfo() {
+    const firstMessage = this.messages[0];
+    const lastMessage = this.messages[this.messages.length - 1];
+    let duration = "N/A";
+    if (firstMessage && lastMessage) {
+      const start = new Date(firstMessage.timestamp);
+      const end = new Date(lastMessage.timestamp);
+      const diff = end.getTime() - start.getTime();
+      const minutes = Math.floor(diff / 6e4);
+      const seconds = Math.floor(diff % 6e4 / 1e3);
+      duration = `${minutes}m ${seconds}s`;
+    }
+    return {
+      id: this.sessionId,
+      messageCount: this.messages.length,
+      model: this.modelConfig.model,
+      temperature: this.modelConfig.temperature || 0.7,
+      duration
+    };
+  }
+};
+// src/chat/stream-handler.ts
+var import_chalk6 = __toESM(require("chalk"));
+var import_sdk = require("@runtypelabs/sdk");
+var StreamHandler = class {
+  buffer = "";
+  isStreaming = false;
+  enableMarkdown;
+  constructor(options = {}) {
+    this.enableMarkdown = options.enableMarkdown ?? true;
+  }
+  async handleStream(response) {
+    this.isStreaming = true;
+    this.buffer = "";
+    const callbacks = {
+      onStepChunk: (chunk) => {
+        this.appendOutput(chunk);
+      },
+      onError: (error) => {
+        console.error(import_chalk6.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);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      console.error(import_chalk6.default.red(`
+Stream error: ${message}`));
+      throw error;
+    } finally {
+      this.isStreaming = false;
+      this.flush();
+    }
+    return this.buffer;
+  }
+  flush() {
+    if (this.buffer && !this.buffer.endsWith("\n")) {
+      process.stdout.write("\n");
+    }
+  }
+  appendOutput(text) {
+    const output = this.enableMarkdown ? text : this.stripMarkdown(text);
+    this.buffer += output;
+    process.stdout.write(output);
+  }
+  stripMarkdown(text) {
+    return text.replace(/([*_`~]|\r)/g, "");
+  }
+  isCurrentlyStreaming() {
+    return this.isStreaming;
+  }
+  getBuffer() {
+    return this.buffer;
+  }
+  clearBuffer() {
+    this.buffer = "";
+  }
+};
+// src/commands/talk.ts
+var CHAT_COMMANDS = {
+  "/help": "Show available commands",
+  "/clear": "Clear conversation history",
+  "/save [filename]": "Save session to file",
+  "/load <filename>": "Load session from file",
+  "/export": "Export conversation as markdown",
+  "/model <model>": "Change AI model",
+  "/temp <value>": "Set temperature (0-1)",
+  "/info": "Show session information",
+  "/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 session = new ChatSession({
+    model: options.model,
+    temperature: parseFloat(options.temperature),
+    maxOutputTokens: parseInt(options.maxOutputTokens),
+    systemPrompt: options.system
+  });
+  if (options.continue) {
+    try {
+      await session.loadFromFile(options.continue);
+      console.log(import_chalk7.default.green(`Loaded session from: ${options.continue}`));
+    } catch (error) {
+      console.error(import_chalk7.default.red(`Failed to load session: ${error.message}`));
+      process.exit(1);
+    }
+  }
+  const apiUrl = getApiUrl();
+  const streamHandler = new StreamHandler({
+    enableMarkdown: options.markdown !== false
+  });
+  const rl = import_readline.default.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: import_chalk7.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'));
+  if (options.system) {
+    session.addMessage("system", options.system);
+  }
+  const handleCommand = async (input) => {
+    const parts = input.split(" ");
+    const command = parts[0];
+    const args = parts.slice(1).join(" ");
+    switch (command) {
+      case "/help":
+        console.log(import_chalk7.default.cyan("\nAvailable commands:"));
+        for (const [cmd, desc] of Object.entries(CHAT_COMMANDS)) {
+          console.log(`  ${import_chalk7.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"));
+        return true;
+      case "/save":
+        try {
+          const filepath = await session.saveToFile(args || void 0);
+          console.log(import_chalk7.default.green(`Session saved to: ${filepath}`));
+        } catch (error) {
+          console.error(import_chalk7.default.red(`Failed to save: ${error.message}`));
+        }
+        return true;
+      case "/load":
+        if (!args) {
+          console.log(import_chalk7.default.red("Please specify a filename"));
+          return true;
+        }
+        try {
+          await session.loadFromFile(args);
+          console.log(import_chalk7.default.green(`Session loaded from: ${args}`));
+        } catch (error) {
+          console.error(import_chalk7.default.red(`Failed to load: ${error.message}`));
+        }
+        return true;
+      case "/export":
+        try {
+          const filepath = await session.exportAsMarkdown();
+          console.log(import_chalk7.default.green(`Conversation exported to: ${filepath}`));
+        } catch (error) {
+          console.error(import_chalk7.default.red(`Failed to export: ${error.message}`));
+        }
+        return true;
+      case "/model":
+        if (!args) {
+          console.log(import_chalk7.default.yellow("Please specify a model"));
+          return true;
+        }
+        session.setModel(args);
+        return true;
+      case "/temp":
+        if (!args) {
+          console.log(import_chalk7.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"));
+          return true;
+        }
+        session.setTemperature(temp);
+        return true;
+      case "/info":
+        const info = session.getSessionInfo();
+        console.log(import_chalk7.default.cyan("\nSession Information:"));
+        console.log(`  Session ID: ${info.id}`);
+        console.log(`  Messages: ${info.messageCount}`);
+        console.log(`  Model: ${info.model}`);
+        console.log(`  Temperature: ${info.temperature}`);
+        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'));
+          return true;
+        }
+        return false;
+    }
+  };
+  rl.prompt();
+  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!"));
+      rl.close();
+      process.exit(0);
+    }
+    if (!trimmed) {
+      rl.prompt();
+      return;
+    }
+    if (trimmed.startsWith("/")) {
+      const shouldContinue = await handleCommand(trimmed);
+      if (!shouldContinue) {
+        console.log(import_chalk7.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..."));
+    try {
+      const payload = session.buildDispatchPayload(trimmed);
+      const response = await fetch(`${apiUrl}/dispatch`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${apiKey}`,
+          "Content-Type": "application/json",
+          "Accept": "text/event-stream"
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`API error: ${response.status} - ${error}`);
+      }
+      process.stdout.write("\x1B[1A\x1B[2K");
+      process.stdout.write(import_chalk7.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}`));
+      rl.prompt();
+    }
+  });
+  rl.on("SIGINT", () => {
+    console.log(import_chalk7.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'));
+    }
+    process.exit(0);
+  });
+  rl.on("error", (error) => {
+    console.error(import_chalk7.default.red(`Readline error: ${error.message}`));
+    process.exit(1);
+  });
+});
+// src/commands/config.ts
+var import_commander7 = require("commander");
+var import_chalk8 = __toESM(require("chalk"));
+var import_conf2 = __toESM(require("conf"));
+var import_path3 = __toESM(require("path"));
+var import_os3 = __toESM(require("os"));
+var CLI_CONFIG_KEYS = [
+  "apiUrl",
+  "defaultModel",
+  "defaultTemperature",
+  "outputFormat",
+  "streamResponses"
+];
+var isCliConfigKey = (value) => {
+  return CLI_CONFIG_KEYS.includes(value);
+};
+var configCommand = new import_commander7.Command("config").description("Manage CLI configuration");
+var config = new import_conf2.default({
+  projectName: "runtype-cli",
+  projectSuffix: "",
+  configName: "config",
+  cwd: import_path3.default.join(import_os3.default.homedir(), ".runtype")
+});
+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`));
+      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`));
+    }
+  } else {
+    const allConfig = config.store;
+    if (Object.keys(allConfig).length > 0) {
+      console.log(import_chalk8.default.cyan("Current Configuration:"));
+      for (const [k, v] of Object.entries(allConfig)) {
+        console.log(`  ${import_chalk8.default.green(k)}: ${v}`);
+      }
+    } else {
+      console.log(import_chalk8.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(", ")}`));
+    process.exit(1);
+  }
+  let parsedValue;
+  switch (key) {
+    case "defaultTemperature":
+      {
+        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"));
+          process.exit(1);
+        }
+        parsedValue = temperature;
+      }
+      break;
+    case "streamResponses":
+      parsedValue = value === "true";
+      break;
+    case "outputFormat":
+      if (!["table", "json", "plain"].includes(value)) {
+        console.log(import_chalk8.default.red("Output format must be: table, json, or plain"));
+        process.exit(1);
+      }
+      parsedValue = value;
+      break;
+    default:
+      parsedValue = value;
+      break;
+  }
+  config.set(key, parsedValue);
+  console.log(import_chalk8.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"));
+});
+configCommand.command("path").description("Show configuration file path").action(() => {
+  console.log(config.path);
+});
+// src/index.ts
+(0, import_dotenv.config)();
+var program = new import_commander8.Command();
+program.name(import_shared.BRAND.cliCommand).description(`CLI for ${import_shared.BRAND.name} 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.exitOverride();
+try {
+  program.parse(process.argv);
+} catch (error) {
+  if (error.code === "commander.missingArgument") {
+    console.error(import_chalk9.default.red(`Error: ${error.message}`));
+    process.exit(1);
+  } else if (error.code === "commander.unknownOption") {
+    console.error(import_chalk9.default.red(`Error: ${error.message}`));
+    process.exit(1);
+  } else if (error.code === "commander.help") {
+    process.exit(0);
+  } else {
+    console.error(import_chalk9.default.red("An unexpected error occurred:"));
+    console.error(error);
+    process.exit(1);
+  }
+}
+if (!process.argv.slice(2).length) {
+  try {
+    program.outputHelp();
+  } catch (error) {
+    if (error.code === "commander.help") {
+      process.exit(0);
+    } else {
+      throw error;
+    }
+  }
+}
+//# sourceMappingURL=index.js.map