promethios-bridge 1.5.1 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "promethios-bridge",
-  "version": "1.5.1",
+  "version": "1.6.0",
   "description": "Run Promethios agent frameworks locally on your computer with full file, terminal, browser access, and Native Framework Mode (run OpenClaw and other frameworks in their native interface via the bridge).",
   "main": "src/index.js",
   "bin": {

package/src/executor.js

@@ -15,11 +15,46 @@
  */
 
 const fs = require('fs').promises;
+const fsSync = require('fs');
 const path = require('path');
+const os = require('os');
 const { execSync, exec } = require('child_process');
 const { promisify } = require('util');
 const execAsync = promisify(exec);
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Custom Tool Registry
+// Tools the agent invents at runtime are stored here and persisted to disk.
+// ─────────────────────────────────────────────────────────────────────────────
+
+const CUSTOM_TOOLS_DIR = path.join(os.homedir(), '.promethios');
+const CUSTOM_TOOLS_FILE = path.join(CUSTOM_TOOLS_DIR, 'custom_tools.json');
+
+// In-memory registry: { [toolName]: { name, description, parameters, type, implementation, createdAt } }
+if (!global.__customToolRegistry) {
+  global.__customToolRegistry = {};
+  // Load persisted tools on first require
+  try {
+    if (fsSync.existsSync(CUSTOM_TOOLS_FILE)) {
+      const saved = JSON.parse(fsSync.readFileSync(CUSTOM_TOOLS_FILE, 'utf8'));
+      Object.assign(global.__customToolRegistry, saved);
+      const count = Object.keys(saved).length;
+      if (count > 0) console.log(`[Bridge] Loaded ${count} custom tool(s) from ${CUSTOM_TOOLS_FILE}`);
+    }
+  } catch (e) {
+    console.warn('[Bridge] Could not load custom tools:', e.message);
+  }
+}
+
+function saveCustomToolRegistry() {
+  try {
+    fsSync.mkdirSync(CUSTOM_TOOLS_DIR, { recursive: true });
+    fsSync.writeFileSync(CUSTOM_TOOLS_FILE, JSON.stringify(global.__customToolRegistry, null, 2), 'utf8');
+  } catch (e) {
+    console.warn('[Bridge] Could not save custom tools:', e.message);
+  }
+}
+
 async function executeLocalTool({ toolName, args, frameworkId, dev }) {
   const log = dev ? (...a) => console.log('[executor]', ...a) : () => {};
 
@@ -45,6 +80,79 @@ async function executeLocalTool({ toolName, args, frameworkId, dev }) {
   if (toolName === 'local_browser_control') {
     return executeLocalTool({ toolName: 'browser_control', args, frameworkId, dev });
   }
+  if (toolName === 'local_create_folder') {
+    return executeLocalTool({ toolName: 'create_folder', args, frameworkId, dev });
+  }
+  if (toolName === 'local_move') {
+    return executeLocalTool({ toolName: 'move_path', args, frameworkId, dev });
+  }
+  if (toolName === 'local_copy') {
+    return executeLocalTool({ toolName: 'copy_path', args, frameworkId, dev });
+  }
+  if (toolName === 'local_delete') {
+    return executeLocalTool({ toolName: 'delete_path', args, frameworkId, dev });
+  }
+  if (toolName === 'local_define_tool') {
+    return executeLocalTool({ toolName: 'define_tool', args, frameworkId, dev });
+  }
+  if (toolName === 'local_list_tools') {
+    return executeLocalTool({ toolName: 'list_tools', args, frameworkId, dev });
+  }
+  if (toolName === 'local_remove_tool') {
+    return executeLocalTool({ toolName: 'remove_tool', args, frameworkId, dev });
+  }
+
+  // ── Dynamic dispatch: check custom tool registry before the built-in switch ──
+  if (global.__customToolRegistry[toolName]) {
+    const toolDef = global.__customToolRegistry[toolName];
+    log(`Dispatching custom tool: ${toolName} (type=${toolDef.type})`);
+
+    if (toolDef.type === 'shell') {
+      // Level 1: shell template — substitute {param} placeholders with args values
+      let cmd = toolDef.implementation;
+      for (const [key, val] of Object.entries(args || {})) {
+        // Escape the value for shell safety (basic quoting)
+        const safe = String(val).replace(/"/g, '\\"');
+        cmd = cmd.replace(new RegExp(`\\{${key}\\}`, 'g'), safe);
+      }
+      log(`Custom shell tool cmd: ${cmd}`);
+      const timeoutMs = 30_000;
+      const { stdout, stderr } = await execAsync(cmd, {
+        timeout: timeoutMs,
+        cwd: args.cwd ? resolveSafePath(args.cwd) : os.homedir(),
+        maxBuffer: 1024 * 1024,
+      });
+      return { stdout: stdout.trim(), stderr: stderr.trim(), exitCode: 0, toolName };
+    }
+
+    if (toolDef.type === 'js') {
+      // Level 2: JS function body — run in vm sandbox
+      const vm = require('vm');
+      const context = vm.createContext({
+        args: { ...args },
+        fetch,
+        require,
+        process: { env: process.env, platform: process.platform },
+        console,
+        Buffer,
+        URL,
+        URLSearchParams,
+        crypto: require('crypto'),
+        fs: require('fs').promises,
+        path: require('path'),
+        os: require('os'),
+        execAsync,
+        resolveSafePath,
+        result: undefined,
+      });
+      const script = new vm.Script(`(async () => { ${toolDef.implementation} })().then(r => { result = r; });`);
+      await script.runInContext(context);
+      await new Promise(r => setTimeout(r, 200));
+      return context.result !== undefined ? context.result : { success: true, toolName };
+    }
+
+    throw new Error(`Custom tool "${toolName}" has unknown type: ${toolDef.type}. Expected 'shell' or 'js'.`);
+  }
 
   // ── local_execute is the built-in tool injected by the backend when the bridge
   //    is connected. It uses an `action` field to dispatch to the right handler.
@@ -410,6 +518,68 @@ async function executeLocalTool({ toolName, args, frameworkId, dev }) {
       };
     }
 
+    // ── File management ────────────────────────────────────────────────────────────
+    case 'create_folder': {
+      const folderPath = resolveSafePath(args.path);
+      log('create_folder', folderPath);
+      await fs.mkdir(folderPath, { recursive: true });
+      return { success: true, path: folderPath, created: true };
+    }
+
+    case 'move_path': {
+      const srcPath = resolveSafePath(args.src);
+      const dstPath = resolveSafePath(args.dst);
+      log('move_path', srcPath, '->', dstPath);
+      // Ensure destination parent directory exists
+      await fs.mkdir(path.dirname(dstPath), { recursive: true });
+      await fs.rename(srcPath, dstPath);
+      return { success: true, src: srcPath, dst: dstPath };
+    }
+
+    case 'copy_path': {
+      const srcPath = resolveSafePath(args.src);
+      const dstPath = resolveSafePath(args.dst);
+      log('copy_path', srcPath, '->', dstPath);
+      // Ensure destination parent directory exists
+      await fs.mkdir(path.dirname(dstPath), { recursive: true });
+      // Check if source is a directory
+      const srcStat = await fs.stat(srcPath);
+      if (srcStat.isDirectory()) {
+        // Recursive directory copy
+        async function copyDir(src, dst) {
+          await fs.mkdir(dst, { recursive: true });
+          const entries = await fs.readdir(src, { withFileTypes: true });
+          for (const entry of entries) {
+            const srcEntry = path.join(src, entry.name);
+            const dstEntry = path.join(dst, entry.name);
+            if (entry.isDirectory()) {
+              await copyDir(srcEntry, dstEntry);
+            } else {
+              await fs.copyFile(srcEntry, dstEntry);
+            }
+          }
+        }
+        await copyDir(srcPath, dstPath);
+        return { success: true, src: srcPath, dst: dstPath, type: 'directory' };
+      } else {
+        await fs.copyFile(srcPath, dstPath);
+        return { success: true, src: srcPath, dst: dstPath, type: 'file' };
+      }
+    }
+
+    case 'delete_path': {
+      const targetPath = resolveSafePath(args.path);
+      log('delete_path', targetPath);
+      const targetStat = await fs.stat(targetPath);
+      if (targetStat.isDirectory()) {
+        await fs.rm(targetPath, { recursive: true, force: true });
+        return { success: true, path: targetPath, type: 'directory' };
+      } else {
+        await fs.unlink(targetPath);
+        return { success: true, path: targetPath, type: 'file' };
+      }
+    }
+
     // ── Browser ────────────────────────────────────────────────────────────────────
     case 'open_browser': {
       const url = args.url;
@@ -553,6 +723,75 @@ async function executeLocalTool({ toolName, args, frameworkId, dev }) {
       }
     }
 
+    // ── Dynamic tool synthesis ───────────────────────────────────────────────────────────────
+    case 'define_tool': {
+      const { name: tName, description: tDesc, parameters: tParams, type: tType, implementation: tImpl } = args;
+      if (!tName) throw new Error('name is required');
+      if (!tType || !['shell', 'js'].includes(tType)) throw new Error('type must be "shell" or "js"');
+      if (!tImpl) throw new Error('implementation is required');
+      // Validate tool name: lowercase alphanumeric + underscores only
+      if (!/^[a-z][a-z0-9_]*$/.test(tName)) {
+        throw new Error(`Tool name "${tName}" is invalid. Use lowercase letters, numbers, and underscores only (must start with a letter).`);
+      }
+      // Prevent overwriting built-in tools
+      const RESERVED = ['local_shell','local_file_read','local_file_write','local_file_read_binary',
+        'local_file_upload_to_thread','local_browser_control','local_create_folder','local_move',
+        'local_copy','local_delete','local_define_tool','local_list_tools','local_remove_tool'];
+      if (RESERVED.includes(tName)) throw new Error(`Cannot redefine built-in tool: ${tName}`);
+
+      const toolEntry = {
+        name: tName,
+        description: tDesc || '',
+        parameters: tParams || { type: 'object', properties: {}, required: [] },
+        type: tType,
+        implementation: tImpl,
+        createdAt: new Date().toISOString(),
+      };
+      global.__customToolRegistry[tName] = toolEntry;
+      saveCustomToolRegistry();
+      log(`Defined custom tool: ${tName} (type=${tType})`);
+      return {
+        success: true,
+        toolName: tName,
+        type: tType,
+        message: `Tool "${tName}" registered successfully. You can now call it directly by name.`,
+        totalCustomTools: Object.keys(global.__customToolRegistry).length,
+      };
+    }
+
+    case 'list_tools': {
+      const tools = Object.values(global.__customToolRegistry);
+      if (tools.length === 0) {
+        return { tools: [], message: 'No custom tools defined yet. Use local_define_tool to create one.' };
+      }
+      return {
+        tools: tools.map(t => ({
+          name: t.name,
+          description: t.description,
+          type: t.type,
+          parameters: t.parameters,
+          createdAt: t.createdAt,
+        })),
+        count: tools.length,
+        message: `${tools.length} custom tool(s) available: ${tools.map(t => t.name).join(', ')}`,
+      };
+    }
+
+    case 'remove_tool': {
+      const { name: rName } = args;
+      if (!rName) throw new Error('name is required');
+      if (!global.__customToolRegistry[rName]) {
+        return { success: false, message: `Tool "${rName}" not found in custom registry.` };
+      }
+      delete global.__customToolRegistry[rName];
+      saveCustomToolRegistry();
+      return {
+        success: true,
+        message: `Tool "${rName}" removed from registry.`,
+        totalCustomTools: Object.keys(global.__customToolRegistry).length,
+      };
+    }
+
     // ── Custom tool (developer-written code from framework definition) ────
     case 'custom':
     default: {