0nmcp 1.5.0 → 1.7.0

package/cli.js

@@ -12,6 +12,8 @@
  *   npx 0nmcp connect      Interactive connection setup
  *   npx 0nmcp list         List connected services
  *   npx 0nmcp migrate      Migrate from ~/.0nmcp to ~/.0n
+ *   npx 0nmcp engine       Engine commands (import, verify, platforms, export, open)
+ *   npx 0nmcp app          Application commands (run, build, inspect, validate, list)
  * 
  * ═══════════════════════════════════════════════════════════════════════════
  */
@@ -78,6 +80,22 @@ ${c.bright}Usage:${c.reset}
   ${c.cyan}npx 0nmcp list${c.reset}         List connected services
   ${c.cyan}npx 0nmcp migrate${c.reset}      Migrate from ~/.0nmcp to ~/.0n
 
+${c.bright}Engine commands:${c.reset}
+
+  ${c.cyan}npx 0nmcp engine import <file>${c.reset}    Import credentials from .env/CSV/JSON
+  ${c.cyan}npx 0nmcp engine verify${c.reset}           Verify all connected API keys
+  ${c.cyan}npx 0nmcp engine platforms${c.reset}        Generate AI platform configs
+  ${c.cyan}npx 0nmcp engine export${c.reset}           Export .0n bundle (AI Brain)
+  ${c.cyan}npx 0nmcp engine open <bundle>${c.reset}    Open/inspect a .0n bundle
+
+${c.bright}Application commands:${c.reset}
+
+  ${c.cyan}npx 0nmcp app run <file>${c.reset}          Start application server
+  ${c.cyan}npx 0nmcp app build${c.reset}               Build application bundle
+  ${c.cyan}npx 0nmcp app inspect <file>${c.reset}      Show application metadata
+  ${c.cyan}npx 0nmcp app validate <file>${c.reset}     Validate application structure
+  ${c.cyan}npx 0nmcp app list${c.reset}                List installed applications
+
 ${c.bright}Serve options:${c.reset}
 
   ${c.cyan}npx 0nmcp serve --port 3000 --host 0.0.0.0${c.reset}
@@ -208,6 +226,20 @@ ${c.bright}Links:${c.reset}
     }
   }
 
+  // App
+  if (command === 'app') {
+    console.log(BANNER);
+    await handleApp(args.slice(1));
+    return;
+  }
+
+  // Engine
+  if (command === 'engine') {
+    console.log(BANNER);
+    await handleEngine(args.slice(1));
+    return;
+  }
+
   // Migrate
   if (command === 'migrate') {
     console.log(BANNER);
@@ -240,6 +272,7 @@ function initDotOn() {
     path.join(DOT_ON_DIR, 'snapshots'),
     path.join(DOT_ON_DIR, 'history'),
     path.join(DOT_ON_DIR, 'cache'),
+    path.join(DOT_ON_DIR, 'apps'),
   ];
 
   console.log(`${c.bright}Initializing ~/.0n directory...${c.reset}\n`);
@@ -421,4 +454,463 @@ async function interactiveConnect() {
   console.log(`  Saved to: ${filePath}`);
 }
 
+async function handleEngine(args) {
+  const sub = args[0];
+
+  if (!sub || sub === 'help') {
+    console.log(`${c.bright}Engine — .0n Conversion Engine${c.reset}\n`);
+    console.log(`  ${c.cyan}import <file>${c.reset}     Import credentials from .env, CSV, or JSON`);
+    console.log(`  ${c.cyan}verify${c.reset}            Verify all connected API keys`);
+    console.log(`  ${c.cyan}platforms${c.reset}         Generate AI platform configs`);
+    console.log(`  ${c.cyan}export${c.reset}            Export .0n bundle (AI Brain)`);
+    console.log(`  ${c.cyan}open <bundle>${c.reset}     Open/inspect a .0n bundle file\n`);
+    return;
+  }
+
+  if (sub === 'import') {
+    const source = args[1];
+    if (!source) {
+      console.log(`${c.red}Usage: npx 0nmcp engine import <file>${c.reset}`);
+      process.exit(1);
+    }
+    try {
+      const { parseFile } = await import('./engine/parser.js');
+      const { mapEnvVars, groupByService, validateMapping } = await import('./engine/mapper.js');
+      const { entries } = parseFile(source);
+      const { mapped, unmapped } = mapEnvVars(entries);
+      const groups = groupByService(mapped);
+
+      console.log(`${c.bright}Import Results:${c.reset}\n`);
+      console.log(`  Entries found:  ${entries.length}`);
+      console.log(`  Mapped:         ${mapped.length}`);
+      console.log(`  Unmapped:       ${unmapped.length}\n`);
+
+      console.log(`${c.bright}Services Detected:${c.reset}\n`);
+      for (const [service, group] of Object.entries(groups)) {
+        const validation = validateMapping(service, group.credentials);
+        const status = validation.valid ? `${c.green}complete${c.reset}` : `${c.yellow}missing: ${validation.missing.join(', ')}${c.reset}`;
+        console.log(`  ${c.green}●${c.reset} ${c.bright}${service}${c.reset} — ${Object.keys(group.credentials).length} credentials (${status})`);
+      }
+
+      if (unmapped.length > 0) {
+        console.log(`\n${c.yellow}Unmapped variables:${c.reset} ${unmapped.map(u => u.key).join(', ')}`);
+      }
+
+      console.log(`\n${c.bright}Next:${c.reset} Run ${c.cyan}npx 0nmcp engine export${c.reset} to create a portable .0n bundle.`);
+    } catch (err) {
+      console.log(`${c.red}Error: ${err.message}${c.reset}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (sub === 'verify') {
+    try {
+      const { verifyAll } = await import('./engine/validator.js');
+      const { existsSync, readdirSync, readFileSync } = await import('fs');
+      const connectionsDir = path.join(DOT_ON_DIR, 'connections');
+
+      if (!existsSync(connectionsDir)) {
+        console.log(`${c.yellow}No connections found. Run ${c.cyan}npx 0nmcp connect${c.reset} first.`);
+        return;
+      }
+
+      const files = readdirSync(connectionsDir).filter(f => f.endsWith('.0n') || f.endsWith('.0n.json'));
+      const connections = {};
+      for (const file of files) {
+        try {
+          const data = JSON.parse(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;
+      }
+
+      console.log(`${c.bright}Verifying ${Object.keys(connections).length} connections...${c.reset}\n`);
+
+      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} ${c.bright}${service}${c.reset}${latency}${result.error ? ` — ${result.error}` : ''}`);
+      }
+
+      console.log(`\n${c.bright}Summary:${c.reset} ${summary.valid}/${summary.total} valid`);
+    } catch (err) {
+      console.log(`${c.red}Error: ${err.message}${c.reset}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (sub === 'platforms') {
+    try {
+      const { getPlatformInfo, generatePlatformConfig } = await import('./engine/platforms.js');
+      const platform = args[1];
+
+      if (platform) {
+        const config = generatePlatformConfig(platform);
+        console.log(`${c.bright}${config.name} Configuration:${c.reset}\n`);
+        console.log(`  Config path: ${config.path || '(HTTP only)'}`);
+        console.log(`  Format: ${config.format}\n`);
+        console.log(typeof config.config === 'string' ? config.config : JSON.stringify(config.config, null, 2));
+      } else {
+        const info = getPlatformInfo();
+        console.log(`${c.bright}Supported AI Platforms:${c.reset}\n`);
+        for (const p of info) {
+          const status = p.installed ? `${c.green}installed${c.reset}` : `${c.yellow}not installed${c.reset}`;
+          console.log(`  ${p.installed ? c.green + '●' : c.blue + '○'}${c.reset} ${c.bright}${p.name}${c.reset} (${status})`);
+          if (p.configPath) console.log(`    ${p.configPath}`);
+        }
+        console.log(`\n${c.bright}Tip:${c.reset} Run ${c.cyan}npx 0nmcp engine platforms <name>${c.reset} to see config for a specific platform.`);
+        console.log(`     Names: claude_desktop, cursor, windsurf, gemini, continue, cline, openai`);
+      }
+    } catch (err) {
+      console.log(`${c.red}Error: ${err.message}${c.reset}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (sub === 'export') {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise(resolve => rl.question(q, resolve));
+
+    try {
+      const passphrase = await ask('Bundle passphrase: ');
+      if (!passphrase) {
+        console.log(`${c.red}Passphrase required.${c.reset}`);
+        rl.close();
+        process.exit(1);
+      }
+      const name = await ask(`Bundle name (default: 0n AI Brain): `) || '0n AI Brain';
+      rl.close();
+
+      const { createBundle } = await import('./engine/bundler.js');
+      const { existsSync, readdirSync, readFileSync } = await import('fs');
+      const connectionsDir = path.join(DOT_ON_DIR, 'connections');
+
+      if (!existsSync(connectionsDir)) {
+        console.log(`${c.yellow}No connections found.${c.reset}`);
+        return;
+      }
+
+      const files = readdirSync(connectionsDir).filter(f => f.endsWith('.0n') || f.endsWith('.0n.json'));
+      const connections = {};
+      for (const file of files) {
+        try {
+          const data = JSON.parse(readFileSync(path.join(connectionsDir, file), 'utf8'));
+          if (data.$0n?.sealed) continue;
+          connections[data.service] = {
+            credentials: data.auth?.credentials || {},
+            name: data.$0n?.name || data.service,
+            authType: data.auth?.type || 'api_key',
+            environment: data.environment || 'production',
+          };
+        } catch { /* skip */ }
+      }
+
+      if (Object.keys(connections).length === 0) {
+        console.log(`${c.yellow}No exportable connections found.${c.reset}`);
+        return;
+      }
+
+      console.log(`\n${c.bright}Creating AI Brain bundle...${c.reset}\n`);
+
+      const result = createBundle({ connections, passphrase, name, platforms: 'all' });
+
+      console.log(`${c.green}${c.bright}Bundle created!${c.reset}\n`);
+      console.log(`  Path:        ${result.path}`);
+      console.log(`  Services:    ${result.manifest.services.join(', ')}`);
+      console.log(`  Connections: ${result.manifest.connection_count}`);
+      console.log(`  Platforms:   ${result.manifest.platform_count}`);
+      console.log(`  Encryption:  ${result.manifest.encryption.method}`);
+      console.log(`\n${c.bright}Share this file — recipient opens with:${c.reset} ${c.cyan}npx 0nmcp engine open <bundle>${c.reset}`);
+    } catch (err) {
+      console.log(`${c.red}Error: ${err.message}${c.reset}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (sub === 'open') {
+    const bundlePath = args[1];
+    if (!bundlePath) {
+      console.log(`${c.red}Usage: npx 0nmcp engine open <bundle.0n>${c.reset}`);
+      process.exit(1);
+    }
+
+    try {
+      const { inspectBundle, openBundle } = await import('./engine/bundler.js');
+
+      // First inspect
+      const info = inspectBundle(bundlePath);
+      console.log(`${c.bright}Bundle: ${info.name}${c.reset}\n`);
+      console.log(`  Created:  ${info.created}`);
+      console.log(`  Services: ${info.services.map(s => s.service).join(', ')}`);
+      console.log(`  Platforms: ${info.platforms.join(', ')}`);
+      if (info.includes.length > 0) {
+        console.log(`  Includes: ${info.includes.map(i => i.name).join(', ')}`);
+      }
+
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const ask = (q) => new Promise(resolve => rl.question(q, resolve));
+
+      const passphrase = await ask('\nPassphrase to decrypt (leave empty to inspect only): ');
+      rl.close();
+
+      if (!passphrase) {
+        console.log(`\n${c.yellow}Inspect only — no credentials extracted.${c.reset}`);
+        return;
+      }
+
+      const result = openBundle(bundlePath, passphrase);
+
+      console.log(`\n${c.green}${c.bright}Bundle opened!${c.reset}\n`);
+      console.log(`  Connections imported: ${result.connections.join(', ')}`);
+      if (result.includes.length > 0) {
+        console.log(`  Files extracted: ${result.includes.join(', ')}`);
+      }
+      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}`);
+        }
+      }
+      console.log(`\n${c.bright}Tip:${c.reset} Run ${c.cyan}npx 0nmcp engine platforms${c.reset} to install AI platform configs.`);
+    } catch (err) {
+      console.log(`${c.red}Error: ${err.message}${c.reset}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  console.log(`${c.red}Unknown engine command: ${sub}${c.reset}`);
+  console.log(`Run ${c.cyan}npx 0nmcp engine help${c.reset} for usage`);
+  process.exit(1);
+}
+
+async function handleApp(args) {
+  const sub = args[0];
+
+  if (!sub || sub === 'help') {
+    console.log(`${c.bright}Application Engine — Build & Run .0n Applications${c.reset}\n`);
+    console.log(`  ${c.cyan}run <file>${c.reset}        Start application server`);
+    console.log(`  ${c.cyan}build${c.reset}             Build application bundle`);
+    console.log(`  ${c.cyan}inspect <file>${c.reset}    Show application metadata`);
+    console.log(`  ${c.cyan}validate <file>${c.reset}   Validate application structure`);
+    console.log(`  ${c.cyan}list${c.reset}              List installed applications\n`);
+    return;
+  }
+
+  if (sub === 'run') {
+    const appFile = args[1];
+    if (!appFile) {
+      console.log(`${c.red}Usage: npx 0nmcp app run <file.0n> [--port 3000] [--passphrase <pw>]${c.reset}`);
+      process.exit(1);
+    }
+
+    const port = Number(getFlag(args, '--port', 3000));
+    let passphrase = getFlag(args, '--passphrase', null);
+
+    if (!passphrase) {
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const ask = (q) => new Promise(resolve => rl.question(q, resolve));
+      passphrase = await ask('Application passphrase: ');
+      rl.close();
+    }
+
+    if (!passphrase) {
+      console.log(`${c.red}Passphrase required.${c.reset}`);
+      process.exit(1);
+    }
+
+    try {
+      const { openApplication } = await import('./engine/app-builder.js');
+      const { Application } = await import('./engine/application.js');
+      const { ApplicationServer } = await import('./engine/app-server.js');
+
+      const bundle = openApplication(appFile, passphrase);
+      const application = new Application(bundle, { passphrase });
+      const server = new ApplicationServer(application);
+
+      await server.start({ port });
+
+      // Keep alive
+      process.on('SIGINT', async () => {
+        console.log(`\n${c.yellow}Shutting down...${c.reset}`);
+        await server.stop();
+        process.exit(0);
+      });
+    } catch (err) {
+      console.log(`${c.red}Error: ${err.message}${c.reset}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (sub === 'build') {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise(resolve => rl.question(q, resolve));
+
+    try {
+      const appName = await ask('Application name: ') || '0n Application';
+      const passphrase = await ask('Bundle passphrase: ');
+      if (!passphrase) {
+        console.log(`${c.red}Passphrase required.${c.reset}`);
+        rl.close();
+        process.exit(1);
+      }
+      rl.close();
+
+      const { createApplication } = await import('./engine/app-builder.js');
+
+      // Load local connections
+      const connectionsDir = path.join(DOT_ON_DIR, 'connections');
+      const connections = {};
+      if (fs.existsSync(connectionsDir)) {
+        const files = fs.readdirSync(connectionsDir).filter(f => f.endsWith('.0n') || f.endsWith('.0n.json'));
+        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 || {},
+              name: data.$0n?.name || data.service,
+              authType: data.auth?.type || 'api_key',
+              environment: data.environment || 'production',
+            };
+          } catch { /* skip */ }
+        }
+      }
+
+      // Load local workflows
+      const { loadLocalWorkflows } = await import('./engine/index.js');
+      const workflows = loadLocalWorkflows();
+
+      console.log(`\n${c.bright}Building application...${c.reset}\n`);
+
+      const result = createApplication({
+        name: appName,
+        passphrase,
+        connections,
+        workflows,
+      });
+
+      console.log(`${c.green}${c.bright}Application built!${c.reset}\n`);
+      console.log(`  Path:        ${result.path}`);
+      console.log(`  Connections: ${result.manifest.connection_count}`);
+      console.log(`  Workflows:   ${result.manifest.workflow_count}`);
+      console.log(`\n${c.bright}Run with:${c.reset} ${c.cyan}npx 0nmcp app run ${result.path}${c.reset}`);
+    } catch (err) {
+      console.log(`${c.red}Error: ${err.message}${c.reset}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (sub === 'inspect') {
+    const appFile = args[1];
+    if (!appFile) {
+      console.log(`${c.red}Usage: npx 0nmcp app inspect <file.0n>${c.reset}`);
+      process.exit(1);
+    }
+
+    try {
+      const { inspectApplication } = await import('./engine/app-builder.js');
+      const info = inspectApplication(appFile);
+
+      console.log(`${c.bright}Application: ${info.name}${c.reset}\n`);
+      console.log(`  Version:     ${info.version}`);
+      console.log(`  Author:      ${info.author || '—'}`);
+      console.log(`  Created:     ${info.created}`);
+      if (info.description) console.log(`  Description: ${info.description}`);
+      console.log(`\n  Connections: ${info.connections.map(c2 => c2.service).join(', ') || 'none'}`);
+      console.log(`  Workflows:   ${info.workflows.join(', ') || 'none'}`);
+      console.log(`  Operations:  ${info.operations.join(', ') || 'none'}`);
+      console.log(`  Endpoints:   ${info.endpoints.join(', ') || 'none'}`);
+      console.log(`  Automations: ${info.automations.join(', ') || 'none'}`);
+    } catch (err) {
+      console.log(`${c.red}Error: ${err.message}${c.reset}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (sub === 'validate') {
+    const appFile = args[1];
+    if (!appFile) {
+      console.log(`${c.red}Usage: npx 0nmcp app validate <file.0n>${c.reset}`);
+      process.exit(1);
+    }
+
+    try {
+      const { validateApplication } = await import('./engine/app-builder.js');
+      const data = JSON.parse(fs.readFileSync(appFile, 'utf8'));
+      const result = validateApplication(data);
+
+      if (result.valid) {
+        console.log(`${c.green}${c.bright}Application is valid!${c.reset}`);
+      } else {
+        console.log(`${c.red}${c.bright}Validation failed:${c.reset}\n`);
+        for (const err of result.errors) {
+          console.log(`  ${c.red}●${c.reset} ${err}`);
+        }
+      }
+
+      if (result.warnings?.length > 0) {
+        console.log(`\n${c.yellow}Warnings:${c.reset}`);
+        for (const w of result.warnings) {
+          console.log(`  ${c.yellow}○${c.reset} ${w}`);
+        }
+      }
+    } catch (err) {
+      console.log(`${c.red}Error: ${err.message}${c.reset}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (sub === 'list') {
+    const appsDir = path.join(DOT_ON_DIR, 'apps');
+    if (!fs.existsSync(appsDir)) {
+      console.log(`${c.yellow}No applications installed.${c.reset}`);
+      return;
+    }
+
+    const files = fs.readdirSync(appsDir).filter(f => f.endsWith('.0n') || f.endsWith('.0n.json'));
+    if (files.length === 0) {
+      console.log(`${c.yellow}No applications installed.${c.reset}`);
+      return;
+    }
+
+    console.log(`${c.bright}Installed Applications:${c.reset}\n`);
+
+    for (const file of files) {
+      try {
+        const data = JSON.parse(fs.readFileSync(path.join(appsDir, file), 'utf8'));
+        if (data.$0n?.type !== 'application') continue;
+
+        const wfCount = Object.keys(data.workflows || {}).length;
+        const epCount = Object.keys(data.endpoints || {}).length;
+        console.log(`  ${c.green}●${c.reset} ${c.bright}${data.$0n.name || file}${c.reset} v${data.$0n.version || '1.0.0'}`);
+        console.log(`    ${wfCount} workflows, ${epCount} endpoints`);
+        console.log(`    ${file}`);
+        console.log('');
+      } catch {
+        console.log(`  ${c.red}●${c.reset} ${file} (error reading)`);
+      }
+    }
+    return;
+  }
+
+  console.log(`${c.red}Unknown app command: ${sub}${c.reset}`);
+  console.log(`Run ${c.cyan}npx 0nmcp app help${c.reset} for usage`);
+  process.exit(1);
+}
+
 main().catch(console.error);

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;