agent-vision-mcp 0.1.0 → 0.1.2

package/README.md

@@ -1,13 +1,16 @@
 <div align="center">
   <h1>Agent Vision</h1>
   <p align="center">
-  <img src="./docs/banner.png" width="800" />
+  <img src="https://github.com/kedarvartak/agent-vision/blob/main/docs/banner.png?raw=true" alt="Agent Vision Banner"/>
   </p>
   <p>
     <img alt="TypeScript" src="https://img.shields.io/badge/TypeScript-ES2022-3178C6?style=flat-square" />
     <img alt="Chrome CDP" src="https://img.shields.io/badge/Chrome-CDP-4285F4?style=flat-square" />
     <img alt="MCP" src="https://img.shields.io/badge/MCP-stdio-7C3AED?style=flat-square" />
     <img alt="License" src="https://img.shields.io/badge/License-MIT-22C55E?style=flat-square" />
+    <a href="https://www.npmjs.com/package/agent-vision-mcp">
+    <img src="https://img.shields.io/npm/v/agent-vision-mcp" />
+  </a>
   </p>
 </div>
 

package/dist/mcp/stdio-server.d.ts

@@ -3,17 +3,6 @@ import type { VisualContextServer } from "../server.js";
 export declare class McpStdioServer {
     private readonly app;
     private readonly logger;
-    private readonly input;
-    private readonly output;
-    private buffer;
-    private initialized;
-    constructor(app: VisualContextServer, logger: Logger, input?: NodeJS.ReadStream & {
-        fd: 0;
-    }, output?: NodeJS.WriteStream & {
-        fd: 1;
-    });
-    start(): void;
-    private processBuffer;
-    private handleMessage;
-    private writeMessage;
+    constructor(app: VisualContextServer, logger: Logger);
+    start(): Promise<void>;
 }

package/dist/mcp/stdio-server.js

@@ -1,19 +1,9 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
 import { isAppError } from "../errors/app-error.js";
-const MCP_PROTOCOL_VERSION = "2025-03-26";
 const SERVER_NAME = "agent-vision-mcp";
-const SERVER_VERSION = "0.1.0";
-const JSON_RPC_VERSION = "2.0";
-const JSON_PARSE_ERROR = -32700;
-const JSON_INVALID_REQUEST = -32600;
-const JSON_METHOD_NOT_FOUND = -32601;
-const JSON_INVALID_PARAMS = -32602;
-const JSON_INTERNAL_ERROR = -32603;
-const toRecord = (value) => {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return {};
-    }
-    return value;
-};
+const SERVER_VERSION = "0.1.1";
 const isImagePayload = (value) => {
     if (!value || typeof value !== "object") {
         return false;
@@ -94,179 +84,63 @@ const toToolErrorResult = (error) => {
         isError: true
     };
 };
-const toJsonRpcError = (id, code, message, data) => ({
-    jsonrpc: JSON_RPC_VERSION,
-    id,
-    error: {
-        code,
-        message,
-        ...(data !== undefined ? { data } : {})
+const toMcpError = (error) => {
+    if (isAppError(error)) {
+        return new McpError(ErrorCode.InternalError, error.message, error.details);
+    }
+    if (error instanceof McpError) {
+        return error;
     }
-});
-const encodeMessage = (message) => {
-    const body = Buffer.from(JSON.stringify(message), "utf8");
-    const header = Buffer.from(`Content-Length: ${body.byteLength}\r\n\r\n`, "utf8");
-    return Buffer.concat([header, body]);
+    return new McpError(ErrorCode.InternalError, error instanceof Error ? error.message : String(error));
 };
 export class McpStdioServer {
     app;
     logger;
-    input;
-    output;
-    buffer = Buffer.alloc(0);
-    initialized = false;
-    constructor(app, logger, input = process.stdin, output = process.stdout) {
+    constructor(app, logger) {
         this.app = app;
         this.logger = logger;
-        this.input = input;
-        this.output = output;
     }
-    start() {
-        this.input.on("data", (chunk) => {
-            this.buffer = Buffer.concat([
-                this.buffer,
-                typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk
-            ]);
-            this.processBuffer();
-        });
-        this.input.on("error", (error) => {
-            this.logger.error("MCP stdio input error", {
-                errorMessage: error instanceof Error ? error.message : String(error)
-            });
+    async start() {
+        const server = new Server({
+            name: SERVER_NAME,
+            version: SERVER_VERSION
+        }, {
+            capabilities: {
+                tools: {}
+            }
         });
-        this.output.on("error", (error) => {
-            this.logger.error("MCP stdio output error", {
-                errorMessage: error instanceof Error ? error.message : String(error)
-            });
+        server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            tools: this.app.listTools().map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                inputSchema: (tool.inputSchema ?? {
+                    type: "object",
+                    properties: {},
+                    additionalProperties: false
+                }),
+                ...(tool.annotations ? { annotations: tool.annotations } : {})
+            }))
+        }));
+        server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const toolName = request.params.name;
+            const args = (request.params.arguments ?? {});
+            try {
+                const result = await this.app.callTool(toolName, args);
+                return toToolResult(result);
+            }
+            catch (error) {
+                this.logger.error("MCP tool call failed", {
+                    toolName,
+                    errorMessage: error instanceof Error ? error.message : String(error)
+                });
+                return toToolErrorResult(error);
+            }
         });
-        this.logger.info("MCP stdio server listening", {
-            protocolVersion: MCP_PROTOCOL_VERSION,
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+        this.logger.info("Official MCP stdio server listening", {
             serverName: SERVER_NAME,
             serverVersion: SERVER_VERSION
         });
     }
-    processBuffer() {
-        while (true) {
-            const headerEnd = this.buffer.indexOf("\r\n\r\n");
-            if (headerEnd === -1) {
-                return;
-            }
-            const headerText = this.buffer.subarray(0, headerEnd).toString("utf8");
-            const match = headerText.match(/Content-Length:\s*(\d+)/i);
-            if (!match) {
-                this.buffer = Buffer.alloc(0);
-                this.writeMessage(toJsonRpcError(null, JSON_INVALID_REQUEST, "Missing Content-Length header"));
-                return;
-            }
-            const contentLength = Number.parseInt(match[1], 10);
-            const bodyStart = headerEnd + 4;
-            const bodyEnd = bodyStart + contentLength;
-            if (this.buffer.byteLength < bodyEnd) {
-                return;
-            }
-            const bodyBuffer = this.buffer.subarray(bodyStart, bodyEnd);
-            this.buffer = this.buffer.subarray(bodyEnd);
-            let parsed;
-            try {
-                parsed = JSON.parse(bodyBuffer.toString("utf8"));
-            }
-            catch {
-                this.writeMessage(toJsonRpcError(null, JSON_PARSE_ERROR, "Invalid JSON payload"));
-                continue;
-            }
-            void this.handleMessage(parsed);
-        }
-    }
-    async handleMessage(message) {
-        if (message.jsonrpc !== JSON_RPC_VERSION || typeof message.method !== "string") {
-            if (message.id !== undefined) {
-                this.writeMessage(toJsonRpcError(message.id ?? null, JSON_INVALID_REQUEST, "Invalid JSON-RPC request"));
-            }
-            return;
-        }
-        const id = message.id ?? null;
-        try {
-            switch (message.method) {
-                case "initialize": {
-                    this.initialized = true;
-                    this.writeMessage({
-                        jsonrpc: JSON_RPC_VERSION,
-                        id,
-                        result: {
-                            protocolVersion: MCP_PROTOCOL_VERSION,
-                            capabilities: {
-                                tools: {
-                                    listChanged: false
-                                }
-                            },
-                            serverInfo: {
-                                name: SERVER_NAME,
-                                version: SERVER_VERSION
-                            }
-                        }
-                    });
-                    return;
-                }
-                case "notifications/initialized": {
-                    return;
-                }
-                case "ping": {
-                    this.writeMessage({
-                        jsonrpc: JSON_RPC_VERSION,
-                        id,
-                        result: {}
-                    });
-                    return;
-                }
-                case "tools/list": {
-                    this.writeMessage({
-                        jsonrpc: JSON_RPC_VERSION,
-                        id,
-                        result: {
-                            tools: this.app.listTools().map((tool) => ({
-                                name: tool.name,
-                                description: tool.description,
-                                inputSchema: tool.inputSchema ?? { type: "object", properties: {}, additionalProperties: false },
-                                ...(tool.annotations ? { annotations: tool.annotations } : {})
-                            }))
-                        }
-                    });
-                    return;
-                }
-                case "tools/call": {
-                    const params = toRecord(message.params);
-                    const toolName = params.name;
-                    if (typeof toolName !== "string") {
-                        this.writeMessage(toJsonRpcError(id, JSON_INVALID_PARAMS, "tools/call requires a string name"));
-                        return;
-                    }
-                    try {
-                        const result = await this.app.callTool(toolName, toRecord(params.arguments));
-                        this.writeMessage({
-                            jsonrpc: JSON_RPC_VERSION,
-                            id,
-                            result: toToolResult(result)
-                        });
-                    }
-                    catch (error) {
-                        this.writeMessage({
-                            jsonrpc: JSON_RPC_VERSION,
-                            id,
-                            result: toToolErrorResult(error)
-                        });
-                    }
-                    return;
-                }
-                default: {
-                    this.writeMessage(toJsonRpcError(id, JSON_METHOD_NOT_FOUND, `Method not found: ${message.method}`));
-                }
-            }
-        }
-        catch (error) {
-            this.writeMessage(toJsonRpcError(id, JSON_INTERNAL_ERROR, "Internal MCP server error", error instanceof Error ? { message: error.message } : { message: String(error) }));
-        }
-    }
-    writeMessage(message) {
-        this.output.write(encodeMessage(message));
-    }
 }

package/dist/mcp/tool-registry.d.ts

@@ -1,5 +1,17 @@
 import type { Logger } from "../logging/logger.js";
-export type JsonSchema = Record<string, unknown>;
+export type JsonSchemaProperty = {
+    type: string;
+    description?: string;
+    [key: string]: unknown;
+};
+export type JsonSchema = {
+    type: "object";
+    properties?: Record<string, JsonSchemaProperty>;
+    required?: string[];
+    additionalProperties?: boolean;
+    description?: string;
+    [key: string]: unknown;
+};
 export type ToolHandler = (args: Record<string, unknown>) => Promise<unknown> | unknown;
 export type ToolAnnotations = {
     readOnlyHint?: boolean;

package/dist/mcp-stdio.js

@@ -2,7 +2,16 @@
 import { ConsoleLogger } from "./logging/logger.js";
 import { McpStdioServer } from "./mcp/stdio-server.js";
 import { VisualContextServer } from "./server.js";
-const app = new VisualContextServer();
-const logger = new ConsoleLogger("agent-vision-mcp");
-app.start();
-new McpStdioServer(app, logger).start();
+const main = async () => {
+    const app = new VisualContextServer();
+    const logger = new ConsoleLogger("agent-vision-mcp");
+    app.start();
+    await new McpStdioServer(app, logger).start();
+};
+void main().catch((error) => {
+    const logger = new ConsoleLogger("agent-vision-mcp");
+    logger.error("Failed to start MCP stdio server", {
+        errorMessage: error instanceof Error ? error.message : String(error)
+    });
+    process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-vision-mcp",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "description": "Browser-first MCP server that gives agents visual access to live tabs through Chrome DevTools Protocol.",
   "bin": {
@@ -27,7 +27,16 @@
     "agent"
   ],
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kedarvartak/agent-vision.git"
+  },
+  "homepage": "https://github.com/kedarvartak/agent-vision#readme",
+  "bugs": {
+    "url": "https://github.com/kedarvartak/agent-vision/issues"
+  },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.17.5",
     "ws": "^8.18.0"
   },
   "devDependencies": {