omnius 1.0.9 → 1.0.11

package/README.md

@@ -278,7 +278,7 @@ The agent uses tools autonomously in a loop — reading errors, fixing code, and
 
 - **61 autonomous tools** — file I/O, shell, grep, web search/fetch/crawl, memory (read/write/search), sub-agents, background tasks, image/OCR/PDF, git, diagnostics, vision, desktop automation, browser automation, temporal agency (scheduler/reminders/agenda), structured files, code sandbox, transcription, skills, opencode delegation, cron agents, nexus P2P networking + x402 micropayments, **COHERE cognitive stack** (persistent REPL, recursive LLM calls, memory metabolism, identity kernel, reflection, exploration)
 - **Moondream vision** — see and interact with the desktop via Moondream VLM (caption, query, detect, point-and-click)
-- **Image generation with TUI previews** — `/image <prompt>` and the `generate_image` tool create PNGs under `.omnius/images/`, support explicit `--model` selection, and render generated, pasted, screenshot, and camera-capture images as auto-sized ASCII previews via `image-to-ascii`
+- **Image generation with TUI previews** — `/image <prompt>` and the `generate_image` tool create PNGs under `.omnius/images/`, support explicit `--model` selection, and render generated, pasted, screenshot, and camera-capture images as auto-sized ASCII previews via the bundled `image-to-ascii` renderer
 - **Desktop automation** — vision-guided clicking: describe a UI element in natural language, the agent finds and clicks it
 - **Auto-install desktop deps** — screenshot, mouse, OCR, and image tools auto-install missing system packages (scrot, xdotool, tesseract, imagemagick) on first use
 - **Hardware-rated model lists** — first-run setup, `/models`, `/score`, and `/image list` score model fit against detected RAM/VRAM/GPU so text and image model choices are visible before you switch or generate
@@ -3294,7 +3294,7 @@ omnius
 
 The TUI features an animated multilingual phrase carousel, live metrics bar with pastel-colored labels (token in/out, context window usage, human expert speed ratio, cost), rotating tips, syntax-highlighted tool output, and dynamic terminal-width cropping.
 
-Image surfaces are first-class in the terminal. `/image` generations, generated-image tool results, pasted image context, screenshots, and camera captures are converted through `image-to-ascii` and sized to the current terminal before being printed into the main scrollback. Each generated image also includes the saved file path below the preview.
+Image surfaces are first-class in the terminal. `/image` generations, generated-image tool results, pasted image context, screenshots, and camera captures are converted through Omnius' bundled `image-to-ascii` renderer and sized to the current terminal before being printed into the main scrollback. The bundled renderer preserves the upstream `require("image-to-ascii")` API without installing the legacy `lwip` native dependency chain that fails on modern Node releases. Each generated image also includes the saved file path below the preview, and preview renderer failures are surfaced in the scrollback instead of disappearing silently.
 
 ### Slash Commands
 

package/dist/index.js

@@ -572498,22 +572498,29 @@ function normalizeAscii(ascii2, width, height) {
   const lines = ascii2.replace(ANSI_PATTERN, "").replace(/\r/g, "").split("\n").map((line) => line.replace(/\s+$/g, "")).filter((line, idx, all2) => line.length > 0 || idx > 0 && idx < all2.length - 1);
   return lines.slice(0, height).map((line) => line.length > width ? line.slice(0, width) : line).join("\n").trimEnd();
 }
+function previewFailure(message2, width) {
+  const clean3 = message2.replace(/\s+/g, " ").trim();
+  const text = `[image-to-ascii preview failed: ${clean3 || "unknown error"}]`;
+  return text.length > width ? `${text.slice(0, Math.max(0, width - 1))}]` : text;
+}
 async function convertWithImageToAscii(imagePath, width, height, timeoutMs) {
   let imageToAscii;
   try {
     const require4 = createRequire4(import.meta.url);
     const mod2 = require4("image-to-ascii");
     imageToAscii = typeof mod2 === "function" ? mod2 : mod2.default;
-    if (typeof imageToAscii !== "function") return null;
-  } catch {
-    return null;
+    if (typeof imageToAscii !== "function") {
+      return { ascii: null, error: "module did not export a function" };
+    }
+  } catch (err) {
+    return { ascii: null, error: err instanceof Error ? err.message : String(err) };
   }
   return new Promise((resolvePreview) => {
     let settled = false;
     const timer = setTimeout(() => {
       if (!settled) {
         settled = true;
-        resolvePreview(null);
+        resolvePreview({ ascii: null, error: `timed out after ${timeoutMs}ms` });
       }
     }, timeoutMs).unref();
     try {
@@ -572532,18 +572539,20 @@ async function convertWithImageToAscii(imagePath, width, height, timeoutMs) {
           settled = true;
           clearTimeout(timer);
           if (err || !converted) {
-            resolvePreview(null);
+            resolvePreview({ ascii: null, error: err?.message || "empty renderer output" });
             return;
           }
           const normalized = normalizeAscii(converted, width, height);
-          resolvePreview(normalized || null);
+          resolvePreview(
+            normalized ? { ascii: normalized } : { ascii: null, error: "empty normalized renderer output" }
+          );
         }
       );
-    } catch {
+    } catch (err) {
       if (!settled) {
         settled = true;
         clearTimeout(timer);
-        resolvePreview(null);
+        resolvePreview({ ascii: null, error: err instanceof Error ? err.message : String(err) });
       }
     }
   });
@@ -572607,8 +572616,15 @@ async function buildImageAsciiPreview(inputPath, options2 = {}) {
   const height = clamp5(options2.height ?? defaults3.height, 8, 60);
   const timeoutMs = clamp5(options2.timeoutMs ?? 5e3, 500, 3e4);
   if (options2.preferPackage !== false) {
-    const ascii2 = await convertWithImageToAscii(imagePath, width, height, timeoutMs);
-    if (ascii2) return { path: imagePath, ascii: ascii2, renderer: "image-to-ascii", width, height };
+    const result = await convertWithImageToAscii(imagePath, width, height, timeoutMs);
+    if (result.ascii) return { path: imagePath, ascii: result.ascii, renderer: "image-to-ascii", width, height };
+    return {
+      path: imagePath,
+      ascii: previewFailure(result.error || "renderer unavailable", width),
+      renderer: "image-to-ascii",
+      width,
+      height
+    };
   }
   const fallback = convertWithFfmpeg(imagePath, width, height, timeoutMs);
   if (fallback) return { path: imagePath, ascii: fallback, renderer: "ffmpeg", width, height };

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": {}
+}