hostedge 0.0.0-stage → 0.1.1

package/dist/hostedge.js

@@ -0,0 +1,3215 @@
+#!/usr/bin/env node
+
+// src/main.ts
+import { spawn } from "node:child_process";
+
+// ../../packages/core/src/plans.ts
+var MB = 1024 * 1024;
+var GB = 1024 * MB;
+var PLANS = {
+  free: {
+    id: "free",
+    name: "Free",
+    priceMonthlyUsd: 0,
+    priceYearlyUsd: 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,
+    priceYearlyUsd: 90,
+    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,
+    priceYearlyUsd: 290,
+    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,
+    priceYearlyUsd: 790,
+    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 PLAN_ORDER = ["free", "starter", "pro", "agency"];
+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",
+  // Assistant instruction folders (`hostedge init --ai`): not part of the site.
+  ".cursor",
+  ".claude"
+]);
+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 FRAMEWORKS = [
+  "static",
+  "astro",
+  "next",
+  "nuxt",
+  "sveltekit",
+  "react-router",
+  "next-server",
+  "astro-server",
+  "sveltekit-server",
+  "nuxt-server",
+  "react-router-server",
+  "vite-react",
+  "vite-vue",
+  "vite-svelte",
+  "vite",
+  "angular",
+  "create-react-app",
+  "gatsby",
+  "docusaurus",
+  "vitepress",
+  "eleventy",
+  "hono",
+  "other"
+];
+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/ai/starter.ts
+var HOSTEDGE_MCP_URL = "https://hostedge.app/api/mcp";
+var CONNECT_WITHOUT_TOKEN = [
+  "I have not connected you to HostEdge yet. Before deploying, ask me to do this once:",
+  '1. In HostEdge open Settings \u2192 API tokens \u2192 AI assistants and press "Create a token for AI assistants" (shown once).',
+  `2. Add the MCP server ${HOSTEDGE_MCP_URL} to your assistant with an Authorization: Bearer header holding that token (Claude Code: claude mcp add --transport http hostedge ${HOSTEDGE_MCP_URL} --header ...; Cursor and others: mcp.json). Most assistants can also connect with just the URL and a sign-in page.`,
+  "3. Never paste the token into this chat, a project file or a commit. Keep it in the assistant's MCP settings or in HOSTEDGE_TOKEN."
+];
+
+// ../../packages/core/src/emails/marketing.ts
+var SITE_URL = "https://hostedge.app";
+var LOGO_URL = `${SITE_URL}/brand/hostedge-mark-email.png`;
+
+// ../../packages/core/src/ai/kit.ts
+var AI_KIT_DEFAULT_URL = "https://hostedge.app";
+var CLI_EXIT_CODES = [
+  { code: 0, name: "ok", meaning: "Success." },
+  { code: 1, name: "failure", meaning: "Generic failure (network error, bad input, unexpected)." },
+  { code: 2, name: "usage", meaning: "Usage error: unknown flag or command, missing input." },
+  {
+    code: 3,
+    name: "auth",
+    meaning: "Not signed in, token invalid, expired, revoked or missing a scope."
+  },
+  { code: 4, name: "not_found", meaning: "Project, deployment or linked folder not found." },
+  { code: 5, name: "deploy_failed", meaning: "The deployment failed or was canceled." },
+  { code: 6, name: "limit", meaning: "A plan limit was reached (projects, size, storage \u2026)." }
+];
+var MB2 = 1024 * 1024;
+var trimUrl = (url) => url.replace(/\/+$/, "");
+var runsOn = (id) => {
+  const info = FRAMEWORK_INFO[id];
+  if (info.group === "worker") return "Worker";
+  return info.server ? "server (Worker)" : "static";
+};
+function frameworkTable() {
+  const rows = FRAMEWORKS.map((id) => {
+    const info = FRAMEWORK_INFO[id];
+    const build = info.defaults.buildCommand ? `\`${info.defaults.buildCommand}\`` : "none";
+    const output = info.defaults.outputDirectory ? `\`${info.defaults.outputDirectory}\`` : "the folder";
+    return `| \`${id}\` | ${info.name} | ${runsOn(id)} | ${build} | ${output} |`;
+  });
+  return [
+    "| id | Framework | Runs as | Build command | Output |",
+    "| --- | --- | --- | --- | --- |",
+    ...rows
+  ].join("\n");
+}
+var count = (value) => value === null ? "unlimited" : value.toLocaleString("en-US");
+function limitsTable() {
+  const header = ["Limit", ...PLAN_ORDER.map((p) => PLANS[p].name)];
+  const row = (label, pick) => [
+    label,
+    ...PLAN_ORDER.map((p) => pick(PLANS[p]))
+  ];
+  const rows = [
+    row("Projects", (p) => count(p.limits.projects)),
+    row("Deployment size", (p) => `${p.limits.maxDeploymentBytes / MB2} MB`),
+    row("Files per deployment", (p) => count(p.limits.maxFiles)),
+    row("Worker CPU per request", (p) => `${p.limits.cpuMs} ms`),
+    row("Subrequests per request", (p) => count(p.limits.subrequests)),
+    row("Storage resources per project", (p) => count(p.limits.storageResourcesPerProject)),
+    row("Requests per month", (p) => count(p.limits.requestsPerMonth))
+  ];
+  return [header, header.map(() => "---"), ...rows].map((r) => `| ${r.join(" | ")} |`).join("\n");
+}
+var exitCodeTable = () => [
+  "| Code | Meaning |",
+  "| --- | --- |",
+  ...CLI_EXIT_CODES.map((c) => `| ${c.code} | ${c.name}: ${c.meaning} |`)
+].join("\n");
+function body(appUrl) {
+  const mcp = `${appUrl}/api/mcp`;
+  return `# HostEdge: how to build and ship here
+
+This project is hosted on HostEdge (${appUrl}): static sites and Workers apps on a global edge network. Every deployment gets its own URL; production is \`https://<project>.hostedge.app\`. Follow this file when you write, deploy or debug code for it. Full docs: ${appUrl}/docs (plain-text index: ${appUrl}/llms.txt).
+
+## Quick path
+
+1. Write the app so it builds to a folder of static files, or to a Worker (see "Static vs server").
+2. Deploy it with the CLI or the MCP server (see "Deploy").
+3. Wait until the deployment is \`ready\`; if it is \`failed\`, read \`failureReason\` and the build log, fix the code and deploy again.
+4. Give the person the URL from the result. Never guess a URL.
+
+## Static vs server
+
+- **Static**: a folder of HTML, CSS, JavaScript and assets. No server code runs, so there are no bindings and environment variables exist only at build time. Any framework that builds to static files works.
+- **Server (Workers)**: server rendering, API routes and Workers run as Workers. A \`_worker.js\` file at the top of the output folder becomes the Worker; for several modules write a \`_worker.js/\` folder with an \`index.js\` entry. Static files are served next to it through the \`ASSETS\` binding. Frameworks with a Cloudflare adapter (Next.js with OpenNext, Astro, SvelteKit, Nuxt, React Router) write that Worker during the build.
+- Server code has Node.js APIs through \`nodejs_compat\` (\`Buffer\`, \`AsyncLocalStorage\`, \`crypto\`, most \`node:*\`), but no native modules and no child processes. Outbound requests to private networks are blocked. The server bundle must stay under 10 MB gzipped.
+- \`wrangler.jsonc\` bindings are not used. Storage is created on HostEdge (below) and bound by name.
+- Pick static output when the app does not need a server; it is faster and uses no CPU budget.
+
+## Supported frameworks
+
+HostEdge detects the framework from \`package.json\` and the lockfile and fills in the build command and output folder (override them in Project > Settings). Anything else: use \`other\` and set the build command and output folder.
+
+${frameworkTable()}
+
+Notes: Next.js static export needs \`output: "export"\` (\`next\`); for server features use \`next-server\`. Astro, SvelteKit, Nuxt and React Router become server presets when their Cloudflare adapter is installed. Single-page apps (Vite, Angular, Create React App, React Router SPA) get SPA fallback; others answer unknown paths with \`404.html\`. Builds run on Node.js 22 with the package manager your lockfile names.
+
+## Bindings (databases, key-value, files)
+
+Server code reaches storage through \`env\`. Create the storage first, then redeploy so the code is bound to it.
+
+| Storage | Built on | Default binding | Code |
+| --- | --- | --- | --- |
+| SQL database | SQLite | \`env.DB\` | \`await env.DB.prepare('SELECT * FROM users WHERE email = ?').bind(email).all()\` |
+| Key-value store | KV | \`env.KV\` | \`await env.KV.put('flag', 'on', { expirationTtl: 3600 })\` |
+| File storage | Object storage | \`env.FILES\` | \`await env.FILES.put(key, request.body)\` |
+
+- Create a database with the MCP tool \`create_database\` (binding defaults to \`DB\`), or in the dashboard under Project > Storage (databases, key-value stores and file storage). Run SQL against it with \`run_sql\`.
+- Binding names use capital letters, digits and underscores, and must not clash with an environment variable of the same project.
+- A static site has no server code, so it cannot use bindings.
+- Previews share production storage unless the person gives previews their own copy in the dashboard.
+
+## Sign-in for the app (HostEdge Auth)
+
+When the app needs user accounts, use HostEdge Auth instead of a third-party service. Users are stored in the project's own SQL database.
+
+1. Create a database (binding \`DB\`) and, in the dashboard under Project > Storage > the database > Authentication, choose **Set up authentication** (creates the \`auth_*\` tables; the library also creates them on first use).
+2. Download \`https://hostedge.app/auth-kit/hostedge-auth.ts\` into the project. One file, no dependencies.
+3. In the Worker: \`const auth = createAuth(env.DB, { env })\`, then \`const response = await auth.handle(request); if (response) return response\`, and \`await auth.getUser(request)\` for the signed-in \`{ id, email }\` or null. Redeploy.
+
+- \`auth.handle\` serves \`POST /auth/sign-up\`, \`/auth/sign-in\`, \`/auth/sign-out\`, \`/auth/magic-link\`, \`/auth/reset-request\`, \`/auth/reset\` (JSON bodies, \`content-type: application/json\`) and \`GET /auth/me\`, \`/auth/verify\`, \`/auth/oauth/github\`, \`/auth/oauth/google\`.
+- Passing \`env\` lets HostEdge send magic-link, reset and confirmation emails (limited per plan per day). To use another sender pass \`sendEmail: async ({ to, kind, url }) => {\u2026}\`. The reset email links to \`/reset-password?token=\u2026\` on the site: build that page and post \`{ token, password }\` to \`/auth/reset\`.
+- Options: \`confirmEmail: true\` to require a confirmed email before password sign-in; \`oauth: { github: { clientId, clientSecret }, google: {\u2026} }\` with the secrets as environment variables; redirect URI \`https://<site>/auth/oauth/<provider>/callback\`.
+- Never write your own password hashing or session handling; do not store passwords yourself.
+
+## Using Postgres instead
+
+For heavy apps (thousands of concurrent users, complex queries) the built-in SQLite-based database is not the right fit. The person can use **Connect Postgres** under Project > Storage (Neon, Supabase or any host): it saves \`DATABASE_URL\` as an environment variable in every environment. Read it as \`env.DATABASE_URL\` (for example \`postgres(env.DATABASE_URL, { prepare: false })\`), prefer the host's pooled connection string, and redeploy after it is set.
+
+## Environment variables
+
+- Set them with the MCP tool \`set_env_vars\` (\`project\`, \`vars\`, optional \`environments\`: \`production\`, \`preview\`) or in the dashboard. The CLI cannot set them; \`hostedge env pull\` writes them to a git-ignored \`.env.local\` for local work.
+- Workers read them as \`env.NAME\` at runtime; static sites only see them at build time.
+- Values are encrypted and never read back; \`list_env_vars\` returns names only.
+- Deployments keep the values they were built with: **redeploy after changing variables or bindings**.
+- At most 63 variables per project and 5 KB per value. Names starting with \`HOSTEDGE_\` or \`CF_\` are reserved.
+
+## Deploy
+
+Check who you are first: \`npx hostedge whoami --json\`.
+
+### With the CLI
+
+Authenticate with an API token from Settings > API tokens: set \`HOSTEDGE_TOKEN\` (preferred; nothing is written to disk), or save it once with \`printf %s "$TOKEN" | npx hostedge login --with-token\`. Interactive \`hostedge login\` opens a browser and is for people.
+
+\`\`\`sh
+npx hostedge deploy --wait --json --yes        # production; prints {deploymentId,status,url,...}
+npx hostedge deploy --preview --wait --json    # a preview that does not touch production
+npx hostedge logs --json --since 1h --level error
+npx hostedge env pull                          # variables to .env.local
+\`\`\`
+
+Always pass \`--json\`: stdout is then one JSON document (NDJSON for \`logs\`) and all human text goes to stderr. \`--yes\` or \`CI=1\` makes it non-interactive; it never waits for input and fails with a clear message instead. \`--quiet\` hides progress. \`--api-url <url>\` or \`HOSTEDGE_API_URL\` points at another HostEdge. The first \`deploy\` in an unlinked folder creates the project and writes \`.hostedge/project.json\` (git-ignored; do not delete it, it links the folder to the project). Files that look like secrets (\`.env*\`, keys) and symbolic links are never uploaded; \`.git\` and \`node_modules\` are skipped.
+
+Exit codes:
+
+${exitCodeTable()}
+
+\`deploy --wait --json\` on failure still prints JSON with \`"status":"failed"\` and \`"failureReason"\`, and exits 5.
+
+### With the MCP server
+
+Endpoint: \`${mcp}\` (Streamable HTTP, \`Authorization: Bearer <API token>\`, or OAuth when the client supports it). In Claude Code: \`claude mcp add --transport http hostedge ${mcp}\`.
+
+| Tool | Use |
+| --- | --- |
+| \`list_projects\` | Projects with URL and latest deployment |
+| \`deploy_files\` | Deploy files you provide (\`project\`, \`files[{path,content,encoding}]\`, \`message\`); creates the project if needed; up to 2,000 files and 20 MB per call |
+| \`deploy_github_repo\` | Deploy a public GitHub repository into a new project |
+| \`get_deployment\` | Status, URL, \`failureReason\` and the last build log lines |
+| \`list_deployments\`, \`rollback\` | History; make an earlier ready deployment production |
+| \`get_logs\`, \`list_errors\` | Runtime logs (\`level\`, \`search\`); open errors grouped by message |
+| \`set_env_vars\`, \`list_env_vars\` | Write variables (values never read back); list names |
+| \`create_database\`, \`run_sql\` | A SQLite database bound as \`env.DB\`; run SQL on it |
+| \`get_analytics\` | Visitors, top pages and sources |
+
+For sites over 20 MB use the CLI.
+
+## Wait until ready
+
+A deployment goes \`queued\` > \`building\` > \`deploying\` > \`ready\`, or ends \`failed\` or \`canceled\`. \`deploy_files\` returns right away; poll \`get_deployment\` every 2 to 5 seconds until the status is \`ready\`, \`failed\` or \`canceled\` (stop after about 5 minutes and tell the person). With the CLI, \`deploy --wait\` does the polling for you. Only report success when the status is \`ready\`.
+
+## Read logs and debug
+
+- Build problems: the \`failureReason\` and the build log in \`get_deployment\` (CLI: the deploy output).
+- Runtime problems: \`get_logs\` / \`list_errors\`, or \`hostedge logs --json --level error --since 1h\` (add \`--follow\` to tail). Ranges are \`1h\`, \`24h\` and \`7d\`.
+- Typical causes: wrong output folder (set it in Project > Settings or pick the right framework), missing environment variable, a binding that was created but not redeployed, a native module in server code.
+
+## Roll back
+
+\`list_deployments\` for the project, pick an earlier deployment whose status is \`ready\`, then \`rollback\` with its \`deploymentId\`. It is instant (no rebuild) and can be undone the same way. The CLI has no rollback command; the dashboard has one too.
+
+## Limits
+
+Plan limits (per workspace unless noted):
+
+${limitsTable()}
+
+A single file may be at most ${MAX_FILE_BYTES / MB2} MB. At the limit, calls fail with a "limit reached" error (CLI exit code 6); tell the person which limit and that upgrading the plan (Settings > Billing) raises it. Do not retry in a loop. Custom domains, cron jobs, forms and uptime monitors are set up in the dashboard.
+
+## Rules
+
+- Never commit secrets (API tokens, \`.env\` files, private keys) and never print or echo \`HOSTEDGE_TOKEN\`. Put secrets in environment variables with \`set_env_vars\`, not in code.
+- Redeploy after changing environment variables or bindings; they only apply to new deployments.
+- Prefer the smallest correct setup: static output unless the app needs a server.
+- Do not invent HostEdge features, flags or endpoints. If this file does not cover it, read ${appUrl}/docs or ${appUrl}/llms.txt.
+- Do not delete \`.hostedge/project.json\`. Do not deploy from a folder you did not build the app in.
+- Verify before telling the person it works: status \`ready\`, then fetch the URL.
+`;
+}
+var DESCRIPTION = "Build, deploy, debug and roll back apps on HostEdge (static sites and Workers apps). Use when the task involves hosting, deploying, logs, environment variables, databases or the hostedge CLI/MCP.";
+function renderAgentsMd(options = {}) {
+  return body(trimUrl(options.appUrl ?? AI_KIT_DEFAULT_URL));
+}
+function renderClaudeMd(options = {}) {
+  const appUrl = trimUrl(options.appUrl ?? AI_KIT_DEFAULT_URL);
+  return `# Claude Code instructions
+
+@AGENTS.md
+
+This project deploys to HostEdge (${appUrl}). The instructions above explain how to build, deploy, read logs and roll back; the \`hostedge\` skill in \`.claude/skills/hostedge/\` has the same content for on-demand use.
+`;
+}
+function renderCursorRule(options = {}) {
+  return `---
+description: ${DESCRIPTION}
+globs:
+alwaysApply: false
+---
+
+${body(trimUrl(options.appUrl ?? AI_KIT_DEFAULT_URL))}`;
+}
+function renderSkill(options = {}) {
+  return `---
+name: hostedge
+description: ${DESCRIPTION}
+---
+
+${body(trimUrl(options.appUrl ?? AI_KIT_DEFAULT_URL))}`;
+}
+function aiKitFiles(options = {}) {
+  return [
+    {
+      id: "agents",
+      path: "AGENTS.md",
+      description: "Instructions for any coding assistant (the shared source)",
+      content: renderAgentsMd(options)
+    },
+    {
+      id: "claude",
+      path: "CLAUDE.md",
+      description: "Claude Code: imports AGENTS.md",
+      content: renderClaudeMd(options)
+    },
+    {
+      id: "cursor",
+      path: ".cursor/rules/hostedge.mdc",
+      description: "Cursor rule",
+      content: renderCursorRule(options)
+    },
+    {
+      id: "skill",
+      path: ".claude/skills/hostedge/SKILL.md",
+      description: "Claude Code skill",
+      content: renderSkill(options)
+    }
+  ];
+}
+
+// ../../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/cli.ts
+import { parseArgs } from "node:util";
+
+// src/commands/ai-kit.ts
+import { lstat, mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+
+// src/io.ts
+var EXIT = {
+  ok: 0,
+  failure: 1,
+  usage: 2,
+  auth: 3,
+  notFound: 4,
+  deployFailed: 5,
+  limit: 6
+};
+function exitName(code) {
+  return CLI_EXIT_CODES.find((c) => c.code === code)?.name ?? "failure";
+}
+var CliError = class extends Error {
+  constructor(message, exitCode = EXIT.failure) {
+    super(message);
+    this.exitCode = exitCode;
+  }
+  exitCode;
+};
+
+// src/commands/ai-kit.ts
+function lineDelta(previous, next) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const line of previous.split("\n")) counts.set(line, (counts.get(line) ?? 0) + 1);
+  let added = 0;
+  for (const line of next.split("\n")) {
+    const left = counts.get(line) ?? 0;
+    if (left > 0) counts.set(line, left - 1);
+    else added += 1;
+  }
+  let removed = 0;
+  for (const left of counts.values()) removed += left;
+  return { added, removed };
+}
+async function writeOne(dir, file, force) {
+  const target = join(dir, ...file.path.split("/"));
+  const base = { id: file.id, path: file.path };
+  const info = await lstat(target).catch(() => null);
+  if (info?.isSymbolicLink())
+    return { ...base, action: "skipped", added: 0, removed: 0, reason: "it is a symbolic link" };
+  if (info && !info.isFile())
+    return { ...base, action: "skipped", added: 0, removed: 0, reason: "it is not a file" };
+  const previous = info ? await readFile(target, "utf8") : null;
+  if (previous === file.content) return { ...base, action: "unchanged", added: 0, removed: 0 };
+  const delta = previous === null ? { added: file.content.split("\n").length, removed: 0 } : lineDelta(previous, file.content);
+  if (previous !== null && !force)
+    return {
+      ...base,
+      action: "skipped",
+      ...delta,
+      reason: "it already exists with different content (use --force to overwrite)"
+    };
+  try {
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, file.content);
+  } catch (error) {
+    throw new CliError(`Could not write ${file.path}: ${error.message}`, EXIT.failure);
+  }
+  return { ...base, action: previous === null ? "created" : "overwritten", ...delta };
+}
+async function writeKit(dir, options) {
+  const info = await stat(dir).catch(() => null);
+  if (!info?.isDirectory()) throw new CliError(`${dir} is not a folder.`, EXIT.usage);
+  const results = [];
+  for (const file of aiKitFiles()) results.push(await writeOne(dir, file, options.force === true));
+  return results;
+}
+function formatKit(r, results) {
+  const s = r.s;
+  const lines = results.map((f) => {
+    switch (f.action) {
+      case "created":
+        return `${s.green("+")} ${f.path} ${s.dim(`(created, ${f.added} lines)`)}`;
+      case "overwritten":
+        return `${s.yellow("~")} ${f.path} ${s.dim(`(overwritten: +${f.added} -${f.removed} lines)`)}`;
+      case "unchanged":
+        return `${s.dim("=")} ${f.path} ${s.dim("(already up to date)")}`;
+      default:
+        return `${s.yellow("!")} ${f.path} ${s.dim(`(kept: ${f.reason ?? "skipped"}${f.added || f.removed ? `; HostEdge's version is +${f.added} -${f.removed} lines` : ""})`)}`;
+    }
+  });
+  const kept = results.filter((f) => f.action === "skipped").length;
+  const wrote = results.filter((f) => f.action === "created" || f.action === "overwritten").length;
+  const note = kept > 0 ? `${wrote} written, ${kept} kept. Run again with --force to overwrite the kept files.` : wrote > 0 ? `${wrote} written. Commit them so every assistant on the project reads them.` : "Nothing to change.";
+  return `${lines.join("\n")}
+${note}
+`;
+}
+async function aiKit(r, options) {
+  const dir = resolve(r.io.cwd, options.dir ?? ".");
+  const files = await writeKit(dir, { force: options.force });
+  r.result({ dir, files }, formatKit(r, files));
+  return EXIT.ok;
+}
+
+// src/commands/auth.ts
+import { randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+import { hostname } from "node:os";
+
+// src/config.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2, chmod, rm } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname as dirname2, join as join2 } from "node:path";
+var DEFAULT_API_URL = "https://hostedge.app";
+function configPath(io2) {
+  const base = io2.env.HOSTEDGE_CONFIG_DIR ?? join2(io2.env.XDG_CONFIG_HOME ?? join2(io2.env.HOME ?? homedir(), ".config"), "hostedge");
+  return join2(base, "config.json");
+}
+async function readJson(path) {
+  try {
+    return JSON.parse(await readFile2(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function readConfig(io2) {
+  return await readJson(configPath(io2)) ?? {};
+}
+async function writeConfig(io2, config) {
+  const path = configPath(io2);
+  await mkdir2(dirname2(path), { recursive: true, mode: 448 });
+  await writeFile2(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);
+  const fromEnv = io2.env.HOSTEDGE_TOKEN?.trim();
+  const token = fromEnv || saved.token || null;
+  return {
+    apiUrl: (io2.env.HOSTEDGE_API_URL || saved.apiUrl || DEFAULT_API_URL).replace(/\/+$/, ""),
+    token,
+    source: fromEnv ? "env" : saved.token ? "saved" : null
+  };
+}
+var linkPath = (dir) => join2(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 mkdir2(join2(dir, ".hostedge"), { recursive: true });
+  await writeFile2(linkPath(dir), `${JSON.stringify(link, null, 2)}
+`);
+}
+async function ensureGitignored(dir, entry) {
+  const path = join2(dir, ".gitignore");
+  let text = "";
+  try {
+    text = await readFile2(path, "utf8");
+  } catch {
+  }
+  const lines = text.split(/\r?\n/).map((l) => l.trim());
+  if (lines.includes(entry) || lines.includes(`/${entry}`)) return false;
+  await writeFile2(path, `${text}${text && !text.endsWith("\n") ? "\n" : ""}${entry}
+`);
+  return true;
+}
+
+// src/api.ts
+function exitCodeFor(status, code) {
+  if (status === 401 || status === 403 || code === "unauthorized" || code === "forbidden")
+    return EXIT.auth;
+  if (status === 404 || code === "not_found") return EXIT.notFound;
+  if (status === 402 || code === "limit_reached") return EXIT.limit;
+  return EXIT.failure;
+}
+var ApiError = class extends CliError {
+  constructor(message, status, code) {
+    super(message, exitCodeFor(status, code));
+    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.1");
+    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 body2 = await response.json().catch(() => ({}));
+      const fields = body2.error?.fields ? ` ${Object.entries(body2.error.fields).map(([k, v]) => `${k}: ${v}`).join("; ")}` : "";
+      const message = response.status === 401 ? `${body2.error?.message ?? "Not signed in."} Run \`hostedge login\`.` : `${body2.error?.message ?? `HostEdge answered ${response.status}.`}${fields}`;
+      throw new ApiError(message, response.status, body2.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).", EXIT.auth);
+  return createApi(io2, apiUrl, token);
+}
+
+// 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(r, apiUrl) {
+  const { io: io2 } = r;
+  const state = randomBytes(24).toString("base64url");
+  let resolveToken = () => void 0;
+  const received = new Promise((resolve6) => {
+    resolveToken = resolve6;
+  });
+  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((resolve6) => server.listen(0, "127.0.0.1", resolve6));
+  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 = r.s;
+  const opened = await io2.openUrl(url);
+  r.always(
+    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.", EXIT.auth)
+      ),
+      LOGIN_TIMEOUT_MS
+    );
+  });
+  try {
+    return await Promise.race([received, timeout]);
+  } finally {
+    clearTimeout(timer);
+    server.close();
+  }
+}
+async function obtainToken(r, options, apiUrl) {
+  const { io: io2 } = r;
+  if (options.token !== void 0 && options.withToken)
+    throw new CliError("Use either --token or --with-token, not both.", EXIT.usage);
+  if (options.token !== void 0) {
+    const token = options.token.trim();
+    if (!token)
+      throw new CliError("--token needs a value. Prefer --with-token (reads stdin).", EXIT.usage);
+    r.warn(
+      `${r.s.dim("Tip: --token shows in your shell history and process list; prefer --with-token or HOSTEDGE_TOKEN.")}
+`
+    );
+    return { token, source: "flag" };
+  }
+  if (options.withToken) {
+    if (io2.isStdinTty)
+      throw new CliError(
+        '--with-token reads the token from stdin, but stdin is a terminal. Pipe it in, e.g. `printf %s "$TOKEN" | hostedge login --with-token`.',
+        EXIT.usage
+      );
+    const token = (await io2.readStdin()).trim();
+    if (!token) throw new CliError("No token received on stdin.", EXIT.usage);
+    return { token, source: "stdin" };
+  }
+  const fromEnv = io2.env.HOSTEDGE_TOKEN?.trim();
+  if (fromEnv) return { token: fromEnv, source: "env" };
+  if (!r.interactive)
+    throw new CliError(
+      "Not signed in, and a browser login needs a person. Set HOSTEDGE_TOKEN, or pass --with-token (token on stdin) or --token <token>.",
+      EXIT.auth
+    );
+  return { token: await browserLogin(r, apiUrl), source: "browser" };
+}
+async function login(r, options) {
+  const { io: io2 } = r;
+  const saved = await readConfig(io2);
+  const apiUrl = (options.api || io2.env.HOSTEDGE_API_URL || saved.apiUrl || DEFAULT_API_URL).replace(/\/+$/, "");
+  const { token, source } = await obtainToken(r, options, apiUrl);
+  const identity = await createApi(io2, apiUrl, token).request("/api/v1/me");
+  const saveIt = source !== "env";
+  if (saveIt) await writeConfig(io2, { apiUrl, token, workspace: identity.workspace.slug });
+  const s = r.s;
+  r.result(
+    {
+      signedIn: true,
+      user: identity.user,
+      workspace: identity.workspace,
+      scopes: identity.scopes,
+      apiUrl,
+      tokenSource: source,
+      saved: saveIt
+    },
+    `${s.green("\u2713")} Signed in as ${s.bold(identity.user.email)} in ${s.bold(identity.workspace.name)}.${saveIt ? "" : " (token from HOSTEDGE_TOKEN, not saved)"}
+`
+  );
+  return EXIT.ok;
+}
+async function logout(r) {
+  await clearConfig(r.io);
+  r.result(
+    { signedOut: true },
+    "Signed out on this computer. The token still exists until you revoke it in Settings \u2192 API tokens.\n"
+  );
+  return EXIT.ok;
+}
+async function whoami(r) {
+  const api = await connect(r.io);
+  const me = await api.request("/api/v1/me");
+  const { apiUrl, source } = await credentials(r.io);
+  const text = `${me.user.email} in ${me.workspace.name} (${me.workspace.slug}) on ${apiUrl}
+Scopes: ${me.scopes.join(", ")}
+`;
+  r.result(
+    { user: me.user, workspace: me.workspace, scopes: me.scopes, apiUrl, tokenSource: source },
+    text,
+    text
+  );
+  return EXIT.ok;
+}
+
+// src/commands/deploy.ts
+import { readFile as readFile4 } from "node:fs/promises";
+import { basename, join as join4, resolve as resolve2 } from "node:path";
+
+// src/files.ts
+import { lstat as lstat2, readdir, readFile as readFile3 } from "node:fs/promises";
+import { join as join3, 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 = join3(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 stat3 = await lstat2(absolute);
+      files.push({ path: normal.path, size: stat3.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 readFile3(file.absolute));
+  return { files: upload, skipped, secrets: [...secrets] };
+}
+async function withRetries(work, retryable, attempts = 4, delayMs = 500) {
+  for (let attempt = 1; ; attempt++) {
+    try {
+      return await work();
+    } catch (error) {
+      if (attempt >= attempts || !retryable(error)) throw error;
+      await new Promise((resolve6) => setTimeout(resolve6, delayMs * 2 ** (attempt - 1)));
+    }
+  }
+}
+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/output.ts
+function styles(io2, stream = "stdout", noColor = false) {
+  const tty = stream === "stdout" ? io2.isTty : io2.isErrTty;
+  const on = tty && !noColor && !io2.env.NO_COLOR && io2.env.TERM !== "dumb";
+  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/sse.ts
+async function* readSse(body2) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let event = "message";
+  let data = [];
+  let id = null;
+  for await (const chunk of body2) {
+    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 = 16;
+var UPLOAD_TIMEOUT_MS = 3e4;
+function temporary(error) {
+  if (error instanceof ApiError) return error.status === 429 || error.status >= 500;
+  return error instanceof CliError;
+}
+async function follow(r, api, deploymentId) {
+  const s = r.s;
+  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;
+          r.say(`${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 r.io.sleep(1e3);
+  }
+  return last;
+}
+async function lookup(api, deploymentId) {
+  try {
+    const d = await api.request(`/api/v1/deployments/${deploymentId}`);
+    return typeof d.status === "string" ? { status: d.status, failureReason: d.failureReason ?? null } : null;
+  } catch {
+    return null;
+  }
+}
+async function deploy(r, options) {
+  const { io: io2 } = r;
+  const started = Date.now();
+  const dir = resolve2(io2.cwd, options.dir ?? ".");
+  const s = r.s;
+  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)
+    r.say(
+      `${s.dim("\u2013")} Left out ${secret}: it looks like a secret. Set it with environment variables instead.
+`
+    );
+  if (skipped.length > 0)
+    r.say(
+      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);
+  r.say(
+    `Uploading ${toUpload.length} of ${files.length} files (${formatBytes(uploadBytes)} of ${formatBytes(total)}; the rest are already on HostEdge)
+`
+  );
+  let uploaded = 0;
+  let reported = 0;
+  const step = Math.max(1, Math.ceil(toUpload.length / 10));
+  await pool(toUpload, UPLOAD_CONCURRENCY, async (file) => {
+    const bytes = await readFile4(file.absolute);
+    await withRetries(
+      () => api.raw(`/api/v1/uploads/${file.hash}`, {
+        method: "PUT",
+        headers: { "content-type": "application/octet-stream" },
+        body: bytes,
+        signal: AbortSignal.timeout(UPLOAD_TIMEOUT_MS)
+      }),
+      temporary
+    );
+    uploaded++;
+    if (toUpload.length > 20 && uploaded - reported >= step && uploaded < toUpload.length) {
+      reported = uploaded;
+      r.say(`${s.dim(`  ${uploaded}/${toUpload.length} uploaded`)}
+`);
+    }
+  });
+  let project;
+  if (!link) {
+    let pkg = null;
+    try {
+      pkg = await readFile4(join4(dir, "package.json"), "utf8");
+    } catch {
+    }
+    project = {
+      name: basename(dir),
+      settings: detectFramework(
+        files.map((f) => f.path),
+        pkg
+      ).settings
+    };
+  }
+  const environment = options.preview ? "preview" : "production";
+  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,
+      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");
+    r.say(`${s.green("\u2713")} Created project ${s.bold(created.projectSlug ?? created.projectId)}
+`);
+  }
+  r.say(`Deployment ${s.bold(created.deploymentId)}
+`);
+  const describe = (outcome) => ({
+    deploymentId: created.deploymentId,
+    status: outcome.status,
+    url: created.url,
+    projectId: created.projectId,
+    environment,
+    failureReason: outcome.failureReason
+  });
+  if (options.wait === false) {
+    r.result(
+      describe({ status: created.status, failureReason: null }),
+      `Queued. Follow it at ${created.url}
+`,
+      `${created.url}
+`
+    );
+    return EXIT.ok;
+  }
+  let result = await follow(r, api, created.deploymentId);
+  if (!FINISHED.has(result.status)) result = await lookup(api, created.deploymentId) ?? result;
+  const seconds = ((Date.now() - started) / 1e3).toFixed(1);
+  if (result.status === "ready") {
+    r.result(
+      describe(result),
+      `${s.green("\u2713")} Live in ${seconds}s: ${s.bold(created.url)}
+`,
+      `${created.url}
+`
+    );
+    return EXIT.ok;
+  }
+  const canceled = result.status === "canceled";
+  const failed = result.status === "failed";
+  const reason = result.failureReason ?? (canceled ? "Deployment canceled." : failed ? null : `The log stream ended while the deployment was ${result.status}. Check it at ${created.url}.`);
+  const human = canceled ? "Deployment canceled.\n" : `${s.red("\u2717")} Deployment ${failed ? "failed" : `stopped while ${result.status}`}${reason ? `: ${reason}` : ""}
+`;
+  if (r.json) r.io.stdout(`${JSON.stringify(describe({ ...result, failureReason: reason }))}
+`);
+  io2.stderr(human);
+  return failed || canceled ? EXIT.deployFailed : EXIT.failure;
+}
+
+// src/commands/env.ts
+import { writeFile as writeFile3 } from "node:fs/promises";
+import { resolve as resolve4 } from "node:path";
+
+// src/commands/logs.ts
+import { resolve as resolve3 } from "node:path";
+var POLL_MS = 2e3;
+var LEVELS = ["debug", "info", "warn", "error"];
+var UNIT_MS = { m: 6e4, h: 36e5, d: 864e5 };
+var RANGES = [
+  { name: "1h", ms: UNIT_MS.h },
+  { name: "24h", ms: 24 * UNIT_MS.h },
+  { name: "7d", ms: 7 * UNIT_MS.d }
+];
+async function requireLink(io2, dir = ".") {
+  const link = await readLink(resolve3(io2.cwd, dir));
+  if (!link)
+    throw new CliError(
+      "This folder isn\u2019t linked to a project. Run `hostedge init` or `hostedge deploy`.",
+      EXIT.notFound
+    );
+  return link;
+}
+function parseSince(text) {
+  const match = /^(\d+)([mhd])$/.exec(text.trim());
+  const ms = match ? Number(match[1]) * UNIT_MS[match[2]] : 0;
+  if (!match || ms <= 0)
+    throw new CliError(
+      `Unknown --since \u201C${text}\u201D. Use a duration like 30m, 1h, 24h or 7d (at most 7d).`,
+      EXIT.usage
+    );
+  const range = RANGES.find((r) => ms <= r.ms);
+  if (!range) throw new CliError(`--since can look back 7 days at most, not \u201C${text}\u201D.`, EXIT.usage);
+  return { range: range.name, windowMs: ms === range.ms ? null : ms };
+}
+var newer = (a, b) => a.ts > b.ts || a.ts === b.ts && a.id > b.id;
+async function logs(r, options) {
+  const { io: io2 } = r;
+  if (options.level && !LEVELS.includes(options.level))
+    throw new CliError(`Unknown --level \u201C${options.level}\u201D. Use ${LEVELS.join(", ")}.`, EXIT.usage);
+  const since = options.since ? parseSince(options.since) : null;
+  const link = await requireLink(io2);
+  const api = await connect(io2);
+  const s = r.s;
+  const query = new URLSearchParams();
+  if (options.level) query.set("level", options.level);
+  if (options.search) query.set("q", options.search);
+  query.set("range", since?.range ?? (options.follow ? "1h" : "24h"));
+  const cutoff = since?.windowMs ? Date.now() - since.windowMs : 0;
+  const print = (row) => {
+    const time = new Date(row.ts).toISOString();
+    const level = row.level.toUpperCase().padEnd(5);
+    const colored = row.level === "error" ? s.red(level) : row.level === "warn" ? s.yellow(level) : s.dim(level);
+    r.line(
+      { id: row.id, timestamp: time, level: row.level, type: row.type, message: row.message },
+      `${s.dim(time.replace("T", " ").slice(0, 19))} ${colored} ${row.message}
+`
+    );
+  };
+  const fetchRows = async () => (await api.request(
+    `/api/v1/projects/${link.projectId}/logs?${query.toString()}`
+  )).rows.filter((row) => row.ts >= cutoff);
+  const first = await fetchRows();
+  for (const row of [...first].reverse()) print(row);
+  if (!options.follow) {
+    if (first.length === 0) r.say(s.dim("No logs in this range.\n"));
+    return EXIT.ok;
+  }
+  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 EXIT.ok;
+}
+
+// src/commands/env.ts
+async function envPull(r, options) {
+  const { io: io2 } = r;
+  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 = resolve4(io2.cwd, file);
+  await writeFile3(path, text, { mode: 384 });
+  const count2 = text.split("\n").filter(Boolean).length;
+  const ignored = await ensureGitignored(io2.cwd, file);
+  const s = r.s;
+  r.result(
+    { environment, file, count: count2, gitignored: ignored },
+    `${s.green("\u2713")} Wrote ${count2} ${environment} variable${count2 === 1 ? "" : "s"} to ${file}${ignored ? ` (added to .gitignore)` : ""}.
+`
+  );
+  return EXIT.ok;
+}
+
+// src/commands/init.ts
+import { readFile as readFile5 } from "node:fs/promises";
+import { basename as basename2, join as join5, resolve as resolve5 } from "node:path";
+async function init(r, options) {
+  const { io: io2 } = r;
+  const dir = resolve5(io2.cwd, options.dir ?? ".");
+  const s = r.s;
+  const existing = await readLink(dir);
+  let kit = null;
+  if (options.ai) {
+    kit = await writeKit(dir, { force: options.force });
+    r.say(formatKit(r, kit));
+  }
+  const files = kit ? { dir, files: kit } : void 0;
+  const relink = options.force && (!options.ai || options.project || options.name);
+  if (existing && !relink) {
+    r.result(
+      {
+        dir,
+        linked: true,
+        alreadyLinked: true,
+        project: { id: existing.projectId, slug: existing.slug, workspace: existing.workspace },
+        ai: files
+      },
+      `Already linked to ${s.bold(existing.slug)}. Use --force to link a different project.
+`,
+      ""
+    );
+    return EXIT.ok;
+  }
+  if (options.ai && !(await credentials(io2)).token) {
+    r.result(
+      { dir, linked: false, linkSkipped: "not signed in", ai: files },
+      `${s.dim("Not signed in, so the folder is not linked yet. Run `hostedge login` then `hostedge init`.")}
+`
+    );
+    return EXIT.ok;
+  }
+  const api = await connect(io2);
+  const me = await api.request("/api/v1/me");
+  let project;
+  let framework;
+  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.`,
+        EXIT.notFound
+      );
+    project = found;
+    framework = found.framework ?? null;
+  } else {
+    const { files: found } = await collectFiles(dir, { maxFiles: 1e5, hash: false });
+    let pkg = null;
+    try {
+      pkg = await readFile5(join5(dir, "package.json"), "utf8");
+    } catch {
+    }
+    const detection = detectFramework(
+      found.map((f) => f.path),
+      pkg
+    );
+    const settings = detection.settings;
+    framework = settings.framework;
+    r.say(`Detected ${s.bold(FRAMEWORK_INFO[settings.framework].name)}: ${detection.reason}
+`);
+    if (detection.problem) r.say(`${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");
+  r.result(
+    {
+      dir,
+      linked: true,
+      alreadyLinked: false,
+      project: { id: project.id, slug: project.slug, workspace: me.workspace.slug },
+      framework,
+      ai: files
+    },
+    `${s.green("\u2713")} Linked ${s.bold(project.slug)}. Run ${s.bold("hostedge deploy")} to publish it.
+`
+  );
+  return EXIT.ok;
+}
+
+// src/commands/share.ts
+import { spawn as nodeSpawn } from "node:child_process";
+import { chmod as chmod2, mkdir as mkdir3, rename, rm as rm2, stat as stat2, writeFile as writeFile4 } from "node:fs/promises";
+import { connect as netConnect } from "node:net";
+import { homedir as homedir2 } from "node:os";
+import { delimiter, join as join6 } 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 stat2(path).catch(() => null))?.isFile() ?? false;
+async function findCloudflared(r) {
+  const { io: io2 } = r;
+  const override = io2.env.HOSTEDGE_TUNNEL_HELPER ?? io2.env.HOSTEDGE_CLOUDFLARED;
+  if (override) return override;
+  const exe = process.platform === "win32" ? "cloudflared.exe" : "cloudflared";
+  for (const dir of (io2.env.PATH ?? "").split(delimiter).filter(Boolean))
+    if (await exists(join6(dir, exe))) return join6(dir, exe);
+  const binDir = join6(io2.env.HOME ?? homedir2(), ".hostedge", "bin");
+  const own = join6(binDir, exe);
+  if (await exists(own)) return own;
+  const asset = cloudflaredAsset(process.platform, process.arch);
+  if (!asset)
+    throw new CliError(
+      "Install the open-source tunnel helper (the cloudflared command) and run this again, or set HOSTEDGE_TUNNEL_HELPER to its path."
+    );
+  r.warn("Downloading the tunnel helper (one time)\u2026\n");
+  const response = await io2.fetch(`${RELEASES}/${asset}`);
+  if (!response.ok) throw new CliError(`Could not download the tunnel helper (${response.status}).`);
+  await mkdir3(binDir, { recursive: true });
+  const tmp = join6(binDir, `${asset}.download`);
+  await writeFile4(tmp, new Uint8Array(await response.arrayBuffer()));
+  if (asset.endsWith(".tgz")) {
+    await new Promise((resolve6, reject) => {
+      const tar = nodeSpawn("tar", ["-xzf", tmp, "-C", binDir], { stdio: "ignore" });
+      tar.on("error", reject);
+      tar.on("exit", (code) => code === 0 ? resolve6() : 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((resolve6) => {
+    const socket = netConnect({ host: "127.0.0.1", port });
+    socket.once("connect", () => {
+      socket.destroy();
+      resolve6(true);
+    });
+    socket.once("error", () => resolve6(false));
+    socket.setTimeout(1e3, () => {
+      socket.destroy();
+      resolve6(false);
+    });
+  });
+}
+var QUICK_URL = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
+async function share(r, options) {
+  const { io: io2 } = r;
+  const s = r.s;
+  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`.",
+      EXIT.usage
+    );
+  if (!await listening(port))
+    r.warn(
+      `${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(r);
+  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().replace(/\bcloudflared\b/gi, "the tunnel helper").replace(/\bCloudflare\b/gi, "the platform")
+      );
+      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;
+    if (r.json)
+      io2.stdout(
+        `${JSON.stringify({ mode: opened.mode, url, expiresAt: opened.share?.expiresAt ?? null })}
+`
+      );
+    if (r.quiet) {
+      if (!r.json) io2.stdout(`${url}
+`);
+      return;
+    }
+    r.always(`
+${s.bold("Your localhost is live:")} ${s.cyan(url)}
+
+`);
+    r.always(`${renderUnicodeCompact(url, { border: 1 })}
+
+`);
+    r.always(
+      `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)
+      r.warn(
+        `${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((resolve6) => {
+    const stop = () => {
+      child.kill("SIGTERM");
+    };
+    options.signal?.addEventListener("abort", stop, { once: true });
+    child.on("error", () => resolve6(1));
+    child.on("exit", (code) => {
+      options.signal?.removeEventListener("abort", stop);
+      resolve6(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);
+    r.say(`${s.dim("Share closed.")}
+`);
+  }
+  if (!progress.announced && exitCode !== 0)
+    throw new CliError(
+      `The tunnel helper stopped before the link was ready. Check your connection.${tail.length ? `
+${tail.join("\n")}` : ""}`
+    );
+  return exitCode;
+}
+
+// src/report.ts
+function isCi(env) {
+  const value = env.CI;
+  return value !== void 0 && value !== "" && value !== "0" && value.toLowerCase() !== "false";
+}
+var TOKEN_LIKE = /hostedge_[A-Za-z0-9_-]{8,}/g;
+function redact(text) {
+  return text.replace(TOKEN_LIKE, "hostedge_\u2026");
+}
+var Reporter = class {
+  constructor(io2, flags) {
+    this.io = io2;
+    this.flags = flags;
+  }
+  io;
+  flags;
+  get json() {
+    return this.flags.json;
+  }
+  get quiet() {
+    return this.flags.quiet;
+  }
+  /** Where human text goes. */
+  get human() {
+    return this.flags.json ? "stderr" : "stdout";
+  }
+  /** Styles for human text (colors only if that stream is a terminal). */
+  get s() {
+    return styles(this.io, this.human, this.flags.noColor);
+  }
+  /** Whether a person could answer a prompt. False for --yes, CI, or when stdin is piped. */
+  get interactive() {
+    return !this.flags.yes && !isCi(this.io.env) && this.io.isStdinTty;
+  }
+  write(stream, text) {
+    if (stream === "stdout") this.io.stdout(text);
+    else this.io.stderr(text);
+  }
+  /** Progress and decoration for people: hidden by --quiet. */
+  say(text) {
+    if (!this.flags.quiet) this.write(this.human, text);
+  }
+  /** Human output that --quiet keeps (the one line a script wants). */
+  always(text) {
+    this.write(this.human, text);
+  }
+  /** A note for people on stderr (never stdout): hidden by --quiet. */
+  warn(text) {
+    if (!this.flags.quiet) this.io.stderr(text);
+  }
+  /**
+   * The command's result. With --json: one JSON document on stdout, and `human` on stderr
+   * for whoever is watching. Otherwise `human` on stdout, or just `quiet` with --quiet
+   * (the one line a script wants; empty by default).
+   */
+  result(data, human, quiet = "") {
+    if (this.flags.json) {
+      this.io.stdout(`${JSON.stringify(data)}
+`);
+      if (!this.flags.quiet) this.io.stderr(human);
+      return;
+    }
+    const text = this.flags.quiet ? quiet : human;
+    if (text) this.io.stdout(text);
+  }
+  /** One NDJSON line with --json, a human line otherwise: for streaming commands. */
+  line(data, human) {
+    if (this.flags.json) this.io.stdout(`${JSON.stringify(data)}
+`);
+    else this.io.stdout(human);
+  }
+  /** Reports a failure: human text on stderr, plus a JSON error envelope on stdout. */
+  fail(message, exitCode) {
+    const clean = redact(message);
+    const red = styles(this.io, "stderr", this.flags.noColor).red;
+    this.io.stderr(`${red("Error:")} ${clean}
+`);
+    if (this.flags.json)
+      this.io.stdout(
+        `${JSON.stringify({ error: { code: exitName(exitCode), message: clean, exitCode } })}
+`
+      );
+  }
+};
+
+// src/cli.ts
+var VERSION = "0.1.1";
+var HELP = `hostedge \u2014 deploy to HostEdge from your terminal
+
+Usage
+  hostedge login [--token <t> | --with-token] [--api-url <url>]
+                                                 Sign in (opens your browser; --with-token reads stdin)
+  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] [--ai]
+                                                 Link a folder to a project; --ai also writes
+                                                 AGENTS.md, CLAUDE.md, .cursor/rules and a Claude skill
+  hostedge ai-kit [dir] [--force]                  Write the assistant instruction files only
+  hostedge deploy [dir] [--preview] [--message <text>] [--wait | --no-wait]
+                                                 Upload and deploy a folder (waits by default)
+  hostedge logs [--follow] [--level <level>] [--search <text>] [--since 30m|1h|24h|7d]
+                                                 Show runtime logs (--json: one JSON object per line)
+  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)
+
+Options for every command
+  --json            Machine-readable output on stdout; progress and text go to stderr
+  -y, --yes         Never prompt; with CI=1 or no TTY it never waits for input either
+  -q, --quiet       Only results and errors (deploy prints just the URL)
+  --api-url <url>   Use another HostEdge for this run (default https://hostedge.app)
+  --no-color        Plain text (NO_COLOR is respected too)
+  -h, --help        Show this help        -v, --version  Show the version
+
+Environment
+  HOSTEDGE_TOKEN          API token (CI); overrides the saved login. Never printed.
+  HOSTEDGE_API_URL        HostEdge URL (default https://hostedge.app)
+  HOSTEDGE_TUNNEL_HELPER  Path to the tunnel helper (otherwise PATH, then a one-time download)
+  NO_COLOR                Disable colors
+  CI                      Treated like --yes
+
+Exit codes
+${CLI_EXIT_CODES.map((c) => `  ${c.code}  ${c.name.padEnd(14)}${c.meaning}`).join("\n")}
+
+Agents: \`hostedge deploy --wait --json\` prints {"deploymentId","status","url","failureReason"}
+and exits 5 when the build fails. Docs: https://hostedge.app/docs/agent-kit
+`;
+var str = (value) => typeof value === "string" ? value : void 0;
+function apiUrlOf(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new CliError(
+      `--api-url \u201C${value}\u201D is not a URL. Use e.g. https://hostedge.app.`,
+      EXIT.usage
+    );
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:")
+    throw new CliError(`--api-url must start with https:// or http://, not \u201C${value}\u201D.`, EXIT.usage);
+  return value.replace(/\/+$/, "");
+}
+async function run(argv, baseIo, signal) {
+  const wantsJson = argv.includes("--json");
+  const early = new Reporter(baseIo, { json: wantsJson, quiet: false, yes: false, noColor: false });
+  let parsed;
+  try {
+    parsed = parseArgs({
+      args: argv,
+      allowPositionals: true,
+      strict: true,
+      options: {
+        help: { type: "boolean", short: "h" },
+        version: { type: "boolean", short: "v" },
+        json: { type: "boolean" },
+        yes: { type: "boolean", short: "y" },
+        quiet: { type: "boolean", short: "q" },
+        "no-color": { type: "boolean" },
+        "api-url": { type: "string" },
+        token: { type: "string" },
+        "with-token": { type: "boolean" },
+        // The original spelling of --api-url, still accepted.
+        api: { type: "string" },
+        name: { type: "string" },
+        project: { type: "string" },
+        force: { type: "boolean" },
+        ai: { type: "boolean" },
+        preview: { type: "boolean" },
+        message: { type: "string", short: "m" },
+        wait: { type: "boolean" },
+        "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) {
+    early.fail(`${error.message}
+Run \`hostedge --help\` for usage.`, EXIT.usage);
+    return EXIT.usage;
+  }
+  const { values, positionals } = parsed;
+  const [command, ...rest] = positionals;
+  if (values.version) {
+    if (wantsJson) early.result({ version: VERSION }, "");
+    else baseIo.stdout(`${VERSION}
+`);
+    return EXIT.ok;
+  }
+  if (values.help || !command) {
+    baseIo.stdout(HELP);
+    return command || values.help ? EXIT.ok : EXIT.usage;
+  }
+  let r = early;
+  try {
+    const apiOverride = str(values["api-url"]) ?? str(values.api);
+    const io2 = apiOverride ? { ...baseIo, env: { ...baseIo.env, HOSTEDGE_API_URL: apiUrlOf(apiOverride) } } : baseIo;
+    r = new Reporter(io2, {
+      json: values.json === true,
+      quiet: values.quiet === true,
+      yes: values.yes === true,
+      noColor: values["no-color"] === true
+    });
+    if (values.wait && values["no-wait"])
+      throw new CliError("Use either --wait or --no-wait, not both.", EXIT.usage);
+    switch (command) {
+      case "login":
+        return await login(r, {
+          token: str(values.token),
+          withToken: values["with-token"] === true,
+          api: apiOverride ? apiUrlOf(apiOverride) : void 0
+        });
+      case "logout":
+        return await logout(r);
+      case "whoami":
+        return await whoami(r);
+      case "init":
+        return await init(r, {
+          dir: rest[0],
+          name: str(values.name),
+          project: str(values.project),
+          force: values.force === true,
+          ai: values.ai === true
+        });
+      case "ai-kit":
+        return await aiKit(r, { dir: rest[0], force: values.force === true });
+      case "deploy":
+        return await deploy(r, {
+          dir: rest[0],
+          preview: values.preview === true,
+          message: str(values.message),
+          wait: values["no-wait"] !== true
+        });
+      case "logs":
+        return await logs(r, {
+          follow: values.follow === true,
+          level: str(values.level),
+          search: str(values.search),
+          since: str(values.since),
+          signal
+        });
+      case "env":
+        if (rest[0] !== "pull")
+          throw new CliError(
+            "Usage: hostedge env pull [--environment <name>] [--file <path>]",
+            EXIT.usage
+          );
+        return await envPull(r, { environment: str(values.environment), file: str(values.file) });
+      case "share":
+        return await share(r, {
+          port: rest[0],
+          quick: values.quick === true,
+          hostHeader: str(values["host-header"]),
+          signal
+        });
+      default:
+        throw new CliError(
+          `Unknown command \u201C${command}\u201D. Run \`hostedge --help\` for usage.`,
+          EXIT.usage
+        );
+    }
+  } catch (error) {
+    if (error instanceof CliError) {
+      r.fail(error.message, error.exitCode);
+      return error.exitCode;
+    }
+    r.fail(
+      `Unexpected error: ${error instanceof Error ? error.stack ?? error.message : String(error)}`,
+      EXIT.failure
+    );
+    return EXIT.failure;
+  }
+}
+
+// src/main.ts
+function openUrl(url) {
+  const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "explorer" : "xdg-open";
+  return new Promise((resolve6) => {
+    try {
+      const child = spawn(command, [url], { stdio: "ignore", detached: true });
+      child.on("error", () => resolve6(false));
+      child.on("spawn", () => {
+        child.unref();
+        resolve6(true);
+      });
+    } catch {
+      resolve6(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,
+  isErrTty: process.stderr.isTTY,
+  isStdinTty: process.stdin.isTTY,
+  readStdin: async () => {
+    const chunks = [];
+    for await (const chunk of process.stdin) chunks.push(chunk);
+    return Buffer.concat(chunks).toString("utf8");
+  },
+  sleep: (ms) => new Promise((resolve6) => setTimeout(resolve6, 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);
+  }
+);