ezi 2.0.0 → 2.0.1

package/README.md

@@ -36,16 +36,24 @@ npm publish       # package `ezi`, bin `ezi` -> dist/index.js
 Users then run:
 
 ```bash
-npx -y ezi .      # first run downloads ~30-60MB binary to cache, opens editor
+npx -y ezi@latest .  # first run downloads ~30-60MB binary to cache, opens editor
 ezi .             # after npm i -g ezi
 ```
 
-Keep `VERSION` in `src/index.ts`, `version` in `package.json`, and `version`
-in `app/Cargo.toml` in sync — the launcher builds its download URL as
-`.../releases/download/v<VERSION>/ezicode-<target>.*`.
+Version resolution (no republish needed for editor releases):
+
+1. `EZI_VERSION=0.1.2` pins that release, no network.
+2. Unset (or `EZI_VERSION=latest`, just `npx ezi`) checks
+   `api.github.com/repos/<owner>/<repo>/releases/latest` on every run.
+   Same tag reuses the cached binary (no download); new tag downloads once
+   to `<cache>/vX.Y.Z/`. Offline / API failure reuses the last-seen tag,
+   else the compiled-in default near `app/Cargo.toml`.
+
+Only republish `ezi` for launcher bugfixes. Skip the lookup with
+`EZI_NO_UPDATE_CHECK=1`. Optional `EZI_GITHUB_TOKEN` raises API rate limits.
 
 ## Cache
 
-- Linux/macOS: `~/.cache/ezi/v<version>/` (or `$XDG_CACHE_HOME`)
+- Linux/macOS: `~/.cache/ezi/v<version>/` (or `$XDG_CACHE_HOME`) + `latest.json` tag cache
 - Windows: `%LOCALAPPDATA%/ezi/cache/v<version>/`
-- Override: `EZI_CACHE`, `EZI_VERSION`, `EZI_REPO`
+- Override: `EZI_CACHE`, `EZI_VERSION`, `EZI_REPO`, `EZI_NO_UPDATE_CHECK=1`

package/dist/index.js

@@ -9,9 +9,11 @@
  *   npx ezi --version               launcher + editor version
  *
  * Env overrides:
- *   EZI_VERSION   GitHub tag version without `v` (default: package version)
+ *   EZI_VERSION   pinned version without `v`, `latest`, or unset (default: auto-detect)
  *   EZI_REPO      `owner/repo` (default: olovalabs/ezicode)
  *   EZI_CACHE     cache dir override
+ *   EZI_NO_UPDATE_CHECK  set to 1 to skip GitHub lookup, use fallback immediately
+ *   EZI_GITHUB_TOKEN     optional token to raise api.github.com rate limits
  *
  * Design: zero npm dependencies (node builtins only) so the published
  * package stays ~5KB. Platform binaries come from GitHub Releases:
@@ -58,10 +60,9 @@ const https = __importStar(require("node:https"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const node_child_process_1 = require("node:child_process");
-const LAUNCHER_VERSION = "2.0.0"; // npm package version
-const EDITOR_VERSION = "0.1.2"; // keep in sync with app/Cargo.toml (default download)
+const LAUNCHER_VERSION = "2.0.1"; // npm package version
+const FALLBACK_EDITOR_VERSION = "0.1.3"; // used when offline / API fails; keep near app/Cargo.toml
 const REPO = process.env.EZI_REPO || "olovalabs/ezicode";
-const TAG = `v${process.env.EZI_VERSION || EDITOR_VERSION}`;
 function resolveTarget() {
     const platform = process.platform;
     const arch = process.arch;
@@ -81,15 +82,141 @@ function resolveTarget() {
         `Prebuilt binaries exist for linux-x64, darwin-arm64, win32-x64 only. ` +
         `Build from source: https://github.com/${REPO}`);
 }
-function cacheDir() {
+function baseCacheDir() {
     if (process.env.EZI_CACHE)
         return process.env.EZI_CACHE;
     if (process.platform === "win32") {
         const base = process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local");
-        return path.join(base, "ezi", "cache", TAG);
+        return path.join(base, "ezi", "cache");
     }
     const xdg = process.env.XDG_CACHE_HOME || path.join(os.homedir(), ".cache");
-    return path.join(xdg, "ezi", TAG);
+    return path.join(xdg, "ezi");
+}
+function cacheDirFor(tag) {
+    return path.join(baseCacheDir(), tag);
+}
+function latestCacheFile() {
+    return path.join(baseCacheDir(), "latest.json");
+}
+function normalizeTag(raw) {
+    const t = raw.trim();
+    return t.startsWith("v") ? t : `v${t}`;
+}
+function fetchLatestTag(verbose) {
+    return new Promise((resolve) => {
+        const headers = {
+            "User-Agent": "ezi-launcher",
+            Accept: "application/vnd.github+json",
+        };
+        if (process.env.EZI_GITHUB_TOKEN) {
+            headers.Authorization = `Bearer ${process.env.EZI_GITHUB_TOKEN}`;
+        }
+        const req = https.get(`https://api.github.com/repos/${REPO}/releases/latest`, { headers, timeout: 5000 }, (res) => {
+            const status = res.statusCode || 0;
+            if (status !== 200) {
+                if (verbose)
+                    console.log(`ezi: release lookup failed (http ${status}), using fallback`);
+                res.resume();
+                resolve(null);
+                return;
+            }
+            let body = "";
+            res.setEncoding("utf8");
+            res.on("data", (chunk) => {
+                body += chunk;
+                // Guard against unexpectedly large payloads.
+                if (body.length > 256 * 1024) {
+                    res.destroy();
+                    resolve(null);
+                }
+            });
+            res.on("end", () => {
+                try {
+                    const json = JSON.parse(body);
+                    if (typeof json.tag_name === "string" && json.tag_name.trim()) {
+                        resolve(normalizeTag(json.tag_name));
+                    }
+                    else {
+                        resolve(null);
+                    }
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+        });
+        req.on("timeout", () => {
+            if (verbose)
+                console.log("ezi: release lookup timed out, using fallback");
+            req.destroy();
+            resolve(null);
+        });
+        req.on("error", (err) => {
+            if (verbose)
+                console.log(`ezi: release lookup error (${err.message}), using fallback`);
+            resolve(null);
+        });
+    });
+}
+function readLastSeenTag(verbose) {
+    try {
+        const raw = fs.readFileSync(latestCacheFile(), "utf8");
+        const cached = JSON.parse(raw);
+        if (typeof cached.tag !== "string" || !cached.tag)
+            return null;
+        if (verbose)
+            console.log(`ezi: last seen ${cached.tag}`);
+        return cached.tag;
+    }
+    catch {
+        return null;
+    }
+}
+function writeCachedTag(tag) {
+    try {
+        fs.mkdirSync(baseCacheDir(), { recursive: true });
+        fs.writeFileSync(latestCacheFile(), JSON.stringify({ tag, checkedAt: Date.now() }), "utf8");
+    }
+    catch {
+        // Cache is best-effort; a read-only homedir must not break launches.
+    }
+}
+/**
+ * Resolve which editor release to run:
+ *   EZI_VERSION=<x.y.z|vX.Y.Z> -> that pin, no network.
+ *   EZI_VERSION=latest (or unset) -> check GitHub every run; same tag reuses
+ *     cached binary (no download), new tag downloads once, offline reuses last seen.
+ *   EZI_NO_UPDATE_CHECK=1 -> skip network, use last seen or fallback.
+ */
+async function resolveTag(verbose) {
+    const pinned = (process.env.EZI_VERSION || "").trim();
+    if (pinned && pinned.toLowerCase() !== "latest") {
+        return normalizeTag(pinned);
+    }
+    if (process.env.EZI_NO_UPDATE_CHECK === "1") {
+        const last = readLastSeenTag(verbose);
+        if (last)
+            return last;
+        if (verbose)
+            console.log("ezi: update check disabled, using fallback");
+        return `v${FALLBACK_EDITOR_VERSION}`;
+    }
+    // Always check: cheap API call (~200ms). Same version -> cached binary, no download.
+    const latest = await fetchLatestTag(verbose);
+    if (latest) {
+        const prev = readLastSeenTag(false);
+        if (prev !== latest && verbose)
+            console.log(`ezi: new release ${latest} (was ${prev || "none"})`);
+        else if (verbose)
+            console.log(`ezi: latest is ${latest}, reusing cache`);
+        writeCachedTag(latest);
+        return latest;
+    }
+    // Offline/API failure: reuse last seen tag so repeat launches keep working.
+    const stale = readLastSeenTag(verbose);
+    if (stale)
+        return stale;
+    return `v${FALLBACK_EDITOR_VERSION}`;
 }
 function download(url, dest, redirects = 5) {
     return new Promise((resolve, reject) => {
@@ -132,15 +259,15 @@ function extractTargz(archive, destDir) {
         });
     });
 }
-async function ensureBinary(verbose) {
+async function ensureBinary(tag, verbose) {
     const target = resolveTarget();
-    const dir = cacheDir();
+    const dir = cacheDirFor(tag);
     fs.mkdirSync(dir, { recursive: true });
     if (target.kind === "exe") {
         const bin = path.join(dir, "ezicode.exe");
         if (fs.existsSync(bin))
             return bin;
-        const url = `https://github.com/${REPO}/releases/download/${TAG}/${target.asset}`;
+        const url = `https://github.com/${REPO}/releases/download/${tag}/${target.asset}`;
         const tmp = bin + ".download";
         if (verbose)
             console.log(`ezi: downloading ${url}`);
@@ -153,7 +280,7 @@ async function ensureBinary(verbose) {
         fs.chmodSync(bin, 0o755);
         return bin;
     }
-    const url = `https://github.com/${REPO}/releases/download/${TAG}/${target.asset}`;
+    const url = `https://github.com/${REPO}/releases/download/${tag}/${target.asset}`;
     const archive = path.join(dir, target.asset);
     if (!fs.existsSync(archive)) {
         if (verbose)
@@ -168,7 +295,7 @@ async function ensureBinary(verbose) {
     fs.chmodSync(bin, 0o755);
     return bin;
 }
-function printHelp() {
+function printHelp(fallbackTag) {
     console.log(`ezi ${LAUNCHER_VERSION} — launcher for ezicode (https://github.com/${REPO})
 
 Usage:
@@ -179,9 +306,10 @@ Usage:
   ezi --clean                       remove cached binaries
 
 Env:
-  EZI_VERSION   release version (default ${EDITOR_VERSION})
+  EZI_VERSION   pin release (e.g. 0.1.3), "latest", or unset for auto-detect (default ${fallbackTag})
   EZI_REPO      owner/repo (default ${REPO})
   EZI_CACHE     cache dir override
+  EZI_NO_UPDATE_CHECK=1  skip GitHub lookup, use cache/fallback
 `);
 }
 async function main() {
@@ -189,19 +317,20 @@ async function main() {
     const verbose = args.includes("--verbose") || !!process.env.EZI_VERBOSE;
     const passthrough = args.filter((a) => a !== "--verbose");
     if (passthrough.includes("--help") || passthrough.includes("-h")) {
-        printHelp();
+        printHelp(`v${FALLBACK_EDITOR_VERSION}`);
         return;
     }
+    const tag = await resolveTag(verbose);
     if (passthrough.includes("--version") || passthrough.includes("-V")) {
-        console.log(`ezi ${LAUNCHER_VERSION} (editor ${TAG} @ ${REPO})`);
+        console.log(`ezi ${LAUNCHER_VERSION} (editor ${tag} @ ${REPO})`);
         return;
     }
     if (passthrough.includes("--clean")) {
-        fs.rmSync(cacheDir(), { recursive: true, force: true });
+        fs.rmSync(baseCacheDir(), { recursive: true, force: true });
         console.log("ezi: cache cleared");
         return;
     }
-    const bin = await ensureBinary(verbose);
+    const bin = await ensureBinary(tag, verbose);
     if (passthrough.includes("--where")) {
         console.log(bin);
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ezi",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Launch ezicode editor with npx — zero-install native binary launcher",
   "license": "MIT",
   "repository": {