@letterblack/lbe-sdk 1.0.0 → 1.0.2

package/README.md

@@ -6,6 +6,8 @@ LBE SDK exposes a WASM-authoritative execution boundary for local AI agent
 governance. JavaScript is transport only: it verifies the engine hash, passes a
 UTF-8 JSON request into WASM, and returns the UTF-8 JSON response.
 
+Every AI action passes through a local gate before it can execute.
+
 Everything runs on your machine. No cloud service is required.
 
 ## Install
@@ -33,17 +35,18 @@ validation and decisions originate in `dist/lbe_engine.wasm`.
 import crypto from 'node:crypto';
 import { execute } from '@letterblack/lbe-sdk';
 
-const output = execute(JSON.stringify({
+const buildRequest = (name, payload = {}) => ({
   version: '1.0',
   request_id: crypto.randomUUID(),
   timestamp: Math.floor(Date.now() / 1000),
   actor: { id: 'agent:local', role: 'agent' },
-  intent: { type: 'command', name: 'status', payload: {} },
+  intent: { type: 'command', name, payload },
   context: { workspace: process.cwd(), env: {}, history: [] },
   constraints: { policy_mode: 'strict', timeout_ms: 5000 },
   auth: { signature: 'provided-by-host', nonce: crypto.randomUUID() }
-}));
+});
 
+const output = execute(JSON.stringify(buildRequest('status')));
 console.log(JSON.parse(output));
 ```
 
@@ -54,8 +57,8 @@ console.log(JSON.parse(output));
 | `npx lbe execute --input input.json` | Execute one JSON request through WASM |
 | `cat input.json \| npx lbe execute` | Execute from stdin |
 
-The legacy `lbe-mcp` command is intentionally disabled in this package until
-the MCP server is rebuilt as a thin bridge over `execute(input)`.
+`lbe-mcp` starts a thin MCP stdio bridge exposing one tool: `lbe_execute`.
+It contains no governance logic; it only passes JSON into `execute(input)`.
 
 ## What ships
 

package/dist/mcp-server.js

@@ -1,3 +1,105 @@
 #!/usr/bin/env node
-process.stderr.write('lbe-mcp is disabled in the WASM-authoritative package until MCP transport is reimplemented as a thin execute() bridge.\n');
-process.exit(2);
+import { execute } from './index.js';
+
+let buffer = Buffer.alloc(0);
+
+function send(payload) {
+  const body = Buffer.from(JSON.stringify(payload), 'utf8');
+  process.stdout.write(`Content-Length: ${body.length}\r\n\r\n`);
+  process.stdout.write(body);
+}
+
+function result(id, value) {
+  send({ jsonrpc: '2.0', id, result: value });
+}
+
+function error(id, code, message) {
+  send({ jsonrpc: '2.0', id, error: { code, message } });
+}
+
+function handle(message) {
+  const { id, method, params } = message;
+  if (method === 'initialize') {
+    result(id, {
+      protocolVersion: params?.protocolVersion || '2024-11-05',
+      capabilities: { tools: {} },
+      serverInfo: { name: 'lbe', version: '1.0.2' }
+    });
+    return;
+  }
+  if (method === 'notifications/initialized') return;
+  if (method === 'tools/list') {
+    result(id, {
+      tools: [{
+        name: 'lbe_execute',
+        description: 'Execute one canonical LBE JSON request through the local WASM boundary.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            input: {
+              type: 'object',
+              description: 'LBE execute request object. It will be serialized and passed to execute(input).'
+            },
+            input_json: {
+              type: 'string',
+              description: 'Raw JSON string to pass to execute(input). Takes precedence over input.'
+            }
+          }
+        }
+      }]
+    });
+    return;
+  }
+  if (method === 'tools/call') {
+    try {
+      if (params?.name !== 'lbe_execute') {
+        error(id, -32602, 'Unknown tool');
+        return;
+      }
+      const args = params.arguments || {};
+      const input = typeof args.input_json === 'string' ? args.input_json : JSON.stringify(args.input);
+      const output = execute(input);
+      result(id, {
+        content: [{ type: 'text', text: output }],
+        structuredContent: JSON.parse(output),
+        isError: false
+      });
+    } catch (err) {
+      result(id, {
+        content: [{ type: 'text', text: String(err?.message || err) }],
+        isError: true
+      });
+    }
+    return;
+  }
+  if (id !== undefined) error(id, -32601, 'Method not found');
+}
+
+function pump() {
+  while (true) {
+    const headerEnd = buffer.indexOf('\r\n\r\n');
+    if (headerEnd < 0) return;
+    const header = buffer.slice(0, headerEnd).toString('utf8');
+    const match = header.match(/Content-Length:\s*(\d+)/i);
+    if (!match) {
+      buffer = buffer.slice(headerEnd + 4);
+      continue;
+    }
+    const length = Number(match[1]);
+    const bodyStart = headerEnd + 4;
+    const bodyEnd = bodyStart + length;
+    if (buffer.length < bodyEnd) return;
+    const body = buffer.slice(bodyStart, bodyEnd).toString('utf8');
+    buffer = buffer.slice(bodyEnd);
+    try {
+      handle(JSON.parse(body));
+    } catch (err) {
+      error(null, -32700, String(err?.message || err));
+    }
+  }
+}
+
+process.stdin.on('data', (chunk) => {
+  buffer = Buffer.concat([buffer, chunk]);
+  pump();
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@letterblack/lbe-sdk",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Local-first execution governance SDK for AI agents.",
   "type": "module",
   "main": "dist/index.js",