agent-manifest 3.2.0 → 3.3.0

package/dist/parser/websocket-parser.js

@@ -0,0 +1,168 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketParser = void 0;
+exports.looksLikeWebSocketFile = looksLikeWebSocketFile;
+const ts_morph_1 = require("ts-morph");
+const intent_classifier_1 = require("./intent-classifier");
+const path = __importStar(require("path"));
+/**
+ * Parses raw WebSocket servers (the `ws` npm package) and extracts
+ * message type handlers as agent actions.
+ *
+ * Detects:
+ *   // ws library
+ *   const wss = new WebSocketServer({ port: 8080 })
+ *   wss.on('connection', (ws) => {
+ *     ws.on('message', (data) => {
+ *       const { type, payload } = JSON.parse(data)
+ *       if (type === 'ping') { ... }
+ *       switch (type) { case 'chat': ... }
+ *     })
+ *   })
+ *
+ * When individual message types are discriminated by a `type` / `action`
+ * string field, each branch is emitted as a separate action. Otherwise
+ * a single `ws_message` action is emitted for the whole handler.
+ */
+class WebSocketParser {
+    project;
+    constructor(sharedProject) {
+        this.project = sharedProject ?? new ts_morph_1.Project({
+            compilerOptions: { allowJs: true, checkJs: false },
+        });
+    }
+    async parseFile(filePath, projectPath) {
+        const sourceFile = this.project.addSourceFileAtPath(filePath);
+        const relativePath = './' + path.relative(projectPath, filePath).replace(/\\/g, '/');
+        const actions = [];
+        const seen = new Set();
+        sourceFile.forEachDescendant(node => {
+            if (!ts_morph_1.Node.isCallExpression(node))
+                return;
+            const expr = node.getExpression();
+            if (!ts_morph_1.Node.isPropertyAccessExpression(expr))
+                return;
+            if (expr.getName() !== 'on')
+                return;
+            const args = node.getArguments();
+            if (args.length < 2)
+                return;
+            const eventArg = args[0];
+            if (!ts_morph_1.Node.isStringLiteral(eventArg))
+                return;
+            if (eventArg.getLiteralValue() !== 'message')
+                return;
+            const handler = args[1];
+            if (!ts_morph_1.Node.isArrowFunction(handler) && !ts_morph_1.Node.isFunctionExpression(handler))
+                return;
+            // Try to detect discriminated message types inside the handler body
+            const messageTypes = this.extractMessageTypes(handler);
+            if (messageTypes.length > 0) {
+                for (const msgType of messageTypes) {
+                    if (seen.has(msgType))
+                        continue;
+                    seen.add(msgType);
+                    const safety = (0, intent_classifier_1.classifySafety)({ name: msgType, type: 'socket' });
+                    actions.push({
+                        name: msgType,
+                        description: `WebSocket message type: ${msgType}`,
+                        intent: (0, intent_classifier_1.inferIntent)(msgType),
+                        type: 'socket',
+                        location: relativePath,
+                        socketEvent: msgType,
+                        safety,
+                        agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety),
+                        requiredAuth: (0, intent_classifier_1.inferActionAuth)({ safety, type: 'socket' }),
+                        inputs: { type: { type: 'string', required: true }, payload: { type: 'object', required: false } },
+                        outputs: { type: 'object' },
+                    });
+                }
+            }
+            else {
+                // Generic message handler — emit a single action
+                const name = 'ws_message';
+                if (!seen.has(name)) {
+                    seen.add(name);
+                    actions.push({
+                        name,
+                        description: 'Raw WebSocket message handler',
+                        intent: 'util.action',
+                        type: 'socket',
+                        location: relativePath,
+                        socketEvent: 'message',
+                        safety: 'write',
+                        agentSafe: true,
+                        requiredAuth: (0, intent_classifier_1.inferActionAuth)({ safety: 'write', type: 'socket' }),
+                        inputs: { data: { type: 'string', required: true } },
+                        outputs: { type: 'object' },
+                    });
+                }
+            }
+        });
+        return actions;
+    }
+    /**
+     * Look inside the message handler body for discriminated type patterns:
+     *   if (type === 'chat')  →  extracts 'chat'
+     *   switch (type) { case 'ping':  →  extracts 'ping'
+     *   if (msg.type === 'join')  →  extracts 'join'
+     */
+    extractMessageTypes(handler) {
+        const types = [];
+        const body = handler.getBody?.();
+        if (!body)
+            return types;
+        const text = body.getText();
+        // switch (type) { case 'value': ... }
+        for (const match of text.matchAll(/case\s+['"`]([^'"`]+)['"`]\s*:/g)) {
+            types.push(match[1]);
+        }
+        // if (type === 'value') or if (msg.type === 'value')
+        for (const match of text.matchAll(/(?:type|action|event)\s*(?:===?|==)\s*['"`]([^'"`]+)['"`]/g)) {
+            if (!types.includes(match[1]))
+                types.push(match[1]);
+        }
+        // Filter out framework noise
+        return types.filter(t => t !== 'message' && t !== 'error' && t !== 'close' && t !== 'open');
+    }
+}
+exports.WebSocketParser = WebSocketParser;
+function looksLikeWebSocketFile(content) {
+    return (content.includes('WebSocketServer') ||
+        content.includes('new WebSocket.Server') ||
+        (content.includes("'ws'") && content.includes(".on('message'")) ||
+        (content.includes('"ws"') && content.includes('.on("message"')));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-manifest",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "description": "Universal agent manifest compiler — generates agent.json for any web app so AI agents can discover and interact with it",
   "main": "dist/index.js",
   "bin": {

package/schema/agent.schema.json

@@ -100,7 +100,7 @@
         },
         "type": {
           "type": "string",
-          "enum": ["api", "contract", "function"]
+          "enum": ["api", "contract", "function", "socket"]
         },
         "location": { "type": "string" },
         "method": {