copilotkit 1.54.0 → 2.0.0

package/dist/lib/init/scaffold/index.js

@@ -1,690 +0,0 @@
-// src/lib/init/scaffold/shadcn.ts
-import spawn from "cross-spawn";
-
-// src/lib/init/types/questions.ts
-import { z } from "zod";
-import { Flags } from "@oclif/core";
-
-// src/lib/init/utils.ts
-var isLocalhost = (url) => {
-  return url.includes("localhost") || url.includes("127.0.0.1") || url.includes("0.0.0.0");
-};
-
-// src/lib/init/types/questions.ts
-var MODES = [
-  "LangGraph",
-  "CrewAI",
-  "Mastra",
-  "LlamaIndex",
-  "Agno",
-  "AG2",
-  "MCP",
-  "Standard"
-];
-var CREW_TYPES = ["Crews", "Flows"];
-var CHAT_COMPONENTS = [
-  "CopilotChat",
-  "CopilotSidebar",
-  "Headless",
-  "CopilotPopup"
-];
-var LANGGRAPH_AGENTS = [
-  "Python Starter",
-  "TypeScript Starter"
-];
-var CREW_FLOW_TEMPLATES = ["Starter"];
-var YES_NO = ["Yes", "No"];
-var DEPLOYMENT_CHOICES = ["Copilot Cloud", "Self-hosted"];
-var sanitizers = {
-  // Remove trailing slash from URLs
-  url: (value) => {
-    if (!value) return value;
-    return value.trim().replace(/\/+$/, "");
-  },
-  // Trim whitespace from strings
-  trim: (value) => {
-    if (!value) return value;
-    return value.trim();
-  },
-  // Lowercase strings
-  lowercase: (value) => {
-    if (!value) return value;
-    return value.toLowerCase().trim();
-  },
-  // Clean API keys (remove whitespace)
-  apiKey: (value) => {
-    if (!value) return value;
-    return value.trim().replace(/\s/g, "");
-  }
-};
-var ModeSchema = z.enum(MODES);
-var CrewTypeSchema = z.enum(CREW_TYPES);
-var ChatComponentSchema = z.enum(CHAT_COMPONENTS);
-var LangGraphAgentSchema = z.enum(LANGGRAPH_AGENTS);
-var CrewFlowTemplateSchema = z.enum(CREW_FLOW_TEMPLATES);
-var YesNoSchema = z.enum(YES_NO);
-var DeploymentChoiceSchema = z.enum(DEPLOYMENT_CHOICES);
-var UrlSchema = z.preprocess(
-  (val) => sanitizers.url(String(val)),
-  z.string().url("Please enter a valid URL").min(1, "URL is required")
-);
-var TokenSchema = z.preprocess(
-  (val) => sanitizers.trim(String(val)),
-  z.string().min(1, "Token is required")
-);
-var ApiKeySchema = z.preprocess(
-  (val) => sanitizers.apiKey(String(val)),
-  z.string().min(1, "API key is required")
-);
-var LLMApiKeySchema = z.preprocess(
-  (val) => sanitizers.apiKey(String(val)),
-  z.string().optional()
-);
-var NameSchema = z.preprocess(
-  (val) => sanitizers.trim(String(val)),
-  z.string().min(1, "Name is required")
-);
-var ConfigSchema = z.object({
-  // Core fields
-  copilotKitVersion: z.string().optional(),
-  mode: ModeSchema,
-  chatUi: ChatComponentSchema.optional(),
-  // Yes/No fields
-  alreadyDeployed: YesNoSchema.optional(),
-  fastApiEnabled: YesNoSchema.optional(),
-  // DEPRECATED: useCopilotCloud - consolidated with signupForCopilotCloud
-  useCopilotCloud: YesNoSchema.optional(),
-  // LangGraph specific fields
-  langGraphAgent: LangGraphAgentSchema.optional(),
-  langGraphPlatform: YesNoSchema.optional(),
-  langGraphPlatformUrl: UrlSchema.optional(),
-  langGraphRemoteEndpointURL: UrlSchema.optional(),
-  // CrewAI specific fields
-  crewType: CrewTypeSchema.optional(),
-  crewName: NameSchema.optional(),
-  crewUrl: UrlSchema.optional(),
-  crewBearerToken: TokenSchema.optional(),
-  // API keys and tokens
-  copilotCloudPublicApiKey: z.string().optional(),
-  langSmithApiKey: ApiKeySchema.optional(),
-  llmToken: LLMApiKeySchema.optional(),
-  // IDE Documentation setup fields
-  setupIDEDocs: YesNoSchema.optional(),
-  selectedIDE: z.union([z.enum(["cursor", "windsurf"]), z.literal("skip")]).optional(),
-  // NEW: A/B/C test fields
-  deploymentChoice: DeploymentChoiceSchema.optional()
-  // For branch B only (Cloud vs Self-hosted)
-}).refine(
-  (data) => {
-    if (data.mode === "CrewAI") {
-      return !!data.crewUrl && !!data.crewBearerToken;
-    }
-    return true;
-  },
-  {
-    message: "Crew URL and bearer token are required for CrewAI",
-    path: ["crewUrl", "crewBearerToken"]
-  }
-).refine(
-  (data) => {
-    if (data.mode === "LangGraph" && data.alreadyDeployed === "Yes" && data.langGraphPlatform === "Yes") {
-      return !!data.langGraphPlatformUrl && !!data.langSmithApiKey || isLocalhost(data.langGraphPlatformUrl || "");
-    }
-    return true;
-  },
-  {
-    message: "LangGraph Platform URL and LangSmith API key are required",
-    path: ["langGraphPlatformUrl", "langSmithApiKey"]
-  }
-);
-var ConfigFlags = {
-  booth: Flags.boolean({
-    description: "Use CopilotKit in booth mode",
-    default: false,
-    char: "b"
-  }),
-  mode: Flags.string({
-    description: "How you will be interacting with AI",
-    options: MODES,
-    char: "m"
-  }),
-  "copilotkit-version": Flags.string({
-    description: "CopilotKit version to use (e.g. 1.7.0)"
-  }),
-  "use-copilot-cloud": Flags.string({
-    description: "Use Copilot Cloud for production-ready hosting",
-    options: YES_NO
-  }),
-  "langgraph-agent": Flags.string({
-    description: "LangGraph agent template to use",
-    options: LANGGRAPH_AGENTS
-  }),
-  "crew-type": Flags.string({
-    description: "CrewAI implementation type",
-    options: CREW_TYPES
-  }),
-  "crew-name": Flags.string({ description: "Name for your CrewAI agent" }),
-  "crew-url": Flags.string({
-    description: "URL endpoint for your CrewAI agent"
-  }),
-  "crew-bearer-token": Flags.string({
-    description: "Bearer token for CrewAI authentication"
-  }),
-  "langsmith-api-key": Flags.string({
-    description: "LangSmith API key for LangGraph observability"
-  }),
-  "llm-token": Flags.string({
-    description: "API key for your preferred LLM provider"
-  }),
-  "setup-ide-docs": Flags.string({
-    description: "Setup IDE documentation rules for AI assistance",
-    options: YES_NO
-  }),
-  "selected-ide": Flags.string({
-    description: "IDE to configure with documentation rules",
-    options: ["cursor", "windsurf", "skip"]
-  }),
-  // NEW: A/B/C test flags
-  "deployment-choice": Flags.string({
-    description: "Choose between Copilot Cloud or Self-hosted deployment",
-    options: DEPLOYMENT_CHOICES
-  })
-};
-
-// src/lib/init/types/templates.ts
-var BASE_URL = "https://registry.copilotkit.ai/r";
-var templateMapping = {
-  // Runtimes
-  RemoteEndpoint: `${BASE_URL}/remote-endpoint.json`,
-  LangGraphPlatformRuntime: `${BASE_URL}/langgraph-platform-runtime.json`,
-  // CrewAI
-  CrewEnterprise: [`${BASE_URL}/coagents-crew-starter.json`],
-  CrewFlowsEnterprise: [`${BASE_URL}/coagents-starter-crewai-flows.json`],
-  // LangGraph
-  LangGraphGeneric: `${BASE_URL}/generic-lg-starter.json`,
-  LangGraphStarter: [
-    `${BASE_URL}/langgraph-platform-starter.json`,
-    `${BASE_URL}/coagents-starter-ui.json`
-  ],
-  // No Agent
-  StandardStarter: `${BASE_URL}/standard-starter.json`,
-  StandardRuntime: `${BASE_URL}/standard-runtime.json`,
-  // MCP
-  McpStarter: `${BASE_URL}/mcp-starter.json`,
-  McpRuntime: `${BASE_URL}/mcp-starter-runtime.json`
-};
-
-// src/lib/init/scaffold/shadcn.ts
-async function scaffoldShadCN(flags, userAnswers) {
-  try {
-    const components = [];
-    switch (userAnswers.mode) {
-      case "LangGraph":
-        components.push(templateMapping.LangGraphGeneric);
-        if (userAnswers.langGraphPlatform === "Yes") {
-          components.push(templateMapping.LangGraphPlatformRuntime);
-        } else {
-          components.push(templateMapping.RemoteEndpoint);
-        }
-        break;
-      case "CrewAI":
-        if (userAnswers.crewType === "Crews") {
-          components.push(...templateMapping.CrewEnterprise);
-        } else if (userAnswers.crewType === "Flows") {
-          components.push(...templateMapping.CrewFlowsEnterprise);
-        } else {
-          components.push(templateMapping.RemoteEndpoint);
-        }
-        break;
-      case "MCP":
-        components.push(templateMapping.McpStarter);
-        if (userAnswers.deploymentChoice === "Self-hosted" || userAnswers.useCopilotCloud === "No") {
-          components.push(templateMapping.McpRuntime);
-        }
-        break;
-      case "Standard":
-        components.push(templateMapping.StandardStarter);
-        if (userAnswers.deploymentChoice === "Self-hosted" || userAnswers.useCopilotCloud === "No") {
-          components.push(templateMapping.StandardRuntime);
-        }
-        break;
-      default:
-        return;
-    }
-    await new Promise((resolve) => setTimeout(resolve, 100));
-    try {
-      const result = spawn.sync(
-        "npx",
-        ["shadcn@latest", "add", ...components],
-        {
-          stdio: "inherit"
-          // This ensures stdin/stdout/stderr are all passed through
-        }
-      );
-      if (result.status !== 0) {
-        throw new Error(
-          `The shadcn installation process exited with code ${result.status}`
-        );
-      }
-    } catch (error) {
-      throw error;
-    }
-  } catch (error) {
-    throw error;
-  }
-}
-
-// src/lib/init/scaffold/env.ts
-import path from "path";
-import fs from "fs";
-
-// src/lib/init/scaffold/langgraph-assistants.ts
-async function getLangGraphAgents(url, langSmithApiKey) {
-  try {
-    const response = await fetch(
-      `${url.trim().replace(/\/$/, "")}/assistants/search`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "X-Api-Key": langSmithApiKey
-        },
-        body: JSON.stringify({
-          limit: 10,
-          offset: 0
-        })
-      }
-    );
-    return await response.json();
-  } catch (error) {
-    throw new Error(`Failed to get LangGraph agents: ${error}`);
-  }
-}
-
-// src/lib/init/scaffold/env.ts
-import inquirer from "inquirer";
-function needsCloudDeployment(userAnswers) {
-  return userAnswers.deploymentChoice === "Copilot Cloud" || // Branch B choice
-  userAnswers.useCopilotCloud === "Yes" || // Branch C choice
-  userAnswers.mode === "CrewAI" || // CrewAI always needs cloud
-  !userAnswers.deploymentChoice && !userAnswers.useCopilotCloud;
-}
-async function scaffoldEnv(flags, userAnswers) {
-  try {
-    const envFile = path.join(process.cwd(), ".env");
-    if (!fs.existsSync(envFile)) {
-      fs.writeFileSync(envFile, "", "utf8");
-    } else {
-    }
-    let newEnvValues = "";
-    const isCloudDeployment = needsCloudDeployment(userAnswers);
-    if (userAnswers.copilotCloudPublicApiKey) {
-      newEnvValues += `NEXT_PUBLIC_COPILOT_API_KEY=${userAnswers.copilotCloudPublicApiKey}
-`;
-    }
-    if (userAnswers.langSmithApiKey) {
-      newEnvValues += `LANGSMITH_API_KEY=${userAnswers.langSmithApiKey}
-`;
-    }
-    if (userAnswers.llmToken) {
-      newEnvValues += `OPENAI_API_KEY=${userAnswers.llmToken}
-`;
-    }
-    if (userAnswers.crewName) {
-      newEnvValues += `NEXT_PUBLIC_COPILOTKIT_AGENT_NAME=${userAnswers.crewName}
-`;
-    }
-    if (userAnswers.langGraphAgent) {
-      newEnvValues += `NEXT_PUBLIC_COPILOTKIT_AGENT_NAME=sample_agent
-`;
-      newEnvValues += `LANGGRAPH_DEPLOYMENT_URL=http://localhost:8123
-`;
-    } else if (userAnswers.langGraphPlatform === "Yes" && !isCloudDeployment) {
-      newEnvValues += `LANGGRAPH_DEPLOYMENT_URL=${userAnswers.langGraphPlatformUrl}
-`;
-    } else if (userAnswers.langGraphRemoteEndpointURL) {
-      newEnvValues += `COPILOTKIT_REMOTE_ENDPOINT=${userAnswers.langGraphRemoteEndpointURL}
-`;
-    }
-    if (flags.runtimeUrl) {
-      newEnvValues += `NEXT_PUBLIC_COPILOTKIT_RUNTIME_URL=${flags.runtimeUrl}
-`;
-    } else if (!isCloudDeployment && userAnswers.crewType !== "Crews" && userAnswers.crewType !== "Flows") {
-      newEnvValues += `NEXT_PUBLIC_COPILOTKIT_RUNTIME_URL=/api/copilotkit
-`;
-    }
-    if (userAnswers.langGraphPlatformUrl && (userAnswers.langSmithApiKey || isLocalhost(userAnswers.langGraphPlatformUrl))) {
-      const langGraphAgents = await getLangGraphAgents(
-        userAnswers.langGraphPlatformUrl,
-        userAnswers.langSmithApiKey || ""
-      );
-      let langGraphAgent = "";
-      if (langGraphAgents.length > 1) {
-        const { langGraphAgentChoice } = await inquirer.prompt([
-          {
-            type: "list",
-            name: "langGraphAgentChoice",
-            message: "\u{1F99C}\u{1F517} Which agent from your graph would you like to use?",
-            choices: langGraphAgents.map((agent) => ({
-              name: agent.graph_id,
-              value: agent.graph_id
-            }))
-          }
-        ]);
-        langGraphAgent = langGraphAgentChoice;
-      } else if (langGraphAgents.length === 1) {
-        langGraphAgent = langGraphAgents[0].graph_id;
-      } else {
-        throw new Error("No agents found in your LangGraph endpoint");
-      }
-      newEnvValues += `NEXT_PUBLIC_COPILOTKIT_AGENT_NAME=${langGraphAgent}
-`;
-    }
-    if (newEnvValues) {
-      fs.appendFileSync(envFile, newEnvValues);
-    }
-  } catch (error) {
-    throw error;
-  }
-}
-
-// src/lib/init/scaffold/github.ts
-import { execSync } from "child_process";
-import * as fs2 from "fs";
-import * as path2 from "path";
-import * as os from "os";
-import chalk from "chalk";
-async function cloneGitHubSubdirectory(githubUrl, destinationPath, spinner) {
-  try {
-    const { owner, repo, branch, subdirectoryPath } = parseGitHubUrl(githubUrl);
-    spinner.text = chalk.cyan(`Cloning from ${owner}/${repo}...`);
-    return await sparseCheckout(
-      owner,
-      repo,
-      branch,
-      subdirectoryPath,
-      destinationPath,
-      spinner
-    );
-  } catch (error) {
-    spinner.text = chalk.red(`Failed to clone from GitHub: ${error}`);
-    return false;
-  }
-}
-async function sparseCheckout(owner, repo, branch, subdirectoryPath, destinationPath, spinner) {
-  const tempDir = fs2.mkdtempSync(path2.join(os.tmpdir(), "copilotkit-sparse-"));
-  try {
-    spinner.text = chalk.cyan("Creating temporary workspace...");
-    execSync("git init", { cwd: tempDir, stdio: "pipe" });
-    spinner.text = chalk.cyan("Connecting to repository...");
-    execSync(`git remote add origin https://github.com/${owner}/${repo}.git`, {
-      cwd: tempDir,
-      stdio: "pipe"
-    });
-    execSync("git config core.sparseCheckout true", {
-      cwd: tempDir,
-      stdio: "pipe"
-    });
-    fs2.writeFileSync(
-      path2.join(tempDir, ".git/info/sparse-checkout"),
-      subdirectoryPath
-    );
-    spinner.text = chalk.cyan("Downloading agent files...");
-    execSync(`git pull origin ${branch} --depth=1`, {
-      cwd: tempDir,
-      stdio: "pipe"
-    });
-    const sourcePath = path2.join(tempDir, subdirectoryPath);
-    if (!fs2.existsSync(sourcePath)) {
-      throw new Error(
-        `Subdirectory '${subdirectoryPath}' not found in the repository.`
-      );
-    }
-    fs2.mkdirSync(destinationPath, { recursive: true });
-    spinner.text = chalk.cyan("Installing agent files...");
-    await copyDirectoryAsync(sourcePath, destinationPath);
-    return true;
-  } finally {
-    try {
-      fs2.rmSync(tempDir, { recursive: true, force: true });
-    } catch (error) {
-      console.warn(`Failed to clean up temporary directory: ${error}`);
-    }
-  }
-}
-async function copyDirectoryAsync(source, destination) {
-  if (!fs2.existsSync(destination)) {
-    fs2.mkdirSync(destination, { recursive: true });
-  }
-  const entries = fs2.readdirSync(source, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = path2.join(source, entry.name);
-    const destPath = path2.join(destination, entry.name);
-    if (entry.isDirectory()) {
-      await copyDirectoryAsync(srcPath, destPath);
-    } else {
-      fs2.copyFileSync(srcPath, destPath);
-    }
-    if (entries.length > 10) {
-      await new Promise((resolve) => setTimeout(resolve, 1));
-    }
-  }
-}
-function parseGitHubUrl(githubUrl) {
-  const url = new URL(githubUrl);
-  if (url.hostname !== "github.com") {
-    throw new Error("Only GitHub URLs are supported");
-  }
-  const pathParts = url.pathname.split("/").filter(Boolean);
-  if (pathParts.length < 2) {
-    throw new Error("Invalid GitHub URL format");
-  }
-  const owner = pathParts[0];
-  const repo = pathParts[1];
-  let branch = "main";
-  let subdirectoryPath = "";
-  if (pathParts.length > 3 && (pathParts[2] === "tree" || pathParts[2] === "blob")) {
-    branch = pathParts[3];
-    subdirectoryPath = pathParts.slice(4).join("/");
-  }
-  return { owner, repo, branch, subdirectoryPath };
-}
-function isValidGitHubUrl(url) {
-  try {
-    const parsedUrl = new URL(url);
-    return parsedUrl.hostname === "github.com" && parsedUrl.pathname.split("/").filter(Boolean).length >= 2;
-  } catch {
-    return false;
-  }
-}
-
-// src/lib/init/scaffold/packages.ts
-import spawn2 from "cross-spawn";
-import chalk2 from "chalk";
-import fs3 from "fs";
-import ora from "ora";
-async function scaffoldPackages(userAnswers) {
-  const spinner = ora({
-    text: chalk2.cyan("Preparing to install packages..."),
-    color: "cyan"
-  }).start();
-  try {
-    const packages = [
-      `@copilotkit/react-ui@${userAnswers.copilotKitVersion}`,
-      `@copilotkit/react-core@${userAnswers.copilotKitVersion}`,
-      `@copilotkit/runtime@${userAnswers.copilotKitVersion}`
-    ];
-    await new Promise((resolve) => setTimeout(resolve, 50));
-    const packageManager = detectPackageManager();
-    const installCommand = detectInstallCommand(packageManager);
-    spinner.text = chalk2.cyan(`Using ${packageManager} to install packages...`);
-    spinner.stop();
-    console.log(chalk2.cyan("\n\u2699\uFE0F  Installing packages...\n"));
-    const result = spawn2.sync(packageManager, [installCommand, ...packages], {
-      stdio: "inherit"
-      // This ensures stdin/stdout/stderr are all passed through
-    });
-    if (result.status !== 0) {
-      throw new Error(
-        `Package installation process exited with code ${result.status}`
-      );
-    }
-    spinner.start();
-    spinner.succeed(chalk2.green("CopilotKit packages installed successfully"));
-  } catch (error) {
-    if (!spinner.isSpinning) {
-      spinner.start();
-    }
-    spinner.fail(chalk2.red("Failed to install CopilotKit packages"));
-    throw error;
-  }
-}
-function detectPackageManager() {
-  const files = fs3.readdirSync(process.cwd());
-  if (files.includes("bun.lockb")) return "bun";
-  if (files.includes("pnpm-lock.yaml")) return "pnpm";
-  if (files.includes("yarn.lock")) return "yarn";
-  if (files.includes("package-lock.json")) return "npm";
-  return "npm";
-}
-function detectInstallCommand(packageManager) {
-  switch (packageManager) {
-    case "yarn":
-    case "pnpm":
-      return "add";
-    default:
-      return "install";
-  }
-}
-
-// src/lib/init/scaffold/agent.ts
-import ora2 from "ora";
-import chalk3 from "chalk";
-import path3 from "path";
-import fs4 from "fs";
-async function scaffoldAgent(userAnswers) {
-  if (userAnswers.mode === "CrewAI" || userAnswers.mode === "LangGraph" && !userAnswers.langGraphAgent || userAnswers.mode === "Standard" || userAnswers.mode === "MCP") {
-    return;
-  }
-  const spinner = ora2({
-    text: chalk3.cyan("Setting up AI agent..."),
-    color: "cyan"
-  }).start();
-  let template = "";
-  switch (userAnswers.mode) {
-    case "LangGraph":
-      if (userAnswers.langGraphAgent === "Python Starter") {
-        template = AgentTemplates.LangGraph.Starter.Python;
-      } else {
-        template = AgentTemplates.LangGraph.Starter.TypeScript;
-      }
-      break;
-  }
-  if (!template) {
-    spinner.fail(chalk3.red("Failed to determine agent template"));
-    throw new Error("Failed to determine agent template");
-  }
-  const agentDir = path3.join(process.cwd(), "agent");
-  try {
-    await cloneGitHubSubdirectory(template, agentDir, spinner);
-    spinner.text = chalk3.cyan("Creating agent environment variables...");
-    let envContent = "";
-    if (userAnswers.llmToken) {
-      envContent += `OPENAI_API_KEY=${userAnswers.llmToken}
-`;
-    }
-    if (userAnswers.mode === "LangGraph" && userAnswers.langSmithApiKey) {
-      envContent += `LANGSMITH_API_KEY=${userAnswers.langSmithApiKey}
-`;
-    }
-    if (envContent) {
-      const agentEnvFile = path3.join(agentDir, ".env");
-      fs4.writeFileSync(agentEnvFile, envContent, "utf8");
-      spinner.text = chalk3.cyan("Added API keys to agent .env file");
-    }
-  } catch (error) {
-    spinner.fail(chalk3.red("Failed to clone agent template"));
-    throw error;
-  }
-  spinner.succeed(`${userAnswers.mode} agent cloned successfully`);
-}
-var AgentTemplates = {
-  LangGraph: {
-    Starter: {
-      Python: "https://github.com/CopilotKit/CopilotKit/tree/main/examples/starters/coagents-langgraph/agent-py",
-      TypeScript: "https://github.com/CopilotKit/CopilotKit/tree/main/examples/starters/coagents-langgraph/agent-js"
-    }
-  },
-  CrewAI: {
-    Flows: {
-      Starter: "https://github.com/CopilotKit/CopilotKit/tree/main/examples/starters/coagents-crewai-flows/agent-py"
-    }
-  }
-};
-
-// src/lib/init/scaffold/crew-inputs.ts
-import * as fs5 from "fs/promises";
-import ora3 from "ora";
-import * as path4 from "path";
-async function addCrewInputs(url, token) {
-  try {
-    const spinner = ora3("Analyzing crew inputs...").start();
-    const inputs = await getCrewInputs(url, token);
-    spinner.text = "Adding inputs to app/copilotkit/page.tsx...";
-    let filePath = path4.join(process.cwd(), "app", "copilotkit", "page.tsx");
-    try {
-      await fs5.access(filePath);
-    } catch {
-      filePath = path4.join(
-        process.cwd(),
-        "src",
-        "app",
-        "copilotkit",
-        "page.tsx"
-      );
-    }
-    try {
-      await fs5.access(filePath);
-    } catch {
-      throw new Error(
-        "app/copilotkit/page.tsx and src/app/copilotkit/page.tsx not found"
-      );
-    }
-    let fileContent = await fs5.readFile(filePath, "utf8");
-    const inputsString = JSON.stringify(inputs);
-    fileContent = fileContent.replace(
-      /\[["']YOUR_INPUTS_HERE["']\]/g,
-      inputsString
-    );
-    await fs5.writeFile(filePath, fileContent, "utf8");
-    spinner.succeed(
-      "Successfully added crew inputs to app/copilotkit/page.tsx"
-    );
-  } catch (error) {
-    console.error("Error updating crew inputs:", error);
-    throw error;
-  }
-}
-async function getCrewInputs(url, token) {
-  const response = await fetch(`${url.trim()}/inputs`, {
-    headers: {
-      Authorization: `Bearer ${token}`
-    }
-  });
-  if (!response.ok) {
-    throw new Error(`Failed to fetch inputs: ${response.statusText}`);
-  }
-  const data = await response.json();
-  return data.inputs;
-}
-export {
-  AgentTemplates,
-  addCrewInputs,
-  cloneGitHubSubdirectory,
-  isValidGitHubUrl,
-  scaffoldAgent,
-  scaffoldEnv,
-  scaffoldPackages,
-  scaffoldShadCN
-};
-//# sourceMappingURL=index.js.map