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

package/bin/dsh-postinstall.cjs

@@ -0,0 +1,77 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+// ── Detect DSH profile context ──
+const cwd = process.cwd();
+const dshHome = process.env.DSH_HOME || path.join(os.homedir(), '.dsh');
+const profilesRoot = path.join(dshHome, 'profiles');
+
+if (!cwd.startsWith(profilesRoot)) {
+  // Not inside a DSH profile — traditional install, just print message
+  console.log('\nHuaweiCloud DevKit installed. Run: npx huaweicloud-devkit install\n');
+  process.exit(0);
+}
+
+// ── Inside a DSH profile: copy skills to ~/.dsh/skills/ ──
+const packageRoot = path.resolve(__dirname, '..');
+
+// Rewrite the bundled patch's relative MCP server path to the absolute package
+// path. Relative paths resolve against the DSH process cwd and break when DSH
+// is started outside the profile directory. Idempotent: absolute paths are kept.
+const bundledPatch = path.join(packageRoot, 'cordis.patch.yml');
+if (fs.existsSync(bundledPatch)) {
+  const relativeArg = './node_modules/huaweicloud-devkit/plugins/huaweicloud-core/src/mcp-server.mjs';
+  const absoluteArg = path
+    .join(packageRoot, 'plugins', 'huaweicloud-core', 'src', 'mcp-server.mjs')
+    .replace(/\\/g, '/')
+    .replace(/'/g, "''");
+  const patch = fs.readFileSync(bundledPatch, 'utf8');
+  const updated = patch.split(`'${relativeArg}'`).join(`'${absoluteArg}'`);
+  if (updated !== patch) {
+    fs.writeFileSync(bundledPatch, updated);
+    console.log('HuaweiCloud DevKit: rewrote DSH patch MCP path to absolute package path');
+  }
+}
+
+const skillsSrc = path.join(packageRoot, 'plugins', 'huaweicloud-core', 'skills');
+const skillsDest = path.join(dshHome, 'skills');
+
+if (!fs.existsSync(skillsSrc)) {
+  console.log('HuaweiCloud DevKit: skills source not found, skipping auto-setup');
+  process.exit(0);
+}
+
+fs.mkdirSync(skillsDest, { recursive: true });
+
+function copyDir(src, dest) {
+  if (!fs.existsSync(src)) return;
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const s = path.join(src, entry.name);
+    const d = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(s, d);
+    } else {
+      fs.copyFileSync(s, d);
+    }
+  }
+}
+
+let count = 0;
+for (const entry of fs.readdirSync(skillsSrc, { withFileTypes: true })) {
+  if (entry.isDirectory()) {
+    copyDir(path.join(skillsSrc, entry.name), path.join(skillsDest, entry.name));
+    count++;
+  }
+}
+
+console.log(`\nHuaweiCloud DevKit: ${count} skills installed to ~/.dsh/skills/`);
+console.log('MCP server will be available after DSH restart.');
+console.log('\n\u001b[1m\u001b[36m  首次使用请配置环境：\u001b[0m');
+console.log('  1. 安装 KooCLI：npx huaweicloud-devkit install-hcloud');
+console.log('  2. 配置凭证：  npx huaweicloud-devkit auth init');
+console.log('  3. 重启 DSH 会话后即可使用');
+console.log('  或者直接在 DSH 中对 Agent 说：帮我安装华为云 KooCLI 并配置凭证\n');

package/bin/setup.cjs

@@ -1,8 +1,11 @@
 #!/usr/bin/env node
 'use strict';
-const path = require('path');
-const fileUrl = require('url').pathToFileURL(path.join(__dirname, '..', 'plugins', 'huaweicloud-core', 'src', 'setup-cli.mjs')).href;
-import(fileUrl).catch(e => {
-  console.error(e.message);
+const path = require('node:path');
+const fileUrl = require('node:url').pathToFileURL(
+  path.join(__dirname, '..', 'plugins', 'huaweicloud-core', 'src', 'setup-cli.mjs'),
+).href;
+
+import(fileUrl).catch((error) => {
+  console.error(error.message);
   process.exit(1);
 });

package/cordis.patch.yml

@@ -0,0 +1,13 @@
+- insert:
+    - id: huaweicloud-devkit
+      name: '@deepseek-ai/dsh-mcp-client'
+      config:
+        serverName: huaweicloud
+        transport: stdio
+        command: node
+        args:
+          - './node_modules/huaweicloud-devkit/plugins/huaweicloud-core/src/mcp-server.mjs'
+        env:
+          HUAWEICLOUD_AGENT_TOOLKIT_MODE: local
+          HDKITSERVICE_ENDPOINT: ''
+        failOnStartupError: false

package/integrations/atomcode/hooks/huaweicloud-telemetry.js

@@ -0,0 +1,181 @@
+/**
+ * huaweicloud-telemetry.js — AtomCode PreToolUse Hook
+ *
+ * Captures Skill loading, hcloud CLI commands, and MCP tool invocations,
+ * writing structured events to hook-events.jsonl for the devkit telemetry
+ * module to ingest and report.
+ *
+ * Classification logic mirrors the existing four platform hooks exactly.
+ * This hook NEVER blocks execution — it always exits 0.
+ */
+
+import { appendFileSync, mkdirSync, existsSync, readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// ══════════════════════════════════════════════════════════════════
+// Debug
+// ══════════════════════════════════════════════════════════════════
+
+const DEBUG = process.env.HUAWEICLOUD_DEVKIT_DEBUG === 'true';
+
+function debugLog(msg) {
+  if (!DEBUG) return;
+  try {
+    const logPath = join(TELEMETRY_DIR, 'atomcode-debug.log');
+    appendFileSync(logPath, `${new Date().toISOString()} ${msg}\n`);
+  } catch (_) {
+    /* best-effort */
+  }
+}
+
+// ══════════════════════════════════════════════════════════════════
+// Paths — hook is installed at <plugin_dir>/hooks/
+// ══════════════════════════════════════════════════════════════════
+
+const __filename = fileURLToPath(import.meta.url);
+const HOOK_DIR = dirname(__filename);
+const PLUGIN_DIR = dirname(HOOK_DIR);
+const TELEMETRY_DIR = join(PLUGIN_DIR, 'telemetry');
+const HOOK_EVENTS_PATH = join(TELEMETRY_DIR, 'hook-events.jsonl');
+
+// ══════════════════════════════════════════════════════════════════
+// Helpers
+// ══════════════════════════════════════════════════════════════════
+
+function ensureDir(dirPath) {
+  if (!existsSync(dirPath)) mkdirSync(dirPath, { recursive: true });
+}
+
+function writeEvent(key, value, extra = {}) {
+  try {
+    ensureDir(TELEMETRY_DIR);
+    const line = JSON.stringify({ key, value, ...extra }) + '\n';
+    appendFileSync(HOOK_EVENTS_PATH, line, 'utf8');
+    debugLog(`writeEvent key=${key} value=${value}`);
+  } catch (error) {
+    debugLog(`writeEvent FAILED: ${error.message}`);
+  }
+}
+
+// ══════════════════════════════════════════════════════════════════
+// Skill identification
+// ══════════════════════════════════════════════════════════════════
+
+function isHuaweiCloudSkill(name) {
+  return typeof name === 'string' && /^huawei/i.test(name);
+}
+
+// ══════════════════════════════════════════════════════════════════
+// CLI command classification (matches skill-tracker.js exactly)
+// ══════════════════════════════════════════════════════════════════
+
+const HCLOUD_RE = /(?:^|[;&|]\s*)hcloud(?:\.exe)?\s+(.+)/i;
+const READ_VERBS = /\b(List|Show|Get|Describe|NovaList|NovaShow)\w*/i;
+const WRITE_VERBS =
+  /\b(Create|Delete|Update|Modify|Remove|Revoke|Grant|Attach|Detach|Enable|Disable|Set|Add|Bind|Unbind|Reset|Change|Activate|Deactivate|Register|Unregister|Import|Export|Download|Upload|Copy|Move|Convert|Migrate|Run|Execute|Invoke|Trigger|Deploy|Push|Start|Stop|Restart|Reboot|Suspend|Resume|Terminate|Release|Allocate)\w*/i;
+
+function classifyHcloud(text) {
+  const m = HCLOUD_RE.exec(text);
+  if (!m) return null;
+  const rest = m[1].trim();
+  const parts = rest.split(/\s+/).filter((p) => !p.startsWith('--'));
+  const cmd = parts.join(' ');
+  if (!cmd) return null;
+  if (READ_VERBS.test(cmd)) return { key: 'cli:read', value: `hcloud ${cmd}` };
+  if (WRITE_VERBS.test(cmd)) return { key: 'cli:write', value: `hcloud ${cmd}` };
+  return { key: 'cli:invoke', value: `hcloud ${cmd}` };
+}
+
+// ══════════════════════════════════════════════════════════════════
+// Input parsing — stdin JSON, with env-var fallback
+// ══════════════════════════════════════════════════════════════════
+
+function parseInput() {
+  // Primary: AtomCode passes data via env vars
+  const toolName = process.env.ATOMCODE_TOOL_NAME || '';
+  const context = process.env.ATOMCODE_HOOK_CONTEXT || '';
+  if (toolName || context) {
+    const input = { tool_name: toolName };
+    if (context) {
+      try {
+        input.tool_input = JSON.parse(context);
+      } catch (_) {
+        input.tool_input = { command: context };
+      }
+    } else {
+      input.tool_input = {};
+    }
+    return input;
+  }
+
+  // Fallback: stdin JSON (piped for manual testing)
+  try {
+    const data = readFileSync(0, 'utf8').trim();
+    if (data) return JSON.parse(data);
+  } catch (_) {
+    /* stdin unavailable */
+  }
+
+  return { tool_name: '', tool_input: {} };
+}
+
+function extractCommand(toolInput) {
+  if (typeof toolInput === 'string') return toolInput;
+  if (toolInput && typeof toolInput === 'object') {
+    return toolInput.command || toolInput.arguments?.command || '';
+  }
+  return '';
+}
+
+function extractSkillName(toolInput) {
+  if (typeof toolInput === 'string') return toolInput;
+  if (toolInput && typeof toolInput === 'object') {
+    return toolInput.name || toolInput.command || '';
+  }
+  return '';
+}
+
+// ══════════════════════════════════════════════════════════════════
+// Main
+// ══════════════════════════════════════════════════════════════════
+
+try {
+  const input = parseInput();
+  const toolName = input.tool_name || input.tool || '';
+  const toolInput = input.tool_input || input.arguments || {};
+
+  debugLog(`tool=${toolName}`);
+
+  // ── Category 1: Skill tool calls ──
+  if (toolName === 'skill' || toolName === 'use_skill') {
+    const skillName = extractSkillName(toolInput);
+    debugLog(`skill name=${skillName}`);
+    if (isHuaweiCloudSkill(skillName)) {
+      writeEvent('skill:retrieve', skillName);
+    }
+  }
+
+  // ── Category 2: Bash/pwsh with hcloud commands ──
+  if (toolName === 'bash' || toolName === 'pwsh') {
+    const command = extractCommand(toolInput);
+    if (command && HCLOUD_RE.test(command)) {
+      debugLog(`hcloud command: ${command.slice(0, 120)}`);
+      const classified = classifyHcloud(command);
+      if (classified) {
+        writeEvent(classified.key, classified.value, { capability: 'cli' });
+      }
+    }
+  }
+
+  // ── Category 3: MCP Huawei Cloud tools ──
+  if (toolName.startsWith('mcp__huaweicloud')) {
+    writeEvent(`tool:${toolName}`, '1', { capability: 'mcp' });
+    debugLog(`MCP tool: ${toolName}`);
+  }
+} catch (error) {
+  debugLog(`FATAL: ${error?.message || error}`);
+}
+
+// Always allow — telemetry hook never blocks; the process exits 0 naturally
+// since all I/O is synchronous and nothing holds the event loop open.

package/integrations/atomcode/hooks.json

@@ -0,0 +1,9 @@
+{
+  "hooks": {
+    "hw-telemetry": {
+      "event": "pre_tool_use",
+      "command": "<node_path> <plugin_dir>/hooks/huaweicloud-telemetry.js",
+      "timeout_ms": 2000
+    }
+  }
+}

package/integrations/dsh/hook-plugin.mjs

@@ -0,0 +1,148 @@
+// hook-plugin.mjs — DSH Cordis Hook Plugin
+// Intercepts Huawei Cloud skill calls and hcloud CLI commands,
+// writes events to hook-events.jsonl for the telemetry module to consume.
+
+import { appendFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// ══════════════════════════════════════════════════════════════════
+// Cordis plugin identity (required by DSH loader)
+// ══════════════════════════════════════════════════════════════════
+export const name = 'huaweicloud-devkit-hook';
+export const inject = ['tools'];
+
+// ══════════════════════════════════════════════════════════════════
+// Paths — this file lives in $DSH_HOME/huaweicloud-plugins/
+// ══════════════════════════════════════════════════════════════════
+const __filename = fileURLToPath(import.meta.url);
+const PLUGIN_DIR = dirname(__filename);
+// telemetry/ dir is the single shared location for event files
+const TELEMETRY_DIR = join(PLUGIN_DIR, 'telemetry');
+const HOOK_EVENTS_PATH = join(TELEMETRY_DIR, 'hook-events.jsonl');
+
+const DEBUG = process.env.HUAWEICLOUD_DEVKIT_DEBUG === 'true';
+
+// ══════════════════════════════════════════════════════════════════
+// Helpers
+// ══════════════════════════════════════════════════════════════════
+
+function ensureDir(dirPath) {
+  if (!existsSync(dirPath)) mkdirSync(dirPath, { recursive: true });
+}
+
+function debugLog(msg) {
+  if (!DEBUG) return;
+  try {
+    const logPath = join(TELEMETRY_DIR, 'telemetry-debug.log');
+    ensureDir(TELEMETRY_DIR);
+    appendFileSync(logPath, `${new Date().toISOString()} [hook] ${msg}\n`, 'utf8');
+  } catch {
+    // debug log is best-effort; never fail the plugin
+  }
+}
+
+function writeEvent(key, value, extra = {}) {
+  try {
+    ensureDir(TELEMETRY_DIR);
+    const line = JSON.stringify({ key, value, ...extra }) + '\n';
+    appendFileSync(HOOK_EVENTS_PATH, line, 'utf8');
+    debugLog(`writeEvent key=${key} value=${value}`);
+  } catch (error) {
+    debugLog(`writeEvent FAILED: ${error.message}`);
+  }
+}
+
+// ══════════════════════════════════════════════════════════════════
+// Huawei Cloud identification
+// ══════════════════════════════════════════════════════════════════
+
+function isHuaweiCloudSkill(name) {
+  return typeof name === 'string' && /^huawei/i.test(name);
+}
+
+// ══════════════════════════════════════════════════════════════════
+// hcloud command classification (mirrors skill-tracker.js)
+// ══════════════════════════════════════════════════════════════════
+
+const HCLOUD_RE = /(?:^|[;&|]\s*)hcloud(?:\.exe)?\s+(.+)/i;
+const READ_VERBS = /\b(List|Show|Get|Describe|NovaList|NovaShow)\w*/i;
+const WRITE_VERBS =
+  /\b(Create|Delete|Update|Modify|Remove|Revoke|Grant|Attach|Detach|Enable|Disable|Set|Add|Bind|Unbind|Reset|Change|Activate|Deactivate|Register|Unregister|Import|Export|Download|Upload|Copy|Move|Convert|Migrate|Run|Execute|Invoke|Trigger|Deploy|Push|Start|Stop|Restart|Reboot|Suspend|Resume|Terminate|Release|Allocate)\w*/i;
+
+function classifyHcloud(text) {
+  const m = HCLOUD_RE.exec(text);
+  if (!m) return null;
+  const rest = m[1].trim();
+  const parts = rest.split(/\s+/).filter((p) => !p.startsWith('--'));
+  const cmd = parts.join(' ');
+  if (!cmd) return null;
+  if (READ_VERBS.test(cmd)) return { key: 'cli:read', value: `hcloud ${cmd}`, capability: 'cli' };
+  if (WRITE_VERBS.test(cmd)) return { key: 'cli:write', value: `hcloud ${cmd}`, capability: 'cli' };
+  return { key: 'cli:invoke', value: `hcloud ${cmd}`, capability: 'cli' };
+}
+
+// ══════════════════════════════════════════════════════════════════
+// apply() — Cordis plugin entry point
+// ══════════════════════════════════════════════════════════════════
+
+export function apply(ctx) {
+  debugLog('=== PLUGIN LOADED ===');
+
+  // ── Layer 1: tools/pre-execute waterfall ──────────────────────
+  ctx.on('tools/pre-execute', async (exec, next) => {
+    try {
+      debugLog(`pre-execute tool=${exec.name}`);
+
+      // ── Intercept 1: skill tool calls ──
+      if (exec.name === 'skill') {
+        const skillName = exec.arguments?.name || '';
+        debugLog(`skill name=${skillName}`);
+        if (isHuaweiCloudSkill(skillName)) {
+          writeEvent('skill:retrieve', skillName);
+          ctx.logger.info(`[hw-hook] skill called: ${skillName}`);
+          debugLog(`SKILL TRACKED: ${skillName}`);
+        }
+      }
+
+      // ── Intercept 2: pwsh/bash with hcloud commands ──
+      if (exec.name === 'pwsh' || exec.name === 'bash') {
+        const command = exec.arguments?.command || '';
+        if (!command) return next();
+
+        if (HCLOUD_RE.test(command)) {
+          debugLog(`hcloud command: ${command.slice(0, 120)}`);
+
+          // Classify and write event
+          const classified = classifyHcloud(command);
+          if (classified) {
+            writeEvent(classified.key, classified.value, { capability: 'cli' });
+            debugLog(`CLI TRACKED: ${classified.key} ${classified.value}`);
+          }
+        }
+      }
+
+      // ── Intercept 3: MCP Huawei Cloud tools (record only) ──
+      if (exec.name.startsWith('mcp__huaweicloud__')) {
+        writeEvent(`tool:${exec.name}`, '1', { capability: 'mcp' });
+        debugLog(`MCP tool: ${exec.name}`);
+      }
+    } catch (error) {
+      debugLog(`pre-execute ERROR: ${error?.message || error}`);
+      ctx.logger.warn(`[hw-hook] pre-execute error: ${error.message}`);
+    }
+    return next();
+  });
+
+  // ── Layer 2: tools/result observe ─────────────────────────────
+  ctx.on('tools/result', (exec, result) => {
+    if (exec.name.startsWith('mcp__huaweicloud__') && result.isError) {
+      const msg = result.error?.message || 'unknown error';
+      debugLog(`tool error: ${exec.name}: ${msg}`);
+      ctx.logger.info(`[hw-hook] tool error: ${exec.name}: ${msg}`);
+    }
+  });
+
+  ctx.logger.info('[hw-hook] DSH Huawei Cloud hook plugin activated');
+  debugLog('=== PLUGIN INIT DONE ===');
+}