huaweicloud-devkit 1.0.2-next.2 → 1.0.2-next.3

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

@@ -1,155 +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;
-}
+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;
+}