copilotkit 0.0.13 → 0.0.14

package/dist/commands/init.js

@@ -0,0 +1,856 @@
+// src/commands/init.ts
+import { Flags as Flags2 } from "@oclif/core";
+import inquirer2 from "inquirer";
+import path3 from "path";
+import fs3 from "fs";
+
+// src/services/auth.service.ts
+import Conf2 from "conf";
+import cors from "cors";
+import express from "express";
+import crypto2 from "node:crypto";
+import open from "open";
+import getPort from "get-port";
+import ora from "ora";
+import chalk from "chalk";
+import inquirer from "inquirer";
+
+// src/utils/trpc.ts
+import { createTRPCClient as createTRPClient_, unstable_httpBatchStreamLink } from "@trpc/client";
+import superjson from "superjson";
+var COPILOT_CLOUD_BASE_URL = process.env.COPILOT_CLOUD_BASE_URL || "https://cloud.copilotkit.ai";
+function createTRPCClient(cliToken) {
+  return createTRPClient_({
+    links: [
+      unstable_httpBatchStreamLink({
+        transformer: superjson,
+        url: `${COPILOT_CLOUD_BASE_URL}/api/trpc-cli`,
+        headers: () => {
+          const headers = new Headers();
+          headers.set("x-trpc-source", "cli");
+          headers.set("x-cli-token", cliToken);
+          return headers;
+        }
+      })
+    ]
+  });
+}
+
+// src/services/analytics.service.ts
+import { Analytics } from "@segment/analytics-node";
+import Conf from "conf";
+var AnalyticsService = class {
+  constructor(authData) {
+    this.authData = authData;
+    if (process.env.SEGMENT_DISABLED === "true") {
+      return;
+    }
+    const segmentWriteKey = process.env.SEGMENT_WRITE_KEY || "9Pv6QyExYef2P4hPz4gks6QAvNMi2AOf";
+    this.globalProperties = {
+      service: "cli"
+    };
+    if (this.authData?.userId) {
+      this.userId = this.authData.userId;
+    }
+    if (this.authData?.email) {
+      this.email = this.authData.email;
+      this.globalProperties.email = this.authData.email;
+    }
+    if (this.authData?.organizationId) {
+      this.organizationId = this.authData.organizationId;
+    }
+    this.segment = new Analytics({
+      writeKey: segmentWriteKey,
+      disable: process.env.SEGMENT_DISABLE === "true"
+    });
+    const config = new Conf({ projectName: "CopilotKitCLI" });
+    if (!config.get("anonymousId")) {
+      config.set("anonymousId", crypto.randomUUID());
+    }
+  }
+  segment;
+  globalProperties = {};
+  userId;
+  email;
+  organizationId;
+  config = new Conf({ projectName: "CopilotKitCLI" });
+  getAnonymousId() {
+    const anonymousId = this.config.get("anonymousId");
+    if (!anonymousId) {
+      const anonymousId2 = crypto.randomUUID();
+      this.config.set("anonymousId", anonymousId2);
+      return anonymousId2;
+    }
+    return anonymousId;
+  }
+  track(event) {
+    if (!this.segment) {
+      return Promise.resolve();
+    }
+    const payload = {
+      userId: this.userId ? this.userId : void 0,
+      email: this.email ? this.email : void 0,
+      anonymousId: this.getAnonymousId(),
+      event: event.event,
+      properties: {
+        ...this.globalProperties,
+        ...event.properties,
+        $groups: this.organizationId ? {
+          segment_group: this.organizationId
+        } : void 0,
+        eventProperties: {
+          ...event.properties,
+          ...this.globalProperties
+        }
+      }
+    };
+    return new Promise((resolve, reject) => {
+      this.segment.track(payload, (err) => {
+        if (err) {
+          resolve();
+        }
+        resolve();
+      });
+    });
+  }
+};
+
+// src/services/auth.service.ts
+var AuthService = class {
+  config = new Conf2({ projectName: "CopilotKitCLI" });
+  COPILOT_CLOUD_BASE_URL = process.env.COPILOT_CLOUD_BASE_URL || "https://cloud.copilotkit.ai";
+  getToken() {
+    return this.config.get("cliToken");
+  }
+  getCLIToken() {
+    const cliToken = this.config.get("cliToken");
+    return cliToken;
+  }
+  async logout(cmd) {
+    this.config.delete("cliToken");
+  }
+  async requireLogin(cmd) {
+    let cliToken = this.getCLIToken();
+    if (!cliToken) {
+      try {
+        const { shouldLogin } = await inquirer.prompt([
+          {
+            name: "shouldLogin",
+            type: "confirm",
+            message: "You are not yet authenticated. Authenticate with Copilot Cloud? (press Enter to confirm)",
+            default: true
+          }
+        ]);
+        if (shouldLogin) {
+          const loginResult = await this.login({ exitAfterLogin: false });
+          cliToken = loginResult.cliToken;
+          cmd.log(`\u{1FA81} Logged in as ${chalk.hex("#7553fc")(loginResult.user.email)}
+`);
+          return loginResult;
+        } else {
+          cmd.error("Authentication required to proceed.");
+        }
+      } catch (error) {
+        if (error instanceof Error && error.name === "ExitPromptError") {
+          cmd.error(chalk.yellow("\nAuthentication cancelled"));
+        }
+        throw error;
+      }
+    }
+    let me;
+    const trpcClient = createTRPCClient(cliToken);
+    try {
+      me = await trpcClient.me.query();
+    } catch (error) {
+      cmd.log(chalk.red("Could not authenticate with Copilot Cloud. Please try again."));
+      process.exit(1);
+    }
+    if (!me.organization || !me.user) {
+      cmd.error("Authentication required to proceed.");
+    }
+    return { cliToken, user: me.user, organization: me.organization };
+  }
+  async login({ exitAfterLogin } = { exitAfterLogin: true }) {
+    let analytics;
+    analytics = new AnalyticsService();
+    const app = express();
+    app.use(cors());
+    app.use(express.urlencoded({ extended: true }));
+    app.use(express.json());
+    const port = await getPort();
+    const state = crypto2.randomBytes(16).toString("hex");
+    return new Promise(async (resolve) => {
+      const server = app.listen(port, () => {
+      });
+      await analytics.track({
+        event: "cli.login.initiated",
+        properties: {}
+      });
+      const spinner = ora("Waiting for browser authentication to complete...\n").start();
+      app.post("/callback", async (req, res) => {
+        const { cliToken, user, organization } = req.body;
+        analytics = new AnalyticsService({ userId: user.id, organizationId: organization.id, email: user.email });
+        await analytics.track({
+          event: "cli.login.success",
+          properties: {
+            organizationId: organization.id,
+            userId: user.id,
+            email: user.email
+          }
+        });
+        if (state !== req.query.state) {
+          res.status(401).json({ message: "Invalid state" });
+          spinner.fail("Invalid state");
+          return;
+        }
+        this.config.set("cliToken", cliToken);
+        res.status(200).json({ message: "Callback called" });
+        spinner.succeed(`\u{1FA81} Successfully logged in as ${chalk.hex("#7553fc")(user.email)}
+`);
+        if (exitAfterLogin) {
+          process.exit(0);
+        } else {
+          server.close();
+          resolve({ cliToken, user, organization });
+        }
+      });
+      open(`${this.COPILOT_CLOUD_BASE_URL}/cli-auth?callbackUrl=http://localhost:${port}/callback&state=${state}`);
+    });
+  }
+};
+
+// src/commands/base-command.ts
+import { Command } from "@oclif/core";
+import Sentry, { consoleIntegration } from "@sentry/node";
+
+// src/utils/version.ts
+var LIB_VERSION = "0.0.14";
+
+// src/commands/base-command.ts
+import chalk2 from "chalk";
+var BaseCommand = class extends Command {
+  async init() {
+    await this.checkCLIVersion();
+    if (process.env.SENTRY_DISABLED === "true") {
+      return;
+    }
+    Sentry.init({
+      dsn: process.env.SENTRY_DSN || "https://1eea15d32e2eacb0456a77db5e39aeeb@o4507288195170304.ingest.us.sentry.io/4508581448581120",
+      integrations: [
+        consoleIntegration()
+      ],
+      // Tracing
+      tracesSampleRate: 1
+      //  Capture 100% of the transactions
+    });
+  }
+  async catch(err) {
+    if (process.env.SENTRY_DISABLED === "true") {
+      super.catch(err);
+      return;
+    }
+    Sentry.captureException(err);
+    super.catch(err);
+  }
+  async finally() {
+    if (process.env.SENTRY_DISABLED === "true") {
+      return;
+    }
+    Sentry.close();
+  }
+  async run() {
+  }
+  async checkCLIVersion() {
+    const response = await fetch(`${COPILOT_CLOUD_BASE_URL}/api/healthz`);
+    const data = await response.json();
+    const cloudVersion = data.cliVersion;
+    if (!cloudVersion || cloudVersion === LIB_VERSION) {
+      return;
+    }
+    this.log(chalk2.yellow("================ New version available! =================\n"));
+    this.log(`You are using CopilotKit CLI v${LIB_VERSION}.`);
+    this.log(`A new CopilotKit CLI version is available (v${cloudVersion}).
+`);
+    this.log("Please update your CLI to the latest version:\n\n");
+    this.log(`${chalk2.cyan(chalk2.underline(chalk2.bold("npm:")))}	 npm install -g copilotkit@${cloudVersion}
+`);
+    this.log(`${chalk2.cyan(chalk2.underline(chalk2.bold("pnpm:")))}	 pnpm install -g copilotkit@${cloudVersion}
+`);
+    this.log(`${chalk2.cyan(chalk2.underline(chalk2.bold("yarn:")))}	 yarn global add copilotkit@${cloudVersion}
+`);
+    this.log(chalk2.yellow("============================================================\n\n"));
+  }
+  async gracefulError(message) {
+    this.log("\n" + chalk2.red(message));
+    process.exit(1);
+  }
+};
+
+// src/lib/init/types/questions.ts
+import { Flags } from "@oclif/core";
+var AGENT_FRAMEWORKS = ["CrewAI", "LangGraph", "None"];
+var CREW_TYPES = ["Crews", "Flows"];
+var CHAT_COMPONENTS = ["CopilotChat", "CopilotSidebar", "Headless", "CopilotPopup"];
+var LANGGRAPH_AGENTS = ["Python Starter", "TypeScript Starter", "None"];
+var ConfigFlags = {
+  copilotKitVersion: Flags.string({ description: "CopilotKit version to use (e.g. 1.7.0)" }),
+  agentFramework: Flags.string({ description: "Agent framework to power your copilot", options: AGENT_FRAMEWORKS }),
+  fastApiEnabled: Flags.string({ description: "Use FastAPI to serve your agent locally", options: ["Yes", "No"] }),
+  useCopilotCloud: Flags.string({ description: "Use Copilot Cloud for production-ready hosting", options: ["Yes", "No"] }),
+  chatUi: Flags.string({ description: "Chat UI component to add to your app", options: CHAT_COMPONENTS }),
+  langGraphAgent: Flags.string({ description: "LangGraph agent template to use", options: LANGGRAPH_AGENTS }),
+  crewType: Flags.string({ description: "CrewAI implementation type", options: CREW_TYPES }),
+  crewName: Flags.string({ description: "Name for your CrewAI agent" }),
+  crewUrl: Flags.string({ description: "URL endpoint for your CrewAI agent" }),
+  crewBearerToken: Flags.string({ description: "Bearer token for CrewAI authentication" }),
+  langSmithApiKey: Flags.string({ description: "LangSmith API key for LangGraph observability" }),
+  llmToken: Flags.string({ description: "API key for your preferred LLM provider" })
+};
+
+// src/lib/init/types/templates.ts
+var BASE_URL = "http://registry.copilotkit.ai/r";
+var templateMapping = {
+  "LangGraphPlatform": `${BASE_URL}/langgraph-platform-starter.json`,
+  "RemoteEndpoint": `${BASE_URL}/remote-endpoint-starter.json`,
+  "CrewEnterprise": `${BASE_URL}/agent-layout.json`,
+  "Standard": `${BASE_URL}/standard-starter.json`,
+  "CopilotChat": `${BASE_URL}/chat.json`,
+  "CopilotPopup": `${BASE_URL}/popup.json`,
+  "CopilotSidebar": `${BASE_URL}/sidebar.json`
+};
+
+// src/lib/init/questions.ts
+var questions = [
+  // Core setup questions - always shown first
+  {
+    type: "select",
+    name: "agentFramework",
+    message: "\u{1F916} Choose your AI framework:",
+    choices: Array.from(AGENT_FRAMEWORKS)
+  },
+  // CrewAI specific questions - shown when CrewAI selected
+  {
+    type: "select",
+    name: "crewType",
+    message: "\u{1F4CB} Select CrewAI implementation type:",
+    choices: Array.from(CREW_TYPES),
+    when: (answers) => answers.agentFramework === "CrewAI"
+  },
+  {
+    type: "input",
+    name: "crewName",
+    message: "\u{1F465} What would you like to name your crew?",
+    when: (answers) => answers.agentFramework === "CrewAI" && answers.crewType === "Crews",
+    default: "MyCopilotCrew"
+  },
+  {
+    type: "input",
+    name: "crewUrl",
+    message: "\u{1F517} Enter your Crew API endpoint:",
+    when: (answers) => answers.agentFramework === "CrewAI" && answers.crewType === "Crews"
+  },
+  {
+    type: "input",
+    name: "crewBearerToken",
+    message: "\u{1F511} Enter your Crew authentication token:",
+    when: (answers) => answers.agentFramework === "CrewAI" && answers.crewType === "Crews"
+  },
+  // LangGraph specific questions - shown when LangGraph selected
+  {
+    type: "yes/no",
+    name: "alreadyDeployed",
+    message: "\u{1F680} Is your LangGraph agent already deployed?",
+    when: (answers) => answers.agentFramework === "LangGraph"
+  },
+  {
+    type: "yes/no",
+    name: "langGraphPlatform",
+    message: "\u{1F99C}\u{1F517} Is it hosted on LangGraph Platform?",
+    when: (answers) => answers.agentFramework === "LangGraph" && answers.alreadyDeployed === "Yes"
+  },
+  {
+    type: "input",
+    name: "langGraphPlatformUrl",
+    message: "\u{1F99C}\u{1F517} Enter your LangGraph platform URL:",
+    when: (answers) => answers.agentFramework === "LangGraph" && answers.alreadyDeployed === "Yes" && answers.langGraphPlatform === "Yes"
+  },
+  {
+    type: "input",
+    name: "langGraphRemoteEndpointURL",
+    message: "\u{1F50C} Enter your LangGraph endpoint URL:",
+    when: (answers) => answers.agentFramework === "LangGraph" && answers.alreadyDeployed === "Yes" && answers.langGraphPlatform === "No"
+  },
+  {
+    type: "select",
+    name: "langGraphAgent",
+    message: "\u{1F4E6} Choose a LangGraph starter template:",
+    choices: Array.from(LANGGRAPH_AGENTS),
+    when: (answers) => answers.agentFramework === "LangGraph" && answers.alreadyDeployed === "No"
+  },
+  {
+    type: "input",
+    name: "langSmithApiKey",
+    message: "\u{1F99C}\u{1F517} Enter your LangSmith API key (required by LangGraph Platform) :",
+    when: (answers) => answers.agentFramework === "LangGraph" && answers.alreadyDeployed === "No"
+  },
+  // Deployment options
+  {
+    type: "yes/no",
+    name: "useCopilotCloud",
+    message: "\u{1FA81} Deploy with Copilot Cloud? (recommended for production)",
+    when: (answers) => !(answers.agentFramework === "CrewAI" && answers.crewType === "Crews")
+  },
+  {
+    type: "yes/no",
+    name: "fastApiEnabled",
+    message: "\u26A1 Set up a FastAPI server for local development?",
+    when: (answers) => answers.agentFramework === "LangGraph" && answers.alreadyDeployed === "No" && answers.langGraphAgent === "Python Starter" && answers.useCopilotCloud !== "Yes"
+  },
+  // UI components - always shown last
+  {
+    type: "select",
+    name: "chatUi",
+    message: "\u{1F4AC} Select a UI component for your copilot:",
+    choices: Array.from(CHAT_COMPONENTS),
+    default: "CopilotChat"
+  }
+];
+
+// src/lib/init/scaffold/shadcn.ts
+import spawn from "cross-spawn";
+async function scaffoldShadCN(userAnswers) {
+  try {
+    const components = [
+      templateMapping[userAnswers.chatUi]
+    ];
+    if (userAnswers.agentFramework !== "None") {
+      switch (userAnswers.agentFramework) {
+        case "LangGraph":
+          components.push(templateMapping.LangGraphPlatform);
+          break;
+        case "CrewAI":
+          if (userAnswers.crewType === "Crews") {
+            components.push(templateMapping.CrewEnterprise);
+          } else {
+            components.push(templateMapping.RemoteEndpoint);
+          }
+          break;
+        default:
+          components.push(templateMapping.RemoteEndpoint);
+          break;
+      }
+    }
+    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";
+import chalk3 from "chalk";
+import ora2 from "ora";
+async function scaffoldEnv(flags, userAnswers) {
+  const spinner = ora2({
+    text: chalk3.cyan("Configuring environment variables..."),
+    color: "cyan"
+  }).start();
+  try {
+    const envFile = path.join(process.cwd(), ".env");
+    if (!fs.existsSync(envFile)) {
+      fs.writeFileSync(envFile, "", "utf8");
+      spinner.text = chalk3.cyan("Created .env file...");
+    } else {
+      spinner.text = chalk3.cyan("Updating existing .env file...");
+    }
+    let newEnvValues = "";
+    let varsAdded = false;
+    if (userAnswers.copilotCloudPublicApiKey) {
+      newEnvValues += `NEXT_PUBLIC_COPILOT_API_KEY=${userAnswers.copilotCloudPublicApiKey}
+`;
+      spinner.text = chalk3.cyan("Adding Copilot Cloud API key...");
+      varsAdded = true;
+    }
+    if (userAnswers.langSmithApiKey) {
+      newEnvValues += `LANG_SMITH_API_KEY=${userAnswers.langSmithApiKey}
+`;
+      spinner.text = chalk3.cyan("Adding LangSmith API key...");
+      varsAdded = true;
+    }
+    if (userAnswers.llmToken) {
+      newEnvValues += `LLM_TOKEN=${userAnswers.llmToken}
+`;
+      spinner.text = chalk3.cyan("Adding LLM token...");
+      varsAdded = true;
+    }
+    if (userAnswers.crewName) {
+      newEnvValues += `NEXT_PUBLIC_COPILOTKIT_AGENT_NAME=${userAnswers.crewName}
+`;
+      spinner.text = chalk3.cyan("Adding Crew agent name...");
+      varsAdded = true;
+    }
+    if (flags.runtimeUrl) {
+      newEnvValues += `NEXT_PUBLIC_COPILOTKIT_RUNTIME_URL=${flags.runtimeUrl}
+`;
+      spinner.text = chalk3.cyan("Adding runtime URL...");
+      varsAdded = true;
+    }
+    if (!varsAdded) {
+      spinner.text = chalk3.cyan("No environment variables needed...");
+    }
+    if (newEnvValues) {
+      fs.appendFileSync(envFile, newEnvValues);
+      spinner.succeed(chalk3("Environment variables configured successfully"));
+    } else {
+      spinner.info(chalk3.yellow("No environment variables were added"));
+    }
+  } catch (error) {
+    spinner.fail(chalk3.red("Failed to update environment variables"));
+    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 chalk4 from "chalk";
+import ora3 from "ora";
+async function scaffoldAgent(userAnswers) {
+  if (userAnswers.agentFramework === "None" || userAnswers.agentFramework === "CrewAI" && userAnswers.crewType === "Crews" || userAnswers.agentFramework === "LangGraph" && (!userAnswers.langGraphAgent || userAnswers.langGraphAgent === "None")) {
+    return;
+  }
+  const spinner = ora3({
+    text: chalk4.cyan("Setting up AI agent..."),
+    color: "cyan"
+  }).start();
+  try {
+    if (userAnswers.agentFramework === "LangGraph") {
+      switch (userAnswers.langGraphAgent) {
+        case "Python Starter":
+          spinner.text = chalk4.cyan("Setting up Python LangGraph agent...");
+          await new Promise((resolve) => setTimeout(resolve, 50));
+          await cloneGitHubSubdirectory(
+            "https://github.com/CopilotKit/CopilotKit/tree/main/examples/coagents-starter/agent-py",
+            path2.join(process.cwd(), "agent"),
+            spinner
+          );
+          break;
+        case "TypeScript Starter":
+          spinner.text = chalk4.cyan("Setting up TypeScript LangGraph agent...");
+          await new Promise((resolve) => setTimeout(resolve, 50));
+          await cloneGitHubSubdirectory(
+            "https://github.com/CopilotKit/CopilotKit/tree/main/examples/coagents-starter/agent-js",
+            path2.join(process.cwd(), "agent"),
+            spinner
+          );
+          break;
+        default:
+          break;
+      }
+    } else if (userAnswers.agentFramework === "CrewAI" && userAnswers.crewType === "Flows") {
+      spinner.text = chalk4.cyan("Setting up CrewAI Flows agent...");
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      spinner.info(chalk4.yellow("CrewAI Flows support is coming soon..."));
+    }
+    spinner.succeed(chalk4.green("AI agent setup complete"));
+  } catch (error) {
+    spinner.fail(chalk4.red("Failed to set up AI agent"));
+    throw error;
+  }
+}
+async function cloneGitHubSubdirectory(githubUrl, destinationPath, spinner) {
+  try {
+    const { owner, repo, branch, subdirectoryPath } = parseGitHubUrl(githubUrl);
+    spinner.text = chalk4.cyan(`Cloning from ${owner}/${repo}...`);
+    return await sparseCheckout(owner, repo, branch, subdirectoryPath, destinationPath, spinner);
+  } catch (error) {
+    spinner.text = chalk4.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 = chalk4.cyan("Creating temporary workspace...");
+    execSync("git init", { cwd: tempDir, stdio: "pipe" });
+    spinner.text = chalk4.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 = chalk4.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 = chalk4.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 };
+}
+
+// src/lib/init/scaffold/packages.ts
+import spawn2 from "cross-spawn";
+import chalk5 from "chalk";
+import ora4 from "ora";
+
+// src/commands/init.ts
+import chalk6 from "chalk";
+import ora5 from "ora";
+var CloudInit = class _CloudInit extends BaseCommand {
+  constructor(argv, config, authService = new AuthService()) {
+    super(argv, config);
+    this.authService = authService;
+  }
+  trpcClient = null;
+  static description = "Set up CopilotKit in your Next.js project";
+  static examples = [
+    "<%= config.bin %> init"
+  ];
+  static flags = {
+    ...BaseCommand.flags,
+    ...ConfigFlags,
+    runtimeUrl: Flags2.string({ description: "runtime URL" }),
+    project: Flags2.string({ description: "project ID (can be found in the Copilot Cloud dashboard)" }),
+    dir: Flags2.string({ description: "directory of the Next.js project", default: "." })
+  };
+  async run() {
+    const { flags } = await this.parse(_CloudInit);
+    try {
+      this.log(chalk6.bold(chalk6.cyan("\n\u{1FA81} Welcome to CopilotKit")));
+      this.log(chalk6.gray("Let's power up your Next.js project with AI capabilities\n"));
+      this.validateProjectCompatibility(flags);
+      const userAnswers = await this.getUserAnswers();
+      const needsCloudSetup = userAnswers.useCopilotCloud === "Yes" || userAnswers.agentFramework === "CrewAI" && userAnswers.crewType === "Crews";
+      if (needsCloudSetup) {
+        await this.setupCloud(flags, userAnswers);
+      }
+      await scaffoldShadCN(userAnswers);
+      await scaffoldAgent(userAnswers);
+      await scaffoldEnv(flags, userAnswers);
+      this.finalSummary(userAnswers);
+    } catch (error) {
+      this.gracefulError(error.message);
+    }
+  }
+  async getUserAnswers() {
+    const inquirerQuestions = questions.map((q) => {
+      const baseQuestion = {
+        name: q.name,
+        message: q.message,
+        when: q.when,
+        default: q.default
+      };
+      switch (q.type) {
+        case "yes/no":
+          return {
+            ...baseQuestion,
+            type: "list",
+            choices: ["Yes", "No"]
+          };
+        case "select":
+          return {
+            ...baseQuestion,
+            type: "list",
+            choices: q.choices
+          };
+        case "input":
+        default:
+          return {
+            ...baseQuestion,
+            type: "input"
+          };
+      }
+    });
+    const answers = await inquirer2.prompt(inquirerQuestions);
+    return answers;
+  }
+  async setupCloud(flags, userAnswers) {
+    const spinner = ora5({
+      text: chalk6("\u{1F511} Authenticating for Copilot Cloud..."),
+      color: "cyan"
+    }).start();
+    const { cliToken, organization, user } = await this.authService.requireLogin(this);
+    const analytics = new AnalyticsService({ userId: user.id, organizationId: organization.id, email: user.email });
+    spinner.succeed(chalk6("\u{1F511} Authenticated for Copilot Cloud"));
+    await analytics.track({
+      event: "cli.init.cloud_used",
+      properties: { userId: user.id }
+    });
+    this.trpcClient = createTRPCClient(cliToken);
+    const availableProjects = await this.trpcClient.listOrgProjects.query({ orgId: organization.id });
+    let selectedProjectId;
+    if (flags.project) {
+      if (!availableProjects.some((project) => project.id === flags.project)) {
+        this.log(chalk6.red(`\u{1F4C1} Project with ID ${flags.project} not found`));
+        process.exit(1);
+      }
+      selectedProjectId = flags.project;
+      this.log(chalk6.green(`\u{1F4C1} Selected project ${selectedProjectId}`));
+    } else {
+      const { projectId } = await inquirer2.prompt([
+        {
+          name: "projectId",
+          type: "list",
+          message: "Choose a project:",
+          choices: availableProjects.map((project) => ({
+            value: project.id,
+            name: `${project.name} (ID: ${project.id})${availableProjects.length === 1 ? " (press Enter to confirm)" : ""}`
+          }))
+        }
+      ]);
+      selectedProjectId = projectId;
+    }
+    const copilotCloudPublicApiKey = await this.trpcClient.getCopilotCloudPublicApiKey.query({ projectId: selectedProjectId });
+    userAnswers.copilotCloudPublicApiKey = copilotCloudPublicApiKey?.key;
+    if (userAnswers.crewUrl && userAnswers.crewName && userAnswers.crewBearerToken) {
+      const crewSpinner = ora5({
+        text: chalk6("\u{1F465} Adding Crew to Copilot Cloud..."),
+        color: "cyan"
+      }).start();
+      await this.trpcClient.createRemoteEndpoint.mutate({
+        type: "CrewAI",
+        projectId: selectedProjectId,
+        config: {
+          type: "CrewAI",
+          url: userAnswers.crewUrl,
+          agentName: userAnswers.crewName,
+          agentDescription: "A helpful Crew",
+          crewApiBearerToken: userAnswers.crewBearerToken
+        }
+      });
+      crewSpinner.succeed(chalk6("\u{1F465} Crew added to Copilot Cloud"));
+    }
+  }
+  validateProjectCompatibility(flags) {
+    const projectPath = path3.resolve(process.cwd(), flags.dir);
+    if (!fs3.existsSync(projectPath)) {
+      this.gracefulError(`Directory ${flags.dir} does not exist. Please provide a valid Next.js project directory.`);
+      return;
+    }
+    const packageJsonPath = path3.join(projectPath, "package.json");
+    if (!fs3.existsSync(packageJsonPath)) {
+      this.gracefulError(`Directory ${projectPath} does not contain a package.json file. Please provide a valid Next.js project.`);
+      process.exit(1);
+    }
+    const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf8"));
+    if (!packageJson.dependencies?.next && !packageJson.devDependencies?.next) {
+      this.gracefulError(`Directory ${projectPath} does not appear to be a Next.js project. Make sure it has next in dependencies.`);
+      process.exit(1);
+    }
+    this.log(chalk6.green(`Valid Next.js project detected
+`));
+    return true;
+  }
+  finalSummary(userAnswers) {
+    let agentDevInstructions = "";
+    let agentType = "";
+    let agentSetupMessage = "";
+    if (userAnswers.agentFramework !== "None") {
+      if (userAnswers.agentFramework === "LangGraph") {
+        agentType = "LangGraph agent";
+        if (userAnswers.alreadyDeployed === "Yes") {
+          agentSetupMessage = `Using your existing deployed agent.`;
+        } else if (userAnswers.langGraphAgent && userAnswers.langGraphAgent !== "None") {
+          agentSetupMessage = `We've scaffolded a ${chalk6.cyan(userAnswers.langGraphAgent)} agent in the ${chalk6.cyan("./agent")} directory.`;
+          if (userAnswers.langGraphAgent === "Python Starter") {
+            if (userAnswers.fastApiEnabled === "Yes") {
+              agentDevInstructions = "poetry install && poetry run demo";
+            } else {
+              agentDevInstructions = "npx @langchain/langgraph-cli dev --port 8123";
+            }
+          } else if (userAnswers.langGraphAgent === "TypeScript Starter") {
+            agentDevInstructions = "npm i && npm run dev";
+          }
+        }
+      } else if (userAnswers.agentFramework === "CrewAI") {
+        agentType = "CrewAI";
+        if (userAnswers.crewType === "Crews") {
+          agentSetupMessage = `Using your Crew from ${chalk6.cyan(userAnswers.crewUrl || "the provided URL")}.`;
+        } else if (userAnswers.crewType === "Flows") {
+          agentSetupMessage = "CrewAI Flows support is coming soon.";
+        }
+      }
+    }
+    this.log(chalk6.bold(chalk6.cyan("\n\u{1F389} Your CopilotKit setup is complete!\n")));
+    this.log(chalk6.bold("\u{1F4AC} User Interface:"));
+    this.log(chalk6.gray(`We've set up the ${chalk6.cyan(userAnswers.chatUi)} component in your Next.js app.`));
+    if (agentType) {
+      this.log(chalk6.bold(`
+\u{1F916} ${agentType}:`));
+      this.log(chalk6.gray(agentSetupMessage));
+    }
+    this.log(chalk6.bold("\n\u{1F4CB} Next steps:"));
+    this.log(`  ${chalk6.cyan("1.")} Start your Next.js app:`);
+    this.log(`     ${chalk6.gray("$")} ${chalk6.yellow("npm run dev")}`);
+    if (agentDevInstructions) {
+      this.log(`  ${chalk6.cyan("2.")} Start your agent:`);
+      this.log(`     ${chalk6.gray("$")} ${chalk6.yellow(`cd agent && ${agentDevInstructions}`)}`);
+    }
+    this.log(chalk6.bold("\n\u{1F4DA} Documentation:"));
+    this.log(`  ${chalk6.blue("https://docs.copilotkit.ai")}`);
+    this.log("");
+  }
+};
+export {
+  CloudInit as default
+};
+//# sourceMappingURL=init.js.map