omnius 1.0.10 → 1.0.12

package/dist/postinstall-daemon.cjs

@@ -47,6 +47,16 @@ function log(msg) {
 function warn(msg) {
   process.stdout.write("  [daemon] " + msg + "\n");
 }
+function quietInstall() {
+  var level = String(process.env.npm_config_loglevel || "").toLowerCase();
+  return process.env.OMNIUS_QUIET_INSTALL === "1" || level === "silent";
+}
+function progress(step, total, msg) {
+  if (quietInstall()) return;
+  var width = 18;
+  var filled = Math.max(0, Math.min(width, Math.round((step / total) * width)));
+  process.stdout.write("  [" + "#".repeat(filled) + ".".repeat(width - filled) + "] " + step + "/" + total + " " + msg + "\n");
+}
 
 function runQuiet(cmd, opts) {
   try {
@@ -669,10 +679,12 @@ function repairBrokenWrappers() {
 
 function main() {
   // Always do the nexus cleanup first, regardless of opt-out.
+  progress(1, 5, "Cleaning stale Nexus runtime state");
   cleanNexus();
 
   // Auto-repair stale Omnius model wrappers BEFORE restarting the daemon, so the
   // freshly-restarted daemon picks up the rebuilt models on first inference.
+  progress(2, 5, "Checking local model wrappers");
   try { repairBrokenWrappers(); } catch (e) {
     warn("wrapper auto-repair crashed (non-fatal): " + (e && e.message));
   }
@@ -688,6 +700,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(3, 5, "Clearing daemon port");
   forceKillPortHolder(PORT, function (killedCount) {
     if (killedCount > 0) {
       log("Killed " + killedCount + " stale daemon process(es) holding port " + PORT + ".");
@@ -718,6 +731,7 @@ function runMainAfterKill() {
       // idempotent and ensures the unit file matches the current bundle.
     }
 
+    progress(4, 5, "Installing daemon service");
     log("Installing Omnius API daemon service for port " + PORT + " ...");
     log("  node:       " + nodeBin);
     log("  omnius script:  " + omniusScript);
@@ -748,6 +762,7 @@ function runMainAfterKill() {
     }
 
     // Wait up to 15s for /health to come up, but don't fail npm install.
+    progress(5, 5, "Verifying daemon health");
     waitForHealth(15000, function (healthy) {
       if (healthy) {
         log("Omnius API daemon is live: http://127.0.0.1:" + PORT + "/health");

package/dist/preinstall.cjs

@@ -29,12 +29,34 @@ var HOME = os.homedir();
 var SERVICE_LABEL = "omnius-daemon";
 var LAUNCHD_LABEL = "ai.omnius.daemon";
 var WIN_TASK_NAME = "OmniusDaemon";
+var BANNER = [
+  "",
+  "░░      ░░░  ░░░░  ░░   ░░░  ░░        ░░  ░░░░  ░░░      ░░",
+  "▒  ▒▒▒▒  ▒▒   ▒▒   ▒▒    ▒▒  ▒▒▒▒▒  ▒▒▒▒▒  ▒▒▒▒  ▒▒  ▒▒▒▒▒▒▒",
+  "▓  ▓▓▓▓  ▓▓        ▓▓  ▓  ▓  ▓▓▓▓▓  ▓▓▓▓▓  ▓▓▓▓  ▓▓▓      ▓▓",
+  "█  ████  ██  █  █  ██  ██    █████  █████  ████  ████████  █",
+  "██      ███  ████  ██  ███   ██        ███      ████      ██",
+  ""
+].join("\n");
+
+function quietInstall() {
+  var level = String(process.env.npm_config_loglevel || "").toLowerCase();
+  return process.env.OMNIUS_QUIET_INSTALL === "1" || level === "silent";
+}
 
 function runQuiet(cmd) {
   try { cp.execSync(cmd, { stdio: "pipe", timeout: 8000 }); return true; } catch (e) { return false; }
 }
 
 function log(msg) { process.stdout.write("  [preinstall] " + msg + "\n"); }
+function progress(step, total, msg) {
+  if (quietInstall()) return;
+  var width = 18;
+  var filled = Math.max(0, Math.min(width, Math.round((step / total) * width)));
+  process.stdout.write("  [" + "#".repeat(filled) + ".".repeat(width - filled) + "] " + step + "/" + total + " " + msg + "\n");
+}
+
+if (!quietInstall()) process.stdout.write(BANNER + "\n");
 
 function stopServiceManager() {
   // Stop via the registered service manager if one exists. This is
@@ -65,8 +87,10 @@ function killPidFile(pidFile) {
   return false;
 }
 
+progress(1, 3, "Preparing Omnius service handoff");
 stopServiceManager();
 killPidFile(path.join(HOME, ".omnius", "daemon.pid"));
+progress(2, 3, "Stopped old daemon handles");
 
 // Final: lsof-based sweep for any process still holding 11435.
 try {
@@ -88,5 +112,5 @@ try {
 } catch (e) {}
 
 // 1.5s grace so SIGTERM handlers can flush state.
+progress(3, 3, "Install handoff ready");
 setTimeout(function () { process.exit(0); }, 1500);
-

package/node_modules/image-to-ascii/bin/image-to-ascii.cjs

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+"use strict";
+
+var imageToAscii = require("../index.cjs");
+
+var source = process.argv[2];
+if (!source) {
+  process.stderr.write("Usage: image-to-ascii <image-path-or-url>\n");
+  process.exit(2);
+}
+
+imageToAscii(source, { colored: false }, function (err, converted) {
+  if (err) {
+    process.stderr.write((err && err.message ? err.message : String(err)) + "\n");
+    process.exit(1);
+  }
+  process.stdout.write(String(converted || "") + "\n");
+});

package/node_modules/image-to-ascii/index.cjs

@@ -0,0 +1,257 @@
+"use strict";
+
+var childProcess = require("node:child_process");
+var crypto = require("node:crypto");
+var fs = require("node:fs");
+var os = require("node:os");
+var path = require("node:path");
+
+var DEFAULT_PIXELS = " .,:;i1tfLCG08@";
+
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Buffer.isBuffer(value);
+}
+
+function clamp(value, min, max) {
+  var n = Number(value);
+  if (!Number.isFinite(n)) return min;
+  n = Math.floor(n);
+  return Math.max(min, Math.min(max, n));
+}
+
+function percentOrNumber(value, basis, fallback) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    var trimmed = value.trim();
+    if (trimmed.endsWith("%")) {
+      var pct = Number(trimmed.slice(0, -1));
+      if (Number.isFinite(pct)) return Math.max(1, Math.floor((basis * pct) / 100));
+    }
+    var parsed = Number(trimmed);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return fallback;
+}
+
+function resolveSize(options) {
+  var size = isObject(options.size) ? options.size : {};
+  var sizeOptions = isObject(options.size_options) ? options.size_options : {};
+  var screen = isObject(sizeOptions.screen_size) ? sizeOptions.screen_size : {};
+  var screenWidth = clamp(screen.width || process.stdout.columns || 80, 20, 240);
+  var screenHeight = clamp(screen.height || process.stdout.rows || 32, 8, 120);
+  var width = percentOrNumber(size.width, screenWidth, Math.min(80, screenWidth));
+  var height = percentOrNumber(size.height, screenHeight, Math.max(8, Math.round(width * 0.42)));
+  return {
+    width: clamp(width, 8, 240),
+    height: clamp(height, 4, 120)
+  };
+}
+
+function normalizeOptions(options) {
+  if (!isObject(options)) options = {};
+  var pixels = options.pixels;
+  if (Array.isArray(pixels)) pixels = pixels.join("");
+  if (typeof pixels !== "string" || pixels.length < 2) pixels = DEFAULT_PIXELS;
+  if (options.reverse === true) pixels = pixels.split("").reverse().join("");
+  return {
+    pixels: pixels,
+    colored: options.colored === true,
+    concat: options.concat !== false,
+    stringify: options.stringify !== false,
+    timeoutMs: clamp(options.timeoutMs || options.timeout || 5000, 500, 60000),
+    preserveAspectRatio: !options.size_options || options.size_options.preserve_aspect_ratio !== false,
+    size: resolveSize(options),
+    stringifyFn: typeof options.stringify_fn === "function" ? options.stringify_fn : null
+  };
+}
+
+function tempFilePath(ext) {
+  var suffix = ext || ".img";
+  if (!suffix.startsWith(".")) suffix = "." + suffix;
+  return path.join(os.tmpdir(), "omnius-image-to-ascii-" + crypto.randomUUID() + suffix);
+}
+
+function extensionFromUrl(url) {
+  try {
+    var parsed = new URL(url);
+    var ext = path.extname(parsed.pathname || "");
+    return ext || ".img";
+  } catch (e) {
+    return ".img";
+  }
+}
+
+function sourceToFile(source, callback) {
+  if (Buffer.isBuffer(source)) {
+    var bufPath = tempFilePath(".img");
+    fs.writeFile(bufPath, source, function (err) {
+      callback(err, bufPath, true);
+    });
+    return;
+  }
+
+  if (typeof source !== "string" || source.trim().length === 0) {
+    callback(new Error("image-to-ascii source must be a file path, URL, or Buffer"));
+    return;
+  }
+
+  if (/^https?:\/\//i.test(source)) {
+    if (typeof fetch !== "function") {
+      callback(new Error("image-to-ascii URL input requires Node fetch support"));
+      return;
+    }
+    fetch(source).then(function (res) {
+      if (!res.ok) throw new Error("image-to-ascii failed to fetch image: HTTP " + res.status);
+      return res.arrayBuffer();
+    }).then(function (arrayBuffer) {
+      var urlPath = tempFilePath(extensionFromUrl(source));
+      fs.writeFile(urlPath, Buffer.from(arrayBuffer), function (err) {
+        callback(err, urlPath, true);
+      });
+    }).catch(function (err) {
+      callback(err);
+    });
+    return;
+  }
+
+  callback(null, source, false);
+}
+
+function buildFilter(width, height, preserveAspectRatio) {
+  if (preserveAspectRatio) {
+    return [
+      "scale=" + width + ":" + height + ":force_original_aspect_ratio=decrease",
+      "pad=" + width + ":" + height + ":(ow-iw)/2:(oh-ih)/2:color=black",
+      "format=gray"
+    ].join(",");
+  }
+  return "scale=" + width + ":" + height + ",format=gray";
+}
+
+function matrixFromRaw(raw, width, height) {
+  var matrix = [];
+  for (var y = 0; y < height; y++) {
+    var row = [];
+    for (var x = 0; x < width; x++) {
+      var value = raw[y * width + x] || 0;
+      row.push({ r: value, g: value, b: value, a: 255, value: value });
+    }
+    matrix.push(row);
+  }
+  return matrix;
+}
+
+function stringifyMatrix(matrix, options) {
+  var lines = [];
+  var pixels = options.pixels;
+  var maxIdx = pixels.length - 1;
+  for (var y = 0; y < matrix.length; y++) {
+    var line = "";
+    for (var x = 0; x < matrix[y].length; x++) {
+      var value = matrix[y][x].value || 0;
+      var idx = Math.round((value / 255) * maxIdx);
+      var ch = pixels[idx] || " ";
+      if (options.colored) {
+        line += "\x1b[38;2;" + value + ";" + value + ";" + value + "m" + ch + "\x1b[0m";
+      } else {
+        line += ch;
+      }
+    }
+    lines.push(line.replace(/\s+$/g, ""));
+  }
+  return options.concat ? lines.join("\n") : lines;
+}
+
+function renderFile(filePath, options, callback) {
+  var width = options.size.width;
+  var height = options.size.height;
+  var args = [
+    "-hide_banner",
+    "-loglevel",
+    "error",
+    "-i",
+    filePath,
+    "-vf",
+    buildFilter(width, height, options.preserveAspectRatio),
+    "-frames:v",
+    "1",
+    "-f",
+    "rawvideo",
+    "-pix_fmt",
+    "gray",
+    "-"
+  ];
+
+  childProcess.execFile("ffmpeg", args, {
+    encoding: "buffer",
+    maxBuffer: width * height + 4096,
+    timeout: options.timeoutMs
+  }, function (err, stdout, stderr) {
+    if (err) {
+      var detail = stderr && stderr.length ? String(stderr).trim() : err.message;
+      callback(new Error("image-to-ascii failed via ffmpeg: " + detail));
+      return;
+    }
+    if (!stdout || stdout.length < width * height) {
+      callback(new Error("image-to-ascii decoded too few pixels for " + width + "x" + height));
+      return;
+    }
+    var matrix = matrixFromRaw(stdout, width, height);
+    if (!options.stringify) {
+      callback(null, matrix);
+      return;
+    }
+    if (options.stringifyFn) {
+      try {
+        callback(null, options.stringifyFn(matrix, options));
+      } catch (stringifyErr) {
+        callback(stringifyErr);
+      }
+      return;
+    }
+    callback(null, stringifyMatrix(matrix, options));
+  });
+}
+
+function imageToAscii(source, options, callback) {
+  if (typeof options === "function") {
+    callback = options;
+    options = {};
+  }
+  if (typeof callback !== "function") {
+    return new Promise(function (resolve, reject) {
+      imageToAscii(source, options || {}, function (err, converted) {
+        if (err) reject(err);
+        else resolve(converted);
+      });
+    });
+  }
+
+  var normalized = normalizeOptions(options || {});
+  sourceToFile(source, function (sourceErr, filePath, cleanup) {
+    if (sourceErr) {
+      callback(sourceErr);
+      return;
+    }
+    renderFile(filePath, normalized, function (renderErr, converted) {
+      if (cleanup) {
+        fs.unlink(filePath, function () {});
+      }
+      callback(renderErr, converted);
+    });
+  });
+}
+
+imageToAscii.defaults = {
+  size_options: {
+    px_size: { width: 1 }
+  },
+  stringify: true,
+  concat: true,
+  size: {
+    height: "100%"
+  }
+};
+
+module.exports = imageToAscii;
+module.exports.default = imageToAscii;

package/node_modules/image-to-ascii/index.d.ts

@@ -0,0 +1,48 @@
+declare namespace imageToAscii {
+  interface Size {
+    width?: number | string;
+    height?: number | string;
+  }
+
+  interface SizeOptions {
+    screen_size?: {
+      width?: number;
+      height?: number;
+    };
+    preserve_aspect_ratio?: boolean;
+    fit_screen?: boolean;
+    px_size?: {
+      width?: number;
+      height?: number;
+    };
+  }
+
+  interface Options {
+    pxWidth?: number;
+    size?: Size;
+    size_options?: SizeOptions;
+    stringify?: boolean;
+    concat?: boolean;
+    pixels?: string | string[];
+    reverse?: boolean;
+    colored?: boolean;
+    bg?: boolean;
+    fg?: boolean;
+    white_bg?: boolean;
+    px_background?: { r: number; g: number; b: number };
+    image_type?: string;
+    timeout?: number;
+    timeoutMs?: number;
+    stringify_fn?: (pixels: unknown, options: Options) => unknown;
+  }
+
+  type Callback = (err: Error | null, converted?: unknown) => void;
+}
+
+declare function imageToAscii(
+  source: string | Buffer,
+  options: imageToAscii.Options | imageToAscii.Callback,
+  callback?: imageToAscii.Callback,
+): void | Promise<unknown>;
+
+export = imageToAscii;

package/node_modules/image-to-ascii/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "image-to-ascii",
+  "version": "3.3.0-omnius.1",
+  "description": "Omnius bundled image-to-ascii compatibility renderer without the legacy lwip native dependency chain.",
+  "main": "index.cjs",
+  "types": "index.d.ts",
+  "bin": {
+    "image-to-ascii": "bin/image-to-ascii.cjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "require": "./index.cjs",
+      "default": "./index.cjs"
+    }
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "dependencies": {}
+}