copilotkit 1.54.0 → 2.0.0

package/dist/commands/dev.js

@@ -1,776 +0,0 @@
-// src/commands/dev.ts
-import { Flags } from "@oclif/core";
-import inquirer2 from "inquirer";
-import { createId } from "@paralleldrive/cuid2";
-import ora2 from "ora";
-import chalk3 from "chalk";
-
-// src/services/auth.service.ts
-import Conf2 from "conf";
-import cors from "cors";
-import express from "express";
-import crypto2 from "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 trpcClient, httpBatchLink } 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 trpcClient({
-    links: [
-      httpBatchLink({
-        url: `${COPILOT_CLOUD_BASE_URL}/api/trpc-cli`,
-        transformer: superjson,
-        headers: () => {
-          return {
-            "x-trpc-source": "cli",
-            "x-cli-token": cliToken
-          };
-        }
-      })
-    ]
-  });
-}
-
-// src/services/analytics.service.ts
-import { Analytics } from "@segment/analytics-node";
-import { PostHog } from "posthog-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"
-    });
-    if (process.env.POSTHOG_DISABLED !== "true") {
-      const posthogKey = process.env.POSTHOG_KEY || "phc_XZdymVYjrph9Mi0xZYGNyCKexxgblXRR1jMENCtdz5Q";
-      const posthogHost = process.env.POSTHOG_HOST || "https://eu.i.posthog.com";
-      this.posthog = new PostHog(posthogKey, {
-        host: posthogHost
-      });
-    }
-    const config = new Conf({ projectName: "CopilotKitCLI" });
-    if (!config.get("anonymousId")) {
-      config.set("anonymousId", crypto.randomUUID());
-    }
-  }
-  segment;
-  posthog;
-  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();
-      });
-    });
-  }
-  /**
-   * Check if a feature flag is enabled
-   */
-  async isFeatureEnabled(flagKey) {
-    if (!this.posthog) {
-      return false;
-    }
-    try {
-      const distinctId = this.userId || this.getAnonymousId();
-      const flag = await this.posthog.isFeatureEnabled(flagKey, distinctId);
-      return Boolean(flag);
-    } catch (error) {
-      console.warn(`Failed to check feature flag ${flagKey}:`, error);
-      return false;
-    }
-  }
-  /**
-   * Get feature flag payload
-   */
-  async getFeatureFlagPayload(flagKey) {
-    if (!this.posthog) {
-      return null;
-    }
-    try {
-      const distinctId = this.userId || this.getAnonymousId();
-      const payload = await this.posthog.getFeatureFlagPayload(
-        flagKey,
-        distinctId
-      );
-      return payload;
-    } catch (error) {
-      console.warn(`Failed to get feature flag payload ${flagKey}:`, error);
-      return null;
-    }
-  }
-  /**
-   * Shutdown analytics services
-   */
-  async shutdown() {
-    if (this.posthog) {
-      await this.posthog.shutdown();
-    }
-  }
-};
-
-// 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, context) {
-    let cliToken = this.getCLIToken();
-    if (!cliToken) {
-      try {
-        let shouldLogin = true;
-        if (context !== "cloud-features") {
-          const response = await inquirer.prompt([
-            {
-              name: "shouldLogin",
-              type: "confirm",
-              message: "\u{1FA81} You are not yet authenticated. Authenticate with Copilot Cloud? (press Enter to confirm)",
-              default: true
-            }
-          ]);
-          shouldLogin = response.shouldLogin;
-        }
-        if (shouldLogin) {
-          if (context === "cloud-features") {
-            cmd.log(
-              chalk.cyan("\n\u{1F680} Setting up Copilot Cloud authentication...\n")
-            );
-          }
-          const loginResult = await this.login({ exitAfterLogin: false });
-          cliToken = loginResult.cliToken;
-          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 trpcClient2 = createTRPCClient(cliToken);
-    try {
-      me = await trpcClient2.me.query();
-    } catch (error) {
-      cmd.log(
-        chalk.yellow("Your authentication has expired. Re-authenticating...")
-      );
-      try {
-        const loginResult = await this.login({ exitAfterLogin: false });
-        return loginResult;
-      } catch (loginError) {
-        cmd.log(
-          chalk.red(
-            "Could not authenticate with Copilot Cloud. Please run: npx copilotkit@latest login"
-          )
-        );
-        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 }) {
-    const spinner = ora("\u{1FA81} Opening browser for authentication...").start();
-    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, reject) => {
-      const server = app.listen(port, () => {
-      });
-      await analytics.track({
-        event: "cli.login.initiated",
-        properties: {}
-      });
-      spinner.text = "\u{1FA81} Waiting for browser authentication to complete...";
-      app.post("/callback", async (req, res) => {
-        const { cliToken, user, organization } = req.body;
-        if (state !== req.query.state) {
-          res.status(401).json({ message: "Invalid state" });
-          spinner.fail("Invalid state");
-          server.close();
-          reject(new Error("OAuth state mismatch"));
-          return;
-        }
-        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
-          }
-        });
-        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/utils/detect-endpoint-type.utils.ts
-var removeTrailingSlash = (url) => url.replace(/\/$/, "");
-var getHumanReadableEndpointType = (type) => {
-  switch (type) {
-    case "LangGraphPlatform" /* LangGraphPlatform */:
-      return "LangGraph Platform";
-    case "CopilotKit" /* CopilotKit */:
-      return "CopilotKit";
-    case "CrewAI" /* CrewAI */:
-      return "CrewAI";
-    case "MCP" /* MCP */:
-      return "MCP";
-    default:
-      return "Invalid";
-  }
-};
-async function detectRemoteEndpointType(url) {
-  const [isLangGraph, isLangGraphFastAPI, isCopilot, isCrewAI, isMCP] = await Promise.all([
-    isLangGraphPlatformEndpoint(url),
-    isLangGraphFastAPIEndpoint(url),
-    isCopilotKitEndpoint(url),
-    isCrewAIEndpoint(url),
-    isMCPEndpoint(url)
-  ]);
-  if (isLangGraph || isLangGraphFastAPI) {
-    return {
-      url,
-      type: "LangGraphPlatform" /* LangGraphPlatform */,
-      humanReadableType: "LangGraph Platform"
-    };
-  }
-  if (isCopilot) {
-    return {
-      url,
-      type: "CopilotKit" /* CopilotKit */,
-      humanReadableType: "CopilotKit"
-    };
-  }
-  if (isCrewAI) {
-    return {
-      url,
-      type: "CrewAI" /* CrewAI */,
-      humanReadableType: "CrewAI"
-    };
-  }
-  if (isMCP) {
-    return {
-      url,
-      type: "MCP" /* MCP */,
-      humanReadableType: "MCP"
-    };
-  }
-  if (!url.endsWith("/copilotkit")) {
-    const copilotKitUrl = `${removeTrailingSlash(url)}/copilotkit`;
-    const isCopilotWithPath = await isCopilotKitEndpoint(copilotKitUrl);
-    if (isCopilotWithPath) {
-      return {
-        url: copilotKitUrl,
-        type: "CopilotKit" /* CopilotKit */,
-        humanReadableType: "CopilotKit"
-      };
-    }
-  }
-  return {
-    url,
-    type: "Invalid" /* Invalid */,
-    humanReadableType: "Invalid"
-  };
-}
-async function isLangGraphPlatformEndpoint(url, retries = 0) {
-  let response;
-  try {
-    response = await fetch(`${url}/assistants/search`, {
-      method: "POST",
-      body: JSON.stringify({
-        metadata: {},
-        limit: 99,
-        offset: 0
-      })
-    });
-  } catch (error) {
-    return false;
-  }
-  if (!response.ok) {
-    if (response.status === 502) {
-      if (retries < 3) {
-        console.log("RETRYING LGC", retries + 1);
-        return isLangGraphPlatformEndpoint(url, retries + 1);
-      }
-    }
-    if (response.status === 403) {
-      return true;
-    }
-    return false;
-  }
-  const data = await response.json();
-  if (data[0].assistant_id) {
-    return true;
-  }
-  return false;
-}
-async function isLangGraphFastAPIEndpoint(url) {
-  let response;
-  try {
-    response = await fetch(`${url}/health`, {
-      method: "GET"
-    });
-  } catch (error) {
-    return false;
-  }
-  return response.ok;
-}
-async function isCopilotKitEndpoint(url, retries = 0) {
-  let response;
-  try {
-    response = await fetch(`${url}/info`, {
-      method: "POST",
-      body: JSON.stringify({})
-    });
-  } catch (error) {
-    return false;
-  }
-  if (!response.ok) {
-    if (response.status === 502) {
-      if (retries < 3) {
-        console.log("RETRYING CK", retries + 1);
-        return isCopilotKitEndpoint(url, retries + 1);
-      }
-    }
-    return false;
-  }
-  const data = await response.json();
-  if (data.agents && data.actions) {
-    return true;
-  }
-  return false;
-}
-async function isCrewAIEndpoint(url) {
-  return url.toLowerCase().includes("crew");
-}
-async function isMCPEndpoint(_url) {
-  return true;
-}
-
-// src/services/tunnel.service.ts
-import axios from "axios";
-import localtunnel from "localtunnel";
-var TunnelService = class {
-  META_DATA_URL = "https://metadata-cdn.copilotkit.ai/cloud.config.json";
-  async create(options) {
-    const metadata = await this.getMetaData();
-    return localtunnel({
-      ...options,
-      host: metadata.tunnelHost
-    });
-  }
-  async getMetaData() {
-    const response = await axios.get(this.META_DATA_URL);
-    return response.data;
-  }
-};
-
-// src/commands/base-command.ts
-import { Command } from "@oclif/core";
-import Sentry, { consoleIntegration } from "@sentry/node";
-
-// src/utils/version.ts
-var LIB_VERSION = "1.54.0";
-
-// 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") {
-      Sentry.captureException(err);
-    }
-    const message = err?.message ?? "Unknown error";
-    this.log("\n" + chalk2.red(message) + "\n");
-    const exitCode = err?.oclif?.exit ?? 1;
-    this.exit(exitCode);
-  }
-  async finally() {
-    if (process.env.SENTRY_DISABLED === "true") {
-      return;
-    }
-    Sentry.close();
-  }
-  async run() {
-  }
-  async checkCLIVersion() {
-    try {
-      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;
-      }
-    } catch {
-    }
-  }
-  async gracefulError(message) {
-    this.log("\n" + chalk2.red(message));
-    process.exit(1);
-  }
-};
-
-// src/commands/dev.ts
-var DEFAULT_CLOUD_BASE_URL = "https://cloud.copilotkit.ai";
-var CLOUD_BASE_URL = process.env.COPILOT_CLOUD_BASE_URL ?? DEFAULT_CLOUD_BASE_URL;
-var Dev = class _Dev extends BaseCommand {
-  constructor(argv, config, authService = new AuthService(), tunnelService = new TunnelService()) {
-    super(argv, config);
-    this.authService = authService;
-    this.tunnelService = tunnelService;
-  }
-  static flags = {
-    port: Flags.string({ description: "port", required: true }),
-    project: Flags.string({
-      description: "project ID (can be found in the Copilot Cloud dashboard)"
-    })
-  };
-  static description = "Start local development for a CopilotKit project";
-  static examples = [
-    "<%= config.bin %> <%= command.id %> --port 8000 --project proj_mv3laowus0lz11kklo57bdr6"
-  ];
-  trpcClient = null;
-  copilotCloudTunnelId = null;
-  async pingTunnelRecursively() {
-    if (!this.copilotCloudTunnelId) {
-      return;
-    }
-    try {
-      await this.trpcClient.pingLocalTunnel.query({
-        localTunnelId: this.copilotCloudTunnelId
-      });
-    } catch (error) {
-      if (error?.data?.code === "NOT_FOUND") {
-        this.gracefulError(error.message);
-      } else {
-        this.gracefulError(
-          "Failed to ping tunnel. The connection may have been lost."
-        );
-      }
-    }
-    await new Promise((resolve) => setTimeout(resolve, 5e3));
-    await this.pingTunnelRecursively();
-  }
-  async run() {
-    const { flags } = await this.parse(_Dev);
-    const { cliToken, organization, user } = await this.authService.requireLogin(this, "general");
-    const analytics = new AnalyticsService({
-      userId: user.id,
-      organizationId: organization.id,
-      email: user.email
-    });
-    this.trpcClient = createTRPCClient(cliToken);
-    const availableProjects = await this.trpcClient.listOrgProjects.query({
-      orgId: organization.id
-    });
-    let selectedProjectId = null;
-    if (flags.project) {
-      if (!availableProjects.some((project) => project.id === flags.project)) {
-        this.log(chalk3.red(`Project with ID ${flags.project} not found`));
-        process.exit(1);
-      }
-      selectedProjectId = flags.project;
-      this.log(chalk3.green(`\u2705 Selected project ${selectedProjectId}`));
-    } else {
-      const { projectId } = await inquirer2.prompt([
-        {
-          name: "projectId",
-          type: "list",
-          message: "Select 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 { type: remoteEndpointType } = await detectRemoteEndpointType(
-      `http://localhost:${flags.port}`
-    );
-    if (remoteEndpointType === "Invalid" /* Invalid */) {
-      return this.gracefulError(
-        `Invalid remote endpoint. Please ensure you are running a compatible endpoint at port ${flags.port} and try again.`
-      );
-    }
-    const humanReadableRemoteEndpointType = getHumanReadableEndpointType(remoteEndpointType);
-    await analytics.track({
-      event: "cli.dev.initiatied",
-      properties: {
-        port: flags.port,
-        projectId: selectedProjectId,
-        endpointType: remoteEndpointType
-      }
-    });
-    this.log(
-      chalk3.green(`\u2705 ${humanReadableRemoteEndpointType} endpoint detected`)
-    );
-    const spinner = ora2("Creating tunnel...\n").start();
-    const tunnelId = createId();
-    const setupTunnel = this.setupTunnel({
-      tunnelId,
-      port: parseInt(flags.port),
-      subdomain: createId(),
-      onSuccess: async ({ url, id }) => {
-        this.log("\nTunnel Information:\n");
-        this.log(`${chalk3.bold.cyan("\u2022 Tunnel URL:		")} ${chalk3.white(url)}`);
-        this.log(
-          `${chalk3.bold.cyan("\u2022 Endpoint Type:	")} ${chalk3.white(humanReadableRemoteEndpointType)}`
-        );
-        this.log(
-          `${chalk3.bold.cyan("\u2022 Project:		")} ${chalk3.white(`${CLOUD_BASE_URL}/projects/${selectedProjectId}`)}`
-        );
-        this.log(chalk3.yellow("\nPress Ctrl+C to stop the tunnel"));
-        this.log("\n");
-        spinner.text = "Linking local tunnel to Copilot Cloud...";
-        const { localTunnelId } = await this.trpcClient.reportRemoteEndpointLocalTunnel.mutate({
-          tunnelId: id,
-          projectId: selectedProjectId,
-          endpointType: remoteEndpointType === "CopilotKit" /* CopilotKit */ ? "CopilotKit" : "LangGraphCloud",
-          tunnelUrl: url,
-          port: parseInt(flags.port)
-        });
-        this.copilotCloudTunnelId = localTunnelId;
-        await analytics.track({
-          event: "cli.dev.tunnel.created",
-          properties: {
-            tunnelId: localTunnelId,
-            port: flags.port,
-            projectId: selectedProjectId,
-            endpointType: remoteEndpointType
-          }
-        });
-        spinner.color = "green";
-        spinner.text = "\u{1F680} Local tunnel is live and linked to Copilot Cloud!\n";
-        spinner.succeed();
-        await this.pingTunnelRecursively();
-      },
-      onTunnelClose: async ({ id }) => {
-        if (this.copilotCloudTunnelId) {
-          await analytics.track({
-            event: "cli.dev.tunnel.closed",
-            properties: {
-              tunnelId: id
-            }
-          });
-          await this.trpcClient.deleteLocalTunnel.mutate({
-            localTunnelId: this.copilotCloudTunnelId
-          });
-          this.copilotCloudTunnelId = null;
-        }
-      },
-      spinner
-    });
-    await Promise.all([setupTunnel]);
-  }
-  async setupTunnel({
-    port,
-    subdomain,
-    onSuccess,
-    onTunnelClose,
-    spinner,
-    tunnelId
-  }) {
-    const TUNNEL_TIMEOUT = 15e3;
-    const CONNECTION_TEST_TIMEOUT = 5e3;
-    spinner.text = `Testing connection to localhost:${port}...`;
-    try {
-      const testResponse = await Promise.race([
-        fetch(`http://localhost:${port}`, { method: "HEAD" }),
-        new Promise(
-          (_, reject) => setTimeout(
-            () => reject(new Error("Connection timeout")),
-            CONNECTION_TEST_TIMEOUT
-          )
-        )
-      ]);
-    } catch (error) {
-      spinner.fail();
-      return this.gracefulError(
-        `Cannot connect to localhost:${port}. Please ensure your application is running on port ${port} and try again.`
-      );
-    }
-    spinner.text = "Creating tunnel...";
-    try {
-      const tunnel = await Promise.race([
-        this.tunnelService.create({
-          port,
-          subdomain: tunnelId
-        }),
-        new Promise(
-          (_, reject) => setTimeout(
-            () => reject(new Error("Tunnel creation timeout")),
-            TUNNEL_TIMEOUT
-          )
-        )
-      ]);
-      tunnel.on("request", (info) => {
-        this.log(
-          `${chalk3.green("\u279C")} ${chalk3.white((/* @__PURE__ */ new Date()).toISOString())} - ${info.method} ${info.path}`
-        );
-      });
-      tunnel.on("error", (err) => {
-        this.gracefulError(chalk3.red(`Tunnel error: ${err.message}`));
-      });
-      tunnel.on("close", async () => {
-        this.log(chalk3.yellow("\nTunnel closed"));
-        await onTunnelClose({ id: tunnelId });
-        process.exit(0);
-      });
-      await Promise.all([
-        new Promise(() => {
-          process.on("SIGINT", async () => {
-            this.log("\nShutting down tunnel...");
-            await onTunnelClose({ id: tunnelId });
-            tunnel.close();
-            process.exit(0);
-          });
-          process.on("SIGTERM", async () => {
-            this.log("\nShutting down tunnel...");
-            await onTunnelClose({ id: tunnelId });
-            tunnel.close();
-            process.exit(0);
-          });
-        }),
-        onSuccess({ url: tunnel.url, id: tunnelId })
-      ]);
-    } catch (error) {
-      spinner.fail();
-      if (error.message === "Tunnel creation timeout") {
-        return this.gracefulError(
-          `Unable to establish tunnel connection after ${TUNNEL_TIMEOUT / 1e3} seconds.
-
-This usually means:
-\u2022 Network connectivity issues
-\u2022 Tunnel service is temporarily unavailable
-\u2022 Firewall blocking outbound connections
-
-Please try:
-1. Check your internet connection
-2. Try again in a few moments
-`
-        );
-      } else if (error.message === "Connection timeout") {
-        return this.gracefulError(
-          `Cannot connect to localhost:${port}. Please ensure your application is running on port ${port} and try again.`
-        );
-      } else {
-        return this.gracefulError(`Failed to create tunnel: ${error.message}`);
-      }
-    }
-  }
-};
-export {
-  Dev as default
-};
-//# sourceMappingURL=dev.js.map