@evomap/evolver 1.90.0 → 2.0.0-beta.0

package/src/gep/portable.js

@@ -1,103 +0,0 @@
-// Portable .gepx archive export (CommonJS).
-// Mirrors @evomap/gep-sdk exportGepx semantics: gzip-tar the local GEP assets
-// (genes / capsules / events / memory graph) plus a manifest and sha256
-// checksums so the archive is self-describing.
-//
-// Kept intentionally minimal (no import path): evolver sync uses this to bundle
-// "everything locally known about this agent" so a user can hand the single
-// file to another machine or keep a point-in-time snapshot.
-const { execFileSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-const crypto = require('crypto');
-
-function countJsonlLines(filePath) {
-  if (!fs.existsSync(filePath)) return 0;
-  return fs.readFileSync(filePath, 'utf8').split('\n').filter((l) => l.trim()).length;
-}
-
-function countJsonItems(filePath, key) {
-  if (!fs.existsSync(filePath)) return 0;
-  try {
-    const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-    return Array.isArray(data[key]) ? data[key].length : 0;
-  } catch {
-    return 0;
-  }
-}
-
-function exportGepx({ assetsDir, memoryGraphPath, outputPath, agentId, agentName }) {
-  if (!assetsDir) throw new Error('exportGepx: assetsDir required');
-  if (!outputPath) throw new Error('exportGepx: outputPath required');
-
-  const outDir = path.dirname(path.resolve(outputPath));
-  if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
-
-  const tmpDir = `${outputPath}.tmp`;
-  if (fs.existsSync(tmpDir)) fs.rmSync(tmpDir, { recursive: true, force: true });
-  fs.mkdirSync(path.join(tmpDir, 'genes'), { recursive: true });
-  fs.mkdirSync(path.join(tmpDir, 'capsules'), { recursive: true });
-  fs.mkdirSync(path.join(tmpDir, 'events'), { recursive: true });
-  fs.mkdirSync(path.join(tmpDir, 'memory'), { recursive: true });
-
-  const filesToCopy = [
-    { src: path.join(assetsDir, 'genes.json'), dest: path.join(tmpDir, 'genes', 'genes.json') },
-    { src: path.join(assetsDir, 'genes.jsonl'), dest: path.join(tmpDir, 'genes', 'genes.jsonl') },
-    { src: path.join(assetsDir, 'capsules.json'), dest: path.join(tmpDir, 'capsules', 'capsules.json') },
-    { src: path.join(assetsDir, 'capsules.jsonl'), dest: path.join(tmpDir, 'capsules', 'capsules.jsonl') },
-    { src: path.join(assetsDir, 'events.jsonl'), dest: path.join(tmpDir, 'events', 'events.jsonl') },
-  ];
-  if (memoryGraphPath) {
-    filesToCopy.push({ src: memoryGraphPath, dest: path.join(tmpDir, 'memory', 'memory_graph.jsonl') });
-  }
-
-  const checksums = [];
-  for (const f of filesToCopy) {
-    if (!fs.existsSync(f.src)) continue;
-    const content = fs.readFileSync(f.src);
-    fs.mkdirSync(path.dirname(f.dest), { recursive: true });
-    fs.writeFileSync(f.dest, content);
-    const hash = crypto.createHash('sha256').update(content).digest('hex');
-    checksums.push(`${hash}  ${path.relative(tmpDir, f.dest).replace(/\\/g, '/')}`);
-  }
-
-  const stats = {
-    total_events: countJsonlLines(path.join(tmpDir, 'events', 'events.jsonl')),
-    total_genes: countJsonItems(path.join(tmpDir, 'genes', 'genes.json'), 'genes'),
-    total_capsules: countJsonItems(path.join(tmpDir, 'capsules', 'capsules.json'), 'capsules'),
-    memory_graph_entries: memoryGraphPath
-      ? countJsonlLines(path.join(tmpDir, 'memory', 'memory_graph.jsonl'))
-      : 0,
-  };
-
-  const manifest = {
-    gep_version: '1.0.0',
-    created_at: new Date().toISOString(),
-    agent_id: agentId || null,
-    agent_name: agentName || 'unknown',
-    statistics: stats,
-    source: { platform: 'evolver', component: 'sync' },
-  };
-
-  fs.writeFileSync(path.join(tmpDir, 'manifest.json'), JSON.stringify(manifest, null, 2) + '\n');
-  fs.writeFileSync(path.join(tmpDir, 'checksum.sha256'), checksums.join('\n') + '\n');
-
-  try {
-    // Run tar from inside tmpDir with a relative output path so no absolute
-    // Windows paths (e.g. "C:\...") are passed to tar. GNU tar on Windows
-    // (Git for Windows) misparses "C:" as a remote hostname when it appears
-    // in the -czf argument, causing "Cannot connect to C: resolve failed".
-    // Since tmpDir = outputPath + ".tmp" they share the same parent, so the
-    // relative output path is always "../<basename>".
-    const relOut = path.join('..', path.basename(outputPath));
-    execFileSync('tar', ['-czf', relOut, '.'], { cwd: tmpDir, timeout: 60000 });
-  } catch (err) {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-    throw new Error(`tar failed: ${err.message}. Ensure tar is available on your system.`);
-  }
-  fs.rmSync(tmpDir, { recursive: true, force: true });
-
-  return { outputPath, manifest };
-}
-
-module.exports = { exportGepx };

package/src/gep/privacyClient.js

@@ -1,235 +0,0 @@
-// ---------------------------------------------------------------------------
-// privacyClient -- Hub privacy computing API client.
-// Handles encrypted blob upload, sealed tool registration/execution,
-// status polling, and result retrieval.
-// ---------------------------------------------------------------------------
-
-const { getNodeId, buildHubHeaders, buildNodeScopedHubHeaders } = require('./a2aProtocol');
-const { generateKey, encrypt, decrypt, pack, unpack } = require('./crypto');
-const { resolveHubUrl } = require('../config');
-const { hubFetch } = require('./hubFetch');
-
-const PRIVACY_TIMEOUT_MS = 15000;
-
-function buildPrivacyNodeHeaders() {
-  const buildHeaders = buildNodeScopedHubHeaders || buildHubHeaders;
-  return buildHeaders();
-}
-
-function privacyUrl(path) {
-  return `${resolveHubUrl().replace(/\/+$/, '')}/a2a/privacy${path}`;
-}
-
-function privacyNodeUrl(path) {
-  const nodeId = getNodeId();
-  if (!nodeId) return null;
-  const sep = path.includes('?') ? '&' : '?';
-  return privacyUrl(path) + sep + 'node_id=' + encodeURIComponent(nodeId);
-}
-
-/**
- * Submit a privacy computing task to Hub.
- * @param {{ title: string, body?: string, signals?: string }} opts
- * @returns {{ taskId: string, status: string } | null}
- */
-async function submitPrivacyTask(opts) {
-  const nodeId = getNodeId();
-  if (!nodeId) return null;
-
-  try {
-    const res = await hubFetch(privacyUrl('/submit'), {
-      method: 'POST',
-      headers: Object.assign({ 'Content-Type': 'application/json' }, buildPrivacyNodeHeaders() || {}),
-      body: JSON.stringify({ ...opts, node_id: nodeId }),
-      signal: AbortSignal.timeout(PRIVACY_TIMEOUT_MS),
-    });
-    if (!res.ok) return null;
-    return await res.json();
-  } catch (err) {
-    console.warn('[PrivacyClient] submitPrivacyTask failed:', err?.message || err);
-    return null;
-  }
-}
-
-/**
- * Encrypt data locally and upload the encrypted blob to Hub.
- * Returns the blobId and the local key (caller must store the key).
- * @param {Buffer|string} plaintext
- * @param {{ privacyTaskId: string, label?: string }} opts
- * @returns {{ blobId: string, key: Buffer, iv: Buffer, authTag: Buffer } | null}
- */
-async function uploadEncryptedBlob(plaintext, opts) {
-  const nodeId = getNodeId();
-  if (!nodeId || !opts?.privacyTaskId) return null;
-
-  try {
-    const key = generateKey();
-    const parts = encrypt(plaintext, key);
-    const packed = pack(parts);
-
-    const body = JSON.stringify({
-      node_id: nodeId,
-      privacy_task_id: opts.privacyTaskId,
-      label: opts.label || 'blob',
-      data_base64: packed.toString('base64'),
-      encryption: 'aes-256-gcm',
-    });
-
-    const res = await hubFetch(privacyUrl('/blob/upload'), {
-      method: 'POST',
-      headers: Object.assign({ 'Content-Type': 'application/json' }, buildPrivacyNodeHeaders() || {}),
-      body,
-      signal: AbortSignal.timeout(PRIVACY_TIMEOUT_MS),
-    });
-    if (!res.ok) return null;
-    const resp = await res.json();
-    return {
-      blobId: resp.blob_id || resp.blobId,
-      key,
-      iv: parts.iv,
-      authTag: parts.authTag,
-    };
-  } catch (err) {
-    console.warn('[PrivacyClient] uploadEncryptedBlob failed:', err?.message || err);
-    return null;
-  }
-}
-
-/**
- * Execute a sealed tool on a previously uploaded blob.
- * @param {{ toolId: string, blobId: string }} opts
- * @returns {{ resultKey?: string, resultHash?: string, error?: string } | null}
- */
-async function executeSealedTool(opts) {
-  const nodeId = getNodeId();
-  if (!nodeId || !opts?.toolId || !opts?.blobId) return null;
-
-  try {
-    const res = await hubFetch(privacyUrl('/tool/execute'), {
-      method: 'POST',
-      headers: Object.assign({ 'Content-Type': 'application/json' }, buildPrivacyNodeHeaders() || {}),
-      body: JSON.stringify({
-        toolId: opts.toolId,
-        blobId: opts.blobId,
-        node_id: nodeId,
-      }),
-      signal: AbortSignal.timeout(30000),
-    });
-    if (!res.ok) {
-      const errBody = await res.json().catch(() => ({}));
-      return { error: errBody.error || `http_${res.status}` };
-    }
-    return await res.json();
-  } catch (err) {
-    console.warn('[PrivacyClient] executeSealedTool failed:', err?.message || err);
-    return { error: err?.message || 'network_error' };
-  }
-}
-
-/**
- * Check status of a privacy task.
- * @param {string} taskId
- * @returns {{ status: string, progress?: number } | null}
- */
-async function getPrivacyStatus(taskId) {
-  if (!taskId) return null;
-  try {
-    const url = privacyNodeUrl(`/status/${encodeURIComponent(taskId)}`);
-    if (!url) return null;
-    const res = await hubFetch(url, {
-      headers: buildPrivacyNodeHeaders(),
-      signal: AbortSignal.timeout(PRIVACY_TIMEOUT_MS),
-    });
-    if (!res.ok) return null;
-    return await res.json();
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Retrieve the encrypted result of a privacy task and decrypt it locally.
- * @param {string} taskId
- * @param {Buffer} key - the original encryption key
- * @returns {{ plaintext: Buffer, resultHash?: string } | null}
- */
-async function getPrivacyResult(taskId, key) {
-  if (!taskId || !key) return null;
-  try {
-    const url = privacyNodeUrl(`/result/${encodeURIComponent(taskId)}`);
-    if (!url) return null;
-    const res = await hubFetch(url, {
-      headers: buildPrivacyNodeHeaders(),
-      signal: AbortSignal.timeout(PRIVACY_TIMEOUT_MS),
-    });
-    if (!res.ok) return null;
-    const data = await res.json();
-    if (!data.encrypted_result_base64) return null;
-
-    const packed = Buffer.from(data.encrypted_result_base64, 'base64');
-    const parts = unpack(packed);
-    const plaintext = decrypt(parts.ciphertext, key, parts.iv, parts.authTag);
-    return { plaintext, resultHash: data.result_hash };
-  } catch (err) {
-    console.warn('[PrivacyClient] getPrivacyResult failed:', err?.message || err);
-    return null;
-  }
-}
-
-/**
- * List available sealed tool templates.
- * @returns {Array | null}
- */
-async function getToolTemplates() {
-  try {
-    const url = privacyNodeUrl('/tool/templates');
-    if (!url) return null;
-    const res = await hubFetch(url, {
-      headers: buildPrivacyNodeHeaders(),
-      signal: AbortSignal.timeout(PRIVACY_TIMEOUT_MS),
-    });
-    if (!res.ok) return null;
-    const data = await res.json();
-    return data.templates || data;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Parse [PRIVACY_PARAMS] block from task body.
- * Returns { tool_id, blob_ids[] } or null if no block found.
- * @param {string} body
- * @returns {{ toolId: string, blobIds: string[] } | null}
- */
-function parsePrivacyParams(body) {
-  if (!body || typeof body !== 'string') return null;
-  const start = body.indexOf('[PRIVACY_PARAMS]');
-  const end = body.indexOf('[/PRIVACY_PARAMS]');
-  if (start === -1 || end === -1 || end <= start) return null;
-
-  const block = body.substring(start + '[PRIVACY_PARAMS]'.length, end).trim();
-  const lines = block.split('\n').map(l => l.trim()).filter(Boolean);
-  const params = {};
-  for (const line of lines) {
-    const colon = line.indexOf(':');
-    if (colon === -1) continue;
-    const key = line.substring(0, colon).trim();
-    const val = line.substring(colon + 1).trim();
-    params[key] = val;
-  }
-
-  if (!params.tool_id) return null;
-  const blobIds = (params.blob_ids || '').split(',').map(s => s.trim()).filter(Boolean);
-  return { toolId: params.tool_id, blobIds };
-}
-
-module.exports = {
-  submitPrivacyTask,
-  uploadEncryptedBlob,
-  executeSealedTool,
-  getPrivacyStatus,
-  getPrivacyResult,
-  getToolTemplates,
-  parsePrivacyParams,
-};