@runtypelabs/cli 2.4.0 → 2.6.0

package/dist/index.js

@@ -11636,6 +11636,7 @@ var require_generated_model_routing = __commonJS({
       "gemini-3.1-flash-lite-preview": ["vercel"],
       "gemini-3.1-pro-preview": ["vercel"],
       "gemini-embedding-001": ["vercel"],
+      "gemini-embedding-2": ["vercel"],
       "gemini-flash-1.5-8b": ["google"],
       "gemini-pro": ["google"],
       "gemma-2-9b": ["vercel"],
@@ -11785,8 +11786,11 @@ var require_generated_model_routing = __commonJS({
       "grok-4-fast-reasoning": ["vercel"],
       "grok-4.1-fast-non-reasoning": ["vercel"],
       "grok-4.1-fast-reasoning": ["vercel"],
+      "grok-4.20-multi-agent": ["vercel"],
       "grok-4.20-multi-agent-beta": ["vercel"],
+      "grok-4.20-non-reasoning": ["vercel"],
       "grok-4.20-non-reasoning-beta": ["vercel"],
+      "grok-4.20-reasoning": ["vercel"],
       "grok-4.20-reasoning-beta": ["vercel"],
       "grok-beta": ["xai"],
       "grok-code-fast-1": ["vercel", "xai"],
@@ -11843,6 +11847,7 @@ var require_generated_model_routing = __commonJS({
       "Meta-Llama-3.3-70B-Instruct-Turbo": ["togetherai"],
       "meta.llama3-8b-instruct-v1%3A0": ["bedrock"],
       "mimo-v2-flash": ["vercel"],
+      "mimo-v2-pro": ["vercel"],
       "minimax-m2": ["vercel"],
       "minimax-m2.1": ["vercel"],
       "minimax-m2.1-lightning": ["vercel"],
@@ -12091,6 +12096,7 @@ var require_generated_model_routing = __commonJS({
       "gemini-3-flash": ["google", "vercel"],
       "gemini-3-pro-image": ["vercel"],
       "gemini-embedding-001": ["vercel"],
+      "gemini-embedding-2": ["vercel"],
       "gemini-flash-1-5-8b": ["google"],
       "gemini-pro": ["google"],
       "gemma-2-9b": ["vercel"],
@@ -12231,8 +12237,11 @@ var require_generated_model_routing = __commonJS({
       "grok-4": ["vercel", "xai"],
       "grok-4-1-fast-non-reasoning": ["vercel"],
       "grok-4-1-fast-reasoning": ["vercel"],
+      "grok-4-20-multi-agent": ["vercel"],
       "grok-4-20-multi-agent-beta": ["vercel"],
+      "grok-4-20-non-reasoning": ["vercel"],
       "grok-4-20-non-reasoning-beta": ["vercel"],
+      "grok-4-20-reasoning": ["vercel"],
       "grok-4-20-reasoning-beta": ["vercel"],
       "grok-4-fast": ["xai"],
       "grok-4-fast-non-reasoning": ["vercel"],
@@ -12284,6 +12293,7 @@ var require_generated_model_routing = __commonJS({
       "meta-llama-3-8b-instruct-turbo": ["togetherai"],
       "meta.llama3-8b-instruct-v1%3a0": ["bedrock"],
       "mimo-v2-flash": ["vercel"],
+      "mimo-v2-pro": ["vercel"],
       "minimax-m2": ["vercel"],
       "minimax-m2-1": ["vercel"],
       "minimax-m2-1-lightning": ["vercel"],
@@ -12817,6 +12827,9 @@ var require_generated_model_routing = __commonJS({
       "gemini-embedding-001": {
         "vercel": "google/gemini-embedding-001"
       },
+      "gemini-embedding-2": {
+        "vercel": "google/gemini-embedding-2"
+      },
       "gemini-flash-1-5-8b": {
         "google": "gemini-flash-1.5-8b"
       },
@@ -13455,12 +13468,21 @@ var require_generated_model_routing = __commonJS({
       "grok-4-1-fast-reasoning": {
         "vercel": "xai/grok-4.1-fast-reasoning"
       },
+      "grok-4-20-multi-agent": {
+        "vercel": "xai/grok-4.20-multi-agent"
+      },
       "grok-4-20-multi-agent-beta": {
         "vercel": "xai/grok-4.20-multi-agent-beta"
       },
+      "grok-4-20-non-reasoning": {
+        "vercel": "xai/grok-4.20-non-reasoning"
+      },
       "grok-4-20-non-reasoning-beta": {
         "vercel": "xai/grok-4.20-non-reasoning-beta"
       },
+      "grok-4-20-reasoning": {
+        "vercel": "xai/grok-4.20-reasoning"
+      },
       "grok-4-20-reasoning-beta": {
         "vercel": "xai/grok-4.20-reasoning-beta"
       },
@@ -13479,12 +13501,21 @@ var require_generated_model_routing = __commonJS({
       "grok-4.1-fast-reasoning": {
         "vercel": "xai/grok-4.1-fast-reasoning"
       },
+      "grok-4.20-multi-agent": {
+        "vercel": "xai/grok-4.20-multi-agent"
+      },
       "grok-4.20-multi-agent-beta": {
         "vercel": "xai/grok-4.20-multi-agent-beta"
       },
+      "grok-4.20-non-reasoning": {
+        "vercel": "xai/grok-4.20-non-reasoning"
+      },
       "grok-4.20-non-reasoning-beta": {
         "vercel": "xai/grok-4.20-non-reasoning-beta"
       },
+      "grok-4.20-reasoning": {
+        "vercel": "xai/grok-4.20-reasoning"
+      },
       "grok-4.20-reasoning-beta": {
         "vercel": "xai/grok-4.20-reasoning-beta"
       },
@@ -13726,6 +13757,9 @@ var require_generated_model_routing = __commonJS({
       "mimo-v2-flash": {
         "vercel": "xiaomi/mimo-v2-flash"
       },
+      "mimo-v2-pro": {
+        "vercel": "xiaomi/mimo-v2-pro"
+      },
       "minimax-m2": {
         "vercel": "minimax/minimax-m2"
       },
@@ -15342,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
@@ -21552,12 +21586,21 @@ function isRecord(value) {
 function parseSandboxProvider(value) {
   if (!value) return void 0;
   const normalized = value.trim().toLowerCase();
-  if (normalized === "quickjs" || normalized === "daytona" || normalized === "cloudflare-worker")
+  if (normalized === "quickjs" || normalized === "daytona" || normalized === "cloudflare-worker" || normalized === "cloudflare-shell")
     return normalized;
   return void 0;
 }
 function parseSandboxLanguage(provider, value) {
   if (provider === "quickjs" || provider === "cloudflare-worker") return "javascript";
+  if (provider === "cloudflare-shell") {
+    if (typeof value === "string") {
+      const normalized = value.trim().toLowerCase();
+      if (normalized === "javascript" || normalized === "typescript") {
+        return normalized;
+      }
+    }
+    return "javascript";
+  }
   if (typeof value === "string") {
     const normalized = value.trim().toLowerCase();
     if (normalized === "javascript" || normalized === "typescript" || normalized === "python") {
@@ -21637,6 +21680,44 @@ function createSandboxInstructions(provider) {
       "return { sum, count: nums.length }"
     ].join("\n");
   }
+  if (provider === "cloudflare-shell") {
+    return [
+      "--- Sandbox Tooling (Cloudflare Shell) ---",
+      "You can execute JavaScript/TypeScript code with the local tool `run_sandbox_code`.",
+      "Call shape:",
+      '{ "code": "...", "parameters": { ... }, "language": "javascript|typescript", "timeoutMs": 30000 }',
+      "Cloudflare Shell rules:",
+      "1. Choose one language: javascript or typescript.",
+      "2. TypeScript is fully supported with runtime compilation and npm dependency resolution.",
+      "3. Inputs are passed via the `parameters` object (for example: `const x = parameters.x`).",
+      "4. async/await and Promises are fully supported.",
+      "5. The snippet is wrapped in an async function. Use top-level `return ...` to produce the result.",
+      "6. Return JSON-serializable values (object, array, string, number, boolean, null).",
+      "7. Helper functions are available under `helpers.*` namespace (e.g., `helpers.extractEmails(text)`).",
+      "8. Persistent filesystem: `state.writeFile()`, `state.readFile()`, `state.glob()` are available for working with files.",
+      "9. Files persist across multiple `run_sandbox_code` calls within the same sandbox.",
+      "10. No Python support \u2014 use Daytona for Python workloads.",
+      "11. No network access (fetch calls are blocked by default).",
+      "Example:",
+      "const nums = parameters.nums || []",
+      "const sum = nums.reduce((acc: number, n: number) => acc + n, 0)",
+      "return { sum, count: nums.length }",
+      "",
+      "--- Deploy with Preview (Cloudflare Shell) ---",
+      "You also have `deploy_sandbox` to deploy a persistent web server and get a live preview URL.",
+      "Call shape:",
+      '{ "code": "...", "files": { "public/index.html": "..." }, "packageJson": "{\\"dependencies\\": {\\"hono\\": \\"^4.0.0\\"}}", "language": "typescript", "port": 3000 }',
+      "Deploy rules:",
+      "1. Use this when you need to run a web server (Hono, etc.) that the user can visit in their browser.",
+      "2. The `code` is the main entry point file. The `packageJson` string provides npm dependencies.",
+      "3. The `files` parameter writes additional files (path \u2192 content). Keys must be plain file paths.",
+      "4. The code must export a fetch handler (Cloudflare Workers format): `export default { fetch(req) { ... } }`",
+      "5. The sandbox is persistent \u2014 each sandbox has its own Durable Object with isolated state.",
+      "6. The returned `previewUrl` is a REAL live URL (e.g., https://api.runtype.com/preview/{sandboxId}/) that the user can open in their browser.",
+      "7. The sandbox persists for 2 hours after the last activity, then auto-cleans up.",
+      "8. Prefer this over `run_sandbox_code` when building web apps, APIs, or anything with a UI."
+    ].join("\n");
+  }
   return [
     "--- Sandbox Tooling (Daytona) ---",
     "You can execute code snippets with the local tool `run_sandbox_code`.",
@@ -21666,7 +21747,7 @@ function createSandboxInstructions(provider) {
 }
 function createSandboxLocalTool(client, provider, debugMode) {
   return {
-    description: provider === "cloudflare-worker" ? "Execute JavaScript code in Cloudflare Worker sandbox. Async/await supported. Inputs are passed via parameters object." : provider === "quickjs" ? "Execute JavaScript code in QuickJS sandbox (legacy). Inputs are passed via parameters object." : "Execute JavaScript/TypeScript/Python code in Daytona sandbox. Inputs are injected as top-level variables.",
+    description: provider === "cloudflare-worker" ? "Execute JavaScript code in Cloudflare Worker sandbox. Async/await supported. Inputs are passed via parameters object." : provider === "quickjs" ? "Execute JavaScript code in QuickJS sandbox (legacy). Inputs are passed via parameters object." : provider === "cloudflare-shell" ? "Execute JavaScript/TypeScript code in Cloudflare Shell sandbox. TypeScript and npm dependencies supported. Inputs are passed via parameters object." : "Execute JavaScript/TypeScript/Python code in Daytona sandbox. Inputs are injected as top-level variables.",
     parametersSchema: {
       type: "object",
       properties: {
@@ -21677,8 +21758,8 @@ function createSandboxLocalTool(client, provider, debugMode) {
         },
         language: {
           type: "string",
-          enum: provider === "quickjs" || provider === "cloudflare-worker" ? ["javascript"] : ["javascript", "typescript", "python"],
-          description: provider === "quickjs" ? "QuickJS only accepts javascript" : provider === "cloudflare-worker" ? "Cloudflare Worker only accepts javascript" : "Daytona code language"
+          enum: provider === "quickjs" || provider === "cloudflare-worker" ? ["javascript"] : provider === "cloudflare-shell" ? ["javascript", "typescript"] : ["javascript", "typescript", "python"],
+          description: provider === "quickjs" ? "QuickJS only accepts javascript" : provider === "cloudflare-worker" ? "Cloudflare Worker only accepts javascript" : provider === "cloudflare-shell" ? "Cloudflare Shell accepts javascript or typescript" : "Daytona code language"
         },
         timeoutMs: { type: "number", description: "Execution timeout in ms (max 30000)" }
       },
@@ -21709,7 +21790,7 @@ function createSandboxLocalTool(client, provider, debugMode) {
         {
           allowedToolTypes: ["custom"],
           allowedSandboxProviders: [provider],
-          allowedLanguages: provider === "quickjs" || provider === "cloudflare-worker" ? ["javascript"] : ["javascript", "typescript", "python"],
+          allowedLanguages: provider === "quickjs" || provider === "cloudflare-worker" ? ["javascript"] : provider === "cloudflare-shell" ? ["javascript", "typescript"] : ["javascript", "typescript", "python"],
           maxTimeoutMs: 3e4,
           maxCodeLength: 12e3
         }
@@ -21871,6 +21952,84 @@ function createDeploySandboxLocalTool(client, debugMode) {
     }
   };
 }
+var activeCfShellWorkerId;
+function createDeployCfShellLocalTool(client, debugMode) {
+  return {
+    description: "Deploy code to a persistent Cloudflare Shell Dynamic Worker and get a live preview URL. Use this to run web servers, APIs, or UIs that the user can visit in their browser. Supports JavaScript and TypeScript with npm dependencies.",
+    parametersSchema: {
+      type: "object",
+      properties: {
+        code: { type: "string", description: "Code to deploy (main entry point file)" },
+        packageJson: {
+          type: "object",
+          description: 'package.json content as a JSON object, e.g. { "dependencies": { "hono": "^4.0.0" } }'
+        },
+        language: {
+          type: "string",
+          enum: ["javascript", "typescript"],
+          description: "Language of the code (default: typescript)"
+        },
+        port: {
+          type: "number",
+          description: "Port the server listens on (default: 3000)"
+        },
+        files: {
+          type: "object",
+          description: 'Additional files to write (path \u2192 content), e.g. { "public/index.html": "<html>..." }. Keys must be plain file paths. Use this for multi-file projects.',
+          additionalProperties: { type: "string" }
+        }
+      },
+      required: ["code"]
+    },
+    execute: async (args) => {
+      const code = typeof args.code === "string" ? args.code : "";
+      if (!code.trim()) {
+        return { success: false, error: "code is required" };
+      }
+      const request = {
+        code,
+        ...args.packageJson && typeof args.packageJson === "object" ? { packageJson: JSON.stringify(args.packageJson) } : typeof args.packageJson === "string" ? { packageJson: args.packageJson } : {},
+        ...typeof args.language === "string" ? { language: args.language } : {},
+        ...typeof args.port === "number" ? { port: args.port } : {},
+        ...args.files && typeof args.files === "object" && !Array.isArray(args.files) ? { files: args.files } : {},
+        // Reuse existing worker if one was created
+        ...activeCfShellWorkerId ? { workerId: activeCfShellWorkerId } : {}
+      };
+      try {
+        const result = await client.tools.deployCfShell(request);
+        if (result.workerId) {
+          activeCfShellWorkerId = result.workerId;
+        }
+        if (result.previewUrl) {
+          activeDeploySandboxPreviewUrl = result.previewUrl;
+        }
+        if (debugMode) {
+          console.log(
+            chalk11.gray(
+              `  [deploy_cf_shell] ${result.status} \u2014 ${result.previewUrl || "no preview URL"}`
+            )
+          );
+        }
+        return {
+          success: result.status === "running",
+          workerId: result.workerId,
+          previewUrl: result.previewUrl,
+          output: result.output,
+          ...result.error ? { error: result.error } : {}
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (debugMode) {
+          console.log(chalk11.gray(`  [deploy_cf_shell] error: ${message}`));
+        }
+        return {
+          success: false,
+          error: message
+        };
+      }
+    }
+  };
+}
 
 // src/marathon/event-log.ts
 import * as fs3 from "fs";
@@ -27364,6 +27523,8 @@ function buildLocalTools(client, sandboxProvider, options, context) {
     enabledTools.run_sandbox_code = createSandboxLocalTool(client, sandboxProvider, options.debug);
     if (sandboxProvider === "daytona") {
       enabledTools.deploy_sandbox = createDeploySandboxLocalTool(client, options.debug);
+    } else if (sandboxProvider === "cloudflare-shell") {
+      enabledTools.deploy_sandbox = createDeployCfShellLocalTool(client, options.debug);
     }
   }
   return Object.keys(enabledTools).length > 0 ? enabledTools : void 0;
@@ -31521,14 +31682,538 @@ 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 { execFile as execFileCallback } from "child_process";
+import { promisify } from "util";
+
+// 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
+  });
+  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 execFile = promisify(execFileCallback);
+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";
+}
+async function copyToClipboard2(text) {
+  if (process.platform === "darwin") {
+    await execFile("pbcopy", [], { input: text });
+    return;
+  }
+  if (process.platform === "win32") {
+    await execFile("clip", [], { shell: true, input: text });
+    return;
+  }
+  try {
+    await execFile("xclip", ["-selection", "clipboard"], { input: text });
+  } catch {
+    await execFile("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);
+  }
+  const cleanup = () => {
+    process.stdin.setRawMode(false);
+    process.stdin.removeAllListeners("keypress");
+  };
+  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 {
+          await 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");
+        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;
@@ -31548,8 +32233,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;
@@ -31613,27 +32298,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;
@@ -31684,13 +32369,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;
@@ -31727,8 +32412,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;
@@ -31792,14 +32477,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;
@@ -31814,7 +32499,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 {
@@ -31848,11 +32533,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;
@@ -31888,13 +32573,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) => {
@@ -31909,21 +32594,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;
@@ -31983,8 +32668,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;
@@ -32049,8 +32734,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;
@@ -32103,11 +32788,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;
@@ -32148,7 +32833,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;
@@ -32242,7 +32927,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);
@@ -32284,7 +32969,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);
@@ -32302,6 +32987,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);
@@ -32319,15 +33005,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);
   }
@@ -32336,12 +33022,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 {