@juspay/neurolink 9.88.0 → 9.88.2

package/dist/cli/commands/config.js

@@ -50,7 +50,7 @@ const ConfigSchema = z.object({
             sessionToken: z.string().optional(),
             model: z
                 .string()
-                .default("arn:aws:bedrock:us-east-2:225681119357:inference-profile/us.anthropic.claude-3-7-sonnet-20250219-v1:0"),
+                .default("arn:aws:bedrock:us-east-2:123456789012:inference-profile/us.anthropic.claude-3-7-sonnet-20250219-v1:0"),
         })
             .optional(),
         vertex: z
@@ -582,7 +582,7 @@ export class ConfigManager {
                 type: "input",
                 name: "model",
                 message: "Model ARN:",
-                default: "arn:aws:bedrock:us-east-2:225681119357:inference-profile/us.anthropic.claude-3-7-sonnet-20250219-v1:0",
+                default: "arn:aws:bedrock:us-east-2:123456789012:inference-profile/us.anthropic.claude-3-7-sonnet-20250219-v1:0",
             },
         ]);
         this.config.providers.bedrock = {

package/dist/lib/agent/directTools.d.ts

@@ -56,6 +56,12 @@ export declare const directAgentTools: {
         path: string;
         includeHidden: boolean;
     }, {
+        success: boolean;
+        error: string;
+        path?: undefined;
+        items?: undefined;
+        count?: undefined;
+    } | {
         success: boolean;
         path: string;
         items: {

package/dist/lib/agent/directTools.js

@@ -14,6 +14,28 @@ function truncateOutput(output) {
     }
     return output;
 }
+/**
+ * Contain a built-in file tool to the process working directory.
+ *
+ * Returns the resolved absolute path when it lies inside `process.cwd()`, or an
+ * `error` string otherwise. This is the sandbox for the default-enabled
+ * `readFile` / `writeFile` / `listDirectory` / `analyzeCSV` tools: without it an
+ * agent can pass an absolute path (`/etc/passwd`) or `../` traversal and reach
+ * arbitrary files. The previous guard (`!resolvedPath.startsWith(cwd) &&
+ * !path.isAbsolute(filePath)`) was always false for absolute paths, so it never
+ * fired. The `cwd + path.sep` suffix prevents a sibling-prefix bypass
+ * (`/home/app` vs `/home/app-evil`).
+ */
+function resolveWithinCwd(filePath) {
+    const resolvedPath = path.resolve(filePath);
+    const cwd = path.resolve(process.cwd());
+    if (resolvedPath !== cwd && !resolvedPath.startsWith(cwd + path.sep)) {
+        return {
+            error: `Access denied: "${filePath}" resolves outside the working directory`,
+        };
+    }
+    return { path: resolvedPath };
+}
 // Runtime Google Search tool creation - bypasses TypeScript strict typing
 function createGoogleSearchTools() {
     const searchTool = {};
@@ -71,15 +93,13 @@ export const directAgentTools = {
         }),
         execute: async ({ path: filePath }) => {
             try {
-                // Security check - prevent reading outside current directory for relative paths
-                const resolvedPath = path.resolve(filePath);
-                const cwd = process.cwd();
-                if (!resolvedPath.startsWith(cwd) && !path.isAbsolute(filePath)) {
-                    return {
-                        success: false,
-                        error: `Access denied: Cannot read files outside current directory`,
-                    };
+                // Sandbox: contain reads to the working directory (blocks absolute-path
+                // escape and ../ traversal).
+                const guard = resolveWithinCwd(filePath);
+                if ("error" in guard) {
+                    return { success: false, error: guard.error };
                 }
+                const resolvedPath = guard.path;
                 const content = fs.readFileSync(resolvedPath, "utf-8");
                 const stats = fs.statSync(resolvedPath);
                 return {
@@ -113,7 +133,12 @@ export const directAgentTools = {
         }),
         execute: async ({ path: dirPath, includeHidden }) => {
             try {
-                const resolvedPath = path.resolve(dirPath);
+                // Sandbox: contain directory listing to the working directory.
+                const guard = resolveWithinCwd(dirPath);
+                if ("error" in guard) {
+                    return { success: false, error: guard.error };
+                }
+                const resolvedPath = guard.path;
                 const items = fs.readdirSync(resolvedPath);
                 const filteredItems = includeHidden
                     ? items
@@ -229,15 +254,13 @@ export const directAgentTools = {
         }),
         execute: async ({ path: filePath, content, mode }) => {
             try {
-                const resolvedPath = path.resolve(filePath);
-                const cwd = process.cwd();
-                // Security check
-                if (!resolvedPath.startsWith(cwd) && !path.isAbsolute(filePath)) {
-                    return {
-                        success: false,
-                        error: `Access denied: Cannot write files outside current directory`,
-                    };
+                // Sandbox: contain writes to the working directory (blocks absolute-path
+                // escape and ../ traversal).
+                const guard = resolveWithinCwd(filePath);
+                if ("error" in guard) {
+                    return { success: false, error: guard.error };
                 }
+                const resolvedPath = guard.path;
                 // Check if file exists for create mode
                 if (mode === "create" && fs.existsSync(resolvedPath)) {
                     return {
@@ -326,11 +349,12 @@ export const directAgentTools = {
             try {
                 // Resolve file path
                 logger.debug(`[analyzeCSV] Resolving file: ${filePath}`);
-                const path = await import("path");
-                // Resolve path (support both relative and absolute)
-                const resolvedPath = path.isAbsolute(filePath)
-                    ? filePath
-                    : path.resolve(process.cwd(), filePath);
+                // Sandbox: contain CSV reads to the working directory.
+                const guard = resolveWithinCwd(filePath);
+                if ("error" in guard) {
+                    return { success: false, error: guard.error };
+                }
+                const resolvedPath = guard.path;
                 logger.debug(`[analyzeCSV] Resolved path: ${resolvedPath}`);
                 // Parse CSV using streaming from disk (memory efficient)
                 logger.info(`[analyzeCSV] Starting CSV parsing (max ${maxRows} rows)...`);

package/dist/lib/types/multimodal.js

@@ -115,17 +115,25 @@ function isDirectorSegment(segment) {
     return false;
 }
 export function isMultimodalInput(input) {
-    const maybeInput = input;
-    return !!(maybeInput?.images?.length ||
-        maybeInput?.csvFiles?.length ||
-        maybeInput?.pdfFiles?.length ||
-        maybeInput?.files?.length ||
-        maybeInput?.content?.length ||
-        maybeInput?.audioFiles?.length ||
-        maybeInput?.videoFiles?.length ||
-        (maybeInput?.segments?.length &&
-            Array.isArray(maybeInput.segments) &&
-            maybeInput.segments.every(isDirectorSegment)));
+    if (typeof input !== "object" || input === null) {
+        return false;
+    }
+    const m = input;
+    // Each field must be a NON-EMPTY ARRAY. Checking `.length` alone is unsafe:
+    // a string value (e.g. `{ images: "oops" }`) has a truthy `.length`, so the
+    // old guard would claim a malformed input is multimodal and then crash
+    // downstream when the field is iterated as an array.
+    const hasItems = (v) => Array.isArray(v) && v.length > 0;
+    return !!(hasItems(m.images) ||
+        hasItems(m.csvFiles) ||
+        hasItems(m.pdfFiles) ||
+        hasItems(m.files) ||
+        hasItems(m.content) ||
+        hasItems(m.audioFiles) ||
+        hasItems(m.videoFiles) ||
+        (Array.isArray(m.segments) &&
+            m.segments.length > 0 &&
+            m.segments.every(isDirectorSegment)));
 }
 /**
  * Type guard to check if message content is multimodal (array)

package/dist/types/multimodal.js

@@ -115,17 +115,25 @@ function isDirectorSegment(segment) {
     return false;
 }
 export function isMultimodalInput(input) {
-    const maybeInput = input;
-    return !!(maybeInput?.images?.length ||
-        maybeInput?.csvFiles?.length ||
-        maybeInput?.pdfFiles?.length ||
-        maybeInput?.files?.length ||
-        maybeInput?.content?.length ||
-        maybeInput?.audioFiles?.length ||
-        maybeInput?.videoFiles?.length ||
-        (maybeInput?.segments?.length &&
-            Array.isArray(maybeInput.segments) &&
-            maybeInput.segments.every(isDirectorSegment)));
+    if (typeof input !== "object" || input === null) {
+        return false;
+    }
+    const m = input;
+    // Each field must be a NON-EMPTY ARRAY. Checking `.length` alone is unsafe:
+    // a string value (e.g. `{ images: "oops" }`) has a truthy `.length`, so the
+    // old guard would claim a malformed input is multimodal and then crash
+    // downstream when the field is iterated as an array.
+    const hasItems = (v) => Array.isArray(v) && v.length > 0;
+    return !!(hasItems(m.images) ||
+        hasItems(m.csvFiles) ||
+        hasItems(m.pdfFiles) ||
+        hasItems(m.files) ||
+        hasItems(m.content) ||
+        hasItems(m.audioFiles) ||
+        hasItems(m.videoFiles) ||
+        (Array.isArray(m.segments) &&
+            m.segments.length > 0 &&
+            m.segments.every(isDirectorSegment)));
 }
 /**
  * Type guard to check if message content is multimodal (array)

package/package.json

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