agent-gear 1.1.1 → 1.1.4

package/src/commands/mcp-proxy.ts

@@ -0,0 +1,128 @@
+import { spawn, ChildProcess } from 'child_process';
+import { io as ioClient, Socket } from 'socket.io-client';
+
+interface McpProxyOptions {
+  server: string;
+  key: string;
+  command: string;
+}
+
+export async function startMcpRegistration(options: McpProxyOptions): Promise<void> {
+  const { server, key, command } = options;
+
+  console.log(`Registering MCP proxy with server ${server}...`);
+
+  // 1. Register with server
+  const response = await fetch(`${server}/api/mcp-proxy/register`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      key,
+      hostname: process.env.HOSTNAME || 'unknown',
+      command,
+      serverName: command.split(' ').pop() || 'unknown',
+    }),
+  });
+
+  const result = await response.json() as any;
+  if (!result.success) {
+    console.error('Registration failed:', result.error);
+    process.exit(1);
+  }
+
+  console.log(`Registered as proxy ${result.proxyId}, server ${result.serverId}`);
+
+  // 2. Spawn local command
+  const [cmd, ...args] = command.split(' ');
+  console.log(`Starting local MCP command: ${cmd} ${args.join(' ')}`);
+
+  const child = spawn(cmd, args, {
+    stdio: ['pipe', 'pipe', 'pipe'],
+    shell: true,
+  });
+
+  child.on('error', (err) => {
+    console.error('Failed to start MCP command:', err.message);
+  });
+
+  child.on('exit', (code) => {
+    console.log(`MCP command exited with code ${code}`);
+  });
+
+  // 3. Establish WebSocket connection
+  const socket = ioClient(`${server}/mcp-proxy`, {
+    transports: ['websocket'],
+    autoConnect: true,
+  });
+
+  socket.on('connect', () => {
+    console.log('WebSocket connected to proxy namespace');
+    socket.emit('proxy:register', { proxyId: result.proxyId, key });
+  });
+
+  socket.on('proxy:registered', (data: { proxyId: string; serverId: string }) => {
+    console.log(`Registered with proxy namespace, serverId: ${data.serverId}`);
+  });
+
+  socket.on('proxy:error', (data: { code: string; message: string }) => {
+    console.error(`Proxy error: ${data.code} - ${data.message}`);
+  });
+
+  // 4. Bridge requests
+  socket.on('proxy:request', async (data: { requestId: string; request: any }) => {
+    try {
+      const response = await forwardToChild(child, data.request);
+      socket.emit('proxy:response', { requestId: data.requestId, response });
+    } catch (err: any) {
+      socket.emit('proxy:response', {
+        requestId: data.requestId,
+        response: {
+          jsonrpc: '2.0',
+          id: data.request.id,
+          error: { code: -32603, message: err.message },
+        },
+      });
+    }
+  });
+
+  // 5. Heartbeat
+  const heartbeatInterval = setInterval(() => {
+    if (socket.connected) {
+      socket.emit('proxy:heartbeat', { proxyId: result.proxyId });
+    }
+  }, 30000);
+
+  // 6. Cleanup
+  const shutdown = () => {
+    console.log('Shutting down MCP proxy...');
+    clearInterval(heartbeatInterval);
+    socket.emit('proxy:unregister', { proxyId: result.proxyId });
+    child.kill();
+    socket.disconnect();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+function forwardToChild(child: ChildProcess, request: any): Promise<any> {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error('Request timeout'));
+    }, 30000);
+
+    const onData = (data: Buffer) => {
+      clearTimeout(timeout);
+      child.stdout?.removeListener('data', onData);
+      try {
+        resolve(JSON.parse(data.toString()));
+      } catch {
+        reject(new Error('Invalid JSON response from MCP command'));
+      }
+    };
+
+    child.stdout?.on('data', onData);
+    child.stdin?.write(JSON.stringify(request) + '\n');
+  });
+}

package/src/commands/mcp.ts

@@ -0,0 +1,41 @@
+import * as readline from 'readline';
+
+interface McpProxyOptions {
+  endpoint: string;
+  token: string;
+}
+
+export async function startMcpProxy(options: McpProxyOptions): Promise<void> {
+  const { endpoint, token } = options;
+
+  console.log(`Starting MCP proxy for endpoint: ${endpoint}`);
+
+  const rl = readline.createInterface({ input: process.stdin });
+
+  rl.on('line', async (line) => {
+    try {
+      const request = JSON.parse(line);
+      const response = await fetch(endpoint, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${token}`,
+        },
+        body: JSON.stringify(request),
+      });
+      const result = await response.json();
+      process.stdout.write(JSON.stringify(result) + '\n');
+    } catch (err: any) {
+      const error = {
+        jsonrpc: '2.0',
+        id: null,
+        error: { code: -32603, message: err.message },
+      };
+      process.stdout.write(JSON.stringify(error) + '\n');
+    }
+  });
+
+  rl.on('close', () => {
+    process.exit(0);
+  });
+}

package/src/gateway.test.ts

@@ -0,0 +1,301 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('node:net', () => ({
+  default: {
+    connect: vi.fn(),
+  },
+}));
+
+import net from 'node:net';
+import { GatewayManager } from './gateway.js';
+
+function createMockLocalSocket() {
+  const handlers = new Map<string, Function>();
+  return {
+    once: vi.fn((event: string, handler: Function) => {
+      handlers.set(event, handler);
+    }),
+    on: vi.fn((event: string, handler: Function) => {
+      handlers.set(event, handler);
+    }),
+    removeListener: vi.fn(),
+    destroy: vi.fn(),
+    write: vi.fn(),
+    emit: vi.fn(),
+    setKeepAlive: vi.fn(),
+    _handlers: handlers,
+    _trigger(event: string, ...args: unknown[]) {
+      const handler = handlers.get(event);
+      if (handler) handler(...args);
+    },
+  };
+}
+
+function createMockServerSocket() {
+  return {
+    emit: vi.fn(),
+  };
+}
+
+describe('GatewayManager', () => {
+  let gatewayManager: GatewayManager;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    gatewayManager = new GatewayManager();
+  });
+
+  describe('createTunnel', () => {
+    it('should send port-forward:created(success: true) and store tunnel on connection success', async () => {
+      const mockLocalSocket = createMockLocalSocket();
+      const mockServerSocket = createMockServerSocket();
+      vi.mocked(net.connect).mockReturnValue(mockLocalSocket as never);
+
+      const promise = gatewayManager.createTunnel('tunnel-1', 3000, mockServerSocket as never);
+      mockLocalSocket._trigger('connect');
+      await promise;
+
+      expect(net.connect).toHaveBeenCalledWith({ host: '127.0.0.1', port: 3000 });
+      expect(mockLocalSocket.setKeepAlive).toHaveBeenCalledWith(true, 5000);
+      expect(mockServerSocket.emit).toHaveBeenCalledWith('port-forward:created', {
+        tunnelId: 'tunnel-1',
+        success: true,
+      });
+    });
+
+    it('should destroy socket and schedule reconnect on connection failure (not emit failure to server)', async () => {
+      const mockLocalSocket = createMockLocalSocket();
+      const mockServerSocket = createMockServerSocket();
+      vi.mocked(net.connect).mockReturnValue(mockLocalSocket as never);
+
+      const promise = gatewayManager.createTunnel('tunnel-1', 3000, mockServerSocket as never);
+      mockLocalSocket._trigger('error', new Error('ECONNREFUSED'));
+      await promise;
+
+      expect(mockServerSocket.emit).not.toHaveBeenCalled();
+      expect(mockLocalSocket.destroy).toHaveBeenCalled();
+    });
+
+    it('should send port-forward:data with base64 encoded data when local socket receives data', async () => {
+      const mockLocalSocket = createMockLocalSocket();
+      const mockServerSocket = createMockServerSocket();
+      vi.mocked(net.connect).mockReturnValue(mockLocalSocket as never);
+
+      const promise = gatewayManager.createTunnel('tunnel-1', 3000, mockServerSocket as never);
+      mockLocalSocket._trigger('connect');
+      await promise;
+
+      const testData = Buffer.from('hello world');
+      mockLocalSocket._trigger('data', testData);
+
+      expect(mockServerSocket.emit).toHaveBeenCalledWith('port-forward:data', {
+        tunnelId: 'tunnel-1',
+        data: testData.toString('base64'),
+      });
+    });
+
+    it('should schedule reconnect (not emit close) when local socket closes', async () => {
+      const mockLocalSocket = createMockLocalSocket();
+      const mockServerSocket = createMockServerSocket();
+      vi.mocked(net.connect).mockReturnValue(mockLocalSocket as never);
+
+      const promise = gatewayManager.createTunnel('tunnel-1', 3000, mockServerSocket as never);
+      mockLocalSocket._trigger('connect');
+      await promise;
+
+      mockLocalSocket._trigger('close');
+
+      expect(mockServerSocket.emit).not.toHaveBeenCalledWith('port-forward:close', expect.anything());
+    });
+
+    it('should send port-forward:error on local socket error after connect', async () => {
+      const mockLocalSocket = createMockLocalSocket();
+      const mockServerSocket = createMockServerSocket();
+      vi.mocked(net.connect).mockReturnValue(mockLocalSocket as never);
+
+      const promise = gatewayManager.createTunnel('tunnel-1', 3000, mockServerSocket as never);
+      mockLocalSocket._trigger('connect');
+      await promise;
+
+      mockLocalSocket._trigger('error', new Error('ECONNRESET'));
+
+      expect(mockServerSocket.emit).toHaveBeenCalledWith('port-forward:error', {
+        tunnelId: 'tunnel-1',
+        error: 'ECONNRESET',
+      });
+    });
+  });
+
+  describe('handleTunnelData', () => {
+    it('should write base64 decoded data to the corresponding local socket', async () => {
+      const mockLocalSocket = createMockLocalSocket();
+      const mockServerSocket = createMockServerSocket();
+      vi.mocked(net.connect).mockReturnValue(mockLocalSocket as never);
+
+      const promise = gatewayManager.createTunnel('tunnel-1', 3000, mockServerSocket as never);
+      mockLocalSocket._trigger('connect');
+      await promise;
+
+      const base64Data = Buffer.from('test payload').toString('base64');
+      gatewayManager.handleTunnelData('tunnel-1', base64Data);
+
+      expect(mockLocalSocket.write).toHaveBeenCalledWith(Buffer.from('test payload'));
+    });
+
+    it('should parse http-request JSON and write raw HTTP request to local socket', async () => {
+      const mockLocalSocket = createMockLocalSocket();
+      const mockServerSocket = createMockServerSocket();
+      vi.mocked(net.connect).mockReturnValue(mockLocalSocket as never);
+
+      const promise = gatewayManager.createTunnel('tunnel-1', 3000, mockServerSocket as never);
+      mockLocalSocket._trigger('connect');
+      await promise;
+
+      const httpRequest = {
+        type: 'http-request',
+        requestId: 'req-1',
+        method: 'POST',
+        path: '/api/test',
+        headers: { 'content-type': 'application/json', 'x-custom': 'val' },
+        body: Buffer.from('{"key":"value"}').toString('base64'),
+      };
+      const base64Data = Buffer.from(JSON.stringify(httpRequest)).toString('base64');
+      gatewayManager.handleTunnelData('tunnel-1', base64Data);
+
+      const expected = 'POST /api/test HTTP/1.1\r\n' +
+        'content-type: application/json\r\n' +
+        'x-custom: val\r\n' +
+        'Host: 127.0.0.1:3000\r\n' +
+        'Connection: close\r\n' +
+        '\r\n' +
+        '{"key":"value"}';
+
+      expect(mockLocalSocket.write).toHaveBeenCalledWith(expected);
+    });
+
+    it('should send raw base64 TCP response when no pending http-request', async () => {
+      const mockLocalSocket = createMockLocalSocket();
+      const mockServerSocket = createMockServerSocket();
+      vi.mocked(net.connect).mockReturnValue(mockLocalSocket as never);
+
+      const promise = gatewayManager.createTunnel('tunnel-1', 3000, mockServerSocket as never);
+      mockLocalSocket._trigger('connect');
+      await promise;
+
+      const testData = Buffer.from('HTTP/1.1 200 OK\r\n\r\nok');
+      mockLocalSocket._trigger('data', testData);
+
+      expect(mockServerSocket.emit).toHaveBeenCalledWith('port-forward:data', {
+        tunnelId: 'tunnel-1',
+        data: testData.toString('base64'),
+      });
+    });
+
+    it('should wrap TCP response in http-response JSON when pendingRequestId is set', async () => {
+      vi.useFakeTimers();
+
+      const mockLocalSocket = createMockLocalSocket();
+      const mockServerSocket = createMockServerSocket();
+      vi.mocked(net.connect).mockReturnValue(mockLocalSocket as never);
+
+      const promise = gatewayManager.createTunnel('tunnel-1', 3000, mockServerSocket as never);
+      mockLocalSocket._trigger('connect');
+      await promise;
+
+      const httpRequest = {
+        type: 'http-request',
+        requestId: 'req-42',
+        method: 'GET',
+        path: '/',
+        headers: {},
+      };
+      gatewayManager.handleTunnelData('tunnel-1', Buffer.from(JSON.stringify(httpRequest)).toString('base64'));
+
+      mockLocalSocket.write.mockClear();
+      mockServerSocket.emit.mockClear();
+
+      const tcpResponse = Buffer.from('HTTP/1.1 200 OK\r\ncontent-length: 2\r\n\r\nok');
+      mockLocalSocket._trigger('data', tcpResponse);
+
+      expect(mockServerSocket.emit).not.toHaveBeenCalled();
+
+      vi.advanceTimersByTime(150);
+
+      expect(mockServerSocket.emit).toHaveBeenCalledWith('port-forward:data', expect.objectContaining({
+        tunnelId: 'tunnel-1',
+      }));
+      const emitArg = mockServerSocket.emit.mock.calls.find(
+        (c: any[]) => c[0] === 'port-forward:data',
+      )?.[1];
+      expect(emitArg).toBeDefined();
+      const decoded = JSON.parse(Buffer.from(emitArg.data as string, 'base64').toString('utf8'));
+      expect(decoded.type).toBe('http-response');
+      expect(decoded.requestId).toBe('req-42');
+      expect(decoded.body).toBe(tcpResponse.toString('base64'));
+
+      vi.useRealTimers();
+    });
+
+    it('should log warning and ignore for unknown tunnelId', () => {
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      gatewayManager.handleTunnelData('unknown-tunnel', 'data');
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('unknown tunnel'),
+      );
+      warnSpy.mockRestore();
+    });
+  });
+
+  describe('closeTunnel', () => {
+    it('should destroy local socket, emit close, and remove tunnel from map', async () => {
+      const mockLocalSocket = createMockLocalSocket();
+      const mockServerSocket = createMockServerSocket();
+      vi.mocked(net.connect).mockReturnValue(mockLocalSocket as never);
+
+      const promise = gatewayManager.createTunnel('tunnel-1', 3000, mockServerSocket as never);
+      mockLocalSocket._trigger('connect');
+      await promise;
+
+      gatewayManager.closeTunnel('tunnel-1');
+
+      expect(mockLocalSocket.destroy).toHaveBeenCalled();
+      expect(mockServerSocket.emit).toHaveBeenCalledWith('port-forward:close', {
+        tunnelId: 'tunnel-1',
+      });
+    });
+
+    it('should silently ignore unknown tunnelId', () => {
+      expect(() => gatewayManager.closeTunnel('unknown-tunnel')).not.toThrow();
+    });
+  });
+
+  describe('closeAll', () => {
+    it('should close all tunnels, emit close events, and clear the map', async () => {
+      const socket1 = createMockLocalSocket();
+      const socket2 = createMockLocalSocket();
+      const mockServerSocket = createMockServerSocket();
+      vi.mocked(net.connect)
+        .mockReturnValueOnce(socket1 as never)
+        .mockReturnValueOnce(socket2 as never);
+
+      const promise1 = gatewayManager.createTunnel('tunnel-1', 3000, mockServerSocket as never);
+      socket1._trigger('connect');
+      await promise1;
+
+      const promise2 = gatewayManager.createTunnel('tunnel-2', 4000, mockServerSocket as never);
+      socket2._trigger('connect');
+      await promise2;
+
+      gatewayManager.closeAll();
+
+      expect(socket1.destroy).toHaveBeenCalled();
+      expect(socket2.destroy).toHaveBeenCalled();
+      expect(mockServerSocket.emit).toHaveBeenCalledWith('port-forward:close', {
+        tunnelId: 'tunnel-1',
+      });
+      expect(mockServerSocket.emit).toHaveBeenCalledWith('port-forward:close', {
+        tunnelId: 'tunnel-2',
+      });
+    });
+  });
+});

package/src/gateway.ts

@@ -0,0 +1,195 @@
+import net from 'node:net';
+import type { Socket } from 'socket.io-client';
+
+interface Tunnel {
+  id: string;
+  port: number;
+  localSocket: net.Socket | null;
+  serverSocket: Socket;
+  pendingRequestId?: string | null;
+  responseBuffer: Buffer[];
+  responseTimer?: ReturnType<typeof setTimeout> | null;
+}
+
+const RECONNECT_INTERVAL_MS = 3000;
+const HTTP_RESPONSE_COLLECT_MS = 100;
+
+export class GatewayManager {
+  private tunnels: Map<string, Tunnel> = new Map();
+  private reconnectTimers: Map<string, ReturnType<typeof setTimeout>> = new Map();
+
+  async createTunnel(tunnelId: string, port: number, serverSocket: Socket): Promise<void> {
+    this.tunnels.set(tunnelId, { id: tunnelId, port, localSocket: null, serverSocket, responseBuffer: [] });
+    await this.connect(tunnelId, true);
+  }
+
+  private async connect(tunnelId: string, isInitial: boolean): Promise<void> {
+    const tunnel = this.tunnels.get(tunnelId);
+    if (!tunnel) return;
+
+    const localSocket = net.connect({ host: '127.0.0.1', port: tunnel.port });
+    localSocket.setKeepAlive(true, 5000);
+
+    return new Promise<void>((resolve) => {
+      const onError = (err: Error) => {
+        console.error(`Gateway tunnel error: tunnelId=${tunnelId} error=${err.message}`);
+        localSocket.destroy();
+        this.scheduleReconnect(tunnelId);
+        resolve();
+      };
+
+      localSocket.once('error', onError);
+
+      localSocket.once('connect', () => {
+        localSocket.removeListener('error', onError);
+
+        tunnel.localSocket = localSocket;
+        console.log(`Gateway tunnel connected: tunnelId=${tunnelId} port=${tunnel.port}`);
+
+        if (isInitial) {
+          tunnel.serverSocket.emit('port-forward:created', { tunnelId, success: true });
+        }
+
+        localSocket.on('data', (data: Buffer) => {
+          if (tunnel.pendingRequestId) {
+            tunnel.responseBuffer.push(data);
+            if (tunnel.responseTimer) clearTimeout(tunnel.responseTimer);
+            tunnel.responseTimer = setTimeout(() => this.flushResponse(tunnel), HTTP_RESPONSE_COLLECT_MS);
+          } else {
+            tunnel.serverSocket.emit('port-forward:data', {
+              tunnelId,
+              data: data.toString('base64'),
+            });
+          }
+        });
+
+        localSocket.on('close', () => {
+          console.log(`Gateway local socket closed: tunnelId=${tunnelId}`);
+          tunnel.localSocket = null;
+          this.scheduleReconnect(tunnelId);
+        });
+
+        localSocket.on('error', (err: Error) => {
+          console.error(`Gateway local socket error: tunnelId=${tunnelId} error=${err.message}`);
+          tunnel.serverSocket.emit('port-forward:error', { tunnelId, error: err.message });
+        });
+
+        resolve();
+      });
+    });
+  }
+
+  private flushResponse(tunnel: Tunnel): void {
+    if (!tunnel.pendingRequestId) return;
+    const combined = Buffer.concat(tunnel.responseBuffer);
+    tunnel.responseBuffer = [];
+    const requestId = tunnel.pendingRequestId;
+    tunnel.pendingRequestId = null;
+    tunnel.responseTimer = null;
+
+    tunnel.serverSocket.emit('port-forward:data', {
+      tunnelId: tunnel.id,
+      data: Buffer.from(JSON.stringify({
+        type: 'http-response',
+        requestId,
+        body: combined.toString('base64'),
+      })).toString('base64'),
+    });
+  }
+
+  private scheduleReconnect(tunnelId: string): void {
+    if (!this.tunnels.has(tunnelId) || this.reconnectTimers.has(tunnelId)) return;
+
+    console.log(`Gateway scheduling reconnection: tunnelId=${tunnelId}`);
+    const timer = setTimeout(() => {
+      this.reconnectTimers.delete(tunnelId);
+      this.connect(tunnelId, false);
+    }, RECONNECT_INTERVAL_MS);
+
+    this.reconnectTimers.set(tunnelId, timer);
+  }
+
+  handleTunnelData(tunnelId: string, data: string): void {
+    const tunnel = this.tunnels.get(tunnelId);
+    if (!tunnel) {
+      console.warn(`Gateway data for unknown tunnel: tunnelId=${tunnelId}`);
+      return;
+    }
+
+    const buffer = Buffer.from(data, 'base64');
+    let parsed: any;
+    try {
+      parsed = JSON.parse(buffer.toString('utf8'));
+    } catch {
+      if (tunnel.localSocket) {
+        tunnel.localSocket.write(buffer);
+      }
+      return;
+    }
+
+    if (parsed.type === 'http-request') {
+      const { method, path, headers, body } = parsed;
+      let rawRequest = `${method} ${path} HTTP/1.1\r\n`;
+      for (const [key, value] of Object.entries(headers || {})) {
+        rawRequest += `${key}: ${value}\r\n`;
+      }
+      rawRequest += `Host: 127.0.0.1:${tunnel.port}\r\n`;
+      rawRequest += 'Connection: close\r\n';
+      rawRequest += '\r\n';
+      if (body) rawRequest += Buffer.from(body, 'base64').toString('utf8');
+
+      tunnel.pendingRequestId = parsed.requestId;
+      tunnel.responseBuffer = [];
+
+      if (tunnel.localSocket) {
+        tunnel.localSocket.write(rawRequest);
+      }
+      return;
+    }
+
+    if (tunnel.localSocket) {
+      tunnel.localSocket.write(buffer);
+    }
+  }
+
+  closeTunnel(tunnelId: string): void {
+    const tunnel = this.tunnels.get(tunnelId);
+    if (!tunnel) return;
+
+    console.log(`Gateway closing tunnel: tunnelId=${tunnelId}`);
+
+    const timer = this.reconnectTimers.get(tunnelId);
+    if (timer) {
+      clearTimeout(timer);
+      this.reconnectTimers.delete(tunnelId);
+    }
+
+    this.tunnels.delete(tunnelId);
+
+    if (tunnel.localSocket) {
+      tunnel.localSocket.destroy();
+    }
+    tunnel.serverSocket.emit('port-forward:close', { tunnelId });
+  }
+
+  closeAll(): void {
+    console.log(`Gateway closing all tunnels: count=${this.tunnels.size}`);
+
+    for (const [tunnelId, tunnel] of [...this.tunnels]) {
+      const timer = this.reconnectTimers.get(tunnelId);
+      if (timer) {
+        clearTimeout(timer);
+        this.reconnectTimers.delete(tunnelId);
+      }
+
+      this.tunnels.delete(tunnelId);
+
+      if (tunnel.localSocket) {
+        tunnel.localSocket.destroy();
+      }
+      tunnel.serverSocket.emit('port-forward:close', { tunnelId: tunnel.id });
+    }
+  }
+}
+
+export const gatewayManager = new GatewayManager();

package/src/index.ts

@@ -4,6 +4,8 @@ import { hostname } from 'os';
 import { resolveKey, resolveEndpoint, saveKeyToConfig, saveEndpointToConfig } from './config.js';
 import { connectToServer } from './socketio-client.js';
 import { writePid, removePid, isRunning } from './daemon.js';
+import { startMcpRegistration } from './commands/mcp-proxy.js';
+import { startMcpProxy } from './commands/mcp.js';
 
 const program = new Command();
 
@@ -56,4 +58,30 @@ program
     });
   });
 
+program
+  .command('mcp-proxy')
+  .description('Register a local MCP command as a proxy')
+  .requiredOption('--mcp-server <endpoint>', 'Server endpoint URL')
+  .requiredOption('--mcp-key <key>', 'MCP Proxy Key')
+  .requiredOption('--command <command>', 'Local MCP command to proxy')
+  .action(async (options) => {
+    await startMcpRegistration({
+      server: options.mcpServer,
+      key: options.mcpKey,
+      command: options.command,
+    });
+  });
+
+program
+  .command('mcp')
+  .description('Start stdio MCP proxy (HTTP to stdio)')
+  .requiredOption('--endpoint <url>', 'MCP forwarder endpoint URL')
+  .requiredOption('--token <token>', 'Bearer token for authentication')
+  .action(async (options) => {
+    await startMcpProxy({
+      endpoint: options.endpoint,
+      token: options.token,
+    });
+  });
+
 program.parse();