0nmcp 2.0.0 → 2.1.0

package/vault/deed-collector.js

@@ -0,0 +1,286 @@
+// ============================================================
+// 0nMCP — Vault: Deed Credential Collector
+// ============================================================
+// Collects credentials from multiple sources (files, dirs,
+// manual entry) and auto-detects services using the engine
+// mapper. Feeds into BusinessDeed.create().
+//
+// Patent Pending: US Provisional Patent Application #63/990,046
+// ============================================================
+
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join, extname } from "path";
+import { homedir } from "os";
+import { parseFile, parseEnvString, parseJsonString, parseCsvString } from "../engine/parser.js";
+import { mapEnvVars, groupByService } from "../engine/mapper.js";
+import { verifyCredentials } from "../engine/validator.js";
+
+const CONNECTIONS_DIR = join(homedir(), ".0n", "connections");
+
+// ── Collect from .0n connection files ───────────────────────
+
+/**
+ * Load credentials from ~/.0n/connections/*.0n files.
+ *
+ * @param {string} [dir] - Connections directory (default: ~/.0n/connections/)
+ * @returns {{ credentials: Object, services: string[] }}
+ */
+export function collectFromConnections(dir = CONNECTIONS_DIR) {
+  const credentials = {};
+  const services = [];
+
+  if (!existsSync(dir)) return { credentials, services };
+
+  const files = readdirSync(dir).filter(f => f.endsWith(".0n"));
+
+  for (const file of files) {
+    try {
+      const content = readFileSync(join(dir, file), "utf-8");
+      const data = JSON.parse(content);
+
+      // .0n connection file format: { $0n: { type, service }, credentials: { ... } }
+      const service = data?.$0n?.service || file.replace(".0n", "");
+      if (data.credentials && typeof data.credentials === "object") {
+        credentials[service] = data.credentials;
+        services.push(service);
+      }
+    } catch {
+      // Skip invalid files
+    }
+  }
+
+  return { credentials, services };
+}
+
+// ── Collect from file (auto-detect format) ──────────────────
+
+/**
+ * Collect credentials from a file (.env, .json, .csv).
+ *
+ * @param {string} filePath
+ * @returns {{ credentials: Object, envVars: Object, services: string[], unmapped: Array }}
+ */
+export function collectFromFile(filePath) {
+  const { entries } = parseFile(filePath);
+  return processEntries(entries);
+}
+
+// ── Collect from string content ─────────────────────────────
+
+/**
+ * Collect from raw .env string content.
+ * @param {string} content
+ * @returns {{ credentials: Object, envVars: Object, services: string[], unmapped: Array }}
+ */
+export function collectFromEnvString(content) {
+  const entries = parseEnvString(content);
+  return processEntries(entries);
+}
+
+/**
+ * Collect from raw JSON string content.
+ * @param {string} content
+ * @returns {{ credentials: Object, envVars: Object, services: string[], unmapped: Array }}
+ */
+export function collectFromJsonString(content) {
+  const entries = parseJsonString(content);
+  return processEntries(entries);
+}
+
+/**
+ * Collect from raw CSV string content.
+ * @param {string} content
+ * @returns {{ credentials: Object, envVars: Object, services: string[], unmapped: Array }}
+ */
+export function collectFromCsvString(content) {
+  const entries = parseCsvString(content);
+  return processEntries(entries);
+}
+
+// ── Collect from manual key-value pairs ─────────────────────
+
+/**
+ * Collect from manual key-value pairs.
+ *
+ * @param {Array<{ key: string, value: string }>} pairs
+ * @returns {{ credentials: Object, envVars: Object, services: string[], unmapped: Array }}
+ */
+export function collectFromManual(pairs) {
+  return processEntries(pairs);
+}
+
+// ── Collect from pre-structured service credentials ─────────
+
+/**
+ * Collect from already-structured credentials object.
+ * Format: { stripe: { apiKey: "sk_..." }, github: { token: "ghp_..." } }
+ *
+ * @param {Object} structured
+ * @returns {{ credentials: Object, services: string[] }}
+ */
+export function collectFromStructured(structured) {
+  const services = Object.keys(structured);
+  return { credentials: structured, services };
+}
+
+// ── Process entries through mapper ──────────────────────────
+
+/**
+ * Process raw key-value entries through the mapper pipeline.
+ *
+ * @param {Array<{ key: string, value: string }>} entries
+ * @returns {{ credentials: Object, envVars: Object, services: string[], unmapped: Array }}
+ */
+function processEntries(entries) {
+  const { mapped, unmapped } = mapEnvVars(entries);
+  const grouped = groupByService(mapped);
+
+  // Build credentials and envVars
+  const credentials = {};
+  const envVars = {};
+  const services = [];
+
+  for (const [service, group] of Object.entries(grouped)) {
+    credentials[service] = group.credentials;
+    services.push(service);
+    for (const envVar of group.envVars) {
+      const entry = entries.find(e => e.key === envVar);
+      if (entry) envVars[entry.key] = entry.value;
+    }
+  }
+
+  // Unmapped entries go to envVars
+  for (const entry of unmapped) {
+    envVars[entry.key] = entry.value;
+  }
+
+  return { credentials, envVars, services, unmapped };
+}
+
+// ── Validate credentials live ───────────────────────────────
+
+/**
+ * Validate collected credentials against live API endpoints.
+ *
+ * @param {Object} credentials - { service: { field: value } }
+ * @returns {Promise<Object>} Validation results per service
+ */
+export async function validateCollected(credentials) {
+  const results = {};
+  const summary = { total: 0, valid: 0, invalid: 0, skipped: 0 };
+
+  const entries = Object.entries(credentials);
+  summary.total = entries.length;
+
+  // Validate in parallel batches of 5
+  const batchSize = 5;
+  for (let i = 0; i < entries.length; i += batchSize) {
+    const batch = entries.slice(i, i + batchSize);
+    const promises = batch.map(([service, creds]) =>
+      verifyCredentials(service, creds).then(r => ({ service, ...r }))
+    );
+    const batchResults = await Promise.allSettled(promises);
+
+    for (const result of batchResults) {
+      if (result.status === "fulfilled") {
+        const r = result.value;
+        results[r.service] = r;
+        if (r.skipped) summary.skipped++;
+        else if (r.valid) summary.valid++;
+        else summary.invalid++;
+      }
+    }
+  }
+
+  return { results, summary };
+}
+
+// ── Master collection function ──────────────────────────────
+
+/**
+ * Collect credentials from multiple sources at once.
+ *
+ * @param {Object} sources
+ * @param {string}  [sources.envFile] - Path to .env file
+ * @param {string}  [sources.jsonFile] - Path to JSON file
+ * @param {string}  [sources.csvFile] - Path to CSV file
+ * @param {string}  [sources.connectionsDir] - Path to connections dir
+ * @param {Array}   [sources.manual] - Manual key-value pairs
+ * @param {Object}  [sources.structured] - Pre-structured credentials
+ * @param {boolean} [sources.validate] - Validate credentials live
+ * @returns {Promise<Object>}
+ */
+export async function collectCredentials(sources) {
+  const allCredentials = {};
+  const allEnvVars = {};
+  const allServices = new Set();
+  const allUnmapped = [];
+
+  // Collect from each source
+  if (sources.envFile && existsSync(sources.envFile)) {
+    const result = collectFromFile(sources.envFile);
+    mergeResults(allCredentials, allEnvVars, allServices, allUnmapped, result);
+  }
+
+  if (sources.jsonFile && existsSync(sources.jsonFile)) {
+    const result = collectFromFile(sources.jsonFile);
+    mergeResults(allCredentials, allEnvVars, allServices, allUnmapped, result);
+  }
+
+  if (sources.csvFile && existsSync(sources.csvFile)) {
+    const result = collectFromFile(sources.csvFile);
+    mergeResults(allCredentials, allEnvVars, allServices, allUnmapped, result);
+  }
+
+  if (sources.connectionsDir || existsSync(CONNECTIONS_DIR)) {
+    const dir = sources.connectionsDir || CONNECTIONS_DIR;
+    const result = collectFromConnections(dir);
+    for (const [svc, creds] of Object.entries(result.credentials)) {
+      allCredentials[svc] = { ...allCredentials[svc], ...creds };
+      allServices.add(svc);
+    }
+  }
+
+  if (sources.manual && Array.isArray(sources.manual)) {
+    const result = collectFromManual(sources.manual);
+    mergeResults(allCredentials, allEnvVars, allServices, allUnmapped, result);
+  }
+
+  if (sources.structured && typeof sources.structured === "object") {
+    const result = collectFromStructured(sources.structured);
+    for (const [svc, creds] of Object.entries(result.credentials)) {
+      allCredentials[svc] = { ...allCredentials[svc], ...creds };
+      allServices.add(svc);
+    }
+  }
+
+  const output = {
+    credentials: allCredentials,
+    envVars: allEnvVars,
+    services: Array.from(allServices),
+    unmapped: allUnmapped,
+    credentialCount: Object.values(allCredentials).reduce(
+      (sum, svc) => sum + Object.keys(svc).length, 0
+    ),
+  };
+
+  // Optional live validation
+  if (sources.validate) {
+    output.validation = await validateCollected(allCredentials);
+  }
+
+  return output;
+}
+
+// ── Merge helper ────────────────────────────────────────────
+
+function mergeResults(allCreds, allEnv, allServices, allUnmapped, result) {
+  for (const [svc, creds] of Object.entries(result.credentials || {})) {
+    allCreds[svc] = { ...allCreds[svc], ...creds };
+    allServices.add(svc);
+  }
+  for (const [k, v] of Object.entries(result.envVars || {})) {
+    allEnv[k] = v;
+  }
+  if (result.unmapped) allUnmapped.push(...result.unmapped);
+}

package/vault/deed-importer.js

@@ -0,0 +1,277 @@
+// ============================================================
+// 0nMCP — Vault: Deed Importer
+// ============================================================
+// Writes decrypted deed contents back to live system config.
+// Generates .0n connection files, .env files, MCP platform
+// configs, and restores workflows and AI brain data.
+//
+// Patent Pending: US Provisional Patent Application #63/990,046
+// ============================================================
+
+import { existsSync, mkdirSync, writeFileSync, readdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const DOT_ON = join(homedir(), ".0n");
+const CONNECTIONS_DIR = join(DOT_ON, "connections");
+const WORKFLOWS_DIR = join(DOT_ON, "workflows");
+const BRAIN_DIR = join(DOT_ON, "brain");
+
+function ensureDir(dir) {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+
+// ── Write .0n Connection Files ──────────────────────────────
+
+/**
+ * Write service credentials as .0n connection files.
+ *
+ * @param {Object} credentials - { service: { field: value } }
+ * @param {string} dir - Target connections directory
+ * @returns {{ written: string[], skipped: string[] }}
+ */
+function writeConnectionFiles(credentials, dir) {
+  ensureDir(dir);
+  const written = [];
+  const skipped = [];
+
+  for (const [service, creds] of Object.entries(credentials)) {
+    try {
+      const connection = {
+        $0n: {
+          type: "connection",
+          version: "1.0.0",
+          service,
+          created: new Date().toISOString(),
+          source: "business_deed_import",
+        },
+        credentials: creds,
+      };
+
+      const filePath = join(dir, `${service}.0n`);
+      writeFileSync(filePath, JSON.stringify(connection, null, 2));
+      written.push(service);
+    } catch (err) {
+      skipped.push(`${service}: ${err.message}`);
+    }
+  }
+
+  return { written, skipped };
+}
+
+// ── Generate .env File ──────────────────────────────────────
+
+/**
+ * Write environment variables to a .env file.
+ *
+ * @param {Object} envVars - { KEY: value }
+ * @param {string} filePath - Output .env path
+ * @returns {{ written: number, file: string }}
+ */
+function writeEnvFile(envVars, filePath) {
+  const lines = [
+    `# Generated by 0nMCP Business Deed Import`,
+    `# ${new Date().toISOString()}`,
+    "",
+  ];
+
+  for (const [key, value] of Object.entries(envVars)) {
+    // Quote values that contain spaces or special chars
+    const needsQuotes = /[\s#"'\\]/.test(value);
+    lines.push(`${key}=${needsQuotes ? `"${value}"` : value}`);
+  }
+
+  writeFileSync(filePath, lines.join("\n") + "\n");
+  return { written: Object.keys(envVars).length, file: filePath };
+}
+
+// ── Write Workflow Files ────────────────────────────────────
+
+/**
+ * Write workflow definitions to ~/.0n/workflows/.
+ *
+ * @param {Array|Object} workflows - Workflow definitions
+ * @param {string} dir - Target workflows directory
+ * @returns {{ written: string[], count: number }}
+ */
+function writeWorkflowFiles(workflows, dir) {
+  ensureDir(dir);
+  const written = [];
+
+  const items = Array.isArray(workflows) ? workflows : [workflows];
+
+  for (const workflow of items) {
+    try {
+      const name = workflow?.$0n?.name || workflow?.name || `workflow-${Date.now()}`;
+      const safeName = name.replace(/[^a-zA-Z0-9_-]/g, "_");
+      const filePath = join(dir, `${safeName}.0n`);
+      writeFileSync(filePath, JSON.stringify(workflow, null, 2));
+      written.push(safeName);
+    } catch {
+      // Skip invalid workflows
+    }
+  }
+
+  return { written, count: written.length };
+}
+
+// ── Write MCP Configs ───────────────────────────────────────
+
+/**
+ * Write MCP platform configurations.
+ *
+ * @param {Object} mcpConfigs - MCP configuration data
+ * @param {string} targetDir - Target directory
+ * @returns {{ written: string[] }}
+ */
+function writeMcpConfigs(mcpConfigs, targetDir) {
+  const written = [];
+
+  if (mcpConfigs.platforms && typeof mcpConfigs.platforms === "object") {
+    for (const [platform, config] of Object.entries(mcpConfigs.platforms)) {
+      try {
+        const filePath = join(targetDir, `mcp-${platform}.json`);
+        writeFileSync(filePath, JSON.stringify(config, null, 2));
+        written.push(platform);
+      } catch {
+        // Skip
+      }
+    }
+  }
+
+  // Write raw config if present
+  if (mcpConfigs.servers) {
+    try {
+      const filePath = join(targetDir, "mcp-config.json");
+      writeFileSync(filePath, JSON.stringify(mcpConfigs, null, 2));
+      written.push("mcp-config");
+    } catch {
+      // Skip
+    }
+  }
+
+  return { written };
+}
+
+// ── Write AI Brain Data ─────────────────────────────────────
+
+/**
+ * Write AI brain data to ~/.0n/brain/.
+ *
+ * @param {Object} aiBrain - AI brain data
+ * @param {string} dir - Target brain directory
+ * @returns {{ written: string[] }}
+ */
+function writeBrainData(aiBrain, dir) {
+  ensureDir(dir);
+  const written = [];
+
+  // Write each brain section as a separate file
+  for (const [section, data] of Object.entries(aiBrain)) {
+    try {
+      const filePath = join(dir, `${section}.json`);
+      writeFileSync(filePath, JSON.stringify(data, null, 2));
+      written.push(section);
+    } catch {
+      // Skip
+    }
+  }
+
+  return { written };
+}
+
+// ── Master Import Function ──────────────────────────────────
+
+/**
+ * Import all deed layers into the live system.
+ *
+ * @param {Object} layers - Decrypted layer data
+ * @param {string} [targetDir] - Base target directory (default: ~/.0n/)
+ * @returns {Object} Import report
+ */
+export function importDeedToSystem(layers, targetDir = null) {
+  const baseDir = targetDir || DOT_ON;
+  const connectionsDir = join(baseDir, "connections");
+  const workflowsDir = join(baseDir, "workflows");
+  const brainDir = join(baseDir, "brain");
+
+  ensureDir(baseDir);
+
+  const report = {
+    success: true,
+    timestamp: new Date().toISOString(),
+    connections: { written: [], skipped: [] },
+    envFile: null,
+    workflows: { written: [], count: 0 },
+    mcpConfigs: { written: [] },
+    brain: { written: [] },
+    siteProfiles: null,
+    deed: null,
+    errors: [],
+  };
+
+  // 1. Import credentials as .0n connection files
+  if (layers.credentials && typeof layers.credentials === "object" && !layers.credentials.error) {
+    try {
+      report.connections = writeConnectionFiles(layers.credentials, connectionsDir);
+    } catch (err) {
+      report.errors.push(`credentials: ${err.message}`);
+    }
+  }
+
+  // 2. Generate .env file from env_vars
+  if (layers.env_vars && typeof layers.env_vars === "object" && !layers.env_vars.error) {
+    try {
+      const envPath = join(baseDir, ".env.deed");
+      report.envFile = writeEnvFile(layers.env_vars, envPath);
+    } catch (err) {
+      report.errors.push(`env_vars: ${err.message}`);
+    }
+  }
+
+  // 3. Write workflows
+  if (layers.workflows && !layers.workflows.error) {
+    try {
+      report.workflows = writeWorkflowFiles(layers.workflows, workflowsDir);
+    } catch (err) {
+      report.errors.push(`workflows: ${err.message}`);
+    }
+  }
+
+  // 4. Write MCP configs
+  if (layers.mcp_configs && typeof layers.mcp_configs === "object" && !layers.mcp_configs.error) {
+    try {
+      report.mcpConfigs = writeMcpConfigs(layers.mcp_configs, baseDir);
+    } catch (err) {
+      report.errors.push(`mcp_configs: ${err.message}`);
+    }
+  }
+
+  // 5. Write site profiles
+  if (layers.site_profiles && typeof layers.site_profiles === "object" && !layers.site_profiles.error) {
+    try {
+      const profilePath = join(baseDir, "site-profiles.json");
+      writeFileSync(profilePath, JSON.stringify(layers.site_profiles, null, 2));
+      report.siteProfiles = { file: profilePath };
+    } catch (err) {
+      report.errors.push(`site_profiles: ${err.message}`);
+    }
+  }
+
+  // 6. Write AI brain data
+  if (layers.ai_brain && typeof layers.ai_brain === "object" && !layers.ai_brain.error) {
+    try {
+      report.brain = writeBrainData(layers.ai_brain, brainDir);
+    } catch (err) {
+      report.errors.push(`ai_brain: ${err.message}`);
+    }
+  }
+
+  // 7. Extract deed metadata from audit_trail
+  if (layers.audit_trail?.deed) {
+    report.deed = layers.audit_trail.deed;
+  }
+
+  report.success = report.errors.length === 0;
+  return report;
+}