turbollm 1.10.0 → 1.10.1

package/dist/cli.js

@@ -34,9 +34,9 @@ function hideChildConsoleWindows() {
 
 // src/cli.ts
 import { spawn as spawn10 } from "child_process";
-import { openSync as openSync3, readFileSync as readFileSync19 } from "fs";
+import { openSync as openSync3, readFileSync as readFileSync20 } from "fs";
 import { serve } from "@hono/node-server";
-import { dirname as dirname12, join as join36 } from "path";
+import { dirname as dirname12, join as join37 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/config/config.ts
@@ -3348,6 +3348,95 @@ function isStaleCapabilities(flags) {
   return false;
 }
 
+// src/telemetry/classify.ts
+var OOM_SIGNS = [
+  "out of memory",
+  "outofmemory",
+  "failed to allocate",
+  "alloc_buffer",
+  "memory allocation of size",
+  "cudamalloc",
+  "insufficient memory",
+  "not enough memory",
+  "unable to allocate",
+  "bad_alloc",
+  "out of vram",
+  "vram allocation failed",
+  "cuda_error_out_of_memory",
+  "resource_exhausted"
+];
+var ARCH_SIGNS = [
+  "unknown model architecture",
+  "unsupported model architecture",
+  "unsupported architecture",
+  "architecture not supported",
+  "unknown architecture"
+];
+var GGUF_SIGNS = [
+  "invalid magic",
+  "error loading model",
+  "failed to load model",
+  "gguf_init",
+  "corrupt",
+  "unexpected end of file",
+  "unexpectedly reached end of file",
+  "truncated",
+  "failed to read tensor",
+  "wrong number of tensors",
+  "tensor not found"
+];
+function classifyLoadFailure(err8) {
+  if (!err8) return "other";
+  if (err8.code === "readiness_timeout") return "timeout";
+  if (err8.code === "engine_unsupported") return "no_engine";
+  const haystack = [err8.message ?? "", ...err8.logTail ?? []].join("\n").toLowerCase();
+  if (haystack.includes("no_active_engine")) return "no_engine";
+  if (haystack.includes("no_such_model")) return "bad_gguf";
+  if (OOM_SIGNS.some((s) => haystack.includes(s))) return "oom";
+  if (ARCH_SIGNS.some((s) => haystack.includes(s))) return "unsupported_arch";
+  if (GGUF_SIGNS.some((s) => haystack.includes(s))) return "bad_gguf";
+  return "other";
+}
+function classifyBenchFailure(results) {
+  if (results.some((r) => r.outcome === "oom")) return "oom";
+  if (results.some((r) => r.outcome === "timeout")) return "timeout";
+  return "other";
+}
+function classifyEngineErrorFingerprint(err8) {
+  if (!err8) return "other";
+  if (err8.code === "readiness_timeout") return "engine_start_timeout";
+  if (err8.code === "model_load_failed") return "model_load_failed";
+  const haystack = [err8.message ?? "", ...err8.logTail ?? []].join("\n").toLowerCase();
+  if (OOM_SIGNS.some((s) => haystack.includes(s))) return "cuda_oom";
+  if (ARCH_SIGNS.some((s) => haystack.includes(s))) return "model_load_failed";
+  if (GGUF_SIGNS.some((s) => haystack.includes(s))) return "model_load_failed";
+  if (err8.code === "engine_exited" || err8.code === "engine_spawn_failed") return "engine_crash";
+  return "other";
+}
+var NETWORK_SIGNS = [
+  "enotfound",
+  "econnreset",
+  "econnrefused",
+  "etimedout",
+  "fetch failed",
+  "network",
+  "check your connection"
+];
+var NO_ASSET_SIGNS = ["404", "no downloadable binary", "no release asset", "not found in"];
+var UNSUPPORTED_PLATFORM_SIGNS = ["no prebuilt binary for this operating system", "unsupported platform", "unsupported architecture"];
+var DISK_FULL_SIGNS = ["enospc", "no space left"];
+var PERMISSION_SIGNS = ["eacces", "eperm", "permission denied", "access is denied"];
+function classifyProvisionFailure(message) {
+  if (!message) return "other";
+  const haystack = message.toLowerCase();
+  if (UNSUPPORTED_PLATFORM_SIGNS.some((s) => haystack.includes(s))) return "unsupported_platform";
+  if (NO_ASSET_SIGNS.some((s) => haystack.includes(s))) return "no_asset";
+  if (DISK_FULL_SIGNS.some((s) => haystack.includes(s))) return "disk_full";
+  if (PERMISSION_SIGNS.some((s) => haystack.includes(s))) return "permission_denied";
+  if (NETWORK_SIGNS.some((s) => haystack.includes(s))) return "network";
+  return "other";
+}
+
 // src/engines/provision-state.ts
 var ProvisionState = class {
   s = { active: false, phase: "idle", backend: "", pct: 0, part: 1, parts: 1, error: null };
@@ -3365,8 +3454,9 @@ var ProvisionState = class {
     this.s.parts = parts;
   }
   /** Optional observer for the terminal outcome, wired in cli.ts (ADR-299
-   *  `onboarding_step`). The error string is deliberately not passed — the only
-   *  consumer may never transmit free text. */
+   *  `onboarding_step`). The raw error STRING is deliberately never passed —
+   *  only `failReason`, a `classifyProvisionFailure` enum member, so the only
+   *  consumer still never sees free text even though it now learns *why*. */
   onSettled;
   done() {
     this.s = { active: false, phase: "idle", backend: "", pct: 0, part: 1, parts: 1, error: null };
@@ -3374,11 +3464,11 @@ var ProvisionState = class {
   }
   fail(error) {
     this.s = { active: false, phase: "error", backend: this.s.backend, pct: 0, part: 1, parts: 1, error };
-    this.settle(false);
+    this.settle(false, classifyProvisionFailure(error));
   }
-  settle(ok) {
+  settle(ok, failReason) {
     try {
-      this.onSettled?.(ok);
+      this.onSettled?.(ok, failReason);
     } catch {
     }
   }
@@ -3411,21 +3501,31 @@ var BuildState = class {
     if (this.s.log.length > LOG_TAIL) this.s.log.splice(0, this.s.log.length - LOG_TAIL);
   }
   /** Optional observer for the terminal outcome, wired in cli.ts (ADR-299
-   *  `onboarding_step`). A plain callback so this module keeps no telemetry
-   *  dependency; the error STRING is deliberately not passed, because the only
-   *  consumer may never send free text. */
+   *  `onboarding_step` / ADR-327 `error`). A plain callback so this module keeps
+   *  no telemetry dependency; the error STRING is deliberately never passed,
+   *  because the only consumer may never send free text. Three outcomes, not
+   *  two — `cancelled` is distinct from `fail` (PR #105 review finding): a
+   *  build the user deliberately aborted must not be reported as a crash. */
   onSettled;
   done() {
     this.s = { ...this.s, active: false, phase: "done", error: null };
-    this.settle(true);
+    this.settle("ok");
   }
   fail(error) {
     this.s = { ...this.s, active: false, phase: "error", error };
-    this.settle(false);
+    this.settle("fail");
   }
-  settle(ok) {
+  /** A deliberate user cancellation. Same terminal UI shape as `fail()` (phase
+   *  'error', so the UI still shows the run ended and why) — only the observer
+   *  outcome differs. A cancel is a choice, not a failure, and must not be
+   *  reported as one. */
+  cancel(message) {
+    this.s = { ...this.s, active: false, phase: "error", error: message };
+    this.settle("cancelled");
+  }
+  settle(outcome) {
     try {
-      this.onSettled?.(ok);
+      this.onSettled?.(outcome);
     } catch {
     }
   }
@@ -15142,6 +15242,14 @@ var FAIL_REASONS = [
   "cancelled",
   "other"
 ];
+var PROVISION_FAIL_REASONS = [
+  "network",
+  "no_asset",
+  "unsupported_platform",
+  "disk_full",
+  "permission_denied",
+  "other"
+];
 var COUNT_BUCKETS = ["1", "2-5", "6-20", "21-100", "100+"];
 var ERROR_FINGERPRINTS = [
   "cuda_oom",
@@ -15197,7 +15305,14 @@ var HW_SPEC = {
   ramMb: { kind: "number" }
 };
 var PAYLOAD_SPECS = {
-  onboarding_step: { step: { enum: ONBOARDING_STEPS }, outcome: { enum: OUTCOMES } },
+  // `failReason` is optional and, today, only ever sent for `step: 'engine_install'`
+  // (classified by `classifyProvisionFailure`, PROVISION_FAIL_REASONS) — mirrors
+  // `model_first_load.failReason`'s own "optional, only present on a real failure"
+  // shape. Not step-conditional at the schema level (this validator is flat per
+  // event name, not per payload value) — enforced by convention at the one call
+  // site that sends it (cli.ts's `provision.onSettled`), same as elsewhere in this
+  // file's payload specs.
+  onboarding_step: { step: { enum: ONBOARDING_STEPS }, outcome: { enum: OUTCOMES }, failReason: { enum: PROVISION_FAIL_REASONS, optional: true } },
   model_first_load: { outcome: { enum: OUTCOMES }, failReason: { enum: FAIL_REASONS, optional: true } },
   feature_first_use: { feature: { enum: FEATURES } },
   feature_used_daily: { feature: { enum: FEATURES }, countBucket: { enum: COUNT_BUCKETS } },
@@ -15379,36 +15494,6 @@ function reportModelLoad(dataDir, emitter, outcome, failReason) {
   }
 }
 
-// src/telemetry/classify.ts
-var OOM_SIGNS = [
-  "out of memory",
-  "outofmemory",
-  "failed to allocate",
-  "alloc_buffer",
-  "memory allocation of size",
-  "cudamalloc",
-  "insufficient memory"
-];
-var ARCH_SIGNS = ["unknown model architecture", "unsupported model architecture", "unsupported architecture"];
-var GGUF_SIGNS = ["invalid magic", "error loading model", "failed to load model", "gguf_init", "corrupt"];
-function classifyLoadFailure(err8) {
-  if (!err8) return "other";
-  if (err8.code === "readiness_timeout") return "timeout";
-  if (err8.code === "engine_unsupported") return "no_engine";
-  const haystack = [err8.message ?? "", ...err8.logTail ?? []].join("\n").toLowerCase();
-  if (haystack.includes("no_active_engine")) return "no_engine";
-  if (haystack.includes("no_such_model")) return "bad_gguf";
-  if (OOM_SIGNS.some((s) => haystack.includes(s))) return "oom";
-  if (ARCH_SIGNS.some((s) => haystack.includes(s))) return "unsupported_arch";
-  if (GGUF_SIGNS.some((s) => haystack.includes(s))) return "bad_gguf";
-  return "other";
-}
-function classifyBenchFailure(results) {
-  if (results.some((r) => r.outcome === "oom")) return "oom";
-  if (results.some((r) => r.outcome === "timeout")) return "timeout";
-  return "other";
-}
-
 // src/telemetry/disabled.ts
 var TELEMETRY_ENV = "TURBOLLM_TELEMETRY";
 var OFF_VALUES = /* @__PURE__ */ new Set(["off", "0", "false", "no"]);
@@ -15618,6 +15703,9 @@ var BenchRunner = class {
       this.telemetry.emit("onboarding_step", { step: "first_load", outcome });
     }
     reportModelLoad(this.store.dir(), this.telemetry, outcome, failReason);
+    if (outcome === "fail") {
+      this.telemetry.error(failReason === "oom" ? "cuda_oom" : failReason === "timeout" ? "engine_start_timeout" : "other");
+    }
   }
   /** Stop the engine — force-killed immediately when the run is cancelled (the user is actively
    *  waiting for it to stop, ADR-220), gracefully otherwise (lets llama-server release resources
@@ -20296,7 +20384,7 @@ function registerApi(app2, d) {
           }
           if (e?.name === "AbortError") {
             d.build.log("Build cancelled.");
-            d.build.fail("Build cancelled.");
+            d.build.cancel("Build cancelled.");
           } else {
             const asmIssue = d.build.get().log.some((l) => /No CMAKE_ASM_COMPILER could be found|ASM compiler identification is unknown/i.test(l));
             const raw = e instanceof Error ? e.message : String(e);
@@ -20371,7 +20459,7 @@ function registerApi(app2, d) {
       } catch (e) {
         if (e?.name === "AbortError") {
           d.build.log("CUDA download cancelled.");
-          d.build.fail("CUDA download cancelled.");
+          d.build.cancel("CUDA download cancelled.");
         } else {
           d.build.fail(`Could not download CUDA: ${e instanceof Error ? e.message : String(e)}`);
         }
@@ -24226,7 +24314,15 @@ async function recordOpenAiStreamUsage(d, body8, source, modelKey, codeSessionId
 
 // src/telemetry/feature-map.ts
 var BY_SEGMENT = {
+  // `chat` (bare) only covers `/api/v1/chat/stop` — the Stop-generation button. Real
+  // chat traffic (sending a message, creating/loading a conversation) lives under
+  // `/api/v1/conversations/*` instead (PR #105 review finding: `chat` alone was
+  // silently under-counting the product's own core feature). `conversations` IS the
+  // chat feature's own primary data endpoint, not a foreign feature fetched as a side
+  // effect the way `/api/v1/skills`/`/api/v1/chat-agents` are (see the comment below) —
+  // so, unlike those two, mapping it here doesn't risk corrupting an unrelated signal.
   chat: "chat",
+  conversations: "chat",
   code: "code",
   artifacts: "artifacts",
   mcp: "mcp",
@@ -24272,7 +24368,10 @@ function createApp(d) {
   app2.use("/api/v1/code/*", codeAuth(d));
   app2.use("*", async (c, next) => {
     const feature = d.telemetry ? featureForPath(c.req.path) : null;
-    if (feature !== null) d.telemetry?.firstUse(feature);
+    if (feature !== null) {
+      d.telemetry?.firstUse(feature);
+      d.telemetry?.useFeature(feature);
+    }
     await next();
   });
   app2.get("/healthz", (c) => c.json({ status: "ok", version: d.version }));
@@ -24578,6 +24677,89 @@ var TunnelManager = class {
 
 // src/telemetry/emit.ts
 import { randomUUID as randomUUID14 } from "crypto";
+
+// src/telemetry/daily-usage.ts
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync17, mkdirSync as mkdirSync19 } from "fs";
+import { join as join36 } from "path";
+var cache = /* @__PURE__ */ new Map();
+function usagePath(dataDir) {
+  return join36(dataDir, "telemetry", "daily-usage.json");
+}
+function readFromDisk(dataDir) {
+  try {
+    const parsed = JSON.parse(readFileSync19(usagePath(dataDir), "utf8"));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+function writeToDisk(dataDir, usage) {
+  mkdirSync19(join36(dataDir, "telemetry"), { recursive: true });
+  writeFileSync17(usagePath(dataDir), JSON.stringify(usage));
+}
+function loadCache(dataDir) {
+  let usage = cache.get(dataDir);
+  if (usage === void 0) {
+    usage = readFromDisk(dataDir);
+    cache.set(dataDir, usage);
+  }
+  return usage;
+}
+function bucketCount(n) {
+  if (n <= 1) return "1";
+  if (n <= 5) return "2-5";
+  if (n <= 20) return "6-20";
+  if (n <= 100) return "21-100";
+  return "100+";
+}
+function recordFeatureUse(dataDir, feature, today) {
+  try {
+    const usage = loadCache(dataDir);
+    const existing = usage[feature];
+    if (existing === void 0) {
+      usage[feature] = { day: today, count: 1 };
+      return null;
+    }
+    if (existing.day === today) {
+      usage[feature] = { day: today, count: existing.count + 1 };
+      return null;
+    }
+    const rolled = { day: existing.day, bucket: bucketCount(existing.count) };
+    usage[feature] = { day: today, count: 1 };
+    writeToDisk(dataDir, usage);
+    return rolled;
+  } catch {
+    return null;
+  }
+}
+function flushStaleDailyUsage(dataDir, today) {
+  try {
+    const usage = loadCache(dataDir);
+    const rolled = [];
+    let changed = false;
+    for (const [feature, entry] of Object.entries(usage)) {
+      if (entry.day === today) continue;
+      rolled.push({ feature, day: entry.day, bucket: bucketCount(entry.count) });
+      delete usage[feature];
+      changed = true;
+    }
+    if (changed) writeToDisk(dataDir, usage);
+    return rolled;
+  } catch {
+    return [];
+  }
+}
+function persistDailyUsage(dataDir) {
+  try {
+    const usage = cache.get(dataDir);
+    if (usage === void 0) return;
+    writeToDisk(dataDir, usage);
+  } catch {
+  }
+}
+
+// src/telemetry/emit.ts
 var REQUIRES_FULL = /* @__PURE__ */ new Set(["error"]);
 var Emitter = class {
   o;
@@ -24634,6 +24816,45 @@ var Emitter = class {
     if (!this.canSend("daily_active")) return;
     if (this.claim(`daily:${this.today()}`)) this.emit("daily_active");
   }
+  /**
+   * Count one use of `feature` toward today's tally, emitting a bucketed
+   * `feature_used_daily` for the previous day the moment the calendar day
+   * rolls over. Consent is checked BEFORE any count is recorded — same
+   * reasoning as `firstUse` above (see its doc comment): usage while
+   * telemetry is off must never silently contribute to a count reported
+   * after the user opts in later.
+   */
+  useFeature(feature) {
+    if (!this.canSend("feature_used_daily")) return;
+    const rolled = recordFeatureUse(this.o.dataDir, feature, this.today());
+    if (rolled) this.emit("feature_used_daily", { feature, countBucket: rolled.bucket });
+  }
+  /**
+   * Roll over any feature whose tally is from a day earlier than today, then
+   * persist whatever's left (today's still-in-progress counts) to disk.
+   * Called periodically (cli.ts, alongside the queue flush) for two reasons:
+   * a feature used only on a user's LAST active day still gets reported
+   * instead of waiting indefinitely for a next use that may never come, AND
+   * same-day counts — which `useFeature` only ever keeps in memory, to avoid
+   * a disk write on every matching API request — get a chance to survive a
+   * crash instead of living only until the next rollover.
+   */
+  flushDailyUsage() {
+    if (!this.canSend("feature_used_daily")) return;
+    for (const { feature, bucket } of flushStaleDailyUsage(this.o.dataDir, this.today())) {
+      this.emit("feature_used_daily", { feature, countBucket: bucket });
+    }
+    persistDailyUsage(this.o.dataDir);
+  }
+  /**
+   * Emit `error` — full level only (`REQUIRES_FULL` above), and deliberately
+   * NOT once-only: unlike `model_first_load`'s single most-valuable-attempt
+   * signal, every crash after the first is still a real data point (ADR-299's
+   * "what is failing?" journey question, previously never wired to anything).
+   */
+  error(fingerprint) {
+    this.emit("error", { fingerprint });
+  }
   /**
    * Mint the anonymous machine id lazily.
    *
@@ -24662,8 +24883,8 @@ var Emitter = class {
 hideChildConsoleWindows();
 var version = "0.1.1";
 try {
-  const pkgPath = join36(dirname12(fileURLToPath2(import.meta.url)), "..", "package.json");
-  version = JSON.parse(readFileSync19(pkgPath, "utf8")).version ?? version;
+  const pkgPath = join37(dirname12(fileURLToPath2(import.meta.url)), "..", "package.json");
+  version = JSON.parse(readFileSync20(pkgPath, "utf8")).version ?? version;
 } catch {
 }
 var [nodeMajor, nodeMinor] = process.versions.node.split(".").map(Number);
@@ -24691,7 +24912,7 @@ function argValue(name, fallback) {
 if (hasFlag("--no-telemetry")) process.env[TELEMETRY_ENV] = "off";
 function configuredDaemonPort(configPath) {
   try {
-    const cfg2 = JSON.parse(readFileSync19(configPath, "utf8"));
+    const cfg2 = JSON.parse(readFileSync20(configPath, "utf8"));
     if (typeof cfg2.daemon?.port === "number" && cfg2.daemon.port > 0) return cfg2.daemon.port;
   } catch {
   }
@@ -24816,7 +25037,7 @@ if (pruned > 0) console.log(`pruned ${pruned} dangling engine build(s)`);
 var provision = new ProvisionState();
 var build = new BuildState();
 var updates = new UpdateChecker();
-var enginesDir = join36(store.dir(), "engines");
+var enginesDir = join37(store.dir(), "engines");
 void seedDefaultEngines(registry, enginesDir, provision).then(() => registry.ensureProbed());
 var manager = new Manager(store);
 var scanner = new Scanner(store);
@@ -24871,15 +25092,23 @@ manager.onLoadSettled = (ok, err8) => {
     telemetry.emit("onboarding_step", { step: "first_load", outcome });
   }
   reportModelLoad(store.dir(), telemetry, outcome, ok ? void 0 : classifyLoadFailure(err8));
+  if (!ok) telemetry.error(classifyEngineErrorFingerprint(err8));
 };
 bench.telemetry = telemetry;
-provision.onSettled = (ok) => telemetry.emit("onboarding_step", { step: "engine_install", outcome: ok ? "ok" : "fail" });
-downloads.onSettled = (outcome) => telemetry.emit("onboarding_step", { step: "model_download", outcome });
+provision.onSettled = (ok, failReason) => telemetry.emit("onboarding_step", { step: "engine_install", outcome: ok ? "ok" : "fail", ...failReason ? { failReason } : {} });
+downloads.onSettled = (outcome) => {
+  telemetry.emit("onboarding_step", { step: "model_download", outcome });
+  if (outcome === "fail") telemetry.error("download_failed");
+};
+build.onSettled = (outcome) => {
+  if (outcome === "fail") telemetry.error("build_failed");
+};
 setTimeout(() => {
   telemetry.once("app_first_run");
   void flush(store.dir(), store.snapshot().telemetry.level);
 }, 3e3).unref();
 setInterval(() => void flush(store.dir(), store.snapshot().telemetry.level), 5 * 6e4).unref();
+setInterval(() => telemetry.flushDailyUsage(), 5 * 6e4).unref();
 var tunnelRequested = hasFlag("--tunnel");
 if (tunnelRequested) deps.tunnel = new TunnelManager(store.dir());
 deps.codeRuns = new CodeRunManager(deps);
@@ -25049,7 +25278,7 @@ var restarting = false;
 function spawnReplacement() {
   let out = "ignore";
   try {
-    out = openSync3(join36(store.dir(), "restart.log"), "a");
+    out = openSync3(join37(store.dir(), "restart.log"), "a");
   } catch {
     out = "ignore";
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turbollm",
-  "version": "1.10.0",
+  "version": "1.10.1",
   "description": "TurboLLM — local LLM platform: run any inference engine auto-tuned to your GPU, with a web UI and OpenAI/Anthropic-compatible API. Point Claude Code at your own machine in one command.",
   "license": "FSL-1.1-ALv2",
   "author": "Mohit Soni",