@juspay/neurolink 7.28.0 → 7.29.0

package/CHANGELOG.md

@@ -1,3 +1,16 @@
+## [7.29.0](https://github.com/juspay/neurolink/compare/v7.28.1...v7.29.0) (2025-08-26)
+
+### Features
+
+- **(guardrails):** added guardrails as a middleware ([ac60f6b](https://github.com/juspay/neurolink/commit/ac60f6b143a58f86e17481ddb3e067e5307391cf))
+
+## [7.28.1](https://github.com/juspay/neurolink/compare/v7.28.0...v7.28.1) (2025-08-26)
+
+### Bug Fixes
+
+- **(cli):** resolve ESM interop and spawn synchronization issues ([4983221](https://github.com/juspay/neurolink/commit/49832210cd56df14e7cb77925fcc89c1cc72c046))
+- **(security):** prevent command injection in ollama pull ([27e6088](https://github.com/juspay/neurolink/commit/27e6088aa9e2d7dddaa1839d777e6b642e095549))
+
 ## [7.28.0](https://github.com/juspay/neurolink/compare/v7.27.0...v7.28.0) (2025-08-25)
 
 ### Features

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

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

package/dist/cli/commands/ollama.js

@@ -0,0 +1,288 @@
+import { spawnSync } from "child_process";
+import chalk from "chalk";
+import ora from "ora";
+import inquirer from "inquirer";
+import { logger } from "../../lib/utils/logger.js";
+import { OllamaUtils } from "../utils/ollamaUtils.js";
+export function addOllamaCommands(cli) {
+    cli.command("ollama <command>", "Manage Ollama local AI models", (yargs) => {
+        return yargs
+            .command("list-models", "List installed Ollama models", {}, listModelsHandler)
+            .command("pull <model>", "Download an Ollama model", {
+            model: {
+                describe: "Model name to download",
+                type: "string",
+                demandOption: true,
+            },
+        }, pullModelHandler)
+            .command("remove <model>", "Remove an Ollama model", {
+            model: {
+                describe: "Model name to remove",
+                type: "string",
+                demandOption: true,
+            },
+        }, removeModelHandler)
+            .command("status", "Check Ollama service status", {}, statusHandler)
+            .command("start", "Start Ollama service", {}, startHandler)
+            .command("stop", "Stop Ollama service", {}, stopHandler)
+            .command("setup", "Interactive Ollama setup", {}, setupHandler)
+            .demandCommand(1, "Please specify a command");
+    }, () => { });
+}
+async function listModelsHandler() {
+    const spinner = ora("Fetching installed models...").start();
+    try {
+        const res = spawnSync("ollama", ["list"], { encoding: "utf8" });
+        if (res.error) {
+            throw res.error;
+        }
+        spinner.succeed("Installed models:");
+        const output = res.stdout?.toString().trim();
+        if (output) {
+            logger.always(output);
+        }
+        else {
+            logger.always(chalk.yellow('No models installed. Use "neurolink ollama pull <model>" to download a model.'));
+        }
+    }
+    catch (error) {
+        spinner.fail("Failed to list models. Is Ollama installed?");
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error(chalk.red("Error:", errorMessage));
+        logger.always(chalk.blue("\nTip: Install Ollama from https://ollama.ai"));
+        process.exit(1);
+    }
+}
+async function pullModelHandler(argv) {
+    const { model } = argv;
+    logger.always(chalk.blue(`Downloading model: ${model}`));
+    logger.always(chalk.gray("This may take several minutes..."));
+    try {
+        const res = spawnSync("ollama", ["pull", model], { stdio: "inherit" });
+        if (res.error) {
+            throw res.error;
+        }
+        if (res.status !== 0) {
+            throw new Error(`ollama pull exited with code ${res.status}`);
+        }
+        logger.always(chalk.green(`\n✅ Successfully downloaded ${model}`));
+        logger.always(chalk.blue(`\nTest it with: npx @juspay/neurolink generate "Hello!" --provider ollama --model ${model}`));
+    }
+    catch (error) {
+        logger.error(chalk.red(`\n❌ Failed to download ${model}`));
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error(chalk.red("Error:", errorMessage));
+        process.exit(1);
+    }
+}
+async function removeModelHandler(argv) {
+    const { model } = argv;
+    const { confirm } = await inquirer.prompt([
+        {
+            type: "confirm",
+            name: "confirm",
+            message: `Are you sure you want to remove model "${model}"?`,
+            default: false,
+        },
+    ]);
+    if (!confirm) {
+        logger.always(chalk.yellow("Removal cancelled."));
+        return;
+    }
+    const spinner = ora(`Removing model ${model}...`).start();
+    try {
+        const res = spawnSync("ollama", ["rm", model], { encoding: "utf8" });
+        if (res.error) {
+            throw res.error;
+        }
+        if (res.status !== 0) {
+            throw new Error(`ollama rm exited with ${res.status}`);
+        }
+        spinner.succeed(`Successfully removed ${model}`);
+    }
+    catch (error) {
+        spinner.fail(`Failed to remove ${model}`);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error(chalk.red("Error:", errorMessage));
+        process.exit(1);
+    }
+}
+async function statusHandler() {
+    const spinner = ora("Checking Ollama service status...").start();
+    try {
+        const res = spawnSync("ollama", ["list"], { encoding: "utf8" });
+        if (res.error) {
+            throw res.error;
+        }
+        if (res.status !== 0) {
+            throw new Error("Ollama not running");
+        }
+        spinner.succeed("Ollama service is running");
+    }
+    catch (error) {
+        spinner.fail("Ollama service is not running");
+        logger.debug("Ollama status check failed:", error);
+        logger.always(chalk.yellow("\nStart Ollama with: ollama serve"));
+        process.exit(1);
+    }
+}
+async function startHandler() {
+    await OllamaUtils.startOllamaService();
+}
+async function stopHandler() {
+    const spinner = ora("Stopping Ollama service...").start();
+    try {
+        if (process.platform === "darwin") {
+            try {
+                spawnSync("pkill", ["ollama"], { encoding: "utf8" });
+            }
+            catch {
+                spawnSync("killall", ["Ollama"], { encoding: "utf8" });
+            }
+        }
+        else if (process.platform === "linux") {
+            try {
+                spawnSync("systemctl", ["stop", "ollama"], { encoding: "utf8" });
+            }
+            catch {
+                spawnSync("pkill", ["ollama"], { encoding: "utf8" });
+            }
+        }
+        else {
+            spawnSync("taskkill", ["/F", "/IM", "ollama.exe"], { encoding: "utf8" });
+        }
+        spinner.succeed("Ollama service stopped");
+    }
+    catch (err) {
+        spinner.fail("Failed to stop Ollama service");
+        logger.error(chalk.red("It may not be running or requires manual stop"));
+        logger.error(chalk.red(`Error details: ${err}`));
+    }
+}
+async function setupHandler() {
+    logger.always(chalk.blue("🦙 Welcome to Ollama Setup!\n"));
+    // Check installation
+    const checkSpinner = ora("Checking Ollama installation...").start();
+    let isInstalled = false;
+    try {
+        spawnSync("ollama", ["--version"], { encoding: "utf8" });
+        isInstalled = true;
+        checkSpinner.succeed("Ollama is installed");
+    }
+    catch {
+        checkSpinner.fail("Ollama is not installed");
+    }
+    if (!isInstalled) {
+        logger.always(chalk.yellow("\nOllama needs to be installed first."));
+        logger.always(chalk.blue("\nInstallation instructions:"));
+        if (process.platform === "darwin") {
+            logger.always("\nFor macOS:");
+            logger.always(chalk.gray("  brew install ollama"));
+            logger.always(chalk.gray("  # or download from https://ollama.ai"));
+        }
+        else if (process.platform === "linux") {
+            logger.always("\nFor Linux:");
+            logger.always(chalk.gray("  curl -fsSL https://ollama.ai/install.sh | sh"));
+        }
+        else {
+            logger.always("\nFor Windows:");
+            logger.always(chalk.gray("  Download from https://ollama.ai"));
+        }
+        const { proceedAnyway } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "proceedAnyway",
+                message: "Would you like to continue with setup anyway?",
+                default: false,
+            },
+        ]);
+        if (!proceedAnyway) {
+            logger.always(chalk.blue("\nInstall Ollama and run setup again!"));
+            return;
+        }
+    }
+    // Check if service is running
+    let serviceRunning = false;
+    try {
+        spawnSync("ollama", ["list"], { encoding: "utf8" });
+        serviceRunning = true;
+        logger.always(chalk.green("\n✅ Ollama service is running"));
+    }
+    catch {
+        logger.always(chalk.yellow("\n⚠️  Ollama service is not running"));
+        const { startService } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "startService",
+                message: "Would you like to start the Ollama service?",
+                default: true,
+            },
+        ]);
+        if (startService) {
+            await startHandler();
+            serviceRunning = true;
+        }
+    }
+    if (serviceRunning) {
+        // List available models
+        logger.always(chalk.blue("\n📦 Popular Ollama models:"));
+        logger.always("  • llama2 (7B) - General purpose");
+        logger.always("  • codellama (7B) - Code generation");
+        logger.always("  • mistral (7B) - Fast and efficient");
+        logger.always("  • tinyllama (1B) - Lightweight");
+        logger.always("  • phi (2.7B) - Microsoft's compact model");
+        const { downloadModel } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "downloadModel",
+                message: "Would you like to download a model?",
+                default: true,
+            },
+        ]);
+        if (downloadModel) {
+            const { selectedModel } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "selectedModel",
+                    message: "Select a model to download:",
+                    choices: [
+                        {
+                            name: "llama2 (7B) - Recommended for general use",
+                            value: "llama2",
+                        },
+                        {
+                            name: "codellama (7B) - Best for code generation",
+                            value: "codellama",
+                        },
+                        { name: "mistral (7B) - Fast and efficient", value: "mistral" },
+                        { name: "tinyllama (1B) - Lightweight, fast", value: "tinyllama" },
+                        { name: "phi (2.7B) - Microsoft's compact model", value: "phi" },
+                        { name: "Other (enter manually)", value: "other" },
+                    ],
+                },
+            ]);
+            let modelToDownload = selectedModel;
+            if (selectedModel === "other") {
+                const { customModel } = await inquirer.prompt([
+                    {
+                        type: "input",
+                        name: "customModel",
+                        message: "Enter the model name:",
+                        validate: (input) => input.trim().length > 0 || "Model name is required",
+                    },
+                ]);
+                modelToDownload = customModel;
+            }
+            await pullModelHandler({ model: modelToDownload });
+        }
+    }
+    logger.always(chalk.green("\n✅ Setup complete!\n"));
+    logger.always(chalk.blue("Next steps:"));
+    logger.always("1. List models: " + chalk.gray("neurolink ollama list-models"));
+    logger.always("2. Generate text: " +
+        chalk.gray('neurolink generate "Hello!" --provider ollama'));
+    logger.always("3. Use specific model: " +
+        chalk.gray('neurolink generate "Hello!" --provider ollama --model codellama'));
+    logger.always(chalk.gray("\nFor more information, see: https://docs.neurolink.ai/providers/ollama"));
+}
+export default addOllamaCommands;

package/dist/cli/factories/ollamaCommandFactory.d.ts

@@ -3,6 +3,10 @@ import type { CommandModule } from "yargs";
  * Factory for creating Ollama CLI commands using the Factory Pattern
  */
 export declare class OllamaCommandFactory {
+    /**
+     * Secure wrapper around spawnSync to prevent command injection.
+     */
+    private static safeSpawn;
     /**
      * Create the Ollama command group
      */

package/dist/cli/factories/ollamaCommandFactory.js

@@ -1,12 +1,24 @@
-import { execSync } from "child_process";
+import { spawnSync, } from "child_process";
 import chalk from "chalk";
 import ora from "ora";
 import inquirer from "inquirer";
 import { logger } from "../../lib/utils/logger.js";
+import { OllamaUtils } from "../utils/ollamaUtils.js";
 /**
  * Factory for creating Ollama CLI commands using the Factory Pattern
  */
 export class OllamaCommandFactory {
+    /**
+     * Secure wrapper around spawnSync to prevent command injection.
+     */
+    static safeSpawn(command, args, options = {}) {
+        // Command validation is now handled by TypeScript with AllowedCommand type
+        const defaultOptions = {
+            ...options,
+            encoding: "utf8", // Always enforce utf8 encoding
+        };
+        return spawnSync(command, args, defaultOptions);
+    }
     /**
      * Create the Ollama command group
      */
@@ -46,9 +58,13 @@ export class OllamaCommandFactory {
     static async listModelsHandler() {
         const spinner = ora("Fetching installed models...").start();
         try {
-            const output = execSync("ollama list", { encoding: "utf8" });
+            const res = this.safeSpawn("ollama", ["list"]);
+            if (res.error || res.status !== 0) {
+                throw res.error || new Error(res.stderr);
+            }
             spinner.succeed("Installed models:");
-            if (output.trim()) {
+            const output = res.stdout.trim();
+            if (output) {
                 logger.always(output);
             }
             else {
@@ -71,7 +87,12 @@ export class OllamaCommandFactory {
         logger.always(chalk.blue(`Downloading model: ${model}`));
         logger.always(chalk.gray("This may take several minutes..."));
         try {
-            execSync(`ollama pull ${model}`, { stdio: "inherit" });
+            const res = this.safeSpawn("ollama", ["pull", model], {
+                stdio: "inherit",
+            });
+            if (res.error || res.status !== 0) {
+                throw res.error || new Error("pull failed");
+            }
             logger.always(chalk.green(`\n✅ Successfully downloaded ${model}`));
             logger.always(chalk.blue(`\nTest it with: npx @juspay/neurolink generate "Hello!" --provider ollama --model ${model}`));
         }
@@ -87,7 +108,6 @@ export class OllamaCommandFactory {
      */
     static async removeModelHandler(argv) {
         const { model } = argv;
-        // Confirm removal
         const { confirm } = await inquirer.prompt([
             {
                 type: "confirm",
@@ -102,7 +122,10 @@ export class OllamaCommandFactory {
         }
         const spinner = ora(`Removing model ${model}...`).start();
         try {
-            execSync(`ollama rm ${model}`, { encoding: "utf8" });
+            const res = this.safeSpawn("ollama", ["rm", model]);
+            if (res.error || res.status !== 0) {
+                throw res.error || new Error(res.stderr);
+            }
             spinner.succeed(`Successfully removed ${model}`);
         }
         catch (error) {
@@ -118,28 +141,50 @@ export class OllamaCommandFactory {
     static async statusHandler() {
         const spinner = ora("Checking Ollama service status...").start();
         try {
-            // Try to run a simple command
-            execSync("ollama list", { encoding: "utf8" });
+            const res = this.safeSpawn("ollama", ["list"]);
+            if (res.error || res.status !== 0) {
+                throw res.error || new Error(res.stderr);
+            }
             spinner.succeed("Ollama service is running");
-            // Get additional info
-            try {
-                const response = execSync("curl -s http://localhost:11434/api/tags", {
-                    encoding: "utf8",
-                });
-                const data = JSON.parse(response);
-                if (data.models && data.models.length > 0) {
-                    logger.always(chalk.green(`\n${data.models.length} models available`));
+            // Attempt to get model list with retry logic for JSON parsing
+            let modelsData = null;
+            for (let attempt = 1; attempt <= 3; attempt++) {
+                try {
+                    const curlRes = this.safeSpawn("curl", [
+                        "-s",
+                        "http://localhost:11434/api/tags",
+                    ]);
+                    if (!curlRes.error && curlRes.status === 0 && curlRes.stdout.trim()) {
+                        try {
+                            modelsData = JSON.parse(curlRes.stdout);
+                            break; // Success, exit retry loop
+                        }
+                        catch (jsonError) {
+                            logger.debug(`JSON parse failed on attempt ${attempt}: ${jsonError}`);
+                            if (attempt < 3) {
+                                // Brief delay before retry
+                                await new Promise((resolve) => setTimeout(resolve, 500));
+                                continue;
+                            }
+                            // Final attempt failed, log warning but don't throw
+                            logger.debug("Failed to parse Ollama API response after 3 attempts");
+                        }
+                    }
+                }
+                catch (curlError) {
+                    logger.debug(`Curl failed on attempt ${attempt}: ${curlError}`);
+                    if (attempt < 3) {
+                        await new Promise((resolve) => setTimeout(resolve, 500));
+                    }
                 }
             }
-            catch (error) {
-                // Curl might not be available, that's ok. Error is ignored.
-                logger.debug &&
-                    logger.debug("Optional curl command failed in statusHandler:", error);
+            // Display model count if we got valid data
+            if (modelsData?.models && modelsData.models.length > 0) {
+                logger.always(chalk.green(`\n${modelsData.models.length} models available`));
             }
         }
-        catch (error) {
+        catch (_error) {
             spinner.fail("Ollama service is not running");
-            logger.debug && logger.debug("Ollama status check failed:", error);
             logger.always(chalk.yellow("\nStart Ollama with: ollama serve"));
             logger.always(chalk.blue("Or restart the Ollama app if using the desktop version"));
             process.exit(1);
@@ -149,59 +194,7 @@ export class OllamaCommandFactory {
      * Handler for starting Ollama service
      */
     static async startHandler() {
-        logger.always(chalk.blue("Starting Ollama service..."));
-        try {
-            // Check if already running
-            try {
-                execSync("ollama list", { encoding: "utf8" });
-                logger.always(chalk.yellow("Ollama service is already running!"));
-                return;
-            }
-            catch {
-                // Not running, continue to start
-            }
-            // Different approaches for different platforms
-            if (process.platform === "darwin") {
-                // macOS
-                logger.always(chalk.gray("Starting Ollama on macOS..."));
-                try {
-                    execSync("open -a Ollama");
-                    logger.always(chalk.green("✅ Ollama app started"));
-                }
-                catch {
-                    // Try service command
-                    execSync("ollama serve > /dev/null 2>&1 &", { stdio: "ignore" });
-                    logger.always(chalk.green("✅ Ollama service started"));
-                }
-            }
-            else if (process.platform === "linux") {
-                // Linux
-                logger.always(chalk.gray("Starting Ollama service on Linux..."));
-                try {
-                    execSync("systemctl start ollama", { encoding: "utf8" });
-                    logger.always(chalk.green("✅ Ollama service started"));
-                }
-                catch {
-                    // Try direct command
-                    execSync("ollama serve > /dev/null 2>&1 &", { stdio: "ignore" });
-                    logger.always(chalk.green("✅ Ollama service started"));
-                }
-            }
-            else {
-                // Windows
-                logger.always(chalk.gray("Starting Ollama on Windows..."));
-                execSync("start ollama serve", { stdio: "ignore" });
-                logger.always(chalk.green("✅ Ollama service started"));
-            }
-            logger.always(chalk.blue("\nWait a few seconds for the service to initialize..."));
-        }
-        catch (error) {
-            logger.error(chalk.red("Failed to start Ollama service"));
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.error(chalk.red("Error:", errorMessage));
-            logger.always(chalk.blue("\nTry starting Ollama manually or check installation"));
-            process.exit(1);
-        }
+        await OllamaUtils.startOllamaService();
     }
     /**
      * Handler for stopping Ollama service
@@ -210,26 +203,23 @@ export class OllamaCommandFactory {
         const spinner = ora("Stopping Ollama service...").start();
         try {
             if (process.platform === "darwin") {
-                // macOS
                 try {
-                    execSync("pkill ollama", { encoding: "utf8" });
+                    this.safeSpawn("pkill", ["ollama"]);
                 }
                 catch {
-                    execSync("killall Ollama", { encoding: "utf8" });
+                    this.safeSpawn("killall", ["Ollama"]);
                 }
             }
             else if (process.platform === "linux") {
-                // Linux
                 try {
-                    execSync("systemctl stop ollama", { encoding: "utf8" });
+                    this.safeSpawn("systemctl", ["stop", "ollama"]);
                 }
                 catch {
-                    execSync("pkill ollama", { encoding: "utf8" });
+                    this.safeSpawn("pkill", ["ollama"]);
                 }
             }
             else {
-                // Windows
-                execSync("taskkill /F /IM ollama.exe", { encoding: "utf8" });
+                this.safeSpawn("taskkill", ["/F", "/IM", "ollama.exe"]);
             }
             spinner.succeed("Ollama service stopped");
         }
@@ -244,13 +234,17 @@ export class OllamaCommandFactory {
      */
     static async setupHandler() {
         logger.always(chalk.blue("🦙 Welcome to Ollama Setup!\n"));
-        // Check if Ollama is installed
         const checkSpinner = ora("Checking Ollama installation...").start();
         let isInstalled = false;
         try {
-            execSync("ollama --version", { encoding: "utf8" });
-            isInstalled = true;
-            checkSpinner.succeed("Ollama is installed");
+            const res = this.safeSpawn("ollama", ["--version"]);
+            if (!res.error && res.status === 0) {
+                isInstalled = true;
+                checkSpinner.succeed("Ollama is installed");
+            }
+            else {
+                throw new Error(res.stderr);
+            }
         }
         catch {
             checkSpinner.fail("Ollama is not installed");
@@ -284,12 +278,13 @@ export class OllamaCommandFactory {
                 return;
             }
         }
-        // Check if service is running
         let serviceRunning = false;
         try {
-            execSync("ollama list", { encoding: "utf8" });
-            serviceRunning = true;
-            logger.always(chalk.green("\n✅ Ollama service is running"));
+            const res = this.safeSpawn("ollama", ["list"]);
+            if (!res.error && res.status === 0) {
+                serviceRunning = true;
+                logger.always(chalk.green("\n✅ Ollama service is running"));
+            }
         }
         catch {
             logger.always(chalk.yellow("\n⚠️  Ollama service is not running"));
@@ -307,7 +302,6 @@ export class OllamaCommandFactory {
             }
         }
         if (serviceRunning) {
-            // List available models
             logger.always(chalk.blue("\n📦 Popular Ollama models:"));
             logger.always("  • llama2 (7B) - General purpose");
             logger.always("  • codellama (7B) - Code generation");
@@ -362,7 +356,6 @@ export class OllamaCommandFactory {
                 await this.pullModelHandler({ model: modelToDownload });
             }
         }
-        // Final instructions
         logger.always(chalk.green("\n✅ Setup complete!\n"));
         logger.always(chalk.blue("Next steps:"));
         logger.always("1. List models: " + chalk.gray("neurolink ollama list-models"));

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

@@ -0,0 +1,24 @@
+import { type SpawnSyncReturns, type SpawnSyncOptions } from "child_process";
+type AllowedCommand = "ollama" | "curl" | "systemctl" | "pkill" | "killall" | "open" | "taskkill" | "start";
+/**
+ * Shared Ollama utilities for CLI commands
+ */
+export declare class OllamaUtils {
+    /**
+     * Secure wrapper around spawnSync to prevent command injection.
+     */
+    static safeSpawn(command: AllowedCommand, args: string[], options?: SpawnSyncOptions): SpawnSyncReturns<string>;
+    /**
+     * Wait for Ollama service to become ready with exponential backoff
+     */
+    static waitForOllamaReady(maxAttempts?: number, initialDelay?: number): Promise<boolean>;
+    /**
+     * Check if Ollama service is already running
+     */
+    static isOllamaRunning(): boolean;
+    /**
+     * Unified Ollama start logic that works across platforms
+     */
+    static startOllamaService(): Promise<void>;
+}
+export {};