@juspay/neurolink 11.22.0 → 11.22.2

package/dist/cli/factories/ollamaCommandFactory.js

@@ -9,6 +9,17 @@ import { AIProviderName } from "../../types/index.js";
 /**
  * Factory for creating Ollama CLI commands using the Factory Pattern
  */
+/** See the note on the identically-named constant in cli/utils/ollamaUtils.ts. */
+const OLLAMA_QUERY_TIMEOUT_MS = 15_000;
+/**
+ * Explicit opt-out from the query bound, for commands that are long by design.
+ *
+ * `spawnSync` treats 0 as "no timeout" (verified: a 3s child under
+ * `timeout: 0` runs to completion with no error, while `timeout: 1000` returns
+ * at 1.0s with ETIMEDOUT). Named rather than written as a bare 0 at the call
+ * site, because `timeout: 0` reads like "expire immediately".
+ */
+const OLLAMA_NO_TIMEOUT = 0;
 export class OllamaCommandFactory {
     /**
      * Secure wrapper around spawnSync to prevent command injection.
@@ -16,6 +27,12 @@ export class OllamaCommandFactory {
     static safeSpawn(command, args, options = {}) {
         // Command validation is now handled by TypeScript with AllowedCommand type
         const defaultOptions = {
+            // spawnSync blocks the event loop, so an unresponsive daemon hangs the
+            // whole CLI with no output and no error. SIGKILL because spawnSync's
+            // timeout otherwise sends SIGTERM and keeps waiting. Callers with
+            // legitimately long commands override via `options`.
+            timeout: OLLAMA_QUERY_TIMEOUT_MS,
+            killSignal: "SIGKILL",
             ...options,
             encoding: "utf8", // Always enforce utf8 encoding
         };
@@ -24,31 +41,42 @@ export class OllamaCommandFactory {
     /**
      * Create the Ollama command group
      */
+    /**
+     * Every handler is registered `.bind(this)`.
+     *
+     * yargs invokes the handler as a plain function, so a bare `this.xHandler`
+     * reference arrives with `this` unset and the first `this.safeSpawn(...)`
+     * throws `TypeError: this.safeSpawn is not a function`. That made EVERY
+     * subcommand here fail on its first line — list-models, pull, remove, status
+     * and stop all reported their generic "Failed to ..." message regardless of
+     * whether Ollama was installed or running, which is exactly why the real
+     * cause stayed hidden.
+     */
     static createOllamaCommands() {
         return {
             command: "ollama <command>",
             describe: "Manage Ollama local AI models",
             builder: (yargs) => {
                 return yargs
-                    .command("list-models", "List installed Ollama models", {}, this.listModelsHandler)
+                    .command("list-models", "List installed Ollama models", {}, this.listModelsHandler.bind(this))
                     .command("pull <model>", "Download an Ollama model", {
                     model: {
                         describe: "Model name to download",
                         type: "string",
                         demandOption: true,
                     },
-                }, this.pullModelHandler)
+                }, this.pullModelHandler.bind(this))
                     .command("remove <model>", "Remove an Ollama model", {
                     model: {
                         describe: "Model name to remove",
                         type: "string",
                         demandOption: true,
                     },
-                }, this.removeModelHandler)
-                    .command("status", "Check Ollama service status", {}, this.statusHandler)
-                    .command("start", "Start Ollama service", {}, this.startHandler)
-                    .command("stop", "Stop Ollama service", {}, this.stopHandler)
-                    .command("setup", "Interactive Ollama setup", {}, this.setupHandler)
+                }, this.removeModelHandler.bind(this))
+                    .command("status", "Check Ollama service status", {}, this.statusHandler.bind(this))
+                    .command("start", "Start Ollama service", {}, this.startHandler.bind(this))
+                    .command("stop", "Stop Ollama service", {}, this.stopHandler.bind(this))
+                    .command("setup", "Interactive Ollama setup", {}, this.setupHandler.bind(this))
                     .demandCommand(1, "Please specify a command");
             },
             handler: () => { }, // No-op handler as subcommands handle everything
@@ -89,8 +117,16 @@ export class OllamaCommandFactory {
         logger.always(chalk.blue(`Downloading model: ${model}`));
         logger.always(chalk.gray("This may take several minutes..."));
         try {
+            // A model pull is hundreds of megabytes and legitimately runs for many
+            // minutes, so it MUST opt out of safeSpawn's default query bound.
+            // Passing only `stdio` here is what made the first revision of this
+            // change kill downloads at 15s: the wrapper spreads `options` over its
+            // defaults, so an unmentioned `timeout` keeps the default rather than
+            // being absent. It inherits stdio, so the user sees progress and can
+            // interrupt it — the two things a wedged query lacks.
             const res = this.safeSpawn("ollama", ["pull", model], {
                 stdio: "inherit",
+                timeout: OLLAMA_NO_TIMEOUT,
             });
             if (res.error || res.status !== 0) {
                 throw res.error || new Error("pull failed");
@@ -211,25 +247,36 @@ export class OllamaCommandFactory {
      */
     static async stopHandler() {
         const spinner = ora("Stopping Ollama service...").start();
+        // `safeSpawn` RETURNS a result; it does not throw on a failed command. So
+        // the try/catch fallbacks that used to sit here never fired — `killall`
+        // and the pkill fallback were unreachable, and the handler reported
+        // "stopped" whatever happened. Bounding these calls made that worse rather
+        // than better: a timeout now yields `error: ETIMEDOUT` with `status: null`,
+        // which is still not a throw, so a wedged kill would be reported as a
+        // successful stop while Ollama stayed up.
+        //
+        // Branch on the result instead, which both restores the fallback and makes
+        // the success message conditional on something actually succeeding.
+        const ok = (r) => !r.error && r.status === 0;
         try {
+            let stopped;
             if (process.platform === "darwin") {
-                try {
-                    this.safeSpawn("pkill", ["ollama"]);
-                }
-                catch {
-                    this.safeSpawn("killall", ["Ollama"]);
-                }
+                stopped =
+                    ok(this.safeSpawn("pkill", ["ollama"])) ||
+                        ok(this.safeSpawn("killall", ["Ollama"]));
             }
             else if (process.platform === "linux") {
-                try {
-                    this.safeSpawn("systemctl", ["stop", "ollama"]);
-                }
-                catch {
-                    this.safeSpawn("pkill", ["ollama"]);
-                }
+                stopped =
+                    ok(this.safeSpawn("systemctl", ["stop", "ollama"])) ||
+                        ok(this.safeSpawn("pkill", ["ollama"]));
             }
             else {
-                this.safeSpawn("taskkill", ["/F", "/IM", "ollama.exe"]);
+                stopped = ok(this.safeSpawn("taskkill", ["/F", "/IM", "ollama.exe"]));
+            }
+            if (!stopped) {
+                spinner.fail("Could not confirm Ollama service stopped");
+                logger.error(chalk.red("No stop command succeeded — it may not have been running, or it may still be up. Check with: ollama list"));
+                return;
             }
             spinner.succeed("Ollama service stopped");
         }

package/dist/cli/utils/ollamaUtils.d.ts

@@ -8,6 +8,15 @@ export declare class OllamaUtils {
      * Secure wrapper around spawnSync to prevent command injection.
      */
     static safeSpawn(command: AllowedCommand, args: string[], options?: SpawnSyncOptions): SpawnSyncReturns<string>;
+    /**
+     * Whether a `safeSpawn` call actually succeeded.
+     *
+     * `spawnSync` reports failure by RETURNING — `error` set (ENOENT, ETIMEDOUT)
+     * or a non-zero `status` — never by throwing. Every `try/catch` around one of
+     * these calls was therefore dead code, which is why several fallbacks in this
+     * file had never run.
+     */
+    private static spawnSucceeded;
     /**
      * Check if Ollama command line is available
      */

package/dist/cli/utils/ollamaUtils.js

@@ -2,6 +2,32 @@ import { spawnSync, spawn, } from "child_process";
 import chalk from "chalk";
 import ora from "ora";
 import { logger } from "../../utils/logger.js";
+/**
+ * Ceiling for a synchronous Ollama query (`list`, `--version`, `rm`, …).
+ *
+ * `spawnSync` blocks the event loop, so an unresponsive daemon does not make
+ * the CLI slow — it makes it unkillable by anything short of Ctrl-C, with no
+ * output and no error. These calls are local IPC that normally answer in
+ * milliseconds, so a ceiling this generous only ever fires on a genuine wedge.
+ *
+ * `killSignal: "SIGKILL"` is not decoration. `spawnSync`'s `timeout` sends
+ * SIGTERM by default and then keeps waiting, so a child that ignores SIGTERM
+ * hangs forever anyway and the timeout buys nothing.
+ *
+ * Long-running commands (`ollama pull`) must pass their own `timeout` — the
+ * spread below lets a caller override this — because a model download
+ * legitimately runs for many minutes.
+ */
+const OLLAMA_QUERY_TIMEOUT_MS = 15_000;
+/**
+ * Ceiling for the whole readiness loop, not one probe inside it.
+ *
+ * Ollama normally answers within seconds of starting; a wait longer than this
+ * means it is not coming up, and continuing to spin helps nobody. Sized to
+ * outlast a slow cold start while staying far below the ~15 minutes that 30
+ * attempts of bounded probes could otherwise reach.
+ */
+const READINESS_DEADLINE_MS = 90_000;
 /**
  * Shared Ollama utilities for CLI commands
  */
@@ -11,11 +37,24 @@ export class OllamaUtils {
      */
     static safeSpawn(command, args, options = {}) {
         const defaultOptions = {
+            timeout: OLLAMA_QUERY_TIMEOUT_MS,
+            killSignal: "SIGKILL",
             ...options,
             encoding: "utf8", // Always enforce utf8 encoding
         };
         return spawnSync(command, args, defaultOptions);
     }
+    /**
+     * Whether a `safeSpawn` call actually succeeded.
+     *
+     * `spawnSync` reports failure by RETURNING — `error` set (ENOENT, ETIMEDOUT)
+     * or a non-zero `status` — never by throwing. Every `try/catch` around one of
+     * these calls was therefore dead code, which is why several fallbacks in this
+     * file had never run.
+     */
+    static spawnSucceeded(result) {
+        return !result.error && result.status === 0;
+    }
     /**
      * Check if Ollama command line is available
      */
@@ -70,7 +109,16 @@ export class OllamaUtils {
      */
     static async waitForOllamaReady(maxAttempts = 30, initialDelay = 500) {
         let delay = initialDelay;
+        // A per-call bound alone is not enough here, and adding one made this
+        // worse before it made it better: each attempt can now burn the full
+        // command bound plus the API bound, so 30 attempts is up to ~15 minutes of
+        // spinner rather than the seconds this loop was written to take. The
+        // per-attempt bound stops one wedged call; this stops the loop around it.
+        const deadline = Date.now() + READINESS_DEADLINE_MS;
         for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            if (Date.now() >= deadline) {
+                return false;
+            }
             try {
                 // Try command line check first
                 if (!this.isOllamaCommandReady()) {
@@ -117,11 +165,17 @@ export class OllamaUtils {
         try {
             if (process.platform === "darwin") {
                 logger.always(chalk.gray("Starting Ollama on macOS..."));
-                try {
-                    this.safeSpawn("open", ["-a", "Ollama"]);
+                // `safeSpawn` RETURNS a result; it does not throw on a failed command,
+                // so this catch only ever fired on a programming error and the
+                // `ollama serve` fallback beneath it was effectively unreachable.
+                // Bounding these calls made that worse: a timeout yields
+                // `error: ETIMEDOUT` with `status: null`, still not a throw, so a
+                // wedged launcher would have been reported as a successful start.
+                // Branch on the result so the fallback actually runs.
+                if (this.spawnSucceeded(this.safeSpawn("open", ["-a", "Ollama"]))) {
                     logger.always(chalk.green("✅ Ollama app started"));
                 }
-                catch {
+                else {
                     const child = spawn("ollama", ["serve"], {
                         stdio: "ignore",
                         detached: true,
@@ -135,11 +189,10 @@ export class OllamaUtils {
             }
             else if (process.platform === "linux") {
                 logger.always(chalk.gray("Starting Ollama service on Linux..."));
-                try {
-                    this.safeSpawn("systemctl", ["start", "ollama"]);
+                if (this.spawnSucceeded(this.safeSpawn("systemctl", ["start", "ollama"]))) {
                     logger.always(chalk.green("✅ Ollama service started"));
                 }
-                catch {
+                else {
                     const child = spawn("ollama", ["serve"], {
                         stdio: "ignore",
                         detached: true,
@@ -156,11 +209,16 @@ export class OllamaUtils {
                 // Security Note: Windows shell=true usage is intentional here for 'start' command.
                 // Arguments are controlled internally (no user input) and safeSpawn validates command names.
                 // This is safer than alternative Windows process creation methods for this specific use case.
-                this.safeSpawn("start", ["ollama", "serve"], {
+                const started = this.safeSpawn("start", ["ollama", "serve"], {
                     stdio: "ignore",
                     shell: true,
                 });
-                logger.always(chalk.green("✅ Ollama service started"));
+                if (this.spawnSucceeded(started)) {
+                    logger.always(chalk.green("✅ Ollama service started"));
+                }
+                else {
+                    logger.always(chalk.yellow("⚠️ Could not confirm Ollama started — check with: ollama list"));
+                }
             }
             // Wait for service to become ready with readiness probe
             const readinessSpinner = ora("Waiting for Ollama service to be ready...").start();

package/dist/localUsage/claudeCodeReader.js

@@ -179,10 +179,22 @@ export async function createClaudeCodeReader() {
             const unpriced = new Set();
             const files = [];
             await collectTranscripts(projectsRoot(), files);
-            const sinceDays = options?.sinceDays ?? DEFAULT_SINCE_DAYS;
-            const cutoff = Number.isFinite(sinceDays) && sinceDays > 0
-                ? Date.now() - sinceDays * 86_400_000
-                : undefined;
+            // Only Infinity means "no time filter". A non-positive sinceDays used to
+            // leave the cutoff undefined and read EVERYTHING — measured at 17,534
+            // files and 35.9s for `sinceDays: 0`, which is the widest possible scan
+            // in answer to the narrowest possible request. Zero now means a
+            // zero-length window, which is what it reads as.
+            // NaN is not a window, and it is the case the previous fix missed:
+            // Math.max(0, NaN) is NaN, every comparison against NaN is false, so the
+            // filter passes EVERY file. Measured: sinceDays NaN read 17,537 files in
+            // 32.8s — the same unbounded sweep this guard exists to prevent, reached
+            // by a different door. The old guard caught it with Number.isFinite and
+            // the replacement dropped that check.
+            const requestedDays = options?.sinceDays ?? DEFAULT_SINCE_DAYS;
+            const sinceDays = Number.isNaN(requestedDays) ? 0 : requestedDays;
+            const cutoff = sinceDays === Infinity
+                ? undefined
+                : Date.now() - Math.max(0, sinceDays) * 86_400_000;
             let filesScanned = 0;
             for (const file of files) {
                 try {

package/dist/localUsage/codexReader.js

@@ -167,10 +167,22 @@ export async function createCodexReader() {
             const models = new Set();
             const files = [];
             await collectRollouts(sessionsRoot(), files);
-            const sinceDays = options?.sinceDays ?? DEFAULT_SINCE_DAYS;
-            const cutoff = Number.isFinite(sinceDays) && sinceDays > 0
-                ? Date.now() - sinceDays * 86_400_000
-                : undefined;
+            // Only Infinity means "no time filter". A non-positive sinceDays used to
+            // leave the cutoff undefined and read EVERYTHING — measured at 17,534
+            // files and 35.9s for `sinceDays: 0`, which is the widest possible scan
+            // in answer to the narrowest possible request. Zero now means a
+            // zero-length window, which is what it reads as.
+            // NaN is not a window, and it is the case the previous fix missed:
+            // Math.max(0, NaN) is NaN, every comparison against NaN is false, so the
+            // filter passes EVERY file. Measured: sinceDays NaN read 17,537 files in
+            // 32.8s — the same unbounded sweep this guard exists to prevent, reached
+            // by a different door. The old guard caught it with Number.isFinite and
+            // the replacement dropped that check.
+            const requestedDays = options?.sinceDays ?? DEFAULT_SINCE_DAYS;
+            const sinceDays = Number.isNaN(requestedDays) ? 0 : requestedDays;
+            const cutoff = sinceDays === Infinity
+                ? undefined
+                : Date.now() - Math.max(0, sinceDays) * 86_400_000;
             let filesScanned = 0;
             for (const file of files) {
                 try {

package/dist/localUsage/openCodeReader.js

@@ -114,10 +114,28 @@ export async function createOpenCodeReader() {
                 });
                 return { cliId: CLI_ID, totals, filesScanned: 0, errors };
             }
-            const sinceDays = options?.sinceDays ?? DEFAULT_SINCE_DAYS;
-            const cutoffMs = Number.isFinite(sinceDays) && sinceDays > 0
-                ? Date.now() - sinceDays * 86_400_000
-                : 0;
+            // Only Infinity means "no time filter". A non-positive sinceDays used to
+            // leave the cutoff undefined and read EVERYTHING — measured at 17,534
+            // files and 35.9s for `sinceDays: 0`, which is the widest possible scan
+            // in answer to the narrowest possible request. Zero now means a
+            // zero-length window, which is what it reads as.
+            // NaN is not a window, and it is the case the previous fix missed:
+            // Math.max(0, NaN) is NaN, every comparison against NaN is false, so the
+            // filter passes EVERY file. Measured: sinceDays NaN read 17,537 files in
+            // 32.8s — the same unbounded sweep this guard exists to prevent, reached
+            // by a different door. The old guard caught it with Number.isFinite and
+            // the replacement dropped that check.
+            //
+            // On this reader NaN was worse than an unbounded scan: the value went
+            // into the SQL text, and SQLite parses a bare NaN as an identifier —
+            // "no such column: NaN" — so the whole scan failed rather than
+            // over-reading. The cutoff is a bound parameter now, so a value can
+            // never be SQL syntax whatever it is.
+            const requestedDays = options?.sinceDays ?? DEFAULT_SINCE_DAYS;
+            const sinceDays = Number.isNaN(requestedDays) ? 0 : requestedDays;
+            const cutoffMs = sinceDays === Infinity
+                ? 0
+                : Date.now() - Math.max(0, sinceDays) * 86_400_000;
             let db;
             try {
                 // Read-only: this is the user's live store and OpenCode may be running.
@@ -125,9 +143,13 @@ export async function createOpenCodeReader() {
                 // Filtered in SQL rather than in JS. `time_created` is epoch ms, and
                 // the table holds thousands of rows whose `data` blobs are large — the
                 // point of the time window is not reading them at all.
+                // Bound parameter, not interpolation. A number spliced into SQL text
+                // is still SQL text: NaN parsed as an identifier and failed the whole
+                // scan with "no such column: NaN". A bound value cannot become syntax
+                // whatever it holds.
                 const rows = db
-                    .prepare(`SELECT data FROM message WHERE time_created >= ${cutoffMs}`)
-                    .all();
+                    .prepare("SELECT data FROM message WHERE time_created >= ?")
+                    .all(cutoffMs);
                 for (const row of rows) {
                     if (typeof row.data !== "string") {
                         continue;

package/dist/types/localUsage.d.ts

@@ -121,7 +121,7 @@ export type LocalUsageAggregateReport = {
     generatedAt: string;
     /** Only CLIs whose store was detected AND scanned appear here. */
     totals: Partial<Record<LocalUsageCliId, LocalUsageTotals>>;
-    /** CLIs that were registered but produced nothing, and why. */
+    /** CLIs whose reader could not be created, detected, or scanned, and why. */
     failures: LocalUsageReaderFailure[];
     /** CLIs with no local store on this machine — absent, not failed. */
     notInstalled: LocalUsageCliId[];
@@ -161,7 +161,7 @@ export type LocalUsageCodexSessionRollup = {
  */
 export type LocalUsageSqliteDatabase = {
     prepare: (sql: string) => {
-        all: () => unknown[];
+        all: (...params: unknown[]) => unknown[];
     };
     close: () => void;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "11.22.0",
+  "version": "11.22.2",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {

package/dist/cli/commands/ollama.d.ts

@@ -1,3 +0,0 @@
-import type { Argv } from "yargs";
-export declare function addOllamaCommands(cli: Argv): void;
-export default addOllamaCommands;