mindforge-sdk 11.0.0 → 11.7.0

package/README.md

@@ -64,7 +64,7 @@ if (!valid) console.error(errors);
 - The SDK operates on local files and provides no network authentication. Do not expose SDK
   endpoints to the public internet.
 
-## New in v11.0.0
+## New in v11.7.0
 
 ### Additional exports
 
@@ -73,7 +73,7 @@ import {
   MindForgeClient,
   MindForgeEventStream,
   WebSocketEventStream,
-  VERSION,              // '11.0.0'
+  VERSION,              // '11.7.0'
 } from 'mindforge-sdk';
 
 import type {
@@ -102,11 +102,34 @@ for await (const chunk of stream) {
 
 ### Batch execution
 
+Runs commands concurrently (semaphore-bounded by `maxConcurrency`, default 3). Each
+task's `command` is the executable and `options.args` is a **string array** — it is NOT a
+shell string. Commands run with `shell: false`, so arguments are passed directly to the
+process and are safe from shell injection.
+
 ```typescript
-const results = await client.batchExecute([
-  { phase: 1, taskId: 'task-a' },
-  { phase: 1, taskId: 'task-b' },
-], { concurrency: 4 });
+const batch = await client.batchExecute({
+  tasks: [
+    { id: 'task-a', command: 'node', options: { args: ['--version'] } },
+    { id: 'task-b', command: 'git',  options: { args: ['rev-parse', 'HEAD'] } },
+  ],
+  maxConcurrency: 4,
+});
+
+for (const entry of batch.results) {
+  if (entry.status === 'fulfilled') {
+    // entry.result is { stdout, stderr, exitCode }
+    const { stdout, stderr, exitCode } = entry.result as {
+      stdout: string; stderr: string; exitCode: number;
+    };
+    console.log(`${entry.taskId} exited ${exitCode}: ${stdout.trim()}`);
+  } else {
+    // entry.status === 'rejected'
+    console.error(`${entry.taskId} failed: ${entry.error}`);
+  }
+}
+
+console.log(`batch finished in ${batch.totalDurationMs}ms`);
 ```
 
 ### Runtime config validation

package/dist/client.js

@@ -38,6 +38,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MindForgeClient = void 0;
 const events_1 = require("events");
+const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const events_2 = require("./events");
@@ -235,7 +236,8 @@ class MindForgeClient extends events_1.EventEmitter {
         await eventSource.connect();
         const chunks = [];
         let resolveNext = null;
-        eventSource.on('stream_chunk', (data) => {
+        eventSource.on('stream_chunk', (raw) => {
+            const data = raw; // socket payload is untyped JSON; narrow at the boundary
             if (resolveNext) {
                 resolveNext({ value: data, done: data.type === 'done' });
                 resolveNext = null;
@@ -307,8 +309,42 @@ class MindForgeClient extends events_1.EventEmitter {
             errors.push('taskTimeoutMs must be positive');
         return { valid: errors.length === 0, errors };
     }
-    async executeCommand(command, options) {
-        return { command, options, executed: true };
+    executeCommand(command, options) {
+        const args = Array.isArray(options?.args) ? options.args : [];
+        const cwd = options?.cwd ?? this.projectRoot;
+        const timeoutMs = this.config.taskTimeoutMs;
+        return new Promise((resolve, reject) => {
+            const child = (0, child_process_1.spawn)(command, args, { cwd, shell: false });
+            let stdout = '';
+            let stderr = '';
+            let settled = false;
+            const timer = setTimeout(() => {
+                if (settled)
+                    return;
+                child.kill('SIGTERM');
+                setTimeout(() => { if (!child.killed)
+                    child.kill('SIGKILL'); }, 2000).unref();
+                settled = true;
+                reject(new Error(`Command timed out after ${timeoutMs}ms: ${command}`));
+            }, timeoutMs);
+            timer.unref();
+            child.stdout?.on('data', (d) => { stdout += d.toString(); });
+            child.stderr?.on('data', (d) => { stderr += d.toString(); });
+            child.on('error', (err) => {
+                if (settled)
+                    return;
+                clearTimeout(timer);
+                settled = true;
+                reject(err);
+            });
+            child.on('close', (code) => {
+                if (settled)
+                    return;
+                clearTimeout(timer);
+                settled = true;
+                resolve({ stdout, stderr, exitCode: code ?? -1 });
+            });
+        });
     }
 }
 exports.MindForgeClient = MindForgeClient;

package/dist/events.d.ts

@@ -25,6 +25,7 @@ export declare class MindForgeEventStream {
      */
     stop(): void;
 }
+type EventHandler = (data: unknown) => void;
 export declare class WebSocketEventStream {
     private url;
     private ws;
@@ -33,7 +34,8 @@ export declare class WebSocketEventStream {
     private listeners;
     constructor(url?: string);
     connect(): Promise<void>;
-    on(eventType: string, handler: (data: any) => void): void;
-    off(eventType: string, handler: (data: any) => void): void;
+    on(eventType: string, handler: EventHandler): void;
+    off(eventType: string, handler: EventHandler): void;
     disconnect(): void;
 }
+export {};

package/dist/events.js

@@ -202,7 +202,7 @@ class WebSocketEventStream {
             this.ws.onerror = (err) => reject(err);
             this.ws.onmessage = (event) => {
                 try {
-                    const parsed = JSON.parse(event.data.toString());
+                    const parsed = JSON.parse(String(event.data));
                     const handlers = this.listeners.get(parsed.type) || new Set();
                     handlers.forEach(handler => handler(parsed.data));
                 }

package/dist/index.d.ts

@@ -8,4 +8,4 @@ export { commands, batch } from './commands';
 export { MindForgeMemory } from './memory';
 export type { CommandOptions } from './commands';
 export type { MindForgeConfig, PhaseResult, TaskResult, SecurityFinding, GateResult, HealthReport, HealthIssue, MindForgeEvent, AuditLogEntry, WaveExecutionResult, MigrationResult, StreamChunk, StreamingExecutionResult, BatchExecutionRequest, BatchExecutionResult, } from './types';
-export declare const VERSION = "11.0.0";
+export declare const VERSION = "11.7.0";

package/dist/index.js

@@ -15,4 +15,4 @@ Object.defineProperty(exports, "commands", { enumerable: true, get: function ()
 Object.defineProperty(exports, "batch", { enumerable: true, get: function () { return commands_1.batch; } });
 var memory_1 = require("./memory");
 Object.defineProperty(exports, "MindForgeMemory", { enumerable: true, get: function () { return memory_1.MindForgeMemory; } });
-exports.VERSION = '11.0.0';
+exports.VERSION = '11.7.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindforge-sdk",
-  "version": "11.0.0",
+  "version": "11.7.0",
   "description": "MindForge SDK \u2014 Programmatic API for embedding MindForge in tools",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -20,9 +20,10 @@
   },
   "scripts": {
     "build": "tsc",
-    "test": "node tests/sdk.test.js",
+    "pretest": "npm run build",
+    "test": "node tests/sdk.test.js && node tests/execute-command.test.js",
     "lint": "eslint .",
-    "prepublishOnly": "npm run build && npm test"
+    "prepublishOnly": "npm test"
   },
   "keywords": [
     "mindforge",