@o-lang/olang 1.0.26 → 1.0.27

package/cli.js

@@ -6,7 +6,7 @@ const fs = require('fs');
 const path = require('path');
 
 /**
- * Enforce .ol extension ONLY
+ * Enforce .ol extension ONLY (CLI only)
  */
 function ensureOlExtension(filename) {
   if (!filename.endsWith('.ol')) {
@@ -22,24 +22,29 @@ function ensureOlExtension(filename) {
  */
 async function defaultMockResolver(action, context) {
   if (!action || typeof action !== 'string') return `[Unhandled: ${String(action)}]`;
+
   if (action.startsWith('Search for ')) {
     return {
       title: "HR Policy 2025",
-      text: "Employees are entitled to 20 days of paid leave per year. All requests must be submitted via the HR portal.",
+      text: "Employees are entitled to 20 days of paid leave per year.",
       url: "mock://hr-policy"
     };
   }
+
   if (action.startsWith('Ask ')) {
-    return " ✅  [Mock] Summarized for demonstration.";
+    return "✅ [Mock] Summarized for demonstration.";
   }
+
   if (action.startsWith('Notify ')) {
     const recipient = action.match(/Notify (\S+)/)?.[1] || 'user@example.com';
-    return ` 📬  Notification sent to ${recipient}`;
+    return `📬 Notification sent to ${recipient}`;
   }
+
   if (action.startsWith('Debrief ') || action.startsWith('Evolve ')) {
     console.log(`[O-Lang] ${action}`);
     return 'Acknowledged';
   }
+
   return `[Unhandled: ${action}]`;
 }
 defaultMockResolver.resolverName = 'defaultMockResolver';
@@ -48,45 +53,43 @@ defaultMockResolver.resolverName = 'defaultMockResolver';
  * Built-in Math Resolver
  */
 async function builtInMathResolver(action, context) {
-  if (!action || typeof action !== 'string') return null;
-  const a = action.replace(/\{([^\}]+)\}/g, (_, k) => {
-    const v = context[k.trim()];
-    return v !== undefined ? v : `{${k}}`;
-  });
+  if (!action || typeof action !== 'string') return undefined;
+
+  const a = action.replace(/\{([^\}]+)\}/g, (_, k) =>
+    context[k.trim()] ?? `{${k}}`
+  );
+
   let m;
-  m = a.match(/^add\(([^,]+),\s*([^)]+)\)$/i); if (m) return parseFloat(m[1]) + parseFloat(m[2]);
-  m = a.match(/^subtract\(([^,]+),\s*([^)]+)\)$/i); if (m) return parseFloat(m[1]) - parseFloat(m[2]);
-  m = a.match(/^multiply\(([^,]+),\s*([^)]+)\)$/i); if (m) return parseFloat(m[1]) * parseFloat(m[2]);
-  m = a.match(/^divide\(([^,]+),\s*([^)]+)\)$/i); if (m) return parseFloat(m[1]) / parseFloat(m[2]);
-  m = a.match(/^sum\(\s*\[([^\]]+)\]\s*\)$/i); if (m) return m[1].split(',').map(s => parseFloat(s.trim())).reduce((s, v) => s + v, 0);
-  return null;
+  if ((m = a.match(/^add\(([^,]+),\s*([^)]+)\)$/i))) return +m[1] + +m[2];
+  if ((m = a.match(/^subtract\(([^,]+),\s*([^)]+)\)$/i))) return +m[1] - +m[2];
+  if ((m = a.match(/^multiply\(([^,]+),\s*([^)]+)\)$/i))) return +m[1] * +m[2];
+  if ((m = a.match(/^divide\(([^,]+),\s*([^)]+)\)$/i))) return +m[1] / +m[2];
+  if ((m = a.match(/^sum\(\s*\[([^\]]+)\]\s*\)$/i)))
+    return m[1].split(',').map(Number).reduce((a, b) => a + b, 0);
+
+  return undefined;
 }
 builtInMathResolver.resolverName = 'builtInMathResolver';
 
 /**
- * Resolver chaining: returns the FIRST resolver that returns a non-undefined result.
+ * Resolver chaining
  */
 function createResolverChain(resolvers, verbose = false) {
   const wrapped = async (action, context) => {
-    for (let i = 0; i < resolvers.length; i++) {
-      const resolver = resolvers[i];
+    for (const resolver of resolvers) {
       try {
-        const res = await resolver(action, context);
-        if (res !== undefined) {
-          // Store result in context for debugging
-          context[`__resolver_${i}`] = res;
+        const result = await resolver(action, context);
+        if (result !== undefined) {
           if (verbose) {
-            console.log(`[✅ ${resolver.resolverName || 'anonymous'}] handled action`);
+            console.log(`✅ ${resolver.resolverName} handled "${action}"`);
           }
-          return res;
+          return result;
         }
-      } catch (e) {
-        console.error(` ❌  Resolver ${resolver.resolverName || 'anonymous'} failed:`, e.message);
+      } catch (err) {
+        console.error(`❌ Resolver ${resolver.resolverName} failed:`, err.message);
       }
     }
-    if (verbose) {
-      console.log(`[⏭️] No resolver handled action: "${action}"`);
-    }
+    if (verbose) console.log(`⏭️ No resolver handled "${action}"`);
     return undefined;
   };
   wrapped._chain = resolvers;
@@ -94,150 +97,133 @@ function createResolverChain(resolvers, verbose = false) {
 }
 
 /**
- * Load a single resolver — NO fallback to defaultMockResolver
+ * Load a single resolver
  */
 function loadSingleResolver(specifier) {
-  if (!specifier) {
-    throw new Error('Empty resolver specifier provided');
+  if (!specifier) throw new Error('Empty resolver specifier');
+
+  if (specifier.endsWith('.json')) {
+    const manifest = JSON.parse(fs.readFileSync(specifier, 'utf8'));
+    if (manifest.protocol?.startsWith('http')) {
+      const externalResolver = async () => undefined;
+      externalResolver.resolverName = manifest.name;
+      externalResolver.manifest = manifest;
+      console.log(`🌐 Loaded external resolver: ${manifest.name}`);
+      return externalResolver;
+    }
   }
 
-  let resolver, pkgName;
-
-  // Extract clean package name (e.g., @o-lang/extractor → extractor)
-  if (specifier.startsWith('./') || specifier.startsWith('../') || specifier.startsWith('/')) {
-    // Local file: use filename without extension
-    pkgName = path.basename(specifier, path.extname(specifier));
-  } else {
-    // npm package: strip scope (e.g., @o-lang/extractor → extractor)
-    pkgName = specifier.replace(/^@[^/]+\//, '');
-  }
+  let resolver;
+  const pkgName = specifier.startsWith('.') || specifier.startsWith('/')
+    ? path.basename(specifier, path.extname(specifier))
+    : specifier.replace(/^@[^/]+\//, '');
 
   try {
     resolver = require(specifier);
-  } catch (e1) {
-    try {
-      const absolutePath = path.resolve(process.cwd(), specifier);
-      resolver = require(absolutePath);
-      console.log(` 📁  Loaded resolver: ${absolutePath}`);
-    } catch (e2) {
-      throw new Error(
-        `Failed to load resolver '${specifier}':\n  npm: ${e1.message}\n  file: ${e2.message}`
-      );
-    }
+  } catch {
+    resolver = require(path.resolve(process.cwd(), specifier));
   }
 
   if (typeof resolver !== 'function') {
     throw new Error(`Resolver must export a function`);
   }
 
-  // ✅ Auto-assign resolverName from package/filename if missing
-  if (!resolver.resolverName || typeof resolver.resolverName !== 'string') {
-    resolver.resolverName = pkgName;
-    console.log(` 🏷️  Auto-assigned resolverName: "${pkgName}" (from ${specifier})`);
-  } else {
-    console.log(` 📦  Loaded resolver: ${specifier} (name: ${resolver.resolverName})`);
-  }
-
+  resolver.resolverName ||= pkgName;
+  console.log(`📦 Loaded resolver: ${resolver.resolverName}`);
   return resolver;
 }
 
 /**
- * ✅ POLICY-AWARE resolver loader: only includes resolvers in allowedResolvers
+ * Policy-aware resolver loader
  */
-function loadResolverChain(specifiers, verbose = false, allowedResolvers = new Set()) {
-  const userResolvers = specifiers?.map(loadSingleResolver) || [];
+function loadResolverChain(specifiers, verbose, allowed) {
   const resolvers = [];
 
-  // Only add builtInMathResolver if allowed
-  if (allowedResolvers.has('builtInMathResolver')) {
-    resolvers.push(builtInMathResolver);
-  }
+  if (allowed.has('builtInMathResolver')) resolvers.push(builtInMathResolver);
 
-  // Add user resolvers only if their name is allowed
-  for (const r of userResolvers) {
-    const name = r.resolverName || r.name || 'unknown';
-    if (allowedResolvers.has(name)) {
-      resolvers.push(r);
-    } else if (verbose) {
-      console.warn(` ⚠️  Skipping disallowed user resolver: ${name}`);
-    }
+  for (const r of specifiers.map(loadSingleResolver)) {
+    if (allowed.has(r.resolverName)) resolvers.push(r);
+    else if (verbose) console.warn(`⚠️ Skipped disallowed resolver: ${r.resolverName}`);
   }
 
-  // Only add defaultMockResolver if explicitly allowed
-  if (allowedResolvers.has('defaultMockResolver')) {
-    resolvers.push(defaultMockResolver);
-  }
-
-  if (resolvers.length === 0) {
-    if (verbose) {
-      console.warn(' ⚠️  No allowed resolvers loaded. Actions may fail.');
-    }
-  } else {
-    if (verbose) {
-      console.log(` ℹ️  Loaded allowed resolvers: ${resolvers.map(r => r.resolverName || 'anonymous').join(', ')}`);
-    }
-  }
+  if (allowed.has('defaultMockResolver')) resolvers.push(defaultMockResolver);
 
   return createResolverChain(resolvers, verbose);
 }
 
 /**
- * CLI Setup
+ * CLI SETUP
  */
 const program = new Command();
+
+// === RUN COMMAND ===
 program
   .name('olang')
-  .description('O-Lang CLI: run .ol workflows with rule-enforced agent governance')
   .command('run <file>')
-  .option(
-    '-r, --resolver <specifier>',
-    'Resolver (npm package or local path). Can be used multiple times.',
-    (val, acc) => { acc.push(val); return acc; },
-    []
-  )
-  .option(
-    '-i, --input <k=v>',
-    'Input parameters',
-    (val, acc = {}) => {
-      const [k, v] = val.split('=');
-      const parsed = v === undefined ? '' : (v === 'true' ? true : (v === 'false' ? false : (isNaN(v) ? v : parseFloat(v))));
-      acc[k] = parsed;
-      return acc;
-    },
-    {}
-  )
-  .option('-v, --verbose', 'Verbose mode: logs resolver outputs and context after each step')
+  .option('-r, --resolver <specifier>', 'Resolver', (v, a) => (a.push(v), a), [])
+  .option('-i, --input <k=v>', 'Input', (v, a = {}) => {
+    const [k, val] = v.split('=');
+    a[k] = isNaN(val) ? val : Number(val);
+    return a;
+  }, {})
+  .option('-v, --verbose')
   .action(async (file, options) => {
-    try {
-      ensureOlExtension(file);
-      const content = fs.readFileSync(file, 'utf8');
-      const workflow = parse(content, file);
-      if (!workflow || typeof workflow !== 'object') {
-        console.error(' ❌  Error: Parsed workflow is invalid or empty');
-        process.exit(1);
-      }
-      if (options.verbose) {
-        console.log(' 📄  Parsed Workflow:', JSON.stringify(workflow, null, 2));
-      }
+    ensureOlExtension(file);
+    const workflowSource = fs.readFileSync(file, 'utf8');
+    const workflow = parse(workflowSource, file);
+
+    const allowed = new Set(workflow.allowedResolvers);
+    const resolver = loadResolverChain(options.resolver, options.verbose, allowed);
 
-      const allowedSet = new Set(workflow.allowedResolvers.map(r => r.trim()));
-      const resolver = loadResolverChain(options.resolver, options.verbose, allowedSet);
+    const result = await execute(workflow, options.input, resolver, options.verbose);
+    console.log(JSON.stringify(result, null, 2));
+  });
 
-      // 🔔 Warn if allowed resolvers declared but none loaded
-      if (workflow.allowedResolvers.length > 0 && resolver._chain.length === 0) {
-        console.warn(
-          `\n⚠️  Warning: Workflow allows [${workflow.allowedResolvers.join(', ')}],\n` +
-          `   but no matching resolvers were loaded. Use -r <path> to provide them.\n`
-        );
+// === SERVER COMMAND (✅ PROPER INTEGRATION) ===
+program
+  .command('server')
+  .description('Start O-lang kernel in HTTP server mode')
+  .option('-p, --port <port>', 'Server port', process.env.OLANG_SERVER_PORT || '3000')
+  .option('-h, --host <host>', 'Server host', '0.0.0.0')
+  .action(async (options) => {
+    const fastify = require('fastify')({ logger: false });
+
+    fastify.get('/health', () => ({
+      status: 'healthy',
+      kernel: 'o-lang',
+      uptime: process.uptime()
+    }));
+
+    fastify.post('/execute-workflow', async (req, reply) => {
+      try {
+        const { workflowSource, inputs = {}, resolvers = [], verbose = false } = req.body;
+
+        if (typeof workflowSource !== 'string') {
+          return reply.status(400).send({ error: 'workflowSource must be a string' });
+        }
+
+        const workflow = parse(workflowSource, 'remote.ol');
+        const allowed = new Set(workflow.allowedResolvers);
+        const resolver = loadResolverChain(resolvers, verbose, allowed);
+
+        const result = await execute(workflow, inputs, resolver, verbose);
+        reply.send(result);
+      } catch (err) {
+        reply.status(500).send({ error: err.message });
       }
+    });
 
-      const result = await execute(workflow, options.input, resolver, options.verbose);
-      console.log('\n=== Workflow Result ===');
-      console.log(JSON.stringify(result, null, 2));
+    const PORT = parseInt(options.port, 10);
+    const HOST = options.host;
+
+    try {
+      await fastify.listen({ port: PORT, host: HOST });
+      console.log(`✅ O-Lang Kernel running on http://${HOST}:${PORT}`);
     } catch (err) {
-      console.error(' ❌  Error:', err.message);
+      console.error('❌ Failed to start server:', err);
       process.exit(1);
     }
   });
 
+// === PARSE CLI ===
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@o-lang/olang",
-  "version": "1.0.26",
+  "version": "1.0.27",
   "author": "Olalekan Ogundipe <info@workfily.com>",
   "description": "O-Lang: A governance language for user-directed, rule-enforced agent workflows",
   "main": "./src/index.js",

package/src/runtime.js

@@ -145,6 +145,79 @@ class RuntimeAPI {
     }
   }
 
+  // -----------------------------
+  // ✅ ADDITION 1 — External Resolver Detection
+  // -----------------------------
+  /**
+   * Determines whether a resolver is external (HTTP-based)
+   * External resolvers MUST be declared via a manifest (.json)
+   * and explicitly allowed by workflow policy
+   */
+  _isExternalResolver(resolver) {
+    return Boolean(
+      resolver &&
+      resolver.manifest &&
+      typeof resolver.manifest === 'object' &&
+      typeof resolver.manifest.protocol === 'string' &&
+      resolver.manifest.protocol.startsWith('http')
+    );
+  }
+
+  // -----------------------------
+  // ✅ ADDITION 2 — External Resolver Invocation (HTTP Enforcement)
+  // -----------------------------
+  /**
+   * Calls an external HTTP resolver using its manifest definition.
+   * Enforces:
+   * - timeout
+   * - JSON contract
+   * - isolation (no direct execution)
+   */
+  async _callExternalResolver(resolver, action, context) {
+    const manifest = resolver.manifest;
+    const endpoint = manifest.endpoint;
+    const timeoutMs = manifest.timeout_ms || 30000;
+
+    const payload = {
+      action,
+      context,
+      resolver: resolver.resolverName,
+      workflow: context.workflow_name,
+      timestamp: new Date().toISOString()
+    };
+
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+
+    try {
+      const res = await fetch(`${endpoint}/resolve`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+        signal: controller.signal
+      });
+
+      if (!res.ok) {
+        throw new Error(`HTTP ${res.status} ${res.statusText}`);
+      }
+
+      const json = await res.json();
+
+      if (json?.error) {
+        throw new Error(json.error.message || 'External resolver error');
+      }
+
+      return json.result;
+    } catch (err) {
+      if (err.name === 'AbortError') {
+        throw new Error(`External resolver timeout after ${timeoutMs}ms`);
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
   // -----------------------------
   // Utilities
   // -----------------------------
@@ -218,15 +291,28 @@ class RuntimeAPI {
   async executeStep(step, agentResolver) {
     const stepType = step.type;
 
-    const validateResolver = (resolver) => {
-      const resolverName = (resolver?.resolverName || resolver?.name || '').trim();
-      if (!resolverName) throw new Error('[O-Lang] Resolver missing name metadata');
+    // ✅ ADDITION 3 — Resolver Policy Enforcement (External + Local)
+    const enforceResolverPolicy = (resolver, step) => {
+      const resolverName = resolver?.resolverName || resolver?.name;
 
-      const allowed = Array.from(this.allowedResolvers || []).map(r => r.trim());
+      if (!resolverName) {
+        throw new Error('[O-Lang] Resolver missing resolverName');
+      }
 
-      if (!allowed.includes(resolverName)) {
-        this.logDisallowedResolver(resolverName, step.actionRaw || step.tool || step.target);
-        throw new Error(`[O-Lang] Resolver "${resolverName}" is not allowed by workflow policy`);
+      if (!this.allowedResolvers.has(resolverName)) {
+        this.logDisallowedResolver(resolverName, step.actionRaw || step.type);
+        throw new Error(
+          `[O-Lang] Resolver "${resolverName}" blocked by workflow policy`
+        );
+      }
+
+      // External resolvers MUST be HTTP-only
+      if (this._isExternalResolver(resolver)) {
+        if (!resolver.manifest.endpoint) {
+          throw new Error(
+            `[O-Lang] External resolver "${resolverName}" missing endpoint`
+          );
+        }
       }
     };
 
@@ -261,17 +347,28 @@ class RuntimeAPI {
       // ✅ Return the FIRST resolver that returns a non-undefined result
       for (let idx = 0; idx < resolversToRun.length; idx++) {
         const resolver = resolversToRun[idx];
-        validateResolver(resolver);
+        enforceResolverPolicy(resolver, step); // ✅ Use new policy enforcement
 
         try {
-          const out = await resolver(action, this.context);
-          outputs.push(out);
-          this.context[`__resolver_${idx}`] = out;
-          
-          // ✅ If resolver handled the action (returned non-undefined), use it immediately
-          if (out !== undefined) {
-            return out;
+          let result; // ✅ ADDITION 4 — External Resolver Execution Path
+
+          if (this._isExternalResolver(resolver)) {
+            result = await this._callExternalResolver(
+              resolver,
+              action,
+              this.context
+            );
+          } else {
+            result = await resolver(action, this.context);
           }
+
+          if (result !== undefined) {
+            this.context[`__resolver_${idx}`] = result;
+            return result;
+          }
+
+          outputs.push(result);
+          this.context[`__resolver_${idx}`] = result;
         } catch (e) {
           this.addWarning(`Resolver ${resolver?.resolverName || resolver?.name || idx} failed for action "${action}": ${e.message}`);
           outputs.push(null);
@@ -475,7 +572,12 @@ class RuntimeAPI {
       }
     }
 
+    // ✅ ADDITION 5 — Security Warning for External Resolvers
     if (this.verbose) {
+      for (const r of this.allowedResolvers) {
+        // Note: We can't easily check if resolvers are external here since we only have names
+        // This would need to be moved to where we have the actual resolver objects
+      }
       console.log(`\n[Step: ${step.type} | saveAs: ${step.saveAs || 'N/A'}]`);
       console.log(JSON.stringify(this.context, null, 2));
     }