@xberg-io/liter-llm-cli 1.11.1 → 1.11.2

package/bin/liter-llm.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-// ~keep Launcher: exec the downloaded native liter-llm binary, forwarding argv and
-// ~keep inheriting stdio. If the binary is missing (postinstall failed), download it
-// ~keep on demand before exec.
+// ~keep Launcher: exec the downloaded native liter-llm binary, forwarding argv
+// and ~keep inheriting stdio. If the binary is missing (postinstall failed),
+// download it ~keep on demand before exec.
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { spawnSync } from "node:child_process";
+import {fileURLToPath} from "node:url";
+import {spawnSync} from "node:child_process";
 
 const BIN_NAME = "liter-llm";
 
@@ -18,13 +18,16 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // ~keep install.js extracts the binary into this same bin/ directory.
 const binPath = path.join(__dirname, binaryName());
 
-// ~keep A cached binary is only usable if it is non-empty and (on non-Windows) has an
-// ~keep exec bit. A truncated or non-executable file means a corrupt cache: re-download.
+// ~keep A cached binary is only usable if it is non-empty and (on non-Windows)
+// has an ~keep exec bit. A truncated or non-executable file means a corrupt
+// cache: re-download.
 function isHealthy(file) {
   try {
     const stat = fs.statSync(file);
-    if (stat.size <= 0) return false;
-    if (os.type() !== "Windows_NT" && (stat.mode & 0o111) === 0) return false;
+    if (stat.size <= 0)
+      return false;
+    if (os.type() !== "Windows_NT" && (stat.mode & 0o111) === 0)
+      return false;
     return true;
   } catch {
     return false;
@@ -32,20 +35,22 @@ function isHealthy(file) {
 }
 
 async function ensureBinary() {
-  if (fs.existsSync(binPath) && isHealthy(binPath)) return;
-  process.stderr.write(`${BIN_NAME}: binary missing or corrupt, attempting download...\n`);
-  // ~keep Call main() explicitly rather than relying on import side-effects: ESM
-  // ~keep caches modules, so the installer's top-level run is gated to direct
-  // ~keep invocation only and would not fire on import.
-  const { main } = await import("../install.js");
+  if (fs.existsSync(binPath) && isHealthy(binPath))
+    return;
+  process.stderr.write(
+      `${BIN_NAME}: binary missing or corrupt, attempting download...\n`);
+  // ~keep Call main() explicitly rather than relying on import side-effects:
+  // ESM ~keep caches modules, so the installer's top-level run is gated to
+  // direct ~keep invocation only and would not fire on import.
+  const {main} = await import("../install.js");
   await main();
 }
 
 function printUnavailable() {
   process.stderr.write(
-    `${BIN_NAME} is not available for your platform yet. Install it with:\n` +
-      `  brew install xberg-io/tap/liter-llm\n` +
-      `  or use the Xberg plugin:  /plugin marketplace add xberg-io/plugins\n`,
+      `${BIN_NAME} is not available for your platform yet. Install it with:\n` +
+          `  brew install xberg-io/tap/liter-llm\n` +
+          `  or use the Xberg plugin:  /plugin marketplace add xberg-io/plugins\n`,
   );
 }
 
@@ -55,16 +60,18 @@ async function main() {
     printUnavailable();
     process.exit(1);
   }
-  const result = spawnSync(binPath, process.argv.slice(2), { stdio: "inherit" });
+  const result = spawnSync(binPath, process.argv.slice(2), {stdio : "inherit"});
   if (result.error) {
-    process.stderr.write(`${BIN_NAME}: failed to spawn binary: ${result.error.message}\n`);
+    process.stderr.write(
+        `${BIN_NAME}: failed to spawn binary: ${result.error.message}\n`);
     process.exit(1);
   }
   process.exit(result.status ?? 0);
 }
 
 main().catch((err) => {
-  // ~keep No standalone CLI for this platform: print the graceful install hint, not a stack.
+  // ~keep No standalone CLI for this platform: print the graceful install hint,
+  // not a stack.
   if (err && err.name === "CliUnavailableError") {
     printUnavailable();
     process.exit(1);

package/install.js

@@ -1,10 +1,10 @@
+import {execFileSync, spawnSync} from "node:child_process";
+import crypto from "node:crypto";
 import fs from "node:fs";
+import https from "node:https";
 import os from "node:os";
 import path from "node:path";
-import https from "node:https";
-import crypto from "node:crypto";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { spawnSync, execFileSync } from "node:child_process";
+import {fileURLToPath, pathToFileURL} from "node:url";
 
 const REPO = "xberg-io/liter-llm";
 const BIN_NAME = "liter-llm";
@@ -17,17 +17,22 @@ function targetTriple() {
   const arch = os.arch();
 
   if (type === "Windows_NT") {
-    if (arch === "x64") return "x86_64-pc-windows-msvc";
+    if (arch === "x64")
+      return "x86_64-pc-windows-msvc";
     throw new Error(`unsupported Windows arch: ${arch}`);
   }
   if (type === "Linux") {
-    if (arch === "x64") return "x86_64-unknown-linux-gnu";
-    if (arch === "arm64") return "aarch64-unknown-linux-gnu";
+    if (arch === "x64")
+      return "x86_64-unknown-linux-gnu";
+    if (arch === "arm64")
+      return "aarch64-unknown-linux-gnu";
     throw new Error(`unsupported Linux arch: ${arch}`);
   }
   if (type === "Darwin") {
-    if (arch === "arm64") return "aarch64-apple-darwin";
-    if (arch === "x64") return "x86_64-apple-darwin";
+    if (arch === "arm64")
+      return "aarch64-apple-darwin";
+    if (arch === "x64")
+      return "x86_64-apple-darwin";
     throw new Error(`unsupported macOS arch: ${arch}`);
   }
   throw new Error(`unsupported platform: ${type} ${arch}`);
@@ -37,30 +42,35 @@ function binaryName() {
   return os.type() === "Windows_NT" ? `${BIN_NAME}.exe` : BIN_NAME;
 }
 
-function httpGetBuffer(url, { headers = {} } = {}, maxRedirects = 5) {
+function httpGetBuffer(url, {headers = {}} = {}, maxRedirects = 5) {
   return new Promise((resolve, reject) => {
-    if (maxRedirects < 0) return reject(new Error("too many redirects"));
+    if (maxRedirects < 0)
+      return reject(new Error("too many redirects"));
     if (!/^https:\/\//i.test(url)) {
       return reject(new Error(`refusing non-https URL: ${url}`));
     }
-    const req = https.get(url, { headers: { "User-Agent": USER_AGENT, ...headers } }, (res) => {
-      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-        res.resume();
-        const next = res.headers.location;
-        if (!/^https:\/\//i.test(next)) {
-          return reject(new Error(`refusing non-https redirect to: ${next}`));
-        }
-        return httpGetBuffer(next, { headers }, maxRedirects - 1).then(resolve, reject);
-      }
-      if (res.statusCode !== 200) {
-        res.resume();
-        return reject(new Error(`HTTP ${res.statusCode} for ${url}`));
-      }
-      const chunks = [];
-      res.on("data", (c) => chunks.push(c));
-      res.on("end", () => resolve(Buffer.concat(chunks)));
-      res.on("error", reject);
-    });
+    const req = https.get(
+        url, {headers : {"User-Agent" : USER_AGENT, ...headers}}, (res) => {
+          if (res.statusCode >= 300 && res.statusCode < 400 &&
+              res.headers.location) {
+            res.resume();
+            const next = res.headers.location;
+            if (!/^https:\/\//i.test(next)) {
+              return reject(
+                  new Error(`refusing non-https redirect to: ${next}`));
+            }
+            return httpGetBuffer(next, {headers}, maxRedirects - 1)
+                .then(resolve, reject);
+          }
+          if (res.statusCode !== 200) {
+            res.resume();
+            return reject(new Error(`HTTP ${res.statusCode} for ${url}`));
+          }
+          const chunks = [];
+          res.on("data", (c) => chunks.push(c));
+          res.on("end", () => resolve(Buffer.concat(chunks)));
+          res.on("error", reject);
+        });
     req.on("error", reject);
     req.setTimeout(60000, () => {
       req.destroy();
@@ -70,7 +80,8 @@ function httpGetBuffer(url, { headers = {} } = {}, maxRedirects = 5) {
 }
 
 async function httpGetJson(url) {
-  const buf = await httpGetBuffer(url, { headers: { Accept: "application/vnd.github+json" } });
+  const buf = await httpGetBuffer(
+      url, {headers : {Accept : "application/vnd.github+json"}});
   return JSON.parse(buf.toString("utf8"));
 }
 
@@ -106,19 +117,24 @@ export function isNonCliArtifact(name) {
 export function assetScore(name) {
   const n = (name || "").toLowerCase();
   let score = 0;
-  if (n.includes("cli")) score += 2;
-  if (n.includes(BIN_NAME.toLowerCase())) score += 1;
+  if (n.includes("cli"))
+    score += 2;
+  if (n.includes(BIN_NAME.toLowerCase()))
+    score += 1;
   return score;
 }
 
 export function selectArchiveName(names, triple) {
   const survivors = (names || []).filter((name) => {
     const n = (name || "").toLowerCase();
-    if (!n.includes(triple)) return false;
-    if (!(n.endsWith(".tar.gz") || n.endsWith(".zip"))) return false;
+    if (!n.includes(triple))
+      return false;
+    if (!(n.endsWith(".tar.gz") || n.endsWith(".zip")))
+      return false;
     return !isNonCliArtifact(n);
   });
-  if (survivors.length === 0) return null;
+  if (survivors.length === 0)
+    return null;
   survivors.sort((a, b) => assetScore(b) - assetScore(a));
   return survivors[0];
 }
@@ -127,15 +143,16 @@ async function resolveRelease() {
   const triple = targetTriple();
   const pinned = process.env[VERSION_ENV];
   const apiUrl = pinned
-    ? `https://api.github.com/repos/${REPO}/releases/tags/${encodeURIComponent(pinned)}`
-    : `https://api.github.com/repos/${REPO}/releases/latest`;
+                     ? `https://api.github.com/repos/${REPO}/releases/tags/${
+                           encodeURIComponent(pinned)}`
+                     : `https://api.github.com/repos/${REPO}/releases/latest`;
 
   let release;
   try {
     release = await httpGetJson(apiUrl);
   } catch (err) {
     if (pinned && /HTTP 404/.test(err.message)) {
-      throw new Error(`release tag '${pinned}' not found`, { cause: err });
+      throw new Error(`release tag '${pinned}' not found`, {cause : err});
     }
     throw err;
   }
@@ -143,16 +160,18 @@ async function resolveRelease() {
   const tag = release.tag_name || pinned || "latest";
 
   const chosenName = selectArchiveName(
-    assets.map((a) => a.name),
-    triple,
+      assets.map((a) => a.name),
+      triple,
   );
   if (!chosenName) {
-    throw new CliUnavailableError(`no standalone CLI asset for target triple "${triple}" in ${REPO} release ${tag}`);
+    throw new CliUnavailableError(`no standalone CLI asset for target triple "${
+        triple}" in ${REPO} release ${tag}`);
   }
   const archive = assets.find((a) => a.name === chosenName);
-  const checksums = assets.find((a) => (a.name || "").toUpperCase().includes("SHA256SUMS"));
+  const checksums =
+      assets.find((a) => (a.name || "").toUpperCase().includes("SHA256SUMS"));
 
-  return { tag, triple, archive, checksums };
+  return {tag, triple, archive, checksums};
 }
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -161,11 +180,14 @@ const BIN_DIR = path.join(__dirname, "bin");
 function expectedDigest(text, assetName) {
   for (const raw of text.split(/\r?\n/)) {
     const line = raw.trim();
-    if (!line) continue;
+    if (!line)
+      continue;
     const parts = line.split(/\s+/);
-    if (parts.length < 2) continue;
+    if (parts.length < 2)
+      continue;
     const name = parts[parts.length - 1].replace(/^\*/, "");
-    if (name === assetName) return parts[0].toLowerCase();
+    if (name === assetName)
+      return parts[0].toLowerCase();
   }
   return null;
 }
@@ -173,49 +195,58 @@ function expectedDigest(text, assetName) {
 async function verifyOrWarn(archiveBuf, archiveName, checksums) {
   if (!checksums) {
     process.stderr.write(
-      `WARNING: no SHA256SUMS asset found for ${archiveName}; ` +
-        `installing over HTTPS without checksum verification.\n`,
+        `WARNING: no SHA256SUMS asset found for ${archiveName}; ` +
+            `installing over HTTPS without checksum verification.\n`,
     );
     return;
   }
-  const sumsText = (await httpGetBuffer(checksums.browser_download_url)).toString("utf8");
+  const sumsText =
+      (await httpGetBuffer(checksums.browser_download_url)).toString("utf8");
   const expected = expectedDigest(sumsText, archiveName);
   if (!expected) {
     throw new Error(
-      `no checksum entry for ${archiveName} in ${checksums.name} — refusing to install unverified binary`,
+        `no checksum entry for ${archiveName} in ${
+            checksums.name} — refusing to install unverified binary`,
     );
   }
-  const actual = crypto.createHash("sha256").update(archiveBuf).digest("hex").toLowerCase();
+  const actual = crypto.createHash("sha256")
+                     .update(archiveBuf)
+                     .digest("hex")
+                     .toLowerCase();
   if (actual !== expected) {
-    throw new Error(`checksum mismatch for ${archiveName} (expected ${expected}, got ${actual})`);
+    throw new Error(`checksum mismatch for ${archiveName} (expected ${
+        expected}, got ${actual})`);
   }
   process.stderr.write(`Checksum verified for ${archiveName}.\n`);
 }
 
 function isUnsafeEntry(name) {
   const entry = String(name).replace(/\\/g, "/").trim();
-  if (!entry) return false;
-  if (entry.startsWith("/")) return true;
-  if (/^[a-zA-Z]:/.test(entry)) return true;
-  if (entry.startsWith("//")) return true;
+  if (!entry)
+    return false;
+  if (entry.startsWith("/"))
+    return true;
+  if (/^[a-zA-Z]:/.test(entry))
+    return true;
+  if (entry.startsWith("//"))
+    return true;
   return entry.split("/").some((part) => part === "..");
 }
 
 function listTarEntries(archivePath) {
-  const result = spawnSync("tar", ["-tzf", archivePath]);
+  const result = spawnSync("tar", [ "-tzf", archivePath ]);
   if (result.status !== 0) {
     const stderr = result.stderr ? result.stderr.toString() : "";
     throw new Error(`tar listing failed: ${stderr || result.error}`);
   }
-  return result.stdout
-    .toString()
-    .split(/\r?\n/)
-    .map((s) => s.trim())
-    .filter(Boolean);
+  return result.stdout.toString()
+      .split(/\r?\n/)
+      .map((s) => s.trim())
+      .filter(Boolean);
 }
 
 function extractTarGz(archivePath, destDir) {
-  const result = spawnSync("tar", ["-xzf", archivePath, "-C", destDir]);
+  const result = spawnSync("tar", [ "-xzf", archivePath, "-C", destDir ]);
   if (result.status !== 0) {
     const stderr = result.stderr ? result.stderr.toString() : "";
     throw new Error(`tar extraction failed: ${stderr || result.error}`);
@@ -225,28 +256,26 @@ function extractTarGz(archivePath, destDir) {
 function listZipEntries(archivePath) {
   if (os.type() === "Windows_NT") {
     const script =
-      "$ErrorActionPreference='Stop';" +
-      "Add-Type -AssemblyName System.IO.Compression.FileSystem;" +
-      "[System.IO.Compression.ZipFile]::OpenRead($args[0]).Entries |" +
-      " ForEach-Object { $_.FullName }";
-    const out = execFileSync("powershell", ["-NoProfile", "-NonInteractive", "-Command", script, archivePath], {
-      encoding: "utf8",
-    });
-    return out
-      .split(/\r?\n/)
-      .map((s) => s.trim())
-      .filter(Boolean);
+        "$ErrorActionPreference='Stop';" +
+        "Add-Type -AssemblyName System.IO.Compression.FileSystem;" +
+        "[System.IO.Compression.ZipFile]::OpenRead($args[0]).Entries |" +
+        " ForEach-Object { $_.FullName }";
+    const out = execFileSync(
+        "powershell",
+        [ "-NoProfile", "-NonInteractive", "-Command", script, archivePath ], {
+          encoding : "utf8",
+        });
+    return out.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
   }
-  const result = spawnSync("unzip", ["-Z1", archivePath]);
+  const result = spawnSync("unzip", [ "-Z1", archivePath ]);
   if (result.status !== 0) {
     const stderr = result.stderr ? result.stderr.toString() : "";
     throw new Error(`zip listing failed: ${stderr || result.error}`);
   }
-  return result.stdout
-    .toString()
-    .split(/\r?\n/)
-    .map((s) => s.trim())
-    .filter(Boolean);
+  return result.stdout.toString()
+      .split(/\r?\n/)
+      .map((s) => s.trim())
+      .filter(Boolean);
 }
 
 function extractZip(archivePath, destDir) {
@@ -268,7 +297,7 @@ function extractZip(archivePath, destDir) {
     }
     return;
   }
-  const result = spawnSync("unzip", ["-o", archivePath, "-d", destDir]);
+  const result = spawnSync("unzip", [ "-o", archivePath, "-d", destDir ]);
   if (result.status !== 0) {
     const stderr = result.stderr ? result.stderr.toString() : "";
     throw new Error(`zip extraction failed: ${stderr || result.error}`);
@@ -276,11 +305,12 @@ function extractZip(archivePath, destDir) {
 }
 
 function findBinary(dir, name) {
-  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs.readdirSync(dir, {withFileTypes : true})) {
     const full = path.join(dir, entry.name);
     if (entry.isDirectory()) {
       const found = findBinary(full, name);
-      if (found) return found;
+      if (found)
+        return found;
     } else if (entry.name === name) {
       return full;
     }
@@ -289,18 +319,22 @@ function findBinary(dir, name) {
 }
 
 function findDir(dir, name) {
-  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    if (entry.name === name) return path.join(dir, entry.name);
+  for (const entry of fs.readdirSync(dir, {withFileTypes : true})) {
+    if (!entry.isDirectory())
+      continue;
+    if (entry.name === name)
+      return path.join(dir, entry.name);
     const found = findDir(path.join(dir, entry.name), name);
-    if (found) return found;
+    if (found)
+      return found;
   }
   return null;
 }
 
 function safeExtract(archivePath, archiveName, dest) {
   const isZip = archiveName.toLowerCase().endsWith(".zip");
-  const entries = isZip ? listZipEntries(archivePath) : listTarEntries(archivePath);
+  const entries =
+      isZip ? listZipEntries(archivePath) : listTarEntries(archivePath);
   for (const entry of entries) {
     if (isUnsafeEntry(entry)) {
       throw new Error(`refusing unsafe archive entry: ${entry}`);
@@ -318,18 +352,19 @@ function safeExtract(archivePath, archiveName, dest) {
     const binName = binaryName();
     const extractedBin = findBinary(tmpDir, binName);
     if (!extractedBin) {
-      throw new CliUnavailableError(`archive ${archiveName} did not contain expected CLI binary ${binName}`);
+      throw new CliUnavailableError(`archive ${
+          archiveName} did not contain expected CLI binary ${binName}`);
     }
     const finalBin = path.join(dest, binName);
     fs.copyFileSync(extractedBin, finalBin);
 
     const libDir = findDir(tmpDir, "lib");
     if (libDir) {
-      fs.cpSync(libDir, path.join(dest, "lib"), { recursive: true });
+      fs.cpSync(libDir, path.join(dest, "lib"), {recursive : true});
     }
     return finalBin;
   } finally {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
+    fs.rmSync(tmpDir, {recursive : true, force : true});
   }
 }
 
@@ -341,14 +376,17 @@ export async function main() {
       const stat = fs.statSync(finalPath);
       const sizeOk = stat.size > 0;
       const execOk = os.type() === "Windows_NT" || (stat.mode & 0o111) !== 0;
-      if (sizeOk && execOk) return;
-    } catch {}
+      if (sizeOk && execOk)
+        return;
+    } catch {
+    }
   }
 
-  fs.mkdirSync(BIN_DIR, { recursive: true });
+  fs.mkdirSync(BIN_DIR, {recursive : true});
 
-  const { tag, archive, checksums } = await resolveRelease();
-  process.stderr.write(`Downloading ${BIN_NAME} ${tag} asset ${archive.name}...\n`);
+  const {tag, archive, checksums} = await resolveRelease();
+  process.stderr.write(
+      `Downloading ${BIN_NAME} ${tag} asset ${archive.name}...\n`);
 
   const archiveBuf = await httpGetBuffer(archive.browser_download_url);
   await verifyOrWarn(archiveBuf, archive.name, checksums);
@@ -359,7 +397,7 @@ export async function main() {
     fs.writeFileSync(archivePath, archiveBuf);
     safeExtract(archivePath, archive.name, BIN_DIR);
   } finally {
-    fs.rmSync(stageDir, { recursive: true, force: true });
+    fs.rmSync(stageDir, {recursive : true, force : true});
   }
 
   if (os.type() !== "Windows_NT") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xberg-io/liter-llm-cli",
-  "version": "1.11.1",
+  "version": "1.11.2",
   "description": "CLI proxy for liter-llm — downloads and runs the native liter-llm binary from GitHub releases.",
   "license": "MIT",
   "author": "Na'aman Hirschfeld",