retell-cli 1.0.0

package/dist/index.js

@@ -0,0 +1,808 @@
+#!/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_commander = require("commander");
+var import_fs4 = require("fs");
+var import_path4 = require("path");
+
+// src/commands/login.ts
+var readline = __toESM(require("readline/promises"));
+var import_process = require("process");
+var import_retell_sdk2 = __toESM(require("retell-sdk"));
+
+// src/services/config.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var import_zod = require("zod");
+var ConfigSchema = import_zod.z.object({
+  apiKey: import_zod.z.string().min(1, "API key cannot be empty"),
+  defaultFormat: import_zod.z.enum(["json", "text"]).default("json")
+});
+var CONFIG_FILE_NAME = ".retellrc.json";
+var CONFIG_FILE_PERMISSIONS = 384;
+var ConfigError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "ConfigError";
+  }
+};
+function getConfigPath() {
+  return (0, import_path.join)(process.cwd(), CONFIG_FILE_NAME);
+}
+function readConfigFile() {
+  const configPath = getConfigPath();
+  if (!(0, import_fs.existsSync)(configPath)) {
+    return null;
+  }
+  try {
+    const content = (0, import_fs.readFileSync)(configPath, "utf-8");
+    const parsed = JSON.parse(content);
+    return ConfigSchema.parse(parsed);
+  } catch (error) {
+    if (error instanceof import_zod.z.ZodError) {
+      throw new ConfigError(
+        `Invalid config file format: ${error.errors.map((e) => e.message).join(", ")}`,
+        "INVALID_CONFIG"
+      );
+    }
+    if (error instanceof SyntaxError) {
+      throw new ConfigError(
+        `Config file contains invalid JSON: ${error.message}`,
+        "INVALID_JSON"
+      );
+    }
+    throw error;
+  }
+}
+function getApiKeyFromEnv() {
+  return process.env.RETELL_API_KEY || null;
+}
+function getConfig() {
+  const envApiKey = getApiKeyFromEnv();
+  if (envApiKey) {
+    return {
+      apiKey: envApiKey,
+      defaultFormat: "json"
+      // Default when using env var
+    };
+  }
+  const fileConfig = readConfigFile();
+  if (fileConfig) {
+    return fileConfig;
+  }
+  throw new ConfigError(
+    "No configuration found. Please run `retell login` to authenticate.",
+    "NO_CONFIG"
+  );
+}
+function saveConfig(config) {
+  let validatedConfig;
+  try {
+    validatedConfig = ConfigSchema.parse(config);
+  } catch (error) {
+    if (error instanceof import_zod.z.ZodError) {
+      throw new ConfigError(
+        `Invalid configuration: ${error.errors.map((e) => e.message).join(", ")}`,
+        "INVALID_CONFIG"
+      );
+    }
+    throw error;
+  }
+  const configPath = getConfigPath();
+  try {
+    (0, import_fs.writeFileSync)(
+      configPath,
+      JSON.stringify(validatedConfig, null, 2),
+      { encoding: "utf-8" }
+    );
+    (0, import_fs.chmodSync)(configPath, CONFIG_FILE_PERMISSIONS);
+  } catch (error) {
+    throw new ConfigError(
+      `Failed to save config: ${error.message}`,
+      "WRITE_ERROR"
+    );
+  }
+}
+function configFileExists() {
+  return (0, import_fs.existsSync)(getConfigPath());
+}
+
+// src/services/output-formatter.ts
+var import_retell_sdk = __toESM(require("retell-sdk"));
+function outputJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function outputError(error, code) {
+  const errorObj = {
+    error: typeof error === "string" ? error : error.message,
+    code: code || "UNKNOWN_ERROR"
+  };
+  console.error(JSON.stringify(errorObj, null, 2));
+  process.exit(1);
+}
+function handleSdkError(error) {
+  if (error instanceof import_retell_sdk.default.NotFoundError) {
+    outputError("Resource not found", "NOT_FOUND");
+  }
+  if (error instanceof import_retell_sdk.default.AuthenticationError) {
+    outputError(
+      "Authentication failed. Invalid API key. Please run `retell login` to authenticate.",
+      "AUTH_ERROR"
+    );
+  }
+  if (error instanceof import_retell_sdk.default.BadRequestError) {
+    const message = error.message || "Invalid request parameters";
+    outputError(message, "BAD_REQUEST");
+  }
+  if (error instanceof import_retell_sdk.default.RateLimitError) {
+    outputError("Rate limit exceeded. Please try again later.", "RATE_LIMIT");
+  }
+  if (error instanceof import_retell_sdk.default.PermissionDeniedError) {
+    outputError("Permission denied. Check your API key permissions.", "PERMISSION_DENIED");
+  }
+  if (error instanceof import_retell_sdk.default.InternalServerError) {
+    outputError("Retell API server error. Please try again later.", "SERVER_ERROR");
+  }
+  if (error instanceof import_retell_sdk.default.APIConnectionError) {
+    outputError("Failed to connect to Retell API. Check your network connection.", "CONNECTION_ERROR");
+  }
+  if (error instanceof import_retell_sdk.default.APIConnectionTimeoutError) {
+    outputError("Request to Retell API timed out. Please try again.", "TIMEOUT_ERROR");
+  }
+  if (error instanceof import_retell_sdk.default.APIError) {
+    const message = error.message || "An API error occurred";
+    outputError(message, "API_ERROR");
+  }
+  if (error instanceof Error) {
+    outputError(error.message, "UNKNOWN_ERROR");
+  }
+  outputError("An unexpected error occurred", "UNKNOWN_ERROR");
+}
+
+// src/commands/login.ts
+async function loginCommand() {
+  const rl = readline.createInterface({ input: import_process.stdin, output: import_process.stdout });
+  try {
+    if (configFileExists()) {
+      const overwrite = await rl.question("Config already exists. Overwrite? (y/n): ");
+      if (overwrite.toLowerCase() !== "y") {
+        rl.close();
+        outputJson({ message: "Login cancelled" });
+        return;
+      }
+    }
+    const apiKey = await rl.question("Enter your Retell API key: ");
+    rl.close();
+    if (!apiKey || apiKey.trim() === "") {
+      outputJson({
+        error: "API key cannot be empty",
+        code: "INVALID_INPUT"
+      });
+      process.exit(1);
+      return;
+    }
+    const testClient = new import_retell_sdk2.default({ apiKey: apiKey.trim() });
+    await testClient.agent.list({ limit: 1 });
+    saveConfig({ apiKey: apiKey.trim(), defaultFormat: "json" });
+    outputJson({
+      message: "Successfully authenticated!",
+      configPath: "./.retellrc.json",
+      nextSteps: [
+        "Try: retell agents list",
+        "Try: retell transcripts list"
+      ]
+    });
+  } catch (error) {
+    rl.close();
+    handleSdkError(error);
+  }
+}
+
+// src/services/retell-client.ts
+var import_retell_sdk3 = __toESM(require("retell-sdk"));
+var clientInstance = null;
+var CLIENT_CONFIG = {
+  maxRetries: 2,
+  // Retry failed requests 2 times (SDK default)
+  timeout: 6e4
+  // 60 second timeout (SDK default)
+};
+function getRetellClient() {
+  if (!clientInstance) {
+    let apiKey;
+    try {
+      const config = getConfig();
+      apiKey = config.apiKey;
+    } catch (error) {
+      if (error instanceof ConfigError) {
+        throw error;
+      }
+      throw new Error(`Failed to initialize Retell client: ${error.message}`);
+    }
+    clientInstance = new import_retell_sdk3.default({
+      apiKey,
+      maxRetries: CLIENT_CONFIG.maxRetries,
+      timeout: CLIENT_CONFIG.timeout
+    });
+  }
+  return clientInstance;
+}
+
+// src/commands/transcripts/list.ts
+async function listTranscriptsCommand(options) {
+  try {
+    const client = getRetellClient();
+    const calls = await client.call.list({
+      limit: options.limit || 50
+    });
+    outputJson(calls);
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/transcripts/get.ts
+async function getTranscriptCommand(callId) {
+  try {
+    const client = getRetellClient();
+    const call = await client.call.retrieve(callId);
+    outputJson(call);
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/transcripts/analyze.ts
+function extractTranscriptTurns(transcriptObject) {
+  if (!transcriptObject || !Array.isArray(transcriptObject)) {
+    return [];
+  }
+  return transcriptObject.map((turn) => ({
+    role: turn.role,
+    content: turn.content,
+    word_count: turn.content ? turn.content.split(/\s+/).length : 0
+  }));
+}
+async function analyzeTranscriptCommand(callId) {
+  try {
+    const client = getRetellClient();
+    const call = await client.call.retrieve(callId);
+    const analysis = {
+      call_id: callId,
+      metadata: {
+        status: call.call_status || "unknown",
+        duration_ms: call.duration_ms || 0,
+        start_timestamp: call.start_timestamp || 0,
+        end_timestamp: call.end_timestamp || 0,
+        agent_name: call.agent_name || "Unknown"
+      },
+      transcript: extractTranscriptTurns(call.transcript_object),
+      analysis: {
+        summary: call.call_analysis?.call_summary || "No summary available",
+        sentiment: call.call_analysis?.user_sentiment || "Unknown",
+        successful: call.call_analysis?.call_successful ?? false,
+        in_voicemail: call.call_analysis?.in_voicemail ?? false
+      },
+      performance: {
+        latency_p50_ms: {
+          e2e: call.latency?.e2e?.p50 ?? null,
+          llm: call.latency?.llm?.p50 ?? null,
+          tts: call.latency?.tts?.p50 ?? null
+        },
+        latency_p90_ms: {
+          e2e: call.latency?.e2e?.p90 ?? null,
+          llm: call.latency?.llm?.p90 ?? null,
+          tts: call.latency?.tts?.p90 ?? null
+        }
+      },
+      cost: {
+        total: call.call_cost?.combined_cost || 0,
+        breakdown: call.call_cost?.product_costs || []
+      }
+    };
+    outputJson(analysis);
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/agents/list.ts
+async function listAgentsCommand(options = {}) {
+  try {
+    const client = getRetellClient();
+    const agents2 = await client.agent.list({
+      limit: options.limit || 100
+    });
+    const formatted = agents2.map((agent) => {
+      let response_engine_id;
+      switch (agent.response_engine.type) {
+        case "retell-llm":
+          response_engine_id = agent.response_engine.llm_id || "unknown";
+          break;
+        case "conversation-flow":
+          response_engine_id = agent.response_engine.conversation_flow_id || "unknown";
+          break;
+        case "custom-llm":
+          response_engine_id = agent.response_engine.llm_websocket_url || "unknown";
+          break;
+        default:
+          response_engine_id = "unknown";
+      }
+      return {
+        agent_id: agent.agent_id,
+        agent_name: agent.agent_name,
+        version: agent.version,
+        is_published: agent.is_published,
+        response_engine_type: agent.response_engine.type,
+        response_engine_id
+      };
+    });
+    outputJson(formatted);
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/agents/info.ts
+async function agentInfoCommand(agentId) {
+  try {
+    const client = getRetellClient();
+    const agent = await client.agent.retrieve(agentId);
+    outputJson(agent);
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/prompts/pull.ts
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+
+// src/services/prompt-resolver.ts
+async function resolvePromptSource(agentId) {
+  const client = getRetellClient();
+  const agent = await client.agent.retrieve(agentId);
+  if (agent.response_engine.type === "retell-llm") {
+    const llm = await client.llm.retrieve(agent.response_engine.llm_id);
+    return {
+      type: "retell-llm",
+      llmId: llm.llm_id,
+      agentName: agent.agent_name,
+      prompts: {
+        llm_id: llm.llm_id,
+        version: llm.version,
+        general_prompt: llm.general_prompt,
+        begin_message: llm.begin_message,
+        states: llm.states
+      }
+    };
+  }
+  if (agent.response_engine.type === "conversation-flow") {
+    const flow = await client.conversationFlow.retrieve(
+      agent.response_engine.conversation_flow_id
+    );
+    return {
+      type: "conversation-flow",
+      flowId: flow.conversation_flow_id,
+      agentName: agent.agent_name,
+      prompts: {
+        conversation_flow_id: flow.conversation_flow_id,
+        version: flow.version,
+        global_prompt: flow.global_prompt,
+        nodes: flow.nodes
+      }
+    };
+  }
+  return {
+    type: "custom-llm",
+    error: "Custom LLM agents cannot be managed via API. Use the Retell dashboard to update prompts for custom LLM agents."
+  };
+}
+
+// src/commands/prompts/pull.ts
+function validateAgentId(agentId) {
+  if (agentId.includes("..") || agentId.includes("/") || agentId.includes("\\")) {
+    throw new Error("Invalid agent ID: cannot contain path separators or traversal sequences");
+  }
+}
+async function pullPromptsCommand(agentId, options) {
+  try {
+    validateAgentId(agentId);
+    const promptSource = await resolvePromptSource(agentId);
+    if (promptSource.type === "custom-llm") {
+      outputError(promptSource.error, "CUSTOM_LLM_NOT_SUPPORTED");
+      return;
+    }
+    const baseDir = options.output || ".retell-prompts";
+    const agentDir = (0, import_path2.join)(baseDir, agentId);
+    try {
+      (0, import_fs2.mkdirSync)(agentDir, { recursive: true });
+    } catch (error) {
+      if (error.code === "EACCES") {
+        outputError(`Permission denied creating directory: ${agentDir}`, "PERMISSION_DENIED");
+      } else if (error.code === "ENOSPC") {
+        outputError(`No space left on device: ${agentDir}`, "NO_SPACE");
+      } else {
+        outputError(`Failed to create directory: ${error.message}`, "FS_ERROR");
+      }
+      return;
+    }
+    try {
+      if (promptSource.type === "retell-llm") {
+        saveRetellLlmPrompts(agentDir, promptSource);
+      } else if (promptSource.type === "conversation-flow") {
+        saveConversationFlowPrompts(agentDir, promptSource);
+      }
+    } catch (error) {
+      if (error.code === "EACCES") {
+        outputError(`Permission denied writing files to: ${agentDir}`, "PERMISSION_DENIED");
+      } else if (error.code === "ENOSPC") {
+        outputError(`No space left on device: ${agentDir}`, "NO_SPACE");
+      } else {
+        outputError(`Failed to write prompt files: ${error.message}`, "FS_ERROR");
+      }
+      return;
+    }
+    outputJson({
+      message: "Prompts pulled successfully",
+      agent_id: agentId,
+      agent_name: promptSource.agentName,
+      type: promptSource.type,
+      directory: agentDir,
+      files_created: getFilesCreated(promptSource.type, promptSource)
+    });
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+function saveRetellLlmPrompts(agentDir, promptSource) {
+  const { prompts: prompts2, llmId, agentName } = promptSource;
+  const metadata = {
+    type: "retell-llm",
+    agent_name: agentName,
+    llm_id: llmId,
+    version: prompts2.version,
+    pulled_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  (0, import_fs2.writeFileSync)((0, import_path2.join)(agentDir, "metadata.json"), JSON.stringify(metadata, null, 2));
+  (0, import_fs2.writeFileSync)((0, import_path2.join)(agentDir, "general_prompt.md"), prompts2.general_prompt || "");
+  if (prompts2.begin_message) {
+    (0, import_fs2.writeFileSync)((0, import_path2.join)(agentDir, "begin_message.txt"), prompts2.begin_message);
+  }
+  if (prompts2.states && prompts2.states.length > 0) {
+    const statesDir = (0, import_path2.join)(agentDir, "states");
+    (0, import_fs2.mkdirSync)(statesDir, { recursive: true });
+    prompts2.states.forEach((state) => {
+      const filename = `${state.name}.md`;
+      const content = `# State: ${state.name}
+
+${state.state_prompt}`;
+      (0, import_fs2.writeFileSync)((0, import_path2.join)(statesDir, filename), content);
+    });
+  }
+}
+function saveConversationFlowPrompts(agentDir, promptSource) {
+  const { prompts: prompts2, flowId, agentName } = promptSource;
+  const metadata = {
+    type: "conversation-flow",
+    agent_name: agentName,
+    conversation_flow_id: flowId,
+    version: prompts2.version,
+    pulled_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  (0, import_fs2.writeFileSync)((0, import_path2.join)(agentDir, "metadata.json"), JSON.stringify(metadata, null, 2));
+  (0, import_fs2.writeFileSync)((0, import_path2.join)(agentDir, "global_prompt.md"), prompts2.global_prompt || "");
+  (0, import_fs2.writeFileSync)((0, import_path2.join)(agentDir, "nodes.json"), JSON.stringify(prompts2.nodes, null, 2));
+}
+function getFilesCreated(type, promptSource) {
+  const files = ["metadata.json"];
+  if (type === "retell-llm" && promptSource.type === "retell-llm") {
+    files.push("general_prompt.md");
+    if (promptSource.prompts.begin_message) {
+      files.push("begin_message.txt");
+    }
+    if (promptSource.prompts.states && promptSource.prompts.states.length > 0) {
+      files.push(`states/ (${promptSource.prompts.states.length} state files)`);
+    }
+  } else if (type === "conversation-flow") {
+    files.push("global_prompt.md");
+    files.push("nodes.json");
+  }
+  return files;
+}
+
+// src/commands/prompts/update.ts
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+function validateAgentId2(agentId) {
+  if (agentId.includes("..") || agentId.includes("/") || agentId.includes("\\")) {
+    throw new Error("Invalid agent ID: cannot contain path separators or traversal sequences");
+  }
+}
+async function updatePromptsCommand(agentId, options) {
+  try {
+    validateAgentId2(agentId);
+    const baseDir = options.source || ".retell-prompts";
+    const agentDir = (0, import_path3.join)(baseDir, agentId);
+    if (!(0, import_fs3.existsSync)(agentDir)) {
+      outputError(
+        `Prompts directory not found: ${agentDir}. Run 'retell prompts pull ${agentId}' first.`,
+        "DIRECTORY_NOT_FOUND"
+      );
+      return;
+    }
+    const metadataPath = (0, import_path3.join)(agentDir, "metadata.json");
+    if (!(0, import_fs3.existsSync)(metadataPath)) {
+      outputError(
+        `metadata.json not found in ${agentDir}. Directory may be corrupted.`,
+        "METADATA_NOT_FOUND"
+      );
+      return;
+    }
+    const metadata = JSON.parse((0, import_fs3.readFileSync)(metadataPath, "utf-8"));
+    const promptSource = await resolvePromptSource(agentId);
+    if (promptSource.type === "custom-llm") {
+      outputError(promptSource.error, "CUSTOM_LLM_NOT_SUPPORTED");
+      return;
+    }
+    if (metadata.type !== promptSource.type) {
+      outputError(
+        `Type mismatch: local files are ${metadata.type}, but agent uses ${promptSource.type}. Pull prompts again to sync.`,
+        "TYPE_MISMATCH"
+      );
+      return;
+    }
+    const client = getRetellClient();
+    if (promptSource.type === "retell-llm") {
+      const prompts2 = loadRetellLlmPrompts(agentDir);
+      await client.llm.update(promptSource.llmId, prompts2);
+      outputJson({
+        message: "Prompts updated successfully (draft version)",
+        agent_id: agentId,
+        agent_name: promptSource.agentName,
+        type: "retell-llm",
+        llm_id: promptSource.llmId,
+        note: `Run 'retell agent-publish ${agentId}' to publish changes to production`
+      });
+    } else if (promptSource.type === "conversation-flow") {
+      const prompts2 = loadConversationFlowPrompts(agentDir);
+      await client.conversationFlow.update(promptSource.flowId, prompts2);
+      outputJson({
+        message: "Prompts updated successfully (draft version)",
+        agent_id: agentId,
+        agent_name: promptSource.agentName,
+        type: "conversation-flow",
+        conversation_flow_id: promptSource.flowId,
+        note: `Run 'retell agent-publish ${agentId}' to publish changes to production`
+      });
+    }
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      outputError(`Invalid JSON in file: ${error.message}`, "INVALID_JSON");
+      return;
+    }
+    handleSdkError(error);
+  }
+}
+function loadRetellLlmPrompts(agentDir) {
+  const prompts2 = {};
+  const generalPromptPath = (0, import_path3.join)(agentDir, "general_prompt.md");
+  if (!(0, import_fs3.existsSync)(generalPromptPath)) {
+    throw new Error("general_prompt.md not found");
+  }
+  try {
+    prompts2.general_prompt = (0, import_fs3.readFileSync)(generalPromptPath, "utf-8");
+  } catch (error) {
+    throw new Error(`Failed to read general_prompt.md: ${error.message}`);
+  }
+  const beginMessagePath = (0, import_path3.join)(agentDir, "begin_message.txt");
+  if ((0, import_fs3.existsSync)(beginMessagePath)) {
+    try {
+      const beginMessage = (0, import_fs3.readFileSync)(beginMessagePath, "utf-8");
+      if (beginMessage) {
+        prompts2.begin_message = beginMessage;
+      }
+    } catch (error) {
+      throw new Error(`Failed to read begin_message.txt: ${error.message}`);
+    }
+  }
+  const statesDir = (0, import_path3.join)(agentDir, "states");
+  if ((0, import_fs3.existsSync)(statesDir)) {
+    try {
+      const stateFiles = (0, import_fs3.readdirSync)(statesDir).filter((f) => f.endsWith(".md"));
+      if (stateFiles.length > 0) {
+        prompts2.states = stateFiles.map((file) => {
+          const stateName = file.replace(".md", "");
+          let content;
+          try {
+            content = (0, import_fs3.readFileSync)((0, import_path3.join)(statesDir, file), "utf-8");
+          } catch (error) {
+            throw new Error(`Failed to read state file ${file}: ${error.message}`);
+          }
+          const STATE_HEADER_REGEX = /^#\s+State:\s+(.+)$/m;
+          const match = content.match(STATE_HEADER_REGEX);
+          if (!match) {
+            throw new Error(`Invalid state file format in ${file}: missing "# State:" header`);
+          }
+          const statePrompt = content.replace(STATE_HEADER_REGEX, "").trim();
+          return {
+            name: stateName,
+            state_prompt: statePrompt
+          };
+        });
+      }
+    } catch (error) {
+      if (error.message.includes("Invalid state file format") || error.message.includes("Failed to read state file")) {
+        throw error;
+      }
+      throw new Error(`Failed to read states directory: ${error.message}`);
+    }
+  }
+  return prompts2;
+}
+function loadConversationFlowPrompts(agentDir) {
+  const prompts2 = {};
+  const globalPromptPath = (0, import_path3.join)(agentDir, "global_prompt.md");
+  if (!(0, import_fs3.existsSync)(globalPromptPath)) {
+    throw new Error("global_prompt.md not found");
+  }
+  try {
+    prompts2.global_prompt = (0, import_fs3.readFileSync)(globalPromptPath, "utf-8");
+  } catch (error) {
+    throw new Error(`Failed to read global_prompt.md: ${error.message}`);
+  }
+  const nodesPath = (0, import_path3.join)(agentDir, "nodes.json");
+  if (!(0, import_fs3.existsSync)(nodesPath)) {
+    throw new Error("nodes.json not found");
+  }
+  try {
+    const nodesContent = JSON.parse((0, import_fs3.readFileSync)(nodesPath, "utf-8"));
+    if (!Array.isArray(nodesContent)) {
+      throw new Error("nodes.json must contain an array");
+    }
+    prompts2.nodes = nodesContent;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`Invalid JSON in nodes.json: ${error.message}`);
+    }
+    throw error;
+  }
+  return prompts2;
+}
+
+// src/commands/agent/publish.ts
+async function publishAgentCommand(agentId) {
+  try {
+    const client = getRetellClient();
+    const result = await client.agent.publish(agentId);
+    outputJson({
+      message: "Agent published successfully",
+      agent_id: result.agent_id,
+      agent_name: result.agent_name,
+      version: result.version,
+      is_published: result.is_published,
+      note: "Draft version incremented and ready for new changes"
+    });
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/index.ts
+var packageJson = JSON.parse(
+  (0, import_fs4.readFileSync)((0, import_path4.join)(__dirname, "../package.json"), "utf-8")
+);
+var program = new import_commander.Command();
+program.name("retell").description("Retell AI CLI - Manage transcripts and agent prompts").version(packageJson.version, "-v, --version", "Display version number").helpOption("-h, --help", "Display help for command").option("--json", "Output as JSON (default)", true);
+program.command("login").description("Authenticate with Retell AI").addHelpText("after", `
+Examples:
+  $ retell login
+  # Enter your API key when prompted
+  # Creates .retellrc.json in current directory
+  `).action(async () => {
+  await loginCommand();
+});
+var transcripts = program.command("transcripts").description("Manage call transcripts");
+transcripts.command("list").description("List all call transcripts").option("-l, --limit <number>", "Maximum number of calls to return (default: 50)", "50").addHelpText("after", `
+Examples:
+  $ retell transcripts list
+  $ retell transcripts list --limit 100
+  $ retell transcripts list | jq '.[] | select(.call_status == "error")'
+  `).action(async (options) => {
+  const limit = parseInt(options.limit, 10);
+  if (isNaN(limit) || limit < 1) {
+    console.error("Error: limit must be a positive number");
+    process.exit(1);
+  }
+  await listTranscriptsCommand({
+    limit
+  });
+});
+transcripts.command("get <call_id>").description("Get a specific call transcript").addHelpText("after", `
+Examples:
+  $ retell transcripts get call_abc123
+  $ retell transcripts get call_abc123 | jq '.transcript_object'
+  `).action(async (callId) => {
+  await getTranscriptCommand(callId);
+});
+transcripts.command("analyze <call_id>").description("Analyze a call transcript with performance metrics and insights").addHelpText("after", `
+Examples:
+  $ retell transcripts analyze call_abc123
+  $ retell transcripts analyze call_abc123 | jq '.performance.latency_p50_ms'
+  `).action(async (callId) => {
+  await analyzeTranscriptCommand(callId);
+});
+var agents = program.command("agents").description("Manage agents");
+agents.command("list").description("List all agents").option("-l, --limit <number>", "Maximum number of agents to return (default: 100)", "100").addHelpText("after", `
+Examples:
+  $ retell agents list
+  $ retell agents list --limit 10
+  $ retell agents list | jq '.[] | select(.response_engine.type == "retell-llm")'
+  `).action(async (options) => {
+  const limit = parseInt(options.limit, 10);
+  if (isNaN(limit) || limit < 1) {
+    console.error("Error: limit must be a positive number");
+    process.exit(1);
+  }
+  await listAgentsCommand({
+    limit
+  });
+});
+agents.command("info <agent_id>").description("Get detailed agent information").addHelpText("after", `
+Examples:
+  $ retell agents info agent_123abc
+  $ retell agents info agent_123abc | jq '.response_engine.type'
+  `).action(async (agentId) => {
+  await agentInfoCommand(agentId);
+});
+var prompts = program.command("prompts").description("Manage agent prompts");
+prompts.command("pull <agent_id>").description("Download agent prompts to a local file").option("-o, --output <path>", "Output file path (default: .retell-prompts/<agent_id>.json)", ".retell-prompts").addHelpText("after", `
+Examples:
+  $ retell prompts pull agent_123abc
+  $ retell prompts pull agent_123abc --output my-prompts.json
+  `).action(async (agentId, options) => {
+  await pullPromptsCommand(agentId, options);
+});
+prompts.command("update <agent_id>").description("Update agent prompts from a local file").option("-s, --source <path>", "Source file path (default: .retell-prompts/<agent_id>.json)", ".retell-prompts").option("--dry-run", "Preview changes without applying them", false).addHelpText("after", `
+Examples:
+  $ retell prompts update agent_123abc --source my-prompts.json --dry-run
+  $ retell prompts update agent_123abc --source my-prompts.json
+  # Remember to publish: retell agent-publish agent_123abc
+  `).action(async (agentId, options) => {
+  await updatePromptsCommand(agentId, options);
+});
+program.command("agent-publish <agent_id>").description("Publish a draft agent to make changes live").addHelpText("after", `
+Examples:
+  $ retell agent-publish agent_123abc
+  # Run this after updating prompts to make changes live
+  `).action(async (agentId) => {
+  await publishAgentCommand(agentId);
+});
+program.parse(process.argv);
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}