0nmcp 1.6.0 → 2.0.0

package/cli.js

@@ -11,8 +11,12 @@
  *   npx 0nmcp init         Initialize ~/.0n directory
  *   npx 0nmcp connect      Interactive connection setup
  *   npx 0nmcp list         List connected services
+ *   npx 0nmcp commands     List named RUNs from SWITCH file
+ *   npx 0nmcp shell        Interactive REPL (type /command)
+ *   npx 0nmcp <alias>      Run a named command from SWITCH file
  *   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)
  * 
  * ═══════════════════════════════════════════════════════════════════════════
  */
@@ -23,6 +27,8 @@ import { fileURLToPath } from 'url';
 import fs from 'fs';
 import os from 'os';
 import readline from 'readline';
+import { loadCommands, listCommands } from './commands.js';
+import { runCommand } from './command-runner.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -87,6 +93,40 @@ ${c.bright}Engine commands:${c.reset}
   ${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}Vault Container commands (Patent Pending #63/990,046):${c.reset}
+
+  ${c.cyan}npx 0nmcp vault create${c.reset}             Create a .0nv vault container
+  ${c.cyan}npx 0nmcp vault open <file>${c.reset}        Open/decrypt a .0nv container
+  ${c.cyan}npx 0nmcp vault inspect <file>${c.reset}     Inspect container metadata (no passphrase)
+  ${c.cyan}npx 0nmcp vault verify <file>${c.reset}      Verify Seal of Truth + signature
+  ${c.cyan}npx 0nmcp vault escrow create${c.reset}      Generate escrow keypairs
+  ${c.cyan}npx 0nmcp vault escrow unwrap${c.reset}      Unwrap container with escrow key
+  ${c.cyan}npx 0nmcp vault transfer <file>${c.reset}    Register a vault transfer
+  ${c.cyan}npx 0nmcp vault revoke <id>${c.reset}        Revoke a transfer ID
+
+${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}Named Runs (Hotkeys):${c.reset}
+
+  ${c.cyan}npx 0nmcp commands${c.reset}                    List named RUNs from SWITCH file
+  ${c.cyan}npx 0nmcp <alias>${c.reset}                     Execute a named RUN
+  ${c.cyan}npx 0nmcp shell${c.reset}                       Interactive REPL (type /command)
+
+  Define commands in ~/.0n/0n-setup.0n:
+
+  {
+    "commands": {
+      "launch": { "type": "pipeline", "steps": [{ "action": "verify" }] },
+      "score":  { "type": "workflow", "workflow": "lead-scoring" }
+    }
+  }
+
 ${c.bright}Serve options:${c.reset}
 
   ${c.cyan}npx 0nmcp serve --port 3000 --host 0.0.0.0${c.reset}
@@ -217,6 +257,20 @@ ${c.bright}Links:${c.reset}
     }
   }
 
+  // Vault Container
+  if (command === 'vault') {
+    console.log(BANNER);
+    await handleVault(args.slice(1));
+    return;
+  }
+
+  // App
+  if (command === 'app') {
+    console.log(BANNER);
+    await handleApp(args.slice(1));
+    return;
+  }
+
   // Engine
   if (command === 'engine') {
     console.log(BANNER);
@@ -233,9 +287,57 @@ ${c.bright}Links:${c.reset}
     return;
   }
 
+  // Commands — list named RUNs from SWITCH file
+  if (command === 'commands' || command === 'aliases') {
+    console.log(BANNER);
+    const cmds = listCommands();
+    if (cmds.length === 0) {
+      console.log(`${c.yellow}No commands defined.${c.reset}`);
+      console.log(`\nAdd a ${c.cyan}"commands"${c.reset} section to ${c.cyan}~/.0n/0n-setup.0n${c.reset}`);
+      console.log(`\nExample:`);
+      console.log(`  {`);
+      console.log(`    "commands": {`);
+      console.log(`      "launch": { "type": "pipeline", "steps": [{ "action": "verify" }] }`);
+      console.log(`    }`);
+      console.log(`  }`);
+      return;
+    }
+    console.log(`${c.bright}Named Runs:${c.reset}\n`);
+    for (const cmd of cmds) {
+      const typeTag = cmd.type === 'pipeline' ? `${c.blue}pipeline${c.reset}` : `${c.green}workflow${c.reset}`;
+      console.log(`  ${c.cyan}0nmcp ${cmd.alias}${c.reset}  ${cmd.description || cmd.name}  [${typeTag}]`);
+    }
+    console.log(`\n${c.bright}Tip:${c.reset} Run ${c.cyan}0nmcp shell${c.reset} for an interactive REPL where you can type ${c.cyan}/launch${c.reset}, ${c.cyan}/hello${c.reset}, etc.`);
+    return;
+  }
+
+  // Shell — interactive REPL
+  if (command === 'shell' || command === 'repl') {
+    console.log(BANNER);
+    await startShell();
+    return;
+  }
+
+  // Dynamic command aliases from SWITCH file
+  const switchCommands = loadCommands();
+  if (switchCommands.has(command)) {
+    console.log(BANNER);
+    const def = switchCommands.get(command);
+    const cliArgs = args.slice(1);
+    await runCommand(command, def, cliArgs);
+    return;
+  }
+
   // Unknown command
   console.log(`${c.red}Unknown command: ${command}${c.reset}`);
-  console.log(`Run ${c.cyan}npx 0nmcp help${c.reset} for usage`);
+  const switchCmds = listCommands();
+  if (switchCmds.length > 0) {
+    console.log(`\n${c.bright}Available named RUNs:${c.reset}`);
+    for (const cmd of switchCmds) {
+      console.log(`  ${c.cyan}0nmcp ${cmd.alias}${c.reset}  ${cmd.description || cmd.name}`);
+    }
+  }
+  console.log(`\nRun ${c.cyan}npx 0nmcp help${c.reset} for usage`);
   process.exit(1);
 }
 
@@ -256,6 +358,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`);
@@ -437,6 +540,229 @@ async function interactiveConnect() {
   console.log(`  Saved to: ${filePath}`);
 }
 
+// ═══════════════════════════════════════════════════════════
+// Vault Container Commands (Patent Pending #63/990,046)
+// ═══════════════════════════════════════════════════════════
+
+function promptInput(prompt) {
+  return new Promise(resolve => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(prompt, answer => { rl.close(); resolve(answer); });
+  });
+}
+
+async function handleVault(args) {
+  const sub = args[0];
+
+  if (!sub || sub === 'help') {
+    console.log(`
+${c.bright}Vault Container Commands${c.reset} ${c.yellow}(Patent Pending #63/990,046)${c.reset}
+
+  ${c.cyan}vault create${c.reset}              Create a .0nv vault container
+    --layers <names>          Comma-separated layer names (default: all)
+    --passphrase <pass>       Encryption passphrase
+    --output <file>           Output file path
+
+  ${c.cyan}vault open <file>${c.reset}          Open/decrypt a .0nv container
+    --passphrase <pass>       Decryption passphrase
+    --layer <name>            Only decrypt this layer
+
+  ${c.cyan}vault inspect <file>${c.reset}       Inspect without decrypting
+
+  ${c.cyan}vault verify <file>${c.reset}        Verify Seal of Truth + Ed25519 signature
+
+  ${c.cyan}vault escrow create${c.reset}        Generate escrow keypairs
+    --parties <n>             Number of parties (1-8)
+
+  ${c.cyan}vault transfer <file>${c.reset}      Register a transfer
+    --to <recipient>          Recipient identifier
+
+  ${c.cyan}vault revoke <id>${c.reset}          Revoke a transfer ID
+
+${c.bright}7 Semantic Layers:${c.reset}
+  workflows, credentials, env_vars, mcp_configs,
+  site_profiles, ai_brain, audit_trail
+`);
+    return;
+  }
+
+  if (sub === 'create') {
+    const { assembleContainer, saveContainer } = await import('./vault/container.js');
+    const { LAYER_NAMES } = await import('./vault/layers.js');
+
+    const passphrase = getFlag(args, '--passphrase') || await promptInput('Passphrase: ');
+    const output = getFlag(args, '--output');
+    const layerStr = getFlag(args, '--layers');
+    const requestedLayers = layerStr ? layerStr.split(',').map(s => s.trim()) : LAYER_NAMES;
+
+    // Build layer data from ~/.0n directory
+    const layers = {};
+    for (const name of requestedLayers) {
+      if (!LAYER_NAMES.includes(name)) {
+        console.log(`${c.red}Invalid layer: ${name}${c.reset}`);
+        process.exit(1);
+      }
+      layers[name] = { placeholder: true, created: new Date().toISOString() };
+    }
+
+    console.log(`\n${c.bright}Creating vault container...${c.reset}`);
+    console.log(`  Layers: ${Object.keys(layers).join(', ')}`);
+
+    try {
+      const result = await assembleContainer({ layers, passphrase });
+      const homePath = path.join(os.homedir(), '.0n', 'vault');
+      if (!fs.existsSync(homePath)) fs.mkdirSync(homePath, { recursive: true });
+      const filePath = output || path.join(homePath, `${result.transferId}.0nv`);
+      saveContainer(result.buffer, filePath);
+
+      console.log(`\n${c.green}✓ Container created${c.reset}`);
+      console.log(`  Transfer ID:   ${c.cyan}${result.transferId}${c.reset}`);
+      console.log(`  Seal of Truth: ${c.cyan}${result.sealHex}${c.reset}`);
+      console.log(`  Layers:        ${result.layerCount}`);
+      console.log(`  Size:          ${result.buffer.length} bytes`);
+      console.log(`  File:          ${c.yellow}${filePath}${c.reset}`);
+    } catch (err) {
+      console.log(`${c.red}Error: ${err.message}${c.reset}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (sub === 'open') {
+    const file = args[1];
+    if (!file) { console.log(`${c.red}Usage: vault open <file.0nv>${c.reset}`); process.exit(1); }
+
+    const { disassembleContainer, loadContainer } = await import('./vault/container.js');
+    const passphrase = getFlag(args, '--passphrase') || await promptInput('Passphrase: ');
+    const layer = getFlag(args, '--layer');
+
+    try {
+      const buffer = loadContainer(file);
+      const result = await disassembleContainer(buffer, passphrase, layer ? [layer] : null);
+
+      console.log(`\n${c.green}✓ Container opened${c.reset}`);
+      console.log(`  Transfer ID: ${c.cyan}${result.metadata.transferId}${c.reset}`);
+      console.log(`  Seal valid:  ${result.seal.valid ? c.green + '✓' : c.red + '✗'}${c.reset}`);
+      console.log(`  Sig valid:   ${result.signature.valid ? c.green + '✓' : c.red + '✗'}${c.reset}`);
+      console.log(`  Layers:`);
+      for (const [name, data] of Object.entries(result.layers)) {
+        const preview = JSON.stringify(data).substring(0, 80);
+        console.log(`    ${c.cyan}${name}${c.reset}: ${preview}...`);
+      }
+    } catch (err) {
+      console.log(`${c.red}Error: ${err.message}${c.reset}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (sub === 'inspect') {
+    const file = args[1];
+    if (!file) { console.log(`${c.red}Usage: vault inspect <file.0nv>${c.reset}`); process.exit(1); }
+
+    const { inspectContainer, loadContainer } = await import('./vault/container.js');
+    try {
+      const buffer = loadContainer(file);
+      const info = inspectContainer(buffer);
+      console.log(`\n${c.bright}Container Inspection${c.reset}`);
+      console.log(JSON.stringify(info, null, 2));
+    } catch (err) {
+      console.log(`${c.red}Error: ${err.message}${c.reset}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (sub === 'verify') {
+    const file = args[1];
+    if (!file) { console.log(`${c.red}Usage: vault verify <file.0nv>${c.reset}`); process.exit(1); }
+
+    const { inspectContainer, loadContainer } = await import('./vault/container.js');
+    try {
+      const buffer = loadContainer(file);
+      const info = inspectContainer(buffer);
+      const verified = info.seal.valid && info.signature.valid;
+
+      console.log(`\n${verified ? c.green + '✓ VERIFIED' : c.red + '✗ FAILED'}${c.reset}`);
+      console.log(`  Seal of Truth: ${info.seal.valid ? c.green + 'Valid' : c.red + 'Invalid'}${c.reset} (${info.seal.algorithm})`);
+      console.log(`  Signature:     ${info.signature.valid ? c.green + 'Valid' : c.red + 'Invalid'}${c.reset} (${info.signature.algorithm})`);
+      console.log(`  Transfer ID:   ${info.metadata.transferId}`);
+      console.log(`  Created:       ${info.metadata.created}`);
+      console.log(`  Patent:        ${info.patent}`);
+    } catch (err) {
+      console.log(`${c.red}Error: ${err.message}${c.reset}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (sub === 'escrow') {
+    const escrowSub = args[1];
+    if (escrowSub === 'create') {
+      const { generatePartyKeys } = await import('./vault/escrow.js');
+      const count = parseInt(getFlag(args, '--parties') || '3');
+
+      console.log(`\n${c.bright}Generating ${count} escrow keypairs...${c.reset}`);
+      const parties = [];
+      for (let i = 0; i < count; i++) {
+        const party = generatePartyKeys();
+        parties.push(party);
+        console.log(`\n  ${c.cyan}Party ${i + 1}${c.reset} (${party.partyId}):`);
+        console.log(`    Public:  ${party.publicKey.toString('hex').substring(0, 32)}...`);
+        console.log(`    Secret:  ${party.secretKey.toString('hex').substring(0, 32)}...`);
+      }
+      console.log(`\n${c.green}✓ ${count} keypairs generated${c.reset}`);
+      console.log(`  ${c.yellow}Save secret keys securely. Share public keys for container creation.${c.reset}`);
+    }
+    return;
+  }
+
+  if (sub === 'transfer') {
+    const file = args[1];
+    if (!file) { console.log(`${c.red}Usage: vault transfer <file.0nv>${c.reset}`); process.exit(1); }
+
+    const { inspectContainer, loadContainer } = await import('./vault/container.js');
+    const { registerTransfer } = await import('./vault/registry.js');
+    const recipient = getFlag(args, '--to');
+
+    try {
+      const buffer = loadContainer(file);
+      const info = inspectContainer(buffer);
+      const result = registerTransfer(info.metadata.transferId, info.seal.hash, { recipient });
+
+      if (result.success) {
+        console.log(`\n${c.green}✓ Transfer registered${c.reset}`);
+        console.log(`  Transfer ID: ${c.cyan}${info.metadata.transferId}${c.reset}`);
+        if (recipient) console.log(`  Recipient:   ${recipient}`);
+      } else {
+        console.log(`\n${c.red}✗ ${result.error}${c.reset}`);
+      }
+    } catch (err) {
+      console.log(`${c.red}Error: ${err.message}${c.reset}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (sub === 'revoke') {
+    const transferId = args[1];
+    if (!transferId) { console.log(`${c.red}Usage: vault revoke <transferId>${c.reset}`); process.exit(1); }
+
+    const { revokeTransfer } = await import('./vault/registry.js');
+    const result = revokeTransfer(transferId);
+
+    if (result.success) {
+      console.log(`\n${c.green}✓ Transfer revoked: ${transferId}${c.reset}`);
+    } else {
+      console.log(`\n${c.red}✗ ${result.error}${c.reset}`);
+    }
+    return;
+  }
+
+  console.log(`${c.red}Unknown vault command: ${sub}${c.reset}`);
+  console.log(`Run ${c.cyan}0nmcp vault help${c.reset} for usage.`);
+}
+
 async function handleEngine(args) {
   const sub = args[0];
 
@@ -677,4 +1003,344 @@ async function handleEngine(args) {
   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);
+}
+
+async function startShell() {
+  const cmds = loadCommands();
+  const aliases = [...cmds.keys()];
+  const builtins = ['help', 'commands', 'list', 'exit', 'quit'];
+  const allCompletions = [...builtins, ...aliases];
+
+  console.log(`${c.bright}0nMCP Interactive Shell${c.reset}`);
+  console.log(`Type ${c.cyan}/command${c.reset} to run a named RUN, ${c.cyan}/commands${c.reset} to list, ${c.cyan}/exit${c.reset} to quit.\n`);
+
+  if (aliases.length > 0) {
+    console.log(`${c.bright}Available commands:${c.reset} ${aliases.map(a => c.cyan + '/' + a + c.reset).join(', ')}\n`);
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: `${c.green}0n>${c.reset} `,
+    completer: (line) => {
+      const input = line.startsWith('/') ? line.slice(1) : line;
+      const hits = allCompletions.filter(c2 => c2.startsWith(input));
+      return [hits.map(h => '/' + h), line];
+    },
+  });
+
+  rl.prompt();
+
+  rl.on('line', async (line) => {
+    const input = line.trim();
+    if (!input) {
+      rl.prompt();
+      return;
+    }
+
+    // Strip leading / if present
+    const raw = input.startsWith('/') ? input.slice(1) : input;
+    const parts = raw.split(/\s+/);
+    const cmd = parts[0];
+    const cmdArgs = parts.slice(1);
+
+    if (cmd === 'exit' || cmd === 'quit') {
+      console.log(`\n${c.cyan}Goodbye!${c.reset}`);
+      rl.close();
+      process.exit(0);
+    }
+
+    if (cmd === 'help') {
+      console.log(`\n${c.bright}Shell Commands:${c.reset}`);
+      console.log(`  ${c.cyan}/commands${c.reset}   List all named RUNs`);
+      console.log(`  ${c.cyan}/list${c.reset}       Show connected services`);
+      console.log(`  ${c.cyan}/exit${c.reset}       Exit the shell`);
+      if (aliases.length > 0) {
+        console.log(`\n${c.bright}Named RUNs:${c.reset}`);
+        for (const a of aliases) {
+          const def = cmds.get(a);
+          console.log(`  ${c.cyan}/${a}${c.reset}  ${def.description || def.name || ''}`);
+        }
+      }
+      console.log('');
+      rl.prompt();
+      return;
+    }
+
+    if (cmd === 'commands') {
+      if (aliases.length === 0) {
+        console.log(`\n${c.yellow}No commands defined in SWITCH file.${c.reset}\n`);
+      } else {
+        console.log(`\n${c.bright}Named RUNs:${c.reset}`);
+        for (const a of aliases) {
+          const def = cmds.get(a);
+          console.log(`  ${c.cyan}/${a}${c.reset}  ${def.description || def.name || ''}`);
+        }
+        console.log('');
+      }
+      rl.prompt();
+      return;
+    }
+
+    if (cmd === 'list') {
+      const connectionsDir = path.join(DOT_ON_DIR, 'connections');
+      if (fs.existsSync(connectionsDir)) {
+        const files = fs.readdirSync(connectionsDir).filter(f => f.endsWith('.0n'));
+        console.log(`\n${c.bright}Connected Services:${c.reset}`);
+        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}`);
+          } catch {
+            console.log(`  ${c.red}●${c.reset} ${file} (error)`);
+          }
+        }
+        console.log('');
+      } else {
+        console.log(`\n${c.yellow}No connections found.${c.reset}\n`);
+      }
+      rl.prompt();
+      return;
+    }
+
+    // Try to run as a named command
+    if (cmds.has(cmd)) {
+      console.log('');
+      try {
+        await runCommand(cmd, cmds.get(cmd), cmdArgs);
+      } catch (err) {
+        console.log(`${c.red}Error: ${err.message}${c.reset}`);
+      }
+      console.log('');
+      rl.prompt();
+      return;
+    }
+
+    console.log(`${c.yellow}Unknown command: ${cmd}${c.reset}`);
+    console.log(`Type ${c.cyan}/help${c.reset} for available commands.`);
+    rl.prompt();
+  });
+
+  rl.on('close', () => {
+    process.exit(0);
+  });
+}
+
 main().catch(console.error);