0nmcp 1.6.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/connections.js

@@ -18,6 +18,7 @@ const SNAPSHOTS_DIR = join(DOT_ON, "snapshots");
 const HISTORY_DIR = join(DOT_ON, "history");
 const CACHE_DIR = join(DOT_ON, "cache");
 const PLUGINS_DIR = join(DOT_ON, "plugins");
+const APPS_DIR = join(DOT_ON, "apps");
 const CONFIG_FILE = join(DOT_ON, "config.json");
 
 // Legacy path for migration
@@ -28,7 +29,7 @@ const LEGACY_FILE = join(LEGACY_DIR, "connections.json");
  * Initialize the ~/.0n/ directory structure.
  */
 export function initDotOn() {
-  const dirs = [DOT_ON, CONNECTIONS_DIR, WORKFLOWS_DIR, SNAPSHOTS_DIR, HISTORY_DIR, CACHE_DIR, PLUGINS_DIR];
+  const dirs = [DOT_ON, CONNECTIONS_DIR, WORKFLOWS_DIR, SNAPSHOTS_DIR, HISTORY_DIR, CACHE_DIR, PLUGINS_DIR, APPS_DIR];
   for (const dir of dirs) {
     if (!existsSync(dir)) {
       mkdirSync(dir, { recursive: true });
@@ -331,3 +332,4 @@ export const CONNECTIONS_PATH = CONNECTIONS_DIR;
 export const HISTORY_PATH = HISTORY_DIR;
 export const WORKFLOWS_PATH = WORKFLOWS_DIR;
 export const SNAPSHOTS_PATH = SNAPSHOTS_DIR;
+export const APPS_PATH = APPS_DIR;

package/engine/app-builder.js

@@ -0,0 +1,318 @@
+// ============================================================
+// 0nMCP -Engine: Application Builder
+// ============================================================
+// Creates, opens, inspects, and validates .0n application
+// bundles ($0n.type: "application"). Analogous to bundler.js
+// but for the full Application Engine format.
+//
+// Patent Pending: US Provisional Patent Application #63/968,814
+// ============================================================
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join, basename } from "path";
+import { createHash } from "crypto";
+import { homedir } from "os";
+import { sealPortable, unsealPortable } from "./cipher-portable.js";
+import { validateOperations } from "./operations.js";
+
+const APPS_DIR = join(homedir(), ".0n", "apps");
+
+/**
+ * Compute SHA-256 checksum of a string.
+ */
+function sha256(data) {
+  return createHash("sha256").update(data).digest("hex");
+}
+
+/**
+ * Create a .0n application bundle.
+ *
+ * @param {object} options
+ * @param {string} options.name -Application name
+ * @param {string} options.passphrase -Encryption passphrase
+ * @param {Record<string, object>} [options.connections] -{ service: { credentials, authType?, ... } }
+ * @param {Record<string, object>} [options.operations] -Operation definitions
+ * @param {Record<string, object>} [options.workflows] -Workflow definitions
+ * @param {Record<string, object>} [options.endpoints] -Endpoint definitions
+ * @param {Record<string, object>} [options.automations] -Automation definitions
+ * @param {object} [options.environment] -{ variables, secrets, settings, feature_flags }
+ * @param {string} [options.output] -Output file path
+ * @param {string} [options.description]
+ * @param {string} [options.author]
+ * @param {string} [options.version]
+ * @returns {{ bundle: object, path: string, manifest: object }}
+ */
+export function createApplication(options) {
+  const {
+    name = "0n Application",
+    passphrase,
+    connections = {},
+    operations = {},
+    workflows = {},
+    endpoints = {},
+    automations = {},
+    environment = {},
+    output,
+    description = "",
+    author = "",
+    version = "1.0.0",
+  } = options;
+
+  if (!passphrase) {
+    throw new Error("Passphrase is required to create an application bundle.");
+  }
+
+  const now = new Date().toISOString();
+
+  // Seal connections
+  const bundleConnections = [];
+  for (const [service, conn] of Object.entries(connections)) {
+    const credJson = JSON.stringify(conn.credentials || conn);
+    const { sealed } = sealPortable(credJson, passphrase);
+
+    bundleConnections.push({
+      service,
+      name: conn.name || service,
+      environment: conn.environment || "production",
+      auth_type: conn.authType || conn.auth_type || "api_key",
+      credential_keys: Object.keys(conn.credentials || conn),
+      sealed: true,
+      vault: {
+        data: sealed,
+        algorithm: "aes-256-gcm",
+        kdf: "pbkdf2-sha512-100k",
+        portable: true,
+      },
+    });
+  }
+
+  // Seal environment secrets
+  const bundleEnvironment = {
+    variables: environment.variables || {},
+    secrets: {},
+    settings: environment.settings || {},
+    feature_flags: environment.feature_flags || {},
+  };
+
+  if (environment.secrets) {
+    for (const [key, val] of Object.entries(environment.secrets)) {
+      const { sealed } = sealPortable(String(val), passphrase);
+      bundleEnvironment.secrets[key] = sealed;
+    }
+  }
+
+  // Build manifest
+  const manifest = {
+    bundle_version: "1.0.0",
+    generator: "0nmcp-engine/1.7.0",
+    type: "application",
+    connection_count: bundleConnections.length,
+    workflow_count: Object.keys(workflows).length,
+    operation_count: Object.keys(operations).length,
+    endpoint_count: Object.keys(endpoints).length,
+    automation_count: Object.keys(automations).length,
+    services: bundleConnections.map(c => c.service),
+    encryption: {
+      method: "portable",
+      algorithm: "aes-256-gcm",
+      kdf: "pbkdf2-sha512-100k",
+    },
+  };
+
+  // Assemble bundle
+  const bundle = {
+    $0n: {
+      type: "application",
+      version,
+      name,
+      description,
+      author,
+      created: now,
+      updated: now,
+    },
+    connections: bundleConnections,
+    environment: bundleEnvironment,
+    operations,
+    workflows,
+    endpoints,
+    automations,
+    platforms: {},
+    includes: [],
+    manifest,
+  };
+
+  // Compute checksums
+  manifest.checksums = {
+    connections: `sha256:${sha256(JSON.stringify(bundleConnections))}`,
+    operations: `sha256:${sha256(JSON.stringify(operations))}`,
+    workflows: `sha256:${sha256(JSON.stringify(workflows))}`,
+    endpoints: `sha256:${sha256(JSON.stringify(endpoints))}`,
+    automations: `sha256:${sha256(JSON.stringify(automations))}`,
+  };
+
+  // Write to file
+  if (!existsSync(APPS_DIR)) mkdirSync(APPS_DIR, { recursive: true });
+  const ts = now.replace(/[:.]/g, "-").slice(0, 19);
+  const safeName = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+$/, "");
+  const outPath = output || join(APPS_DIR, `${safeName}-${ts}.0n`);
+  const outDir = join(outPath, "..");
+  if (!existsSync(outDir)) mkdirSync(outDir, { recursive: true });
+
+  writeFileSync(outPath, JSON.stringify(bundle, null, 2));
+
+  return { bundle, path: outPath, manifest };
+}
+
+/**
+ * Open a .0n application bundle and return parsed data.
+ *
+ * @param {string} bundlePath -Path to .0n application file
+ * @param {string} passphrase -Decryption passphrase
+ * @returns {object} Parsed and decrypted bundle
+ */
+export function openApplication(bundlePath, passphrase) {
+  const raw = readFileSync(bundlePath, "utf-8");
+  const bundle = JSON.parse(raw);
+
+  if (!bundle.$0n || bundle.$0n.type !== "application") {
+    throw new Error(`Not a .0n application file. Type: ${bundle.$0n?.type || "unknown"}`);
+  }
+
+  // Verify connections can be decrypted
+  for (const conn of bundle.connections || []) {
+    if (conn.sealed && conn.vault?.data) {
+      try {
+        unsealPortable(conn.vault.data, passphrase);
+      } catch {
+        throw new Error(`Failed to decrypt connection "${conn.service}" -wrong passphrase.`);
+      }
+    }
+  }
+
+  return bundle;
+}
+
+/**
+ * Inspect an application bundle without passphrase.
+ *
+ * @param {string} bundlePath
+ * @returns {object} Application metadata
+ */
+export function inspectApplication(bundlePath) {
+  const raw = readFileSync(bundlePath, "utf-8");
+  const bundle = JSON.parse(raw);
+
+  if (!bundle.$0n || bundle.$0n.type !== "application") {
+    throw new Error(`Not a .0n application file. Type: ${bundle.$0n?.type || "unknown"}`);
+  }
+
+  return {
+    name: bundle.$0n.name,
+    version: bundle.$0n.version,
+    description: bundle.$0n.description,
+    author: bundle.$0n.author,
+    created: bundle.$0n.created,
+    updated: bundle.$0n.updated,
+    connections: (bundle.connections || []).map(c => ({
+      service: c.service,
+      name: c.name,
+      sealed: c.sealed,
+      credential_keys: c.credential_keys,
+    })),
+    workflows: Object.keys(bundle.workflows || {}),
+    operations: Object.keys(bundle.operations || {}),
+    endpoints: Object.keys(bundle.endpoints || {}),
+    automations: Object.keys(bundle.automations || {}),
+    environment: {
+      variables: Object.keys(bundle.environment?.variables || {}),
+      secrets: Object.keys(bundle.environment?.secrets || {}),
+      settings: bundle.environment?.settings || {},
+      feature_flags: bundle.environment?.feature_flags || {},
+    },
+    manifest: bundle.manifest,
+  };
+}
+
+/**
+ * Validate an application bundle's cross-references.
+ * Ensures endpoints reference valid workflows, workflows reference valid operations, etc.
+ *
+ * @param {object} bundle -Parsed application bundle
+ * @returns {{ valid: boolean, errors: string[], warnings: string[] }}
+ */
+export function validateApplication(bundle) {
+  const errors = [];
+  const warnings = [];
+
+  if (!bundle.$0n || bundle.$0n.type !== "application") {
+    return { valid: false, errors: ["Not a valid .0n application bundle."], warnings };
+  }
+
+  const workflows = bundle.workflows || {};
+  const operations = bundle.operations || {};
+  const endpoints = bundle.endpoints || {};
+  const automations = bundle.automations || {};
+
+  // Validate operations
+  if (Object.keys(operations).length > 0) {
+    const opValidation = validateOperations(operations);
+    errors.push(...opValidation.errors);
+  }
+
+  // Validate endpoints → workflows
+  for (const [route, ep] of Object.entries(endpoints)) {
+    if (ep.handler) continue; // Built-in handler (e.g., "health")
+
+    if (ep.workflow && !workflows[ep.workflow]) {
+      errors.push(`Endpoint "${route}" references unknown workflow: "${ep.workflow}"`);
+    }
+  }
+
+  // Validate automations → workflows
+  for (const [id, auto] of Object.entries(automations)) {
+    if (auto.workflow && !workflows[auto.workflow]) {
+      errors.push(`Automation "${id}" references unknown workflow: "${auto.workflow}"`);
+    }
+
+    if (auto.type === "schedule" && auto.config?.cron) {
+      // Validate cron expression (import synchronously -already loaded)
+      try {
+        const parts = auto.config.cron.trim().split(/\s+/);
+        if (parts.length !== 5) {
+          errors.push(`Automation "${id}" has invalid cron: must have 5 fields`);
+        }
+      } catch (err) {
+        errors.push(`Automation "${id}" has invalid cron: ${err.message}`);
+      }
+    }
+  }
+
+  // Validate workflow steps → operations
+  for (const [wfId, wf] of Object.entries(workflows)) {
+    if (!wf.steps || !Array.isArray(wf.steps)) {
+      errors.push(`Workflow "${wfId}" has no steps array`);
+      continue;
+    }
+
+    for (const step of wf.steps) {
+      if (step.operation && !operations[step.operation]) {
+        errors.push(`Workflow "${wfId}" step "${step.id}" references unknown operation: "${step.operation}"`);
+      }
+    }
+  }
+
+  // Warnings for unused operations
+  const usedOps = new Set();
+  for (const wf of Object.values(workflows)) {
+    for (const step of wf.steps || []) {
+      if (step.operation) usedOps.add(step.operation);
+    }
+  }
+  for (const opId of Object.keys(operations)) {
+    if (!usedOps.has(opId)) {
+      warnings.push(`Operation "${opId}" is defined but never referenced by any workflow`);
+    }
+  }
+
+  return { valid: errors.length === 0, errors, warnings };
+}