create-wordjs 1.14.1 → 2.0.0

package/README.md

@@ -34,8 +34,9 @@ That single command takes you from nothing to the browser install wizard:
    → https://localhost:3000/install?token=…
    ```
 
-Open the URL, pick your database (SQLite — zero config — or PostgreSQL), create your admin
-account, and you're in.
+Open the URL, pick your database, create your admin account, and you're in. The wizard offers
+**SQLite** (zero config, the default), **PostgreSQL** and **MySQL/MariaDB** — all three are certified
+in CI — plus a pure-JS *SQLite (legacy / WASM)* fallback for hosts where the native binary can't load.
 
 ## Requirements
 
@@ -49,6 +50,9 @@ account, and you're in.
 | `--version <tag>` | Install a specific release (e.g. `--version v1.0.0`) instead of the latest. |
 | `--http` | Serve plain HTTP instead of self-signed HTTPS (sets `WORDJS_HTTP=1`). |
 | `--no-start` | Scaffold and install dependencies only — start the server yourself later. |
+| `--yes`, `-y` | Skip the confirmation prompt (required when `upgrade` runs non-interactively). |
+| `--force` | (`upgrade`) Re-apply even if the site is already on the target version. |
+| `--no-install` | (`upgrade`) Swap the code only; skip `npm run release:install`. |
 | `-h`, `--help` | Show usage. |
 
 Separate-mode options:
@@ -68,8 +72,10 @@ Separate-mode options:
 cd .. && npx create-wordjs@latest upgrade my-site      # or run it from inside: npx create-wordjs@latest upgrade .
 ```
 
-Downloads the newest release and replaces the app code while **preserving your data**: the SQLite
-database, `uploads/`, `wordjs-config.json`, gateway secrets and any user-installed plugins survive.
+Downloads the newest release and replaces the app code while **preserving your data**: the database
+directory (`backend/data`), `backend/uploads/`, `wordjs-config.json`, `.env`, gateway secrets
+(`gateway/gateway-config.json`) and any user-installed plugins survive. It asks for confirmation
+before touching an existing install — on a non-interactive shell it refuses unless you pass `--yes`.
 Restart the server afterwards (schema migrations run automatically on the next start).
 
 ## Separate mode (multi-machine)
@@ -95,9 +101,11 @@ npx create-wordjs@latest join frontend --gateway 10.0.0.1 --token <t> --ca-hash
 ```
 
 Each `join` downloads the release, enrolls against the gateway (the token authorizes exactly one
-certificate signing; it is burned afterwards), then starts the service, which registers with the
-gateway over mTLS. Browse `https://<gateway>:3000` when all three are up. `join` machines need
-`openssl` on the PATH. Full details, port matrix and the manual (source-checkout) procedure:
+certificate signing; it is burned afterwards, and the ones `gateway` printed also expire after 120
+minutes — mint more on the gateway with `node scripts/cluster.js token <backend|frontend>`, which
+defaults to a 60-minute TTL and takes `--ttl <minutes>`), then starts the service, which registers
+with the gateway over mTLS. Browse `https://<gateway>:3000` when all three are up. `join` machines
+need `openssl` on the PATH. Full details, port matrix and the manual (source-checkout) procedure:
 [documentation/separate-mode.md](https://github.com/jaimemartinez/wordjs/blob/main/documentation/separate-mode.md).
 
 ## Good to know
@@ -118,7 +126,9 @@ gateway over mTLS. Browse `https://<gateway>:3000` when all three are up. `join`
 ## What gets created
 
 A ready-to-run WordJS bundle: backend (pre-compiled to `dist/`), frontend (pre-built `.next`),
-gateway, bundled plugins and themes. Secrets (JWT, DB password, install token) are generated
+gateway, the bundled plugins and the four bundled themes (`circuito`, `default`, `gaceta`,
+`vergel`). Marketplace plugins are **not** in the bundle — they ship as separate release assets and
+are installed from the admin. Secrets (JWT, DB password, install token) are generated
 locally during install — nothing sensitive ships in the bundle. See `INSTALL.md` inside the
 scaffolded directory for the manual steps and `documentation/deployment.md` for production
 deployment.

package/index.js

@@ -181,6 +181,41 @@ async function githubJson(url) {
     try { return JSON.parse(body); } catch { fail('GitHub returned an unparsable response.', 'Try again, or use --zip <path-to-zip>.'); }
 }
 
+// NAME THE ASSET WE WANT; DO NOT TAKE THE FIRST ONE THAT LOOKS RIGHT.
+//
+// The core bundle is not alone on the release: the same release carries all 31 marketplace plugin
+// zips, and `wordjs-*.zip` is a shape, not an identity. A plugin slug beginning with `wordjs-` would
+// sort ahead of the bundle in the assets array and this installer would download a plugin and try to
+// boot it as a site. Nothing today collides, which is exactly when it is cheap to fix.
+//
+// release.yml names the bundle after the tag (`wordjs-v2.0.0.zip`), so ask for that by name. The
+// loose match survives only as a fallback — for older releases, and so a rename in the workflow
+// degrades gracefully instead of failing hard.
+//
+// BUT THE FALLBACK IS THE OLD RULE, so it cannot be allowed to guess. Taking the first loose match
+// would reinstate exactly the bug the exact match was added to fix, on every path where the
+// tag-named asset is absent (a workflow_dispatch build, a rename, any earlier release). The loose
+// shape is therefore used ONLY when it is unambiguous: exactly one candidate. Two or more means we
+// would be choosing which file is the site, and choosing wrong installs a plugin as a site — so we
+// refuse and say so, and `--zip` is right there. Fail closed, never guess.
+//
+// Exported (below) so it can be exercised directly: it is the one piece of release resolution that is
+// pure, and testing it through the network call would mean testing a copy of it instead.
+function pickBundleAsset(assets, tagName) {
+    const list = Array.isArray(assets) ? assets : [];
+    const wanted = `wordjs-${tagName}.zip`.toLowerCase();
+    const exact = list.find((a) => String(a && a.name || '').toLowerCase() === wanted);
+    if (exact) return exact;
+    const loose = looseBundleCandidates(list);
+    return loose.length === 1 ? loose[0] : null;
+}
+
+/** Every asset matching the loose `wordjs-*.zip` shape — used to explain an ambiguous refusal. */
+function looseBundleCandidates(assets) {
+    const list = Array.isArray(assets) ? assets : [];
+    return list.filter((a) => /^wordjs-.*\.zip$/i.test(a && a.name || ''));
+}
+
 async function resolveReleaseAsset(tag) {
     const url = tag
         ? `https://api.github.com/repos/${REPO}/releases/tags/${encodeURIComponent(tag)}`
@@ -190,8 +225,17 @@ async function resolveReleaseAsset(tag) {
         fail(tag ? `No release found for tag "${tag}".` : `No releases found for ${REPO}.`,
             `See https://github.com/${REPO}/releases for available versions, or pass --zip <path-or-url>.`);
     }
-    const asset = (release.assets || []).find((a) => /^wordjs-.*\.zip$/i.test(a.name || ''));
-    if (!asset) fail(`Release ${release.tag_name} has no wordjs-*.zip asset.`, 'Pass --zip <path-or-url> instead.');
+    const asset = pickBundleAsset(release.assets, release.tag_name);
+    if (!asset) {
+        // Say WHICH of the two refusals this is: "there is no bundle" and "there are several and I
+        // will not guess" need different answers from whoever is reading.
+        const candidates = looseBundleCandidates(release.assets).map((a) => a.name);
+        if (candidates.length > 1) {
+            fail(`Release ${release.tag_name} has no asset named wordjs-${release.tag_name}.zip, and ${candidates.length} others match wordjs-*.zip: ${candidates.join(', ')}.`,
+                'Refusing to guess which one is the site bundle — pass --zip <path-or-url> with the one you want.');
+        }
+        fail(`Release ${release.tag_name} has no wordjs-*.zip asset.`, 'Pass --zip <path-or-url> instead.');
+    }
     return { name: asset.name, url: asset.browser_download_url, tag: release.tag_name };
 }
 
@@ -730,4 +774,9 @@ async function main() {
     child.on('exit', (code) => process.exit(code == null ? 0 : code));
 }
 
-main().catch((e) => fail(e && e.message ? e.message : String(e)));
+// Run only when invoked as the CLI, so the pure helpers above can be required and exercised.
+if (require.main === module) {
+    main().catch((e) => fail(e && e.message ? e.message : String(e)));
+}
+
+module.exports = { pickBundleAsset };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "create-wordjs",
-    "version": "1.14.1",
+    "version": "2.0.0",
     "description": "Create a WordJS site with one command — the self-hosted CMS where third-party plugins run in an OS-isolated process with per-capability permission grants. SSR/SEO out of the box, SQLite by default, no PHP.",
     "license": "MIT",
     "author": "Jaime Martinez (https://github.com/jaimemartinez)",
@@ -46,6 +46,9 @@
         "access": "public"
     },
     "dependencies": {
-        "adm-zip": "^0.5.16"
+        "adm-zip": "^0.6.0"
+    },
+    "scripts": {
+        "test": "node --test test/*.test.js"
     }
 }