ruvector 0.2.5 → 0.2.7

package/bin/cli.js

@@ -115,6 +115,76 @@ function loadGnn() {
   }
 }
 
+// ── Proxy-aware fetch wrapper ───────────────────────────────────────────────
+// Detects HTTP_PROXY / HTTPS_PROXY / ALL_PROXY env vars and routes traffic
+// through the proxy when configured.  Falls back to native fetch() when no
+// proxy is set or the target matches NO_PROXY.
+let _proxyDispatcherSet = false;
+
+function getProxyUrl(targetUrl) {
+  const NO_PROXY = process.env.NO_PROXY || process.env.no_proxy || '';
+  if (NO_PROXY === '*') return null;
+  if (NO_PROXY) {
+    try {
+      const host = new URL(targetUrl).hostname.toLowerCase();
+      const patterns = NO_PROXY.split(',').map(p => p.trim().toLowerCase());
+      for (const p of patterns) {
+        if (!p) continue;
+        if (host === p || host.endsWith(p.startsWith('.') ? p : '.' + p)) return null;
+      }
+    } catch {}
+  }
+  return process.env.HTTPS_PROXY || process.env.https_proxy
+      || process.env.HTTP_PROXY  || process.env.http_proxy
+      || process.env.ALL_PROXY   || process.env.all_proxy
+      || null;
+}
+
+async function proxyFetch(url, opts) {
+  const target = typeof url === 'string' ? url : url.toString();
+  const proxy = getProxyUrl(target);
+  if (!proxy) return fetch(url, opts);
+
+  // Try undici ProxyAgent (bundled in Node 18+)
+  if (!_proxyDispatcherSet) {
+    try {
+      const undici = require('undici');
+      if (undici.ProxyAgent && undici.setGlobalDispatcher) {
+        undici.setGlobalDispatcher(new undici.ProxyAgent(proxy));
+        _proxyDispatcherSet = true;
+      }
+    } catch {}
+  }
+  if (_proxyDispatcherSet) return fetch(url, opts);
+
+  // Fallback: shell out to curl (which natively respects proxy env vars)
+  const { execFileSync } = require('child_process');
+  const args = ['-sS', '-L', '--max-time', '30'];
+  if (opts && opts.method) { args.push('-X', opts.method); }
+  if (opts && opts.headers) {
+    for (const [k, v] of Object.entries(opts.headers)) {
+      args.push('-H', `${k}: ${v}`);
+    }
+  }
+  if (opts && opts.body) { args.push('-d', typeof opts.body === 'string' ? opts.body : JSON.stringify(opts.body)); }
+  args.push(target);
+  try {
+    const stdout = execFileSync('curl', args, { encoding: 'utf8', timeout: 35000 });
+    const body = stdout.trim();
+    return {
+      ok: true,
+      status: 200,
+      statusText: 'OK',
+      text: async () => body,
+      json: async () => JSON.parse(body),
+      headers: new Map(),
+    };
+  } catch (e) {
+    const msg = e.stderr ? e.stderr.toString().trim() : e.message;
+    throw new Error(`Proxy curl failed: ${msg}`);
+  }
+}
+
 // Lazy load Attention (optional - loaded on first use, not at startup)
 let _attentionModule = undefined;
 let DotProductAttention, MultiHeadAttention, HyperbolicAttention, FlashAttention, LinearAttention, MoEAttention;
@@ -7250,7 +7320,7 @@ async function getRvfManifest(opts = {}) {
 
   // Try GCS
   try {
-    const resp = await fetch(GCS_MANIFEST_URL);
+    const resp = await proxyFetch(GCS_MANIFEST_URL, { signal: AbortSignal.timeout(15000) });
     if (resp.ok) {
       const manifest = await resp.json();
       fs.mkdirSync(cacheDir, { recursive: true });
@@ -7851,19 +7921,9 @@ mcpCmd.command('test')
   });
 
 // ============================================================================
-// Brain Commands — Shared intelligence via @ruvector/pi-brain (lazy-loaded)
+// Brain Commands — Shared intelligence via pi.ruv.io REST API (direct fetch)
 // ============================================================================
 
-async function requirePiBrain() {
-  try {
-    return require('@ruvector/pi-brain');
-  } catch {
-    console.error(chalk.red('Brain commands require @ruvector/pi-brain'));
-    console.error(chalk.yellow('  npm install @ruvector/pi-brain'));
-    process.exit(1);
-  }
-}
-
 function getBrainConfig(opts) {
   return {
     url: opts.url || process.env.BRAIN_URL || 'https://pi.ruv.io',
@@ -7871,6 +7931,30 @@ function getBrainConfig(opts) {
   };
 }
 
+function brainHeaders(config) {
+  const h = { 'Content-Type': 'application/json' };
+  if (config.key) h['Authorization'] = `Bearer ${config.key}`;
+  return h;
+}
+
+async function brainFetch(config, endpoint, opts = {}) {
+  const url = new URL(endpoint, config.url);
+  if (opts.params) {
+    for (const [k, v] of Object.entries(opts.params)) {
+      if (v !== undefined && v !== null) url.searchParams.set(k, String(v));
+    }
+  }
+  const fetchOpts = { headers: brainHeaders(config), signal: AbortSignal.timeout(30000) };
+  if (opts.method) fetchOpts.method = opts.method;
+  if (opts.body) { fetchOpts.method = opts.method || 'POST'; fetchOpts.body = JSON.stringify(opts.body); }
+  const resp = await proxyFetch(url.toString(), fetchOpts);
+  if (!resp.ok) {
+    const errText = await resp.text().catch(() => resp.statusText);
+    throw new Error(`${resp.status} ${errText}`);
+  }
+  return resp.json();
+}
+
 const brainCmd = program.command('brain').description('Shared intelligence — search, share, and manage collective knowledge');
 
 brainCmd.command('search <query>')
@@ -7882,11 +7966,9 @@ brainCmd.command('search <query>')
   .option('--json', 'Output as JSON')
   .option('--verbose', 'Show detailed scoring and metadata per result')
   .action(async (query, opts) => {
-    const piBrain = await requirePiBrain();
     const config = getBrainConfig(opts);
     try {
-      const client = new piBrain.PiBrainClient(config);
-      const results = await client.search(query, { category: opts.category, limit: parseInt(opts.limit) });
+      const results = await brainFetch(config, '/v1/memories/search', { params: { q: query, category: opts.category, limit: opts.limit } });
       if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(results, null, 2)); return; }
       console.log(chalk.bold.cyan(`\nBrain Search: "${query}"\n`));
       if (!results.length) { console.log(chalk.dim('  No results found.\n')); return; }
@@ -7916,11 +7998,9 @@ brainCmd.command('share <title>')
   .option('--url <url>', 'Brain server URL')
   .option('--key <key>', 'Pi key')
   .action(async (title, opts) => {
-    const piBrain = await requirePiBrain();
     const config = getBrainConfig(opts);
     try {
-      const client = new piBrain.PiBrainClient(config);
-      const result = await client.share({ title, content: opts.content || title, category: opts.category, tags: opts.tags ? opts.tags.split(',').map(t => t.trim()) : [], code_snippet: opts.code });
+      const result = await brainFetch(config, '/v1/memories', { body: { title, content: opts.content || title, category: opts.category, tags: opts.tags ? opts.tags.split(',').map(t => t.trim()) : [], code_snippet: opts.code } });
       console.log(chalk.green(`Shared: ${result.id || 'OK'}`));
     } catch (e) { console.error(chalk.red(`Error: ${e.message}`)); process.exit(1); }
   });
@@ -7931,11 +8011,9 @@ brainCmd.command('get <id>')
   .option('--key <key>', 'Pi key')
   .option('--json', 'Output as JSON')
   .action(async (id, opts) => {
-    const piBrain = await requirePiBrain();
     const config = getBrainConfig(opts);
     try {
-      const client = new piBrain.PiBrainClient(config);
-      const result = await client.get(id);
+      const result = await brainFetch(config, `/v1/memories/${id}`);
       if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(result, null, 2)); return; }
       console.log(chalk.bold.cyan(`\nMemory: ${id}\n`));
       if (result.title) console.log(`  ${chalk.bold('Title:')} ${result.title}`);
@@ -7950,11 +8028,9 @@ brainCmd.command('vote <id> <direction>')
   .option('--url <url>', 'Brain server URL')
   .option('--key <key>', 'Pi key')
   .action(async (id, direction, opts) => {
-    const piBrain = await requirePiBrain();
     const config = getBrainConfig(opts);
     try {
-      const client = new piBrain.PiBrainClient(config);
-      await client.vote(id, direction);
+      await brainFetch(config, `/v1/memories/${id}/vote`, { body: { direction } });
       console.log(chalk.green(`Voted ${direction} on ${id}`));
     } catch (e) { console.error(chalk.red(`Error: ${e.message}`)); process.exit(1); }
   });
@@ -7966,16 +8042,21 @@ brainCmd.command('list')
   .option('--url <url>', 'Brain server URL')
   .option('--key <key>', 'Pi key')
   .option('--json', 'Output as JSON')
+  .option('--offset <n>', 'Skip first N results (pagination)', '0')
+  .option('--sort <field>', 'Sort by: updated_at, quality, votes', 'updated_at')
+  .option('--tags <tags>', 'Filter by tags (comma-separated)')
   .action(async (opts) => {
-    const piBrain = await requirePiBrain();
     const config = getBrainConfig(opts);
     try {
-      const client = new piBrain.PiBrainClient(config);
-      const results = await client.list({ category: opts.category, limit: parseInt(opts.limit) });
-      if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(results, null, 2)); return; }
+      const data = await brainFetch(config, '/v1/memories/list', { params: { category: opts.category, limit: opts.limit, offset: opts.offset, sort: opts.sort, tags: opts.tags } });
+      if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(data, null, 2)); return; }
       console.log(chalk.bold.cyan('\nShared Brain Memories\n'));
-      if (!results.length) { console.log(chalk.dim('  No memories found.\n')); return; }
-      results.forEach((r, i) => {
+      const memories = Array.isArray(data) ? data : data.memories || [];
+      if (data.total_count !== undefined) {
+        console.log(chalk.dim(`  Showing ${memories.length} of ${data.total_count} (offset ${data.offset || 0})\n`));
+      }
+      if (!memories.length) { console.log(chalk.dim('  No memories found.\n')); return; }
+      memories.forEach((r, i) => {
         console.log(`  ${chalk.yellow(i + 1 + '.')} ${chalk.bold(r.title || r.id)} ${chalk.dim(`[${r.category || 'unknown'}]`)}`);
       });
       console.log();
@@ -7987,11 +8068,9 @@ brainCmd.command('delete <id>')
   .option('--url <url>', 'Brain server URL')
   .option('--key <key>', 'Pi key')
   .action(async (id, opts) => {
-    const piBrain = await requirePiBrain();
     const config = getBrainConfig(opts);
     try {
-      const client = new piBrain.PiBrainClient(config);
-      await client.delete(id);
+      await brainFetch(config, `/v1/memories/${id}`, { method: 'DELETE' });
       console.log(chalk.green(`Deleted: ${id}`));
     } catch (e) { console.error(chalk.red(`Error: ${e.message}`)); process.exit(1); }
   });
@@ -8002,11 +8081,9 @@ brainCmd.command('status')
   .option('--key <key>', 'Pi key')
   .option('--json', 'Output as JSON')
   .action(async (opts) => {
-    const piBrain = await requirePiBrain();
     const config = getBrainConfig(opts);
     try {
-      const client = new piBrain.PiBrainClient(config);
-      const status = await client.status();
+      const status = await brainFetch(config, '/v1/status');
       if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(status, null, 2)); return; }
       console.log(chalk.bold.cyan('\nBrain Status\n'));
       Object.entries(status).forEach(([k, v]) => {
@@ -8037,11 +8114,9 @@ brainCmd.command('drift')
   .option('--key <key>', 'Pi key')
   .option('--json', 'Output as JSON')
   .action(async (opts) => {
-    const piBrain = await requirePiBrain();
     const config = getBrainConfig(opts);
     try {
-      const client = new piBrain.PiBrainClient(config);
-      const report = await client.drift({ domain: opts.domain });
+      const report = await brainFetch(config, '/v1/drift', { params: { domain: opts.domain } });
       if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(report, null, 2)); return; }
       console.log(chalk.bold.cyan('\nDrift Report\n'));
       console.log(`  ${chalk.bold('Drifting:')} ${report.is_drifting ? chalk.red('Yes') : chalk.green('No')}`);
@@ -8058,11 +8133,9 @@ brainCmd.command('partition')
   .option('--key <key>', 'Pi key')
   .option('--json', 'Output as JSON')
   .action(async (opts) => {
-    const piBrain = await requirePiBrain();
     const config = getBrainConfig(opts);
     try {
-      const client = new piBrain.PiBrainClient(config);
-      const result = await client.partition({ domain: opts.domain, min_cluster_size: parseInt(opts.minSize) });
+      const result = await brainFetch(config, '/v1/partition', { params: { domain: opts.domain, min_cluster_size: opts.minSize } });
       if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(result, null, 2)); return; }
       console.log(chalk.bold.cyan('\nKnowledge Partitions\n'));
       if (result.clusters) {
@@ -8080,11 +8153,9 @@ brainCmd.command('transfer <source> <target>')
   .option('--key <key>', 'Pi key')
   .option('--json', 'Output as JSON')
   .action(async (source, target, opts) => {
-    const piBrain = await requirePiBrain();
     const config = getBrainConfig(opts);
     try {
-      const client = new piBrain.PiBrainClient(config);
-      const result = await client.transfer(source, target);
+      const result = await brainFetch(config, '/v1/transfer', { body: { source_domain: source, target_domain: target } });
       if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(result, null, 2)); return; }
       console.log(chalk.green(`Transfer ${source} -> ${target}: ${result.status || 'OK'}`));
     } catch (e) { console.error(chalk.red(`Error: ${e.message}`)); process.exit(1); }
@@ -8095,11 +8166,9 @@ brainCmd.command('sync [direction]')
   .option('--url <url>', 'Brain server URL')
   .option('--key <key>', 'Pi key')
   .action(async (direction, opts) => {
-    const piBrain = await requirePiBrain();
     const config = getBrainConfig(opts);
     try {
-      const client = new piBrain.PiBrainClient(config);
-      const result = await client.sync(direction || 'both');
+      const result = await brainFetch(config, '/v1/lora/latest', { params: { direction: direction || 'both' } });
       console.log(chalk.green(`Sync ${direction || 'both'}: ${result.status || 'OK'}`));
     } catch (e) { console.error(chalk.red(`Error: ${e.message}`)); process.exit(1); }
   });
@@ -8110,30 +8179,28 @@ brainCmd.command('page <action> [args...]')
   .option('--key <key>', 'Pi key')
   .option('--json', 'Output as JSON')
   .action(async (action, args, opts) => {
-    const piBrain = await requirePiBrain();
     const config = getBrainConfig(opts);
     try {
-      const client = new piBrain.PiBrainClient(config);
       let result;
       switch (action) {
         case 'list':
-          result = await client.listPages ? client.listPages({ limit: 20 }) : { pages: [], message: 'Brainpedia not yet available on this server' };
+          result = await brainFetch(config, '/v1/pages', { params: { limit: 20 } }).catch(() => ({ pages: [], message: 'Brainpedia endpoint not available' }));
           break;
         case 'get':
           if (!args[0]) { console.error(chalk.red('Usage: brain page get <slug>')); process.exit(1); }
-          result = await client.getPage ? client.getPage(args[0]) : { error: 'Brainpedia not yet available' };
+          result = await brainFetch(config, `/v1/pages/${args[0]}`);
           break;
         case 'create':
           if (!args[0]) { console.error(chalk.red('Usage: brain page create <title> [--content <text>]')); process.exit(1); }
-          result = await client.createPage ? client.createPage({ title: args[0], content: opts.content || '' }) : { error: 'Brainpedia not yet available' };
+          result = await brainFetch(config, '/v1/pages', { body: { title: args[0], content: opts.content || '' } });
           break;
         case 'update':
           if (!args[0]) { console.error(chalk.red('Usage: brain page update <slug> [--content <text>]')); process.exit(1); }
-          result = await client.updatePage ? client.updatePage(args[0], { content: opts.content || '' }) : { error: 'Brainpedia not yet available' };
+          result = await brainFetch(config, `/v1/pages/${args[0]}/deltas`, { body: { content: opts.content || '' } });
           break;
         case 'delete':
           if (!args[0]) { console.error(chalk.red('Usage: brain page delete <slug>')); process.exit(1); }
-          result = await client.deletePage ? client.deletePage(args[0]) : { error: 'Brainpedia not yet available' };
+          result = await brainFetch(config, `/v1/pages/${args[0]}`, { method: 'DELETE' }).catch(() => ({ error: 'Delete not available' }));
           break;
         default:
           console.error(chalk.red(`Unknown page action: ${action}. Use: list, get, create, update, delete`));
@@ -8159,10 +8226,8 @@ brainCmd.command('node <action> [args...]')
   .option('--key <key>', 'Pi key')
   .option('--json', 'Output as JSON')
   .action(async (action, args, opts) => {
-    const piBrain = await requirePiBrain();
     const config = getBrainConfig(opts);
     try {
-      const client = new piBrain.PiBrainClient(config);
       let result;
       switch (action) {
         case 'publish':
@@ -8170,14 +8235,14 @@ brainCmd.command('node <action> [args...]')
           const wasmPath = path.resolve(args[0]);
           if (!fs.existsSync(wasmPath)) { console.error(chalk.red(`File not found: ${wasmPath}`)); process.exit(1); }
           const wasmBytes = fs.readFileSync(wasmPath);
-          result = await client.publishNode ? client.publishNode({ wasm: wasmBytes, name: path.basename(wasmPath, '.wasm') }) : { error: 'WASM node publish not yet available on this server' };
+          result = await brainFetch(config, '/v1/nodes', { body: { name: path.basename(wasmPath, '.wasm'), wasm_base64: wasmBytes.toString('base64') } });
           break;
         case 'list':
-          result = await client.listNodes ? client.listNodes({ limit: 20 }) : { nodes: [], message: 'WASM node listing not yet available' };
+          result = await brainFetch(config, '/v1/nodes', { params: { limit: 20 } }).catch(() => ({ nodes: [], message: 'WASM node listing not available' }));
           break;
         case 'status':
           if (!args[0]) { console.error(chalk.red('Usage: brain node status <node-id>')); process.exit(1); }
-          result = await client.nodeStatus ? client.nodeStatus(args[0]) : { error: 'WASM node status not yet available' };
+          result = await brainFetch(config, `/v1/nodes/${args[0]}`);
           break;
         default:
           console.error(chalk.red(`Unknown node action: ${action}. Use: publish, list, status`));
@@ -8203,7 +8268,7 @@ async function fetchBrainEndpoint(config, endpoint) {
   const url = (config.url || 'https://pi.ruv.io') + endpoint;
   const headers = {};
   if (config.key) headers['Authorization'] = `Bearer ${config.key}`;
-  const resp = await fetch(url, { headers });
+  const resp = await proxyFetch(url, { headers, signal: AbortSignal.timeout(30000) });
   if (!resp.ok) throw new Error(`${resp.status} ${resp.statusText}`);
   return resp.json();
 }
@@ -8432,7 +8497,7 @@ midstreamCmd.command('benchmark')
 
     async function timeRequest(url, label) {
       const start = performance.now();
-      const resp = await fetch(url, { headers });
+      const resp = await proxyFetch(url, { headers, signal: AbortSignal.timeout(30000) });
       const elapsed = performance.now() - start;
       return { label, status: resp.status, elapsed };
     }
@@ -8502,7 +8567,7 @@ edgeCmd.command('status')
   .option('--json', 'Output as JSON')
   .action(async (opts) => {
     try {
-      const resp = await fetch(`${EDGE_GENESIS}/status`);
+      const resp = await proxyFetch(`${EDGE_GENESIS}/status`, { signal: AbortSignal.timeout(30000) });
       const data = await resp.json();
       if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(data, null, 2)); return; }
       console.log(chalk.bold.cyan('\nEdge Network Status\n'));
@@ -8518,10 +8583,11 @@ edgeCmd.command('join')
     const piKey = process.env.PI;
     if (!piKey) { console.error(chalk.red('Set PI environment variable first. Run: npx ruvector identity generate')); process.exit(1); }
     try {
-      const resp = await fetch(`${EDGE_GENESIS}/join`, {
+      const resp = await proxyFetch(`${EDGE_GENESIS}/join`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${piKey}` },
-        body: JSON.stringify({ contribution: parseFloat(opts.contribution), pi_key: piKey })
+        body: JSON.stringify({ contribution: parseFloat(opts.contribution), pi_key: piKey }),
+        signal: AbortSignal.timeout(30000)
       });
       const data = await resp.json();
       console.log(chalk.green(`Joined edge network: ${data.node_id || 'OK'}`));
@@ -8536,7 +8602,7 @@ edgeCmd.command('balance')
     if (!piKey) { console.error(chalk.red('Set PI environment variable first.')); process.exit(1); }
     try {
       const pseudonym = require('crypto').createHash('shake256', { outputLength: 16 }).update(piKey).digest('hex');
-      const resp = await fetch(`${EDGE_GENESIS}/balance/${pseudonym}`, { headers: { 'Authorization': `Bearer ${piKey}` } });
+      const resp = await proxyFetch(`${EDGE_GENESIS}/balance/${pseudonym}`, { headers: { 'Authorization': `Bearer ${piKey}` }, signal: AbortSignal.timeout(30000) });
       if (!resp.ok) { console.error(chalk.red(`Edge network returned ${resp.status} ${resp.statusText}`)); process.exit(1); }
       const data = await resp.json();
       if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(data, null, 2)); return; }
@@ -8552,7 +8618,7 @@ edgeCmd.command('tasks')
   .option('--json', 'Output as JSON')
   .action(async (opts) => {
     try {
-      const resp = await fetch(`${EDGE_GENESIS}/tasks?limit=${opts.limit}`);
+      const resp = await proxyFetch(`${EDGE_GENESIS}/tasks?limit=${opts.limit}`, { signal: AbortSignal.timeout(30000) });
       const data = await resp.json();
       if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(data, null, 2)); return; }
       console.log(chalk.bold.cyan('\nEdge Compute Tasks\n'));

package/bin/mcp-server.js

@@ -95,6 +95,71 @@ function sanitizeNumericArg(arg, defaultVal) {
   return Number.isFinite(n) && n > 0 ? n : (defaultVal || 0);
 }
 
+// ── Proxy-aware fetch wrapper ───────────────────────────────────────────────
+let _proxyDispatcherSet = false;
+
+function getProxyUrl(targetUrl) {
+  const NO_PROXY = process.env.NO_PROXY || process.env.no_proxy || '';
+  if (NO_PROXY === '*') return null;
+  if (NO_PROXY) {
+    try {
+      const host = new URL(targetUrl).hostname.toLowerCase();
+      const patterns = NO_PROXY.split(',').map(p => p.trim().toLowerCase());
+      for (const p of patterns) {
+        if (!p) continue;
+        if (host === p || host.endsWith(p.startsWith('.') ? p : '.' + p)) return null;
+      }
+    } catch {}
+  }
+  return process.env.HTTPS_PROXY || process.env.https_proxy
+      || process.env.HTTP_PROXY  || process.env.http_proxy
+      || process.env.ALL_PROXY   || process.env.all_proxy
+      || null;
+}
+
+async function proxyFetch(url, opts) {
+  const target = typeof url === 'string' ? url : url.toString();
+  const proxy = getProxyUrl(target);
+  if (!proxy) return fetch(url, opts);
+
+  if (!_proxyDispatcherSet) {
+    try {
+      const undici = require('undici');
+      if (undici.ProxyAgent && undici.setGlobalDispatcher) {
+        undici.setGlobalDispatcher(new undici.ProxyAgent(proxy));
+        _proxyDispatcherSet = true;
+      }
+    } catch {}
+  }
+  if (_proxyDispatcherSet) return fetch(url, opts);
+
+  const { execFileSync } = require('child_process');
+  const args = ['-sS', '-L', '--max-time', '30'];
+  if (opts && opts.method) { args.push('-X', opts.method); }
+  if (opts && opts.headers) {
+    for (const [k, v] of Object.entries(opts.headers)) {
+      args.push('-H', `${k}: ${v}`);
+    }
+  }
+  if (opts && opts.body) { args.push('-d', typeof opts.body === 'string' ? opts.body : JSON.stringify(opts.body)); }
+  args.push(target);
+  try {
+    const stdout = execFileSync('curl', args, { encoding: 'utf8', timeout: 35000 });
+    const body = stdout.trim();
+    return {
+      ok: true,
+      status: 200,
+      statusText: 'OK',
+      text: async () => body,
+      json: async () => JSON.parse(body),
+      headers: new Map(),
+    };
+  } catch (e) {
+    const msg = e.stderr ? e.stderr.toString().trim() : e.message;
+    throw new Error(`Proxy curl failed: ${msg}`);
+  }
+}
+
 // Try to load the full IntelligenceEngine
 let IntelligenceEngine = null;
 let engineAvailable = false;
@@ -363,7 +428,7 @@ class Intelligence {
 const server = new Server(
   {
     name: 'ruvector',
-    version: '0.2.5',
+    version: '0.2.7',
   },
   {
     capabilities: {
@@ -3122,7 +3187,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         // Fetch from GCS if no fresh cache
         if (!manifest) {
           try {
-            const resp = await fetch(GCS_MANIFEST);
+            const resp = await proxyFetch(GCS_MANIFEST, { signal: AbortSignal.timeout(15000) });
             if (resp.ok) {
               manifest = await resp.json();
               try {
@@ -3276,7 +3341,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
       }
 
-      // ── Brain Tool Handlers ──────────────────────────────────────────────
+      // ── Brain Tool Handlers (direct fetch to pi.ruv.io) ─────────────────
       case 'brain_search':
       case 'brain_share':
       case 'brain_get':
@@ -3289,31 +3354,78 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case 'brain_transfer':
       case 'brain_sync': {
         try {
-          const { PiBrainClient } = require('@ruvector/pi-brain');
-          const client = new PiBrainClient({
-            url: process.env.BRAIN_URL || 'https://pi.ruv.io',
-            key: process.env.PI
-          });
+          const brainUrl = process.env.BRAIN_URL || 'https://pi.ruv.io';
+          const brainKey = process.env.PI;
+          const hdrs = { 'Content-Type': 'application/json' };
+          if (brainKey) hdrs['Authorization'] = `Bearer ${brainKey}`;
           const subCmd = name.replace('brain_', '');
-          let result;
+          let url, fetchOpts = { headers: hdrs, signal: AbortSignal.timeout(30000) };
           switch (subCmd) {
-            case 'search': result = await client.search(args.query, { category: args.category, limit: args.limit || 10 }); break;
-            case 'share': result = await client.share({ title: args.title, content: args.content, category: args.category, tags: args.tags ? args.tags.split(',').map(t => t.trim()) : [], code_snippet: args.code_snippet }); break;
-            case 'get': result = await client.get(args.id); break;
-            case 'vote': result = await client.vote(args.id, args.direction); break;
-            case 'list': result = await client.list({ category: args.category, limit: args.limit || 20 }); break;
-            case 'delete': result = await client.delete(args.id); break;
-            case 'status': result = await client.status(); break;
-            case 'drift': result = await client.drift({ domain: args.domain }); break;
-            case 'partition': result = await client.partition({ domain: args.domain, min_cluster_size: args.min_cluster_size }); break;
-            case 'transfer': result = await client.transfer(args.source_domain, args.target_domain); break;
-            case 'sync': result = await client.sync(args.direction || 'both'); break;
+            case 'search': {
+              const p = new URLSearchParams({ q: args.query || '' });
+              if (args.category) p.set('category', args.category);
+              if (args.limit) p.set('limit', String(args.limit));
+              url = `${brainUrl}/v1/memories/search?${p}`;
+              break;
+            }
+            case 'share': {
+              url = `${brainUrl}/v1/memories`;
+              fetchOpts.method = 'POST';
+              fetchOpts.body = JSON.stringify({ title: args.title, content: args.content, category: args.category, tags: args.tags ? args.tags.split(',').map(t => t.trim()) : [], code_snippet: args.code_snippet });
+              break;
+            }
+            case 'get': url = `${brainUrl}/v1/memories/${args.id}`; break;
+            case 'vote': {
+              url = `${brainUrl}/v1/memories/${args.id}/vote`;
+              fetchOpts.method = 'POST';
+              fetchOpts.body = JSON.stringify({ direction: args.direction });
+              break;
+            }
+            case 'list': {
+              const p = new URLSearchParams();
+              if (args.category) p.set('category', args.category);
+              p.set('limit', String(args.limit || 20));
+              if (args.offset) p.set('offset', String(args.offset));
+              if (args.sort) p.set('sort', args.sort);
+              if (args.tags) p.set('tags', args.tags);
+              url = `${brainUrl}/v1/memories/list?${p}`;
+              break;
+            }
+            case 'delete': {
+              url = `${brainUrl}/v1/memories/${args.id}`;
+              fetchOpts.method = 'DELETE';
+              break;
+            }
+            case 'status': url = `${brainUrl}/v1/status`; break;
+            case 'drift': {
+              const p = new URLSearchParams();
+              if (args.domain) p.set('domain', args.domain);
+              url = `${brainUrl}/v1/drift?${p}`;
+              break;
+            }
+            case 'partition': {
+              const p = new URLSearchParams();
+              if (args.domain) p.set('domain', args.domain);
+              if (args.min_cluster_size) p.set('min_cluster_size', String(args.min_cluster_size));
+              url = `${brainUrl}/v1/partition?${p}`;
+              break;
+            }
+            case 'transfer': {
+              url = `${brainUrl}/v1/transfer`;
+              fetchOpts.method = 'POST';
+              fetchOpts.body = JSON.stringify({ source_domain: args.source_domain, target_domain: args.target_domain });
+              break;
+            }
+            case 'sync': url = `${brainUrl}/v1/lora/latest`; break;
           }
+          const resp = await proxyFetch(url, fetchOpts);
+          if (!resp.ok) {
+            const errText = await resp.text().catch(() => resp.statusText);
+            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: `${resp.status} ${errText}` }, null, 2) }], isError: true };
+          }
+          const result = await resp.json();
           return { content: [{ type: 'text', text: JSON.stringify({ success: true, ...result }, null, 2) }] };
         } catch (e) {
-          if (e.code === 'MODULE_NOT_FOUND') {
-            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'Brain tools require @ruvector/pi-brain. Install with: npm install @ruvector/pi-brain' }, null, 2) }], isError: true };
-          }
           return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }], isError: true };
         }
       }
@@ -3340,7 +3452,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             brain_flags: '/v1/status',
           };
           const endpoint = endpointMap[name];
-          const resp = await fetch(`${brainUrl}${endpoint}`, { headers: hdrs });
+          const resp = await proxyFetch(`${brainUrl}${endpoint}`, { headers: hdrs, signal: AbortSignal.timeout(30000) });
           if (!resp.ok) {
             const errText = await resp.text().catch(() => resp.statusText);
             return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: `${resp.status} ${errText}` }, null, 2) }], isError: true };
@@ -3384,7 +3496,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           const hdrs = { 'Content-Type': 'application/json' };
           if (brainKey) hdrs['Authorization'] = `Bearer ${brainKey}`;
 
-          const resp = await fetch(`${brainUrl}/v1/midstream`, { headers: hdrs });
+          const resp = await proxyFetch(`${brainUrl}/v1/midstream`, { headers: hdrs, signal: AbortSignal.timeout(30000) });
           if (!resp.ok) {
             const errText = await resp.text().catch(() => resp.statusText);
             return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: `${resp.status} ${errText}` }, null, 2) }], isError: true };
@@ -3414,7 +3526,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
           async function timeFetch(url) {
             const start = performance.now();
-            const resp = await fetch(url, { headers: hdrs });
+            const resp = await proxyFetch(url, { headers: hdrs });
             return { status: resp.status, elapsed: performance.now() - start };
           }
 
@@ -3467,7 +3579,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           if (brainKey) hdrs['Authorization'] = `Bearer ${brainKey}`;
           const limit = Math.min(Math.max(parseInt(args.limit) || 10, 1), 100);
           const q = encodeURIComponent(args.query);
-          const resp = await fetch(`${brainUrl}/v1/memories/search?q=${q}&limit=${limit}`, { headers: hdrs });
+          const resp = await proxyFetch(`${brainUrl}/v1/memories/search?q=${q}&limit=${limit}`, { headers: hdrs, signal: AbortSignal.timeout(30000) });
           if (!resp.ok) {
             const errText = await resp.text().catch(() => resp.statusText);
             return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: `${resp.status} ${errText}` }, null, 2) }], isError: true };
@@ -3487,8 +3599,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           if (brainKey) hdrs['Authorization'] = `Bearer ${brainKey}`;
 
           const [healthResp, midResp] = await Promise.all([
-            fetch(`${brainUrl}/v1/health`, { headers: hdrs }).then(r => r.json()).catch(e => ({ error: e.message })),
-            fetch(`${brainUrl}/v1/midstream`, { headers: hdrs }).then(r => r.json()).catch(e => ({ error: e.message })),
+            proxyFetch(`${brainUrl}/v1/health`, { headers: hdrs, signal: AbortSignal.timeout(15000) }).then(r => r.json()).catch(e => ({ error: e.message })),
+            proxyFetch(`${brainUrl}/v1/midstream`, { headers: hdrs, signal: AbortSignal.timeout(15000) }).then(r => r.json()).catch(e => ({ error: e.message })),
           ]);
 
           return { content: [{ type: 'text', text: JSON.stringify({
@@ -3516,7 +3628,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case 'balance': { const ps = process.env.PI ? require('crypto').createHash('shake256', { outputLength: 16 }).update(process.env.PI).digest('hex') : 'anonymous'; endpoint = `/balance/${ps}`; break; }
             case 'tasks': endpoint = `/tasks?limit=${args.limit || 20}`; break;
           }
-          const resp = await fetch(`${genesisUrl}${endpoint}`, {
+          const resp = await proxyFetch(`${genesisUrl}${endpoint}`, {
             method,
             headers: { 'Content-Type': 'application/json', ...(process.env.PI ? { 'Authorization': `Bearer ${process.env.PI}` } : {}) },
             ...(body ? { body } : {})
@@ -3787,7 +3899,7 @@ async function main() {
           transport: 'sse',
           sessions: sessions.size,
           tools: 91,
-          version: '0.2.5'
+          version: '0.2.7'
         }));
 
       } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvector",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "High-performance vector database for Node.js with automatic native/WASM fallback",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -80,12 +80,10 @@
     "typescript": "^5.3.3"
   },
   "peerDependencies": {
-    "@ruvector/pi-brain": ">=0.1.0",
     "@ruvector/ruvllm": ">=2.0.0",
     "@ruvector/router": ">=0.1.0"
   },
   "peerDependenciesMeta": {
-    "@ruvector/pi-brain": { "optional": true },
     "@ruvector/ruvllm": { "optional": true },
     "@ruvector/router": { "optional": true }
   },