omnius 1.0.629 → 1.0.633

package/dist/postinstall-daemon.cjs

@@ -38,7 +38,7 @@ var SERVICE_LABEL = "omnius-daemon";
 var LAUNCHD_LABEL = "ai.omnius.daemon";
 var WIN_TASK_NAME = "OmniusDaemon";
 var REQUIRED_AIWG_VERSION = "2026.5.11";
-var INSTALL_STEPS = 7;
+var INSTALL_STEPS = 8;
 var DISCOVERY_NOTICE_PRINTED = false;
 
 // ─── Helpers ────────────────────────────────────────────────────────────────
@@ -99,6 +99,79 @@ function hasCmd(name) {
   return runQuiet("which " + name);
 }
 
+// Advanced OCR on JetPack preserves whichever ABI-matched system Python stack
+// is actually usable, including NVIDIA's libopencv-python provider.
+// Native packages belong to package installation, never to an inference or
+// readiness request. Jammy has no python3-pytesseract candidate, so that one
+// pure-Python package is intentionally handled later by /v1/ocr/setup.
+function ensureJetsonOcrNativeDependencies() {
+  if (!IS_LINUX) return;
+  var jetson = fs.existsSync("/etc/nv_tegra_release") || fs.existsSync("/sys/module/tegra_fuse");
+  if (!jetson) {
+    try {
+      var model = fs.readFileSync("/proc/device-tree/model", "utf8").replace(/\0/g, " ");
+      jetson = /\b(nvidia|jetson|orin|tegra)\b/i.test(model);
+    } catch (e) {}
+  }
+  if (!jetson || !hasCmd("apt-get") || !hasCmd("dpkg-query")) return;
+
+  var systemPython = fs.existsSync("/usr/bin/python3") ? "/usr/bin/python3" : "python3";
+  var dependencies = [
+    { package: "tesseract-ocr", command: "tesseract" },
+    { package: "python3-venv" },
+    { package: "python3-opencv", module: "cv2", providers: ["python3-opencv", "libopencv-python"] },
+    { package: "python3-numpy", module: "numpy" },
+    { package: "python3-pil", module: "PIL" },
+    { package: "python3-reportlab", module: "reportlab" },
+  ];
+  var missing = dependencies.filter(function (dependency) {
+    // Successful imports with user-site disabled are authoritative. This
+    // avoids replacing NVIDIA OpenCV 4.8 with Ubuntu's generic OpenCV 4.5 just
+    // because the provider package has a different dpkg name.
+    if (dependency.command && hasCmd(dependency.command)) return false;
+    if (dependency.module && runQuiet(
+      "PYTHONNOUSERSITE=1 " + shellQuote(systemPython) + " -c " + shellQuote("import " + dependency.module),
+    )) return false;
+    return !(dependency.providers || [dependency.package]).some(function (provider) {
+      return runQuiet("dpkg-query -W -f='${Status}' " + shellQuote(provider) + " 2>/dev/null | grep -q 'install ok installed'");
+    });
+  }).map(function (dependency) { return dependency.package; });
+  if (missing.length === 0) {
+    log("Jetson advanced-OCR native dependencies are installed.");
+    return;
+  }
+  var install = "apt-get install -y " + missing.map(shellQuote).join(" ");
+  if (process.getuid && process.getuid() === 0) {
+    log("Provisioning Jetson advanced-OCR native dependencies: " + missing.join(", "));
+    if (!runQuiet(install, { timeout: 300000, env: Object.assign({}, process.env, { DEBIAN_FRONTEND: "noninteractive" }) })) {
+      warn("Jetson OCR native dependency install failed. Run: sudo " + install);
+    }
+    return;
+  }
+  if (hasCmd("sudo") && runQuiet("sudo -n true")) {
+    log("Provisioning Jetson advanced-OCR native dependencies with the install-time sudo authorization: " + missing.join(", "));
+    if (!runQuiet("sudo -n " + install, { timeout: 300000, env: Object.assign({}, process.env, { DEBIAN_FRONTEND: "noninteractive" }) })) {
+      warn("Jetson OCR native dependency install failed. Run: sudo " + install);
+    }
+    return;
+  }
+  if (hasCmd("sudo") && process.stdin.isTTY && process.stdout.isTTY) {
+    log("Jetson advanced OCR needs native Ubuntu packages; requesting elevation during package installation.");
+    try {
+      cp.execSync("sudo " + install, {
+        stdio: "inherit",
+        timeout: 300000,
+        env: Object.assign({}, process.env, { DEBIAN_FRONTEND: "noninteractive" }),
+      });
+      return;
+    } catch (e) {
+      warn("Jetson OCR native dependency install was not authorized. Run: sudo " + install);
+      return;
+    }
+  }
+  warn("Jetson OCR native dependencies are missing; install outside inference: sudo " + install);
+}
+
 function shellQuote(value) {
   if (IS_WIN) return '"' + String(value).replace(/"/g, '\\"') + '"';
   return "'" + String(value).replace(/'/g, "'\\''") + "'";
@@ -924,10 +997,13 @@ function main() {
     warn("wrapper auto-repair crashed (non-fatal): " + (e && e.message));
   }
 
-  progress(3, INSTALL_STEPS, "Ensuring AIWG CLI");
+  progress(3, INSTALL_STEPS, "Provisioning Jetson OCR native dependencies");
+  ensureJetsonOcrNativeDependencies();
+
+  progress(4, INSTALL_STEPS, "Ensuring AIWG CLI");
   ensureGlobalAiwgInstall();
 
-  progress(4, INSTALL_STEPS, "Ensuring local REST key");
+  progress(5, INSTALL_STEPS, "Ensuring local REST key");
   ensureBootstrapApiKeyForUser(effectiveUser());
 
   if (process.env.OMNIUS_UPDATE_COORDINATED === "1") {
@@ -946,7 +1022,7 @@ function main() {
   // restart can't reach it, so we have to clean up explicitly. Without this,
   // the new service-managed daemon fails to bind port 11435 and the user
   // ends up running stale in-memory code from the previous version.
-  progress(5, INSTALL_STEPS, "Clearing daemon port");
+  progress(6, INSTALL_STEPS, "Clearing daemon port");
   stopAttestedDaemonPortHolder(PORT, function (killedCount) {
     if (killedCount > 0) {
       log("Killed " + killedCount + " stale daemon process(es) holding port " + PORT + ".");
@@ -977,7 +1053,7 @@ function runMainAfterKill() {
       // idempotent and ensures the unit file matches the current bundle.
     }
 
-    progress(6, INSTALL_STEPS, "Installing daemon service");
+    progress(7, INSTALL_STEPS, "Installing daemon service");
     log("Installing Omnius API daemon service for port " + PORT + " ...");
     log("  node:       " + nodeBin);
     log("  omnius script:  " + omniusScript);
@@ -1008,7 +1084,7 @@ function runMainAfterKill() {
     }
 
     // Wait up to 15s for /health to come up, but don't fail npm install.
-    progress(7, INSTALL_STEPS, "Verifying daemon health");
+    progress(8, INSTALL_STEPS, "Verifying daemon health");
     waitForHealth(15000, function (healthy) {
       if (healthy) {
         log("Omnius API daemon is live: http://127.0.0.1:" + PORT + "/health");

package/dist/scripts/audio-yamnet-tensorrt-worker.py

@@ -150,6 +150,10 @@ def read_wav(path: str, np):
     if sample_rate != 16000:
         raise RuntimeError(f"Expected 16 kHz WAV from the caller, received {sample_rate} Hz")
     waveform = np.frombuffer(raw, dtype="<i2").astype(np.float32) / 32768.0
+    if waveform.size > 96000:
+        raise RuntimeError(
+            f"Expected at most 6 seconds of caller-conditioned audio, received {waveform.size / sample_rate:.3f} seconds"
+        )
     return waveform, sample_rate, (time.perf_counter() - started) * 1000
 
 
@@ -310,7 +314,18 @@ def main() -> int:
             if not request_id or not file_path:
                 raise RuntimeError("classify requires id and file")
             waveform, sample_rate, decode_ms = read_wav(file_path, worker.np)
-            classifications, inference_ms = worker.infer(waveform, max(1, min(int(request.get("top_k", 5)), 25)))
+            rms = float(worker.np.sqrt(worker.np.mean(worker.np.square(waveform)))) if waveform.size else 0.0
+            peak = float(worker.np.max(worker.np.abs(waveform))) if waveform.size else 0.0
+            # Do not force YAMNet to invent an AudioSet label for digital or
+            # near-digital silence. This remains a valid, grounded result.
+            low_information = rms < 0.0005 and peak < 0.002
+            if low_information:
+                classifications, inference_ms = [], 0.0
+            else:
+                classifications, inference_ms = worker.infer(
+                    waveform,
+                    max(1, min(int(request.get("top_k", 5)), 25)),
+                )
             emit({
                 "type": "result",
                 "id": request_id,
@@ -318,6 +333,8 @@ def main() -> int:
                 "sample_rate_hz": sample_rate,
                 "duration_seconds": round(float(waveform.size) / sample_rate, 6),
                 "classifications": classifications,
+                "low_information": low_information,
+                "acoustic": {"rms": round(rms, 8), "peak": round(peak, 8)},
                 "timings_ms": {"decode": round(decode_ms, 3), "inference": round(inference_ms, 3)},
             })
         except Exception as exc:  # keep the persistent worker alive per request

package/dist/scripts/ocr-advanced.py

@@ -45,7 +45,7 @@ def check_deps():
     try:
         import cv2
     except ImportError:
-        missing.append("opencv-python-headless")
+        missing.append("cv2")
     try:
         import numpy
     except ImportError:
@@ -57,12 +57,12 @@ def check_deps():
     try:
         from PIL import Image
     except ImportError:
-        missing.append("Pillow")
+        missing.append("PIL")
 
     if missing:
         print(json.dumps({
-            "error": f"Missing Python packages: {', '.join(missing)}. "
-                     f"Install with: pip install {' '.join(missing)}",
+            "error": f"OCR runtime imports became unavailable: {', '.join(missing)}. "
+                     "Run POST /v1/ocr/setup and poll GET /v1/ocr/readiness; inference never installs packages.",
             "missing": missing,
         }))
         sys.exit(1)
@@ -179,10 +179,9 @@ def run_tesseract(binary_img, language="eng", psm=6):
     pil_img = Image.fromarray(binary_img)
     config = f"--psm {psm}"
 
-    try:
-        text = pytesseract.image_to_string(pil_img, lang=language, config=config).strip()
-    except Exception:
-        return "", 0.0, 0
+    # Engine failures are not blank documents. Let callers distinguish a real
+    # low-information image from a missing language pack or broken Tesseract.
+    text = pytesseract.image_to_string(pil_img, lang=language, config=config).strip()
 
     line_count = len([l for l in text.split("\n") if l.strip()])
 
@@ -322,6 +321,7 @@ def run_pipeline(image_path, language="eng", do_regions=False, debug_dir=None,
 
     # Generate all variants and run OCR
     all_results = {}
+    ocr_errors = []
     best_key = None
     best_score = -1
 
@@ -338,7 +338,11 @@ def run_pipeline(image_path, language="eng", do_regions=False, debug_dir=None,
 
         for psm in psm_modes:
             key = f"{vname}_psm{psm}"
-            text, confidence, line_count = run_tesseract(binary, language, psm)
+            try:
+                text, confidence, line_count = run_tesseract(binary, language, psm)
+            except Exception as error:
+                ocr_errors.append(f"{key}: {error}")
+                continue
             char_count = len(text)
             score = compute_score(text, confidence, line_count)
 
@@ -355,7 +359,8 @@ def run_pipeline(image_path, language="eng", do_regions=False, debug_dir=None,
                 best_key = key
 
     if not best_key:
-        return {"error": "All OCR variants failed to produce output"}
+        detail = ocr_errors[-1] if ocr_errors else "no preprocessing variant completed"
+        return {"error": f"Tesseract failed for every OCR variant: {detail}"}
 
     best = all_results[best_key]
     result = {
@@ -400,7 +405,10 @@ def run_pipeline(image_path, language="eng", do_regions=False, debug_dir=None,
                 if debug_dir:
                     cv2.imwrite(os.path.join(debug_dir, f"region_{rname}_{vname}.png"), binary)
 
-                text, conf, lc = run_tesseract(binary, language, 6)
+                try:
+                    text, conf, lc = run_tesseract(binary, language, 6)
+                except Exception:
+                    continue
                 score = compute_score(text, conf, lc)
                 if score > region_best_score:
                     region_best_score = score
@@ -531,7 +539,7 @@ def main():
             print(f"Processed {result['images_processed']} images → {result['output_dir']}")
         else:
             print(json.dumps(result, indent=2))
-        sys.exit(0)
+        sys.exit(1 if "error" in result else 0)
 
     # Single image mode
     if not os.path.isfile(args.image):
@@ -565,6 +573,8 @@ def main():
         print(result["text"])
     else:
         print(json.dumps(result, indent=2))
+        if "error" in result:
+            sys.exit(1)
 
 
 if __name__ == "__main__":