huaweicloud-devkit 1.0.3-dev.0 → 1.1.0-next.0

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

@@ -1,5 +1,7 @@
 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;
@@ -8,7 +10,7 @@ const DEFAULT_MAX_RETRIES = 1;
 export function planHcloudCommand(args, options = {}) {
   const normalizedArgs = Array.isArray(args) ? args.map(String) : [];
   const classification = classifyHcloudArgs(normalizedArgs, options);
-  const command = ['hcloud', ...normalizedArgs].map(quoteShellArg).join(' ');
+  const command = ['hcloud', ...normalizedArgs].map((arg) => quoteShellArg(arg)).join(' ');
   const warnings = planningWarnings(normalizedArgs);
   const paramValidation = validateRequiredParams(normalizedArgs);
   if (paramValidation.missing.length > 0) {
@@ -46,7 +48,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 +61,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 +161,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 +178,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 +209,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 +227,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,176 @@
+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((t) => normalizeToken(t));
+
+  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,24 @@
 #!/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 +27,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 +118,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

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

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>');
 }