@autolabz/mcp-bridge 1.0.0

package/dist/bridge.d.ts

@@ -0,0 +1,24 @@
+import type { BridgeConfig } from './config.js';
+export declare class Bridge {
+    private config;
+    private ws;
+    private mcpClient;
+    private reconnectTimer;
+    private shouldReconnect;
+    constructor(config: BridgeConfig);
+    /**
+     * Start the bridge: connect to cloud relay via WebSocket.
+     */
+    start(): Promise<void>;
+    private connect;
+    private handleRequest;
+    private scheduleReconnect;
+    /**
+     * Rotate the key hash on the cloud relay.
+     */
+    rotateKey(newKeyHash: string): void;
+    /**
+     * Gracefully stop the bridge.
+     */
+    stop(): void;
+}

package/dist/bridge.js

@@ -0,0 +1,135 @@
+import WebSocket from 'ws';
+import { MCPClient } from './mcp-client.js';
+export class Bridge {
+    config;
+    ws = null;
+    mcpClient;
+    reconnectTimer = null;
+    shouldReconnect = true;
+    constructor(config) {
+        this.config = config;
+        this.mcpClient = new MCPClient(config.piecesEndpoint);
+    }
+    /**
+     * Start the bridge: connect to cloud relay via WebSocket.
+     */
+    async start() {
+        // Initialize local MCP session first
+        console.log('🔌 Initializing local MCP connection...');
+        try {
+            await this.mcpClient.initialize();
+            console.log('✅ Local MCP session established');
+        }
+        catch (err) {
+            console.error('❌ Failed to initialize MCP:', err);
+            console.log('⚠️  Will retry MCP initialization when requests arrive');
+        }
+        this.connect();
+    }
+    connect() {
+        const wsUrl = new URL('/ws/bridge', this.config.cloudUrl.replace('http', 'ws'));
+        wsUrl.searchParams.set('nodeId', this.config.nodeId);
+        wsUrl.searchParams.set('keyHash', this.config.keyHash);
+        console.log(`🌐 Connecting to cloud relay: ${wsUrl.origin}...`);
+        this.ws = new WebSocket(wsUrl.toString());
+        this.ws.on('open', () => {
+            console.log('✅ Connected to cloud relay');
+            if (this.reconnectTimer) {
+                clearTimeout(this.reconnectTimer);
+                this.reconnectTimer = null;
+            }
+        });
+        this.ws.on('message', async (data) => {
+            try {
+                const msg = JSON.parse(data.toString());
+                if (msg.type === 'registered') {
+                    console.log(`🎉 ${msg.message}`);
+                    console.log(`📋 Node ID: ${this.config.nodeId}`);
+                    console.log('👂 Waiting for remote requests...\n');
+                }
+                else if (msg.type === 'request' && msg.requestId) {
+                    await this.handleRequest(msg);
+                }
+                else if (msg.type === 'error') {
+                    console.error(`❌ Cloud error: ${msg.message}`);
+                }
+            }
+            catch (err) {
+                console.error('❌ Failed to handle cloud message:', err);
+            }
+        });
+        this.ws.on('close', (code, reason) => {
+            console.log(`🔌 Disconnected from cloud (${code}: ${reason.toString()})`);
+            this.scheduleReconnect();
+        });
+        this.ws.on('error', (err) => {
+            console.error('❌ WebSocket error:', err.message);
+        });
+    }
+    async handleRequest(msg) {
+        const { requestId, method, params } = msg;
+        console.log(`📥 [${requestId}] ${method}`);
+        try {
+            let result;
+            if (method === 'tools/list') {
+                result = await this.mcpClient.listTools();
+            }
+            else if (method === 'tools/call') {
+                const p = params;
+                result = await this.mcpClient.callTool(p.name, p.arguments);
+            }
+            else {
+                result = await this.mcpClient.sendRequest(method, params);
+            }
+            console.log(`📤 [${requestId}] responded`);
+            this.ws?.send(JSON.stringify({
+                type: 'response',
+                requestId,
+                result,
+            }));
+        }
+        catch (err) {
+            console.error(`❌ [${requestId}] error:`, err.message);
+            this.ws?.send(JSON.stringify({
+                type: 'response',
+                requestId,
+                result: { error: err.message },
+            }));
+        }
+    }
+    scheduleReconnect() {
+        if (!this.shouldReconnect)
+            return;
+        const delay = 5000;
+        console.log(`🔄 Reconnecting in ${delay / 1000}s...`);
+        this.reconnectTimer = setTimeout(() => {
+            this.connect();
+        }, delay);
+    }
+    /**
+     * Rotate the key hash on the cloud relay.
+     */
+    rotateKey(newKeyHash) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error('Not connected to cloud relay');
+        }
+        this.ws.send(JSON.stringify({
+            type: 'rotate_key',
+            newKeyHash,
+        }));
+        this.config.keyHash = newKeyHash;
+    }
+    /**
+     * Gracefully stop the bridge.
+     */
+    stop() {
+        this.shouldReconnect = false;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+        }
+        if (this.ws) {
+            this.ws.close(1000, 'bridge stopped');
+        }
+        console.log('👋 Bridge stopped');
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,18 @@
+export interface BridgeConfig {
+    cloudUrl: string;
+    nodeId: string;
+    keyHash: string;
+    piecesEndpoint: string;
+}
+/**
+ * Load the saved config, or return null if not found.
+ */
+export declare function loadConfig(): BridgeConfig | null;
+/**
+ * Save config to disk.
+ */
+export declare function saveConfig(config: BridgeConfig): void;
+/**
+ * Get the config file path (for display purposes).
+ */
+export declare function getConfigPath(): string;

package/dist/config.js

@@ -0,0 +1,38 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const CONFIG_DIR = join(homedir(), '.mcp-bridge');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+/**
+ * Ensure the config directory exists.
+ */
+function ensureConfigDir() {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+/**
+ * Load the saved config, or return null if not found.
+ */
+export function loadConfig() {
+    try {
+        const raw = readFileSync(CONFIG_FILE, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Save config to disk.
+ */
+export function saveConfig(config) {
+    ensureConfigDir();
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+}
+/**
+ * Get the config file path (for display purposes).
+ */
+export function getConfigPath() {
+    return CONFIG_FILE;
+}

package/dist/e2e-test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * End-to-end integration test for Cloud MCP Bridge.
+ *
+ * Prerequisites:
+ * 1. Cloud relay running: cd cloud && npx wrangler dev
+ * 2. Pieces OS running on localhost:39300
+ *
+ * This script will:
+ * 1. Generate a key and hash it via cloud
+ * 2. Get hashed machine ID
+ * 3. Start bridge, connect to cloud
+ * 4. Make remote curl-style calls via cloud relay
+ */
+export {};

package/dist/e2e-test.js

@@ -0,0 +1,228 @@
+/**
+ * End-to-end integration test for Cloud MCP Bridge.
+ *
+ * Prerequisites:
+ * 1. Cloud relay running: cd cloud && npx wrangler dev
+ * 2. Pieces OS running on localhost:39300
+ *
+ * This script will:
+ * 1. Generate a key and hash it via cloud
+ * 2. Get hashed machine ID
+ * 3. Start bridge, connect to cloud
+ * 4. Make remote curl-style calls via cloud relay
+ */
+import { randomUUID } from 'node:crypto';
+import { createRequire } from 'node:module';
+import WebSocket from 'ws';
+const require2 = createRequire(import.meta.url);
+const { machineIdSync } = require2('node-machine-id');
+const CLOUD_URL = 'http://localhost:8787';
+const PIECES_MCP = 'http://localhost:39300/model_context_protocol/2025-03-26/mcp';
+async function cloudHash(value) {
+    const res = await fetch(`${CLOUD_URL}/api/hash`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ value }),
+    });
+    const data = (await res.json());
+    return data.hash;
+}
+async function main() {
+    console.log('=== Cloud MCP Bridge E2E Test ===\n');
+    // Step 1: Generate key and hash it
+    const rawKey = randomUUID();
+    console.log(`[1] Generated raw key: ${rawKey}`);
+    const keyHash = await cloudHash(rawKey);
+    console.log(`    Key hash: ${keyHash.slice(0, 20)}...`);
+    // Step 2: Hash machine ID
+    const rawMachineId = machineIdSync({ original: true });
+    const nodeId = await cloudHash(rawMachineId);
+    console.log(`[2] Node ID: ${nodeId.slice(0, 20)}...`);
+    // Step 3: Connect bridge via WebSocket
+    console.log('[3] Connecting bridge to cloud...');
+    const wsUrl = `ws://localhost:8787/ws/bridge?nodeId=${nodeId}&keyHash=${keyHash}`;
+    const ws = new WebSocket(wsUrl);
+    await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error('WS connect timeout')), 10000);
+        ws.on('open', () => {
+            clearTimeout(timeout);
+            console.log('    ✅ WebSocket connected');
+        });
+        ws.on('message', (data) => {
+            const msg = JSON.parse(data.toString());
+            if (msg.type === 'registered') {
+                console.log(`    ✅ ${msg.message}`);
+                resolve();
+            }
+        });
+        ws.on('error', (err) => {
+            clearTimeout(timeout);
+            reject(err);
+        });
+    });
+    // Handle forwarded requests from cloud → bridge → local MCP
+    let mcpSessionId = null;
+    // Initialize local MCP session
+    console.log('[4] Initializing local MCP session...');
+    try {
+        const initPayload = {
+            jsonrpc: '2.0',
+            id: 0,
+            method: 'initialize',
+            params: {
+                protocolVersion: '2025-03-26',
+                capabilities: {},
+                clientInfo: { name: 'e2e-test', version: '1.0.0' },
+            },
+        };
+        const initRes = await fetch(PIECES_MCP, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json, text/event-stream',
+            },
+            body: JSON.stringify(initPayload),
+        });
+        const sid = initRes.headers.get('mcp-session-id');
+        if (sid)
+            mcpSessionId = sid;
+        console.log(`    ✅ MCP session: ${mcpSessionId?.slice(0, 15)}...`);
+    }
+    catch (err) {
+        console.log(`    ⚠️ MCP init failed (may still work): ${err}`);
+    }
+    // Bridge: handle incoming cloud requests
+    ws.on('message', async (data) => {
+        const msg = JSON.parse(data.toString());
+        if (msg.type !== 'request')
+            return;
+        console.log(`    📥 Bridge received: ${msg.method}`);
+        try {
+            // Forward to local MCP
+            const mcpPayload = {
+                jsonrpc: '2.0',
+                id: Date.now(),
+                method: msg.method,
+                ...(msg.params && { params: msg.params }),
+            };
+            const headers = {
+                'Content-Type': 'application/json',
+                Accept: 'application/json, text/event-stream',
+            };
+            if (mcpSessionId)
+                headers['mcp-session-id'] = mcpSessionId;
+            const mcpRes = await fetch(PIECES_MCP, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(mcpPayload),
+            });
+            const sid = mcpRes.headers.get('mcp-session-id');
+            if (sid)
+                mcpSessionId = sid;
+            const result = await mcpRes.json();
+            console.log(`    📤 Bridge responding`);
+            ws.send(JSON.stringify({
+                type: 'response',
+                requestId: msg.requestId,
+                result,
+            }));
+        }
+        catch (err) {
+            ws.send(JSON.stringify({
+                type: 'response',
+                requestId: msg.requestId,
+                result: { error: err.message },
+            }));
+        }
+    });
+    // Step 5: Test remote calls via cloud REST API
+    console.log('\n[5] Testing remote calls via cloud relay...\n');
+    // Test 5a: Check bridge status (requires auth)
+    console.log('--- Test: /mcp/:nodeId/status (Bearer auth) ---');
+    const statusRes = await fetch(`${CLOUD_URL}/mcp/${nodeId}/status`, {
+        headers: { Authorization: `Bearer ${rawKey}` },
+    });
+    const statusData = await statusRes.json();
+    console.log(`    Result: ${JSON.stringify(statusData)}`);
+    console.log(`    ${statusData.online ? '✅ PASS' : '❌ FAIL'}\n`);
+    // Test 5b: List tools with Bearer auth
+    console.log('--- Test: /mcp/:nodeId/tools (Bearer auth) ---');
+    const toolsRes = await fetch(`${CLOUD_URL}/mcp/${nodeId}/tools`, {
+        headers: { Authorization: `Bearer ${rawKey}` },
+    });
+    console.log(`    HTTP Status: ${toolsRes.status}`);
+    if (toolsRes.ok) {
+        const toolsData = (await toolsRes.json());
+        if (toolsData?.result?.tools) {
+            const tools = toolsData.result.tools;
+            console.log(`    Found ${tools.length} tools:`);
+            for (const t of tools) {
+                console.log(`      - ${t.name}`);
+            }
+            console.log('    ✅ PASS\n');
+        }
+        else {
+            console.log(`    Response: ${JSON.stringify(toolsData).slice(0, 200)}`);
+            console.log('    ⚠️ Unexpected format\n');
+        }
+    }
+    else {
+        const err = await toolsRes.text();
+        console.log(`    Error: ${err}`);
+        console.log('    ❌ FAIL\n');
+    }
+    // Test 5c: Call ask_pieces_ltm
+    console.log('--- Test: /mcp/:nodeId/call (ask_pieces_ltm) ---');
+    const callRes = await fetch(`${CLOUD_URL}/mcp/${nodeId}/call`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${rawKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            method: 'tools/call',
+            params: {
+                name: 'ask_pieces_ltm',
+                arguments: {
+                    question: '今天我做了什么',
+                    chat_llm: 'gpt-4o',
+                    connected_client: 'e2e-test',
+                },
+            },
+        }),
+    });
+    console.log(`    HTTP Status: ${callRes.status}`);
+    if (callRes.ok) {
+        const callData = (await callRes.json());
+        const text = callData?.result?.content?.[0]?.text;
+        if (text) {
+            console.log(`    LTM response length: ${text.length} chars`);
+            console.log(`    Preview: ${text.slice(0, 150)}...`);
+            console.log('    ✅ PASS\n');
+        }
+        else {
+            console.log(`    Response: ${JSON.stringify(callData).slice(0, 300)}`);
+            console.log('    ⚠️ Check response format\n');
+        }
+    }
+    else {
+        const err = await callRes.text();
+        console.log(`    Error: ${err}`);
+        console.log('    ❌ FAIL\n');
+    }
+    // Test 5d: Wrong key should be rejected
+    console.log('--- Test: Invalid Bearer key (should fail) ---');
+    const badRes = await fetch(`${CLOUD_URL}/mcp/${nodeId}/tools`, {
+        headers: { Authorization: 'Bearer wrong-key-12345' },
+    });
+    console.log(`    HTTP Status: ${badRes.status} (expect 403)`);
+    console.log(`    ${badRes.status === 403 ? '✅ PASS' : '❌ FAIL'}\n`);
+    // Cleanup
+    ws.close();
+    console.log('=== E2E Test Complete ===');
+    process.exit(0);
+}
+main().catch((err) => {
+    console.error('Test failed:', err);
+    process.exit(1);
+});

package/dist/identity.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Get the raw machine ID.
+ */
+export declare function getRawMachineId(): string;
+/**
+ * Hash the machine ID via the cloud /api/hash endpoint.
+ */
+export declare function getHashedMachineId(cloudUrl: string): Promise<string>;

package/dist/identity.js

@@ -0,0 +1,25 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const { machineIdSync } = require('node-machine-id');
+/**
+ * Get the raw machine ID.
+ */
+export function getRawMachineId() {
+    return machineIdSync({ original: true });
+}
+/**
+ * Hash the machine ID via the cloud /api/hash endpoint.
+ */
+export async function getHashedMachineId(cloudUrl) {
+    const rawId = getRawMachineId();
+    const response = await fetch(`${cloudUrl}/api/hash`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ value: rawId }),
+    });
+    if (!response.ok) {
+        throw new Error(`Hash request failed: ${response.status}`);
+    }
+    const data = (await response.json());
+    return data.hash;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { randomUUID } from 'node:crypto';
+import { getHashedMachineId } from './identity.js';
+import { loadConfig, saveConfig, getConfigPath } from './config.js';
+import { Bridge } from './bridge.js';
+const program = new Command();
+program
+    .name('mcp-bridge')
+    .description('Bridge local Pieces MCP to cloud relay')
+    .version('1.0.0');
+/**
+ * init: First-time setup. Generates API key, hashes machine ID,
+ * and saves config.
+ */
+program
+    .command('init')
+    .description('Initialize bridge configuration')
+    .requiredOption('--cloud <url>', 'Cloud relay URL (e.g. http://localhost:8787)')
+    .option('--pieces <url>', 'Local Pieces MCP endpoint', 'http://localhost:39300/model_context_protocol/2025-03-26/mcp')
+    .action(async (opts) => {
+    const cloudUrl = opts.cloud.replace(/\/+$/, '');
+    const piecesEndpoint = opts.pieces;
+    console.log('🔧 Initializing MCP Bridge...\n');
+    // Generate a new API key
+    const rawKey = randomUUID();
+    console.log(`🔑 Generated API Key: ${rawKey}`);
+    console.log('⚠️  请妥善保管此 Key，仅显示一次！\n');
+    // Hash the key via cloud
+    console.log('📡 Hashing key via cloud...');
+    const keyHashRes = await fetch(`${cloudUrl}/api/hash`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ value: rawKey }),
+    });
+    if (!keyHashRes.ok) {
+        console.error(`❌ Cloud hash failed: ${keyHashRes.status}`);
+        process.exit(1);
+    }
+    const { hash: keyHash } = (await keyHashRes.json());
+    // Hash the machine ID via cloud
+    console.log('📡 Hashing machine ID via cloud...');
+    const nodeId = await getHashedMachineId(cloudUrl);
+    // Save config
+    const config = {
+        cloudUrl,
+        nodeId,
+        keyHash,
+        piecesEndpoint,
+    };
+    saveConfig(config);
+    console.log(`\n✅ 配置已保存到: ${getConfigPath()}`);
+    console.log(`📋 Node ID: ${nodeId}`);
+    console.log(`\n📌 远程调用示例:`);
+    console.log(`   curl http://localhost:8787/mcp/${nodeId}/tools \\`);
+    console.log(`     -H "Authorization: Bearer ${rawKey}"`);
+});
+/**
+ * start: Connect the bridge to the cloud relay.
+ */
+program
+    .command('start')
+    .description('Start the bridge and connect to cloud relay')
+    .action(async () => {
+    const config = loadConfig();
+    if (!config) {
+        console.error('❌ No configuration found. Run `mcp-bridge init` first.');
+        process.exit(1);
+    }
+    console.log('🚀 Starting MCP Bridge...');
+    console.log(`   Cloud:  ${config.cloudUrl}`);
+    console.log(`   Pieces: ${config.piecesEndpoint}`);
+    console.log(`   NodeID: ${config.nodeId}\n`);
+    const bridge = new Bridge(config);
+    // Graceful shutdown
+    process.on('SIGINT', () => {
+        bridge.stop();
+        process.exit(0);
+    });
+    process.on('SIGTERM', () => {
+        bridge.stop();
+        process.exit(0);
+    });
+    await bridge.start();
+});
+/**
+ * rotate-key: Generate a new API key and update the cloud relay.
+ */
+program
+    .command('rotate-key')
+    .description('Generate a new API key and update the registration')
+    .action(async () => {
+    const config = loadConfig();
+    if (!config) {
+        console.error('❌ No configuration found. Run `mcp-bridge init` first.');
+        process.exit(1);
+    }
+    const newKey = randomUUID();
+    console.log(`🔑 New API Key: ${newKey}`);
+    console.log('⚠️  请妥善保管此 Key，仅显示一次！\n');
+    // Hash the new key
+    const res = await fetch(`${config.cloudUrl}/api/hash`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ value: newKey }),
+    });
+    if (!res.ok) {
+        console.error(`❌ Cloud hash failed: ${res.status}`);
+        process.exit(1);
+    }
+    const { hash: newKeyHash } = (await res.json());
+    // Update config
+    config.keyHash = newKeyHash;
+    saveConfig(config);
+    console.log('✅ 配置已更新');
+    console.log('⚠️  如果 bridge 正在运行，请重启以生效');
+});
+/**
+ * status: Show current configuration.
+ */
+program
+    .command('status')
+    .description('Show current bridge configuration')
+    .action(() => {
+    const config = loadConfig();
+    if (!config) {
+        console.log('❌ No configuration found. Run `mcp-bridge init` first.');
+        return;
+    }
+    console.log('📋 MCP Bridge Status');
+    console.log('-'.repeat(40));
+    console.log(`Config: ${getConfigPath()}`);
+    console.log(`Cloud:  ${config.cloudUrl}`);
+    console.log(`Pieces: ${config.piecesEndpoint}`);
+    console.log(`NodeID: ${config.nodeId}`);
+    console.log(`KeyHash: ${config.keyHash.slice(0, 12)}...`);
+});
+program.parse();

package/dist/mcp-client.d.ts

@@ -0,0 +1,25 @@
+/**
+ * MCP Streamable HTTP Client
+ * Connects to local Pieces OS via the 2025-03-26 Streamable HTTP transport.
+ */
+export declare class MCPClient {
+    private endpoint;
+    private sessionId;
+    constructor(endpoint: string);
+    /**
+     * Initialize the MCP session by sending the 'initialize' handshake.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Send a JSON-RPC request to the local MCP server.
+     */
+    sendRequest(method: string, params?: unknown): Promise<unknown>;
+    /**
+     * List available MCP tools.
+     */
+    listTools(): Promise<unknown>;
+    /**
+     * Call an MCP tool.
+     */
+    callTool(name: string, args: Record<string, unknown>): Promise<unknown>;
+}

package/dist/mcp-client.js

@@ -0,0 +1,92 @@
+/**
+ * MCP Streamable HTTP Client
+ * Connects to local Pieces OS via the 2025-03-26 Streamable HTTP transport.
+ */
+export class MCPClient {
+    endpoint;
+    sessionId = null;
+    constructor(endpoint) {
+        this.endpoint = endpoint;
+    }
+    /**
+     * Initialize the MCP session by sending the 'initialize' handshake.
+     */
+    async initialize() {
+        const payload = {
+            jsonrpc: '2.0',
+            id: 0,
+            method: 'initialize',
+            params: {
+                protocolVersion: '2025-03-26',
+                capabilities: {},
+                clientInfo: {
+                    name: 'mcp-bridge',
+                    version: '1.0.0',
+                },
+            },
+        };
+        const response = await fetch(this.endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json, text/event-stream',
+            },
+            body: JSON.stringify(payload),
+        });
+        // Extract session ID from response headers
+        const sid = response.headers.get('mcp-session-id');
+        if (sid) {
+            this.sessionId = sid;
+        }
+        const data = await response.json();
+        console.log('[mcp-client] initialized:', JSON.stringify(data));
+    }
+    /**
+     * Send a JSON-RPC request to the local MCP server.
+     */
+    async sendRequest(method, params) {
+        if (!this.sessionId) {
+            await this.initialize();
+        }
+        const payload = {
+            jsonrpc: '2.0',
+            id: Date.now(),
+            method,
+            ...(params !== undefined && { params }),
+        };
+        const headers = {
+            'Content-Type': 'application/json',
+            Accept: 'application/json, text/event-stream',
+        };
+        if (this.sessionId) {
+            headers['mcp-session-id'] = this.sessionId;
+        }
+        const response = await fetch(this.endpoint, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(payload),
+        });
+        // Update session ID if changed
+        const sid = response.headers.get('mcp-session-id');
+        if (sid) {
+            this.sessionId = sid;
+        }
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`MCP request failed (${response.status}): ${text}`);
+        }
+        return response.json();
+    }
+    /**
+     * List available MCP tools.
+     */
+    async listTools() {
+        return this.sendRequest('tools/list');
+    }
+    /**
+     * Call an MCP tool.
+     */
+    async callTool(name, args) {
+        return this.sendRequest('tools/call', { name, arguments: args });
+    }
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@autolabz/mcp-bridge",
+  "version": "1.0.0",
+  "description": "Bridge local Pieces MCP to cloud relay for remote AI agent access",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "mcp-bridge": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js"
+  },
+  "keywords": [
+    "mcp",
+    "pieces",
+    "bridge",
+    "cloudflare-workers",
+    "long-term-memory"
+  ],
+  "author": "mzhh",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mzhh/mcp-proxy"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "commander": "^13.1.0",
+    "node-machine-id": "^1.1.12",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.5.13",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  }
+}