@rama_nigg/open-cursor 2.3.16 → 2.3.17

package/dist/index.js

@@ -31001,7 +31001,7 @@ function registerDefaultTools(registry3) {
         },
         timeout: {
           type: "number",
-          description: "Timeout in milliseconds (default: 30000)"
+          description: "Timeout in seconds (default: 30)"
         },
         cwd: {
           type: "string",
@@ -31012,24 +31012,44 @@ function registerDefaultTools(registry3) {
     },
     source: "local"
   }, async (args) => {
-    const { exec } = await import("child_process");
-    const { promisify } = await import("util");
-    const execAsync = promisify(exec);
-    try {
-      const command = resolveBashCommand(args);
-      if (!command) {
-        throw new Error("bash: missing required argument 'command'");
-      }
-      const timeout = resolveTimeout(args.timeout);
-      const cwd = resolveWorkingDirectory(args);
-      const { stdout, stderr } = await execAsync(command, {
-        timeout: timeout ?? 30000,
+    const { spawn: spawn3 } = await import("child_process");
+    const command = resolveBashCommand(args);
+    if (!command) {
+      throw new Error("bash: missing required argument 'command'");
+    }
+    const timeoutMs = resolveTimeoutMs(args.timeout);
+    const cwd = resolveWorkingDirectory(args);
+    return new Promise((resolve2, reject) => {
+      const proc = spawn3(command, {
+        shell: process.env.SHELL || "/bin/bash",
         cwd
       });
-      return stdout || stderr || "Command executed successfully";
-    } catch (error46) {
-      throw error46;
-    }
+      const stdoutChunks = [];
+      const stderrChunks = [];
+      let timedOut = false;
+      const timer = setTimeout(() => {
+        timedOut = true;
+        proc.kill("SIGTERM");
+      }, timeoutMs);
+      proc.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+      proc.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+      proc.on("close", (code) => {
+        clearTimeout(timer);
+        const stdout = Buffer.concat(stdoutChunks).toString("utf8");
+        const stderr = Buffer.concat(stderrChunks).toString("utf8");
+        const output = stdout || stderr || "Command executed successfully";
+        if (timedOut) {
+          resolve2(`Command timed out after ${timeoutMs / 1000}s
+${output}`);
+        } else if (code !== 0) {
+          resolve2(`${output}
+[Exit code: ${code}]`);
+        } else {
+          resolve2(output);
+        }
+      });
+      proc.on("error", reject);
+    });
   });
   registry3.register({
     id: "read",
@@ -31504,6 +31524,12 @@ function resolveTimeout(value) {
   }
   return;
 }
+function resolveTimeoutMs(value) {
+  const raw = resolveTimeout(value);
+  if (raw === undefined)
+    return 30000;
+  return raw <= 600 ? raw * 1000 : raw;
+}
 function resolveBoolean(value, defaultValue) {
   if (typeof value === "boolean") {
     return value;

package/dist/plugin-entry.js

@@ -31001,7 +31001,7 @@ function registerDefaultTools(registry3) {
         },
         timeout: {
           type: "number",
-          description: "Timeout in milliseconds (default: 30000)"
+          description: "Timeout in seconds (default: 30)"
         },
         cwd: {
           type: "string",
@@ -31012,24 +31012,44 @@ function registerDefaultTools(registry3) {
     },
     source: "local"
   }, async (args) => {
-    const { exec } = await import("child_process");
-    const { promisify } = await import("util");
-    const execAsync = promisify(exec);
-    try {
-      const command = resolveBashCommand(args);
-      if (!command) {
-        throw new Error("bash: missing required argument 'command'");
-      }
-      const timeout = resolveTimeout(args.timeout);
-      const cwd = resolveWorkingDirectory(args);
-      const { stdout, stderr } = await execAsync(command, {
-        timeout: timeout ?? 30000,
+    const { spawn: spawn3 } = await import("child_process");
+    const command = resolveBashCommand(args);
+    if (!command) {
+      throw new Error("bash: missing required argument 'command'");
+    }
+    const timeoutMs = resolveTimeoutMs(args.timeout);
+    const cwd = resolveWorkingDirectory(args);
+    return new Promise((resolve2, reject) => {
+      const proc = spawn3(command, {
+        shell: process.env.SHELL || "/bin/bash",
         cwd
       });
-      return stdout || stderr || "Command executed successfully";
-    } catch (error46) {
-      throw error46;
-    }
+      const stdoutChunks = [];
+      const stderrChunks = [];
+      let timedOut = false;
+      const timer = setTimeout(() => {
+        timedOut = true;
+        proc.kill("SIGTERM");
+      }, timeoutMs);
+      proc.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+      proc.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+      proc.on("close", (code) => {
+        clearTimeout(timer);
+        const stdout = Buffer.concat(stdoutChunks).toString("utf8");
+        const stderr = Buffer.concat(stderrChunks).toString("utf8");
+        const output = stdout || stderr || "Command executed successfully";
+        if (timedOut) {
+          resolve2(`Command timed out after ${timeoutMs / 1000}s
+${output}`);
+        } else if (code !== 0) {
+          resolve2(`${output}
+[Exit code: ${code}]`);
+        } else {
+          resolve2(output);
+        }
+      });
+      proc.on("error", reject);
+    });
   });
   registry3.register({
     id: "read",
@@ -31504,6 +31524,12 @@ function resolveTimeout(value) {
   }
   return;
 }
+function resolveTimeoutMs(value) {
+  const raw = resolveTimeout(value);
+  if (raw === undefined)
+    return 30000;
+  return raw <= 600 ? raw * 1000 : raw;
+}
 function resolveBoolean(value, defaultValue) {
   if (typeof value === "boolean") {
     return value;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rama_nigg/open-cursor",
-  "version": "2.3.16",
+  "version": "2.3.17",
   "description": "No prompt limits. No broken streams. Full thinking + tool support. Your Cursor subscription, properly integrated.",
   "type": "module",
   "main": "dist/plugin-entry.js",

package/src/tools/defaults.ts

@@ -18,7 +18,7 @@ export function registerDefaultTools(registry: ToolRegistry): void {
         },
         timeout: {
           type: "number",
-          description: "Timeout in milliseconds (default: 30000)"
+          description: "Timeout in seconds (default: 30)"
         },
         cwd: {
           type: "string",
@@ -29,25 +29,49 @@ export function registerDefaultTools(registry: ToolRegistry): void {
     },
     source: "local" as const
   }, async (args) => {
-    const { exec } = await import("child_process");
-    const { promisify } = await import("util");
-    const execAsync = promisify(exec);
+    const { spawn } = await import("child_process");
 
-    try {
-      const command = resolveBashCommand(args);
-      if (!command) {
-        throw new Error("bash: missing required argument 'command'");
-      }
-      const timeout = resolveTimeout(args.timeout);
-      const cwd = resolveWorkingDirectory(args);
-      const { stdout, stderr } = await execAsync(command, {
-        timeout: timeout ?? 30000,
-        cwd: cwd
-      });
-      return stdout || stderr || "Command executed successfully";
-    } catch (error: any) {
-      throw error;
+    const command = resolveBashCommand(args);
+    if (!command) {
+      throw new Error("bash: missing required argument 'command'");
     }
+    const timeoutMs = resolveTimeoutMs(args.timeout);
+    const cwd = resolveWorkingDirectory(args);
+
+    return new Promise<string>((resolve, reject) => {
+      const proc = spawn(command, {
+        shell: process.env.SHELL || "/bin/bash",
+        cwd,
+      });
+
+      const stdoutChunks: Buffer[] = [];
+      const stderrChunks: Buffer[] = [];
+      let timedOut = false;
+
+      const timer = setTimeout(() => {
+        timedOut = true;
+        proc.kill("SIGTERM");
+      }, timeoutMs);
+
+      proc.stdout.on("data", (chunk: Buffer) => stdoutChunks.push(chunk));
+      proc.stderr.on("data", (chunk: Buffer) => stderrChunks.push(chunk));
+
+      proc.on("close", (code) => {
+        clearTimeout(timer);
+        const stdout = Buffer.concat(stdoutChunks).toString("utf8");
+        const stderr = Buffer.concat(stderrChunks).toString("utf8");
+        const output = stdout || stderr || "Command executed successfully";
+        if (timedOut) {
+          resolve(`Command timed out after ${timeoutMs / 1000}s\n${output}`);
+        } else if (code !== 0) {
+          resolve(`${output}\n[Exit code: ${code}]`);
+        } else {
+          resolve(output);
+        }
+      });
+
+      proc.on("error", reject);
+    });
   });
 
   // 2. Read tool - Read file contents
@@ -598,6 +622,14 @@ function resolveTimeout(value: unknown): number | undefined {
   return undefined;
 }
 
+// Convert model-supplied timeout (seconds) to milliseconds. Falls back to 30s.
+function resolveTimeoutMs(value: unknown): number {
+  const raw = resolveTimeout(value);
+  if (raw === undefined) return 30_000;
+  // Values ≤ 600 are treated as seconds (no real use case for a <600ms shell timeout).
+  return raw <= 600 ? raw * 1000 : raw;
+}
+
 function resolveBoolean(value: unknown, defaultValue: boolean): boolean {
   if (typeof value === "boolean") {
     return value;