0nmcp 1.6.0 → 2.0.0

package/engine/index.js

@@ -2,16 +2,21 @@
 // 0nMCP — Engine Module
 // ============================================================
 // The .0n Conversion Engine — import credentials, verify keys,
-// generate platform configs, and create portable AI Brain
-// bundle files.
+// generate platform configs, create portable AI Brain bundles,
+// and build/run application bundles.
 //
-// 6 MCP Tools:
+// 11 MCP Tools:
 //   engine_import    — Import credentials from .env/CSV/JSON
 //   engine_verify    — Verify API keys with test calls
 //   engine_platforms — Generate platform configs
 //   engine_export    — Export .0n bundle from connections
 //   engine_bundle    — Full pipeline: import → map → bundle
 //   engine_open      — Open a .0n bundle file
+//   app_build        — Build a .0n application bundle
+//   app_open         — Open/extract a .0n application
+//   app_inspect      — Show application metadata (no passphrase)
+//   app_validate     — Validate application cross-references
+//   app_list         — List installed applications
 //
 // Patent Pending: US Provisional Patent Application #63/968,814
 // ============================================================
@@ -23,6 +28,11 @@ export { mapEnvVars, groupByService, validateMapping } from "./mapper.js";
 export { verifyCredentials, verifyAll } from "./validator.js";
 export { generatePlatformConfig, generateAllPlatformConfigs, installPlatformConfig, getPlatformInfo, listPlatforms } from "./platforms.js";
 export { createBundle, openBundle, inspectBundle, verifyBundle } from "./bundler.js";
+export { OperationRegistry, validateOperations } from "./operations.js";
+export { parseCron, CronScheduler } from "./scheduler.js";
+export { Application } from "./application.js";
+export { createApplication, openApplication, inspectApplication, validateApplication } from "./app-builder.js";
+export { ApplicationServer } from "./app-server.js";
 
 // ── Imports for tool handlers ──────────────────────────────
 import { parseFile } from "./parser.js";
@@ -30,11 +40,14 @@ import { mapEnvVars, groupByService, validateMapping } from "./mapper.js";
 import { verifyCredentials, verifyAll } from "./validator.js";
 import { generatePlatformConfig, generateAllPlatformConfigs, getPlatformInfo, listPlatforms } from "./platforms.js";
 import { createBundle, openBundle, inspectBundle, verifyBundle } from "./bundler.js";
+import { createApplication, openApplication, inspectApplication, validateApplication } from "./app-builder.js";
 import { existsSync, readFileSync, readdirSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 
 const CONNECTIONS_DIR = join(homedir(), ".0n", "connections");
+const APPS_DIR = join(homedir(), ".0n", "apps");
+const WORKFLOWS_DIR = join(homedir(), ".0n", "workflows");
 
 /**
  * Load all connections from ~/.0n/connections/ for bundling.
@@ -387,4 +400,269 @@ Example: engine_open({ bundle: "/path/to/bundle.0n", passphrase: "my-passphrase"
       }
     }
   );
+
+  // ═══════════════════════════════════════════════════════════
+  // Application Engine Tools (v1.7.0)
+  // ═══════════════════════════════════════════════════════════
+
+  // ─── app_build ────────────────────────────────────────────
+  server.tool(
+    "app_build",
+    `Build a .0n application bundle — a portable encrypted file containing
+endpoints, workflows, operations, automations, and connections.
+Deploy anywhere with: 0nmcp app run <file>
+
+Example: app_build({ name: "Lead Scorer", passphrase: "secret", workflows: {...}, endpoints: {...} })`,
+    {
+      name: z.string().describe("Application name"),
+      passphrase: z.string().describe("Passphrase to encrypt the bundle"),
+      workflows: z.record(z.any()).optional().describe("Workflow definitions { id: workflowDef }"),
+      connections: z.record(z.any()).optional().describe("Connections to include { service: { credentials } }"),
+      endpoints: z.record(z.any()).optional().describe("Endpoint definitions { 'METHOD /path': def }"),
+      operations: z.record(z.any()).optional().describe("Reusable operation definitions { id: def }"),
+      automations: z.record(z.any()).optional().describe("Automation definitions { id: def }"),
+      environment: z.object({
+        variables: z.record(z.string()).optional(),
+        secrets: z.record(z.string()).optional(),
+        settings: z.record(z.any()).optional(),
+        feature_flags: z.record(z.boolean()).optional(),
+      }).optional().describe("Environment configuration"),
+      output: z.string().optional().describe("Output file path"),
+    },
+    async ({ name, passphrase, workflows, connections, endpoints, operations, automations, environment, output }) => {
+      try {
+        // If no connections provided, load local connections
+        const conns = connections || loadLocalConnections();
+
+        const result = createApplication({
+          name,
+          passphrase,
+          connections: conns,
+          workflows: workflows || {},
+          endpoints: endpoints || {},
+          operations: operations || {},
+          automations: automations || {},
+          environment: environment || {},
+          output,
+        });
+
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              status: "built",
+              path: result.path,
+              manifest: result.manifest,
+              message: `Application "${name}" built at ${result.path}. Run with: 0nmcp app run ${result.path}`,
+            }, null, 2),
+          }],
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ status: "failed", error: err.message }, null, 2) }] };
+      }
+    }
+  );
+
+  // ─── app_open ─────────────────────────────────────────────
+  server.tool(
+    "app_open",
+    `Open a .0n application bundle file.
+Decrypts and extracts the application for local use.
+
+Example: app_open({ bundle: "/path/to/app.0n", passphrase: "secret" })`,
+    {
+      bundle: z.string().describe("Path to .0n application file"),
+      passphrase: z.string().optional().describe("Passphrase to decrypt — omit to inspect only"),
+    },
+    async ({ bundle, passphrase }) => {
+      try {
+        if (!passphrase) {
+          const info = inspectApplication(bundle);
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                status: "inspected",
+                ...info,
+                message: `Application "${info.name}" has ${info.workflows.length} workflows, ${info.endpoints.length} endpoints. Provide passphrase to extract.`,
+              }, null, 2),
+            }],
+          };
+        }
+
+        const bundleData = openApplication(bundle, passphrase);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              status: "opened",
+              name: bundleData.$0n.name,
+              workflows: Object.keys(bundleData.workflows || {}),
+              endpoints: Object.keys(bundleData.endpoints || {}),
+              operations: Object.keys(bundleData.operations || {}),
+              automations: Object.keys(bundleData.automations || {}),
+              connections: (bundleData.connections || []).map(c => c.service),
+              message: `Application "${bundleData.$0n.name}" opened. Run with: 0nmcp app run ${bundle}`,
+            }, null, 2),
+          }],
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ status: "failed", error: err.message }, null, 2) }] };
+      }
+    }
+  );
+
+  // ─── app_inspect ──────────────────────────────────────────
+  server.tool(
+    "app_inspect",
+    `Inspect a .0n application bundle without passphrase.
+Shows metadata, endpoints, workflows, and automations.
+
+Example: app_inspect({ bundle: "/path/to/app.0n" })`,
+    {
+      bundle: z.string().describe("Path to .0n application file"),
+    },
+    async ({ bundle }) => {
+      try {
+        const info = inspectApplication(bundle);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              status: "inspected",
+              ...info,
+            }, null, 2),
+          }],
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ status: "failed", error: err.message }, null, 2) }] };
+      }
+    }
+  );
+
+  // ─── app_validate ─────────────────────────────────────────
+  server.tool(
+    "app_validate",
+    `Validate a .0n application bundle's structure and cross-references.
+Checks that endpoints reference valid workflows, workflows reference valid operations, etc.
+
+Example: app_validate({ bundle: "/path/to/app.0n", passphrase: "secret" })`,
+    {
+      bundle: z.string().describe("Path to .0n application file"),
+      passphrase: z.string().optional().describe("Passphrase to decrypt for full validation"),
+    },
+    async ({ bundle, passphrase }) => {
+      try {
+        const raw = readFileSync(bundle, "utf-8");
+        const bundleData = JSON.parse(raw);
+
+        const result = validateApplication(bundleData);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              status: result.valid ? "valid" : "invalid",
+              ...result,
+              message: result.valid
+                ? "Application bundle is valid."
+                : `Found ${result.errors.length} error(s).`,
+            }, null, 2),
+          }],
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ status: "failed", error: err.message }, null, 2) }] };
+      }
+    }
+  );
+
+  // ─── app_list ─────────────────────────────────────────────
+  server.tool(
+    "app_list",
+    `List installed .0n applications from ~/.0n/apps/.
+
+Example: app_list({})`,
+    {},
+    async () => {
+      try {
+        if (!existsSync(APPS_DIR)) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                status: "ok",
+                count: 0,
+                apps: [],
+                message: "No applications installed. Build one with app_build.",
+              }, null, 2),
+            }],
+          };
+        }
+
+        const files = readdirSync(APPS_DIR).filter(f => f.endsWith(".0n") || f.endsWith(".0n.json"));
+        const apps = [];
+
+        for (const file of files) {
+          try {
+            const filePath = join(APPS_DIR, file);
+            const data = JSON.parse(readFileSync(filePath, "utf-8"));
+            if (data.$0n?.type !== "application") continue;
+
+            apps.push({
+              name: data.$0n.name || file,
+              version: data.$0n.version || "1.0.0",
+              description: data.$0n.description || "",
+              author: data.$0n.author || "",
+              created: data.$0n.created,
+              file,
+              path: filePath,
+              workflows: Object.keys(data.workflows || {}).length,
+              endpoints: Object.keys(data.endpoints || {}).length,
+              operations: Object.keys(data.operations || {}).length,
+              automations: Object.keys(data.automations || {}).length,
+              connections: (data.connections || []).length,
+            });
+          } catch { /* skip invalid */ }
+        }
+
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              status: "ok",
+              count: apps.length,
+              apps,
+              message: apps.length > 0
+                ? `Found ${apps.length} application(s). Run with: 0nmcp app run <file>`
+                : "No applications installed.",
+            }, null, 2),
+          }],
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ status: "failed", error: err.message }, null, 2) }] };
+      }
+    }
+  );
+}
+
+/**
+ * Load local workflows from ~/.0n/workflows/ for bundling into applications.
+ * @param {string[]} [ids] — Specific workflow IDs to load (default: all)
+ * @returns {Record<string, object>}
+ */
+export function loadLocalWorkflows(ids) {
+  const workflows = {};
+  if (!existsSync(WORKFLOWS_DIR)) return workflows;
+
+  const files = readdirSync(WORKFLOWS_DIR);
+  for (const file of files) {
+    if (!file.endsWith(".0n") && !file.endsWith(".0n.json")) continue;
+    try {
+      const data = JSON.parse(readFileSync(join(WORKFLOWS_DIR, file), "utf-8"));
+      if (!data.$0n || data.$0n.type !== "workflow") continue;
+      const id = file.replace(/\.0n(\.json)?$/, "");
+      if (ids && !ids.includes(id)) continue;
+      workflows[id] = data;
+    } catch { /* skip invalid */ }
+  }
+  return workflows;
 }

package/engine/operations.js

@@ -0,0 +1,227 @@
+// ============================================================
+// 0nMCP -Engine: Operation Registry
+// ============================================================
+// Reusable action definitions referenced by workflow steps
+// via "operation": "id". Wraps INTERNAL_ACTIONS from workflow.js
+// for type: "internal". Service operations delegate to
+// catalog-based execution.
+//
+// Patent Pending: US Provisional Patent Application #63/968,814
+// ============================================================
+
+/**
+ * Registry of reusable operations for application bundles.
+ * Operations are defined once and referenced by ID in workflow steps.
+ */
+export class OperationRegistry {
+  constructor() {
+    /** @type {Map<string, object>} */
+    this._ops = new Map();
+    /** @type {object|null} */
+    this._internalActions = null;
+  }
+
+  /**
+   * Load internal actions for use by "internal" type operations.
+   * @param {object} actions -INTERNAL_ACTIONS from workflow.js
+   */
+  setInternalActions(actions) {
+    this._internalActions = actions;
+  }
+
+  /**
+   * Register a single operation definition.
+   * @param {string} id
+   * @param {object} def -{ name, type, action, params, inputs, outputs }
+   */
+  register(id, def) {
+    this._ops.set(id, { id, ...def });
+  }
+
+  /**
+   * Register all operations from a definitions object.
+   * @param {Record<string, object>} defs -{ opId: { name, type, ... }, ... }
+   */
+  registerAll(defs) {
+    for (const [id, def] of Object.entries(defs)) {
+      this.register(id, def);
+    }
+  }
+
+  /**
+   * Check if an operation exists.
+   * @param {string} id
+   * @returns {boolean}
+   */
+  has(id) {
+    return this._ops.has(id);
+  }
+
+  /**
+   * Get an operation definition.
+   * @param {string} id
+   * @returns {object|undefined}
+   */
+  get(id) {
+    return this._ops.get(id);
+  }
+
+  /**
+   * List all registered operations.
+   * @returns {Array<{ id: string, name: string, type: string }>}
+   */
+  list() {
+    return [...this._ops.values()].map(op => ({
+      id: op.id,
+      name: op.name || op.id,
+      type: op.type || "internal",
+      inputs: op.inputs ? Object.keys(op.inputs) : [],
+      outputs: op.outputs ? Object.keys(op.outputs) : [],
+    }));
+  }
+
+  /**
+   * Execute an operation by ID.
+   *
+   * @param {string} id -Operation ID
+   * @param {object} params -Resolved parameters (after template resolution)
+   * @param {object} context -{ connections?, env? } for service calls
+   * @returns {Promise<object>} Operation result
+   */
+  async execute(id, params, context = {}) {
+    const op = this._ops.get(id);
+    if (!op) {
+      throw new Error(`Unknown operation: ${id}. Available: ${[...this._ops.keys()].join(", ")}`);
+    }
+
+    // Merge operation's default params with step-level params
+    const mergedParams = { ...(op.params || {}), ...params };
+
+    if (op.type === "internal" || !op.type) {
+      return this._executeInternal(op.action, mergedParams);
+    }
+
+    if (op.type === "service") {
+      return this._executeService(op.service, op.action, mergedParams, context);
+    }
+
+    throw new Error(`Unknown operation type: ${op.type} for operation ${id}`);
+  }
+
+  /**
+   * Execute an internal action.
+   * @private
+   */
+  _executeInternal(action, params) {
+    if (!this._internalActions) {
+      throw new Error("Internal actions not loaded. Call setInternalActions() first.");
+    }
+
+    const handler = this._internalActions[action];
+    if (!handler) {
+      throw new Error(`Unknown internal action: ${action}. Available: ${Object.keys(this._internalActions).join(", ")}`);
+    }
+
+    return handler(params);
+  }
+
+  /**
+   * Execute a service call via ConnectionManager.
+   * @private
+   */
+  async _executeService(service, action, params, context) {
+    if (!context.connections) {
+      throw new Error(`Service operation ${service}.${action} requires connections in context.`);
+    }
+
+    const creds = context.connections.getCredentials(service);
+    if (!creds) {
+      throw new Error(`Service ${service} not connected.`);
+    }
+
+    // Delegate to catalog-based execution via the connection manager
+    // This follows the same pattern as WorkflowRunner._executeService
+    const { SERVICE_CATALOG } = await import("../catalog.js");
+    const catalog = SERVICE_CATALOG[service];
+    if (!catalog) {
+      throw new Error(`Unknown service: ${service}`);
+    }
+
+    const endpointKeys = Object.keys(catalog.endpoints);
+    const ep = catalog.endpoints[action] || catalog.endpoints[endpointKeys.find(k => k.includes(action))];
+    if (!ep) {
+      throw new Error(`No endpoint found for ${service}.${action}`);
+    }
+
+    let url = catalog.baseUrl + ep.path;
+    const allParams = { ...creds, ...params };
+    url = url.replace(/\{(\w+)\}/g, (_, key) => allParams[key] || `{${key}}`);
+
+    const headers = catalog.authHeader(creds);
+    const options = { method: ep.method, headers };
+
+    if (ep.method !== "GET" && params) {
+      headers["Content-Type"] = "application/json";
+      options.body = JSON.stringify(params);
+    }
+
+    if (ep.method === "GET" && params) {
+      const flat = {};
+      for (const [k, v] of Object.entries(params)) {
+        if (typeof v !== "object") flat[k] = String(v);
+      }
+      const qs = new URLSearchParams(flat).toString();
+      if (qs) url += (url.includes("?") ? "&" : "?") + qs;
+    }
+
+    const response = await fetch(url, options);
+    const data = await response.json().catch(() => ({ status: response.status }));
+
+    if (!response.ok) {
+      throw new Error(`${service}.${action} failed (${response.status}): ${JSON.stringify(data)}`);
+    }
+
+    return data;
+  }
+}
+
+/**
+ * Validate operation definitions from an application bundle.
+ *
+ * @param {Record<string, object>} defs -operations section of bundle
+ * @returns {{ valid: boolean, errors: string[] }}
+ */
+export function validateOperations(defs) {
+  const errors = [];
+
+  if (!defs || typeof defs !== "object") {
+    return { valid: false, errors: ["Operations must be an object"] };
+  }
+
+  for (const [id, def] of Object.entries(defs)) {
+    if (!def.type && !def.action) {
+      errors.push(`Operation "${id}": must have "type" or "action"`);
+    }
+
+    if (def.type === "internal" || !def.type) {
+      if (!def.action) {
+        errors.push(`Operation "${id}": internal operations require "action"`);
+      }
+    }
+
+    if (def.type === "service") {
+      if (!def.service) errors.push(`Operation "${id}": service operations require "service"`);
+      if (!def.action) errors.push(`Operation "${id}": service operations require "action"`);
+    }
+
+    if (def.inputs && typeof def.inputs !== "object") {
+      errors.push(`Operation "${id}": "inputs" must be an object`);
+    }
+
+    if (def.outputs && typeof def.outputs !== "object") {
+      errors.push(`Operation "${id}": "outputs" must be an object`);
+    }
+  }
+
+  return { valid: errors.length === 0, errors };
+}