ezi 1.0.0 → 2.0.1

package/README.md

@@ -0,0 +1,59 @@
+# ezi — `npx ezi` launcher for ezicode
+
+Zero-dependency TypeScript CLI. It detects OS/arch, downloads the matching
+native `ezicode` binary from GitHub Releases on first run, caches it, and
+launches the editor detached. No `npm install` required by users.
+
+## Mono-repo layout
+
+```
+ezicode/            # Rust workspace (cargo members: app)
+├── app/            # native editor (ezicode binary)
+├── ezi-cli/        # npm launcher (this folder, NOT a cargo member)
+```
+
+Cargo ignores `ezi-cli/` (`members = ["app"]` in root `Cargo.toml:2`), npm
+ignores the Rust side. One repo, two package managers.
+
+## Develop
+
+```bash
+cd ezi-cli
+npm install
+npm run build     # tsc -> dist/index.js
+node ./dist/index.js --help
+EZI_VERBOSE=1 node ./dist/index.js .   # downloads real binary, opens editor
+```
+
+## Publish
+
+```bash
+cd ezi-cli
+npm run build
+npm publish       # package `ezi`, bin `ezi` -> dist/index.js
+```
+
+Users then run:
+
+```bash
+npx -y ezi@latest .  # first run downloads ~30-60MB binary to cache, opens editor
+ezi .             # after npm i -g ezi
+```
+
+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`) + `latest.json` tag cache
+- Windows: `%LOCALAPPDATA%/ezi/cache/v<version>/`
+- Override: `EZI_CACHE`, `EZI_VERSION`, `EZI_REPO`, `EZI_NO_UPDATE_CHECK=1`

package/dist/index.js

@@ -1 +1,352 @@
-document.addEventListener("DOMContentLoaded",(()=>{const t=document.getElementById("root"),e={};function n(t){const e=t.startsWith("/")?t.slice(1):t;window.location.hash=e,o(e)}function o(n){t.innerHTML="";const o=n.startsWith("/")?n.slice(1):n,c=e[o]||e[`/${o}`];if(c){const e=c.cloneNode(!0);t.appendChild(e)}else if(e[""]||e["/"]){const n=(e[""]||e["/"]).cloneNode(!0);t.appendChild(n)}}document.querySelectorAll("template[route]").forEach((t=>{const n=t.getAttribute("route");e[n]=t.content.cloneNode(!0),t.remove()})),document.addEventListener("click",(t=>{let e=t.target;for(;e&&e!==document;){if("A"===e.tagName&&e.hasAttribute("href")){const o=e.getAttribute("href");o.includes("://")||o.startsWith("mailto:")||o.startsWith("tel:")||(t.preventDefault(),n(o));break}e=e.parentNode}})),window.addEventListener("hashchange",(()=>{o(window.location.hash.replace("#",""))}));o(window.location.hash.replace("#",""))}));
+#!/usr/bin/env node
+"use strict";
+/**
+ * ezi — zero-install launcher for the ezicode native editor.
+ *
+ * Usage:
+ *   npx ezi [file|dir] [args...]   open editor (downloads binary on first run)
+ *   npx ezi --help                  show help
+ *   npx ezi --version               launcher + editor version
+ *
+ * Env overrides:
+ *   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:
+ *   linux x64   -> ezicode-x86_64-unknown-linux-gnu.tar.gz
+ *   mac arm64   -> ezicode-aarch64-apple-darwin.tar.gz
+ *   win x64     -> ezicode-x86_64-pc-windows-msvc.exe (standalone, no unzip)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("node:fs"));
+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.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";
+function resolveTarget() {
+    const platform = process.platform;
+    const arch = process.arch;
+    if (platform === "linux" && arch === "x64") {
+        const t = "x86_64-unknown-linux-gnu";
+        return { kind: "targz", asset: `ezicode-${t}.tar.gz`, binRel: `ezicode-${t}/ezicode` };
+    }
+    if (platform === "darwin" && arch === "arm64") {
+        const t = "aarch64-apple-darwin";
+        return { kind: "targz", asset: `ezicode-${t}.tar.gz`, binRel: `ezicode-${t}/ezicode` };
+    }
+    if (platform === "win32" && arch === "x64") {
+        // Standalone exe on the release — no zip extraction needed.
+        return { kind: "exe", asset: "ezicode-x86_64-pc-windows-msvc.exe" };
+    }
+    throw new Error(`ezi: unsupported platform ${platform}/${arch}. ` +
+        `Prebuilt binaries exist for linux-x64, darwin-arm64, win32-x64 only. ` +
+        `Build from source: https://github.com/${REPO}`);
+}
+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");
+    }
+    const xdg = process.env.XDG_CACHE_HOME || path.join(os.homedir(), ".cache");
+    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) => {
+        const req = https.get(url, { headers: { "User-Agent": "ezi-launcher" } }, (res) => {
+            const status = res.statusCode || 0;
+            if (status >= 300 && status < 400 && res.headers.location) {
+                if (redirects === 0) {
+                    reject(new Error(`ezi: too many redirects downloading ${url}`));
+                    return;
+                }
+                res.resume();
+                download(res.headers.location, dest, redirects - 1).then(resolve, reject);
+                return;
+            }
+            if (status !== 200) {
+                res.resume();
+                reject(new Error(`ezi: download failed (${status}) for ${url}`));
+                return;
+            }
+            const out = fs.createWriteStream(dest);
+            res.pipe(out);
+            out.on("finish", () => out.close(() => resolve()));
+            out.on("error", (err) => {
+                fs.rmSync(dest, { force: true });
+                reject(err);
+            });
+        });
+        req.on("error", reject);
+    });
+}
+function extractTargz(archive, destDir) {
+    return new Promise((resolve, reject) => {
+        // System tar exists on linux + macOS runners and images. Zero-dep by design.
+        (0, node_child_process_1.execFile)("tar", ["-xzf", archive, "-C", destDir], (err, _stdout, stderr) => {
+            if (err) {
+                reject(new Error(`ezi: failed to extract ${archive}: ${stderr || err.message}`));
+                return;
+            }
+            resolve();
+        });
+    });
+}
+async function ensureBinary(tag, verbose) {
+    const target = resolveTarget();
+    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 tmp = bin + ".download";
+        if (verbose)
+            console.log(`ezi: downloading ${url}`);
+        await download(url, tmp);
+        fs.renameSync(tmp, bin);
+        return bin;
+    }
+    const bin = path.join(dir, target.binRel);
+    if (fs.existsSync(bin)) {
+        fs.chmodSync(bin, 0o755);
+        return bin;
+    }
+    const url = `https://github.com/${REPO}/releases/download/${tag}/${target.asset}`;
+    const archive = path.join(dir, target.asset);
+    if (!fs.existsSync(archive)) {
+        if (verbose)
+            console.log(`ezi: downloading ${url}`);
+        await download(url, archive);
+    }
+    if (verbose)
+        console.log(`ezi: extracting ${target.asset}`);
+    await extractTargz(archive, dir);
+    if (!fs.existsSync(bin))
+        throw new Error(`ezi: binary not found after extract: ${bin}`);
+    fs.chmodSync(bin, 0o755);
+    return bin;
+}
+function printHelp(fallbackTag) {
+    console.log(`ezi ${LAUNCHER_VERSION} — launcher for ezicode (https://github.com/${REPO})
+
+Usage:
+  ezi [file|dir] [editor-args...]   open in ezicode (downloads binary first run)
+  ezi --help                        this help
+  ezi --version                     launcher version
+  ezi --where                       print cached binary path
+  ezi --clean                       remove cached binaries
+
+Env:
+  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() {
+    const args = process.argv.slice(2);
+    const verbose = args.includes("--verbose") || !!process.env.EZI_VERBOSE;
+    const passthrough = args.filter((a) => a !== "--verbose");
+    if (passthrough.includes("--help") || passthrough.includes("-h")) {
+        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})`);
+        return;
+    }
+    if (passthrough.includes("--clean")) {
+        fs.rmSync(baseCacheDir(), { recursive: true, force: true });
+        console.log("ezi: cache cleared");
+        return;
+    }
+    const bin = await ensureBinary(tag, verbose);
+    if (passthrough.includes("--where")) {
+        console.log(bin);
+        return;
+    }
+    // Launch detached so `npx ezi` returns immediately while the GUI stays open.
+    // stdio ignored: the editor owns its own window, not the terminal.
+    const child = (0, node_child_process_1.spawn)(bin, passthrough, {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+    });
+    child.unref();
+    if (verbose)
+        console.log(`ezi: launched ${bin}`);
+}
+main().catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/package.json

@@ -1,16 +1,32 @@
-{
-  "name": "ezi",
-  "version": "1.0.0",
-  "description": "A JavaScript library for router",
-  "main": "dist/index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [
-    "ezi",
-    "html",
-    "router"
-  ],
-  "author": "Nazmul Hossain",
-  "license": "MIT"
-}
+{
+  "name": "ezi",
+  "version": "2.0.1",
+  "description": "Launch ezicode editor with npx — zero-install native binary launcher",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/olovalabs/ezicode.git",
+    "directory": "ezi-cli"
+  },
+  "homepage": "https://github.com/olovalabs/ezicode",
+  "keywords": ["ezicode", "ezi", "editor", "ide", "cli", "launcher"],
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "ezi": "./dist/index.js"
+  },
+  "files": ["dist/"],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node ./dist/index.js",
+    "prepublishOnly": "npm run build",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^22.7.0",
+    "typescript": "^5.6.0"
+  }
+}