hostedge 0.1.3 → 0.2.0

package/README.md

@@ -99,8 +99,4 @@ The CLI follows the same rules as the dashboard. `.git`, `node_modules` and simi
 - **Too many requests:** the CLI waits and retries by itself; if it keeps failing, run it again in a minute.
 - **Plan limit (exit 6):** upgrade at https://hostedge.app/pricing or remove an unused project.
 
-## Development
-
-`pnpm --filter hostedge build` bundles `dist/hostedge.js` (no runtime dependencies). `pnpm --filter hostedge test` runs the commands against a fake API.
-
-Source: https://github.com/ybenjaa-dev/appdock/tree/main/apps/cli
+More at https://hostedge.app/docs/cli

package/dist/hostedge.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/main.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 
 // ../../packages/core/src/plans.ts
 var MB = 1024 * 1024;
@@ -25,6 +25,7 @@ var PLANS = {
       runtimeLogsPerDay: 2e4,
       analyticsEventsPerMonth: 2e4,
       analyticsRetentionDays: 30,
+      devMinutesPerMonth: 0,
       storageResourcesPerProject: 3,
       storageBytes: 1 * GB,
       kvOperationsPerMonth: 1e6,
@@ -33,7 +34,8 @@ var PLANS = {
       formSubmissionsPerMonth: 100,
       formRetentionDays: 90,
       monitorsPerProject: 2,
-      monitorMinIntervalSeconds: 300
+      monitorMinIntervalSeconds: 300,
+      concurrentBuilds: 1
     }
   },
   starter: {
@@ -54,6 +56,7 @@ var PLANS = {
       runtimeLogsPerDay: 2e5,
       analyticsEventsPerMonth: 2e5,
       analyticsRetentionDays: 365,
+      devMinutesPerMonth: 120,
       storageResourcesPerProject: 10,
       storageBytes: 10 * GB,
       kvOperationsPerMonth: 1e7,
@@ -62,7 +65,8 @@ var PLANS = {
       formSubmissionsPerMonth: 2e3,
       formRetentionDays: 365,
       monitorsPerProject: 10,
-      monitorMinIntervalSeconds: 60
+      monitorMinIntervalSeconds: 60,
+      concurrentBuilds: 2
     }
   },
   pro: {
@@ -83,6 +87,7 @@ var PLANS = {
       runtimeLogsPerDay: 2e6,
       analyticsEventsPerMonth: 2e6,
       analyticsRetentionDays: 730,
+      devMinutesPerMonth: 600,
       storageResourcesPerProject: 25,
       storageBytes: 100 * GB,
       kvOperationsPerMonth: 5e7,
@@ -91,7 +96,8 @@ var PLANS = {
       formSubmissionsPerMonth: 2e4,
       formRetentionDays: 730,
       monitorsPerProject: 50,
-      monitorMinIntervalSeconds: 60
+      monitorMinIntervalSeconds: 60,
+      concurrentBuilds: 4
     }
   },
   agency: {
@@ -112,6 +118,7 @@ var PLANS = {
       runtimeLogsPerDay: 1e7,
       analyticsEventsPerMonth: 1e7,
       analyticsRetentionDays: 1095,
+      devMinutesPerMonth: 2400,
       storageResourcesPerProject: 50,
       storageBytes: 500 * GB,
       kvOperationsPerMonth: 2e8,
@@ -120,7 +127,8 @@ var PLANS = {
       formSubmissionsPerMonth: 1e5,
       formRetentionDays: 1095,
       monitorsPerProject: 100,
-      monitorMinIntervalSeconds: 60
+      monitorMinIntervalSeconds: 60,
+      concurrentBuilds: 8
     }
   }
 };
@@ -139,6 +147,10 @@ var ALLOWED_EXTENSIONS = /* @__PURE__ */ new Set([
   "ts",
   "tsx",
   "json",
+  "jsonc",
+  "sql",
+  "mts",
+  "cts",
   "map",
   "webmanifest",
   "txt",
@@ -245,10 +257,11 @@ function normalisePath(raw) {
 function isIgnoredPath(path) {
   return path.split("/").some((segment) => BLOCKED_SEGMENTS.has(segment));
 }
-function fileTypeProblem(path) {
+function fileTypeProblem(path, anyExtension = false) {
   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.";
+  if (anyExtension) return null;
   const dot = name.lastIndexOf(".");
   const ext = dot > 0 ? name.slice(dot + 1).toLowerCase() : name.startsWith(".") ? name.slice(1).toLowerCase() : "";
   if (!ext || dot <= 0) {
@@ -257,7 +270,7 @@ function fileTypeProblem(path) {
   }
   return ALLOWED_EXTENSIONS.has(ext) ? null : `.${ext} files can\u2019t be deployed.`;
 }
-function checkManifest(entries, limits) {
+function checkManifest(entries, limits, options = {}) {
   const problems = [];
   const ignored = [];
   const files = [];
@@ -278,7 +291,7 @@ function checkManifest(entries, limits) {
       continue;
     }
     const { path } = normal;
-    if (isIgnoredPath(path)) {
+    if (!options.prebuilt && isIgnoredPath(path)) {
       ignored.push(path);
       continue;
     }
@@ -305,7 +318,7 @@ function checkManifest(entries, limits) {
       problems.push({ path, reason: "Invalid content hash." });
       continue;
     }
-    const typeProblem = fileTypeProblem(path);
+    const typeProblem = options.skipTypeChecks ? null : fileTypeProblem(path, options.prebuilt === true);
     if (typeProblem) {
       problems.push({ path, reason: typeProblem });
       continue;
@@ -857,6 +870,67 @@ function detectFramework(allPaths, packageJsonText, rootDirectory = "") {
   };
 }
 
+// ../../packages/core/src/env/dotenv.ts
+var ENV_KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var UNESCAPE = { n: "\n", t: "	", '"': '"', "\\": "\\" };
+function parseDotEnv(text) {
+  const lines = text.replace(/\r\n?/g, "\n").split("\n");
+  const entries = [];
+  const errors = [];
+  for (let i = 0; i < lines.length; i++) {
+    const lineNumber = i + 1;
+    const raw = lines[i] ?? "";
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const body2 = trimmed.replace(/^export\s+/, "");
+    const eq = body2.indexOf("=");
+    if (eq <= 0) {
+      errors.push({ line: lineNumber, message: "Expected KEY=value." });
+      continue;
+    }
+    const key = body2.slice(0, eq).trim();
+    if (!ENV_KEY_PATTERN.test(key)) {
+      errors.push({
+        line: lineNumber,
+        message: `\u201C${key}\u201D is not a valid name. Use letters, digits and underscores, not starting with a digit.`
+      });
+      continue;
+    }
+    let rest = body2.slice(eq + 1).trim();
+    let value;
+    if (rest.startsWith('"')) {
+      let collected = rest.slice(1);
+      let closed = /(^|[^\\])(\\\\)*"/.exec(collected);
+      while (!closed && i + 1 < lines.length) {
+        i += 1;
+        collected += `
+${lines[i] ?? ""}`;
+        closed = /(^|[^\\])(\\\\)*"/.exec(collected);
+      }
+      if (!closed) {
+        errors.push({ line: lineNumber, message: "Missing closing double quote." });
+        continue;
+      }
+      const end = closed.index + closed[0].length - 1;
+      value = collected.slice(0, end).replace(/\\(["\\nt])/g, (_, c) => UNESCAPE[c] ?? c);
+    } else if (rest.startsWith("'")) {
+      const end = rest.indexOf("'", 1);
+      if (end === -1) {
+        errors.push({ line: lineNumber, message: "Missing closing single quote." });
+        continue;
+      }
+      value = rest.slice(1, end);
+    } else {
+      const hash = rest.search(/\s#/);
+      if (hash !== -1) rest = rest.slice(0, hash);
+      value = rest.trim();
+    }
+    entries.push({ key, value, line: lineNumber });
+  }
+  const byKey = new Map(entries.map((e) => [e.key, e]));
+  return { entries: [...byKey.values()].sort((a, b) => a.line - b.line), errors };
+}
+
 // ../../packages/core/src/ai/starter.ts
 var HOSTEDGE_MCP_URL = "https://hostedge.app/api/mcp";
 var CONNECT_WITHOUT_TOKEN = [
@@ -1334,7 +1408,7 @@ 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.3");
+    headers.set("user-agent", "hostedge-cli/0.2.0");
     let response;
     try {
       response = await io2.fetch(`${apiUrl}${path}`, { ...init2, headers });
@@ -1387,8 +1461,8 @@ 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 received = new Promise((resolve7) => {
+    resolveToken = resolve7;
   });
   const server = createServer((req, res) => {
     const url2 = new URL(req.url ?? "/", "http://127.0.0.1");
@@ -1400,7 +1474,7 @@ async function browserLogin(r, apiUrl) {
     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));
+  await new Promise((resolve7) => server.listen(0, "127.0.0.1", resolve7));
   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() })}`;
@@ -1510,8 +1584,8 @@ Scopes: ${me.scopes.join(", ")}
 }
 
 // src/commands/deploy.ts
-import { readFile as readFile4 } from "node:fs/promises";
-import { basename, join as join4, resolve as resolve2 } from "node:path";
+import { readFile as readFile5 } from "node:fs/promises";
+import { basename, join as join6, resolve as resolve3 } from "node:path";
 
 // src/files.ts
 import { lstat as lstat2, readdir, readFile as readFile3 } from "node:fs/promises";
@@ -1559,14 +1633,19 @@ async function collectFiles(root, limits = { maxFiles: 1e5 }) {
     { maxDeploymentBytes: Number.MAX_SAFE_INTEGER, maxFiles: Number.MAX_SAFE_INTEGER }
   );
   const secrets = /* @__PURE__ */ new Set();
+  const problems = [];
   for (const problem of check.problems) {
     if (problem.reason.startsWith("Looks like a secret")) secrets.add(problem.path);
+    else if (limits.strict === false) problems.push(problem);
     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] };
+  const refused = new Set(problems.map((p) => p.path));
+  const upload = files.filter((f) => !secrets.has(f.path) && !refused.has(f.path));
+  if (limits.hash !== false) await hashFiles(upload);
+  return { files: upload, skipped, secrets: [...secrets], problems };
+}
+async function hashFiles(files) {
+  for (const file of files) file.hash = await contentHash(await readFile3(file.absolute));
 }
 async function withRetries(work, retryable, attempts = 4, delayMs = 500) {
   for (let attempt = 1; ; attempt++) {
@@ -1575,7 +1654,7 @@ async function withRetries(work, retryable, attempts = 4, delayMs = 500) {
     } catch (error) {
       if (attempt >= attempts || !retryable(error)) throw error;
       const wait = typeof delayMs === "function" ? delayMs(error, attempt) : delayMs * 2 ** (attempt - 1);
-      await new Promise((resolve6) => setTimeout(resolve6, wait));
+      await new Promise((resolve7) => setTimeout(resolve7, wait));
     }
   }
 }
@@ -1590,6 +1669,337 @@ async function pool(items, limit, work) {
   await Promise.all(runners);
 }
 
+// ../../workers/builder/src/pipeline.ts
+import { existsSync } from "node:fs";
+import { copyFile, cp, lstat as lstat3, mkdir as mkdir3, readdir as readdir2, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname3, join as join4, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+var BuildError = class extends Error {
+  retryable;
+  constructor(message, retryable = false) {
+    super(message);
+    this.retryable = retryable;
+  }
+};
+var WRANGLER_CONFIGS = [
+  "wrangler.json",
+  "wrangler.jsonc",
+  "wrangler.toml",
+  ".wrangler/deploy/config.json"
+];
+var shellQuote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
+function safeJoin(root, path) {
+  const target = resolve2(root, path);
+  if (target !== root && !target.startsWith(root + sep2))
+    throw new BuildError(`Refusing to write outside the build folder: ${path}`);
+  return target;
+}
+function defaultInstallCommand(files) {
+  if (!files.has("package.json")) return null;
+  if (files.has("pnpm-lock.yaml")) return "corepack pnpm install --frozen-lockfile";
+  if (files.has("yarn.lock")) return "corepack yarn install --frozen-lockfile";
+  if (files.has("package-lock.json") || files.has("npm-shrinkwrap.json")) return "npm ci";
+  return "npm install";
+}
+function addPackagesCommand(files, packages) {
+  const list = packages.map((p) => `'${p.replace(/'/g, "")}'`).join(" ");
+  if (files.has("pnpm-lock.yaml")) return `corepack pnpm add -D ${list}`;
+  if (files.has("yarn.lock")) return `corepack yarn add -D ${list}`;
+  return `npm install --no-save --no-audit --no-fund ${list}`;
+}
+var packageName = (spec) => spec.replace(/^(@?[^@]+)(@.*)?$/, "$1");
+function maskSecrets(line, env) {
+  let out = line;
+  for (const value of Object.values(env)) {
+    if (value.length >= 6) out = out.split(value).join("\u2022\u2022\u2022\u2022\u2022\u2022");
+  }
+  return out;
+}
+async function collect(dir, base = dir) {
+  const out = [];
+  for (const name of await readdir2(dir)) {
+    const full = join4(dir, name);
+    const info = await lstat3(full);
+    if (info.isSymbolicLink()) continue;
+    if (info.isDirectory()) out.push(...await collect(full, base));
+    else if (info.isFile()) out.push(relative2(base, full).split(sep2).join("/"));
+  }
+  return out;
+}
+async function runPipeline(options) {
+  const { cwd, work, spec, exec, log } = options;
+  const written = options.written ?? [];
+  const bundleServer = async (server, out2) => {
+    const hasConfig = WRANGLER_CONFIGS.some((file) => existsSync(join4(cwd, file)));
+    const bundle = join4(work, "server-bundle");
+    const args = ["deploy", "--dry-run", "--outdir", bundle];
+    if (!hasConfig) {
+      if (!server.entry)
+        throw new BuildError(
+          "The build did not write a wrangler config. Check that the framework\u2019s edge adapter is installed and enabled."
+        );
+      if (!existsSync(safeJoin(cwd, server.entry)))
+        throw new BuildError(
+          `The build did not write ${server.entry}. Check that the framework\u2019s edge adapter is installed and enabled.`
+        );
+      args.push(
+        server.entry,
+        "--name",
+        "hostedge-build",
+        "--compatibility-date",
+        server.compatibilityDate,
+        "--compatibility-flags",
+        "nodejs_compat"
+      );
+    }
+    log("info", "Bundling the server code into a Worker");
+    await exec(`${options.wrangler} ${args.map(shellQuote).join(" ")}`);
+    const target = safeJoin(out2, "_worker.js");
+    await rm2(target, { recursive: true, force: true });
+    let modules = 0;
+    for (const file of await collect(bundle)) {
+      if (file.endsWith(".map") || file === "README.md") continue;
+      const dest = safeJoin(target, file);
+      await mkdir3(dirname3(dest), { recursive: true });
+      await copyFile(join4(bundle, file), dest);
+      modules += 1;
+    }
+    if (modules === 0) throw new BuildError("Bundling the server code produced no modules.");
+    log("success", `Server bundle: ${modules} module${modules === 1 ? "" : "s"}`);
+  };
+  if (spec.server?.files)
+    for (const file of spec.server.files) {
+      if (file.unless.some((name) => existsSync(safeJoin(cwd, name)))) continue;
+      const target = safeJoin(cwd, file.path);
+      await writeFile3(
+        target,
+        file.content.replaceAll("{{compatibilityDate}}", spec.server.compatibilityDate)
+      );
+      written.push(target);
+      log("info", `No ${file.path} in the project: using HostEdge's default.`);
+    }
+  const install = spec.installCommand ?? defaultInstallCommand(new Set(await readdir2(cwd)));
+  if (install && !options.skipInstall) {
+    await exec(install);
+    await options.afterInstall?.();
+  }
+  if (spec.server?.packages?.length) {
+    const missing = spec.server.packages.filter(
+      (pkg) => !existsSync(join4(cwd, "node_modules", packageName(pkg), "package.json"))
+    );
+    if (missing.length > 0 && options.installMissingPackages === false)
+      throw new BuildError(
+        `${missing.map(packageName).join(" and ")} ${missing.length === 1 ? "is" : "are"} not installed in this project.`
+      );
+    if (missing.length > 0) {
+      log("info", `Adding ${missing.map(packageName).join(" and ")} for the build`);
+      await exec(addPackagesCommand(new Set(await readdir2(cwd)), missing));
+    }
+  }
+  if (spec.buildCommand) await exec(spec.buildCommand);
+  const built = safeJoin(cwd, spec.outputDirectory || ".");
+  if (!existsSync(built))
+    throw new BuildError(
+      `The build finished but \u201C${spec.outputDirectory ?? "."}\u201D does not exist. Check the output directory.`
+    );
+  let out = built;
+  if (options.stageOutput) {
+    out = join4(work, "output");
+    await rm2(out, { recursive: true, force: true });
+    await cp(built, out, { recursive: true, dereference: false });
+  }
+  if (spec.server) await bundleServer(spec.server, out);
+  for (const name of spec.server?.hide ?? [])
+    await rm2(safeJoin(out, name), { recursive: true, force: true });
+  const extra = spec.server?.extraOutput;
+  if (extra && existsSync(safeJoin(cwd, extra.from))) {
+    const from = safeJoin(cwd, extra.from);
+    for (const file of await collect(from)) {
+      const dest = safeJoin(out, `${extra.to}/${file}`);
+      await mkdir3(dirname3(dest), { recursive: true });
+      await copyFile(join4(from, file), dest);
+    }
+  }
+  const files = await collect(out);
+  let bytes = 0;
+  for (const file of files) bytes += (await lstat3(join4(out, file))).size;
+  if (bytes > options.maxOutputBytes)
+    throw new BuildError(
+      `The output is larger than ${Math.round(options.maxOutputBytes / 1024 / 1024)} MB.`
+    );
+  return { out, files, bytes, written };
+}
+
+// src/local-build.ts
+import { spawn } from "node:child_process";
+import { existsSync as existsSync2 } from "node:fs";
+import { mkdtemp, readFile as readFile4, rm as rm3 } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join5 } from "node:path";
+var BUILD_TIMEOUT_MS = 15 * 60 * 1e3;
+var MAX_OUTPUT_BYTES = 1024 * 1024 * 1024;
+var HASH_CONCURRENCY = 8;
+var ENV_FILES = [".env", ".env.local", ".env.production", ".env.production.local"];
+var shellQuote2 = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
+async function undeclaredEnvKeys(folders, known) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const folder of new Set(folders))
+    for (const name of ENV_FILES) {
+      let text;
+      try {
+        text = await readFile4(join5(folder, name), "utf8");
+      } catch {
+        continue;
+      }
+      for (const entry of parseDotEnv(text).entries) if (!known.has(entry.key)) keys.add(entry.key);
+    }
+  return [...keys].sort();
+}
+async function localBuild(r, api, input) {
+  const s = r.s;
+  const skip = (reason) => {
+    r.say(`${s.dim("\u2013")} ${reason} Building on HostEdge instead.
+`);
+    return null;
+  };
+  if (r.io.env.HOSTEDGE_REMOTE_BUILD) return null;
+  if (process.platform === "win32") return null;
+  let plan;
+  try {
+    plan = await api.request("/api/v1/build-plan", {
+      json: {
+        projectId: input.projectId ?? void 0,
+        settings: input.projectId ? void 0 : input.detected,
+        paths: input.sourcePaths.filter((p) => /(^|\/)api\//.test(p))
+      }
+    });
+  } catch (error) {
+    if (error instanceof ApiError && (error.status === 404 || error.status === 405)) return null;
+    throw error;
+  }
+  const { settings } = plan;
+  if (!settings.buildCommand && !plan.server) return null;
+  let projectEnv = {};
+  if (input.projectId) {
+    try {
+      const response = await api.request(
+        `/api/v1/projects/${input.projectId}/env?${new URLSearchParams({ environment: input.environment })}`
+      );
+      projectEnv = Object.fromEntries(response.variables.map((v) => [v.key, v.value]));
+    } catch (error) {
+      if (error instanceof ApiError && (error.status === 401 || error.status === 403))
+        return skip("This token can\u2019t read the project\u2019s environment variables.");
+      throw error;
+    }
+  }
+  const cwd = join5(input.dir, settings.rootDirectory);
+  if (!existsSync2(cwd))
+    return skip(`The root directory \u201C${settings.rootDirectory}\u201D does not exist.`);
+  const shadowed = await undeclaredEnvKeys([cwd, input.dir], new Set(Object.keys(projectEnv)));
+  if (shadowed.length > 0)
+    return skip(
+      `Your .env files define ${shadowed.slice(0, 4).join(", ")}${shadowed.length > 4 ? ` and ${shadowed.length - 4} more` : ""}, which are not set on HostEdge, so a build here would differ from the one HostEdge runs (set them with the dashboard if the build needs them).`
+    );
+  const framework = FRAMEWORK_INFO[settings.framework].name;
+  r.say(`Building ${framework} on this machine (use --remote-build to build on HostEdge)
+`);
+  const env = {};
+  for (const [key, value] of Object.entries(r.io.env)) if (value !== void 0) env[key] = value;
+  Object.assign(env, { CI: "1", HOSTEDGE: "1", WRANGLER_SEND_METRICS: "false" }, projectEnv);
+  const emit = (level, msg) => {
+    const text = maskSecrets(msg, projectEnv);
+    const line = level === "error" ? s.red(text) : level === "warn" ? s.yellow(text) : level === "success" ? s.green(text) : text;
+    r.say(`${s.dim("\u2502")} ${line}
+`);
+  };
+  const exec = (command) => new Promise((resolve7, reject) => {
+    emit("info", `$ ${command}`);
+    const child = spawn("sh", ["-c", command], { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new BuildError("The build ran longer than 15 minutes and was stopped."));
+    }, BUILD_TIMEOUT_MS);
+    for (const stream of [child.stdout, child.stderr]) {
+      let buffer = "";
+      stream.setEncoding("utf8");
+      stream.on("data", (chunk) => {
+        const parts = (buffer + chunk).split(/\r?\n/);
+        buffer = parts.pop() ?? "";
+        for (const part of parts) emit("info", part);
+      });
+      stream.on("end", () => {
+        if (buffer) emit("info", buffer);
+      });
+    }
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      reject(new BuildError(`Could not start the command: ${error.message}`));
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0) resolve7();
+      else reject(new BuildError(`\u201C${command}\u201D exited with code ${code ?? "unknown"}.`));
+    });
+  });
+  const localWrangler = [cwd, input.dir].map((folder) => join5(folder, "node_modules", ".bin", "wrangler")).find((path) => existsSync2(path));
+  const work = await mkdtemp(join5(tmpdir(), "hostedge-build-"));
+  const written = [];
+  const cleanup = async () => {
+    await Promise.all(written.map((file) => rm3(file, { force: true })));
+    await rm3(work, { recursive: true, force: true });
+  };
+  try {
+    const spec = {
+      buildId: `local-${Date.now()}`,
+      rootDirectory: settings.rootDirectory,
+      installCommand: settings.installCommand,
+      buildCommand: settings.buildCommand,
+      outputDirectory: settings.outputDirectory,
+      server: plan.server,
+      env: projectEnv
+    };
+    const hasModules = existsSync2(join5(cwd, "node_modules")) || existsSync2(join5(input.dir, "node_modules"));
+    const result = await runPipeline({
+      cwd,
+      work,
+      spec,
+      exec,
+      log: emit,
+      wrangler: localWrangler ? shellQuote2(localWrangler) : `npx --yes wrangler@${plan.wrangler}`,
+      maxOutputBytes: MAX_OUTPUT_BYTES,
+      skipInstall: hasModules,
+      installMissingPackages: false,
+      written,
+      stageOutput: true
+    });
+    if (hasModules) emit("info", "Using the dependencies already installed in this folder.");
+    const files = result.files.map((path) => ({
+      path,
+      size: 0,
+      hash: "",
+      absolute: join5(result.out, path)
+    }));
+    await pool(files, HASH_CONCURRENCY, async (file) => {
+      const bytes = await readFile4(file.absolute);
+      file.size = bytes.byteLength;
+      file.hash = await contentHash(bytes);
+    });
+    const check = checkManifest(
+      files.map((f) => ({ path: f.path, size: f.size, hash: f.hash })),
+      { maxDeploymentBytes: Number.MAX_SAFE_INTEGER, maxFiles: Number.MAX_SAFE_INTEGER },
+      { prebuilt: true }
+    );
+    const [problem] = check.problems;
+    if (problem) throw new BuildError(`${problem.path ? `${problem.path}: ` : ""}${problem.reason}`);
+    const kept = new Set(check.files.map((f) => f.path));
+    return { files: files.filter((f) => kept.has(f.path)), cleanup };
+  } catch (error) {
+    await cleanup();
+    return skip(
+      `The local build did not work${error instanceof Error ? `: ${error.message}` : "."}`
+    );
+  }
+}
+
 // src/output.ts
 function styles(io2, stream = "stdout", noColor = false) {
   const tty = stream === "stdout" ? io2.isTty : io2.isErrTty;
@@ -1717,11 +2127,15 @@ async function lookup(api, deploymentId) {
 async function deploy(r, options) {
   const { io: io2 } = r;
   const started = Date.now();
-  const dir = resolve2(io2.cwd, options.dir ?? ".");
+  const dir = resolve3(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);
+  const { files, skipped, secrets, problems } = await collectFiles(dir, {
+    maxFiles: 1e5,
+    hash: false,
+    strict: false
+  });
   if (files.length === 0) throw new CliError(`No files to deploy in ${dir}.`);
   for (const secret of secrets)
     r.say(
@@ -1735,100 +2149,127 @@ async function deploy(r, options) {
 `
       )
     );
-  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 pkg = null;
+  try {
+    pkg = await readFile5(join6(dir, "package.json"), "utf8");
+  } catch {
+  }
+  const detected = detectFramework(
+    files.map((f) => f.path),
+    pkg
+  ).settings;
+  const environment = options.preview ? "preview" : "production";
+  const submit = async (toSend, prebuilt) => {
+    const total = toSend.reduce((sum, f) => sum + f.size, 0);
+    const { missing } = await api.request("/api/v1/uploads", {
+      json: { hashes: [...new Set(toSend.map((f) => f.hash))] }
+    });
+    const needed = new Set(missing);
+    const toUpload = toSend.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 ${toSend.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));
-  const progress = (count2) => {
-    uploaded += count2;
-    if (toUpload.length > 20 && uploaded - reported >= step && uploaded < toUpload.length) {
-      reported = uploaded;
-      r.say(`${s.dim(`  ${uploaded}/${toUpload.length} uploaded`)}
+    );
+    let uploaded = 0;
+    let reported = 0;
+    const step = Math.max(1, Math.ceil(toUpload.length / 10));
+    const progress = (count2) => {
+      uploaded += count2;
+      if (toUpload.length > 20 && uploaded - reported >= step && uploaded < toUpload.length) {
+        reported = uploaded;
+        r.say(`${s.dim(`  ${uploaded}/${toUpload.length} uploaded`)}
 `);
-    }
-  };
-  const send = (path, init2, bytes) => withRetries(
-    () => api.raw(path, {
-      ...init2,
-      // 30 s plus a few more for every MB, so a big file on a slow line can finish.
-      signal: AbortSignal.timeout(UPLOAD_TIMEOUT_MS + Math.ceil(bytes / 1048576) * 4e3)
-    }),
-    temporary,
-    6,
-    retryDelay
-  );
-  let batching = true;
-  await pool(batchesOf(toUpload), UPLOAD_CONCURRENCY, async (batch) => {
-    if (batching && (batch.length > 1 || (batch[0]?.size ?? 0) <= BATCH_BYTES)) {
-      const form = new FormData();
-      for (const file of batch)
-        form.append(file.hash, new Blob([await readFile4(file.absolute)]), file.hash);
-      try {
+      }
+    };
+    const send = (path, init2, bytes) => withRetries(
+      () => api.raw(path, {
+        ...init2,
+        // 30 s plus a few more for every MB, so a big file on a slow line can finish.
+        signal: AbortSignal.timeout(UPLOAD_TIMEOUT_MS + Math.ceil(bytes / 1048576) * 4e3)
+      }),
+      temporary,
+      6,
+      retryDelay
+    );
+    let batching = true;
+    await pool(batchesOf(toUpload), UPLOAD_CONCURRENCY, async (batch) => {
+      if (batching && (batch.length > 1 || (batch[0]?.size ?? 0) <= BATCH_BYTES)) {
+        const form = new FormData();
+        for (const file of batch)
+          form.append(file.hash, new Blob([await readFile5(file.absolute)]), file.hash);
+        try {
+          await send(
+            "/api/v1/uploads/batch",
+            { method: "POST", body: form },
+            batch.reduce((sum, file) => sum + file.size, 0)
+          );
+          progress(batch.length);
+          return;
+        } catch (error) {
+          if (!(error instanceof ApiError) || error.status !== 404 && error.status !== 405)
+            throw error;
+          batching = false;
+        }
+      }
+      for (const file of batch) {
         await send(
-          "/api/v1/uploads/batch",
-          { method: "POST", body: form },
-          batch.reduce((sum, file) => sum + file.size, 0)
+          `/api/v1/uploads/${file.hash}`,
+          {
+            method: "PUT",
+            headers: { "content-type": "application/octet-stream" },
+            body: await readFile5(file.absolute)
+          },
+          file.size
         );
-        progress(batch.length);
-        return;
-      } catch (error) {
-        if (!(error instanceof ApiError) || error.status !== 404 && error.status !== 405)
-          throw error;
-        batching = false;
+        progress(1);
       }
-    }
-    for (const file of batch) {
-      await send(
-        `/api/v1/uploads/${file.hash}`,
-        {
-          method: "PUT",
-          headers: { "content-type": "application/octet-stream" },
-          body: await readFile4(file.absolute)
-        },
-        file.size
-      );
-      progress(1);
-    }
-  });
-  let project;
-  if (!link) {
-    let pkg = null;
+    });
+    return api.request("/api/v1/deployments", {
+      json: {
+        projectId: link?.projectId,
+        project: link ? void 0 : { name: basename(dir), settings: detected },
+        files: toSend.map((f) => ({ path: f.path, hash: f.hash, size: f.size })),
+        environment,
+        commitMessage: options.message ?? null,
+        ...prebuilt ? { prebuilt: true } : {}
+      }
+    });
+  };
+  let built = null;
+  if (!options.remoteBuild)
+    built = await localBuild(r, api, {
+      dir,
+      projectId: link?.projectId ?? null,
+      environment,
+      detected,
+      sourcePaths: files.map((f) => f.path)
+    });
+  let created = null;
+  if (built) {
     try {
-      pkg = await readFile4(join4(dir, "package.json"), "utf8");
-    } catch {
+      created = await submit(built.files, true);
+    } catch (error) {
+      if (!(error instanceof ApiError) || error.status !== 400 && error.status !== 413)
+        throw error;
+      r.say(
+        `${s.dim("\u2013")} HostEdge refused the built output (${error.message}) Building on HostEdge instead.
+`
+      );
+    } finally {
+      await built.cleanup();
     }
-    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 (!created) {
+    const [problem] = problems;
+    if (problem) throw new CliError(`${problem.path}: ${problem.reason}`);
+    await hashFiles(files);
+    created = await submit(files, false);
+  }
   if (!link) {
     const me = await api.request("/api/v1/me");
     await writeLink(dir, {
@@ -1885,11 +2326,11 @@ async function deploy(r, options) {
 }
 
 // src/commands/env.ts
-import { writeFile as writeFile3 } from "node:fs/promises";
-import { resolve as resolve4 } from "node:path";
+import { writeFile as writeFile4 } from "node:fs/promises";
+import { resolve as resolve5 } from "node:path";
 
 // src/commands/logs.ts
-import { resolve as resolve3 } from "node:path";
+import { resolve as resolve4 } from "node:path";
 var POLL_MS = 2e3;
 var LEVELS = ["debug", "info", "warn", "error"];
 var UNIT_MS = { m: 6e4, h: 36e5, d: 864e5 };
@@ -1899,7 +2340,7 @@ var RANGES = [
   { name: "7d", ms: 7 * UNIT_MS.d }
 ];
 async function requireLink(io2, dir = ".") {
-  const link = await readLink(resolve3(io2.cwd, dir));
+  const link = await readLink(resolve4(io2.cwd, dir));
   if (!link)
     throw new CliError(
       "This folder isn\u2019t linked to a project. Run `hostedge init` or `hostedge deploy`.",
@@ -1975,8 +2416,8 @@ async function envPull(r, options) {
     `/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 path = resolve5(io2.cwd, file);
+  await writeFile4(path, text, { mode: 384 });
   const count2 = text.split("\n").filter(Boolean).length;
   const ignored = await ensureGitignored(io2.cwd, file);
   const s = r.s;
@@ -1989,11 +2430,11 @@ async function envPull(r, options) {
 }
 
 // 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";
+import { readFile as readFile6 } from "node:fs/promises";
+import { basename as basename2, join as join7, resolve as resolve6 } from "node:path";
 async function init(r, options) {
   const { io: io2 } = r;
-  const dir = resolve5(io2.cwd, options.dir ?? ".");
+  const dir = resolve6(io2.cwd, options.dir ?? ".");
   const s = r.s;
   const existing = await readLink(dir);
   let kit = null;
@@ -2044,7 +2485,7 @@ async function init(r, options) {
     const { files: found } = await collectFiles(dir, { maxFiles: 1e5, hash: false });
     let pkg = null;
     try {
-      pkg = await readFile5(join5(dir, "package.json"), "utf8");
+      pkg = await readFile6(join7(dir, "package.json"), "utf8");
     } catch {
     }
     const detection = detectFramework(
@@ -2080,10 +2521,10 @@ async function init(r, options) {
 
 // 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 { chmod as chmod2, mkdir as mkdir4, rename, rm as rm4, stat as stat2, writeFile as writeFile5 } 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";
+import { delimiter, join as join8 } from "node:path";
 
 // ../../node_modules/.pnpm/uqr@0.1.3/node_modules/uqr/dist/index.mjs
 var QrCodeDataType = /* @__PURE__ */ ((QrCodeDataType2) => {
@@ -2793,9 +3234,9 @@ async function findCloudflared(r) {
   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(join8(dir, exe))) return join8(dir, exe);
+  const binDir = join8(io2.env.HOME ?? homedir2(), ".hostedge", "bin");
+  const own = join8(binDir, exe);
   if (await exists(own)) return own;
   const asset = cloudflaredAsset(process.platform, process.arch);
   if (!asset)
@@ -2805,16 +3246,16 @@ async function findCloudflared(r) {
   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()));
+  await mkdir4(binDir, { recursive: true });
+  const tmp = join8(binDir, `${asset}.download`);
+  await writeFile5(tmp, new Uint8Array(await response.arrayBuffer()));
   if (asset.endsWith(".tgz")) {
-    await new Promise((resolve6, reject) => {
+    await new Promise((resolve7, 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}`)));
+      tar.on("exit", (code) => code === 0 ? resolve7() : reject(new Error(`tar exited ${code}`)));
     });
-    await rm2(tmp, { force: true });
+    await rm4(tmp, { force: true });
   } else {
     await rename(tmp, own);
   }
@@ -2822,16 +3263,16 @@ async function findCloudflared(r) {
   return own;
 }
 function listening(port) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const socket = netConnect({ host: "127.0.0.1", port });
     socket.once("connect", () => {
       socket.destroy();
-      resolve6(true);
+      resolve7(true);
     });
-    socket.once("error", () => resolve6(false));
+    socket.once("error", () => resolve7(false));
     socket.setTimeout(1e3, () => {
       socket.destroy();
-      resolve6(false);
+      resolve7(false);
     });
   });
 }
@@ -2864,8 +3305,8 @@ async function share(r, options) {
     "--http-host-header",
     hostHeader
   ];
-  const spawn2 = options.spawn ?? nodeSpawn;
-  const child = spawn2(binary, args, { stdio: ["ignore", "pipe", "pipe"] });
+  const spawn3 = options.spawn ?? nodeSpawn;
+  const child = spawn3(binary, args, { stdio: ["ignore", "pipe", "pipe"] });
   const progress = { announced: false };
   const tail = [];
   const remember = (chunk) => {
@@ -2924,15 +3365,15 @@ ${s.bold("Your localhost is live:")} ${s.cyan(url)}
     child.stdout?.on("data", watch);
     child.stderr?.on("data", watch);
   }
-  const exitCode = await new Promise((resolve6) => {
+  const exitCode = await new Promise((resolve7) => {
     const stop = () => {
       child.kill("SIGTERM");
     };
     options.signal?.addEventListener("abort", stop, { once: true });
-    child.on("error", () => resolve6(1));
+    child.on("error", () => resolve7(1));
     child.on("exit", (code) => {
       options.signal?.removeEventListener("abort", stop);
-      resolve6(options.signal?.aborted ? 0 : code ?? 1);
+      resolve7(options.signal?.aborted ? 0 : code ?? 1);
     });
   });
   if (api && opened.share) {
@@ -3034,7 +3475,7 @@ var Reporter = class {
 };
 
 // src/cli.ts
-var VERSION = "0.1.3";
+var VERSION = "0.2.0";
 var HELP = `hostedge \u2014 hosting your AI agent can use. Deploy from your terminal, CI or an agent.
 
 Usage
@@ -3046,8 +3487,10 @@ Usage
                                                  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 deploy [dir] [--preview] [--message <text>] [--wait | --no-wait] [--remote-build]
+                                                 Deploy a folder (waits by default). Projects that need a
+                                                 build are built on this machine and only the output goes
+                                                 up; --remote-build has HostEdge build the source instead
   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>]
@@ -3067,6 +3510,7 @@ Options for every command
 Environment
   HOSTEDGE_TOKEN          API token (CI); overrides the saved login. Never printed.
   HOSTEDGE_API_URL        HostEdge URL (default https://hostedge.app)
+  HOSTEDGE_REMOTE_BUILD   Same as --remote-build for every deploy
   HOSTEDGE_TUNNEL_HELPER  Path to the tunnel helper (otherwise PATH, then a one-time download)
   NO_COLOR                Disable colors
   CI                      Treated like --yes
@@ -3121,6 +3565,7 @@ async function run(argv, baseIo, signal) {
         message: { type: "string", short: "m" },
         wait: { type: "boolean" },
         "no-wait": { type: "boolean" },
+        "remote-build": { type: "boolean" },
         follow: { type: "boolean", short: "f" },
         level: { type: "string" },
         search: { type: "string" },
@@ -3186,7 +3631,8 @@ Run \`hostedge --help\` for usage.`, EXIT.usage);
           dir: rest[0],
           preview: values.preview === true,
           message: str(values.message),
-          wait: values["no-wait"] !== true
+          wait: values["no-wait"] !== true,
+          remoteBuild: values["remote-build"] === true
         });
       case "logs":
         return await logs(r, {
@@ -3232,16 +3678,16 @@ Run \`hostedge --help\` for usage.`, EXIT.usage);
 // src/main.ts
 function openUrl(url) {
   const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "explorer" : "xdg-open";
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     try {
-      const child = spawn(command, [url], { stdio: "ignore", detached: true });
-      child.on("error", () => resolve6(false));
+      const child = spawn2(command, [url], { stdio: "ignore", detached: true });
+      child.on("error", () => resolve7(false));
       child.on("spawn", () => {
         child.unref();
-        resolve6(true);
+        resolve7(true);
       });
     } catch {
-      resolve6(false);
+      resolve7(false);
     }
   });
 }
@@ -3261,7 +3707,7 @@ var io = {
     for await (const chunk of process.stdin) chunks.push(chunk);
     return Buffer.concat(chunks).toString("utf8");
   },
-  sleep: (ms) => new Promise((resolve6) => setTimeout(resolve6, ms))
+  sleep: (ms) => new Promise((resolve7) => setTimeout(resolve7, ms))
 };
 var controller = new AbortController();
 process.on("SIGINT", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hostedge",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "Hosting your AI agent can use. Deploy websites and apps to the edge, read logs and manage env vars from the terminal, CI or an AI agent (Claude Code, Cursor, Codex). JSON output, stable exit codes, MCP.",
   "keywords": [
     "hostedge",
@@ -16,11 +16,6 @@
     "cloudflare-workers"
   ],
   "homepage": "https://hostedge.app/docs/cli",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/ybenjaa-dev/appdock.git",
-    "directory": "apps/cli"
-  },
   "type": "module",
   "bin": {
     "hostedge": "dist/hostedge.js"
@@ -33,23 +28,24 @@
   },
   "publishConfig": {
     "access": "public",
-    "provenance": true
+    "provenance": false
+  },
+  "scripts": {
+    "build": "node build.mjs",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --coverage"
   },
   "devDependencies": {
+    "@hostedge/builder": "workspace:*",
+    "@hostedge/config": "workspace:*",
+    "@hostedge/core": "workspace:*",
     "@types/node": "26.6.5",
     "@vitest/coverage-v8": "5.0.5",
     "esbuild": "0.28.2",
     "eslint": "10.13.0",
     "typescript": "6.0.3",
     "uqr": "0.1.3",
-    "vitest": "5.0.5",
-    "@hostedge/core": "0.0.0",
-    "@hostedge/config": "0.0.0"
-  },
-  "scripts": {
-    "build": "node build.mjs",
-    "lint": "eslint .",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run --coverage"
+    "vitest": "5.0.5"
   }
-}
+}