@runtypelabs/cli 2.5.0 → 2.6.1

package/dist/index.js

@@ -15376,8 +15376,8 @@ var require_provider_routing = __commonJS({
 });
 
 // src/index.ts
-import { Command as Command20 } from "commander";
-import chalk27 from "chalk";
+import { Command as Command21 } from "commander";
+import chalk28 from "chalk";
 import { config as loadEnv } from "dotenv";
 
 // src/commands/auth.ts
@@ -31682,14 +31682,542 @@ clientTokensCommand.command("regenerate <id>").description("Regenerate a client
   await waitUntilExit();
 });
 
-// src/commands/analytics.ts
+// src/commands/persona.ts
 import { Command as Command17 } from "commander";
 import chalk23 from "chalk";
+import readline3 from "readline";
+import open5 from "open";
+import { execFileSync } from "child_process";
+
+// src/lib/persona-init.ts
+init_credential_store();
+
+// src/lib/persona-snippets.ts
+function mapCliFormatToPersona(cli) {
+  switch (cli) {
+    case "script-installer":
+      return "script-installer";
+    case "script-manual":
+      return "script-advanced";
+    case "esm":
+    case "react":
+      return "react-component";
+    default: {
+      const _exhaustive = cli;
+      return _exhaustive;
+    }
+  }
+}
+function parsePersonaInitFormat(raw) {
+  const normalized = raw.trim().toLowerCase();
+  if (normalized === "script-installer" || normalized === "script-manual" || normalized === "esm" || normalized === "react") {
+    return normalized;
+  }
+  throw new Error(
+    `Invalid --format "${raw}". Use: script-installer | script-manual | esm | react`
+  );
+}
+var PERSONA_CDN_BASE = "https://cdn.jsdelivr.net/npm/@runtypelabs/persona@latest/dist";
+function mountIdFromSelector(sel) {
+  const s = sel.trim();
+  if (s.startsWith("#")) return s.slice(1);
+  return s || "chat";
+}
+function escapeHtmlAttr(s) {
+  return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;");
+}
+function buildScriptInstaller(input) {
+  const targetSel = input.targetSelector?.trim() || void 0;
+  if (!targetSel) {
+    return `<script
+  src="${PERSONA_CDN_BASE}/install.global.js"
+  data-runtype-token="${escapeHtmlAttr(input.clientToken)}"
+></script>`.trim();
+  }
+  const id = mountIdFromSelector(targetSel);
+  const cfg = JSON.stringify({ target: targetSel, apiUrl: input.apiUrl });
+  return `<div id="${escapeHtmlAttr(id)}"></div>
+<script
+  src="${PERSONA_CDN_BASE}/install.global.js"
+  data-runtype-token="${escapeHtmlAttr(input.clientToken)}"
+  data-config='${cfg.replace(/'/g, "&#39;")}'
+></script>`.trim();
+}
+function buildScriptAdvancedHtml(input) {
+  const targetSel = input.targetSelector?.trim() || void 0;
+  const apiUrl = JSON.stringify(input.apiUrl);
+  const token = JSON.stringify(input.clientToken);
+  const targetJson = JSON.stringify(targetSel || "body");
+  const divLine = targetSel ? `<div id="${escapeHtmlAttr(mountIdFromSelector(targetSel))}"></div>
+` : "";
+  return `<link rel="stylesheet" href="${PERSONA_CDN_BASE}/widget.css" />
+${divLine}<script type="module">
+import { initAgentWidget, markdownPostprocessor } from '${PERSONA_CDN_BASE}/index.js';
+
+initAgentWidget({
+  target: ${targetJson},
+  config: {
+    apiUrl: ${apiUrl},
+    clientToken: ${token},
+    parserType: 'json',
+    postprocessMessage: ({ text }) => markdownPostprocessor(text),
+    launcher: {
+      enabled: true,
+      title: 'Chat',
+      subtitle: 'How can I help you today?',
+      position: 'bottom-right',
+    },
+  },
+});
+</script>`.trim();
+}
+function buildReactComponentSnippet(input) {
+  const targetSel = input.targetSelector?.trim() || void 0;
+  const apiUrl = JSON.stringify(input.apiUrl);
+  const token = JSON.stringify(input.clientToken);
+  const targetStr = JSON.stringify(targetSel || "body");
+  return `import "@runtypelabs/persona/widget.css";
+import { DEFAULT_WIDGET_CONFIG, initAgentWidget, markdownPostprocessor } from "@runtypelabs/persona";
+
+initAgentWidget({
+  target: ${targetStr},
+  config: {
+    ...DEFAULT_WIDGET_CONFIG,
+    apiUrl: ${apiUrl},
+    clientToken: ${token},
+    parserType: "json",
+    postprocessMessage: ({ text }) => markdownPostprocessor(text),
+  },
+});`.trim();
+}
+function generatePersonaInitSnippet(input, personaFormat) {
+  switch (personaFormat) {
+    case "script-installer":
+      return buildScriptInstaller(input);
+    case "script-advanced":
+      return buildScriptAdvancedHtml(input);
+    case "react-component":
+      return buildReactComponentSnippet(input);
+    default: {
+      const _exhaustive = personaFormat;
+      return _exhaustive;
+    }
+  }
+}
+
+// src/lib/persona-init.ts
+async function getPersonaInitApiKeyNonInteractive(apiUrl) {
+  const envApiKey = getRuntimeApiKey();
+  if (envApiKey) {
+    try {
+      const apiKeyManager = new ApiKeyManager();
+      const isValid = await apiKeyManager.validateApiKey(envApiKey, apiUrl);
+      if (isValid) {
+        return envApiKey;
+      }
+    } catch {
+    }
+  }
+  const store = new CredentialStore();
+  return store.getApiKey();
+}
+async function runPersonaInit(options) {
+  const client = new ApiClient(options.apiKey, options.apiUrl);
+  const agent = await client.post("/agents", {
+    name: options.agentName,
+    description: options.agentDescription || "A Persona test agent",
+    config: {
+      model: "qwen3.5-35b-a3b",
+      systemPrompt: "You are a helpful assistant."
+    }
+  });
+  const tokenBody = {
+    name: options.tokenName,
+    flowIds: [],
+    agentIds: [agent.id],
+    allowedOrigins: options.allowedOrigins,
+    environment: options.environment,
+    rateLimitPerMinute: 10,
+    rateLimitPerHour: 100,
+    maxMessagesPerSession: 100,
+    sessionIdleTimeoutMinutes: 30
+  };
+  const tokenRes = await client.post("/client-tokens", tokenBody);
+  const personaFormat = mapCliFormatToPersona(options.format);
+  const code = generatePersonaInitSnippet(
+    {
+      clientToken: tokenRes.token,
+      apiUrl: options.apiUrl,
+      targetSelector: options.targetSelector
+    },
+    personaFormat
+  );
+  const dashboardBase = getDashboardUrl();
+  const dashboardUrl = `${dashboardBase}/agents/${agent.id}`;
+  return {
+    status: "created",
+    agent: { id: agent.id, name: agent.name },
+    clientToken: {
+      id: tokenRes.clientToken.id,
+      name: tokenRes.clientToken.name,
+      token: tokenRes.token,
+      environment: options.environment
+    },
+    snippet: { format: options.format, code },
+    dashboardUrl,
+    warnings: tokenRes.warnings
+  };
+}
+
+// src/commands/persona.ts
+var FORMAT_CYCLE = [
+  "script-installer",
+  "react",
+  "script-manual",
+  "esm"
+];
+function defaultTokenName(agentName) {
+  return `${agentName} Widget`;
+}
+async function promptLine(rl, question, defaultValue) {
+  const hint = defaultValue ? chalk23.dim(` (${defaultValue})`) : "";
+  const answer = await new Promise((resolve8) => {
+    rl.question(`${question}${hint}: `, resolve8);
+  });
+  const trimmed = answer.trim();
+  if (!trimmed && defaultValue !== void 0) {
+    return defaultValue;
+  }
+  return trimmed;
+}
+async function promptConfirm2(rl, message, defaultYes = false) {
+  const hint = defaultYes ? chalk23.dim(" (Y/n)") : chalk23.dim(" (y/N)");
+  const answer = await new Promise((resolve8) => {
+    rl.question(`${message}${hint}: `, resolve8);
+  });
+  const t = answer.trim().toLowerCase();
+  if (t === "") return defaultYes;
+  return t === "y" || t === "yes";
+}
+function copyToClipboard2(text) {
+  if (process.platform === "darwin") {
+    execFileSync("pbcopy", [], { input: text });
+    return;
+  }
+  if (process.platform === "win32") {
+    execFileSync("clip", [], { shell: true, input: text });
+    return;
+  }
+  try {
+    execFileSync("xclip", ["-selection", "clipboard"], { input: text });
+  } catch {
+    execFileSync("wl-copy", [], { input: text });
+  }
+}
+function isProbablyLocalDev(origins) {
+  return origins.some(
+    (o) => o === "http://localhost:*" || o.startsWith("http://localhost:") || o.startsWith("http://127.0.0.1:")
+  );
+}
+function snippetWithFormat(format, token, apiUrl, targetSelector) {
+  const personaFmt = mapCliFormatToPersona(format);
+  const code = generatePersonaInitSnippet(
+    { clientToken: token, apiUrl, targetSelector },
+    personaFmt
+  );
+  return { format, code };
+}
+async function runSuccessKeyLoop(initial, apiUrl, targetSelector) {
+  if (!process.stdin.isTTY) {
+    return;
+  }
+  let currentFormat = initial.snippet.format;
+  let currentCode = initial.snippet.code;
+  const token = initial.clientToken.token;
+  console.log(chalk23.cyan("\nPersona setup complete\n"));
+  console.log(`${chalk23.bold("Agent ID:")} ${initial.agent.id}`);
+  console.log(`${chalk23.bold("Client Token ID:")} ${initial.clientToken.id}`);
+  console.log(`${chalk23.bold("Client Token:")} ${chalk23.yellow(token)}`);
+  console.log(`${chalk23.bold("Snippet format:")} ${currentFormat}`);
+  console.log(chalk23.dim(`
+Dashboard: ${initial.dashboardUrl}`));
+  if (initial.warnings?.length) {
+    for (const w of initial.warnings) {
+      console.log(chalk23.yellow(`\u26A0 ${w.message}`));
+    }
+  }
+  console.log(chalk23.cyan("\nKeys:"));
+  console.log(`  ${chalk23.green("c")}  Copy snippet to clipboard`);
+  console.log(`  ${chalk23.green("p")}  Print snippet to the terminal`);
+  console.log(`  ${chalk23.green("f")}  Switch snippet format`);
+  console.log(`  ${chalk23.green("o")}  Open dashboard in browser`);
+  console.log(`  ${chalk23.green("q")}  Quit`);
+  readline3.emitKeypressEvents(process.stdin);
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  process.stdin.resume();
+  const cleanup = () => {
+    process.stdin.setRawMode(false);
+    process.stdin.removeAllListeners("keypress");
+    process.stdin.pause();
+  };
+  await new Promise((resolve8) => {
+    const onKeypress = async (_str, key) => {
+      if (!key) return;
+      if (key.ctrl && key.name === "c") {
+        cleanup();
+        resolve8();
+        process.exit(0);
+      }
+      const name = key.name;
+      if (name === "q" || name === "escape") {
+        cleanup();
+        resolve8();
+        return;
+      }
+      if (name === "c") {
+        try {
+          copyToClipboard2(currentCode);
+          console.log(chalk23.green("Snippet copied to clipboard."));
+        } catch {
+          console.log(chalk23.red("Could not copy (install xclip/wl-copy on Linux, or use p)."));
+        }
+        return;
+      }
+      if (name === "p") {
+        console.log(chalk23.cyan("\n--- snippet ---\n"));
+        console.log(currentCode);
+        console.log(chalk23.cyan("\n--- end snippet ---\n"));
+        return;
+      }
+      if (name === "f") {
+        const idx = FORMAT_CYCLE.indexOf(currentFormat);
+        const next = FORMAT_CYCLE[(idx + 1) % FORMAT_CYCLE.length] ?? "script-installer";
+        const nextSnippet = snippetWithFormat(next, token, apiUrl, targetSelector);
+        currentFormat = nextSnippet.format;
+        currentCode = nextSnippet.code;
+        console.log(chalk23.dim(`Format: ${currentFormat}`));
+        return;
+      }
+      if (name === "o") {
+        try {
+          await open5(initial.dashboardUrl);
+        } catch {
+          console.log(chalk23.red("Could not open browser."));
+        }
+      }
+    };
+    process.stdin.on("keypress", onKeypress);
+  });
+}
+var personaCommand = new Command17("persona").description(
+  "Set up Persona: create an agent, client token, and embed snippet"
+);
+personaCommand.command("init").description("Create agent + client token and output a Persona embed snippet").option("--agent-name <name>", "Name for the new agent").option("--agent-description <text", "Optional agent description").option("--token-name <name>", "Name for the new client token").option("--environment <env>", "Token environment: test or live", "test").option("--origins <origins...>", "Allowed origins (default: * \u2014 broad; prefer explicit URLs in production)").option(
+  "--format <fmt>",
+  "Snippet format: script-installer | script-manual | esm | react",
+  "script-installer"
+).option("--print-snippet", "Print the generated snippet to stdout (non-interactive summary mode)").option("--target-selector <selector>", "CSS selector for widget mount target (omit to use body)").option("--api-url <url>", "Override API base URL").option("--json", "Structured JSON output (includes snippet body)").option("--yes", "Accept defaults in interactive prompts where sensible").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(
+  async (options, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    const jsonMode = !!(options.json ?? globals.json);
+    const tty = isTTY(options);
+    let formatCli;
+    try {
+      formatCli = parsePersonaInitFormat(options.format);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      if (jsonMode) {
+        console.log(JSON.stringify({ status: "error", error: msg, code: "INVALID_FORMAT" }, null, 2));
+      } else {
+        console.error(chalk23.red(msg));
+      }
+      process.exit(1);
+    }
+    const apiUrl = options.apiUrl || globals.apiUrl || getApiUrl();
+    const targetSelector = options.targetSelector || void 0;
+    let env;
+    if (options.environment === "test" || options.environment === "live") {
+      env = options.environment;
+    } else {
+      const msg = 'Error: --environment must be "test" or "live"';
+      if (jsonMode) {
+        console.log(JSON.stringify({ status: "error", error: msg, code: "INVALID_ENV" }, null, 2));
+      } else {
+        console.error(chalk23.red(msg));
+      }
+      process.exit(1);
+    }
+    const interactive = tty && !jsonMode;
+    let agentName = options.agentName?.trim();
+    let tokenName = options.tokenName?.trim();
+    let allowedOrigins = options.origins;
+    let chosenEnv = env;
+    const rl = interactive && process.stdin.isTTY && process.stdout.isTTY ? readline3.createInterface({ input: process.stdin, output: process.stdout }) : null;
+    if (!interactive) {
+      if (!agentName) {
+        const msg = "Non-interactive mode requires --agent-name";
+        if (jsonMode) {
+          console.log(JSON.stringify({ status: "error", error: msg, code: "MISSING_AGENT_NAME" }, null, 2));
+        } else {
+          console.error(chalk23.red(msg));
+        }
+        process.exit(1);
+      }
+      if (!tokenName) {
+        tokenName = defaultTokenName(agentName);
+      }
+      if (!allowedOrigins || allowedOrigins.length === 0) {
+        allowedOrigins = ["*"];
+      }
+    } else {
+      if (!agentName) {
+        agentName = await promptLine(rl, "Agent name", "Persona Test");
+        if (!agentName) {
+          console.error(chalk23.red("Agent name is required"));
+          process.exit(1);
+        }
+      }
+      if (!tokenName) {
+        const def = options.yes ? defaultTokenName(agentName) : defaultTokenName(agentName);
+        tokenName = await promptLine(rl, "Client token name", def);
+        if (!tokenName) {
+          tokenName = def;
+        }
+      }
+      if (!allowedOrigins?.length) {
+        if (options.yes) {
+          allowedOrigins = ["*"];
+        } else {
+          const originsInput = await promptLine(
+            rl,
+            "Allowed origins (space-separated URLs, or * for any)",
+            "*"
+          );
+          allowedOrigins = originsInput === "*" ? ["*"] : originsInput.split(/\s+/).filter(Boolean);
+        }
+      }
+      if (chosenEnv === "live") {
+        const ok = await promptConfirm2(rl, chalk23.yellow("Create a LIVE token? This is shown only once."), false);
+        if (!ok) {
+          console.log(chalk23.gray("Aborted."));
+          rl.close();
+          process.exit(0);
+        }
+      } else if (!options.yes) {
+        const envAns = await promptLine(rl, "Environment (test/live)", "test");
+        if (envAns === "live") {
+          const ok = await promptConfirm2(rl, chalk23.yellow("Create a LIVE token?"), false);
+          if (!ok) {
+            chosenEnv = "test";
+          } else {
+            chosenEnv = "live";
+          }
+        }
+      }
+    }
+    if (rl) {
+      rl.close();
+    }
+    if (allowedOrigins.includes("*") && chosenEnv === "live" && !isProbablyLocalDev(allowedOrigins)) {
+      console.log(
+        chalk23.yellow(
+          'Warning: allowedOrigins is "*" for a live token. Prefer explicit https:// origins in production.'
+        )
+      );
+    }
+    let apiKey;
+    if (jsonMode || !tty) {
+      apiKey = await getPersonaInitApiKeyNonInteractive(apiUrl);
+      if (!apiKey) {
+        if (jsonMode) {
+          console.log(
+            JSON.stringify(
+              {
+                status: "unauthenticated",
+                message: "Set RUNTYPE_API_KEY or run `runtype auth login` (uses saved credentials)"
+              },
+              null,
+              2
+            )
+          );
+        } else {
+          console.error(
+            chalk23.red(
+              "Authentication required: set RUNTYPE_API_KEY or run `runtype auth login` for stored credentials"
+            )
+          );
+        }
+        process.exit(1);
+      }
+    } else {
+      apiKey = await ensureAuth({ apiUrl });
+      if (!apiKey) {
+        process.exit(1);
+      }
+    }
+    let success;
+    try {
+      success = await runPersonaInit({
+        apiKey,
+        apiUrl,
+        agentName,
+        agentDescription: options.agentDescription,
+        tokenName,
+        environment: chosenEnv,
+        allowedOrigins,
+        format: formatCli,
+        targetSelector
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (jsonMode) {
+        console.log(JSON.stringify({ status: "error", error: message, code: "API_ERROR" }, null, 2));
+      } else {
+        console.error(chalk23.red("Persona init failed"));
+        console.error(chalk23.red(message));
+      }
+      process.exit(1);
+    }
+    if (jsonMode) {
+      printJson(success);
+      return;
+    }
+    if (!tty || options.printSnippet) {
+      console.log(chalk23.green("\nPersona setup complete\n"));
+      console.log(`${chalk23.bold("Agent ID:")} ${success.agent.id}`);
+      console.log(`${chalk23.bold("Client Token ID:")} ${success.clientToken.id}`);
+      console.log(`${chalk23.bold("Client Token:")} ${chalk23.yellow(success.clientToken.token)}`);
+      console.log(`${chalk23.bold("Format:")} ${success.snippet.format}`);
+      console.log(chalk23.dim(`
+Dashboard: ${success.dashboardUrl}`));
+      if (success.warnings?.length) {
+        for (const w of success.warnings) {
+          console.log(chalk23.yellow(`\u26A0 ${w.message}`));
+        }
+      }
+      console.log(chalk23.cyan("\nRecommended next step: npm install @runtypelabs/persona"));
+      if (options.printSnippet) {
+        console.log(chalk23.cyan("\n--- snippet ---\n"));
+        console.log(success.snippet.code);
+      } else {
+        console.log(chalk23.dim("\nUse --print-snippet to print the embed code, or run interactively for copy shortcuts."));
+      }
+      return;
+    }
+    await runSuccessKeyLoop(success, apiUrl, targetSelector);
+  }
+);
+
+// src/commands/analytics.ts
+import { Command as Command18 } from "commander";
+import chalk24 from "chalk";
 import React16 from "react";
 import { render as render16 } from "ink";
 import { useState as useState30, useEffect as useEffect27 } from "react";
 import { Text as Text33 } from "ink";
-var analyticsCommand = new Command17("analytics").description("View analytics and execution results");
+var analyticsCommand = new Command18("analytics").description("View analytics and execution results");
 analyticsCommand.command("stats").description("Show account statistics").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (options) => {
   const apiKey = await ensureAuth();
   if (!apiKey) return;
@@ -31709,8 +32237,8 @@ analyticsCommand.command("stats").description("Show account statistics").option(
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
-      console.error(chalk23.red("Failed to fetch stats"));
-      console.error(chalk23.red(message));
+      console.error(chalk24.red("Failed to fetch stats"));
+      console.error(chalk24.red(message));
       process.exit(1);
     }
     return;
@@ -31774,27 +32302,27 @@ analyticsCommand.command("results").description("List execution results").option
         } else {
           const results = data.data ?? [];
           if (results.length === 0) {
-            console.log(chalk23.gray("No results found"));
+            console.log(chalk24.gray("No results found"));
             return;
           }
-          console.log(chalk23.cyan("Execution Results:"));
+          console.log(chalk24.cyan("Execution Results:"));
           for (const result of results) {
             const statusColor = result.status === "completed" ? "green" : "red";
-            const date = result.createdAt ? chalk23.gray(` ${result.createdAt}`) : "";
+            const date = result.createdAt ? chalk24.gray(` ${result.createdAt}`) : "";
             console.log(
-              `  ${chalk23.green(result.id)} ${chalk23[statusColor](`[${result.status}]`)} flow=${chalk23.gray(result.flowId)} record=${chalk23.gray(result.recordId)}${date}`
+              `  ${chalk24.green(result.id)} ${chalk24[statusColor](`[${result.status}]`)} flow=${chalk24.gray(result.flowId)} record=${chalk24.gray(result.recordId)}${date}`
             );
           }
           const total = getTotalCount(data.pagination);
           if (total !== void 0) {
-            console.log(chalk23.dim(`
+            console.log(chalk24.dim(`
   Total: ${total} results`));
           }
         }
       } catch (error) {
         const message = error instanceof Error ? error.message : "Unknown error";
-        console.error(chalk23.red("Failed to fetch results"));
-        console.error(chalk23.red(message));
+        console.error(chalk24.red("Failed to fetch results"));
+        console.error(chalk24.red(message));
         process.exit(1);
       }
       return;
@@ -31845,13 +32373,13 @@ analyticsCommand.command("results").description("List execution results").option
 );
 
 // src/commands/billing.ts
-import { Command as Command18 } from "commander";
-import chalk24 from "chalk";
+import { Command as Command19 } from "commander";
+import chalk25 from "chalk";
 import React17 from "react";
 import { render as render17 } from "ink";
 import { useState as useState31, useEffect as useEffect28 } from "react";
-import open5 from "open";
-var billingCommand = new Command18("billing").description("View billing and subscription info");
+import open6 from "open";
+var billingCommand = new Command19("billing").description("View billing and subscription info");
 billingCommand.command("status").description("Show current plan and usage").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (options) => {
   const apiKey = await ensureAuth();
   if (!apiKey) return;
@@ -31888,8 +32416,8 @@ billingCommand.command("status").description("Show current plan and usage").opti
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
-      console.error(chalk24.red("Failed to fetch billing status"));
-      console.error(chalk24.red(message));
+      console.error(chalk25.red("Failed to fetch billing status"));
+      console.error(chalk25.red(message));
       process.exit(1);
     }
     return;
@@ -31953,14 +32481,14 @@ billingCommand.command("portal").description("Open the billing portal in your br
       if (data.url) {
         console.log("Opening billing portal...");
         console.log(data.url);
-        await open5(data.url);
+        await open6(data.url);
       } else {
         console.log("No portal URL returned. You may need to set up billing first.");
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
-      console.error(chalk24.red("Failed to open billing portal"));
-      console.error(chalk24.red(message));
+      console.error(chalk25.red("Failed to open billing portal"));
+      console.error(chalk25.red(message));
       process.exit(1);
     }
     return;
@@ -31975,7 +32503,7 @@ billingCommand.command("portal").description("Open the billing portal in your br
         try {
           const data = await client.post("/billing/portal");
           if (data.url) {
-            await open5(data.url);
+            await open6(data.url);
             setMsg("Billing portal opened in browser");
             setSuccess(true);
           } else {
@@ -32009,11 +32537,11 @@ billingCommand.command("refresh").description("Refresh plan data from billing pr
   if (!isTTY(options)) {
     try {
       await client.post("/billing/refresh");
-      console.log(chalk24.green("Plan data refreshed"));
+      console.log(chalk25.green("Plan data refreshed"));
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
-      console.error(chalk24.red("Failed to refresh plan data"));
-      console.error(chalk24.red(message));
+      console.error(chalk25.red("Failed to refresh plan data"));
+      console.error(chalk25.red(message));
       process.exit(1);
     }
     return;
@@ -32049,13 +32577,13 @@ billingCommand.command("refresh").description("Refresh plan data from billing pr
 });
 
 // src/commands/flow-versions.ts
-import { Command as Command19 } from "commander";
-import chalk25 from "chalk";
+import { Command as Command20 } from "commander";
+import chalk26 from "chalk";
 import React18 from "react";
 import { render as render18 } from "ink";
 import { useState as useState32, useEffect as useEffect29 } from "react";
 import { Text as Text34 } from "ink";
-var flowVersionsCommand = new Command19("flow-versions").description(
+var flowVersionsCommand = new Command20("flow-versions").description(
   "Manage flow versions"
 );
 flowVersionsCommand.command("list <flowId>").description("List all versions for a flow").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (flowId, options) => {
@@ -32070,21 +32598,21 @@ flowVersionsCommand.command("list <flowId>").description("List all versions for
       } else {
         const versions = data.data ?? [];
         if (versions.length === 0) {
-          console.log(chalk25.gray("No versions found"));
+          console.log(chalk26.gray("No versions found"));
           return;
         }
-        console.log(chalk25.cyan(`Versions for flow ${flowId}:`));
+        console.log(chalk26.cyan(`Versions for flow ${flowId}:`));
         for (const v of versions) {
-          const publishedTag = v.published ? chalk25.green(" [published]") : "";
+          const publishedTag = v.published ? chalk26.green(" [published]") : "";
           const versionNum = v.version !== void 0 ? `v${v.version}` : v.id;
-          const date = v.createdAt ? chalk25.gray(` ${v.createdAt}`) : "";
-          console.log(`  ${chalk25.green(v.id)} ${versionNum}${publishedTag}${date}`);
+          const date = v.createdAt ? chalk26.gray(` ${v.createdAt}`) : "";
+          console.log(`  ${chalk26.green(v.id)} ${versionNum}${publishedTag}${date}`);
         }
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
-      console.error(chalk25.red("Failed to fetch versions"));
-      console.error(chalk25.red(message));
+      console.error(chalk26.red("Failed to fetch versions"));
+      console.error(chalk26.red(message));
       process.exit(1);
     }
     return;
@@ -32144,8 +32672,8 @@ flowVersionsCommand.command("get <flowId> <versionId>").description("Get a speci
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
-      console.error(chalk25.red("Failed to fetch version"));
-      console.error(chalk25.red(message));
+      console.error(chalk26.red("Failed to fetch version"));
+      console.error(chalk26.red(message));
       process.exit(1);
     }
     return;
@@ -32210,8 +32738,8 @@ flowVersionsCommand.command("published <flowId>").description("Get the published
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
-      console.error(chalk25.red("Failed to fetch published version"));
-      console.error(chalk25.red(message));
+      console.error(chalk26.red("Failed to fetch published version"));
+      console.error(chalk26.red(message));
       process.exit(1);
     }
     return;
@@ -32264,11 +32792,11 @@ flowVersionsCommand.command("publish <flowId>").description("Publish a version")
       await client.post(`/flow-versions/${flowId}/publish`, {
         versionId: options.version
       });
-      console.log(chalk25.green("Version published"));
+      console.log(chalk26.green("Version published"));
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
-      console.error(chalk25.red("Failed to publish version"));
-      console.error(chalk25.red(message));
+      console.error(chalk26.red("Failed to publish version"));
+      console.error(chalk26.red(message));
       process.exit(1);
     }
     return;
@@ -32309,7 +32837,7 @@ flowVersionsCommand.command("publish <flowId>").description("Publish a version")
 init_credential_store();
 
 // src/lib/update-check.ts
-import chalk26 from "chalk";
+import chalk27 from "chalk";
 import Conf3 from "conf";
 var UPDATE_CHECK_INTERVAL_MS = 12 * 60 * 60 * 1e3;
 var UPDATE_NOTIFY_INTERVAL_MS = 24 * 60 * 60 * 1e3;
@@ -32403,7 +32931,7 @@ function notifyFromCachedCliUpdate(args, options = {}) {
     console.error(message);
   });
   notify(
-    `${chalk26.yellow("Update available:")} ${chalk26.red(currentVersion)} ${chalk26.gray("->")} ${chalk26.green(latestVersion)}  ${chalk26.gray(`(${getUpgradeCommand()})`)}`
+    `${chalk27.yellow("Update available:")} ${chalk27.red(currentVersion)} ${chalk27.gray("->")} ${chalk27.green(latestVersion)}  ${chalk27.gray(`(${getUpgradeCommand()})`)}`
   );
   store.set("lastNotifiedAt", now.toISOString());
   store.set("lastNotifiedVersion", latestVersion);
@@ -32445,7 +32973,7 @@ function maybeNotifyAboutCliUpdate(args, options = {}) {
 // src/index.ts
 loadEnv();
 setCliTitle();
-var program = new Command20();
+var program = new Command21();
 program.name("runtype").description("CLI for Runtype AI Platform").version(getCliVersion()).option("-v, --verbose", "Enable verbose output").option("--api-url <url>", "Override API URL").option("--json", "Output in JSON format");
 program.addCommand(initCommand);
 program.addCommand(loginCommand);
@@ -32463,6 +32991,7 @@ program.addCommand(schedulesCommand);
 program.addCommand(evalCommand);
 program.addCommand(apiKeysCommand);
 program.addCommand(clientTokensCommand);
+program.addCommand(personaCommand);
 program.addCommand(analyticsCommand);
 program.addCommand(billingCommand);
 program.addCommand(flowVersionsCommand);
@@ -32480,15 +33009,15 @@ try {
 } catch (error) {
   const commanderError = error;
   if (commanderError.code === "commander.missingArgument") {
-    console.error(chalk27.red(`Error: ${commanderError.message}`));
+    console.error(chalk28.red(`Error: ${commanderError.message}`));
     process.exit(1);
   } else if (commanderError.code === "commander.unknownOption") {
-    console.error(chalk27.red(`Error: ${commanderError.message}`));
+    console.error(chalk28.red(`Error: ${commanderError.message}`));
     process.exit(1);
   } else if (commanderError.code === "commander.help" || commanderError.code === "commander.version") {
     process.exit(0);
   } else {
-    console.error(chalk27.red("An unexpected error occurred:"));
+    console.error(chalk28.red("An unexpected error occurred:"));
     console.error(error);
     process.exit(1);
   }
@@ -32497,12 +33026,12 @@ async function handleNoCommand() {
   const store = new CredentialStore();
   const hasCredentials = await store.hasCredentials();
   if (!hasCredentials) {
-    console.log(chalk27.cyan("\nWelcome to Runtype CLI!\n"));
+    console.log(chalk28.cyan("\nWelcome to Runtype CLI!\n"));
     console.log("It looks like this is your first time. Run the setup wizard:");
-    console.log(`  ${chalk27.green("runtype init")}
+    console.log(`  ${chalk28.green("runtype init")}
 `);
     console.log("Or see all available commands:");
-    console.log(`  ${chalk27.green("runtype --help")}
+    console.log(`  ${chalk28.green("runtype --help")}
 `);
   } else {
     try {