@viral_vector/ig-mcp 0.1.0

package/dist/cli.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { startLocalBridgeServer } from './bridge/server.js';
+import { ExtensionSessionRegistry } from './bridge/sessionRegistry.js';
+import { createViralVectorMcpServer } from './mcp/server.js';
+async function main() {
+    const options = parseArgs(process.argv.slice(2));
+    if (options.help) {
+        printHelp();
+        return;
+    }
+    const registry = new ExtensionSessionRegistry({
+        token: options.token,
+        requestTimeoutMs: options.requestTimeoutMs
+    });
+    const bridge = await startLocalBridgeServer({
+        port: options.port,
+        registry,
+        log: (message, context) => {
+            process.stderr.write(`[vv-ig-mcp] ${message}${context ? ` ${JSON.stringify(context)}` : ''}\n`);
+        }
+    });
+    process.stderr.write(`[vv-ig-mcp] bridge listening on 127.0.0.1:${bridge.port()}\n`);
+    const mcp = createViralVectorMcpServer(registry);
+    const transport = new StdioServerTransport();
+    const shutdown = async () => {
+        await bridge.close();
+        process.exit(0);
+    };
+    process.once('SIGINT', () => void shutdown());
+    process.once('SIGTERM', () => void shutdown());
+    await mcp.connect(transport);
+}
+function parseArgs(args) {
+    const options = {
+        port: parseIntEnv('VV_IG_MCP_PORT', 8765),
+        token: process.env.VV_IG_MCP_TOKEN ?? '',
+        requestTimeoutMs: parseIntEnv('VV_IG_MCP_REQUEST_TIMEOUT_MS', 5_000),
+        help: false
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--help' || arg === '-h') {
+            options.help = true;
+        }
+        else if (arg === '--port') {
+            options.port = parseIntArg(args[++index], '--port');
+        }
+        else if (arg.startsWith('--port=')) {
+            options.port = parseIntArg(arg.slice('--port='.length), '--port');
+        }
+        else if (arg === '--token') {
+            options.token = requiredValue(args[++index], '--token');
+        }
+        else if (arg.startsWith('--token=')) {
+            options.token = requiredValue(arg.slice('--token='.length), '--token');
+        }
+        else if (arg === '--request-timeout-ms') {
+            options.requestTimeoutMs = parseIntArg(args[++index], '--request-timeout-ms');
+        }
+        else if (arg.startsWith('--request-timeout-ms=')) {
+            options.requestTimeoutMs = parseIntArg(arg.slice('--request-timeout-ms='.length), '--request-timeout-ms');
+        }
+        else {
+            throw new Error(`Unknown argument: ${arg}`);
+        }
+    }
+    options.port = Math.min(65_535, Math.max(1_024, Math.trunc(options.port)));
+    options.requestTimeoutMs = Math.max(100, Math.trunc(options.requestTimeoutMs));
+    if (!options.help && options.token.trim() === '') {
+        throw new Error('A pairing token is required. Pass --token or set VV_IG_MCP_TOKEN.');
+    }
+    return options;
+}
+function parseIntEnv(name, fallback) {
+    const raw = process.env[name];
+    if (!raw) {
+        return fallback;
+    }
+    return parseIntArg(raw, name);
+}
+function parseIntArg(value, name) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed)) {
+        throw new Error(`${name} must be a finite number.`);
+    }
+    return Math.trunc(parsed);
+}
+function requiredValue(value, name) {
+    if (!value) {
+        throw new Error(`${name} requires a value.`);
+    }
+    return value;
+}
+function printHelp() {
+    process.stdout.write(`ViralVector Instagram MCP server
+
+Usage:
+  vv-ig-mcp --token <pairing-token> [--port 8765] [--request-timeout-ms 5000]
+
+Environment:
+  VV_IG_MCP_PORT
+  VV_IG_MCP_TOKEN
+  VV_IG_MCP_REQUEST_TIMEOUT_MS
+
+The MCP protocol uses stdio. Runtime diagnostics are written to stderr.
+The extension bridge listens only on 127.0.0.1.
+`);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`[vv-ig-mcp] fatal: ${message}\n`);
+    process.exit(1);
+});

package/dist/mcp/server.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ExtensionSessionRegistry } from '../bridge/sessionRegistry.js';
+export declare function createViralVectorMcpServer(registry: ExtensionSessionRegistry): McpServer;

package/dist/mcp/server.js

@@ -0,0 +1,10 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { registerMcpTools } from './tools.js';
+export function createViralVectorMcpServer(registry) {
+    const server = new McpServer({
+        name: '@viral_vector/ig-mcp',
+        version: '0.1.0'
+    });
+    registerMcpTools(server, registry);
+    return server;
+}

package/dist/mcp/tools.d.ts

@@ -0,0 +1,36 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ToolAnnotations } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import type { BridgeRequestResult, ExtensionSessionRegistry } from '../bridge/sessionRegistry.js';
+type ToolHandler = (input: Record<string, unknown>, registry: ExtensionSessionRegistry) => Promise<ToolResponse>;
+type ToolDefinition = {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: Record<string, z.ZodType>;
+    annotations?: ToolAnnotations;
+    handler: ToolHandler;
+};
+type ToolResponse = ReturnType<typeof jsonToolResponse> | ReturnType<typeof errorToolResponse>;
+export declare const V2_TOOL_DEFINITIONS: readonly ToolDefinition[];
+export declare const MCP_TOOL_DEFINITIONS: readonly ToolDefinition[];
+export declare function registerMcpTools(server: McpServer, registry: ExtensionSessionRegistry): void;
+declare function errorToolResponse(result: BridgeRequestResult): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+} | {
+    isError: boolean;
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};
+declare function jsonToolResponse(value: unknown): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};
+export {};