huaweicloud-devkit 0.1.24 → 0.1.26-dev.0

package/plugins/huaweicloud-core/skills/huawei-ecs/references/create-instance.md

@@ -4,6 +4,7 @@
 
 ## 1. Discover flavors
 hcloud ECS ListFlavors --cli-region=<region> --cli-output=json
+Filter for `os_extra_specs.cond:operation:status == normal` — most results are abandoned. See references/flavors.md.
 
 ## 2. Find availability zones
 hcloud ECS NovaListAvailabilityZones --cli-region=<region>
@@ -30,7 +31,7 @@ hcloud VPC ListSubnets --vpc_id=<vpc-id> --cli-region=<region>
 If no VPC/subnet exists: load `huawei-vpc` skill → create VPC → create subnet (with DNS) → create security group → return here.
 
 ## 5. Create keypair (recommended over adminPass)
-hcloud ECS NovaCreateKeypair --keypair_name=<name>
+hcloud ECS NovaCreateKeypair --keypair.name=<name>
 Save the returned private key to a local file. The public key is auto-injected.
 
 Password alternative:
@@ -43,7 +44,7 @@ hcloud ECS CreateServers --cli-region=<region> --server.name=<name> --server.fla
 
 ### Bootstrap with user_data (cloud-init)
 
-Use `--server.user_data` to run a cloud-init script at first boot. The value must be **base64-encoded**:
+Use `--server.user_data` to run a cloud-init script at first boot. The value must be **base64-encoded**. This is also the recommended bootstrap path when SCP policies block SSH access — user_data serves as the full deployment path, no SSH needed.
 
 ```bash
 # Encode the script
@@ -58,20 +59,34 @@ hcloud ECS CreateServers ... --server.user_data=$user_data
 ```
 
 > **Security**: Never embed secrets (passwords, AK/SK, tokens) in user_data. It is stored unencrypted and readable from within the instance via IMDS. Fetch secrets at boot from DEW/CSMS instead.
->
+
 > **Debugging**: If the script didn't run, check `/var/log/cloud-init-output.log` on the instance.
 
-## 7. EIP (optional)
-hcloud EIP CreatePublicip --publicip.type=<type> --bandwidth.size=<size> --bandwidth.share_type=<share-type> --bandwidth.name=<name>
+## 7. EIP (two methods)
+
+### Method A: Inline with CreateServers (Recommended)
+Add EIP parameters to the `CreateServers` command in step 6:
 
 ```bash
+hcloud ECS CreateServers \
+  --server.publicip.eip.iptype=<type> \
+  --server.publicip.eip.bandwidth.sharetype=<share-type> \
+  --server.publicip.eip.bandwidth.size=<size> \
+  --server.publicip.eip.bandwidth.chargemode=traffic \
+  ...
+```
+
+> **Trap**: Parameter names differ from `EIP CreatePublicip`. Use `iptype` (not `type`), `sharetype` (not `share_type`), and `chargemode` (not `charging_mode`). Always verify with `hcloud ECS CreateServers --help`.
+
+### Method B: Create and bind separately
+hcloud EIP CreatePublicip --publicip.type=<type> --bandwidth.size=<size> --bandwidth.share_type=<share-type> --bandwidth.name=<name>
+
 # Get the ECS network port ID
 hcloud ECS ListServersDetails --cli-region=<region> --server_id=<instance-id>
 # → addresses.<vpc-id>[].OS-EXT-IPS:port_id
 
 # Bind EIP via port
 hcloud EIP AssociatePublicips --publicip_id=<eip-id> --publicip.associate_instance_id=<port-id> --publicip.associate_instance_type=PORT
-```
 
 ## 8. Verify
 hcloud ECS ListServersDetails --cli-region=<region> --server_id=<instance-id>

package/plugins/huaweicloud-core/skills/huawei-ecs/references/flavors.md

@@ -3,7 +3,20 @@
 **Always discover flavors dynamically before recommending a specific flavor name.** Flavor availability varies by region and changes over time.
 
 ## Step 1: List available flavors
-hcloud ECS ListFlavors --cli-region=<region> --cli-output=json
+
+Use JMESPath to filter in-line — raw output returns hundreds of records and floods context:
+
+```bash
+# Filter by family prefix (e.g. ac7), return name + specs only
+hcloud ECS ListFlavors --cli-region=<region> --cli-output=json \
+  --cli-query="flavors[?contains(name, 'ac7')].{name:name, vcpus:vcpus, ram:ram}"
+
+# Filter by vCPU range
+hcloud ECS ListFlavors --cli-region=<region> --cli-output=json \
+  --cli-query="flavors[?vcpus >= '2' && vcpus <= '4'].{name:name, vcpus:vcpus, ram:ram}"
+```
+
+> Always use `--cli-query` with JMESPath to narrow results. Never run bare `ListFlavors` without filtering.
 
 ## Step 2: Filter by scenario
 
@@ -26,3 +39,17 @@ Flavor family names are region-dependent. Example discrepancies seen in testing:
 - Other regions may have s6/m6/g6 families
 
 Always run ListFlavors and pick from actual results.
+
+## Step 3: Filter out abandoned / sold-out specs
+
+`ListFlavors` returns ALL specs including abandoned ones. Before selecting a spec, check the `os_extra_specs` field in the JSON response:
+
+| Field | Values | Meaning |
+|-------|--------|---------|
+| `os_extra_specs.cond:operation:status` | `normal`, `abandon`, `sellout` | Only `normal` specs can be created. `abandon` = deprecated, `sellout` = out of stock |
+| `os_extra_specs.cond:operation:az` | e.g. `cn-north-4g(normal)` | Spec is available in this AZ. Multiple entries = multiple AZ support |
+
+A flavor can be `normal` globally but `abandon` in specific AZs. Selecting an `abandon` or `sellout` spec will fail with **`Ecs.0019`** at creation time — there is no pre-flight validation in `ListFlavors`. If creation fails:
+
+1. Switch to a different AZ: `hcloud ECS NovaListAvailabilityZones --cli-region=<region>`
+2. Or switch to a different flavor family (e.g., `at7` → `ac7`)

package/plugins/huaweicloud-core/skills/huawei-functiongraph/SKILL.md

@@ -63,7 +63,6 @@ Always discover parameters with `--help` before executing. These are the correct
 | Create function | `CreateFunction` | references/create-function.md |
 | Delete function | `DeleteFunction` | Strip `:latest` from URN |
 | Invoke function | `InvokeFunction` | Requires body param (`--name=<value>` becomes event body). Use `--x_cff_request_version=v0` for raw output, `v1` for APIG-wrapped. |
-| List runtimes | `ListRuntimes` | |
 | Create trigger | `CreateFunctionTrigger` | references/triggers.md |
 | List triggers | `ListFunctionTriggers` | |
 | Delete trigger | `DeleteFunctionTrigger` | |

package/plugins/huaweicloud-core/skills/huawei-functiongraph/references/triggers.md

@@ -138,5 +138,5 @@ hcloud FunctionGraph DeleteFunctionTrigger --function_urn=<urn> --trigger_type_c
 ```
 
 > Deleting a trigger does NOT cascade-delete the associated APIG API. After `DeleteFunctionTrigger`, also run `hcloud APIG ListApisV2 --instance_id=<id>` and delete orphaned APIs to avoid resource residue.
->
+
 > **APIG event format**: When using DEDICATEDGATEWAY, the event body is Base64 encoded and uses a non-standard structure. See `apig-event-format.md` for handler templates.

package/plugins/huaweicloud-core/skills/huawei-getting-started/SKILL.md

@@ -18,7 +18,7 @@ version: 1
 
 ## First-Time Setup
 1. **Install KooCLI** using command above
-2. **Accept privacy policy** (first run only): KooCLI requires one-time privacy agreement. Run `hcloud version` and respond `y` to the prompt. For non-interactive terminals, use `echo "y" | hcloud version`
+2. **Accept privacy policy** (first run only): KooCLI requires one-time privacy agreement. Run `hcloud version` to read the agreement, then respond `y` to accept. Do not pipe `echo "y" |` — you must review the terms first.
 3. **Configure credentials**: `hcloud configure init` (interactive, prompts for AK/SK/region safely)
 4. **Verify**: `hcloud configure list` to confirm profile, then `hcloud ECS ListServersDetails --cli-region=cn-north-4`
 5. For detailed auth guidance, see `huaweicloud-cli-and-auth` skill
@@ -43,7 +43,7 @@ hcloud configure list
 | AK/SK must be kept secret | Never commit to git or share |
 | Default region applies to all commands | Override with --cli-region= per command |
 | Some services region-specific | Not all services available in all regions |
-| Privacy policy blocks first run | KooCLI requires one-time `y` confirmation. Non-interactive terminals need `echo "y" \| hcloud <cmd>` |
+| Privacy policy blocks first run | Run `hcloud version` to read and accept the agreement. Review the terms before responding `y` |
 
 ## What Can I Do? (Quick Index)
 | Goal | Skill |

package/plugins/huaweicloud-core/skills/huawei-obs/SKILL.md

@@ -36,22 +36,13 @@ Domain expertise for Huawei Cloud Object Storage Service (OBS). Covers bucket/ob
 | Versioning is irreversible | Once enabled, cannot be disabled, only suspended |
 | OBS uses AK/SK directly | NOT IAM tokens. Auth errors mean check AK/SK validity |
 | Static website via CLI missing | KooCLI OBS lacks website config. Use REST API or console |
-| **OBS needs separate cred config** | `hcloud configure` is NOT enough for OBS. Run `hcloud OBS config -i` (interactive) to create `~/.obsutilconfig`. This must be done OUTSIDE agent chat. |
+| **OBS needs separate cred config** | `hcloud configure` is NOT enough for OBS. Before any OBS operation, call `huaweicloud_setup_obs_config` to sync credentials from hcloud profile. |
 | **obsutil interactive prompts** | `cp`/`rm` without `-f` causes "Please input (y/n)" → Agent hangs (TIMEOUT). Always use `-f` for non-interactive. |
 | **Directory upload adds prefix** | `cp <dir>/ obs://<bucket>/ -r` puts files under `bucket/<dir>/...`. Use `-flat` for root-level files (static sites). Preview with `-dryRun` first. |
 
 ## OBS Credential Setup (Required Before First Use)
 
-KooCLI OBS uses a separate config file (`~/.obsutilconfig`), NOT `~/.hcloud/config.json`. Use the **same AK/SK** that you configured for hcloud. Run once outside agent chat:
-
-```bash
-# Preferred: interactive (safe, no AK/SK in shell history)
-hcloud OBS config -i
-# Follow prompts: AK, SK, endpoint (e.g. obs.cn-north-4.myhuaweicloud.com)
-
-# Alternative: non-interactive (use with caution — AK/SK in shell history)
-hcloud OBS config -e=<endpoint> -i=<AK> -k=<SK>
-```
+KooCLI OBS uses a separate config file (`~/.obsutilconfig`), NOT `~/.hcloud/config.json`. Call `huaweicloud_setup_obs_config` to automatically sync credentials from the active hcloud profile. No manual AK/SK entry needed.
 
 ## Common Workflows
 

package/plugins/huaweicloud-core/skills/huawei-vpc/SKILL.md

@@ -10,6 +10,8 @@ version: 1
 
 Always run `hcloud <Service> <Operation> --help` before constructing commands to discover exact parameter names and requirements.
 
+> **Multi-version APIs**: KooCLI may print a warning like "ListVpcs有多个版本,默认使用该API版本v3" before the actual response. The text BEFORE the first `{` is the version selection notice — parse JSON starting from `{` only. This is normal behavior, not an error.
+
 ## Overview
 
 Domain expertise for Huawei Cloud Virtual Private Cloud (VPC). Covers VPC/subnet lifecycle, security groups, EIP management, NAT gateways, VPN, and network ACLs.
@@ -27,6 +29,7 @@ Domain expertise for Huawei Cloud Virtual Private Cloud (VPC). Covers VPC/subnet
 | **VPC params need nested prefix** | KooCLI 7.x VPC API uses `--vpc.<param>`, `--subnet.<param>`, `--security_group.<param>`. Example: `--vpc.name=xxx` NOT `--name=xxx` |
 | **Security group needs no vpc_id** | VPC v3 API `CreateSecurityGroup` does NOT accept `vpc_id`. Security groups are region-level, not VPC-bound |
 | Subnet DNS empty → ECS no DNS | DNS params (`--subnet.primary_dns`, `--subnet.secondary_dns`) marked optional but empty default breaks cloud-init domain resolution — `yum`/`apt` installs fail silently. Always set both. See `--help` for region-specific DNS IPs |
+| SCP blocks 0.0.0.0/0 SG rules | If `CreateSecurityGroupRule` with `--remote_ip_prefix=0.0.0.0/0` fails with `SYS.0403`, an org-level SCP policy is denying wide-open rules. Narrow to a specific CIDR range (e.g., your office IP) instead |
 
 ## Common Workflows
 
@@ -55,7 +58,7 @@ Domain expertise for Huawei Cloud Virtual Private Cloud (VPC). Covers VPC/subnet
 | VPC.0301: Bandwidth name invalid | PER type requires `--bandwidth.name`, even though `--help` marks it optional |
 | EIP has no public IP after binding | May need AddIngressEipV2 for ELB-type resources (see huawei-apig) |
 | ECS cloud-init fails silently (port 80/443 closed) | Subnet likely has no DNS. Check `hcloud VPC ShowSubnet --subnet_id=<id>` → `dnsList` empty? Rebuild subnet with `--subnet.primary_dns=<dns1> --subnet.secondary_dns=<dns2>`. DNS addresses per region: `hcloud VPC CreateSubnet --help` |
-| SYS.0403 / SCP deny | Service Control Policy explicitly denies this operation — contact org admin to adjust SCP, or use an account/region without the restriction |
+| SYS.0403 / SCP deny | Service Control Policy explicitly denies this operation — contact org admin to adjust SCP, or use an account/region without the restriction. If SSH is blocked, bootstrap via cloud-init user_data instead: see `huawei-ecs` — no SSH needed |
 
 ## Security Considerations
 

package/plugins/huaweicloud-core/skills/huaweicloud-cli-and-auth/SKILL.md

@@ -72,14 +72,14 @@ Agent processes find executables through `PATH`. If OpenCode/Codex cannot find `
 2. **KooCLI first-run privacy agreement**: On a fresh KooCLI install, `hcloud` blocks with `同意并继续使用(y)/不同意并退出(N)` and fails with `[USE_ERROR]您输入的是无效字符` in non-interactive mode. Detection: check command output for these strings. Ask the user: "KooCLI needs to accept its privacy agreement. May I accept it on your behalf?" If the user agrees, run `huaweicloud_run_readonly_command` with `args=["version"]` and `stdin="y\n"`. This accepts the agreement once, after which hcloud works normally.
 3. Ask the user to configure credentials outside the agent conversation when setup is needed.
 4. Inspect profile and region only through redacted tooling.
-5. Discover exact operation names with `hcloud <Service> --help` before guessing. Example: ECS instance listing is commonly `ECS ListServersDetails`; ECS creation is commonly `ECS CreateServers`; image lookup may be under `IMS GlanceShowImage`.
-6. Use `--cli-output=json` for machine-readable responses when supported.
-7. For resource operations, include `--cli-region`, `--cli-profile`, and service-specific project information when required.
-8. Classify every command before running it:
+4. Discover exact operation names with `hcloud <Service> --help` before guessing. Example: ECS instance listing is commonly `ECS ListServersDetails`; ECS creation is commonly `ECS CreateServers`; image lookup may be under `IMS GlanceShowImage`.
+5. Use `--cli-output=json` for machine-readable responses when supported.
+6. For resource operations, include `--cli-region`, `--cli-profile`, and service-specific project information when required.
+7. Classify every command before running it:
    - Read-only: `List*`, `Show*`, `Get*`, `Describe*`.
    - Write: `Create*`, `Delete*`, `Update*`, `Resize*`, `Start*`, `Stop*`, `Authorize*`, and similar.
    - Secret: any operation returning secret string, binary secret, token, or password.
-9. For write operations, show the exact command and ask for explicit approval.
+8. For write operations, show the exact command and ask for explicit approval.
 
 ## KooCLI Syntax Notes
 

package/plugins/huaweicloud-core/skills/huaweicloud-safety/SKILL.md

@@ -38,6 +38,20 @@ Use this skill before any Huawei Cloud action that may expose secrets, change re
 - Approved tool path: use `huaweicloud_run_approved_command` only when the exact planned command has been shown and the user explicitly approved that exact command.
 - After a write, verify with `huaweicloud_run_readonly_command` or another read-only check.
 
+## Proactive Hook Checks
+
+Before executing, deploying, or handing generated cloud artifacts to the user, run the matching check when available:
+
+- `huaweicloud_hook_check_command` for shell or KooCLI command text.
+- `huaweicloud_hook_check_artifacts` for generated policy, IaC, config, workflow, or deployment files.
+- `huaweicloud_hook_check_deploy_plan` for sandbox, preview, FunctionGraph, ECS, CCE, APIG, OBS, IAM, or cost-affecting plans.
+
+If the result is `deny`, repair the command, artifact, or deployment plan before execution. If the result is `warn`, show the warning to the user and repair or ask for explicit confirmation.
+
+## Static Analysis Boundary
+
+Hook checks inspect the command or plan text that is available before execution. If a command builds cloud parameters through shell variables, string concatenation, subshells, encoded payloads, or generated scripts, first expand the final command into reviewable text and run `huaweicloud_hook_check_command` on that final form. When the final values cannot be determined, stop and ask the user to review the expanded command or use `huaweicloud_plan_cli_command` before execution.
+
 ## Safe Alternatives
 
 - Use redacted profile inspection instead of raw `hcloud configure show`.

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

@@ -3,6 +3,7 @@ import { stdin, stdout } from 'node:process';
 import { TOOL_DEFINITIONS, callTool } from './tools.mjs';
 
 let buffer = Buffer.alloc(0);
+let useContentLengthFraming = true;
 
 stdin.on('data', (chunk) => {
   buffer = Buffer.concat([buffer, chunk]);
@@ -12,23 +13,43 @@ stdin.on('data', (chunk) => {
 function readFrames() {
   while (true) {
     const headerEnd = buffer.indexOf('\r\n\r\n');
-    if (headerEnd === -1) return;
-    const header = buffer.subarray(0, headerEnd).toString('utf8');
-    const match = header.match(/Content-Length:\s*(\d+)/i);
-    if (!match) {
-      buffer = Buffer.alloc(0);
-      return;
+    if (headerEnd !== -1) {
+      useContentLengthFraming = true;
+      const consumed = parseContentLengthFrame(headerEnd);
+      if (!consumed) return;
+      continue;
     }
-    const length = Number(match[1]);
-    const bodyStart = headerEnd + 4;
-    const bodyEnd = bodyStart + length;
-    if (buffer.length < bodyEnd) return;
-    const body = buffer.subarray(bodyStart, bodyEnd).toString('utf8');
-    buffer = buffer.subarray(bodyEnd);
-    void handleMessage(JSON.parse(body));
+
+    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;
@@ -89,5 +110,9 @@ async function dispatch(method, params) {
 
 function writeMessage(message) {
   const json = JSON.stringify(message);
-  stdout.write(`Content-Length: ${Buffer.byteLength(json, 'utf8')}\r\n\r\n${json}`);
+  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/risk-rule-engine.mjs

@@ -0,0 +1,137 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const defaultRulesPath = join(__dirname, '..', 'safety', 'rules', 'cloud-risk-rules.json');
+
+const SEVERITY_RANK = {
+  deny: 3,
+  warn: 2,
+  info: 1,
+};
+
+export function loadRiskRules(options = {}) {
+  const path = options.path || defaultRulesPath;
+  return JSON.parse(readFileSync(path, 'utf8'));
+}
+
+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(/(AK|SK)\s*[:=]\s*("[^"]*"|'[^']*'|[^\s,;]+)/g, '$1=<redacted>');
+}
+
+function normalizeText(value) {
+  if (typeof value === 'string') return value;
+  return JSON.stringify(value, null, 2);
+}
+
+function evaluationContext(stage, input) {
+  if (stage === 'command') {
+    const command = normalizeText(input.command || input.text || '');
+    return { text: command, command };
+  }
+  if (stage === 'artifact') {
+    const path = String(input.path || '');
+    const content = normalizeText(input.content || '');
+    return { text: `${path}\n${content}`, path, content };
+  }
+  if (stage === 'deploy_plan') {
+    const plan = normalizeText(input.plan || input.text || input);
+    return { text: plan, plan };
+  }
+  return { text: normalizeText(input) };
+}
+
+function conditionMatches(condition, context) {
+  const field = condition.field || 'text';
+  const value = Object.hasOwn(context, field) ? context[field] : context.text;
+  return new RegExp(condition.regex, 'ims').test(String(value || ''));
+}
+
+function ruleMatches(rule, context) {
+  const match = rule.match || {};
+  const all = match.all;
+  const any = match.any;
+  const none = match.none;
+  if (Array.isArray(all) && !all.every((condition) => conditionMatches(condition, context))) {
+    return false;
+  }
+  if (Array.isArray(any) && !any.some((condition) => conditionMatches(condition, context))) {
+    return false;
+  }
+  if (Array.isArray(none) && none.some((condition) => conditionMatches(condition, context))) {
+    return false;
+  }
+  return Array.isArray(all) || Array.isArray(any);
+}
+
+function excerpt(text) {
+  const compact = redactEvidence(String(text).replace(/\s+/g, ' ').trim());
+  if (compact.length <= 240) return compact;
+  return `${compact.slice(0, 237)}...`;
+}
+
+function evaluate(stage, inputs, options = {}) {
+  const catalog = options.catalog || loadRiskRules(options);
+  const items = Array.isArray(inputs) ? inputs : [inputs];
+  const findings = [];
+
+  for (const input of items) {
+    const context = evaluationContext(stage, input || {});
+    for (const rule of catalog.rules) {
+      if (!rule.stages.includes(stage)) continue;
+      if (!ruleMatches(rule, context)) continue;
+      findings.push({
+        ruleId: rule.id,
+        title: rule.title,
+        category: rule.category,
+        severity: rule.severity,
+        message: rule.message,
+        remediation: rule.remediation,
+        source: input?.path || stage,
+        evidence: excerpt(context.text),
+      });
+    }
+  }
+
+  findings.sort((a, b) => SEVERITY_RANK[b.severity] - SEVERITY_RANK[a.severity]);
+  const hasDeny = findings.some((finding) => finding.severity === 'deny');
+  const hasWarn = findings.some((finding) => finding.severity === 'warn');
+  return {
+    decision: hasDeny ? 'deny' : hasWarn ? 'warn' : 'allow',
+    findings,
+  };
+}
+
+export function evaluateCommandRisk(command, options = {}) {
+  return evaluate('command', { command }, options);
+}
+
+export function evaluateArtifacts(artifacts, options = {}) {
+  return evaluate('artifact', Array.isArray(artifacts) ? artifacts : [], options);
+}
+
+export function evaluateDeployPlan(plan, options = {}) {
+  return evaluate('deploy_plan', { plan }, options);
+}
+
+export function mergeRiskDecision(base, risk) {
+  if (!risk || !risk.findings?.length) return base;
+  if (risk.decision === 'deny') {
+    const topFinding = risk.findings[0];
+    return {
+      ...base,
+      decision: 'deny',
+      risk: topFinding.category,
+      reason: topFinding.message,
+      blockedByRiskRule: true,
+      findings: risk.findings,
+    };
+  }
+  return {
+    ...base,
+    warnings: [...(base.warnings || []), ...risk.findings],
+  };
+}

package/plugins/huaweicloud-core/src/safety-policy.mjs

@@ -1,6 +1,7 @@
 import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { evaluateCommandRisk, mergeRiskDecision } from './risk-rule-engine.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const policyPath = join(__dirname, '..', 'safety', 'policy.json');
@@ -92,6 +93,18 @@ function isLocalMetadataCommand(args) {
   return args.some((arg) => /^(--help|-h|help|version|--version)$/i.test(String(arg)));
 }
 
+function commandRiskText(normalizedArgs, options = {}) {
+  return options.rawCommand || ['hcloud', ...normalizedArgs].join(' ');
+}
+
+function applyCommandRiskRules(base, normalizedArgs, options = {}) {
+  if (base.decision === 'deny' || options.skipRiskRules === true) {
+    return base;
+  }
+  const risk = evaluateCommandRisk(commandRiskText(normalizedArgs, options));
+  return mergeRiskDecision(base, risk);
+}
+
 export function classifyHcloudArgs(args, options = {}) {
   const policy = options.policy || DEFAULT_POLICY;
   const { service, operation, args: normalizedArgs } = commandOperation(args);
@@ -106,14 +119,14 @@ export function classifyHcloudArgs(args, options = {}) {
   }
 
   if (isLocalMetadataCommand(normalizedArgs)) {
-    return {
+    return applyCommandRiskRules({
       decision: 'allow',
       risk: 'local_metadata',
       reason: 'KooCLI local help and version commands are read-only and do not call Huawei Cloud resource APIs.',
       service,
       operation,
       args: normalizedArgs,
-    };
+    }, normalizedArgs, options);
   }
 
   if (service.toLowerCase() === 'configure') {
@@ -180,49 +193,49 @@ export function classifyHcloudArgs(args, options = {}) {
     };
   }
   if (isObsRead) {
-    return {
+    return applyCommandRiskRules({
       decision: 'allow',
       risk: 'read_only',
       reason: 'OBS read-only operation.',
       service,
       operation,
       args: normalizedArgs,
-    };
+    }, normalizedArgs, options);
   }
   if (isObsWrite && options.allowWrites) {
-    return {
+    return applyCommandRiskRules({
       decision: 'allow',
       risk: 'write',
       reason: 'OBS write operation approved by user.',
       service,
       operation,
       args: normalizedArgs,
-    };
+    }, normalizedArgs, options);
   }
 
   if (isExecution && options.allowWrites) {
-    return {
+    return applyCommandRiskRules({
       decision: 'allow',
       risk: 'execution',
       reason: 'Huawei Cloud execution/trigger operation approved by user.',
       service,
       operation,
       args: normalizedArgs,
-    };
+    }, normalizedArgs, options);
   }
 
   if (isWrite && options.allowWrites) {
-    return {
+    return applyCommandRiskRules({
       decision: 'allow',
       risk: 'write',
       reason: 'Huawei Cloud write operation approved by user.',
       service,
       operation,
       args: normalizedArgs,
-    };
+    }, normalizedArgs, options);
   }
 
-  return {
+  return applyCommandRiskRules({
     decision: 'allow',
     risk: readOnly ? 'read_only' : 'unknown_read',
     reason: readOnly
@@ -231,7 +244,7 @@ export function classifyHcloudArgs(args, options = {}) {
     service,
     operation,
     args: normalizedArgs,
-  };
+  }, normalizedArgs, options);
 }
 
 function splitSimpleCommand(command) {
@@ -261,7 +274,7 @@ export function classifyTextCommand(command, options = {}) {
   }
 
   if (/(^|\s)hcloud(\.exe)?\s+/i.test(text)) {
-    return classifyHcloudArgs(splitSimpleCommand(text), options);
+    return classifyHcloudArgs(splitSimpleCommand(text), { ...options, rawCommand: text });
   }
 
   if (/ShowSecretVersion|GetSecretValue|secret_string|secret_binary/i.test(text)) {