npm - @cimplify/cli - Versions diffs - 0.2.0 - Mend

@cimplify/cli 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (457) hide show

package/dist/list-D4JC2VWY.mjs ADDED Viewed

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+import { REGISTRY_INDEX } from './chunk-XSWWWO6H.mjs';
+import { parseArgs, flagBool } from './chunk-D7D75ONX.mjs';
+import { CliError, CLI_ERROR_CODE, info, bold, dim, green, result } from './chunk-NZ4RG62Z.mjs';
+// src/commands/list.ts
+async function run(argv) {
+  const args = parseArgs(argv);
+  const utilitiesOnly = flagBool(args, "utilities");
+  const componentsOnly = flagBool(args, "components");
+  const index = REGISTRY_INDEX;
+  if (!index || !Array.isArray(index.components)) {
+    throw new CliError(
+      CLI_ERROR_CODE.NOT_FOUND,
+      "Embedded SDK component registry is empty.",
+      {
+        remediation: "Rebuild the CLI with the SDK present: `cd packages/sdk && bun run build && cd ../cli && bun run build`."
+      }
+    );
+  }
+  const filtered = index.components.filter((entry) => {
+    if (utilitiesOnly) return entry.type === "utility";
+    if (componentsOnly) return entry.type === "component";
+    return true;
+  });
+  const maxName = filtered.reduce((max, c) => Math.max(max, c.name.length), 0);
+  info("");
+  info(bold(`Available registry entries (${filtered.length})`));
+  info("");
+  for (const entry of filtered) {
+    const tag = entry.type === "utility" ? dim(" (utility)") : "";
+    info(`  ${green(entry.name.padEnd(maxName))}  ${entry.description}${tag}`);
+  }
+  info("");
+  info(dim("Eject a component into your project with `cimplify add <name>`."));
+  result({
+    count: filtered.length,
+    components: filtered.map((c) => ({
+      name: c.name,
+      title: c.title,
+      description: c.description,
+      type: c.type,
+      registryDependencies: c.registryDependencies
+    }))
+  });
+}
+export { run as default };

package/dist/login-MRYWLQRY.mjs ADDED Viewed

@@ -0,0 +1,276 @@
+#!/usr/bin/env node
+import { parseArgs, flagString, flagBool } from './chunk-D7D75ONX.mjs';
+import { resolveBaseUrl, ApiClient } from './chunk-4ZVTPMUZ.mjs';
+import { writeAuth } from './chunk-JJYWETGA.mjs';
+import { CliError, CLI_ERROR_CODE, success, result, isJsonMode, step, info, dim } from './chunk-NZ4RG62Z.mjs';
+import os from 'os';
+import { randomBytes, createHash } from 'crypto';
+import { createServer } from 'http';
+import { spawn } from 'child_process';
+var CODE_VERIFIER_BYTES = 32;
+var STATE_BYTES = 16;
+var LOOPBACK_HOST = "127.0.0.1";
+var CALLBACK_PATH = "/callback";
+var CALLBACK_TIMEOUT_MS = 10 * 60 * 1e3;
+function generatePkcePair() {
+  const codeVerifier = base64UrlEncode(randomBytes(CODE_VERIFIER_BYTES));
+  const codeChallenge = base64UrlEncode(
+    createHash("sha256").update(codeVerifier).digest()
+  );
+  return { codeVerifier, codeChallenge, codeChallengeMethod: "S256" };
+}
+function generateState() {
+  return base64UrlEncode(randomBytes(STATE_BYTES));
+}
+function base64UrlEncode(buf) {
+  return buf.toString("base64").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+var HTML_SUCCESS = (apiBaseUrl) => `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><title>Cimplify CLI</title>
+<style>
+body{font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;
+  background:#0a0a0a;color:#e5e5e5;display:flex;align-items:center;
+  justify-content:center;height:100vh;margin:0}
+.card{background:#141414;border:1px solid #262626;border-radius:12px;
+  padding:32px 40px;max-width:420px;text-align:center}
+.tick{color:#22c55e;font-size:32px}
+h1{margin:8px 0 4px;font-size:20px;font-weight:600}
+p{margin:4px 0;color:#a3a3a3;font-size:14px}
+.host{color:#737373;font-family:ui-monospace,monospace;font-size:12px;margin-top:16px}
+</style></head><body><div class="card">
+<div class="tick">\u2713</div>
+<h1>You're logged in</h1>
+<p>Return to your terminal \u2014 it'll continue from here.</p>
+<p>You can close this tab.</p>
+<div class="host">${apiBaseUrl}</div>
+</div></body></html>`;
+var HTML_ERROR = (msg) => `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><title>Cimplify CLI</title>
+<style>body{font-family:sans-serif;padding:40px;max-width:480px;margin:auto}
+h1{color:#dc2626}</style></head><body>
+<h1>Sign-in failed</h1><p>${escapeHtml(msg)}</p>
+<p>Return to your terminal and try <code>cimplify login</code> again.</p>
+</body></html>`;
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+async function startLoopbackServer(apiBaseUrl) {
+  let resolveCb = null;
+  let rejectCb = null;
+  const callbackPromise = new Promise((resolve, reject) => {
+    resolveCb = resolve;
+    rejectCb = reject;
+  });
+  const server = createServer((req, res) => {
+    if (!req.url) {
+      res.writeHead(400).end();
+      return;
+    }
+    const parsed = new URL(req.url, `http://${LOOPBACK_HOST}`);
+    if (parsed.pathname !== CALLBACK_PATH) {
+      res.writeHead(404).end("Not Found");
+      return;
+    }
+    const code = parsed.searchParams.get("code");
+    const state = parsed.searchParams.get("state");
+    const error = parsed.searchParams.get("error");
+    if (error) {
+      res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" }).end(HTML_ERROR(error));
+      rejectCb?.(new CliError(CLI_ERROR_CODE.UNAUTHORIZED, `OAuth error: ${error}`));
+      return;
+    }
+    if (!code || !state) {
+      res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" }).end(HTML_ERROR("Missing code or state in callback"));
+      rejectCb?.(new CliError(CLI_ERROR_CODE.UNAUTHORIZED, "Malformed callback"));
+      return;
+    }
+    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" }).end(HTML_SUCCESS(apiBaseUrl));
+    resolveCb?.({ code, state });
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, LOOPBACK_HOST, resolve);
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    server.close();
+    throw new CliError(
+      CLI_ERROR_CODE.UNAUTHORIZED,
+      "Could not bind loopback server"
+    );
+  }
+  const redirectUri = `http://${LOOPBACK_HOST}:${address.port}${CALLBACK_PATH}`;
+  return {
+    redirectUri,
+    async awaitCallback(timeoutMs = CALLBACK_TIMEOUT_MS) {
+      let timer = null;
+      const timeoutPromise = new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          reject(
+            new CliError(
+              CLI_ERROR_CODE.TIMEOUT,
+              `Login timed out after ${Math.round(timeoutMs / 1e3)}s`
+            )
+          );
+        }, timeoutMs);
+      });
+      try {
+        return await Promise.race([callbackPromise, timeoutPromise]);
+      } finally {
+        if (timer) clearTimeout(timer);
+        server.close();
+      }
+    },
+    close() {
+      server.close();
+    }
+  };
+}
+function openBrowser(url) {
+  const platformCommand = (() => {
+    switch (process.platform) {
+      case "darwin":
+        return { cmd: "open", args: [url] };
+      case "win32":
+        return { cmd: "cmd", args: ["/c", "start", '""', url] };
+      default:
+        return { cmd: "xdg-open", args: [url] };
+    }
+  })();
+  try {
+    const child = spawn(platformCommand.cmd, platformCommand.args, {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+// src/commands/login.ts
+var FLAG_API_KEY = "api-key";
+var FLAG_BASE_URL = "base-url";
+var FLAG_NO_BROWSER = "no-browser";
+var ENDPOINT_AUTH_ME = "/v1/auth/me";
+var ENDPOINT_CLI_START = "/v1/auth/cli/start";
+var ENDPOINT_CLI_TOKEN = "/v1/auth/cli/token";
+var KEY_PREFIX_DK = "dk_";
+var KEY_PREFIX_SK = "sk_";
+var PRODUCT_NAME = "cimplify-cli";
+async function run(argv) {
+  const args = parseArgs(argv);
+  const baseUrl = resolveBaseUrl(flagString(args, FLAG_BASE_URL));
+  const explicitKey = flagString(args, FLAG_API_KEY);
+  if (explicitKey) {
+    await loginWithKey(baseUrl, explicitKey);
+    return;
+  }
+  await loginWithBrowser(baseUrl, flagBool(args, FLAG_NO_BROWSER));
+}
+async function loginWithKey(baseUrl, apiKey) {
+  if (!apiKey.startsWith(KEY_PREFIX_DK) && !apiKey.startsWith(KEY_PREFIX_SK)) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      `API key must start with "${KEY_PREFIX_DK}" or "${KEY_PREFIX_SK}".`
+    );
+  }
+  const client = ApiClient.withKey(apiKey, baseUrl);
+  const me = await client.get(ENDPOINT_AUTH_ME);
+  await writeAuth({
+    apiKey,
+    apiBaseUrl: baseUrl,
+    accountId: me.id,
+    businessId: me.business_id,
+    email: me.email,
+    name: me.name,
+    savedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  success(`Logged in as ${me.email ?? me.name ?? me.id} (business ${me.business_id})`);
+  result({
+    logged_in: true,
+    account: { id: me.id, email: me.email ?? null, name: me.name ?? null },
+    business: { id: me.business_id },
+    method: "api_key"
+  });
+}
+async function loginWithBrowser(baseUrl, noBrowser) {
+  if (isJsonMode()) {
+    throw new CliError(
+      CLI_ERROR_CODE.INTERACTIVE_REQUIRED,
+      "browser login is not supported in --json mode",
+      { remediation: "pass --api-key dk_\u2026 (create one in the dashboard or via `cimplify auth keys create`)" }
+    );
+  }
+  const pkce = generatePkcePair();
+  const state = generateState();
+  const loopback = await startLoopbackServer(baseUrl);
+  const startBody = {
+    code_challenge: pkce.codeChallenge,
+    code_challenge_method: pkce.codeChallengeMethod,
+    redirect_uri: loopback.redirectUri,
+    state,
+    client_meta: {
+      hostname: os.hostname(),
+      platform: process.platform,
+      arch: process.arch,
+      node_version: process.version,
+      product: PRODUCT_NAME
+    }
+  };
+  const unauthClient = ApiClient.unauthenticated(baseUrl);
+  const startResponse = await unauthClient.post(
+    ENDPOINT_CLI_START,
+    startBody
+  );
+  step("Opening browser to authorize this CLI...");
+  info(dim(startResponse.approval_url));
+  if (!noBrowser) {
+    openBrowser(startResponse.approval_url);
+  } else {
+    info("");
+    info(dim("Open the URL above in any browser to continue."));
+  }
+  let callback;
+  try {
+    callback = await loopback.awaitCallback(startResponse.expires_in_secs * 1e3);
+  } catch (err) {
+    loopback.close();
+    throw err;
+  }
+  if (callback.state !== state) {
+    throw new CliError(
+      CLI_ERROR_CODE.UNAUTHORIZED,
+      "OAuth state mismatch. Possible CSRF attempt \u2014 try again."
+    );
+  }
+  const token = await unauthClient.post(ENDPOINT_CLI_TOKEN, {
+    auth_code: callback.code,
+    code_verifier: pkce.codeVerifier,
+    redirect_uri: loopback.redirectUri
+  });
+  const meClient = ApiClient.withKey(token.access_token, baseUrl);
+  const me = await meClient.get(ENDPOINT_AUTH_ME);
+  await writeAuth({
+    apiKey: token.access_token,
+    apiBaseUrl: baseUrl,
+    accountId: me.id,
+    businessId: me.business_id,
+    email: me.email,
+    name: me.name,
+    savedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  success(
+    `Logged in as ${me.email ?? me.name ?? me.id} (business ${me.business_id})`
+  );
+  result({
+    logged_in: true,
+    account: { id: me.id, email: me.email ?? null, name: me.name ?? null },
+    business: { id: me.business_id },
+    method: "oauth_pkce"
+  });
+}
+export { run as default };

package/dist/logout-ZFZLSJ32.mjs ADDED Viewed

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { clearAuth } from './chunk-JJYWETGA.mjs';
+import { success, info, result } from './chunk-NZ4RG62Z.mjs';
+// src/commands/logout.ts
+async function run(_argv) {
+  const removed = await clearAuth();
+  if (removed) {
+    success("Logged out.");
+  } else {
+    info("Not logged in.");
+  }
+  result({ logged_out: removed });
+}
+export { run as default };

package/dist/logs-LK7CMBCE.mjs ADDED Viewed

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+import { TERMINAL_DEPLOYMENT_STATUSES } from './chunk-MQMNWLMU.mjs';
+import { parseArgs, flagString, flagBool } from './chunk-D7D75ONX.mjs';
+import { ApiClient } from './chunk-4ZVTPMUZ.mjs';
+import { readAuth, readProjectLink, readProjectState } from './chunk-JJYWETGA.mjs';
+import { CliError, CLI_ERROR_CODE, isJsonMode, failure, result, red } from './chunk-NZ4RG62Z.mjs';
+// src/commands/logs.ts
+var FLAG_DEPLOYMENT = "deployment";
+var FLAG_FOLLOW = "follow";
+var POLL_INTERVAL_MS = 1e3;
+var POLL_MAX_MS = 60 * 60 * 1e3;
+function progressEndpoint(businessId, projectId, deploymentId) {
+  return `/v1/businesses/${encodeURIComponent(businessId)}/projects/${encodeURIComponent(projectId)}/deployments/${encodeURIComponent(deploymentId)}/progress`;
+}
+function nextChunk(cursor, full) {
+  if (!full) return "";
+  if (full.length <= cursor.printed) return "";
+  const chunk = full.slice(cursor.printed);
+  cursor.printed = full.length;
+  return chunk;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function run(argv) {
+  const args = parseArgs(argv);
+  const auth = await readAuth();
+  const link = await readProjectLink();
+  const client = ApiClient.fromAuth(auth);
+  let deploymentId = flagString(args, FLAG_DEPLOYMENT);
+  if (!deploymentId) {
+    const state = await readProjectState();
+    deploymentId = state?.lastDeploymentId;
+  }
+  if (!deploymentId) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      "No deployment specified and no recent deployment in state.\nPass --deployment <id> or run `cimplify deploy` first."
+    );
+  }
+  const endpoint = progressEndpoint(link.businessId, link.projectId, deploymentId);
+  const follow = flagBool(args, FLAG_FOLLOW);
+  const json = isJsonMode();
+  if (!follow) {
+    const progress = await client.get(endpoint);
+    if (!json) {
+      if (progress.build_logs) process.stdout.write(progress.build_logs);
+      if (progress.error_message) failure(progress.error_message);
+    }
+    result({
+      deployment_id: deploymentId,
+      status: progress.status,
+      build_logs: progress.build_logs ?? null,
+      error_message: progress.error_message ?? null
+    });
+    return;
+  }
+  const cursor = { printed: 0 };
+  const startedAt = Date.now();
+  let lastErrorMessage;
+  let finalProgress = null;
+  while (true) {
+    const progress = await client.get(endpoint);
+    if (!json) {
+      const chunk = nextChunk(cursor, progress.build_logs);
+      if (chunk.length > 0) process.stdout.write(chunk);
+      if (progress.error_message && progress.error_message !== lastErrorMessage) {
+        process.stdout.write(`
+${red(progress.error_message)}
+`);
+        lastErrorMessage = progress.error_message;
+      }
+    }
+    if (TERMINAL_DEPLOYMENT_STATUSES.has(progress.status)) {
+      finalProgress = progress;
+      break;
+    }
+    if (Date.now() - startedAt > POLL_MAX_MS) {
+      throw new CliError(
+        CLI_ERROR_CODE.NETWORK_ERROR,
+        "Logs polling timed out (1 hour). Re-run `cimplify logs --follow` to resume."
+      );
+    }
+    await sleep(POLL_INTERVAL_MS);
+  }
+  result({
+    deployment_id: deploymentId,
+    status: finalProgress.status,
+    build_logs: finalProgress.build_logs ?? null,
+    error_message: finalProgress.error_message ?? null
+  });
+}
+export { run as default, nextChunk };

package/dist/projects-QJUGOCQZ.mjs ADDED Viewed

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+import { REPO_PROVIDER } from './chunk-MQMNWLMU.mjs';
+import { parseArgs, flagString, flagBool } from './chunk-D7D75ONX.mjs';
+import { ApiClient } from './chunk-4ZVTPMUZ.mjs';
+import { readAuth } from './chunk-JJYWETGA.mjs';
+import { CliError, CLI_ERROR_CODE, info, dim, result, bold, success } from './chunk-NZ4RG62Z.mjs';
+// src/commands/projects.ts
+var SUB_LS = "ls";
+var SUB_LIST = "list";
+var SUB_CREATE = "create";
+var FLAG_NO_REPO = "no-repo";
+var FLAG_CONNECT = "connect";
+var PROJECT_TYPE_DEFAULT = "nextjs-app";
+var COL_GAP = "  ";
+function projectsEndpoint(businessId) {
+  return `/v1/businesses/${encodeURIComponent(businessId)}/projects`;
+}
+function provisionRepoEndpoint(businessId, projectId) {
+  return `/v1/businesses/${encodeURIComponent(businessId)}/projects/${encodeURIComponent(projectId)}/repo/provision`;
+}
+function connectRepoEndpoint(businessId, projectId) {
+  return `/v1/businesses/${encodeURIComponent(businessId)}/projects/${encodeURIComponent(projectId)}/repo/connect`;
+}
+function detectProviderFromUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.hostname === "git.freestyle.sh") return REPO_PROVIDER.FREESTYLE;
+    if (parsed.hostname === "github.com" || parsed.hostname.endsWith(".github.com")) {
+      return REPO_PROVIDER.GITHUB;
+    }
+    if (parsed.hostname.includes("gitea")) return REPO_PROVIDER.GITEA;
+  } catch {
+  }
+  return REPO_PROVIDER.EXTERNAL;
+}
+async function run(argv) {
+  const args = parseArgs(argv);
+  const sub = args.positional[0];
+  if (!sub) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      `Usage: cimplify projects <${SUB_LS}|${SUB_CREATE}>`
+    );
+  }
+  const auth = await readAuth();
+  const client = ApiClient.fromAuth(auth);
+  if (sub === SUB_LS || sub === SUB_LIST) {
+    await listProjects(client, auth.businessId);
+    return;
+  }
+  if (sub === SUB_CREATE) {
+    const name = args.positional[1];
+    if (!name) {
+      throw new CliError(
+        CLI_ERROR_CODE.INVALID_INPUT,
+        `Usage: cimplify projects ${SUB_CREATE} <name> [--no-repo | --connect <url>]`
+      );
+    }
+    await createProject(client, auth.businessId, name, {
+      noRepo: flagBool(args, FLAG_NO_REPO),
+      connectRemote: flagString(args, FLAG_CONNECT)
+    });
+    return;
+  }
+  throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `Unknown subcommand "${sub}"`);
+}
+async function listProjects(client, businessId) {
+  const projects = await client.get(projectsEndpoint(businessId));
+  if (projects.length === 0) {
+    info(dim("No projects yet. Create one: `cimplify projects create <name>`"));
+    result({ projects: [] });
+    return;
+  }
+  const idWidth = Math.max(...projects.map((p) => p.id.length));
+  const nameWidth = Math.max(...projects.map((p) => p.name.length));
+  info(
+    bold(
+      [
+        "ID".padEnd(idWidth),
+        "NAME".padEnd(nameWidth),
+        "TYPE"
+      ].join(COL_GAP)
+    )
+  );
+  for (const p of projects) {
+    info(
+      [
+        p.id.padEnd(idWidth),
+        p.name.padEnd(nameWidth),
+        p.project_type ?? ""
+      ].join(COL_GAP)
+    );
+  }
+  result({
+    projects: projects.map((p) => ({
+      id: p.id,
+      name: p.name,
+      project_type: p.project_type ?? null
+    }))
+  });
+}
+async function createProject(client, businessId, name, options = {}) {
+  if (options.noRepo && options.connectRemote) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      "Cannot pass both --no-repo and --connect."
+    );
+  }
+  const body = { name, project_type: PROJECT_TYPE_DEFAULT };
+  const project = await client.post(projectsEndpoint(businessId), body);
+  success(`Created project ${project.name} (${project.id})`);
+  if (options.noRepo) {
+    info(dim("Skipped repo provisioning (--no-repo). Use `cimplify repo provision` later."));
+    info(dim(`Link locally: cimplify link ${project.id}`));
+    result({
+      project: { id: project.id, name: project.name },
+      repo: null
+    });
+    return;
+  }
+  if (options.connectRemote) {
+    const provider = detectProviderFromUrl(options.connectRemote);
+    if (provider === REPO_PROVIDER.FREESTYLE) {
+      throw new CliError(
+        CLI_ERROR_CODE.INVALID_INPUT,
+        "Cannot connect a Freestyle URL \u2014 Freestyle repos are provisioned, not connected."
+      );
+    }
+    const repoBody = {
+      provider,
+      remote_url: options.connectRemote
+    };
+    const repo2 = await client.post(
+      connectRepoEndpoint(businessId, project.id),
+      repoBody
+    );
+    success(`Connected ${repo2.provider} remote ${repo2.remote_url}`);
+    info(dim(`Link locally: cimplify link ${project.id}`));
+    result({
+      project: { id: project.id, name: project.name },
+      repo: { provider: repo2.provider, id: repo2.id, remote_url: repo2.remote_url, default_branch: repo2.default_branch }
+    });
+    return;
+  }
+  const repo = await client.post(
+    provisionRepoEndpoint(businessId, project.id),
+    {}
+  );
+  success(`Provisioned ${repo.provider} repo`);
+  info(dim(`  remote: ${repo.remote_url}`));
+  info("");
+  info(dim("Wire your local repo:"));
+  info(dim(`  cimplify link ${project.id}`));
+  info(dim(`  git init && git remote add origin ${repo.remote_url}`));
+  info(dim(`  git add . && git commit -m "Initial commit"`));
+  info(dim(`  cimplify deploy`));
+  result({
+    project: { id: project.id, name: project.name },
+    repo: { provider: repo.provider, id: repo.id, remote_url: repo.remote_url, default_branch: repo.default_branch }
+  });
+}
+export { run as default, detectProviderFromUrl };

package/dist/repo-MV22OHON.mjs ADDED Viewed

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+export { run as default, fetchCloneToken } from './chunk-5XH72JMJ.mjs';
+import './chunk-L6474RPL.mjs';
+import './chunk-MQMNWLMU.mjs';
+import './chunk-D7D75ONX.mjs';
+import './chunk-4ZVTPMUZ.mjs';
+import './chunk-JJYWETGA.mjs';
+import './chunk-NZ4RG62Z.mjs';