lunel-cli 0.1.32 → 0.1.33

package/dist/index.js

@@ -8,7 +8,7 @@ const ignore = Ignore.default;
 import * as fs from "fs/promises";
 import * as path from "path";
 import * as os from "os";
-import { spawn, execSync } from "child_process";
+import { spawn, execSync, execFileSync } from "child_process";
 import { createServer, createConnection } from "net";
 import { createInterface } from "readline";
 const DEFAULT_PROXY_URL = process.env.LUNEL_PROXY_URL || "https://gateway.lunel.dev";
@@ -17,6 +17,8 @@ const CLI_ARGS = process.argv.slice(2);
 import { createRequire } from "module";
 const __require = createRequire(import.meta.url);
 const VERSION = __require("../package.json").version;
+const PTY_RELEASE_INFO_URL = process.env.LUNEL_PTY_INFO_URL ||
+    "https://raw.githubusercontent.com/ssbharambe-m/pty-releases/refs/heads/main/info.json";
 // Root directory - sandbox all file operations to this
 const ROOT_DIR = process.cwd();
 // Terminal sessions (managed by Rust PTY binary)
@@ -595,14 +597,157 @@ async function handleGitDiscard(payload) {
 // Terminal Handlers (delegates to Rust PTY binary)
 // ============================================================================
 let dataChannel = null;
+let ensurePtyBinaryPromise = null;
+function normalizeJsonWithTrailingCommas(text) {
+    return text.replace(/,\s*([}\]])/g, "$1");
+}
+function compareSemver(a, b) {
+    const aParts = a.split(".").map((part) => Number.parseInt(part, 10) || 0);
+    const bParts = b.split(".").map((part) => Number.parseInt(part, 10) || 0);
+    const max = Math.max(aParts.length, bParts.length);
+    for (let i = 0; i < max; i++) {
+        const left = aParts[i] ?? 0;
+        const right = bParts[i] ?? 0;
+        if (left !== right)
+            return left > right ? 1 : -1;
+    }
+    return 0;
+}
+function getLunelConfigDir() {
+    const platform = os.platform();
+    if (platform === "win32") {
+        const appData = process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
+        return path.join(appData, "lunel");
+    }
+    if (platform === "darwin") {
+        return path.join(os.homedir(), "Library", "Application Support", "lunel");
+    }
+    const xdg = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+    return path.join(xdg, "lunel");
+}
 function getPtyBinaryPath() {
-    // TODO: Switch to GitHub releases download for production
-    return path.join(os.homedir(), "lunel-pty");
+    const binName = os.platform() === "win32" ? "lunel-pty.exe" : "lunel-pty";
+    return path.join(getLunelConfigDir(), "pty-releases", binName);
+}
+function getPtyPlatformKey() {
+    const platform = os.platform();
+    if (platform === "win32")
+        return "windows";
+    if (platform === "linux")
+        return "linux";
+    if (platform === "darwin")
+        return "macos";
+    throw new Error(`Unsupported platform for PTY: ${platform}`);
+}
+function getPtyArchKey() {
+    const arch = os.arch();
+    if (arch === "arm64" || arch === "arm")
+        return "arm";
+    if (arch === "x64" || arch === "ia32")
+        return "x86";
+    throw new Error(`Unsupported architecture for PTY: ${arch}`);
+}
+async function fetchPtyReleaseInfo() {
+    const response = await fetch(PTY_RELEASE_INFO_URL);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch PTY release info (${response.status})`);
+    }
+    const raw = await response.text();
+    const parsed = JSON.parse(raw);
+    if (!parsed?.version) {
+        throw new Error("Invalid PTY release info: missing version");
+    }
+    return parsed;
+}
+function readInstalledPtyVersion(binPath) {
+    try {
+        const output = execFileSync(binPath, ["--version"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        const version = output.trim();
+        return version || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function downloadPtyBinary(url, destination) {
+    const tempPath = `${destination}.download`;
+    console.log("[pty] Downloading PTY [downloading...]");
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to download PTY binary (${response.status})`);
+    }
+    if (!response.body) {
+        throw new Error("PTY download response had no body");
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let totalBytes = 0;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        if (value) {
+            chunks.push(value);
+            totalBytes += value.byteLength;
+        }
+    }
+    const binary = Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)));
+    await fs.writeFile(tempPath, binary);
+    if (os.platform() !== "win32") {
+        await fs.chmod(tempPath, 0o755);
+    }
+    await fs.rename(tempPath, destination);
+    console.log(`[pty] Downloaded PTY (${Math.max(1, Math.round(totalBytes / 1024))} KB)`);
+}
+async function ensurePtyBinaryReady() {
+    if (ensurePtyBinaryPromise)
+        return ensurePtyBinaryPromise;
+    ensurePtyBinaryPromise = (async () => {
+        const binPath = getPtyBinaryPath();
+        await fs.mkdir(path.dirname(binPath), { recursive: true });
+        const releaseInfo = await fetchPtyReleaseInfo();
+        const platformKey = getPtyPlatformKey();
+        const archKey = getPtyArchKey();
+        const downloadUrl = releaseInfo[platformKey]?.[archKey] || null;
+        if (!downloadUrl) {
+            throw new Error(`PTY binary is not available for ${platformKey}/${archKey} in release ${releaseInfo.version}`);
+        }
+        let hasBinary = true;
+        try {
+            await fs.access(binPath);
+        }
+        catch {
+            hasBinary = false;
+        }
+        const installedVersion = hasBinary ? readInstalledPtyVersion(binPath) : null;
+        const shouldDownload = !hasBinary ||
+            !installedVersion ||
+            compareSemver(installedVersion, releaseInfo.version) < 0;
+        if (!shouldDownload)
+            return binPath;
+        if (!hasBinary) {
+            console.log(`[pty] PTY missing. Installing ${releaseInfo.version}...`);
+        }
+        else {
+            console.log(`[pty] PTY outdated (${installedVersion} -> ${releaseInfo.version}). Updating...`);
+        }
+        await downloadPtyBinary(downloadUrl, binPath);
+        return binPath;
+    })();
+    try {
+        return await ensurePtyBinaryPromise;
+    }
+    finally {
+        ensurePtyBinaryPromise = null;
+    }
 }
-function ensurePtyProcess() {
+async function ensurePtyProcess() {
     if (ptyProcess && ptyProcess.exitCode === null)
         return;
-    const binPath = getPtyBinaryPath();
+    const binPath = await ensurePtyBinaryReady();
     ptyProcess = spawn(binPath, [], {
         cwd: ROOT_DIR,
         stdio: ["pipe", "pipe", "pipe"],
@@ -690,7 +835,7 @@ function sendToPty(cmd) {
     ptyProcess.stdin.write(JSON.stringify(cmd) + "\n");
 }
 async function handleTerminalSpawn(payload) {
-    ensurePtyProcess();
+    await ensurePtyProcess();
     const shell = payload.shell || process.env.SHELL || "/bin/sh";
     const cols = payload.cols || 80;
     const rows = payload.rows || 24;
@@ -2152,6 +2297,9 @@ async function main() {
         console.log(`Extra ports enabled: ${EXTRA_PORTS.join(", ")}`);
     }
     try {
+        console.log("Checking PTY runtime...");
+        await ensurePtyBinaryReady();
+        console.log("PTY runtime ready.\n");
         // Generate auth credentials (like CodeNomad does)
         const opencodeUsername = "lunel";
         const opencodePassword = crypto.randomBytes(32).toString("base64url");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lunel-cli",
-  "version": "0.1.32",
+  "version": "0.1.33",
   "author": [
     {
       "name": "Soham Bharambe",