turbollm 1.12.3 → 1.12.5

package/README.md

@@ -507,6 +507,10 @@ above.
 llama.cpp-compatible fork's git URL (+ optional branch, defaults to the repo's own default) and
 build it in-app with the same 1-click flow, no separate "point at a folder" step needed.
 
+Branch pickers and engine update checks both read GitHub's API, which allows 60 anonymous
+requests an hour. If you run into that ceiling, add a **GitHub token** in Settings → Models &
+loading to raise it to 5,000/hour — it is write-only and never leaves your machine.
+
 **Auto-provisioned default.** Don't want to fetch anything? On first run TurboLLM downloads
 the right upstream prebuilt for your GPU automatically — and a **backend picker** lets you
 switch between CUDA / ROCm / Metal / SYCL / Vulkan / CPU at any time (it downloads the variant
@@ -624,7 +628,8 @@ Use `--config <file>` to point at an alternate config (its directory becomes the
 
   </details>
 
-- **Windows, macOS, or Linux.**
+- **Windows, macOS, or Linux** for `npx turbollm`. A native **Android app** also exists, with a
+  bundled Vulkan-accelerated engine — currently in closed/open testing, see turbollm.dev.
 - A GPU is recommended but **not required** — a CPU build is provisioned as a fallback.
 - On Windows, the first time the auto-downloaded `llama-server` runs, SmartScreen/Defender may
   prompt (it's an upstream binary). Allow it once.

package/dist/android-preload.cjs

@@ -0,0 +1,35 @@
+// TurboLLM Android's `--require` preload for the embedded (nodejs-mobile) Node 18.20.4
+// runtime (see NodeRuntimeLauncher.android.kt's startScript, which passes this via
+// `--require` BEFORE the entry script path).
+//
+// Why a --require preload and not a normal import/require inside cli.ts: confirmed live that
+// a plain top-level ESM import at the very top of cli.ts's own source does NOT reliably run
+// before every other module in its import graph. Node's ESM linker executes CommonJS
+// dependencies' top-level code as part of resolving their NAMED EXPORTS during the LINK
+// phase, which covers the whole import graph before ANY module (including the entry module's
+// own body) reaches evaluation — so "first import in the source" does not mean "runs first".
+// A `--require` preload runs via Node's own CLI bootstrap strictly before it even begins
+// loading the entry module, which is the only mechanism confirmed to reliably beat that phase.
+//
+// The actual bug this works around: this embedded Node build does not expose the WHATWG
+// `File` global that `undici` (an npm dependency, used transitively for fetch) reads at its
+// own module-load time (`node_modules/undici/lib/web/webidl/index.js` does
+// `webidl.is.File = webidl.util.MakeTypeAssertion(File)`), which throws
+// `ReferenceError: File is not defined` and crashes the whole daemon before any of its own
+// code runs. Desktop Node exposes `File` as a global; this build's own `node:buffer` module
+// does NOT re-export `File` either (confirmed live — re-exporting it as the global had zero
+// effect), so this builds a minimal polyfill on `Blob` instead, which is stable since Node 15
+// and far more likely to have survived a size-stripped mobile build.
+'use strict'
+
+if (typeof globalThis.File === 'undefined') {
+  const { Blob } = require('node:buffer')
+  class PolyfillFile extends Blob {
+    constructor(fileBits, fileName, options = {}) {
+      super(fileBits, options)
+      this.name = fileName
+      this.lastModified = options.lastModified ?? Date.now()
+    }
+  }
+  globalThis.File = PolyfillFile
+}

package/dist/chunk-5HBNOSJB.js

@@ -0,0 +1,46 @@
+// src/util/resolve-executable.ts
+import { accessSync, constants, statSync } from "fs";
+import { delimiter, extname, isAbsolute, join } from "path";
+var SHIM_EXTENSIONS = /* @__PURE__ */ new Set([".cmd", ".bat"]);
+function isFile(p) {
+  try {
+    return statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function isExecutableFile(p) {
+  if (!isFile(p)) return false;
+  if (process.platform === "win32") return true;
+  try {
+    accessSync(p, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveExecutable(command, env = process.env, platform = process.platform) {
+  if (!command) return null;
+  const win32 = platform === "win32";
+  const exts = win32 ? (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean).map((e) => e.toLowerCase()) : [""];
+  const candidates = (base) => extname(base) ? [base] : win32 ? exts.map((e) => base + e) : [base];
+  if (isAbsolute(command) || command.startsWith("./") || command.startsWith(".\\")) {
+    return candidates(command).find(isExecutableFile) ?? null;
+  }
+  for (const dir of (env.PATH ?? env.Path ?? "").split(delimiter).filter(Boolean)) {
+    const clean = dir.replace(/^"|"$/g, "");
+    const hit = candidates(join(clean, command)).find(isExecutableFile);
+    if (hit) return hit;
+  }
+  return null;
+}
+function requiresShell(resolvedPath, platform = process.platform) {
+  if (!resolvedPath) return true;
+  if (platform !== "win32") return false;
+  return SHIM_EXTENSIONS.has(extname(resolvedPath).toLowerCase());
+}
+
+export {
+  resolveExecutable,
+  requiresShell
+};