0nmcp 1.7.0 → 2.0.0

package/command-runner.js

@@ -0,0 +1,224 @@
+/**
+ * ═══════════════════════════════════════════════════════════════════════════
+ * 0nMCP — Command Runner
+ * ═══════════════════════════════════════════════════════════════════════════
+ *
+ * Executes named RUNs (command aliases) defined in the SWITCH file.
+ *
+ * Pipeline commands run built-in actions sequentially:
+ *   verify, platforms, list, serve, connect
+ *
+ * Workflow commands run .0n workflow files via the WorkflowRunner.
+ *
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+import { resolveInputs, parseCommandArgs } from './commands.js';
+
+const DOT_ON_DIR = path.join(os.homedir(), '.0n');
+
+// Colors
+const c = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+};
+
+/**
+ * Run a command from the SWITCH file
+ * @param {string} alias - The command alias
+ * @param {object} def - The command definition
+ * @param {string[]} rawArgs - CLI arguments after the alias
+ */
+export async function runCommand(alias, def, rawArgs = []) {
+  const type = def.type || 'workflow';
+  const { args, flags } = parseCommandArgs(rawArgs);
+
+  console.log(`${c.bright}Running: ${c.cyan}${def.name || alias}${c.reset}`);
+  if (def.description) console.log(`  ${def.description}\n`);
+
+  const start = Date.now();
+
+  try {
+    switch (type) {
+      case 'pipeline':
+        await runPipeline(def, args, flags);
+        break;
+      case 'workflow':
+        await runWorkflow(def, args, flags);
+        break;
+      default:
+        console.log(`${c.red}Unknown command type: ${type}${c.reset}`);
+        process.exit(1);
+    }
+
+    const elapsed = Date.now() - start;
+    console.log(`\n${c.green}${c.bright}Done${c.reset} ${c.green}(${elapsed}ms)${c.reset}`);
+  } catch (err) {
+    console.log(`\n${c.red}${c.bright}Failed:${c.reset} ${c.red}${err.message}${c.reset}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Execute a pipeline command — sequential built-in actions
+ */
+async function runPipeline(def, args, flags) {
+  const steps = def.steps || [];
+
+  if (steps.length === 0) {
+    console.log(`${c.yellow}No steps defined in this command.${c.reset}`);
+    return;
+  }
+
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const action = step.action;
+    const stepNum = `[${i + 1}/${steps.length}]`;
+
+    console.log(`${c.cyan}${stepNum}${c.reset} ${step.description || action}...`);
+
+    await executePipelineAction(action, step, args, flags);
+
+    console.log(`${c.green}  ✓${c.reset} ${action} complete\n`);
+  }
+}
+
+/**
+ * Execute a single pipeline action
+ */
+async function executePipelineAction(action, step, args, flags) {
+  switch (action) {
+    case 'verify': {
+      const { verifyAll } = await import('./engine/validator.js');
+      const connectionsDir = path.join(DOT_ON_DIR, 'connections');
+
+      if (!fs.existsSync(connectionsDir)) {
+        console.log(`  ${c.yellow}No connections found.${c.reset}`);
+        return;
+      }
+
+      const files = fs.readdirSync(connectionsDir).filter(f => f.endsWith('.0n'));
+      const connections = {};
+      for (const file of files) {
+        try {
+          const data = JSON.parse(fs.readFileSync(path.join(connectionsDir, file), 'utf8'));
+          if (data.$0n?.sealed) continue;
+          connections[data.service] = { credentials: data.auth?.credentials || {} };
+        } catch { /* skip */ }
+      }
+
+      if (Object.keys(connections).length === 0) {
+        console.log(`  ${c.yellow}No unsealed connections to verify.${c.reset}`);
+        return;
+      }
+
+      const { results, summary } = await verifyAll(connections);
+      for (const [service, result] of Object.entries(results)) {
+        const icon = result.valid ? `${c.green}  ✓` : `${c.red}  ✗`;
+        const latency = result.latency_ms ? ` (${result.latency_ms}ms)` : '';
+        console.log(`${icon}${c.reset} ${service}${latency}${result.error ? ` — ${result.error}` : ''}`);
+      }
+      console.log(`  ${summary.valid}/${summary.total} valid`);
+      break;
+    }
+
+    case 'platforms': {
+      const { getPlatformInfo } = await import('./engine/platforms.js');
+      const info = getPlatformInfo();
+      for (const p of info) {
+        const status = p.installed ? `${c.green}installed${c.reset}` : `${c.blue}available${c.reset}`;
+        console.log(`  ${p.installed ? '●' : '○'} ${p.name} (${status})`);
+      }
+      break;
+    }
+
+    case 'list': {
+      const connectionsDir = path.join(DOT_ON_DIR, 'connections');
+      if (!fs.existsSync(connectionsDir)) {
+        console.log(`  ${c.yellow}No connections found.${c.reset}`);
+        return;
+      }
+
+      const files = fs.readdirSync(connectionsDir).filter(f => f.endsWith('.0n'));
+      for (const file of files) {
+        try {
+          const data = JSON.parse(fs.readFileSync(path.join(connectionsDir, file), 'utf8'));
+          console.log(`  ${c.green}●${c.reset} ${data.$0n?.name || data.service} (${file})`);
+        } catch {
+          console.log(`  ${c.red}●${c.reset} ${file} (error)`);
+        }
+      }
+      break;
+    }
+
+    case 'serve': {
+      const port = step.port || flags.port || 3001;
+      const host = step.host || flags.host || '0.0.0.0';
+      console.log(`  Starting server on ${host}:${port}...`);
+      const { startServer } = await import('./server.js');
+      await startServer({ port: Number(port), host: String(host) });
+      break;
+    }
+
+    default:
+      console.log(`  ${c.yellow}Unknown pipeline action: ${action}${c.reset}`);
+  }
+}
+
+/**
+ * Execute a workflow command — runs a .0n workflow file
+ */
+async function runWorkflow(def, args, flags) {
+  const workflowName = def.workflow;
+  if (!workflowName) {
+    console.log(`${c.red}No workflow specified in command definition.${c.reset}`);
+    process.exit(1);
+  }
+
+  // Resolve inputs from CLI args/flags
+  const inputs = def.inputs ? resolveInputs(def.inputs, args, flags) : {};
+
+  const { ConnectionManager } = await import('./connections.js');
+  const { WorkflowRunner } = await import('./workflow.js');
+
+  const connections = new ConnectionManager();
+  const runner = new WorkflowRunner(connections);
+
+  if (Object.keys(inputs).length > 0) {
+    console.log(`${c.bright}Inputs:${c.reset}`, JSON.stringify(inputs, null, 2));
+    console.log('');
+  }
+
+  const result = await runner.run({ workflowPath: workflowName, inputs });
+
+  if (result.success) {
+    console.log(`${c.green}${c.bright}Workflow completed${c.reset}`);
+  } else {
+    console.log(`${c.red}${c.bright}Workflow failed${c.reset}`);
+  }
+
+  console.log(`  Steps: ${result.stepsSuccessful}/${result.stepsExecuted} successful`);
+  console.log(`  Duration: ${result.duration}ms`);
+
+  if (result.outputs && Object.keys(result.outputs).length > 0) {
+    console.log(`\n${c.bright}Outputs:${c.reset}`);
+    console.log(JSON.stringify(result.outputs, null, 2));
+  }
+
+  if (result.errors?.length > 0) {
+    console.log(`\n${c.red}Errors:${c.reset}`);
+    for (const err of result.errors) {
+      console.log(`  ${c.red}●${c.reset} ${err.service}.${err.action}: ${err.error}`);
+    }
+  }
+
+  if (!result.success) process.exit(1);
+}

package/commands.js

@@ -0,0 +1,115 @@
+/**
+ * ═══════════════════════════════════════════════════════════════════════════
+ * 0nMCP — Named Runs / Command Aliases
+ * ═══════════════════════════════════════════════════════════════════════════
+ *
+ * Loads command aliases from the SWITCH file (~/.0n/0n-setup.0n) and makes
+ * them available as CLI commands: `0nmcp launch`, `0nmcp hello`, etc.
+ *
+ * Command types:
+ *   - pipeline: Sequential built-in actions (verify, platforms, list, serve)
+ *   - workflow: Run a named .0n workflow from ~/.0n/workflows/
+ *
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const DOT_ON_DIR = join(homedir(), '.0n');
+const DEFAULT_SWITCH = join(DOT_ON_DIR, '0n-setup.0n');
+
+/**
+ * Load commands from a SWITCH file
+ * @param {string} [switchPath] - Path to SWITCH file. Defaults to ~/.0n/0n-setup.0n
+ * @returns {Map<string, object>} Map of alias → command definition
+ */
+export function loadCommands(switchPath) {
+  const filePath = switchPath || DEFAULT_SWITCH;
+  if (!existsSync(filePath)) return new Map();
+
+  try {
+    const raw = readFileSync(filePath, 'utf8');
+    const data = JSON.parse(raw);
+    if (!data.commands || typeof data.commands !== 'object') return new Map();
+    return new Map(Object.entries(data.commands));
+  } catch {
+    return new Map();
+  }
+}
+
+/**
+ * List all available commands with metadata
+ * @param {string} [switchPath]
+ * @returns {Array<{alias: string, name: string, description: string, type: string}>}
+ */
+export function listCommands(switchPath) {
+  const commands = loadCommands(switchPath);
+  return [...commands.entries()].map(([alias, def]) => ({
+    alias,
+    name: def.name || alias,
+    description: def.description || '',
+    type: def.type || 'workflow',
+  }));
+}
+
+/**
+ * Parse CLI arguments into positional args and named flags
+ * @param {string[]} rawArgs - Arguments after the command name
+ * @returns {{ args: string[], flags: Record<string, string> }}
+ */
+export function parseCommandArgs(rawArgs) {
+  const args = [];
+  const flags = {};
+
+  for (let i = 0; i < rawArgs.length; i++) {
+    if (rawArgs[i].startsWith('--') && rawArgs[i + 1] && !rawArgs[i + 1].startsWith('--')) {
+      flags[rawArgs[i].slice(2)] = rawArgs[i + 1];
+      i++;
+    } else if (rawArgs[i].startsWith('--')) {
+      flags[rawArgs[i].slice(2)] = 'true';
+    } else {
+      args.push(rawArgs[i]);
+    }
+  }
+
+  return { args, flags };
+}
+
+/**
+ * Resolve template expressions in command inputs
+ * Supports {{args.N}}, {{flags.key}}, and literal values
+ * @param {Record<string, string>} inputs - Input template map
+ * @param {string[]} args - Positional CLI args
+ * @param {Record<string, string>} flags - Named CLI flags
+ * @returns {Record<string, unknown>}
+ */
+export function resolveInputs(inputs, args, flags) {
+  const resolved = {};
+
+  for (const [key, template] of Object.entries(inputs)) {
+    if (typeof template !== 'string') {
+      resolved[key] = template;
+      continue;
+    }
+
+    const argsMatch = template.match(/^\{\{args\.(\d+)\}\}$/);
+    if (argsMatch) {
+      const idx = parseInt(argsMatch[1]);
+      resolved[key] = args[idx] ?? template;
+      continue;
+    }
+
+    const flagsMatch = template.match(/^\{\{flags\.(\w+)\}\}$/);
+    if (flagsMatch) {
+      resolved[key] = flags[flagsMatch[1]] ?? template;
+      continue;
+    }
+
+    // Pass through literal values
+    resolved[key] = template;
+  }
+
+  return resolved;
+}

package/index.js

@@ -28,6 +28,7 @@ import { WorkflowRunner } from "./workflow.js";
 import { registerAllTools } from "./tools.js";
 import { registerCrmTools } from "./crm/index.js";
 import { registerVaultTools, autoUnseal } from "./vault/index.js";
+import { registerContainerTools } from "./vault/tools-container.js";
 import { unsealedCache } from "./vault/cache.js";
 import { registerEngineTools } from "./engine/index.js";
 
@@ -39,7 +40,7 @@ const workflowRunner = new WorkflowRunner(connections);
 
 const server = new McpServer({
   name: "0nMCP",
-  version: "1.6.0",
+  version: "2.0.0",
 });
 
 // ============================================================
@@ -73,6 +74,12 @@ if (vaultResult.unsealed.length > 0) {
 
 registerEngineTools(server, z);
 
+// ============================================================
+// VAULT CONTAINER TOOLS (patent-pending 0nVault containers)
+// ============================================================
+
+registerContainerTools(server, z);
+
 // ============================================================
 // START SERVER (stdio transport)
 // ============================================================

package/lib/stats.json

@@ -1,5 +1,5 @@
 {
-  "generated": "2026-02-15T08:02:44.106Z",
+  "generated": "2026-02-25T10:54:43.654Z",
   "catalogVersion": "1.2.2",
   "services": 26,
   "tools": 290,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0nmcp",
-  "version": "1.7.0",
+  "version": "2.0.0",
   "mcpName": "io.github.0nork/0nMCP",
   "description": "Universal AI API Orchestrator — 550 tools, 26 services, portable AI Brain bundles + machine-bound vault encryption + Application Engine. The most comprehensive MCP server available. Free and open source from 0nORK.",
   "type": "module",
@@ -64,6 +64,15 @@
     },
     "./engine/scheduler": {
       "import": "./engine/scheduler.js"
+    },
+    "./vault/container": {
+      "import": "./vault/container.js"
+    },
+    "./vault/escrow": {
+      "import": "./vault/escrow.js"
+    },
+    "./vault/seal": {
+      "import": "./vault/seal.js"
     }
   },
   "scripts": {
@@ -136,6 +145,15 @@
     "ai-brain",
     "credential-import",
     "platform-config",
+    "0nvault",
+    "semantic-layers",
+    "escrow",
+    "seal-of-truth",
+    "ed25519",
+    "x25519",
+    "sha3",
+    "argon2",
+    "digital-asset-transfer",
     "0n",
     "0nork",
     "0nmcp"
@@ -159,7 +177,10 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
-    "express": "^4.21.0"
+    "argon2": "^0.44.0",
+    "express": "^4.21.0",
+    "js-sha3": "^0.9.3",
+    "tweetnacl": "^1.0.3"
   },
   "optionalDependencies": {
     "0n-spec": "^1.1.0"
@@ -175,6 +196,8 @@
   "files": [
     "index.js",
     "cli.js",
+    "commands.js",
+    "command-runner.js",
     "tools.js",
     "workflow.js",
     "server.js",
@@ -204,6 +227,6 @@
     "triggers": 93,
     "totalCapabilities": 708,
     "categories": 13,
-    "lastUpdated": "2026-02-15T08:02:44.106Z"
+    "lastUpdated": "2026-02-25T10:54:43.654Z"
   }
 }