huaweicloud-devkit 1.1.2-next.0 → 1.1.2-next.2

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-protocol.mjs

@@ -0,0 +1,88 @@
+import { readFileSync } from 'node:fs';
+import { resolve, dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { TOOL_DEFINITIONS, callTool } from './tools.mjs';
+import { peekCachedUpdateInfo, applyUpdateHint } from './update-check.mjs';
+import { initTelemetry } from './telemetry/telemetry.mjs';
+import { detectAgent } from './telemetry/agent-detect.mjs';
+
+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 {}
+}
+
+// 会话内首个非 check/upgrade 工具调用附加 _updateInfo，只消费一次。
+let hintConsumed = false;
+function decorateResult(name, result) {
+  if (hintConsumed) return result;
+  try {
+    const hint = peekCachedUpdateInfo();
+    if (!hint) return result;
+    const decorated = applyUpdateHint(result, name, hint);
+    if (decorated !== result) hintConsumed = true;
+    return decorated;
+  } catch {
+    return result; // 兜底装饰失败绝不影响工具调用
+  }
+}
+
+export async function dispatch(method, params) {
+  if (method === 'initialize') {
+    const ci = params.clientInfo || {};
+
+    try {
+      const { hdkitGenerateUserHash } = await import('./sandbox/hdkitservice-api.mjs');
+      await Promise.race([
+        hdkitGenerateUserHash(),
+        new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 3000)),
+      ]);
+    } catch {}
+
+    const agent = detectAgent(ci);
+    initTelemetry({ harness: agent.harness, version: agent.version });
+    return {
+      protocolVersion: params.protocolVersion || '2024-11-05',
+      capabilities: {
+        tools: {},
+      },
+      serverInfo: {
+        name: 'huaweicloud-devkit',
+        version: pkgVersion,
+      },
+    };
+  }
+
+  if (method === 'tools/list') {
+    return { tools: TOOL_DEFINITIONS };
+  }
+
+  if (method === 'tools/call') {
+    const result = await callTool(params.name, params.arguments || {});
+    const decorated = decorateResult(params.name, result);
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(decorated, null, 2),
+        },
+      ],
+      isError: false,
+    };
+  }
+
+  if (method === 'resources/list') {
+    return { resources: [] };
+  }
+
+  throw new Error(`Unsupported method: ${method}`);
+}

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

@@ -0,0 +1,107 @@
+import { createServer } from 'node:http';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { format } from 'node:util';
+
+import { dispatch } from './mcp-protocol.mjs';
+
+export const DEFAULT_PORT = 9528;
+export const DEFAULT_HOST = '127.0.0.1';
+
+export async function startRemoteServer({ port = DEFAULT_PORT, host = DEFAULT_HOST } = {}) {
+  const server = createServer(async (req, res) => {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+    res.setHeader(
+      'Access-Control-Allow-Headers',
+      'Content-Type, MCP-Protocol-Version, Mcp-Session-Id, Accept, Authorization',
+    );
+    res.setHeader('Access-Control-Expose-Headers', 'MCP-Protocol-Version, Mcp-Session-Id');
+
+    if (req.method === 'OPTIONS') {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    if (req.method !== 'POST') {
+      res.writeHead(405, { Allow: 'POST, OPTIONS' });
+      res.end();
+      return;
+    }
+
+    let message;
+    try {
+      const chunks = [];
+      for await (const chunk of req) chunks.push(chunk);
+      message = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    } catch {
+      res.writeHead(400, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } }));
+      return;
+    }
+
+    if (!Object.hasOwn(message, 'id')) {
+      // 通知类消息（含 notifications/initialized）无需响应体，HTTP 层直接 202。
+      res.writeHead(202);
+      res.end();
+      return;
+    }
+
+    let response;
+    try {
+      const result = await dispatch(message.method, message.params || {});
+      response = { jsonrpc: '2.0', id: message.id, result };
+      if (message.method === 'initialize') {
+        res.setHeader('MCP-Protocol-Version', result.protocolVersion || '2024-11-05');
+      }
+    } catch (error) {
+      response = {
+        jsonrpc: '2.0',
+        id: message.id,
+        error: { code: -32603, message: error.message },
+      };
+    }
+
+    writeMCPResponse(res, response, req.headers.accept || '');
+  });
+
+  await new Promise((resolvePromise, rejectPromise) => {
+    server.once('error', rejectPromise);
+    server.listen(port, host, () => resolvePromise());
+  });
+
+  const address = server.address();
+  process.stdout.write(format('huaweicloud-devkit MCP server (remote) listening on %s:%s\n', host, address.port));
+
+  return {
+    server,
+    port: address.port,
+    close: () => new Promise((resolvePromise) => server.close(resolvePromise)),
+  };
+}
+
+function writeMCPResponse(res, response, accept) {
+  const json = JSON.stringify(response);
+  if (accept.includes('application/json')) {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(json);
+    return;
+  }
+  // 客户端只接受 SSE 时的兜底：单帧 event 后关闭流。
+  res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache' });
+  res.write(`event: message\ndata: ${json}\n\n`);
+  res.end();
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === resolve(process.argv[1])) {
+  const portIdx = process.argv.indexOf('--port');
+  const port = portIdx > -1 ? Number(process.argv[portIdx + 1]) : DEFAULT_PORT;
+  const hostIdx = process.argv.indexOf('--host');
+  const host = hostIdx > -1 && process.argv[hostIdx + 1] ? process.argv[hostIdx + 1] : DEFAULT_HOST;
+  startRemoteServer({ port, host }).catch((error) => {
+    process.stderr.write(`Failed to start MCP remote server: ${error.message}\n`);
+    // eslint-disable-next-line n/no-process-exit -- fatal startup error in standalone CLI mode
+    process.exit(1);
+  });
+}

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

@@ -2,8 +2,48 @@
 import { stdin, stdout } from 'node:process';
 import { rmSync, existsSync } from 'node:fs';
 import { resolve, dirname } from 'node:path';
+import { platform } from 'node:os';
 import { fileURLToPath } from 'node:url';
-import { TOOL_DEFINITIONS, callTool } from './tools.mjs';
+
+import { dispatch } from './mcp-protocol.mjs';
+import { DEFAULT_PORT, DEFAULT_HOST } from './mcp-server-remote.mjs';
+import { getCachedUpdateInfo, readInstalledVersion } from './update-check.mjs';
+import { detectAgent } from './telemetry/agent-detect.mjs';
+
+const transportIdx = process.argv.indexOf('--transport');
+const transport = transportIdx > -1 && process.argv[transportIdx + 1] ? process.argv[transportIdx + 1] : 'stdio';
+const portIdx = process.argv.indexOf('--port');
+const remotePort = portIdx > -1 ? Number(process.argv[portIdx + 1]) : DEFAULT_PORT;
+const hostIdx = process.argv.indexOf('--host');
+const remoteHost = hostIdx > -1 && process.argv[hostIdx + 1] ? process.argv[hostIdx + 1] : DEFAULT_HOST;
+
+const projectDirIdx = process.argv.indexOf('--codearts-project-dir');
+if (projectDirIdx > -1 && process.argv[projectDirIdx + 1]) {
+  process.env.CODEARTS_PROJECT_DIR = process.argv[projectDirIdx + 1];
+}
+
+const endpointIdx = process.argv.indexOf('--hdkitservice-endpoint');
+if (endpointIdx > -1 && process.argv[endpointIdx + 1]) {
+  process.env.HDKITSERVICE_ENDPOINT = process.argv[endpointIdx + 1];
+}
+
+const telemetryEndpointIdx = process.argv.indexOf('--telemetry-endpoint');
+if (telemetryEndpointIdx > -1 && process.argv[telemetryEndpointIdx + 1]) {
+  process.env.HUAWEICLOUD_DEVKIT_TELEMETRY_ENDPOINT = process.argv[telemetryEndpointIdx + 1];
+}
+
+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".
@@ -13,117 +53,132 @@ try {
   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;
-    }
+if (transport === 'remote') {
+  const { startRemoteServer } = await import('./mcp-server-remote.mjs');
+  startRemoteServer({ port: remotePort, host: remoteHost }).catch((error) => {
+    process.stderr.write(`Failed to start MCP remote server: ${error.message}\n`);
+    // eslint-disable-next-line n/no-process-exit -- fatal startup error; no active session to keep alive
+    process.exit(1);
+  });
+} else {
+  runStdioServer();
+}
 
-    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;
-    }
+function runStdioServer() {
+  const updatePrewarm = () => {
+    getCachedUpdateInfo(readInstalledVersion() || '0.0.0').catch(() => {});
+  };
 
-    return;
-  }
-}
+  let buffer = Buffer.alloc(0);
+  let useContentLengthFraming = true;
 
-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;
-}
+  // Keep the event loop alive after stdin is closed (Windows Hermes workaround).
+  // Node.js exits when no active handles remain; the stdin 'data' listener is
+  // the only handle. On Windows, Hermes may close the stdin pipe after the
+  // initial handshake, causing the process to exit silently (exit 0).
+  //
+  // For Hermes on Windows: start a keepalive timer on stdin close, and only exit
+  // when stdout also closes.
+  // For all other agents (OfficeAce, WorkBuddy, etc.): stdin close is the
+  // shutdown signal — exit cleanly so the host does not see CLOSE_TIMEOUT.
+  const { harness } = detectAgent();
+  const NEEDS_KEEPALIVE = harness === 'hermes' && platform() === 'win32';
+
+  // 版本升级检测预热：异步、非阻塞；失败静默（离线/超时不影响会话）。
+  process.nextTick(updatePrewarm);
 
-async function handleMessage(message) {
-  if (!Object.hasOwn(message, 'id')) {
-    if (message.method === 'notifications/initialized') return;
-    return;
+  let keepAlive = null;
+  function onStdinClose() {
+    if (keepAlive) return;
+    if (NEEDS_KEEPALIVE) {
+      keepAlive = setInterval(() => {}, 60000);
+    } else {
+      // eslint-disable-next-line n/no-process-exit -- stdin close is the shutdown signal; exit now without waiting for stdout
+      process.exit(0);
+    }
   }
-  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,
-      },
-    });
+  function onStdoutClose() {
+    if (keepAlive) {
+      clearInterval(keepAlive);
+      keepAlive = null;
+    }
+    process.exitCode = 0;
   }
-}
+  stdin.on('close', onStdinClose);
+  stdin.on('end', onStdinClose);
+  stdout.on('close', onStdoutClose);
 
-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',
-      },
-    };
-  }
+  stdin.on('data', (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+    readFrames();
+  });
 
-  if (method === 'tools/list') {
-    return { tools: TOOL_DEFINITIONS };
-  }
+  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;
+      }
 
-  if (method === 'tools/call') {
-    const result = await callTool(params.name, params.arguments || {});
-    return {
-      content: [
-        {
-          type: 'text',
-          text: JSON.stringify(result, null, 2),
-        },
-      ],
-      isError: false,
-    };
+      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;
+    }
   }
 
-  if (method === 'resources/list') {
-    return { resources: [] };
+  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;
   }
 
-  throw new Error(`Unsupported method: ${method}`);
-}
+  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,
+        },
+      });
+    }
+  }
 
-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');
+  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');
+    }
   }
 }