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

package/plugins/huaweicloud-core/src/hcloud-cli.mjs

@@ -1,5 +1,6 @@
 import { spawn } from 'node:child_process';
 import { classifyHcloudArgs, redactSecrets, assertAllowed } from './safety-policy.mjs';
+import { getProxySettings } from './proxy/proxy-config.mjs';
 
 const DEFAULT_TIMEOUT_MS = 60_000;
 const DEFAULT_FORCE_KILL_AFTER_MS = 2_000;
@@ -46,7 +47,7 @@ export async function runHcloud(args, options = {}) {
         attempts: attempt + 1,
       };
     }
-    await wait((options.retryBaseDelayMs ?? 500) * (2 ** attempt));
+    await wait((options.retryBaseDelayMs ?? 500) * 2 ** attempt);
   }
   throw new Error('Unreachable retry state.');
 }
@@ -59,12 +60,20 @@ function runHcloudOnce(plan, options) {
   const cwd = options.cwd || undefined;
 
   return new Promise((resolve) => {
+    const proxySettings = getProxySettings();
+    const proxyEnv = {};
+    if (proxySettings) {
+      if (proxySettings.https_proxy) proxyEnv.HTTPS_PROXY = proxySettings.https_proxy;
+      if (proxySettings.http_proxy) proxyEnv.HTTP_PROXY = proxySettings.http_proxy;
+      if (proxySettings.no_proxy) proxyEnv.NO_PROXY = proxySettings.no_proxy;
+    }
     const child = spawn(executable, [...executableArgs, ...plan.rawArgs], {
       shell: false,
       windowsHide: true,
       cwd,
       env: {
         ...process.env,
+        ...proxyEnv,
         ...options.env,
       },
     });
@@ -151,7 +160,10 @@ function runHcloudOnce(plan, options) {
         return;
       }
       finish({
-        ok: code === 0 || (code !== 0 && /successfully|succ?ess.*\[200\]|create bucket successfully|upload successfully/i.test(stdout + stderr)),
+        ok:
+          code === 0 ||
+          (code !== 0 &&
+            /successfully|succ?ess.*\[200\]|create bucket successfully|upload successfully/i.test(stdout + stderr)),
         exitCode: code,
         signal,
         stdout: redactOutput(stdout),
@@ -165,7 +177,9 @@ function runHcloudOnce(plan, options) {
 function isRetryableNetworkError(result) {
   if (result.code === 'TIMEOUT') return false;
   const text = `${result.error || ''}\n${result.stdout || ''}\n${result.stderr || ''}`;
-  return /\[NETWORK_ERROR\]|connection timed out|ECONNRESET|ETIMEDOUT|temporary failure|TLS handshake timeout/i.test(text);
+  return /\[NETWORK_ERROR\]|connection timed out|ECONNRESET|ETIMEDOUT|temporary failure|TLS handshake timeout/i.test(
+    text,
+  );
 }
 
 function wait(ms) {
@@ -194,7 +208,11 @@ const REQUIRED_PARAMS = {
   'ECS CreateServers': ['server.flavorRef', 'server.imageRef', 'server.nics.1.subnet_id'],
   'VPC CreateVpc': ['vpc.cidr'],
   'VPC CreateSubnet': ['subnet.vpc_id', 'subnet.cidr'],
-  'VPC CreateSecurityGroupRule': ['security_group_rule.security_group_id', 'security_group_rule.direction', 'security_group_rule.protocol'],
+  'VPC CreateSecurityGroupRule': [
+    'security_group_rule.security_group_id',
+    'security_group_rule.direction',
+    'security_group_rule.protocol',
+  ],
   'EIP CreatePublicip': ['bandwidth.share_type', 'publicip.type'],
   'FunctionGraph CreateFunction': ['func_name', 'runtime', 'handler', 'memory_size', 'package', 'timeout'],
   'FunctionGraph CreateFunctionTrigger': ['function_urn', 'trigger_type_code'],
@@ -208,9 +226,9 @@ const PARAM_VALUE_HINTS = {
   'server.imageRef': 'Run `hcloud IMS ListImages --cli-region=<r> --__imagetype=gold` to find valid image IDs',
   'server.nics.1.subnet_id': 'Run `hcloud VPC ListSubnets --cli-region=<r>` to find subnet IDs',
   'subnet.vpc_id': 'Run `hcloud VPC ListVpcs --cli-region=<r>` to find VPC IDs',
-  'func_name': 'Function name must be unique within project',
-  'runtime': 'Run `hcloud FunctionGraph ListRuntimes` to see available runtimes',
-  'spec_id': 'APIG spec: BASIC (no public IP) or PROFESSIONAL (requires --loadbalancer_provider)',
+  func_name: 'Function name must be unique within project',
+  runtime: 'Run `hcloud FunctionGraph ListRuntimes` to see available runtimes',
+  spec_id: 'APIG spec: BASIC (no public IP) or PROFESSIONAL (requires --loadbalancer_provider)',
   'obs://': 'Bucket name must be globally unique and DNS-compliant (lowercase, numbers, hyphens only)',
 };
 

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,10 +1,23 @@
 #!/usr/bin/env node
 import { stdin, stdout } from 'node:process';
-import { rmSync, existsSync } from 'node:fs';
-import { resolve, dirname } from 'node:path';
+import { rmSync, existsSync, readFileSync } from 'node:fs';
+import { resolve, dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { TOOL_DEFINITIONS, callTool } from './tools.mjs';
 
+try {
+  const { readProxyConfig } = await import('./proxy/proxy-config.mjs');
+  const proxyConfig = readProxyConfig();
+  if (proxyConfig) {
+    if (proxyConfig.https_proxy || proxyConfig.HTTPS_PROXY) {
+      process.env.HTTPS_PROXY = process.env.HTTPS_PROXY || proxyConfig.https_proxy || proxyConfig.HTTPS_PROXY;
+    }
+    if (proxyConfig.http_proxy || proxyConfig.HTTP_PROXY) {
+      process.env.HTTP_PROXY = process.env.HTTP_PROXY || proxyConfig.http_proxy || proxyConfig.HTTP_PROXY;
+    }
+  }
+} catch {}
+
 // 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 {
@@ -13,6 +26,20 @@ try {
   if (existsSync(marker)) rmSync(marker, { force: true });
 } catch {}
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pluginRoot = resolve(__dirname, '..');
+const packageRoot = resolve(pluginRoot, '..', '..');
+let pkgVersion = '0.0.0';
+for (const base of [pluginRoot, packageRoot]) {
+  try {
+    const version = JSON.parse(readFileSync(join(base, 'package.json'), 'utf8')).version;
+    if (version) {
+      pkgVersion = version;
+      break;
+    }
+  } catch {}
+}
+
 let buffer = Buffer.alloc(0);
 let useContentLengthFraming = true;
 
@@ -90,7 +117,7 @@ async function dispatch(method, params) {
       },
       serverInfo: {
         name: 'huaweicloud-devkit',
-        version: '0.1.0',
+        version: pkgVersion,
       },
     };
   }

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

@@ -3,6 +3,15 @@ import { getProxyUrlForTarget } from './proxy-config.mjs';
 let cachedDispatcher = undefined;
 let cachedDispatcherProxyUrl = null;
 
+async function importUndici() {
+  try {
+    /* eslint-disable-next-line n/no-missing-import */
+    return await import('node:undici');
+  } catch {
+    return await import('undici');
+  }
+}
+
 export async function getProxyDispatcher(targetUrl) {
   const proxyUrl = getProxyUrlForTarget(targetUrl);
   if (!proxyUrl) return undefined;
@@ -11,7 +20,7 @@ export async function getProxyDispatcher(targetUrl) {
     return cachedDispatcher;
   }
 
-  const { ProxyAgent } = await import('undici');
+  const { ProxyAgent } = await importUndici();
   cachedDispatcher = new ProxyAgent(proxyUrl);
   cachedDispatcherProxyUrl = proxyUrl;
   return cachedDispatcher;
@@ -29,7 +38,7 @@ export async function createProxyWebSocket(url, protocols) {
   }
 
   const dispatcher = await getProxyDispatcher(url);
-  const { WebSocket: UndiciWebSocket } = await import('undici');
+  const { WebSocket: UndiciWebSocket } = await importUndici();
 
   const wsOptions = { dispatcher };
   if (protocols) {
@@ -43,113 +52,22 @@ export async function createProxyWebSocket(url, protocols) {
   return new UndiciWebSocket(url, wsOptions);
 }
 
-export function getWebSocketImpl(targetUrl) {
+export async 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 dispatcher = await getProxyDispatcher(targetUrl);
+  const { WebSocket: UndiciWebSocket } = await importUndici();
 
-      const wsOptions = { dispatcher };
+  class ProxyWebSocket extends UndiciWebSocket {
+    constructor(url, protocols) {
+      const options = { 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);
+        options.protocols = Array.isArray(protocols) ? protocols : [protocols];
       }
+      super(url, options);
     }
-    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;
+  return ProxyWebSocket;
 }

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

@@ -47,6 +47,10 @@ function shouldBypassProxy(hostname, noProxyList) {
     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;
   }
@@ -60,13 +64,16 @@ export function getProxySettings(targetUrl) {
 
   const fileConfig = readProxyConfig();
 
-  const https_proxy = envHttps || (fileConfig?.https_proxy || '');
-  const http_proxy = envHttp || (fileConfig?.http_proxy || '');
-  const no_proxy = envNoProxy || (fileConfig?.no_proxy || '');
+  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);
+  const noProxyList = no_proxy
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean);
 
   if (targetUrl) {
     const parsed = new URL(targetUrl);

package/plugins/huaweicloud-core/src/risk-rule-engine.mjs

@@ -18,7 +18,10 @@ export function loadRiskRules(options = {}) {
 
 function redactEvidence(text) {
   return String(text)
-    .replace(/((?:access[_-]?key|secret[_-]?key|security[_-]?token|x[_-]?auth[_-]?token|authorization|password|passwd|adminPass|credential)\s*[:=]\s*)("[^"]*"|'[^']*'|[^\s,;]+)/gi, '$1<redacted>')
+    .replace(
+      /((?:access[_-]?key|secret[_-]?key|security[_-]?token|x[_-]?auth[_-]?token|authorization|password|passwd|adminPass|credential)\s*[:=]\s*)("[^"]*"|'[^']*'|[^\s,;]+)/gi,
+      '$1<redacted>',
+    )
     .replace(/(AK|SK)\s*[:=]\s*("[^"]*"|'[^']*'|[^\s,;]+)/g, '$1=<redacted>');
 }