hostedge 0.0.0-stage → 0.1.0

package/dist/hostedge.js

@@ -0,0 +1,2461 @@
+#!/usr/bin/env node
+
+// src/main.ts
+import { spawn } from "node:child_process";
+
+// src/cli.ts
+import { parseArgs } from "node:util";
+
+// src/commands/auth.ts
+import { randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+import { hostname } from "node:os";
+
+// src/config.ts
+import { mkdir, readFile, writeFile, chmod, rm } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+var DEFAULT_API_URL = "https://hostedge.app";
+function configPath(io2) {
+  const base = io2.env.HOSTEDGE_CONFIG_DIR ?? join(io2.env.XDG_CONFIG_HOME ?? join(io2.env.HOME ?? homedir(), ".config"), "hostedge");
+  return join(base, "config.json");
+}
+async function readJson(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function readConfig(io2) {
+  return await readJson(configPath(io2)) ?? {};
+}
+async function writeConfig(io2, config) {
+  const path = configPath(io2);
+  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  await writeFile(path, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+  await chmod(path, 384);
+}
+async function clearConfig(io2) {
+  await rm(configPath(io2), { force: true });
+}
+async function credentials(io2) {
+  const saved = await readConfig(io2);
+  return {
+    apiUrl: (io2.env.HOSTEDGE_API_URL ?? saved.apiUrl ?? DEFAULT_API_URL).replace(/\/+$/, ""),
+    token: io2.env.HOSTEDGE_TOKEN ?? saved.token ?? null
+  };
+}
+var linkPath = (dir) => join(dir, ".hostedge", "project.json");
+async function readLink(dir) {
+  const link = await readJson(linkPath(dir));
+  return link && typeof link.projectId === "string" ? link : null;
+}
+async function writeLink(dir, link) {
+  await mkdir(join(dir, ".hostedge"), { recursive: true });
+  await writeFile(linkPath(dir), `${JSON.stringify(link, null, 2)}
+`);
+}
+async function ensureGitignored(dir, entry) {
+  const path = join(dir, ".gitignore");
+  let text = "";
+  try {
+    text = await readFile(path, "utf8");
+  } catch {
+  }
+  const lines = text.split(/\r?\n/).map((l) => l.trim());
+  if (lines.includes(entry) || lines.includes(`/${entry}`)) return false;
+  await writeFile(path, `${text}${text && !text.endsWith("\n") ? "\n" : ""}${entry}
+`);
+  return true;
+}
+
+// src/io.ts
+var CliError = class extends Error {
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.exitCode = exitCode;
+  }
+  exitCode;
+};
+
+// src/api.ts
+var ApiError = class extends CliError {
+  constructor(message, status, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+  status;
+  code;
+};
+function createApi(io2, apiUrl, token) {
+  async function raw(path, init2 = {}) {
+    const headers = new Headers(init2.headers);
+    headers.set("authorization", `Bearer ${token}`);
+    headers.set("user-agent", "hostedge-cli/0.1.0");
+    let response;
+    try {
+      response = await io2.fetch(`${apiUrl}${path}`, { ...init2, headers });
+    } catch {
+      throw new CliError(`Could not reach ${apiUrl}. Check your connection, or HOSTEDGE_API_URL.`);
+    }
+    if (!response.ok) {
+      const body = await response.json().catch(() => ({}));
+      const fields = body.error?.fields ? ` ${Object.entries(body.error.fields).map(([k, v]) => `${k}: ${v}`).join("; ")}` : "";
+      const message = response.status === 401 ? `${body.error?.message ?? "Not signed in."} Run \`hostedge login\`.` : `${body.error?.message ?? `HostEdge answered ${response.status}.`}${fields}`;
+      throw new ApiError(message, response.status, body.error?.code ?? null);
+    }
+    return response;
+  }
+  return {
+    apiUrl,
+    raw,
+    async request(path, init2 = {}) {
+      const { json, ...rest } = init2;
+      let request = rest;
+      if (json !== void 0) {
+        const headers = new Headers(rest.headers);
+        headers.set("content-type", "application/json");
+        request = { ...rest, method: rest.method ?? "POST", headers, body: JSON.stringify(json) };
+      }
+      const response = await raw(path, request);
+      return await response.json();
+    }
+  };
+}
+async function connect(io2) {
+  const { apiUrl, token } = await credentials(io2);
+  if (!token) throw new CliError("Not signed in. Run `hostedge login` (or set HOSTEDGE_TOKEN).");
+  return createApi(io2, apiUrl, token);
+}
+
+// src/output.ts
+function styles(io2) {
+  const on = io2.isTty && !io2.env.NO_COLOR;
+  const wrap = (open, close) => (text) => on ? `\x1B[${open}m${text}\x1B[${close}m` : text;
+  return {
+    bold: wrap(1, 22),
+    dim: wrap(2, 22),
+    red: wrap(31, 39),
+    green: wrap(32, 39),
+    yellow: wrap(33, 39),
+    cyan: wrap(36, 39)
+  };
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ["KB", "MB", "GB"];
+  let value = bytes / 1024;
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit += 1;
+  }
+  return `${value.toFixed(value >= 10 ? 0 : 1)} ${units[unit]}`;
+}
+
+// src/commands/auth.ts
+var LOGIN_TIMEOUT_MS = 5 * 6e4;
+var DONE_PAGE = `<!doctype html><meta charset="utf-8"><title>hostedge CLI</title>
+<body style="font:16px system-ui;margin:4rem auto;max-width:28rem;color:#16161a;background:#f7f6f2">
+<p><strong>The hostedge CLI is signed in.</strong></p><p>You can close this tab and return to your terminal.</p>`;
+async function browserLogin(io2, apiUrl) {
+  const state = randomBytes(24).toString("base64url");
+  let resolveToken = () => void 0;
+  const received = new Promise((resolve5) => {
+    resolveToken = resolve5;
+  });
+  const server = createServer((req, res) => {
+    const url2 = new URL(req.url ?? "/", "http://127.0.0.1");
+    const token = url2.searchParams.get("token");
+    if (url2.pathname !== "/callback" || url2.searchParams.get("state") !== state || !token) {
+      res.writeHead(400, { "content-type": "text/plain" }).end("Unexpected request.");
+      return;
+    }
+    res.writeHead(200, { "content-type": "text/html; charset=utf-8" }).end(DONE_PAGE);
+    resolveToken(token);
+  });
+  await new Promise((resolve5) => server.listen(0, "127.0.0.1", resolve5));
+  const address = server.address();
+  const port = typeof address === "object" && address ? address.port : 0;
+  const url = `${apiUrl}/cli/authorize?${new URLSearchParams({ port: String(port), state, host: hostname() })}`;
+  const s = styles(io2);
+  const opened = await io2.openUrl(url);
+  io2.stdout(
+    opened ? `Opened your browser to authorize the CLI. If nothing happened, visit:
+  ${s.bold(url)}
+` : `Open this URL in a browser to authorize the CLI:
+  ${s.bold(url)}
+`
+  );
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(
+      () => reject(new CliError("Timed out waiting for the browser. Run `hostedge login` again.")),
+      LOGIN_TIMEOUT_MS
+    );
+  });
+  try {
+    return await Promise.race([received, timeout]);
+  } finally {
+    clearTimeout(timer);
+    server.close();
+  }
+}
+async function login(io2, options) {
+  const saved = await readConfig(io2);
+  const apiUrl = (options.api ?? io2.env.HOSTEDGE_API_URL ?? saved.apiUrl ?? DEFAULT_API_URL).replace(/\/+$/, "");
+  const token = options.token ?? await browserLogin(io2, apiUrl);
+  const identity = await createApi(io2, apiUrl, token).request("/api/v1/me");
+  await writeConfig(io2, { apiUrl, token, workspace: identity.workspace.slug });
+  const s = styles(io2);
+  io2.stdout(
+    `${s.green("\u2713")} Signed in as ${s.bold(identity.user.email)} in ${s.bold(identity.workspace.name)}.
+`
+  );
+  return 0;
+}
+async function logout(io2) {
+  await clearConfig(io2);
+  io2.stdout(
+    "Signed out on this computer. The token still exists until you revoke it in Settings \u2192 API tokens.\n"
+  );
+  return 0;
+}
+async function whoami(io2) {
+  const api = await connect(io2);
+  const me = await api.request("/api/v1/me");
+  const { apiUrl } = await credentials(io2);
+  io2.stdout(
+    `${me.user.email} in ${me.workspace.name} (${me.workspace.slug}) on ${apiUrl}
+Scopes: ${me.scopes.join(", ")}
+`
+  );
+  return 0;
+}
+
+// ../../packages/core/src/plans.ts
+var MB = 1024 * 1024;
+var GB = 1024 * MB;
+var PLANS = {
+  free: {
+    id: "free",
+    name: "Free",
+    priceMonthlyUsd: 0,
+    limits: {
+      projects: 3,
+      customDomains: 1,
+      requestsPerMonth: 1e5,
+      bandwidthBytesPerMonth: 10 * GB,
+      members: 1,
+      cpuMs: 10,
+      subrequests: 50,
+      maxDeploymentBytes: 50 * MB,
+      maxFiles: 2e3,
+      runtimeLogsPerDay: 2e4,
+      analyticsEventsPerMonth: 2e4,
+      analyticsRetentionDays: 30,
+      storageResourcesPerProject: 3,
+      storageBytes: 1 * GB,
+      kvOperationsPerMonth: 1e6,
+      cronJobsPerProject: 2,
+      cronMinIntervalMinutes: 60,
+      formSubmissionsPerMonth: 100,
+      formRetentionDays: 90,
+      monitorsPerProject: 2,
+      monitorMinIntervalSeconds: 300
+    }
+  },
+  starter: {
+    id: "starter",
+    name: "Starter",
+    priceMonthlyUsd: 9,
+    limits: {
+      projects: 10,
+      customDomains: 5,
+      requestsPerMonth: 1e6,
+      bandwidthBytesPerMonth: 100 * GB,
+      members: 3,
+      cpuMs: 30,
+      subrequests: 100,
+      maxDeploymentBytes: 250 * MB,
+      maxFiles: 2e4,
+      runtimeLogsPerDay: 2e5,
+      analyticsEventsPerMonth: 2e5,
+      analyticsRetentionDays: 365,
+      storageResourcesPerProject: 10,
+      storageBytes: 10 * GB,
+      kvOperationsPerMonth: 1e7,
+      cronJobsPerProject: 10,
+      cronMinIntervalMinutes: 5,
+      formSubmissionsPerMonth: 2e3,
+      formRetentionDays: 365,
+      monitorsPerProject: 10,
+      monitorMinIntervalSeconds: 60
+    }
+  },
+  pro: {
+    id: "pro",
+    name: "Pro",
+    priceMonthlyUsd: 29,
+    limits: {
+      projects: 50,
+      customDomains: 25,
+      requestsPerMonth: 1e7,
+      bandwidthBytesPerMonth: 500 * GB,
+      members: 10,
+      cpuMs: 50,
+      subrequests: 500,
+      maxDeploymentBytes: 250 * MB,
+      maxFiles: 2e4,
+      runtimeLogsPerDay: 2e6,
+      analyticsEventsPerMonth: 2e6,
+      analyticsRetentionDays: 730,
+      storageResourcesPerProject: 25,
+      storageBytes: 100 * GB,
+      kvOperationsPerMonth: 5e7,
+      cronJobsPerProject: 50,
+      cronMinIntervalMinutes: 1,
+      formSubmissionsPerMonth: 2e4,
+      formRetentionDays: 730,
+      monitorsPerProject: 50,
+      monitorMinIntervalSeconds: 60
+    }
+  },
+  agency: {
+    id: "agency",
+    name: "Agency",
+    priceMonthlyUsd: 79,
+    limits: {
+      projects: null,
+      customDomains: 100,
+      requestsPerMonth: 5e7,
+      bandwidthBytesPerMonth: 2e3 * GB,
+      members: 25,
+      cpuMs: 50,
+      subrequests: 1e3,
+      maxDeploymentBytes: 250 * MB,
+      maxFiles: 2e4,
+      runtimeLogsPerDay: 1e7,
+      analyticsEventsPerMonth: 1e7,
+      analyticsRetentionDays: 1095,
+      storageResourcesPerProject: 50,
+      storageBytes: 500 * GB,
+      kvOperationsPerMonth: 2e8,
+      cronJobsPerProject: 100,
+      cronMinIntervalMinutes: 1,
+      formSubmissionsPerMonth: 1e5,
+      formRetentionDays: 1095,
+      monitorsPerProject: 100,
+      monitorMinIntervalSeconds: 60
+    }
+  }
+};
+var MAX_FILE_BYTES = 25 * MB;
+
+// ../../packages/core/src/projects/upload.ts
+var ALLOWED_EXTENSIONS = /* @__PURE__ */ new Set([
+  "html",
+  "htm",
+  "css",
+  "js",
+  "mjs",
+  "cjs",
+  "jsx",
+  "ts",
+  "tsx",
+  "json",
+  "map",
+  "webmanifest",
+  "txt",
+  "md",
+  "mdx",
+  "xml",
+  "csv",
+  "svg",
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "webp",
+  "avif",
+  "ico",
+  "bmp",
+  "woff",
+  "woff2",
+  "ttf",
+  "otf",
+  "eot",
+  "wasm",
+  "pdf",
+  "mp4",
+  "webm",
+  "ogg",
+  "mp3",
+  "wav",
+  "m4a",
+  "vtt",
+  "astro",
+  "vue",
+  "svelte",
+  // Template languages that static site generators build from (Eleventy and friends).
+  "njk",
+  "liquid",
+  "hbs",
+  "handlebars",
+  "mustache",
+  "ejs",
+  "pug",
+  "webc",
+  "scss",
+  "sass",
+  "less",
+  "yaml",
+  "yml",
+  "toml",
+  "lock",
+  "gitignore",
+  "npmrc",
+  "nvmrc",
+  "editorconfig",
+  "prettierrc",
+  "eslintrc",
+  "browserslistrc",
+  "gltf",
+  "glb",
+  "zip"
+]);
+var ALLOWED_BARE_NAMES = /* @__PURE__ */ new Set([
+  "license",
+  "readme",
+  "cname",
+  "_headers",
+  "_redirects",
+  "dockerfile",
+  "procfile",
+  "makefile",
+  "notice",
+  "authors",
+  "changelog"
+]);
+var BLOCKED_SEGMENTS = /* @__PURE__ */ new Set([
+  ".git",
+  ".svn",
+  ".hg",
+  "node_modules",
+  ".DS_Store",
+  "__MACOSX",
+  ".wrangler",
+  ".vercel",
+  ".netlify"
+]);
+var SECRET_NAMES = /^(\.env(\..*)?|.*\.pem|.*\.key|id_rsa.*|\.npmrc\.local|\.dev\.vars.*)$/i;
+var HASH_PATTERN = /^[0-9a-f]{32}$/;
+function normalisePath(raw) {
+  if (typeof raw !== "string" || raw.length === 0) return { ok: false, reason: "Empty file name." };
+  if (raw.length > 512) return { ok: false, reason: "Path is longer than 512 characters." };
+  if (/[\u0000-\u001f\u007f]/.test(raw))
+    return { ok: false, reason: "Path contains control characters." };
+  const path = raw.replace(/\\/g, "/").replace(/^\.\//, "");
+  if (path.startsWith("/") || /^[a-zA-Z]:/.test(path))
+    return { ok: false, reason: "Absolute paths are not allowed." };
+  const segments = path.split("/");
+  if (segments.some((s) => s === "..")) return { ok: false, reason: "Paths may not contain \u201C..\u201D." };
+  if (segments.some((s) => s === "" || s === "."))
+    return { ok: false, reason: "Path has an empty or \u201C.\u201D segment." };
+  return { ok: true, path };
+}
+function isIgnoredPath(path) {
+  return path.split("/").some((segment) => BLOCKED_SEGMENTS.has(segment));
+}
+function fileTypeProblem(path) {
+  const name = path.slice(path.lastIndexOf("/") + 1);
+  if (SECRET_NAMES.test(name))
+    return "Looks like a secret (env file or key). Remove it \u2014 set secrets as environment variables instead.";
+  const dot = name.lastIndexOf(".");
+  const ext = dot > 0 ? name.slice(dot + 1).toLowerCase() : name.startsWith(".") ? name.slice(1).toLowerCase() : "";
+  if (!ext || dot <= 0) {
+    if (name.startsWith(".") && ALLOWED_EXTENSIONS.has(ext)) return null;
+    return ALLOWED_BARE_NAMES.has(name.toLowerCase()) ? null : `\u201C${name}\u201D has no file extension HostEdge can serve.`;
+  }
+  return ALLOWED_EXTENSIONS.has(ext) ? null : `.${ext} files can\u2019t be deployed.`;
+}
+function checkManifest(entries, limits) {
+  const problems = [];
+  const ignored = [];
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  if (!Array.isArray(entries))
+    return {
+      files,
+      ignored,
+      problems: [{ path: "", reason: "Manifest must be a list of files." }],
+      totalBytes: 0
+    };
+  for (const raw of entries) {
+    const entry = raw;
+    const rawPath = typeof entry?.path === "string" ? entry.path : "";
+    const normal = normalisePath(rawPath);
+    if (!normal.ok) {
+      problems.push({ path: rawPath, reason: normal.reason });
+      continue;
+    }
+    const { path } = normal;
+    if (isIgnoredPath(path)) {
+      ignored.push(path);
+      continue;
+    }
+    const lower = path.toLowerCase();
+    if (seen.has(lower)) {
+      problems.push({ path, reason: "Two files share this path (names differ only in case)." });
+      continue;
+    }
+    seen.add(lower);
+    const size = entry?.size;
+    const hash = entry?.hash;
+    if (typeof size !== "number" || !Number.isInteger(size) || size < 0) {
+      problems.push({ path, reason: "Invalid file size." });
+      continue;
+    }
+    if (size > MAX_FILE_BYTES) {
+      problems.push({
+        path,
+        reason: `File is ${(size / 1024 / 1024).toFixed(1)} MB; the limit per file is 25 MB.`
+      });
+      continue;
+    }
+    if (typeof hash !== "string" || !HASH_PATTERN.test(hash)) {
+      problems.push({ path, reason: "Invalid content hash." });
+      continue;
+    }
+    const typeProblem = fileTypeProblem(path);
+    if (typeProblem) {
+      problems.push({ path, reason: typeProblem });
+      continue;
+    }
+    files.push({ path, size, hash });
+  }
+  const totalBytes = files.reduce((sum, f) => sum + f.size, 0);
+  if (files.length === 0 && problems.length === 0)
+    problems.push({ path: "", reason: "No files to deploy." });
+  if (files.length > limits.maxFiles)
+    problems.push({
+      path: "",
+      reason: `This deploy has ${files.length.toLocaleString("en-US")} files; your plan allows ${limits.maxFiles.toLocaleString("en-US")}.`
+    });
+  if (totalBytes > limits.maxDeploymentBytes) {
+    problems.push({
+      path: "",
+      reason: `This deploy is ${(totalBytes / 1024 / 1024).toFixed(1)} MB; your plan allows ${Math.round(limits.maxDeploymentBytes / 1024 / 1024)} MB.`
+    });
+  }
+  return { files, ignored, problems, totalBytes };
+}
+
+// ../../packages/core/src/projects/frameworks.ts
+var NEXT_CACHE_OUTPUT = "_hostedge/next-cache";
+var OPEN_NEXT_DEFAULT_CONFIG = `// Written by HostEdge because this project had no open-next.config.ts.
+// Commit your own to change it: https://opennext.js.org/cloudflare/caching
+import { defineCloudflareConfig, getCloudflareContext } from '@opennextjs/cloudflare'
+import r2IncrementalCache from '@opennextjs/cloudflare/overrides/incremental-cache/r2-incremental-cache'
+import d1NextTagCache from '@opennextjs/cloudflare/overrides/tag-cache/d1-next-tag-cache'
+
+const pending = new Set<string>()
+
+/** Stale-while-revalidate: answer now, regenerate the page after the response. */
+const queue = {
+  name: 'hostedge-queue',
+  async send(message: {
+    MessageBody: { host: string; url: string }
+    MessageDeduplicationId: string
+  }) {
+    const { host, url } = message.MessageBody
+    const id = message.MessageDeduplicationId
+    if (pending.has(id)) return
+    pending.add(id)
+    const protocol = host.includes('localhost') ? 'http' : 'https'
+    const work = fetch(\`\${protocol}://\${host}\${url}\`, {
+      method: 'HEAD',
+      headers: {
+        'x-prerender-revalidate': process.env.NEXT_PREVIEW_MODE_ID ?? '',
+        'x-isr': '1',
+      },
+      signal: AbortSignal.timeout(10_000),
+    })
+      .then((response) => response.body?.cancel())
+      .catch(() => undefined)
+      .finally(() => pending.delete(id))
+    getCloudflareContext().ctx.waitUntil(work)
+  },
+}
+
+export default defineCloudflareConfig({
+  incrementalCache: r2IncrementalCache,
+  tagCache: d1NextTagCache,
+  queue: () => Promise.resolve(queue),
+})
+`;
+var OPEN_NEXT_DEFAULT_WRANGLER = `// Written by HostEdge because this project had no wrangler config.
+{
+  "name": "hostedge-app",
+  "main": ".open-next/worker.js",
+  "compatibility_date": "{{compatibilityDate}}",
+  "compatibility_flags": ["nodejs_compat", "global_fetch_strictly_public"],
+  "assets": { "directory": ".open-next/assets", "binding": "ASSETS" },
+  "r2_buckets": [{ "binding": "NEXT_INC_CACHE_R2_BUCKET", "bucket_name": "hostedge-next-cache" }],
+  "d1_databases": [
+    {
+      "binding": "NEXT_TAG_CACHE_D1",
+      "database_name": "hostedge-next-tags",
+      "database_id": "00000000-0000-0000-0000-000000000000"
+    }
+  ]
+}
+`;
+var npm = (outputDirectory, buildCommand = "npm run build") => ({
+  installCommand: "npm install",
+  buildCommand,
+  outputDirectory
+});
+var FRAMEWORK_INFO = {
+  static: {
+    id: "static",
+    name: "Static HTML",
+    description: "No build step. Your files are deployed as they are.",
+    group: "static",
+    defaults: { installCommand: null, buildCommand: null, outputDirectory: null },
+    notFound: "404-page"
+  },
+  astro: {
+    id: "astro",
+    name: "Astro",
+    description: "Static build to dist/. Your 404 page answers unknown paths.",
+    group: "static",
+    defaults: npm("dist"),
+    notFound: "404-page",
+    outputHint: "Astro writes dist/ for static output. With @astrojs/cloudflare, pick Astro (server)."
+  },
+  next: {
+    id: "next",
+    name: "Next.js (static export)",
+    description: 'Static export to out/. Needs output: "export" in next.config.',
+    group: "app",
+    defaults: npm("out"),
+    notFound: "404-page",
+    outputHint: 'Next.js writes out/ only when next.config sets output: "export". For server features, pick Next.js (full, OpenNext).'
+  },
+  nuxt: {
+    id: "nuxt",
+    name: "Nuxt (static)",
+    description: "Prerendered with nuxi generate to .output/public.",
+    group: "app",
+    defaults: npm(".output/public", "npx nuxi generate"),
+    notFound: "404-page",
+    outputHint: "Nuxt writes .output/public with `nuxi generate`. For a server, pick Nuxt (server)."
+  },
+  sveltekit: {
+    id: "sveltekit",
+    name: "SvelteKit (static)",
+    description: "adapter-static build to build/.",
+    group: "app",
+    defaults: npm("build"),
+    notFound: "404-page",
+    outputHint: "SvelteKit writes build/ with @sveltejs/adapter-static. With adapter-cloudflare, pick SvelteKit (server)."
+  },
+  "react-router": {
+    id: "react-router",
+    name: "React Router (SPA mode)",
+    description: "ssr: false build to build/client, with client-side routing.",
+    group: "app",
+    defaults: npm("build/client"),
+    notFound: "single-page-application",
+    outputHint: "React Router writes build/client when react-router.config sets ssr: false."
+  },
+  "next-server": {
+    id: "next-server",
+    name: "Next.js (full, OpenNext)",
+    description: "Server rendering, API routes, server actions and middleware, through @opennextjs/cloudflare.",
+    group: "server",
+    defaults: npm(".open-next/assets", "npx opennextjs-cloudflare build"),
+    notFound: "none",
+    server: {
+      entry: ".open-next/worker.js",
+      packages: ["@opennextjs/cloudflare@^1", "wrangler@^4"],
+      files: [
+        {
+          path: "open-next.config.ts",
+          content: OPEN_NEXT_DEFAULT_CONFIG,
+          unless: ["open-next.config.ts"]
+        },
+        {
+          path: "wrangler.jsonc",
+          content: OPEN_NEXT_DEFAULT_WRANGLER,
+          unless: ["wrangler.jsonc", "wrangler.json", "wrangler.toml"]
+        }
+      ],
+      extraOutput: { from: ".open-next/cache", to: NEXT_CACHE_OUTPUT }
+    },
+    outputHint: "OpenNext writes .open-next/. HostEdge adds @opennextjs/cloudflare and its config when they are missing."
+  },
+  "astro-server": {
+    id: "astro-server",
+    name: "Astro (server)",
+    description: "On-demand rendering and endpoints with the @astrojs/cloudflare adapter.",
+    group: "server",
+    defaults: npm("dist/client"),
+    notFound: "none",
+    server: { entry: null },
+    outputHint: "Astro with @astrojs/cloudflare writes dist/client and dist/server."
+  },
+  "sveltekit-server": {
+    id: "sveltekit-server",
+    name: "SvelteKit (server)",
+    description: "Server load functions and form actions with @sveltejs/adapter-cloudflare.",
+    group: "server",
+    defaults: npm(".svelte-kit/cloudflare"),
+    notFound: "none",
+    server: { entry: ".svelte-kit/cloudflare/_worker.js" },
+    outputHint: "SvelteKit with @sveltejs/adapter-cloudflare writes .svelte-kit/cloudflare."
+  },
+  "nuxt-server": {
+    id: "nuxt-server",
+    name: "Nuxt (server)",
+    description: "Server routes and SSR with the Nitro cloudflare_module preset.",
+    group: "server",
+    defaults: npm(".output/public", "npx nuxi build --preset=cloudflare_module"),
+    notFound: "none",
+    server: { entry: ".output/server/index.mjs" },
+    outputHint: "Nuxt writes .output/public and .output/server with the cloudflare_module preset."
+  },
+  "react-router-server": {
+    id: "react-router-server",
+    name: "React Router (server)",
+    description: "Loaders, actions and SSR with @cloudflare/vite-plugin.",
+    group: "server",
+    defaults: npm("build/client"),
+    notFound: "none",
+    server: { entry: null },
+    outputHint: "React Router with @cloudflare/vite-plugin writes build/client and build/server."
+  },
+  "vite-react": {
+    id: "vite-react",
+    name: "Vite + React",
+    description: "Single-page app in dist/. Unknown paths serve index.html.",
+    group: "app",
+    defaults: npm("dist"),
+    notFound: "single-page-application"
+  },
+  "vite-vue": {
+    id: "vite-vue",
+    name: "Vite + Vue",
+    description: "Single-page app in dist/. Unknown paths serve index.html.",
+    group: "app",
+    defaults: npm("dist"),
+    notFound: "single-page-application"
+  },
+  "vite-svelte": {
+    id: "vite-svelte",
+    name: "Vite + Svelte",
+    description: "Single-page app in dist/. Unknown paths serve index.html.",
+    group: "app",
+    defaults: npm("dist"),
+    notFound: "single-page-application"
+  },
+  vite: {
+    id: "vite",
+    name: "Vite",
+    description: "Solid, Preact, Lit or plain Vite in dist/, with client-side routing.",
+    group: "app",
+    defaults: npm("dist"),
+    notFound: "single-page-application"
+  },
+  angular: {
+    id: "angular",
+    name: "Angular",
+    description: "Browser build in dist/<project>/browser, with client-side routing.",
+    group: "app",
+    defaults: npm("dist/app/browser"),
+    notFound: "single-page-application",
+    outputHint: "Angular writes dist/<project name>/browser. Set the output directory to match angular.json."
+  },
+  "create-react-app": {
+    id: "create-react-app",
+    name: "Create React App",
+    description: "Single-page app in build/. Unknown paths serve index.html.",
+    group: "app",
+    defaults: npm("build"),
+    notFound: "single-page-application"
+  },
+  gatsby: {
+    id: "gatsby",
+    name: "Gatsby",
+    description: "Static build to public/.",
+    group: "static",
+    defaults: npm("public"),
+    notFound: "404-page"
+  },
+  docusaurus: {
+    id: "docusaurus",
+    name: "Docusaurus",
+    description: "Documentation site built to build/.",
+    group: "docs",
+    defaults: npm("build"),
+    notFound: "404-page"
+  },
+  vitepress: {
+    id: "vitepress",
+    name: "VitePress",
+    description: "Documentation site built to .vitepress/dist.",
+    group: "docs",
+    defaults: npm("docs/.vitepress/dist", "npm run docs:build"),
+    notFound: "404-page",
+    outputHint: "VitePress writes <docs folder>/.vitepress/dist."
+  },
+  eleventy: {
+    id: "eleventy",
+    name: "Eleventy",
+    description: "Static build to _site/.",
+    group: "static",
+    defaults: npm("_site", "npx @11ty/eleventy"),
+    notFound: "404-page"
+  },
+  hono: {
+    id: "hono",
+    name: "Hono",
+    description: "A Worker (dist/_worker.js) with static files served alongside.",
+    group: "worker",
+    defaults: npm("dist"),
+    notFound: "none",
+    outputHint: "The build must write dist/_worker.js (a single bundled file)."
+  },
+  other: {
+    id: "other",
+    name: "Other",
+    description: "Any build that writes static files, or a _worker.js, to a folder.",
+    group: "static",
+    defaults: npm("dist"),
+    notFound: "404-page"
+  }
+};
+var LOCKFILES = [
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["package-lock.json", "npm"],
+  ["npm-shrinkwrap.json", "npm"]
+];
+function installCommandFor(pm, locked, yarnBerry) {
+  if (pm === "pnpm") return locked ? "pnpm install --frozen-lockfile" : "pnpm install";
+  if (pm === "yarn")
+    return locked ? yarnBerry ? "yarn install --immutable" : "yarn install --frozen-lockfile" : "yarn install";
+  return locked ? "npm ci" : "npm install";
+}
+function withPackageManager(defaults, pm, install) {
+  const run2 = (cmd) => {
+    if (!cmd || pm === "npm") return cmd;
+    const match = /^npm run (\S+)(.*)$/.exec(cmd);
+    if (match)
+      return pm === "yarn" ? `yarn ${match[1]}${match[2]}` : `pnpm run ${match[1]}${match[2]}`;
+    if (cmd.startsWith("npx "))
+      return pm === "yarn" ? `yarn dlx ${cmd.slice(4)}` : `pnpm exec ${cmd.slice(4)}`;
+    return cmd;
+  };
+  return {
+    installCommand: defaults.installCommand === null ? null : install ?? installCommandFor(pm, false, false),
+    buildCommand: run2(defaults.buildCommand),
+    outputDirectory: defaults.outputDirectory
+  };
+}
+function parsePackageJson(text) {
+  if (!text) return null;
+  try {
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function scoped(paths, root) {
+  if (!root) return paths;
+  const prefix = `${root.replace(/\/+$/, "")}/`;
+  return paths.filter((p) => p.startsWith(prefix)).map((p) => p.slice(prefix.length));
+}
+var has = (...names) => (deps) => names.some((n) => n in deps);
+var RULES = [
+  {
+    framework: "next-server",
+    when: (d) => "next" in d && "@opennextjs/cloudflare" in d,
+    found: "next and @opennextjs/cloudflare"
+  },
+  {
+    framework: "astro-server",
+    when: (d) => "astro" in d && "@astrojs/cloudflare" in d,
+    found: "astro and @astrojs/cloudflare"
+  },
+  {
+    framework: "sveltekit-server",
+    when: (d) => "@sveltejs/kit" in d && "@sveltejs/adapter-cloudflare" in d,
+    found: "@sveltejs/kit and @sveltejs/adapter-cloudflare"
+  },
+  {
+    framework: "nuxt-server",
+    when: (d) => ("nuxt" in d || "nuxt3" in d) && ("nitro-cloudflare-dev" in d || "wrangler" in d),
+    found: "nuxt with Cloudflare tooling"
+  },
+  {
+    framework: "react-router-server",
+    when: (d) => "@react-router/dev" in d && "@cloudflare/vite-plugin" in d,
+    found: "@react-router/dev and @cloudflare/vite-plugin"
+  },
+  {
+    // HostEdge adds OpenNext during the build, so plain Next.js apps get the full runtime.
+    framework: "next-server",
+    when: has("next"),
+    found: "next",
+    problem: () => 'HostEdge adds @opennextjs/cloudflare during the build. If next.config sets output: "export", pick Next.js (static export) instead.'
+  },
+  {
+    framework: "nuxt",
+    when: has("nuxt", "nuxt3"),
+    found: "nuxt",
+    tune: (pkg) => pkg.scripts?.generate ? { buildCommand: "npm run generate" } : {}
+  },
+  {
+    framework: "sveltekit",
+    when: has("@sveltejs/kit"),
+    found: "@sveltejs/kit",
+    problem: (deps) => "@sveltejs/adapter-static" in deps ? null : "Use @sveltejs/adapter-static for a static site, or @sveltejs/adapter-cloudflare and pick SvelteKit (server)."
+  },
+  {
+    framework: "react-router",
+    when: has("@react-router/dev"),
+    found: "@react-router/dev",
+    problem: () => "Deployed in SPA mode: set ssr: false in react-router.config. For server rendering, add @cloudflare/vite-plugin and pick React Router (server)."
+  },
+  { framework: "astro", when: has("astro"), found: "astro" },
+  { framework: "gatsby", when: has("gatsby"), found: "gatsby" },
+  { framework: "docusaurus", when: has("@docusaurus/core"), found: "@docusaurus/core" },
+  {
+    framework: "vitepress",
+    when: has("vitepress"),
+    found: "vitepress",
+    tune: (pkg) => {
+      const entry = Object.entries(pkg.scripts ?? {}).find(
+        ([, cmd]) => /\bvitepress build\b/.test(cmd)
+      );
+      if (!entry) return {};
+      const dir = /\bvitepress build\s+([^\s-][^\s]*)/.exec(entry[1])?.[1]?.replace(/^\.\/|\/$/g, "");
+      return {
+        buildCommand: `npm run ${entry[0]}`,
+        outputDirectory: dir && dir !== "." ? `${dir}/.vitepress/dist` : ".vitepress/dist"
+      };
+    }
+  },
+  {
+    framework: "eleventy",
+    when: has("@11ty/eleventy"),
+    found: "@11ty/eleventy",
+    tune: (pkg) => pkg.scripts?.build ? { buildCommand: "npm run build" } : {}
+  },
+  {
+    framework: "angular",
+    when: has("@angular/core"),
+    found: "@angular/core",
+    tune: (pkg) => {
+      const name = pkg.name?.replace(/^@[^/]+\//, "");
+      return name && /^[\w.-]+$/.test(name) ? { outputDirectory: `dist/${name}/browser` } : {};
+    }
+  },
+  { framework: "create-react-app", when: has("react-scripts"), found: "react-scripts" },
+  { framework: "hono", when: has("hono"), found: "hono" },
+  {
+    framework: "vite-react",
+    when: (d) => "vite" in d && ("react" in d || "react-dom" in d),
+    found: "vite and react"
+  },
+  { framework: "vite-vue", when: (d) => "vite" in d && "vue" in d, found: "vite and vue" },
+  { framework: "vite-svelte", when: (d) => "vite" in d && "svelte" in d, found: "vite and svelte" },
+  { framework: "vite", when: has("vite"), found: "vite" }
+];
+function packageManagerFrom(paths, allPaths, pkg) {
+  const lock = LOCKFILES.find(([file]) => paths.includes(file) || allPaths.includes(file));
+  const declared = /^(npm|pnpm|yarn)@(\d+)/.exec(pkg?.packageManager ?? "");
+  const pm = lock?.[1] ?? declared?.[1] ?? "npm";
+  const berry = pm === "yarn" && (paths.includes(".yarnrc.yml") || allPaths.includes(".yarnrc.yml") || Number(declared?.[2] ?? 1) >= 2);
+  const bun = ["bun.lockb", "bun.lock"].some((f) => paths.includes(f) || allPaths.includes(f));
+  return {
+    pm,
+    locked: Boolean(lock),
+    berry,
+    note: bun && !lock ? "Found a Bun lockfile; builds use npm, so bun-only APIs won\u2019t run." : null
+  };
+}
+function detectFramework(allPaths, packageJsonText, rootDirectory = "") {
+  const normalised = allPaths.map((p) => p.replace(/^\/+/, ""));
+  const paths = scoped(normalised, rootDirectory);
+  const pkg = parsePackageJson(packageJsonText);
+  const deps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+  const manager = packageManagerFrom(paths, normalised, pkg);
+  const install = installCommandFor(manager.pm, manager.locked, manager.berry);
+  const settingsFor = (framework, overrides = {}) => ({
+    framework,
+    rootDirectory,
+    ...withPackageManager(
+      { ...FRAMEWORK_INFO[framework].defaults, ...overrides },
+      manager.pm,
+      install
+    )
+  });
+  const managerNote = [
+    manager.locked ? `Installs with ${manager.pm} from the lockfile.` : null,
+    manager.note
+  ].filter(Boolean).join(" ");
+  const withNote = (reason) => managerNote ? `${reason} ${managerNote}` : reason;
+  if (pkg) {
+    const rule = RULES.find((r) => r.when(deps, pkg));
+    if (rule)
+      return {
+        settings: settingsFor(rule.framework, rule.tune?.(pkg, deps)),
+        reason: withNote(`Found ${rule.found} in package.json.`),
+        problem: rule.problem?.(deps) ?? null
+      };
+    if (pkg.scripts?.build)
+      return {
+        settings: settingsFor("other"),
+        reason: withNote("Found a build script in package.json."),
+        problem: null
+      };
+    if (paths.includes("index.html"))
+      return {
+        settings: settingsFor("static"),
+        reason: "Found index.html and no build script.",
+        problem: null
+      };
+    return {
+      settings: settingsFor("other"),
+      reason: "Found package.json without a build script.",
+      problem: 'Add a "build" script to package.json, or deploy the folder that contains index.html.'
+    };
+  }
+  if (paths.includes("index.html"))
+    return { settings: settingsFor("static"), reason: "Found index.html.", problem: null };
+  const nested = paths.find((p) => /^[^/]+\/index\.html$/.test(p));
+  if (nested) {
+    const dir = nested.split("/")[0] ?? "";
+    return {
+      settings: settingsFor("static", { outputDirectory: dir }),
+      reason: `Found ${nested}.`,
+      problem: null
+    };
+  }
+  const anyHtml = paths.some((p) => p.endsWith(".html"));
+  return {
+    settings: settingsFor("static"),
+    reason: anyHtml ? "Found HTML files but no index.html." : "No HTML files found.",
+    problem: anyHtml ? "Add an index.html so the site has a home page." : "This folder has no index.html. Drop the folder that contains your site\u2019s index.html."
+  };
+}
+
+// ../../packages/core/src/client.ts
+async function contentHash(content) {
+  const buffer = content instanceof Uint8Array ? content : new Uint8Array(content);
+  const digest = new Uint8Array(
+    await crypto.subtle.digest("SHA-256", buffer)
+  );
+  let hex = "";
+  for (const byte of digest) hex += byte.toString(16).padStart(2, "0");
+  return hex.slice(0, 32);
+}
+
+// src/commands/deploy.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import { basename, join as join3, resolve } from "node:path";
+
+// src/files.ts
+import { lstat, readdir, readFile as readFile2 } from "node:fs/promises";
+import { join as join2, relative, sep } from "node:path";
+var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", ".hostedge", ".next", ".turbo", ".wrangler"]);
+async function collectFiles(root, limits = { maxFiles: 1e5 }) {
+  const files = [];
+  const skipped = [];
+  async function walk(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      const absolute = join2(dir, entry.name);
+      const rel = relative(root, absolute).split(sep).join("/");
+      if (entry.isSymbolicLink())
+        throw new CliError(
+          `${rel} is a symbolic link. HostEdge uploads real files only \u2014 replace the link with the file it points to.`
+        );
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name)) skipped.push(`${rel}/`);
+        else await walk(absolute);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      const normal = normalisePath(rel);
+      if (!normal.ok) throw new CliError(`${rel}: ${normal.reason}`);
+      if (isIgnoredPath(normal.path)) {
+        skipped.push(normal.path);
+        continue;
+      }
+      if (files.length >= limits.maxFiles)
+        throw new CliError(`More than ${limits.maxFiles.toLocaleString("en-US")} files to upload.`);
+      const stat2 = await lstat(absolute);
+      files.push({ path: normal.path, size: stat2.size, hash: "", absolute });
+    }
+  }
+  try {
+    await walk(root);
+  } catch (error) {
+    if (error instanceof CliError) throw error;
+    throw new CliError(`Could not read ${root}: ${error.message}`);
+  }
+  const check = checkManifest(
+    files.map((f) => ({ path: f.path, size: f.size, hash: "0".repeat(32) })),
+    { maxDeploymentBytes: Number.MAX_SAFE_INTEGER, maxFiles: Number.MAX_SAFE_INTEGER }
+  );
+  const secrets = /* @__PURE__ */ new Set();
+  for (const problem of check.problems) {
+    if (problem.reason.startsWith("Looks like a secret")) secrets.add(problem.path);
+    else throw new CliError(`${problem.path}: ${problem.reason}`);
+  }
+  const upload = files.filter((f) => !secrets.has(f.path));
+  if (limits.hash !== false)
+    for (const file of upload) file.hash = await contentHash(await readFile2(file.absolute));
+  return { files: upload, skipped, secrets: [...secrets] };
+}
+async function pool(items, limit, work) {
+  let next = 0;
+  const runners = Array.from({ length: Math.min(limit, items.length) }, async () => {
+    while (next < items.length) {
+      const item = items[next++];
+      await work(item);
+    }
+  });
+  await Promise.all(runners);
+}
+
+// src/sse.ts
+async function* readSse(body) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let event = "message";
+  let data = [];
+  let id = null;
+  for await (const chunk of body) {
+    buffer += decoder.decode(chunk, { stream: true });
+    let newline = buffer.search(/\r?\n/);
+    while (newline !== -1) {
+      const line = buffer.slice(0, newline);
+      buffer = buffer.slice(buffer[newline] === "\r" ? newline + 2 : newline + 1);
+      if (line === "") {
+        if (data.length > 0) yield { event, data: data.join("\n"), id };
+        event = "message";
+        data = [];
+      } else if (!line.startsWith(":")) {
+        const colon = line.indexOf(":");
+        const field = colon === -1 ? line : line.slice(0, colon);
+        const value = colon === -1 ? "" : line.slice(colon + 1).replace(/^ /, "");
+        if (field === "event") event = value;
+        else if (field === "data") data.push(value);
+        else if (field === "id") id = value;
+      }
+      newline = buffer.search(/\r?\n/);
+    }
+  }
+}
+
+// src/commands/deploy.ts
+var FINISHED = /* @__PURE__ */ new Set(["ready", "failed", "canceled"]);
+var UPLOAD_CONCURRENCY = 8;
+async function follow(io2, api, deploymentId) {
+  const s = styles(io2);
+  let cursor = null;
+  let last = { status: "queued", failureReason: null };
+  for (let attempt = 0; attempt < 20; attempt++) {
+    const response = await api.raw(`/api/v1/deployments/${deploymentId}/events`, {
+      headers: cursor ? { "last-event-id": cursor, accept: "text/event-stream" } : {}
+    });
+    if (!response.body) break;
+    for await (const event of readSse(response.body)) {
+      if (event.id) cursor = event.id;
+      if (event.event === "log") {
+        for (const line of JSON.parse(event.data)) {
+          const text = line.level === "error" ? s.red(line.msg) : line.level === "warn" ? s.yellow(line.msg) : line.level === "success" ? s.green(line.msg) : line.msg;
+          io2.stdout(`${s.dim("\u2502")} ${text}
+`);
+        }
+      } else if (event.event === "status") {
+        const data = JSON.parse(event.data);
+        last = { status: data.status, failureReason: data.failureReason };
+      } else if (event.event === "end") {
+        return last;
+      }
+    }
+    if (FINISHED.has(last.status)) return last;
+    await io2.sleep(1e3);
+  }
+  return last;
+}
+async function deploy(io2, options) {
+  const started = Date.now();
+  const dir = resolve(io2.cwd, options.dir ?? ".");
+  const s = styles(io2);
+  const api = await connect(io2);
+  const link = await readLink(dir);
+  const { files, skipped, secrets } = await collectFiles(dir);
+  if (files.length === 0) throw new CliError(`No files to deploy in ${dir}.`);
+  for (const secret of secrets)
+    io2.stdout(
+      `${s.dim("\u2013")} Left out ${secret}: it looks like a secret. Set it with environment variables instead.
+`
+    );
+  if (skipped.length > 0)
+    io2.stdout(
+      s.dim(
+        `Skipped ${skipped.slice(0, 5).join(", ")}${skipped.length > 5 ? ` and ${skipped.length - 5} more` : ""}
+`
+      )
+    );
+  const total = files.reduce((sum, f) => sum + f.size, 0);
+  const { missing } = await api.request("/api/v1/uploads", {
+    json: { hashes: [...new Set(files.map((f) => f.hash))] }
+  });
+  const needed = new Set(missing);
+  const toUpload = files.filter((f) => {
+    if (!needed.has(f.hash)) return false;
+    needed.delete(f.hash);
+    return true;
+  });
+  const uploadBytes = toUpload.reduce((sum, f) => sum + f.size, 0);
+  io2.stdout(
+    `Uploading ${toUpload.length} of ${files.length} files (${formatBytes(uploadBytes)} of ${formatBytes(total)}; the rest are already on HostEdge)
+`
+  );
+  await pool(toUpload, UPLOAD_CONCURRENCY, async (file) => {
+    const bytes = await readFile3(file.absolute);
+    await api.raw(`/api/v1/uploads/${file.hash}`, {
+      method: "PUT",
+      headers: { "content-type": "application/octet-stream" },
+      body: bytes
+    });
+  });
+  let project;
+  if (!link) {
+    let pkg = null;
+    try {
+      pkg = await readFile3(join3(dir, "package.json"), "utf8");
+    } catch {
+    }
+    project = {
+      name: basename(dir),
+      settings: detectFramework(
+        files.map((f) => f.path),
+        pkg
+      ).settings
+    };
+  }
+  const created = await api.request("/api/v1/deployments", {
+    json: {
+      projectId: link?.projectId,
+      project,
+      files: files.map((f) => ({ path: f.path, hash: f.hash, size: f.size })),
+      environment: options.preview ? "preview" : "production",
+      commitMessage: options.message ?? null
+    }
+  });
+  if (!link) {
+    const me = await api.request("/api/v1/me");
+    await writeLink(dir, {
+      projectId: created.projectId,
+      slug: created.projectSlug ?? created.projectId,
+      workspace: me.workspace.slug
+    });
+    await ensureGitignored(dir, ".hostedge");
+    io2.stdout(
+      `${s.green("\u2713")} Created project ${s.bold(created.projectSlug ?? created.projectId)}
+`
+    );
+  }
+  io2.stdout(`Deployment ${s.bold(created.deploymentId)}
+`);
+  if (options.wait === false) {
+    io2.stdout(`Queued. Follow it at ${created.url}
+`);
+    return 0;
+  }
+  const result = await follow(io2, api, created.deploymentId);
+  const seconds = ((Date.now() - started) / 1e3).toFixed(1);
+  if (result.status === "ready") {
+    io2.stdout(`${s.green("\u2713")} Live in ${seconds}s: ${s.bold(created.url)}
+`);
+    return 0;
+  }
+  if (result.status === "canceled") {
+    io2.stderr(`Deployment canceled.
+`);
+    return 1;
+  }
+  io2.stderr(
+    `${s.red("\u2717")} Deployment ${result.status === "failed" ? "failed" : `stopped while ${result.status}`}${result.failureReason ? `: ${result.failureReason}` : ""}
+`
+  );
+  return 1;
+}
+
+// src/commands/env.ts
+import { writeFile as writeFile2 } from "node:fs/promises";
+import { resolve as resolve3 } from "node:path";
+
+// src/commands/logs.ts
+import { resolve as resolve2 } from "node:path";
+var POLL_MS = 2e3;
+async function requireLink(io2, dir = ".") {
+  const link = await readLink(resolve2(io2.cwd, dir));
+  if (!link)
+    throw new CliError(
+      "This folder isn\u2019t linked to a project. Run `hostedge init` or `hostedge deploy`."
+    );
+  return link;
+}
+var newer = (a, b) => a.ts > b.ts || a.ts === b.ts && a.id > b.id;
+async function logs(io2, options) {
+  const link = await requireLink(io2);
+  const api = await connect(io2);
+  const s = styles(io2);
+  const query = new URLSearchParams();
+  if (options.level) query.set("level", options.level);
+  if (options.search) query.set("q", options.search);
+  query.set("range", options.since ?? (options.follow ? "1h" : "24h"));
+  const print = (row) => {
+    const time = new Date(row.ts).toISOString().replace("T", " ").slice(0, 19);
+    const level = row.level.toUpperCase().padEnd(5);
+    const colored = row.level === "error" ? s.red(level) : row.level === "warn" ? s.yellow(level) : s.dim(level);
+    io2.stdout(`${s.dim(time)} ${colored} ${row.message}
+`);
+  };
+  const fetchRows = async () => (await api.request(
+    `/api/v1/projects/${link.projectId}/logs?${query.toString()}`
+  )).rows;
+  const first = await fetchRows();
+  for (const row of [...first].reverse()) print(row);
+  if (!options.follow) {
+    if (first.length === 0) io2.stdout(s.dim("No logs in this range.\n"));
+    return 0;
+  }
+  let cursor = first[0] ? { ts: first[0].ts, id: first[0].id } : { ts: 0, id: "" };
+  while (!options.signal?.aborted) {
+    await io2.sleep(POLL_MS);
+    if (options.signal?.aborted) break;
+    const rows = (await fetchRows()).filter((row) => newer(row, cursor)).reverse();
+    for (const row of rows) print(row);
+    const last = rows.at(-1);
+    if (last) cursor = { ts: last.ts, id: last.id };
+  }
+  return 0;
+}
+
+// src/commands/env.ts
+async function envPull(io2, options) {
+  const link = await requireLink(io2);
+  const api = await connect(io2);
+  const environment = options.environment ?? "development";
+  const file = options.file ?? ".env.local";
+  const response = await api.raw(
+    `/api/v1/projects/${link.projectId}/env?${new URLSearchParams({ environment, format: "dotenv" })}`
+  );
+  const text = await response.text();
+  const path = resolve3(io2.cwd, file);
+  await writeFile2(path, text, { mode: 384 });
+  const count = text.split("\n").filter(Boolean).length;
+  const ignored = await ensureGitignored(io2.cwd, file);
+  const s = styles(io2);
+  io2.stdout(
+    `${s.green("\u2713")} Wrote ${count} ${environment} variable${count === 1 ? "" : "s"} to ${file}${ignored ? ` (added to .gitignore)` : ""}.
+`
+  );
+  return 0;
+}
+
+// src/commands/init.ts
+import { readFile as readFile4 } from "node:fs/promises";
+import { basename as basename2, join as join4, resolve as resolve4 } from "node:path";
+async function init(io2, options) {
+  const dir = resolve4(io2.cwd, options.dir ?? ".");
+  const s = styles(io2);
+  const existing = await readLink(dir);
+  if (existing && !options.force) {
+    io2.stdout(
+      `Already linked to ${s.bold(existing.slug)}. Use --force to link a different project.
+`
+    );
+    return 0;
+  }
+  const api = await connect(io2);
+  const me = await api.request("/api/v1/me");
+  let project;
+  if (options.project) {
+    const { projects } = await api.request("/api/v1/projects");
+    const found = projects.find((p) => p.id === options.project || p.slug === options.project);
+    if (!found)
+      throw new CliError(
+        `No project \u201C${options.project}\u201D in ${me.workspace.slug}. Run \`hostedge init\` without --project to create one.`
+      );
+    project = found;
+  } else {
+    const { files } = await collectFiles(dir, { maxFiles: 1e5, hash: false });
+    let pkg = null;
+    try {
+      pkg = await readFile4(join4(dir, "package.json"), "utf8");
+    } catch {
+    }
+    const detection = detectFramework(
+      files.map((f) => f.path),
+      pkg
+    );
+    const settings = detection.settings;
+    io2.stdout(`Detected ${s.bold(FRAMEWORK_INFO[settings.framework].name)}: ${detection.reason}
+`);
+    if (detection.problem) io2.stdout(`${s.yellow("!")} ${detection.problem}
+`);
+    project = await api.request("/api/v1/projects", {
+      json: { name: options.name ?? basename2(dir), settings }
+    });
+  }
+  await writeLink(dir, { projectId: project.id, slug: project.slug, workspace: me.workspace.slug });
+  await ensureGitignored(dir, ".hostedge");
+  io2.stdout(
+    `${s.green("\u2713")} Linked ${s.bold(project.slug)}. Run ${s.bold("hostedge deploy")} to publish it.
+`
+  );
+  return 0;
+}
+
+// src/commands/share.ts
+import { spawn as nodeSpawn } from "node:child_process";
+import { chmod as chmod2, mkdir as mkdir2, rename, rm as rm2, stat, writeFile as writeFile3 } from "node:fs/promises";
+import { connect as netConnect } from "node:net";
+import { homedir as homedir2 } from "node:os";
+import { delimiter, join as join5 } from "node:path";
+
+// ../../node_modules/.pnpm/uqr@0.1.3/node_modules/uqr/dist/index.mjs
+var QrCodeDataType = /* @__PURE__ */ ((QrCodeDataType2) => {
+  QrCodeDataType2[QrCodeDataType2["Border"] = -1] = "Border";
+  QrCodeDataType2[QrCodeDataType2["Data"] = 0] = "Data";
+  QrCodeDataType2[QrCodeDataType2["Function"] = 1] = "Function";
+  QrCodeDataType2[QrCodeDataType2["Position"] = 2] = "Position";
+  QrCodeDataType2[QrCodeDataType2["Timing"] = 3] = "Timing";
+  QrCodeDataType2[QrCodeDataType2["Alignment"] = 4] = "Alignment";
+  return QrCodeDataType2;
+})(QrCodeDataType || {});
+var LOW = [0, 1];
+var MEDIUM = [1, 0];
+var QUARTILE = [2, 3];
+var HIGH = [3, 2];
+var EccMap = {
+  L: LOW,
+  M: MEDIUM,
+  Q: QUARTILE,
+  H: HIGH
+};
+var NUMERIC_REGEX = /^\d*$/;
+var ALPHANUMERIC_REGEX = /^[A-Z0-9 $%*+./:-]*$/;
+var ALPHANUMERIC_CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+var MIN_VERSION = 1;
+var MAX_VERSION = 40;
+var PENALTY_N1 = 3;
+var PENALTY_N2 = 3;
+var PENALTY_N3 = 40;
+var PENALTY_N4 = 10;
+var ECC_CODEWORDS_PER_BLOCK = [
+  // Version: (note that index 0 is for padding, and is set to an illegal value)
+  // 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40    Error correction level
+  [-1, 7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28, 28, 28, 30, 30, 26, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+  // Low
+  [-1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28],
+  // Medium
+  [-1, 13, 22, 18, 26, 18, 24, 18, 22, 20, 24, 28, 26, 24, 20, 30, 24, 28, 28, 26, 30, 28, 30, 30, 30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+  // Quartile
+  [-1, 17, 28, 22, 16, 22, 28, 26, 26, 24, 28, 24, 28, 22, 24, 24, 30, 28, 28, 26, 28, 30, 24, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30]
+  // High
+];
+var NUM_ERROR_CORRECTION_BLOCKS = [
+  // Version: (note that index 0 is for padding, and is set to an illegal value)
+  // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40    Error correction level
+  [-1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 6, 7, 8, 8, 9, 9, 10, 12, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25],
+  // Low
+  [-1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49],
+  // Medium
+  [-1, 1, 1, 2, 2, 4, 4, 6, 6, 8, 8, 8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34, 34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68],
+  // Quartile
+  [-1, 1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35, 37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81]
+  // High
+];
+var QrCode = class {
+  /* -- Constructor (low level) and fields -- */
+  // Creates a new QR Code with the given version number,
+  // error correction level, data codeword bytes, and mask number.
+  // This is a low-level API that most users should not use directly.
+  // A mid-level API is the encodeSegments() function.
+  constructor(version, ecc, dataCodewords, msk) {
+    this.version = version;
+    this.ecc = ecc;
+    if (version < MIN_VERSION || version > MAX_VERSION)
+      throw new RangeError("Version value out of range");
+    if (msk < -1 || msk > 7)
+      throw new RangeError("Mask value out of range");
+    this.size = version * 4 + 17;
+    const row = Array.from({ length: this.size }).fill(false);
+    for (let i = 0; i < this.size; i++) {
+      this.modules.push(row.slice());
+      this.types.push(row.map(() => 0));
+    }
+    this.drawFunctionPatterns();
+    const allCodewords = this.addEccAndInterleave(dataCodewords);
+    this.drawCodewords(allCodewords);
+    if (msk === -1) {
+      let minPenalty = 1e9;
+      for (let i = 0; i < 8; i++) {
+        this.applyMask(i);
+        this.drawFormatBits(i);
+        const penalty = this.getPenaltyScore();
+        if (penalty < minPenalty) {
+          msk = i;
+          minPenalty = penalty;
+        }
+        this.applyMask(i);
+      }
+    }
+    this.mask = msk;
+    this.applyMask(msk);
+    this.drawFormatBits(msk);
+  }
+  /* -- Fields -- */
+  // The width and height of this QR Code, measured in modules, between
+  // 21 and 177 (inclusive). This is equal to version * 4 + 17.
+  size;
+  // The index of the mask pattern used in this QR Code, which is between 0 and 7 (inclusive).
+  // Even if a QR Code is created with automatic masking requested (mask = -1),
+  // the resulting object still has a mask value between 0 and 7.
+  mask;
+  // The modules of this QR Code (false = light, true = dark).
+  // Immutable after constructor finishes. Accessed through getModule().
+  modules = [];
+  types = [];
+  /* -- Accessor methods -- */
+  // Returns the color of the module (pixel) at the given coordinates, which is false
+  // for light or true for dark. The top left corner has the coordinates (x=0, y=0).
+  // If the given coordinates are out of bounds, then false (light) is returned.
+  getModule(x, y) {
+    return x >= 0 && x < this.size && y >= 0 && y < this.size && this.modules[y][x];
+  }
+  /* -- Private helper methods for constructor: Drawing function modules -- */
+  // Reads this object's version field, and draws and marks all function modules.
+  drawFunctionPatterns() {
+    for (let i = 0; i < this.size; i++) {
+      this.setFunctionModule(6, i, i % 2 === 0, QrCodeDataType.Timing);
+      this.setFunctionModule(i, 6, i % 2 === 0, QrCodeDataType.Timing);
+    }
+    this.drawFinderPattern(3, 3);
+    this.drawFinderPattern(this.size - 4, 3);
+    this.drawFinderPattern(3, this.size - 4);
+    const alignPatPos = this.getAlignmentPatternPositions();
+    const numAlign = alignPatPos.length;
+    for (let i = 0; i < numAlign; i++) {
+      for (let j = 0; j < numAlign; j++) {
+        if (!(i === 0 && j === 0 || i === 0 && j === numAlign - 1 || i === numAlign - 1 && j === 0))
+          this.drawAlignmentPattern(alignPatPos[i], alignPatPos[j]);
+      }
+    }
+    this.drawFormatBits(0);
+    this.drawVersion();
+  }
+  // Draws two copies of the format bits (with its own error correction code)
+  // based on the given mask and this object's error correction level field.
+  drawFormatBits(mask) {
+    const data = this.ecc[1] << 3 | mask;
+    let rem = data;
+    for (let i = 0; i < 10; i++)
+      rem = rem << 1 ^ (rem >>> 9) * 1335;
+    const bits = (data << 10 | rem) ^ 21522;
+    for (let i = 0; i <= 5; i++)
+      this.setFunctionModule(8, i, getBit(bits, i));
+    this.setFunctionModule(8, 7, getBit(bits, 6));
+    this.setFunctionModule(8, 8, getBit(bits, 7));
+    this.setFunctionModule(7, 8, getBit(bits, 8));
+    for (let i = 9; i < 15; i++)
+      this.setFunctionModule(14 - i, 8, getBit(bits, i));
+    for (let i = 0; i < 8; i++)
+      this.setFunctionModule(this.size - 1 - i, 8, getBit(bits, i));
+    for (let i = 8; i < 15; i++)
+      this.setFunctionModule(8, this.size - 15 + i, getBit(bits, i));
+    this.setFunctionModule(8, this.size - 8, true);
+  }
+  // Draws two copies of the version bits (with its own error correction code),
+  // based on this object's version field, iff 7 <= version <= 40.
+  drawVersion() {
+    if (this.version < 7)
+      return;
+    let rem = this.version;
+    for (let i = 0; i < 12; i++)
+      rem = rem << 1 ^ (rem >>> 11) * 7973;
+    const bits = this.version << 12 | rem;
+    for (let i = 0; i < 18; i++) {
+      const color = getBit(bits, i);
+      const a = this.size - 11 + i % 3;
+      const b = Math.floor(i / 3);
+      this.setFunctionModule(a, b, color);
+      this.setFunctionModule(b, a, color);
+    }
+  }
+  // Draws a 9*9 finder pattern including the border separator,
+  // with the center module at (x, y). Modules can be out of bounds.
+  drawFinderPattern(x, y) {
+    for (let dy = -4; dy <= 4; dy++) {
+      for (let dx = -4; dx <= 4; dx++) {
+        const dist = Math.max(Math.abs(dx), Math.abs(dy));
+        const xx = x + dx;
+        const yy = y + dy;
+        if (xx >= 0 && xx < this.size && yy >= 0 && yy < this.size)
+          this.setFunctionModule(xx, yy, dist !== 2 && dist !== 4, QrCodeDataType.Position);
+      }
+    }
+  }
+  // Draws a 5*5 alignment pattern, with the center module
+  // at (x, y). All modules must be in bounds.
+  drawAlignmentPattern(x, y) {
+    for (let dy = -2; dy <= 2; dy++) {
+      for (let dx = -2; dx <= 2; dx++) {
+        this.setFunctionModule(
+          x + dx,
+          y + dy,
+          Math.max(Math.abs(dx), Math.abs(dy)) !== 1,
+          QrCodeDataType.Alignment
+        );
+      }
+    }
+  }
+  // Sets the color of a module and marks it as a function module.
+  // Only used by the constructor. Coordinates must be in bounds.
+  setFunctionModule(x, y, isDark, type = QrCodeDataType.Function) {
+    this.modules[y][x] = isDark;
+    this.types[y][x] = type;
+  }
+  /* -- Private helper methods for constructor: Codewords and masking -- */
+  // Returns a new byte string representing the given data with the appropriate error correction
+  // codewords appended to it, based on this object's version and error correction level.
+  addEccAndInterleave(data) {
+    const ver = this.version;
+    const ecl = this.ecc;
+    if (data.length !== getNumDataCodewords(ver, ecl))
+      throw new RangeError("Invalid argument");
+    const numBlocks = NUM_ERROR_CORRECTION_BLOCKS[ecl[0]][ver];
+    const blockEccLen = ECC_CODEWORDS_PER_BLOCK[ecl[0]][ver];
+    const rawCodewords = Math.floor(getNumRawDataModules(ver) / 8);
+    const numShortBlocks = numBlocks - rawCodewords % numBlocks;
+    const shortBlockLen = Math.floor(rawCodewords / numBlocks);
+    const blocks = [];
+    const rsDiv = reedSolomonComputeDivisor(blockEccLen);
+    for (let i = 0, k = 0; i < numBlocks; i++) {
+      const dat = data.slice(k, k + shortBlockLen - blockEccLen + (i < numShortBlocks ? 0 : 1));
+      k += dat.length;
+      const ecc = reedSolomonComputeRemainder(dat, rsDiv);
+      if (i < numShortBlocks)
+        dat.push(0);
+      blocks.push(dat.concat(ecc));
+    }
+    const result = [];
+    for (let i = 0; i < blocks[0].length; i++) {
+      blocks.forEach((block, j) => {
+        if (i !== shortBlockLen - blockEccLen || j >= numShortBlocks)
+          result.push(block[i]);
+      });
+    }
+    return result;
+  }
+  // Draws the given sequence of 8-bit codewords (data and error correction) onto the entire
+  // data area of this QR Code. Function modules need to be marked off before this is called.
+  drawCodewords(data) {
+    if (data.length !== Math.floor(getNumRawDataModules(this.version) / 8))
+      throw new RangeError("Invalid argument");
+    let i = 0;
+    for (let right = this.size - 1; right >= 1; right -= 2) {
+      if (right === 6)
+        right = 5;
+      for (let vert = 0; vert < this.size; vert++) {
+        for (let j = 0; j < 2; j++) {
+          const x = right - j;
+          const upward = (right + 1 & 2) === 0;
+          const y = upward ? this.size - 1 - vert : vert;
+          if (!this.types[y][x] && i < data.length * 8) {
+            this.modules[y][x] = getBit(data[i >>> 3], 7 - (i & 7));
+            i++;
+          }
+        }
+      }
+    }
+  }
+  // XORs the codeword modules in this QR Code with the given mask pattern.
+  // The function modules must be marked and the codeword bits must be drawn
+  // before masking. Due to the arithmetic of XOR, calling applyMask() with
+  // the same mask value a second time will undo the mask. A final well-formed
+  // QR Code needs exactly one (not zero, two, etc.) mask applied.
+  applyMask(mask) {
+    if (mask < 0 || mask > 7)
+      throw new RangeError("Mask value out of range");
+    for (let y = 0; y < this.size; y++) {
+      for (let x = 0; x < this.size; x++) {
+        let invert;
+        switch (mask) {
+          case 0:
+            invert = (x + y) % 2 === 0;
+            break;
+          case 1:
+            invert = y % 2 === 0;
+            break;
+          case 2:
+            invert = x % 3 === 0;
+            break;
+          case 3:
+            invert = (x + y) % 3 === 0;
+            break;
+          case 4:
+            invert = (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0;
+            break;
+          case 5:
+            invert = x * y % 2 + x * y % 3 === 0;
+            break;
+          case 6:
+            invert = (x * y % 2 + x * y % 3) % 2 === 0;
+            break;
+          case 7:
+            invert = ((x + y) % 2 + x * y % 3) % 2 === 0;
+            break;
+          default:
+            throw new Error("Unreachable");
+        }
+        if (!this.types[y][x] && invert)
+          this.modules[y][x] = !this.modules[y][x];
+      }
+    }
+  }
+  // Calculates and returns the penalty score based on state of this QR Code's current modules.
+  // This is used by the automatic mask choice algorithm to find the mask pattern that yields the lowest score.
+  getPenaltyScore() {
+    let result = 0;
+    for (let y = 0; y < this.size; y++) {
+      let runColor = false;
+      let runX = 0;
+      const runHistory = [0, 0, 0, 0, 0, 0, 0];
+      for (let x = 0; x < this.size; x++) {
+        if (this.modules[y][x] === runColor) {
+          runX++;
+          if (runX === 5)
+            result += PENALTY_N1;
+          else if (runX > 5)
+            result++;
+        } else {
+          this.finderPenaltyAddHistory(runX, runHistory);
+          if (!runColor)
+            result += this.finderPenaltyCountPatterns(runHistory) * PENALTY_N3;
+          runColor = this.modules[y][x];
+          runX = 1;
+        }
+      }
+      result += this.finderPenaltyTerminateAndCount(runColor, runX, runHistory) * PENALTY_N3;
+    }
+    for (let x = 0; x < this.size; x++) {
+      let runColor = false;
+      let runY = 0;
+      const runHistory = [0, 0, 0, 0, 0, 0, 0];
+      for (let y = 0; y < this.size; y++) {
+        if (this.modules[y][x] === runColor) {
+          runY++;
+          if (runY === 5)
+            result += PENALTY_N1;
+          else if (runY > 5)
+            result++;
+        } else {
+          this.finderPenaltyAddHistory(runY, runHistory);
+          if (!runColor)
+            result += this.finderPenaltyCountPatterns(runHistory) * PENALTY_N3;
+          runColor = this.modules[y][x];
+          runY = 1;
+        }
+      }
+      result += this.finderPenaltyTerminateAndCount(runColor, runY, runHistory) * PENALTY_N3;
+    }
+    for (let y = 0; y < this.size - 1; y++) {
+      for (let x = 0; x < this.size - 1; x++) {
+        const color = this.modules[y][x];
+        if (color === this.modules[y][x + 1] && color === this.modules[y + 1][x] && color === this.modules[y + 1][x + 1]) {
+          result += PENALTY_N2;
+        }
+      }
+    }
+    let dark = 0;
+    for (const row of this.modules)
+      dark = row.reduce((sum, color) => sum + (color ? 1 : 0), dark);
+    const total = this.size * this.size;
+    const k = Math.ceil(Math.abs(dark * 20 - total * 10) / total) - 1;
+    result += k * PENALTY_N4;
+    return result;
+  }
+  /* -- Private helper functions -- */
+  // Returns an ascending list of positions of alignment patterns for this version number.
+  // Each position is in the range [0,177), and are used on both the x and y axes.
+  // This could be implemented as lookup table of 40 variable-length lists of integers.
+  getAlignmentPatternPositions() {
+    if (this.version === 1) {
+      return [];
+    } else {
+      const numAlign = Math.floor(this.version / 7) + 2;
+      const step = this.version === 32 ? 26 : Math.ceil((this.version * 4 + 4) / (numAlign * 2 - 2)) * 2;
+      const result = [6];
+      for (let pos = this.size - 7; result.length < numAlign; pos -= step)
+        result.splice(1, 0, pos);
+      return result;
+    }
+  }
+  // Can only be called immediately after a light run is added, and
+  // returns either 0, 1, or 2. A helper function for getPenaltyScore().
+  finderPenaltyCountPatterns(runHistory) {
+    const n = runHistory[1];
+    const core = n > 0 && runHistory[2] === n && runHistory[3] === n * 3 && runHistory[4] === n && runHistory[5] === n;
+    return (core && runHistory[0] >= n * 4 && runHistory[6] >= n ? 1 : 0) + (core && runHistory[6] >= n * 4 && runHistory[0] >= n ? 1 : 0);
+  }
+  // Must be called at the end of a line (row or column) of modules. A helper function for getPenaltyScore().
+  finderPenaltyTerminateAndCount(currentRunColor, currentRunLength, runHistory) {
+    if (currentRunColor) {
+      this.finderPenaltyAddHistory(currentRunLength, runHistory);
+      currentRunLength = 0;
+    }
+    currentRunLength += this.size;
+    this.finderPenaltyAddHistory(currentRunLength, runHistory);
+    return this.finderPenaltyCountPatterns(runHistory);
+  }
+  // Pushes the given value to the front and drops the last value. A helper function for getPenaltyScore().
+  finderPenaltyAddHistory(currentRunLength, runHistory) {
+    if (runHistory[0] === 0)
+      currentRunLength += this.size;
+    runHistory.pop();
+    runHistory.unshift(currentRunLength);
+  }
+};
+function appendBits(val, len, bb) {
+  if (len < 0 || len > 31 || val >>> len !== 0)
+    throw new RangeError("Value out of range");
+  for (let i = len - 1; i >= 0; i--)
+    bb.push(val >>> i & 1);
+}
+function getBit(x, i) {
+  return (x >>> i & 1) !== 0;
+}
+var QrSegment = class {
+  // Creates a new QR Code segment with the given attributes and data.
+  // The character count (numChars) must agree with the mode and the bit buffer length,
+  // but the constraint isn't checked. The given bit buffer is cloned and stored.
+  constructor(mode, numChars, bitData) {
+    this.mode = mode;
+    this.numChars = numChars;
+    this.bitData = bitData;
+    if (numChars < 0)
+      throw new RangeError("Invalid argument");
+    this.bitData = bitData.slice();
+  }
+  /* -- Methods -- */
+  // Returns a new copy of the data bits of this segment.
+  getData() {
+    return this.bitData.slice();
+  }
+};
+var MODE_NUMERIC = [1, 10, 12, 14];
+var MODE_ALPHANUMERIC = [2, 9, 11, 13];
+var MODE_BYTE = [4, 8, 16, 16];
+function numCharCountBits(mode, ver) {
+  return mode[Math.floor((ver + 7) / 17) + 1];
+}
+function makeBytes(data) {
+  const bb = [];
+  for (const b of data)
+    appendBits(b, 8, bb);
+  return new QrSegment(MODE_BYTE, data.length, bb);
+}
+function makeNumeric(digits) {
+  if (!isNumeric(digits))
+    throw new RangeError("String contains non-numeric characters");
+  const bb = [];
+  for (let i = 0; i < digits.length; ) {
+    const n = Math.min(digits.length - i, 3);
+    appendBits(Number.parseInt(digits.substring(i, i + n), 10), n * 3 + 1, bb);
+    i += n;
+  }
+  return new QrSegment(MODE_NUMERIC, digits.length, bb);
+}
+function makeAlphanumeric(text) {
+  if (!isAlphanumeric(text))
+    throw new RangeError("String contains unencodable characters in alphanumeric mode");
+  const bb = [];
+  let i;
+  for (i = 0; i + 2 <= text.length; i += 2) {
+    let temp = ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)) * 45;
+    temp += ALPHANUMERIC_CHARSET.indexOf(text.charAt(i + 1));
+    appendBits(temp, 11, bb);
+  }
+  if (i < text.length)
+    appendBits(ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)), 6, bb);
+  return new QrSegment(MODE_ALPHANUMERIC, text.length, bb);
+}
+function makeSegments(text) {
+  if (text === "")
+    return [];
+  else if (isNumeric(text))
+    return [makeNumeric(text)];
+  else if (isAlphanumeric(text))
+    return [makeAlphanumeric(text)];
+  else
+    return [makeBytes(toUtf8ByteArray(text))];
+}
+function isNumeric(text) {
+  return NUMERIC_REGEX.test(text);
+}
+function isAlphanumeric(text) {
+  return ALPHANUMERIC_REGEX.test(text);
+}
+function getTotalBits(segs, version) {
+  let result = 0;
+  for (const seg of segs) {
+    const ccbits = numCharCountBits(seg.mode, version);
+    if (seg.numChars >= 1 << ccbits)
+      return Number.POSITIVE_INFINITY;
+    result += 4 + ccbits + seg.bitData.length;
+  }
+  return result;
+}
+function toUtf8ByteArray(str2) {
+  str2 = encodeURI(str2);
+  const result = [];
+  for (let i = 0; i < str2.length; i++) {
+    if (str2.charAt(i) !== "%") {
+      result.push(str2.charCodeAt(i));
+    } else {
+      result.push(Number.parseInt(str2.substring(i + 1, i + 3), 16));
+      i += 2;
+    }
+  }
+  return result;
+}
+function getNumRawDataModules(ver) {
+  if (ver < MIN_VERSION || ver > MAX_VERSION)
+    throw new RangeError("Version number out of range");
+  let result = (16 * ver + 128) * ver + 64;
+  if (ver >= 2) {
+    const numAlign = Math.floor(ver / 7) + 2;
+    result -= (25 * numAlign - 10) * numAlign - 55;
+    if (ver >= 7)
+      result -= 36;
+  }
+  return result;
+}
+function getNumDataCodewords(ver, ecl) {
+  return Math.floor(getNumRawDataModules(ver) / 8) - ECC_CODEWORDS_PER_BLOCK[ecl[0]][ver] * NUM_ERROR_CORRECTION_BLOCKS[ecl[0]][ver];
+}
+function reedSolomonComputeDivisor(degree) {
+  if (degree < 1 || degree > 255)
+    throw new RangeError("Degree out of range");
+  const result = [];
+  for (let i = 0; i < degree - 1; i++)
+    result.push(0);
+  result.push(1);
+  let root = 1;
+  for (let i = 0; i < degree; i++) {
+    for (let j = 0; j < result.length; j++) {
+      result[j] = reedSolomonMultiply(result[j], root);
+      if (j + 1 < result.length)
+        result[j] ^= result[j + 1];
+    }
+    root = reedSolomonMultiply(root, 2);
+  }
+  return result;
+}
+function reedSolomonComputeRemainder(data, divisor) {
+  const result = divisor.map((_) => 0);
+  for (const b of data) {
+    const factor = b ^ result.shift();
+    result.push(0);
+    divisor.forEach((coef, i) => result[i] ^= reedSolomonMultiply(coef, factor));
+  }
+  return result;
+}
+function reedSolomonMultiply(x, y) {
+  if (x >>> 8 !== 0 || y >>> 8 !== 0)
+    throw new RangeError("Byte out of range");
+  let z = 0;
+  for (let i = 7; i >= 0; i--) {
+    z = z << 1 ^ (z >>> 7) * 285;
+    z ^= (y >>> i & 1) * x;
+  }
+  return z;
+}
+function encodeSegments(segs, ecl, minVersion = 1, maxVersion = 40, mask = -1, boostEcl = true) {
+  if (!(MIN_VERSION <= minVersion && minVersion <= maxVersion && maxVersion <= MAX_VERSION) || mask < -1 || mask > 7) {
+    throw new RangeError("Invalid value");
+  }
+  let version;
+  let dataUsedBits;
+  for (version = minVersion; ; version++) {
+    const dataCapacityBits2 = getNumDataCodewords(version, ecl) * 8;
+    const usedBits = getTotalBits(segs, version);
+    if (usedBits <= dataCapacityBits2) {
+      dataUsedBits = usedBits;
+      break;
+    }
+    if (version >= maxVersion)
+      throw new RangeError("Data too long");
+  }
+  for (const newEcl of [MEDIUM, QUARTILE, HIGH]) {
+    if (boostEcl && dataUsedBits <= getNumDataCodewords(version, newEcl) * 8)
+      ecl = newEcl;
+  }
+  const bb = [];
+  for (const seg of segs) {
+    appendBits(seg.mode[0], 4, bb);
+    appendBits(seg.numChars, numCharCountBits(seg.mode, version), bb);
+    for (const b of seg.getData())
+      bb.push(b);
+  }
+  const dataCapacityBits = getNumDataCodewords(version, ecl) * 8;
+  appendBits(0, Math.min(4, dataCapacityBits - bb.length), bb);
+  appendBits(0, (8 - bb.length % 8) % 8, bb);
+  for (let padByte = 236; bb.length < dataCapacityBits; padByte ^= 236 ^ 17)
+    appendBits(padByte, 8, bb);
+  const dataCodewords = Array.from({ length: Math.ceil(bb.length / 8) }, () => 0);
+  bb.forEach((b, i) => dataCodewords[i >>> 3] |= b << 7 - (i & 7));
+  return new QrCode(version, ecl, dataCodewords, mask);
+}
+function encode(data, options) {
+  const {
+    ecc = "L",
+    boostEcc = false,
+    minVersion = 1,
+    maxVersion = 40,
+    maskPattern = -1,
+    border = 1
+  } = options || {};
+  const segment = typeof data === "string" ? makeSegments(data) : Array.isArray(data) ? [makeBytes(data)] : void 0;
+  if (!segment)
+    throw new Error(`uqr only supports encoding string and binary data, but got: ${typeof data}`);
+  const qr = encodeSegments(
+    segment,
+    EccMap[ecc],
+    minVersion,
+    maxVersion,
+    maskPattern,
+    boostEcc
+  );
+  const result = addBorder({
+    version: qr.version,
+    maskPattern: qr.mask,
+    size: qr.size,
+    data: qr.modules,
+    types: qr.types
+  }, border);
+  if (options?.invert)
+    result.data = result.data.map((row) => row.map((mod) => !mod));
+  options?.onEncoded?.(result);
+  return result;
+}
+function addBorder(input, border = 1) {
+  if (!border)
+    return input;
+  const { size } = input;
+  const newSize = size + border * 2;
+  input.size = newSize;
+  input.data.forEach((row) => {
+    for (let i = 0; i < border; i++) {
+      row.unshift(false);
+      row.push(false);
+    }
+  });
+  for (let i = 0; i < border; i++) {
+    input.data.unshift(Array.from({ length: newSize }, (_) => false));
+    input.data.push(Array.from({ length: newSize }, (_) => false));
+  }
+  const b = QrCodeDataType.Border;
+  input.types.forEach((row) => {
+    for (let i = 0; i < border; i++) {
+      row.unshift(b);
+      row.push(b);
+    }
+  });
+  for (let i = 0; i < border; i++) {
+    input.types.unshift(Array.from({ length: newSize }, (_) => b));
+    input.types.push(Array.from({ length: newSize }, (_) => b));
+  }
+  return input;
+}
+function getDataAt(data, x, y, defaults = false) {
+  if (x < 0 || y < 0 || x >= data.length || y >= data.length)
+    return defaults;
+  return data[y][x];
+}
+function renderUnicodeCompact(data, options = {}) {
+  const palette = {
+    WHITE_ALL: "\u2588",
+    WHITE_BLACK: "\u2580",
+    BLACK_WHITE: "\u2584",
+    BLACK_ALL: " "
+  };
+  const result = encode(data, options);
+  const WHITE = false;
+  const BLACK = true;
+  const at = (x, y) => getDataAt(result.data, x, y, true);
+  const lines = [];
+  let line = "";
+  for (let row = 0; row < result.size; row += 2) {
+    for (let col = 0; col < result.size; col++) {
+      if (at(col, row) === WHITE && at(col, row + 1) === WHITE)
+        line += palette.WHITE_ALL;
+      else if (at(col, row) === WHITE && at(col, row + 1) === BLACK)
+        line += palette.WHITE_BLACK;
+      else if (at(col, row) === BLACK && at(col, row + 1) === WHITE)
+        line += palette.BLACK_WHITE;
+      else
+        line += palette.BLACK_ALL;
+    }
+    lines.push(line);
+    line = "";
+  }
+  return lines.join("\n");
+}
+
+// src/commands/share.ts
+var RELEASES = "https://github.com/cloudflare/cloudflared/releases/latest/download";
+function cloudflaredAsset(platform, arch) {
+  const cpu = arch === "x64" ? "amd64" : arch === "arm64" ? "arm64" : null;
+  if (!cpu) return null;
+  if (platform === "linux") return `cloudflared-linux-${cpu}`;
+  if (platform === "darwin") return `cloudflared-darwin-${cpu}.tgz`;
+  if (platform === "win32" && cpu === "amd64") return "cloudflared-windows-amd64.exe";
+  return null;
+}
+var exists = async (path) => (await stat(path).catch(() => null))?.isFile() ?? false;
+async function findCloudflared(io2) {
+  if (io2.env.HOSTEDGE_CLOUDFLARED) return io2.env.HOSTEDGE_CLOUDFLARED;
+  const exe = process.platform === "win32" ? "cloudflared.exe" : "cloudflared";
+  for (const dir of (io2.env.PATH ?? "").split(delimiter).filter(Boolean))
+    if (await exists(join5(dir, exe))) return join5(dir, exe);
+  const binDir = join5(io2.env.HOME ?? homedir2(), ".hostedge", "bin");
+  const own = join5(binDir, exe);
+  if (await exists(own)) return own;
+  const asset = cloudflaredAsset(process.platform, process.arch);
+  if (!asset)
+    throw new CliError(
+      "Install cloudflared (https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/) and run this again."
+    );
+  io2.stderr("Downloading cloudflared (one time)\u2026\n");
+  const response = await io2.fetch(`${RELEASES}/${asset}`);
+  if (!response.ok) throw new CliError(`Could not download cloudflared (${response.status}).`);
+  await mkdir2(binDir, { recursive: true });
+  const tmp = join5(binDir, `${asset}.download`);
+  await writeFile3(tmp, new Uint8Array(await response.arrayBuffer()));
+  if (asset.endsWith(".tgz")) {
+    await new Promise((resolve5, reject) => {
+      const tar = nodeSpawn("tar", ["-xzf", tmp, "-C", binDir], { stdio: "ignore" });
+      tar.on("error", reject);
+      tar.on("exit", (code) => code === 0 ? resolve5() : reject(new Error(`tar exited ${code}`)));
+    });
+    await rm2(tmp, { force: true });
+  } else {
+    await rename(tmp, own);
+  }
+  await chmod2(own, 493);
+  return own;
+}
+function listening(port) {
+  return new Promise((resolve5) => {
+    const socket = netConnect({ host: "127.0.0.1", port });
+    socket.once("connect", () => {
+      socket.destroy();
+      resolve5(true);
+    });
+    socket.once("error", () => resolve5(false));
+    socket.setTimeout(1e3, () => {
+      socket.destroy();
+      resolve5(false);
+    });
+  });
+}
+var QUICK_URL = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
+async function share(io2, options) {
+  const s = styles(io2);
+  const port = Number(options.port ?? "3000");
+  if (!Number.isInteger(port) || port < 1 || port > 65535)
+    throw new CliError("Give the port your dev server runs on, e.g. `hostedge share 5173`.", 2);
+  if (!await listening(port))
+    io2.stderr(
+      `${s.yellow("Note:")} nothing answers on localhost:${port} yet. Start your dev server; the link works as soon as it does.
+`
+    );
+  const { apiUrl, token } = await credentials(io2);
+  let opened = { mode: "quick" };
+  const api = token && !options.quick ? createApi(io2, apiUrl, token) : null;
+  if (api) opened = await api.request("/api/v1/shares", { json: { port } });
+  const binary = await findCloudflared(io2);
+  const hostHeader = options.hostHeader ?? "localhost";
+  const args = opened.mode === "tunnel" && opened.token ? ["tunnel", "--no-autoupdate", "run", "--token", opened.token] : [
+    "tunnel",
+    "--no-autoupdate",
+    "--url",
+    `http://localhost:${port}`,
+    "--http-host-header",
+    hostHeader
+  ];
+  const spawn2 = options.spawn ?? nodeSpawn;
+  const child = spawn2(binary, args, { stdio: ["ignore", "pipe", "pipe"] });
+  const progress = { announced: false };
+  const tail = [];
+  const remember = (chunk) => {
+    for (const line of chunk.toString().split("\n").filter((l) => l.trim())) {
+      tail.push(line.trim());
+      if (tail.length > 4) tail.shift();
+    }
+  };
+  child.stdout?.on("data", remember);
+  child.stderr?.on("data", remember);
+  const announce = (url) => {
+    if (progress.announced) return;
+    progress.announced = true;
+    io2.stdout(`
+${s.bold("Your localhost is live:")} ${s.cyan(url)}
+
+`);
+    io2.stdout(`${renderUnicodeCompact(url, { border: 1 })}
+
+`);
+    io2.stdout(
+      `Scan with your phone, or share the link.${opened.share ? ` It closes when you press Ctrl+C, or at ${new Date(opened.share.expiresAt).toLocaleTimeString()}.` : " Quick links are public and anonymous; they close when you press Ctrl+C."}
+`
+    );
+  };
+  if (opened.mode === "tunnel" && opened.share) {
+    const url = opened.share.url;
+    const watch = (chunk) => {
+      if (/Registered tunnel connection|Connection [0-9a-f-]+ registered/i.test(chunk.toString()))
+        announce(url);
+    };
+    child.stdout?.on("data", watch);
+    child.stderr?.on("data", watch);
+  } else {
+    if (!api && !options.quick)
+      io2.stderr(
+        `${s.dim("Not signed in: using a quick tunnel. `hostedge login` for a hostedge.app link.")}
+`
+      );
+    const watch = (chunk) => {
+      const match = QUICK_URL.exec(chunk.toString());
+      if (match) announce(match[0]);
+    };
+    child.stdout?.on("data", watch);
+    child.stderr?.on("data", watch);
+  }
+  const exitCode = await new Promise((resolve5) => {
+    const stop = () => {
+      child.kill("SIGTERM");
+    };
+    options.signal?.addEventListener("abort", stop, { once: true });
+    child.on("error", () => resolve5(1));
+    child.on("exit", (code) => {
+      options.signal?.removeEventListener("abort", stop);
+      resolve5(options.signal?.aborted ? 0 : code ?? 1);
+    });
+  });
+  if (api && opened.share) {
+    await api.request(`/api/v1/shares/${encodeURIComponent(opened.share.id)}`, { method: "DELETE" }).catch(() => void 0);
+    io2.stdout(`${s.dim("Share closed.")}
+`);
+  }
+  if (!progress.announced && exitCode !== 0)
+    throw new CliError(
+      `cloudflared stopped before the link was ready. Check your connection.${tail.length ? `
+${tail.join("\n")}` : ""}`
+    );
+  return exitCode;
+}
+
+// src/cli.ts
+var VERSION = "0.1.0";
+var HELP = `hostedge \u2014 deploy to HostEdge from your terminal
+
+Usage
+  hostedge login [--token <token>] [--api <url>]   Sign in (opens your browser)
+  hostedge logout                                  Forget the saved token
+  hostedge whoami                                  Show who and where you are signed in
+  hostedge init [dir] [--name <name>] [--project <id|slug>] [--force]
+                                                 Link a folder to a project
+  hostedge deploy [dir] [--preview] [--message <text>] [--no-wait]
+                                                 Upload and deploy a folder
+  hostedge logs [--follow] [--level <level>] [--search <text>] [--since 1h|24h|7d]
+                                                 Show runtime logs
+  hostedge env pull [--environment <name>] [--file <path>]
+                                                 Write variables to a .env file
+  hostedge share [port] [--quick] [--host-header <host>]
+                                                 Public HTTPS link to a local dev server
+                                                 (try it on your phone before deploying)
+
+Environment
+  HOSTEDGE_TOKEN     API token (CI); overrides the saved login
+  HOSTEDGE_API_URL   HostEdge URL (default https://hostedge.app)
+  HOSTEDGE_CLOUDFLARED  Path to cloudflared (otherwise PATH, then a one-time download)
+  NO_COLOR         Disable colors
+`;
+var str = (value) => typeof value === "string" ? value : void 0;
+async function run(argv, io2, signal) {
+  const s = styles(io2);
+  let parsed;
+  try {
+    parsed = parseArgs({
+      args: argv,
+      allowPositionals: true,
+      strict: true,
+      options: {
+        help: { type: "boolean", short: "h" },
+        version: { type: "boolean", short: "v" },
+        token: { type: "string" },
+        api: { type: "string" },
+        name: { type: "string" },
+        project: { type: "string" },
+        force: { type: "boolean" },
+        preview: { type: "boolean" },
+        message: { type: "string", short: "m" },
+        "no-wait": { type: "boolean" },
+        follow: { type: "boolean", short: "f" },
+        level: { type: "string" },
+        search: { type: "string" },
+        since: { type: "string" },
+        environment: { type: "string", short: "e" },
+        file: { type: "string" },
+        quick: { type: "boolean" },
+        "host-header": { type: "string" }
+      }
+    });
+  } catch (error) {
+    io2.stderr(`${error.message}
+Run \`hostedge --help\` for usage.
+`);
+    return 2;
+  }
+  const { values, positionals } = parsed;
+  const [command, ...rest] = positionals;
+  if (values.version) {
+    io2.stdout(`${VERSION}
+`);
+    return 0;
+  }
+  if (values.help || !command) {
+    io2.stdout(HELP);
+    return command || values.help ? 0 : 2;
+  }
+  try {
+    switch (command) {
+      case "login":
+        return await login(io2, { token: str(values.token), api: str(values.api) });
+      case "logout":
+        return await logout(io2);
+      case "whoami":
+        return await whoami(io2);
+      case "init":
+        return await init(io2, {
+          dir: rest[0],
+          name: str(values.name),
+          project: str(values.project),
+          force: values.force === true
+        });
+      case "deploy":
+        return await deploy(io2, {
+          dir: rest[0],
+          preview: values.preview === true,
+          message: str(values.message),
+          wait: values["no-wait"] !== true
+        });
+      case "logs":
+        return await logs(io2, {
+          follow: values.follow === true,
+          level: str(values.level),
+          search: str(values.search),
+          since: str(values.since),
+          signal
+        });
+      case "env":
+        if (rest[0] !== "pull") {
+          io2.stderr("Usage: hostedge env pull [--environment <name>] [--file <path>]\n");
+          return 2;
+        }
+        return await envPull(io2, { environment: str(values.environment), file: str(values.file) });
+      case "share":
+        return await share(io2, {
+          port: rest[0],
+          quick: values.quick === true,
+          hostHeader: str(values["host-header"]),
+          signal
+        });
+      default:
+        io2.stderr(`Unknown command \u201C${command}\u201D. Run \`hostedge --help\` for usage.
+`);
+        return 2;
+    }
+  } catch (error) {
+    if (error instanceof CliError) {
+      io2.stderr(`${s.red("Error:")} ${error.message}
+`);
+      return error.exitCode;
+    }
+    throw error;
+  }
+}
+
+// src/main.ts
+function openUrl(url) {
+  const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "explorer" : "xdg-open";
+  return new Promise((resolve5) => {
+    try {
+      const child = spawn(command, [url], { stdio: "ignore", detached: true });
+      child.on("error", () => resolve5(false));
+      child.on("spawn", () => {
+        child.unref();
+        resolve5(true);
+      });
+    } catch {
+      resolve5(false);
+    }
+  });
+}
+var io = {
+  cwd: process.cwd(),
+  env: process.env,
+  stdout: (text) => process.stdout.write(text),
+  stderr: (text) => process.stderr.write(text),
+  fetch: globalThis.fetch,
+  openUrl,
+  // Undefined (not false) when stdout is a pipe.
+  isTty: process.stdout.isTTY,
+  sleep: (ms) => new Promise((resolve5) => setTimeout(resolve5, ms))
+};
+var controller = new AbortController();
+process.on("SIGINT", () => {
+  if (controller.signal.aborted) process.exit(130);
+  controller.abort();
+});
+run(process.argv.slice(2), io, controller.signal).then(
+  (code) => process.exit(code),
+  (error) => {
+    process.stderr.write(
+      `Unexpected error: ${error instanceof Error ? error.stack : String(error)}
+`
+    );
+    process.exit(1);
+  }
+);