huaweicloud-devkit 1.0.2-dev.9 → 1.0.2-next.10

package/plugins/huaweicloud-core/src/icon-library.mjs

@@ -0,0 +1,171 @@
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getProxyDispatcher } from './proxy/proxy-agent.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SNAPSHOT_PATH = join(__dirname, 'data', 'icons-manifest.v1.json');
+const MANIFEST_URL = 'https://open.huaweicloud.com/openplatform/icons/manifest.v1.json';
+const ICONS_PAGE_URL = 'https://open.huaweicloud.com/openplatform/icons.html';
+const HTTP_TIMEOUT_MS = 10000;
+const MAX_RESULTS = 5;
+
+let cachedManifest = null;
+
+export function clearIconCache() {
+  cachedManifest = null;
+}
+
+async function fetchLiveManifest() {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), HTTP_TIMEOUT_MS);
+  try {
+    const dispatcher = await getProxyDispatcher(MANIFEST_URL);
+    const fetchOpts = {
+      headers: { 'User-Agent': 'huaweicloud-devkit/1.0' },
+      signal: controller.signal,
+    };
+    if (dispatcher) fetchOpts.dispatcher = dispatcher;
+    const resp = await fetch(MANIFEST_URL, fetchOpts);
+    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+    const data = await resp.json();
+    if (!data || !Array.isArray(data.icons)) {
+      throw new Error('Manifest is missing the icons array.');
+    }
+    return data;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function loadSnapshot() {
+  const manifest = JSON.parse(readFileSync(SNAPSHOT_PATH, 'utf8'));
+  if (!manifest || !Array.isArray(manifest.icons)) {
+    throw new Error('Bundled icons manifest is corrupted.');
+  }
+  return manifest;
+}
+
+async function loadManifest() {
+  if (cachedManifest) return cachedManifest;
+  if (process.env.HUAWEICLOUD_ICONS_OFFLINE === '1') {
+    cachedManifest = { manifest: loadSnapshot(), source: 'snapshot' };
+    return cachedManifest;
+  }
+  try {
+    const live = await fetchLiveManifest();
+    cachedManifest = { manifest: live, source: 'live' };
+  } catch {
+    cachedManifest = { manifest: loadSnapshot(), source: 'snapshot' };
+  }
+  return cachedManifest;
+}
+
+function normalizeToken(token) {
+  return token.toLowerCase();
+}
+
+function scoreIcon(icon, tokens, index) {
+  let total = 0;
+  const matched = [];
+  for (const token of tokens) {
+    let best = 0;
+    const id = (icon.id || '').toLowerCase();
+    const name = (icon.name || '').toLowerCase();
+    if (id === token || (index.aliases[token] || []).includes(id)) {
+      best = 10;
+    } else if (name === token) {
+      best = 9;
+    } else if (name.startsWith(token)) {
+      best = 8;
+    } else if (name.includes(token)) {
+      best = 7;
+    } else if (id.includes(token)) {
+      best = 5;
+    } else if ((index.aliases[id] || []).some((a) => a.includes(token))) {
+      best = 6;
+    } else if ((index.tags[id] || []).some((t) => t.includes(token))) {
+      best = 4;
+    } else if ((index.categories[id] || '').includes(token)) {
+      best = 3;
+    } else if ((index.descriptions[id] || '').includes(token)) {
+      best = 2;
+    }
+    if (best > 0) {
+      total += best;
+      matched.push(token);
+    }
+  }
+  return [total, matched];
+}
+
+export async function getServiceIcon(service = '', category = '') {
+  const query = String(service || '').trim();
+  const catFilter = String(category || '')
+    .trim()
+    .toLowerCase();
+  if (!query && !catFilter) {
+    return {
+      ok: false,
+      error:
+        'service or category is required. Examples: ecs, obs, modelarts, 对象存储, 虚拟私有云, or a category such as 计算 / 存储 / 人工智能.',
+      iconsPageUrl: ICONS_PAGE_URL,
+    };
+  }
+  const { manifest, source } = await loadManifest();
+  const tokens = query.replace(/[,;]/g, ' ').split(/\s+/).filter(Boolean).map(normalizeToken);
+
+  const index = { aliases: {}, tags: {}, categories: {}, descriptions: {} };
+  for (const icon of manifest.icons) {
+    const id = (icon.id || '').toLowerCase();
+    index.aliases[id] = (icon.aliases || []).map((a) => String(a).toLowerCase());
+    index.tags[id] = (icon.tags || []).map((t) => String(t).toLowerCase());
+    index.categories[id] = [
+      String(icon.category || '').toLowerCase(),
+      String(icon.subcategory || '').toLowerCase(),
+    ].join(' ');
+    index.descriptions[id] = String(icon.description || '').toLowerCase();
+  }
+
+  const results = [];
+  for (const icon of manifest.icons) {
+    const categoryMatches = !catFilter || String(icon.category || '').toLowerCase() === catFilter;
+    if (!categoryMatches) continue;
+    const [score, matched] = tokens.length ? scoreIcon(icon, tokens, index) : [0, []];
+    if (tokens.length && score === 0) continue;
+    results.push({
+      id: icon.id,
+      name: icon.name,
+      category: icon.category,
+      subcategory: icon.subcategory || undefined,
+      description: icon.description || undefined,
+      aliases: icon.aliases,
+      product_url: icon.product_url,
+      logo: {
+        source_url: icon.logo?.source_url,
+        local_path: icon.logo?.local_path,
+      },
+      architecture: icon.architecture
+        ? { status: icon.architecture.status, local_path: icon.architecture.local_path }
+        : undefined,
+      score,
+      matched,
+    });
+  }
+  results.sort((a, b) => b.score - a.score);
+
+  return {
+    ok: true,
+    query,
+    category: catFilter || undefined,
+    source,
+    manifestGeneratedAt: manifest.generated_at,
+    count: results.length,
+    iconsPageUrl: ICONS_PAGE_URL,
+    note:
+      source === 'live'
+        ? 'Live manifest from open.huaweicloud.com.'
+        : 'Live manifest unreachable; using bundled snapshot. Upgrade the package to refresh the bundled snapshot.',
+    results: results.slice(0, MAX_RESULTS),
+  };
+}

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

@@ -1,129 +1,130 @@
-#!/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
+process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+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,68 @@
+import { getProxyUrlForTarget } from './proxy-config.mjs';
+
+let cachedDispatcher = undefined;
+let cachedDispatcherProxyUrl = null;
+
+async function importUndici() {
+  return await import('undici');
+}
+
+export async function getProxyDispatcher(targetUrl) {
+  const proxyUrl = getProxyUrlForTarget(targetUrl);
+  if (!proxyUrl) return undefined;
+
+  if (cachedDispatcher && cachedDispatcherProxyUrl === proxyUrl) {
+    return cachedDispatcher;
+  }
+
+  const { ProxyAgent } = await importUndici();
+  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 importUndici();
+
+  const wsOptions = { dispatcher };
+  if (protocols) {
+    if (Array.isArray(protocols)) {
+      wsOptions.protocols = protocols;
+    } else {
+      wsOptions.protocols = [protocols];
+    }
+  }
+
+  return new UndiciWebSocket(url, wsOptions);
+}
+
+export async function getWebSocketImpl(targetUrl) {
+  const proxyUrl = getProxyUrlForTarget(targetUrl);
+  if (!proxyUrl) return globalThis.WebSocket;
+
+  const dispatcher = await getProxyDispatcher(targetUrl);
+  const { WebSocket: UndiciWebSocket } = await importUndici();
+
+  class ProxyWebSocket extends UndiciWebSocket {
+    constructor(url, protocols) {
+      const options = { dispatcher };
+      if (protocols) {
+        options.protocols = Array.isArray(protocols) ? protocols : [protocols];
+      }
+      super(url, options);
+    }
+  }
+
+  return ProxyWebSocket;
+}

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

@@ -0,0 +1,94 @@
+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('*.')) {
+      const domain = p.slice(1);
+      if (lower.endsWith(domain) || lower === p.slice(2)) 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 || fileConfig?.HTTPS_PROXY || '';
+  const http_proxy = envHttp || fileConfig?.http_proxy || fileConfig?.HTTP_PROXY || '';
+  const no_proxy = envNoProxy || fileConfig?.no_proxy || 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;
+}