@nevios/cli 0.1.0

package/bin/nevios.mjs

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+/**
+ * nevios — the storefront developer CLI.
+ *
+ *   nevios start   [--dir .]                          # dev server against Nevios
+ *   nevios push    [--dir ./build/server] [--build] [--store <h>] [--account <h>]
+ *   nevios undeploy [--store <h>] [--account <h>]
+ *
+ * `start` runs your store's dev server (react-router dev) wired to the Nevios API.
+ * `push` deploys your built React store to Nevios hosting (Cloudflare Workers-
+ * for-Platforms). With --build it runs `react-router build` first, then uploads
+ * `build/server/*` to Nevios, which hosts it at your store's domain.
+ *
+ * Config: CLI flag → env → ./nevios.json. Auth token in NEVIOS_PAT (server-only).
+ * `.env.local` / `.env` are auto-loaded so local runs work without exporting.
+ */
+
+import { execSync, spawn } from "node:child_process";
+import { readdir, readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+
+import { collectAssets, collectModules, deployStore, detectGit, undeployStore } from "../src/index.mjs";
+
+function parseArgs(argv) {
+  const a = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const t = argv[i];
+    if (t.startsWith("--")) {
+      const k = t.slice(2);
+      if (k === "build" || k === "dry-run") a[k] = true;
+      else a[k] = argv[++i];
+    } else a._.push(t);
+  }
+  return a;
+}
+
+async function loadDotenv(cwd) {
+  for (const name of [".env.local", ".env"]) {
+    let raw;
+    try {
+      raw = await readFile(resolve(cwd, name), "utf8");
+    } catch {
+      continue;
+    }
+    for (const line of raw.split("\n")) {
+      const m = /^\s*([A-Z_][A-Z0-9_]*)\s*=\s*(.*?)\s*$/.exec(line);
+      if (!m || process.env[m[1]] !== undefined) continue;
+      let v = m[2];
+      if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) v = v.slice(1, -1);
+      process.env[m[1]] = v;
+    }
+  }
+}
+
+async function loadConfig(cwd) {
+  try {
+    return JSON.parse(await readFile(resolve(cwd, "nevios.json"), "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+function run(cmd, args, cwd) {
+  return new Promise((res, rej) => {
+    const p = spawn(cmd, args, { cwd, stdio: "inherit", shell: process.platform === "win32" });
+    p.on("close", (code) => (code === 0 ? res() : rej(new Error(`${cmd} exited ${code}`))));
+    p.on("error", rej);
+  });
+}
+
+const fail = (m) => {
+  console.error(`\n✗ ${m}\n`);
+  process.exit(1);
+};
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const cmd = args._[0];
+  if (!cmd || !["start", "push", "preview", "undeploy"].includes(cmd)) {
+    fail(`usage: nevios <start|push|preview|undeploy> [--build] [--dir <path>] [--store h] [--account h]`);
+  }
+  const cwd = process.cwd();
+  await loadDotenv(cwd);
+  const cfg = await loadConfig(cwd);
+
+  if (cmd === "start") {
+    // Dev server against Nevios. The store reads NEXT_PUBLIC_/VITE_ Nevios vars
+    // from its own .env.local; we just launch its dev server in one command.
+    const apiUrl = process.env.NEVIOS_API_URL ?? process.env.NEVIOS_COMMERCE_URL ?? cfg.apiUrl ?? "(store .env)";
+    console.log(`\nnevios start — dev server against Nevios (${apiUrl})`);
+    if (args["dry-run"]) {
+      console.log(`  would run: react-router dev\n`);
+      return;
+    }
+    await run("npx", ["react-router", "dev"], resolve(cwd, args.dir ?? ".")).catch((e) =>
+      fail(`dev server failed: ${e.message} (is this a React Router store dir?)`),
+    );
+    return;
+  }
+
+  const account = args.account ?? process.env.NEVIOS_ACCOUNT ?? cfg.account;
+  const store = args.store ?? process.env.NEVIOS_STORE ?? cfg.store;
+  const apiUrl =
+    args.api ?? process.env.NEVIOS_API_URL ?? process.env.NEVIOS_COMMERCE_URL ?? cfg.apiUrl ?? "https://c.nevios.io";
+  const token = args.token ?? process.env.NEVIOS_PAT ?? cfg.token;
+  if (!account) fail("account is required (--account / NEVIOS_ACCOUNT / nevios.json)");
+  if (!store) fail("store is required (--store / NEVIOS_STORE / nevios.json)");
+  if (!token) fail("token is required (--token / NEVIOS_PAT)");
+
+  if (cmd === "undeploy") {
+    console.log(`\nnevios undeploy — ${store} @ ${account}`);
+    const sf = await undeployStore({ apiUrl, token, account, store }).catch((e) => fail(e.message));
+    console.log(`✓ isolate removed — back to the shared default worker\n`);
+    return sf;
+  }
+
+  // push / preview — same build + upload, different slot
+  const isPreview = cmd === "preview";
+  const buildDir = resolve(cwd, args.dir ?? cfg.dir ?? "./build/server");
+  if (args.build) {
+    console.log(`\nnevios ${cmd} — building (react-router build)…`);
+    await run("npx", ["react-router", "build"], cwd).catch((e) => fail(`build failed: ${e.message}`));
+  }
+  let modules;
+  try {
+    modules = await collectModules(buildDir, { readdir, readFile });
+  } catch (e) {
+    fail(`could not read build dir "${buildDir}": ${e.message} (did you build first? try --build)`);
+  }
+  const names = Object.keys(modules);
+  if (!names.length) fail(`no built modules in ${buildDir} — run \`react-router build\` (or pass --build)`);
+
+  // client bundle (build/client, sibling of build/server) → Workers Static Assets
+  const assetsDir = resolve(cwd, args.assets ?? cfg.assets ?? resolve(buildDir, "../client"));
+  const assets = await collectAssets(assetsDir, { readdir, readFileBuffer: (p) => readFile(p) });
+  // compatibility flags from the RR build (nodejs_compat etc.)
+  let compatibilityFlags;
+  try {
+    compatibilityFlags = JSON.parse(await readFile(resolve(buildDir, "wrangler.json"), "utf8")).compatibility_flags;
+  } catch {
+    /* no wrangler.json — backend defaults to nodejs_compat */
+  }
+
+  console.log(`\nnevios ${cmd} — ${store} @ ${account} → ${apiUrl}`);
+  console.log(
+    `  ${names.length} module(s), ${Object.keys(assets).length} asset(s)${compatibilityFlags ? ` · flags: ${compatibilityFlags.join(",")}` : ""}`,
+  );
+  if (args["dry-run"]) {
+    console.log(`\n(dry run — nothing pushed)\n`);
+    return;
+  }
+  // Git provenance — logged to the deploy history. CI sets NEVIOS_TRIGGERED_BY.
+  const git = detectGit((c) => execSync(c, { cwd, stdio: ["ignore", "pipe", "ignore"] }));
+  // GitHub Actions checks out in DETACHED HEAD, so `rev-parse --abbrev-ref HEAD`
+  // returns the literal "HEAD" — prefer the CI-provided branch/tag name.
+  const sourceRef = process.env.GITHUB_REF_NAME || (git.ref && git.ref !== "HEAD" ? git.ref : null);
+  if (git.commit) console.log(`  commit ${git.commit.slice(0, 7)}${sourceRef ? ` (${sourceRef})` : ""}`);
+  const sf = await deployStore({
+    apiUrl,
+    token,
+    account,
+    store,
+    modules,
+    assets,
+    compatibilityFlags,
+    preview: isPreview,
+    sourceCommit: git.commit,
+    sourceRef,
+    triggeredBy: process.env.NEVIOS_TRIGGERED_BY || "cli",
+  }).catch((e) => fail(e.message));
+  if (isPreview) {
+    console.log(`\n✓ preview deployed — ${sf.preview?.url}\n  (live store untouched)\n`);
+  } else {
+    console.log(
+      `\n✓ deployed — worker_script=${sf.worker_script} version=${sf.worker_version}\n  live at https://${sf.host}\n`,
+    );
+  }
+  return sf;
+}
+
+main().catch((e) => fail(e.stack || e.message));

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@nevios/cli",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "nevios \u2014 the storefront developer CLI: push a React store to Nevios hosting (Cloudflare), preview, and scaffold.",
+  "bin": {
+    "nevios": "bin/nevios.mjs"
+  },
+  "exports": {
+    ".": "./src/index.mjs"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "bin",
+    "src"
+  ]
+}

package/src/index.mjs

@@ -0,0 +1,172 @@
+/**
+ * @nevios/cli — core ops for the storefront developer CLI.
+ *
+ * `push` deploys a built React store to Nevios hosting: it collects the built
+ * Cloudflare Worker ESM modules (e.g. `build/server/*`) and POSTs them to the
+ * Nevios admin deploy endpoint, which uploads the isolate to Workers-for-
+ * Platforms and points the store's host at it (dispatcher → isolate). The store
+ * never holds Cloudflare credentials — the platform does the CF upload.
+ *
+ * Pure functions (fs/fetch injected) so they unit-test without a real project.
+ */
+
+const MODULE_RE = /\.(js|mjs)$/;
+const DEFAULT_VERSION = "2026-01";
+
+/**
+ * Best-effort git provenance for the current working tree → { commit, ref }.
+ * `exec` is injected (a sync `(cmd) => string`) so this unit-tests without git.
+ * Returns nulls when not a git repo / git unavailable — deploy still proceeds.
+ */
+export function detectGit(exec) {
+  const run = (cmd) => {
+    try {
+      return String(exec(cmd)).trim() || null;
+    } catch {
+      return null;
+    }
+  };
+  return {
+    commit: run("git rev-parse HEAD"),
+    ref: run("git rev-parse --abbrev-ref HEAD"),
+  };
+}
+
+/** Recursively collect built Worker modules from a dir → { relPath: source }. */
+export async function collectModules(dir, fs) {
+  const out = {};
+  async function walk(absDir, relDir) {
+    const entries = await fs.readdir(absDir, { withFileTypes: true });
+    for (const e of entries) {
+      const rel = relDir ? `${relDir}/${e.name}` : e.name;
+      if (e.isDirectory()) {
+        await walk(`${absDir}/${e.name}`, rel);
+      } else if (MODULE_RE.test(e.name)) {
+        out[rel] = await fs.readFile(`${absDir}/${e.name}`, "utf8");
+      }
+    }
+  }
+  await walk(dir, "");
+  return out;
+}
+
+/** Collect the built client bundle (build/client) → { site-path: base64 }. */
+export async function collectAssets(dir, fs) {
+  const out = {};
+  async function walk(absDir, relDir) {
+    let entries;
+    try {
+      entries = await fs.readdir(absDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (e.name === ".assetsignore") continue;
+      const rel = relDir ? `${relDir}/${e.name}` : e.name;
+      if (e.isDirectory()) {
+        await walk(`${absDir}/${e.name}`, rel);
+      } else {
+        const buf = await fs.readFileBuffer(`${absDir}/${e.name}`);
+        out[`/${rel}`] = buf.toString("base64");
+      }
+    }
+  }
+  await walk(dir, "");
+  return out;
+}
+
+/** Pick the entry module: `index.js` if present, else the shallowest .js. */
+export function pickMainModule(modules) {
+  const names = Object.keys(modules);
+  if (names.includes("index.js")) return "index.js";
+  const sorted = names
+    .filter((n) => n.endsWith(".js"))
+    .sort((a, b) => a.split("/").length - b.split("/").length || a.localeCompare(b));
+  return sorted[0] ?? names[0];
+}
+
+/**
+ * POST a built isolate to the Nevios admin deploy endpoint. Auth is a platform
+ * token (PAT or JWT) — the account owner. Returns the updated storefront.
+ */
+export async function deployStore({
+  apiUrl,
+  token,
+  account,
+  store,
+  modules,
+  mainModule,
+  version,
+  assets,
+  compatibilityFlags,
+  preview = false,
+  sourceCommit,
+  sourceRef,
+  triggeredBy,
+  apiVersion = DEFAULT_VERSION,
+  fetch = globalThis.fetch,
+}) {
+  if (!apiUrl) throw new Error("push: apiUrl is required");
+  if (!token) throw new Error("push: token (NEVIOS_PAT) is required");
+  if (!account) throw new Error("push: account handle is required");
+  if (!store) throw new Error("push: store handle is required");
+  if (!modules || !Object.keys(modules).length) throw new Error("push: no built modules found");
+  const main = mainModule || pickMainModule(modules);
+  const base = apiUrl.replace(/\/+$/, "");
+  const url = `${base}/admin/${apiVersion}/${encodeURIComponent(account)}/storefronts/${encodeURIComponent(store)}/deploy.json`;
+
+  const body = { modules, main_module: main, version, preview };
+  if (assets && Object.keys(assets).length) body.assets = assets;
+  if (compatibilityFlags && compatibilityFlags.length) body.compatibility_flags = compatibilityFlags;
+  if (sourceCommit) body.source_commit = sourceCommit;
+  if (sourceRef) body.source_ref = sourceRef;
+  if (triggeredBy) body.triggered_by = triggeredBy;
+
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+    },
+    body: JSON.stringify(body),
+  });
+  const text = await res.text();
+  let json = null;
+  try {
+    json = text ? JSON.parse(text) : null;
+  } catch {
+    json = null;
+  }
+  if (!res.ok) {
+    const msg = json?.error?.message || `deploy failed (HTTP ${res.status})`;
+    throw new Error(msg);
+  }
+  return json?.storefront ?? json;
+}
+
+/** Undeploy a store's isolate → back to the shared default. */
+export async function undeployStore({
+  apiUrl,
+  token,
+  account,
+  store,
+  apiVersion = DEFAULT_VERSION,
+  fetch = globalThis.fetch,
+}) {
+  const base = apiUrl.replace(/\/+$/, "");
+  const url = `${base}/admin/${apiVersion}/${encodeURIComponent(account)}/storefronts/${encodeURIComponent(store)}/undeploy.json`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, Accept: "application/json" },
+  });
+  const text = await res.text();
+  let json = null;
+  try {
+    json = text ? JSON.parse(text) : null;
+  } catch {
+    json = null;
+  }
+  if (!res.ok) throw new Error(json?.error?.message || `undeploy failed (HTTP ${res.status})`);
+  return json?.storefront ?? json;
+}