huaweicloud-devkit 1.0.2-dev.8 → 1.0.2-next.0

package/plugins/huaweicloud-core/src/mcp-server.mjs

@@ -1,129 +1,129 @@
-#!/usr/bin/env node
-import { stdin, stdout } from 'node:process';
-import { rmSync, existsSync } from 'node:fs';
-import { resolve, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { TOOL_DEFINITIONS, callTool } from './tools.mjs';
-
-// The MCP server is now loaded by a live agent session. Clear the install marker
-// in this plugin dir so `doctor` no longer reports "restart needed".
-try {
-  const pluginDir = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-  const marker = resolve(pluginDir, '.installed');
-  if (existsSync(marker)) rmSync(marker, { force: true });
-} catch {}
-
-let buffer = Buffer.alloc(0);
-let useContentLengthFraming = true;
-
-stdin.on('data', (chunk) => {
-  buffer = Buffer.concat([buffer, chunk]);
-  readFrames();
-});
-
-function readFrames() {
-  while (true) {
-    const headerEnd = buffer.indexOf('\r\n\r\n');
-    if (headerEnd !== -1) {
-      useContentLengthFraming = true;
-      const consumed = parseContentLengthFrame(headerEnd);
-      if (!consumed) return;
-      continue;
-    }
-
-    const lf = buffer.indexOf('\n');
-    if (lf !== -1) {
-      useContentLengthFraming = false;
-      const line = buffer.subarray(0, lf).toString('utf8').trim();
-      buffer = buffer.subarray(lf + 1);
-      if (line) void handleMessage(JSON.parse(line));
-      continue;
-    }
-
-    return;
-  }
-}
-
-function parseContentLengthFrame(headerEnd) {
-  const header = buffer.subarray(0, headerEnd).toString('utf8');
-  const match = header.match(/Content-Length:\s*(\d+)/i);
-  if (!match) {
-    buffer = Buffer.alloc(0);
-    return true;
-  }
-  const length = Number(match[1]);
-  const bodyStart = headerEnd + 4;
-  const bodyEnd = bodyStart + length;
-  if (buffer.length < bodyEnd) return false;
-  const body = buffer.subarray(bodyStart, bodyEnd).toString('utf8');
-  buffer = buffer.subarray(bodyEnd);
-  void handleMessage(JSON.parse(body));
-  return true;
-}
-
-async function handleMessage(message) {
-  if (!Object.hasOwn(message, 'id')) {
-    if (message.method === 'notifications/initialized') return;
-    return;
-  }
-  try {
-    const result = await dispatch(message.method, message.params || {});
-    writeMessage({ jsonrpc: '2.0', id: message.id, result });
-  } catch (error) {
-    writeMessage({
-      jsonrpc: '2.0',
-      id: message.id,
-      error: {
-        code: -32603,
-        message: error.message,
-      },
-    });
-  }
-}
-
-async function dispatch(method, params) {
-  if (method === 'initialize') {
-    return {
-      protocolVersion: params.protocolVersion || '2024-11-05',
-      capabilities: {
-        tools: {},
-      },
-      serverInfo: {
-        name: 'huaweicloud-devkit',
-        version: '0.1.0',
-      },
-    };
-  }
-
-  if (method === 'tools/list') {
-    return { tools: TOOL_DEFINITIONS };
-  }
-
-  if (method === 'tools/call') {
-    const result = await callTool(params.name, params.arguments || {});
-    return {
-      content: [
-        {
-          type: 'text',
-          text: JSON.stringify(result, null, 2),
-        },
-      ],
-      isError: false,
-    };
-  }
-
-  if (method === 'resources/list') {
-    return { resources: [] };
-  }
-
-  throw new Error(`Unsupported method: ${method}`);
-}
-
-function writeMessage(message) {
-  const json = JSON.stringify(message);
-  if (useContentLengthFraming) {
-    stdout.write(`Content-Length: ${Buffer.byteLength(json, 'utf8')}\r\n\r\n${json}`);
-  } else {
-    stdout.write(json + '\n');
-  }
-}
+#!/usr/bin/env node
+import { stdin, stdout } from 'node:process';
+import { rmSync, existsSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { TOOL_DEFINITIONS, callTool } from './tools.mjs';
+
+// The MCP server is now loaded by a live agent session. Clear the install marker
+// in this plugin dir so `doctor` no longer reports "restart needed".
+try {
+  const pluginDir = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+  const marker = resolve(pluginDir, '.installed');
+  if (existsSync(marker)) rmSync(marker, { force: true });
+} catch {}
+
+let buffer = Buffer.alloc(0);
+let useContentLengthFraming = true;
+
+stdin.on('data', (chunk) => {
+  buffer = Buffer.concat([buffer, chunk]);
+  readFrames();
+});
+
+function readFrames() {
+  while (true) {
+    const headerEnd = buffer.indexOf('\r\n\r\n');
+    if (headerEnd !== -1) {
+      useContentLengthFraming = true;
+      const consumed = parseContentLengthFrame(headerEnd);
+      if (!consumed) return;
+      continue;
+    }
+
+    const lf = buffer.indexOf('\n');
+    if (lf !== -1) {
+      useContentLengthFraming = false;
+      const line = buffer.subarray(0, lf).toString('utf8').trim();
+      buffer = buffer.subarray(lf + 1);
+      if (line) void handleMessage(JSON.parse(line));
+      continue;
+    }
+
+    return;
+  }
+}
+
+function parseContentLengthFrame(headerEnd) {
+  const header = buffer.subarray(0, headerEnd).toString('utf8');
+  const match = header.match(/Content-Length:\s*(\d+)/i);
+  if (!match) {
+    buffer = Buffer.alloc(0);
+    return true;
+  }
+  const length = Number(match[1]);
+  const bodyStart = headerEnd + 4;
+  const bodyEnd = bodyStart + length;
+  if (buffer.length < bodyEnd) return false;
+  const body = buffer.subarray(bodyStart, bodyEnd).toString('utf8');
+  buffer = buffer.subarray(bodyEnd);
+  void handleMessage(JSON.parse(body));
+  return true;
+}
+
+async function handleMessage(message) {
+  if (!Object.hasOwn(message, 'id')) {
+    if (message.method === 'notifications/initialized') return;
+    return;
+  }
+  try {
+    const result = await dispatch(message.method, message.params || {});
+    writeMessage({ jsonrpc: '2.0', id: message.id, result });
+  } catch (error) {
+    writeMessage({
+      jsonrpc: '2.0',
+      id: message.id,
+      error: {
+        code: -32603,
+        message: error.message,
+      },
+    });
+  }
+}
+
+async function dispatch(method, params) {
+  if (method === 'initialize') {
+    return {
+      protocolVersion: params.protocolVersion || '2024-11-05',
+      capabilities: {
+        tools: {},
+      },
+      serverInfo: {
+        name: 'huaweicloud-devkit',
+        version: '0.1.0',
+      },
+    };
+  }
+
+  if (method === 'tools/list') {
+    return { tools: TOOL_DEFINITIONS };
+  }
+
+  if (method === 'tools/call') {
+    const result = await callTool(params.name, params.arguments || {});
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+      isError: false,
+    };
+  }
+
+  if (method === 'resources/list') {
+    return { resources: [] };
+  }
+
+  throw new Error(`Unsupported method: ${method}`);
+}
+
+function writeMessage(message) {
+  const json = JSON.stringify(message);
+  if (useContentLengthFraming) {
+    stdout.write(`Content-Length: ${Buffer.byteLength(json, 'utf8')}\r\n\r\n${json}`);
+  } else {
+    stdout.write(json + '\n');
+  }
+}

package/plugins/huaweicloud-core/src/proxy/proxy-agent.mjs

@@ -0,0 +1,155 @@
+import { getProxyUrlForTarget } from './proxy-config.mjs';
+
+let cachedDispatcher = undefined;
+let cachedDispatcherProxyUrl = null;
+
+export async function getProxyDispatcher(targetUrl) {
+  const proxyUrl = getProxyUrlForTarget(targetUrl);
+  if (!proxyUrl) return undefined;
+
+  if (cachedDispatcher && cachedDispatcherProxyUrl === proxyUrl) {
+    return cachedDispatcher;
+  }
+
+  const { ProxyAgent } = await import('undici');
+  cachedDispatcher = new ProxyAgent(proxyUrl);
+  cachedDispatcherProxyUrl = proxyUrl;
+  return cachedDispatcher;
+}
+
+export function clearProxyDispatcherCache() {
+  cachedDispatcher = undefined;
+  cachedDispatcherProxyUrl = null;
+}
+
+export async function createProxyWebSocket(url, protocols) {
+  const proxyUrl = getProxyUrlForTarget(url);
+  if (!proxyUrl) {
+    return new globalThis.WebSocket(url, protocols);
+  }
+
+  const dispatcher = await getProxyDispatcher(url);
+  const { WebSocket: UndiciWebSocket } = await import('undici');
+
+  const wsOptions = { dispatcher };
+  if (protocols) {
+    if (Array.isArray(protocols)) {
+      wsOptions.protocols = protocols;
+    } else {
+      wsOptions.protocols = [protocols];
+    }
+  }
+
+  return new UndiciWebSocket(url, wsOptions);
+}
+
+export function getWebSocketImpl(targetUrl) {
+  const proxyUrl = getProxyUrlForTarget(targetUrl);
+  if (!proxyUrl) return globalThis.WebSocket;
+
+  return (url, protocols) => {
+    const proxyUrlForTarget = getProxyUrlForTarget(url);
+    if (!proxyUrlForTarget) {
+      return new globalThis.WebSocket(url, protocols);
+    }
+
+    const wsPromise = (async () => {
+      const dispatcher = await getProxyDispatcher(url);
+      const { WebSocket: UndiciWebSocket } = await import('undici');
+
+      const wsOptions = { dispatcher };
+      if (protocols) {
+        if (Array.isArray(protocols)) {
+          wsOptions.protocols = protocols;
+        } else {
+          wsOptions.protocols = [protocols];
+        }
+      }
+
+      return new UndiciWebSocket(url, wsOptions);
+    })();
+
+    return createSyncProxyWebSocketWrapper(wsPromise);
+  };
+}
+
+function createSyncProxyWebSocketWrapper(wsPromise) {
+  const pendingEvents = [];
+  const eventHandlers = new Map();
+  let ws = null;
+  let settled = false;
+  let readyState = 0;
+  let binaryType = 'arraybuffer';
+
+  const wrapper = {
+    get readyState() { return ws ? ws.readyState : readyState; },
+    get url() { return ws ? ws.url : ''; },
+    get protocol() { return ws ? ws.protocol : ''; },
+    get binaryType() { return ws ? ws.binaryType : binaryType; },
+    set binaryType(v) {
+      binaryType = v;
+      if (ws) ws.binaryType = v;
+    },
+
+    send(data, callback) {
+      if (ws) {
+        if (ws.send.length >= 2) return ws.send(data, callback);
+        try { ws.send(data); if (callback) callback(null); } catch (e) { if (callback) callback(e); }
+        return;
+      }
+      pendingEvents.push({ type: 'send', data, callback });
+    },
+
+    close(code, reason) {
+      if (ws) { ws.close(code, reason); return; }
+      readyState = 3;
+      pendingEvents.push({ type: 'close', code, reason });
+    },
+
+    addEventListener(type, handler) {
+      if (!eventHandlers.has(type)) eventHandlers.set(type, new Set());
+      eventHandlers.get(type).add(handler);
+      if (ws) ws.addEventListener(type, handler);
+    },
+
+    removeEventListener(type, handler) {
+      const handlers = eventHandlers.get(type);
+      if (handlers) handlers.delete(handler);
+      if (ws) ws.removeEventListener(type, handler);
+    },
+
+    on(type, handler) { wrapper.addEventListener(type, handler); },
+    off(type, handler) { wrapper.removeEventListener(type, handler); },
+  };
+
+  function flushPendingEvents() {
+    for (const evt of pendingEvents) {
+      if (evt.type === 'send') {
+        if (ws.send.length >= 2) ws.send(evt.data, evt.callback);
+        else { try { ws.send(evt.data); if (evt.callback) evt.callback(null); } catch (e) { if (evt.callback) evt.callback(e); } }
+      } else if (evt.type === 'close') {
+        ws.close(evt.code, evt.reason);
+      }
+    }
+    pendingEvents.length = 0;
+  }
+
+  wsPromise.then((resolvedWs) => {
+    ws = resolvedWs;
+    if ('binaryType' in ws) ws.binaryType = binaryType;
+    for (const [type, handlers] of eventHandlers) {
+      for (const handler of handlers) {
+        ws.addEventListener(type, handler);
+      }
+    }
+    flushPendingEvents();
+  }).catch((err) => {
+    readyState = 3;
+    const handlers = eventHandlers.get('error');
+    if (handlers) for (const h of handlers) h(err instanceof Error ? err : new Error(String(err)));
+    const closeHandlers = eventHandlers.get('close');
+    if (closeHandlers) for (const h of closeHandlers) h({ code: 1006, reason: err.message || String(err) });
+  });
+
+  return wrapper;
+}

package/plugins/huaweicloud-core/src/proxy/proxy-config.mjs

@@ -0,0 +1,87 @@
+import { existsSync, readFileSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+
+function baseHome() {
+  return process.env.HUAWEICLOUD_HOME || homedir();
+}
+
+export function proxyConfigPath() {
+  return join(baseHome(), '.config', 'huaweicloud', 'proxy.json');
+}
+
+export function readProxyConfig() {
+  const path = proxyConfigPath();
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function writeProxyConfig(config = {}) {
+  const path = proxyConfigPath();
+  mkdirSync(dirname(path), { recursive: true });
+  const payload = {
+    https_proxy: String(config.https_proxy || ''),
+    http_proxy: String(config.http_proxy || ''),
+    no_proxy: String(config.no_proxy || ''),
+  };
+  writeFileSync(path, JSON.stringify(payload, null, 2), { encoding: 'utf8' });
+  return path;
+}
+
+export function clearProxyConfig() {
+  const path = proxyConfigPath();
+  if (!existsSync(path)) return false;
+  rmSync(path);
+  return true;
+}
+
+function shouldBypassProxy(hostname, noProxyList) {
+  if (!noProxyList.length) return false;
+  const lower = hostname.toLowerCase();
+  for (const pattern of noProxyList) {
+    const p = pattern.trim().toLowerCase();
+    if (!p) continue;
+    if (p === lower) return true;
+    if (p === '*') return true;
+    if (p.startsWith('.') && lower.endsWith(p)) return true;
+    if (lower.endsWith('.' + p)) return true;
+  }
+  return false;
+}
+
+export function getProxySettings(targetUrl) {
+  const envHttps = process.env.HTTPS_PROXY || process.env.https_proxy || '';
+  const envHttp = process.env.HTTP_PROXY || process.env.http_proxy || '';
+  const envNoProxy = process.env.NO_PROXY || process.env.no_proxy || '';
+
+  const fileConfig = readProxyConfig();
+
+  const https_proxy = envHttps || (fileConfig?.https_proxy || '');
+  const http_proxy = envHttp || (fileConfig?.http_proxy || '');
+  const no_proxy = envNoProxy || (fileConfig?.no_proxy || '');
+
+  if (!https_proxy && !http_proxy) return null;
+
+  const noProxyList = no_proxy.split(',').map((s) => s.trim()).filter(Boolean);
+
+  if (targetUrl) {
+    const parsed = new URL(targetUrl);
+    if (shouldBypassProxy(parsed.hostname, noProxyList)) return null;
+    const isHttps = parsed.protocol === 'https:';
+    const proxyUrl = isHttps ? https_proxy : http_proxy;
+    if (!proxyUrl) return null;
+    return { proxyUrl, noProxyList, targetProtocol: parsed.protocol };
+  }
+
+  return { https_proxy, http_proxy, no_proxy, noProxyList };
+}
+
+export function getProxyUrlForTarget(targetUrl) {
+  const settings = getProxySettings(targetUrl);
+  if (!settings) return null;
+  return settings.proxyUrl || null;
+}