@xberg-io/liter-llm-cli 1.16.0 → 1.18.0

package/bin/liter-llm.js

@@ -5,8 +5,8 @@
 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";
 
@@ -24,10 +24,8 @@ const binPath = path.join(__dirname, binaryName());
 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;
@@ -35,22 +33,20 @@ 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`);
+  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");
+  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`,
   );
 }
 
@@ -60,10 +56,9 @@ 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);

package/install.js

@@ -1,10 +1,10 @@
-import {execFileSync, spawnSync} from "node:child_process";
+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 {fileURLToPath, pathToFileURL} from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 
 const REPO = "xberg-io/liter-llm";
 const BIN_NAME = "liter-llm";
@@ -17,22 +17,17 @@ 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}`);
@@ -42,35 +37,30 @@ 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();
@@ -80,8 +70,7 @@ 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"));
 }
 
@@ -117,24 +106,19 @@ 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];
 }
@@ -143,16 +127,15 @@ 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;
   }
@@ -160,18 +143,16 @@ 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));
@@ -180,14 +161,11 @@ 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;
 }
@@ -195,58 +173,49 @@ 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}`);
@@ -256,26 +225,28 @@ 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) {
@@ -297,7 +268,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}`);
@@ -305,12 +276,11 @@ 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;
     }
@@ -319,22 +289,18 @@ 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}`);
@@ -352,19 +318,18 @@ 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 });
   }
 }
 
@@ -376,17 +341,14 @@ 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);
@@ -397,7 +359,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.16.0",
+  "version": "1.18.0",
   "description": "CLI proxy for liter-llm — downloads and runs the native liter-llm binary from GitHub releases.",
   "license": "MIT",
   "author": "Na'aman Hirschfeld",