@kenhkl/agent-moss 0.8.0 → 0.8.1

package/dist/cli.js

@@ -2307,6 +2307,7 @@ var init_token_stats = __esm({
 });
 
 // src/engine/llm-analyzer.ts
+import { appendFileSync } from "fs";
 import OpenAI from "openai";
 async function runLLMAnalysis(input, previous) {
   if (!isLLMAvailable()) {
@@ -2340,6 +2341,7 @@ async function runLLMAnalysis(input, previous) {
     scriptAnalysis = analyzeScriptContent(input.aNext.actionType, input.aNext.actionDetail);
   }
   const prompt = buildPrompt(input, previous, matchedSkills, templates, scriptAnalysis, previous.skipL3Hints ?? "", scriptChainText);
+  logPrompt(prompt, input.aNext, previous.llmLogPath);
   const result = await analyzeWithLLM(prompt, config);
   if (llmCache.size >= LLM_CACHE_MAX) {
     const firstKey = llmCache.keys().next().value;
@@ -2348,6 +2350,20 @@ async function runLLMAnalysis(input, previous) {
   llmCache.set(cacheKey, result);
   return result;
 }
+function logPrompt(prompt, aNext, logPath) {
+  if (!logPath) return;
+  try {
+    const actionType = aNext.actionType || "unknown";
+    const actionDetail = (aNext.actionDetail || "").slice(0, 100);
+    const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [LLM_PROMPT] action_type=${actionType}, action_detail=${actionDetail}... prompt_length=${prompt.length}
+${prompt}
+--- END PROMPT ---
+`;
+    appendFileSync(logPath, line, "utf-8");
+  } catch (e) {
+    console.warn("[AgentMoss] Failed to write LLM prompt to log:", e);
+  }
+}
 function buildPrompt(input, previous, matchedSkills, templates, scriptAnalysis, skipL3Hints = "", scriptChainText = "") {
   const skillsText = formatSkillsForPrompt(matchedSkills);
   const historyStr = input.actionHistory.map((h, i) => `${i + 1}. ${h.actionType}: ${h.actionDetail}`).join("\n") || "(\u65E0\u5386\u53F2\u64CD\u4F5C)";
@@ -2508,18 +2524,44 @@ var init_llm_analyzer = __esm({
 var runtime_config_exports = {};
 __export(runtime_config_exports, {
   DENY_MODE_LABELS: () => DENY_MODE_LABELS,
+  addCustomRule: () => addCustomRule,
+  addCustomSkill: () => addCustomSkill,
+  deleteCustomRule: () => deleteCustomRule,
+  deleteCustomSkill: () => deleteCustomSkill,
   filterEnabledRules: () => filterEnabledRules,
+  generateSourceDefaults: () => generateSourceDefaults,
   getDisabledL2RulesWithSkipL3: () => getDisabledL2RulesWithSkipL3,
+  getDisabledSkillIds: () => getDisabledSkillIds,
   getEnabledL1CommandPatterns: () => getEnabledL1CommandPatterns,
+  getEnabledL1CommandPatternsOrDefault: () => getEnabledL1CommandPatternsOrDefault,
+  getEnabledL1InjectionKeywords: () => getEnabledL1InjectionKeywords,
+  getEnabledL1InjectionKeywordsOrDefault: () => getEnabledL1InjectionKeywordsOrDefault,
+  getEnabledL2IntentPatterns: () => getEnabledL2IntentPatterns,
+  getEnabledL2IntentPatternsOrDefault: () => getEnabledL2IntentPatternsOrDefault,
+  getEnabledL2PasswordPatterns: () => getEnabledL2PasswordPatterns,
+  getEnabledL2PasswordPatternsOrDefault: () => getEnabledL2PasswordPatternsOrDefault,
   getEnabledL2SensitivePaths: () => getEnabledL2SensitivePaths,
+  getEnabledL2SensitivePathsOrDefault: () => getEnabledL2SensitivePathsOrDefault,
+  getEnabledL2UserDeletionPatterns: () => getEnabledL2UserDeletionPatterns,
+  getEnabledL2UserDeletionPatternsOrDefault: () => getEnabledL2UserDeletionPatternsOrDefault,
   getEnvOverrides: () => getEnvOverrides,
+  getProfileOrDetect: () => getProfileOrDetect,
   getRuntimeConfigPath: () => getRuntimeConfigPath,
   hasRuntimeConfig: () => hasRuntimeConfig,
+  isL2CategoryEnabled: () => isL2CategoryEnabled,
   isLayerEnabled: () => isLayerEnabled,
   loadRuntimeConfig: () => loadRuntimeConfig,
-  saveRuntimeConfig: () => saveRuntimeConfig
+  mergeConfig: () => mergeConfig,
+  saveRuntimeConfig: () => saveRuntimeConfig,
+  updateCategoryEnabled: () => updateCategoryEnabled,
+  updateLayerEnabled: () => updateLayerEnabled,
+  updateRuleDenyMode: () => updateRuleDenyMode,
+  updateRuleEnabled: () => updateRuleEnabled,
+  updateRuleSkipL3: () => updateRuleSkipL3,
+  updateSkillCategoryEnabled: () => updateSkillCategoryEnabled,
+  updateSkillEnabled: () => updateSkillEnabled
 });
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync2, existsSync as existsSync7, mkdirSync as mkdirSync2 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync2, existsSync as existsSync7, mkdirSync as mkdirSync2, unlinkSync as unlinkSync2 } from "fs";
 import { join as join4 } from "path";
 import { homedir as homedir3 } from "os";
 function getRuntimeConfigPath() {
@@ -2544,9 +2586,17 @@ function emptyRuntimeConfig() {
 }
 function loadRuntimeConfig() {
   const p = getRuntimeConfigPath();
-  if (!existsSync7(p)) return emptyRuntimeConfig();
+  if (!existsSync7(p)) {
+    const seeded = mergeConfig({}, generateSourceDefaults());
+    try {
+      saveRuntimeConfig(seeded);
+    } catch {
+    }
+    return seeded;
+  }
   try {
     const data = JSON.parse(readFileSync7(p, "utf-8"));
+    const merged = mergeConfig(data, generateSourceDefaults());
     return {
       version: data.version || 1,
       layers: {
@@ -2554,9 +2604,9 @@ function loadRuntimeConfig() {
         L2_logic_rules: data.layers?.L2_logic_rules ?? true,
         L3_llm_analysis: data.layers?.L3_llm_analysis ?? true
       },
-      L1_rules: data.L1_rules || {},
-      L2_rules: data.L2_rules || {},
-      L3_skills: data.L3_skills || {}
+      L1_rules: merged.L1_rules || {},
+      L2_rules: merged.L2_rules || {},
+      L3_skills: merged.L3_skills || {}
     };
   } catch {
     return emptyRuntimeConfig();
@@ -2644,11 +2694,508 @@ function getDisabledL2RulesWithSkipL3() {
   }
   return result;
 }
-var RUNTIME_CONFIG_DIR, RUNTIME_CONFIG_PATH, ENV_RUNTIME_CONFIG_PATH, LAYER_DISABLE_ENV, DENY_MODE_LABELS;
+function _slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "") || "x";
+}
+function _generatePatternId(pattern) {
+  return `pat_${_slugify(pattern)}`;
+}
+function _deriveDenyMode(rule) {
+  if (rule.deny_mode) return rule.deny_mode;
+  if (rule.credential) return "deny_both";
+  if (rule.read_only) return "deny_read";
+  return "deny_write";
+}
+function _syncDenyModeFields(rule) {
+  const dm = rule.deny_mode || "deny_write";
+  if (dm === "deny_both") {
+    rule.credential = true;
+    delete rule.read_only;
+  } else if (dm === "deny_read") {
+    delete rule.credential;
+    rule.read_only = true;
+  } else {
+    delete rule.credential;
+    delete rule.read_only;
+  }
+}
+function _l1CommandPatternsToRules() {
+  return DANGEROUS_PATTERNS.map((p) => ({
+    id: _generatePatternId(p.pattern instanceof RegExp ? p.pattern.source : p.pattern),
+    pattern: p.pattern instanceof RegExp ? p.pattern.source : p.pattern,
+    risk_level: p.severity,
+    risk_type: p.riskType,
+    reason: p.description,
+    enabled: true,
+    builtin: true
+  }));
+}
+function _l1InjectionKeywordsToRules() {
+  return INJECTION_KEYWORDS.map((kw) => ({
+    id: `inj_${_slugify(kw.keyword)}`,
+    keyword: kw.keyword,
+    risk_level: kw.riskLevel,
+    lang: kw.lang || "en",
+    enabled: true,
+    builtin: true
+  }));
+}
+function _l2SensitivePathsToRules() {
+  const all = [...ROOT_SENSITIVE_PATHS, ...HOME_SENSITIVE_PATHS, ...CREDENTIAL_PATHS];
+  return all.map((sp) => {
+    const denyMode = _deriveDenyMode({
+      deny_mode: sp.deny_mode,
+      credential: sp.credential,
+      read_only: sp.read_only
+    });
+    const rule = {
+      id: `path_${_slugify(sp.path)}`,
+      path: sp.path,
+      risk_level: sp.riskLevel,
+      desc: sp.desc,
+      deny_mode: denyMode,
+      source_deny_mode: denyMode,
+      skip_l3_on_disabled: true,
+      enabled: true,
+      builtin: true
+    };
+    _syncDenyModeFields(rule);
+    return rule;
+  });
+}
+function _l2IntentPatternsToRules() {
+  return INTENT_DEVIATION_PATTERNS.map((pat, i) => ({
+    id: `intent_${i + 1}_${_slugify(pat.reason.slice(0, 30))}`,
+    intent_keywords: pat.intentKeywords,
+    dangerous_actions: pat.dangerousActions,
+    reason: pat.reason,
+    skip_l3_on_disabled: true,
+    enabled: true,
+    builtin: true
+  }));
+}
+function _l2PasswordPatternsToRules() {
+  return PASSWORD_MODIFY_PATTERNS.map((p) => ({
+    id: `pw_${_slugify(p.source)}`,
+    pattern: p.source,
+    skip_l3_on_disabled: true,
+    enabled: true,
+    builtin: true
+  }));
+}
+function _l2UserDeletionPatternsToRules() {
+  return USER_DELETION_PATTERNS.map((p) => ({
+    id: `ud_${_slugify(p.source)}`,
+    pattern: p.source,
+    skip_l3_on_disabled: true,
+    enabled: true,
+    builtin: true
+  }));
+}
+function _l3SkillsToRules() {
+  const skillCategories = {
+    file_operations: ["file_access_guard", "script_execution_guard", "indirect_access_guard"],
+    network_security: [
+      "data_exfiltration_guard",
+      "browser_web_access_guard",
+      "lateral_movement_guard",
+      "email_operation_guard"
+    ],
+    persistence_supply_chain: [
+      "persistence_backdoor_guard",
+      "supply_chain_guard",
+      "skill_installation_guard"
+    ],
+    intent_and_general: ["intent_deviation_guard", "general_tool_risk_guard"],
+    resource: ["resource_exhaustion_guard"]
+  };
+  const out = {};
+  for (const [cat, ids] of Object.entries(skillCategories)) {
+    out[cat] = {
+      category_enabled: true,
+      category_desc: "",
+      skills: ids.map((s) => ({
+        id: s,
+        keywords: SKILL_KEYWORD_MAP[s] || [],
+        enabled: true,
+        builtin: true
+      }))
+    };
+  }
+  const categorized = new Set(Object.values(skillCategories).flat());
+  for (const s of Object.keys(SKILL_KEYWORD_MAP)) {
+    if (!categorized.has(s)) {
+      (out.intent_and_general ??= { category_enabled: true, category_desc: "", skills: [] }).skills.push({
+        id: s,
+        keywords: SKILL_KEYWORD_MAP[s],
+        enabled: true,
+        builtin: true
+      });
+    }
+  }
+  out.user_custom = { category_enabled: true, category_desc: "", skills: [] };
+  return out;
+}
+function generateSourceDefaults() {
+  return {
+    version: 1,
+    layers: { L1_heuristic: true, L2_logic_rules: true, L3_llm_analysis: true },
+    L1_rules: {
+      dangerous_commands: {
+        category_enabled: true,
+        category_desc: "\u5371\u9669\u547D\u4EE4\u68C0\u6D4B\uFF08\u9012\u5F52\u5220\u9664\u3001\u5168\u6743\u9650\u8BBE\u7F6E\u3001\u63D0\u6743\u6267\u884C\u7B49\uFF09",
+        rules: _l1CommandPatternsToRules()
+      },
+      injection_detection: {
+        category_enabled: true,
+        category_desc: "Prompt \u6CE8\u5165\u653B\u51FB\u68C0\u6D4B",
+        rules: _l1InjectionKeywordsToRules()
+      },
+      user_sensitive_actions: { category_enabled: true, category_desc: "\u7528\u6237\u81EA\u5B9A\u4E49\u654F\u611F\u52A8\u4F5C/\u5DE5\u5177\u89C4\u5219", rules: [] },
+      user_custom: { category_enabled: true, category_desc: "\u7528\u6237\u81EA\u5B9A\u4E49\u547D\u4EE4\u89C4\u5219", rules: [] }
+    },
+    L2_rules: {
+      sensitive_path_access: {
+        category_enabled: true,
+        category_desc: "\u654F\u611F\u8DEF\u5F84\u8BBF\u95EE\u68C0\u6D4B",
+        rules: _l2SensitivePathsToRules()
+      },
+      intent_consistency: {
+        category_enabled: true,
+        category_desc: "\u610F\u56FE\u4E00\u81F4\u6027\u68C0\u6D4B",
+        rules: _l2IntentPatternsToRules()
+      },
+      password_modify_consent: {
+        category_enabled: true,
+        category_desc: "\u975E\u4EA4\u4E92\u5F0F\u5BC6\u7801\u4FEE\u6539\u6388\u6743\u68C0\u6D4B",
+        rules: _l2PasswordPatternsToRules()
+      },
+      user_deletion_consent: {
+        category_enabled: true,
+        category_desc: "\u7528\u6237/\u7EC4\u5220\u9664\u64CD\u4F5C\u6388\u6743\u68C0\u6D4B",
+        rules: _l2UserDeletionPatternsToRules()
+      },
+      read_before_write: { category_enabled: true, category_desc: "read_before_write \u5B89\u5168\u539F\u5219\u68C0\u6D4B", rules: [] },
+      dangerous_patterns: { category_enabled: true, category_desc: "\u5371\u9669\u64CD\u4F5C\u6A21\u5F0F\u68C0\u6D4B", rules: [] }
+    },
+    L3_skills: _l3SkillsToRules()
+  };
+}
+function _ruleFingerprint(rule) {
+  if (rule.intent_keywords && rule.intent_keywords.length || rule.dangerous_actions && rule.dangerous_actions.length) {
+    return JSON.stringify([
+      [...rule.intent_keywords || []].sort(),
+      [...rule.dangerous_actions || []].sort()
+    ]);
+  }
+  if (rule.path) return JSON.stringify([rule.path]);
+  if (rule.pattern) return JSON.stringify([rule.pattern]);
+  if (rule.keyword) return JSON.stringify([rule.keyword, rule.lang || ""]);
+  return JSON.stringify([rule.id || ""]);
+}
+function _mergeRuleCategories(userCfg, srcDefaults, layerKey) {
+  const userLayer = userCfg[layerKey] || (userCfg[layerKey] = {});
+  const srcLayer = srcDefaults[layerKey] || {};
+  for (const [catName, srcCat] of Object.entries(srcLayer)) {
+    if (!(catName in userLayer)) {
+      userLayer[catName] = srcCat;
+      continue;
+    }
+    const userCat = userLayer[catName];
+    if (userCat.category_desc === void 0) userCat.category_desc = srcCat.category_desc || "";
+    if (userCat.category_enabled === void 0) userCat.category_enabled = srcCat.category_enabled ?? true;
+    const srcRules = srcCat.rules || [];
+    const userRules = userCat.rules || (userCat.rules = []);
+    const userByFp = /* @__PURE__ */ new Map();
+    for (const r of userRules) userByFp.set(_ruleFingerprint(r), r);
+    const srcFps = /* @__PURE__ */ new Set();
+    for (const srcR of srcRules) {
+      const fp = _ruleFingerprint(srcR);
+      srcFps.add(fp);
+      if (userByFp.has(fp)) {
+        const existing = userByFp.get(fp);
+        const userEnabled = existing.enabled;
+        const userSkipL3 = existing.skip_l3_on_disabled;
+        const userDenyMode = existing.deny_mode;
+        const userSourceDeny = existing.source_deny_mode;
+        Object.keys(existing).forEach((k) => delete existing[k]);
+        Object.assign(existing, srcR);
+        existing.enabled = userEnabled;
+        if (userSkipL3 !== void 0) existing.skip_l3_on_disabled = userSkipL3;
+        if (userDenyMode && userSourceDeny && userDenyMode !== userSourceDeny) {
+          existing.deny_mode = userDenyMode;
+        }
+        if (existing.deny_mode) _syncDenyModeFields(existing);
+      } else {
+        const newR = { ...srcR, enabled: true };
+        userRules.push(newR);
+      }
+    }
+    for (const r of userRules) {
+      if (r.builtin && !srcFps.has(_ruleFingerprint(r))) {
+        r.source_removed = true;
+        r.enabled = false;
+      }
+    }
+    if (catName === "sensitive_path_access") {
+      for (const r of userRules) {
+        if (!r.deny_mode) r.deny_mode = _deriveDenyMode(r);
+        _syncDenyModeFields(r);
+      }
+    }
+  }
+}
+function _mergeSkillCategories(userCfg, srcDefaults, layerKey) {
+  const userLayer = userCfg[layerKey] || (userCfg[layerKey] = {});
+  const srcLayer = srcDefaults[layerKey] || {};
+  for (const [catName, srcCat] of Object.entries(srcLayer)) {
+    if (!(catName in userLayer)) {
+      userLayer[catName] = srcCat;
+      continue;
+    }
+    const userCat = userLayer[catName];
+    if (userCat.category_desc === void 0) userCat.category_desc = srcCat.category_desc || "";
+    if (userCat.category_enabled === void 0) userCat.category_enabled = srcCat.category_enabled ?? true;
+    const userSkills = userCat.skills || (userCat.skills = []);
+    const existingIds = new Set(userSkills.map((s) => s.id));
+    for (const srcS of srcCat.skills || []) {
+      if (!existingIds.has(srcS.id)) userSkills.push({ ...srcS });
+    }
+  }
+}
+function mergeConfig(userCfg, srcDefaults) {
+  const cfg = userCfg;
+  if (cfg.version === void 0) cfg.version = srcDefaults.version || 1;
+  if (!cfg.layers) cfg.layers = {};
+  for (const [layerKey, defaultVal] of Object.entries(srcDefaults.layers)) {
+    if (!(layerKey in cfg.layers)) cfg.layers[layerKey] = defaultVal;
+  }
+  _mergeRuleCategories(cfg, srcDefaults, "L1_rules");
+  _mergeRuleCategories(cfg, srcDefaults, "L2_rules");
+  _mergeSkillCategories(cfg, srcDefaults, "L3_skills");
+  return cfg;
+}
+function getEnabledL1InjectionKeywords(runtime) {
+  const cat = runtime.L1_rules?.injection_detection || { category_enabled: true, rules: [] };
+  return filterEnabledRules(cat.rules || [], cat.category_enabled).map((r) => ({
+    keyword: r.keyword || "",
+    risk_level: r.risk_level || "",
+    lang: r.lang || "en"
+  }));
+}
+function getEnabledL2IntentPatterns(runtime) {
+  const cat = runtime.L2_rules?.intent_consistency || { category_enabled: true, rules: [] };
+  return filterEnabledRules(cat.rules || [], cat.category_enabled).map((r) => ({
+    intent_keywords: r.intent_keywords || [],
+    dangerous_actions: r.dangerous_actions || [],
+    reason: r.reason || ""
+  }));
+}
+function getEnabledL2PasswordPatterns(runtime) {
+  const cat = runtime.L2_rules?.password_modify_consent || { category_enabled: true, rules: [] };
+  return filterEnabledRules(cat.rules || [], cat.category_enabled).map((r) => r.pattern || "");
+}
+function getEnabledL2UserDeletionPatterns(runtime) {
+  const cat = runtime.L2_rules?.user_deletion_consent || { category_enabled: true, rules: [] };
+  return filterEnabledRules(cat.rules || [], cat.category_enabled).map((r) => r.pattern || "");
+}
+function isL2CategoryEnabled(runtime, categoryKey) {
+  const cat = runtime.L2_rules?.[categoryKey];
+  return cat?.category_enabled ?? true;
+}
+function getDisabledSkillIds(runtime) {
+  const disabled = /* @__PURE__ */ new Set();
+  for (const catData of Object.values(runtime.L3_skills || {})) {
+    if (!catData.category_enabled) {
+      for (const s of catData.skills || []) disabled.add(s.id);
+    } else {
+      for (const s of catData.skills || []) {
+        if (s.enabled === false) disabled.add(s.id);
+      }
+    }
+  }
+  return disabled;
+}
+function getEnabledL1CommandPatternsOrDefault(runtime) {
+  const enabled = getEnabledL1CommandPatterns(runtime);
+  if (enabled.length) return enabled;
+  if (!hasRuntimeConfig()) return _l1CommandPatternsToRules();
+  return [];
+}
+function getEnabledL1InjectionKeywordsOrDefault(runtime) {
+  const enabled = getEnabledL1InjectionKeywords(runtime);
+  if (enabled.length) return enabled;
+  if (!hasRuntimeConfig()) return _l1InjectionKeywordsToRules();
+  return [];
+}
+function getEnabledL2SensitivePathsOrDefault(runtime) {
+  const enabled = getEnabledL2SensitivePaths(runtime);
+  if (enabled.length) return enabled;
+  if (!hasRuntimeConfig()) return _l2SensitivePathsToRules();
+  return [];
+}
+function getEnabledL2IntentPatternsOrDefault(runtime) {
+  const enabled = getEnabledL2IntentPatterns(runtime);
+  if (enabled.length) return enabled;
+  if (!hasRuntimeConfig()) return _l2IntentPatternsToRules();
+  return [];
+}
+function getEnabledL2PasswordPatternsOrDefault(runtime) {
+  const enabled = getEnabledL2PasswordPatterns(runtime);
+  if (enabled.length) return enabled;
+  if (!hasRuntimeConfig()) {
+    return PASSWORD_MODIFY_PATTERNS.map((p) => p.source);
+  }
+  return [];
+}
+function getEnabledL2UserDeletionPatternsOrDefault(runtime) {
+  const enabled = getEnabledL2UserDeletionPatterns(runtime);
+  if (enabled.length) return enabled;
+  if (!hasRuntimeConfig()) {
+    return USER_DELETION_PATTERNS.map((p) => p.source);
+  }
+  return [];
+}
+function _validateSkillId(skillId) {
+  if (!skillId || !SKILL_ID_RE.test(skillId)) {
+    throw new Error(`skill_id '${skillId}' \u4E0D\u5408\u6CD5\uFF1A\u53EA\u5141\u8BB8\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u4E0B\u5212\u7EBF\u548C\u8FDE\u5B57\u7B26`);
+  }
+}
+function updateLayerEnabled(layerKey, enabled) {
+  const runtime = loadRuntimeConfig();
+  runtime.layers[layerKey] = enabled;
+  saveRuntimeConfig(runtime);
+  return runtime;
+}
+function updateRuleEnabled(layer, category, ruleId, enabled) {
+  const runtime = loadRuntimeConfig();
+  for (const r of runtime[layer]?.[category]?.rules || []) {
+    if (r.id === ruleId) {
+      r.enabled = enabled;
+      break;
+    }
+  }
+  saveRuntimeConfig(runtime);
+  return runtime;
+}
+function updateRuleDenyMode(layer, category, ruleId, denyMode) {
+  const runtime = loadRuntimeConfig();
+  for (const r of runtime[layer]?.[category]?.rules || []) {
+    if (r.id === ruleId) {
+      r.deny_mode = denyMode;
+      _syncDenyModeFields(r);
+      break;
+    }
+  }
+  saveRuntimeConfig(runtime);
+  return runtime;
+}
+function updateRuleSkipL3(layer, category, ruleId, skipL3) {
+  const runtime = loadRuntimeConfig();
+  for (const r of runtime[layer]?.[category]?.rules || []) {
+    if (r.id === ruleId) {
+      r.skip_l3_on_disabled = skipL3;
+      break;
+    }
+  }
+  saveRuntimeConfig(runtime);
+  return runtime;
+}
+function updateCategoryEnabled(layer, category, enabled) {
+  const runtime = loadRuntimeConfig();
+  const cat = runtime[layer]?.[category];
+  if (cat) cat.category_enabled = enabled;
+  saveRuntimeConfig(runtime);
+  return runtime;
+}
+function addCustomRule(layer, category, rule) {
+  const runtime = loadRuntimeConfig();
+  const layerObj = runtime[layer] || (runtime[layer] = {});
+  const cat = layerObj[category] || (layerObj[category] = { category_enabled: true, category_desc: "", rules: [] });
+  const rules = cat.rules || (cat.rules = []);
+  const newRule = { ...rule, builtin: false, enabled: true };
+  if (!newRule.id) {
+    newRule.id = `custom_${Date.now()}_${_slugify(JSON.stringify(rule).slice(0, 30))}`;
+  }
+  if (newRule.deny_mode) _syncDenyModeFields(newRule);
+  rules.push(newRule);
+  saveRuntimeConfig(runtime);
+  return runtime;
+}
+function deleteCustomRule(layer, category, ruleId) {
+  const runtime = loadRuntimeConfig();
+  const rules = runtime[layer]?.[category]?.rules || [];
+  const idx = rules.findIndex((r) => r.id === ruleId);
+  if (idx >= 0) {
+    if (rules[idx].builtin) return null;
+    rules.splice(idx, 1);
+    saveRuntimeConfig(runtime);
+  }
+  return runtime;
+}
+function addCustomSkill(skillId, category, keywords, content) {
+  _validateSkillId(skillId);
+  const runtime = loadRuntimeConfig();
+  const skillsDir = join4(RUNTIME_CONFIG_DIR, "agent_moss_skills");
+  try {
+    mkdirSync2(skillsDir, { recursive: true });
+  } catch {
+  }
+  writeFileSync2(join4(skillsDir, `${skillId}.md`), content, "utf-8");
+  const l3 = runtime.L3_skills || (runtime.L3_skills = {});
+  const cat = l3[category] || (l3[category] = { category_enabled: true, category_desc: "", skills: [] });
+  (cat.skills || (cat.skills = [])).push({ id: skillId, keywords, enabled: true, builtin: false });
+  saveRuntimeConfig(runtime);
+  return runtime;
+}
+function deleteCustomSkill(skillId, category) {
+  _validateSkillId(skillId);
+  const runtime = loadRuntimeConfig();
+  const skills = runtime.L3_skills?.[category]?.skills || [];
+  const idx = skills.findIndex((s) => s.id === skillId);
+  if (idx >= 0) {
+    if (skills[idx].builtin) return null;
+    skills.splice(idx, 1);
+    const skillPath = join4(RUNTIME_CONFIG_DIR, "agent_moss_skills", `${skillId}.md`);
+    try {
+      if (existsSync7(skillPath)) unlinkSync2(skillPath);
+    } catch {
+    }
+    saveRuntimeConfig(runtime);
+  }
+  return runtime;
+}
+function updateSkillEnabled(skillId, enabled) {
+  const runtime = loadRuntimeConfig();
+  for (const catData of Object.values(runtime.L3_skills || {})) {
+    for (const s of catData.skills || []) {
+      if (s.id === skillId) {
+        s.enabled = enabled;
+        break;
+      }
+    }
+  }
+  saveRuntimeConfig(runtime);
+  return runtime;
+}
+function updateSkillCategoryEnabled(category, enabled) {
+  const runtime = loadRuntimeConfig();
+  const cat = runtime.L3_skills?.[category];
+  if (cat) cat.category_enabled = enabled;
+  saveRuntimeConfig(runtime);
+  return runtime;
+}
+function getProfileOrDetect() {
+  return null;
+}
+var RUNTIME_CONFIG_DIR, RUNTIME_CONFIG_PATH, ENV_RUNTIME_CONFIG_PATH, LAYER_DISABLE_ENV, DENY_MODE_LABELS, SKILL_ID_RE;
 var init_runtime_config = __esm({
   "src/infra/runtime-config.ts"() {
     "use strict";
     init_esm_shims();
+    init_heuristic();
+    init_logic_rules();
+    init_skill_loader();
     RUNTIME_CONFIG_DIR = join4(homedir3(), ".config", "agentmoss");
     RUNTIME_CONFIG_PATH = join4(RUNTIME_CONFIG_DIR, "agent_moss_runtime.json");
     ENV_RUNTIME_CONFIG_PATH = "AGENT_MOSS_RUNTIME_CONFIG_PATH";
@@ -2662,6 +3209,7 @@ var init_runtime_config = __esm({
       deny_read: "\u4EC5\u62E6\u622A\u8BFB\u53D6",
       deny_both: "\u8BFB\u5199\u5747\u62E6\u622A"
     };
+    SKILL_ID_RE = /^[A-Za-z0-9_-]+$/;
   }
 });
 
@@ -2862,7 +3410,8 @@ async function runAnalysis(input) {
       heuristic: heuristicResult,
       logic: logicResult,
       skipL3Hints,
-      scriptChain: scriptChain ?? void 0
+      scriptChain: scriptChain ?? void 0,
+      llmLogPath: input.llmLogPath
     });
   } catch (e) {
     const { getLLMFailMode: getLLMFailMode2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -2976,9 +3525,10 @@ init_esm_shims();
 
 // src/server.ts
 init_esm_shims();
-import { Hono } from "hono";
+import { Hono as Hono2 } from "hono";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
+import net from "net";
 
 // src/routes.ts
 init_esm_shims();
@@ -3158,7 +3708,8 @@ async function analyzeRoute(c) {
       osType,
       cwd: req.cwd,
       agentId: req.agent_id,
-      llmConfig: req.metadata?.llm_config
+      llmConfig: req.metadata?.llm_config,
+      llmLogPath: req.metadata?.llm_log_path
     });
     const durationMs = performance.now() - t0;
     try {
@@ -3203,15 +3754,216 @@ async function analyzeRoute(c) {
   }
 }
 
+// src/console/index.ts
+init_esm_shims();
+
+// src/console/router.ts
+init_esm_shims();
+init_runtime_config();
+init_token_stats();
+import { Hono } from "hono";
+import { readFileSync as readFileSync8, existsSync as existsSync9 } from "fs";
+import { join as join5, dirname as dirname5 } from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
+var __dirname5 = dirname5(fileURLToPath5(import.meta.url));
+var STATIC_DIR = join5(__dirname5, "static");
+var CONSOLE_TOKEN_ENV = "AGENT_MOSS_CONSOLE_TOKEN";
+function getConsoleToken() {
+  return process.env[CONSOLE_TOKEN_ENV] || "";
+}
+function verifyAuth(req) {
+  const token = getConsoleToken();
+  if (!token) return true;
+  const auth = req.headers.get("Authorization") || "";
+  if (auth.startsWith("Bearer ")) return auth.slice(7) === token;
+  return false;
+}
+function authMiddleware() {
+  return async (c, next) => {
+    if (!verifyAuth(c.req.raw)) {
+      return c.json({ error: "Unauthorized: invalid or missing Bearer token" }, 401);
+    }
+    await next();
+  };
+}
+function createConsoleRouter() {
+  const console2 = new Hono();
+  console2.use("/api/*", authMiddleware());
+  const serveIndex = (c) => {
+    const indexFile = join5(STATIC_DIR, "index.html");
+    if (existsSync9(indexFile)) {
+      return c.html(readFileSync8(indexFile, "utf-8"));
+    }
+    return c.html("<h1>AgentMoss Policy Console</h1><p>Frontend not built. Use /console/api/* endpoints.</p>");
+  };
+  console2.get("/", serveIndex);
+  console2.get("", serveIndex);
+  console2.get("/api/layers", (c) => {
+    const rc = loadRuntimeConfig();
+    return c.json({ layers: rc.layers });
+  });
+  console2.put("/api/layers", async (c) => {
+    const body = await c.req.json();
+    const rc = updateLayerEnabled(body.layer_key, body.enabled);
+    return c.json({ layers: rc.layers });
+  });
+  console2.get("/api/rules", (c) => {
+    const rc = loadRuntimeConfig();
+    return c.json({ L1_rules: rc.L1_rules, L2_rules: rc.L2_rules });
+  });
+  console2.put("/api/rules/enabled", async (c) => {
+    const b = await c.req.json();
+    const rc = updateRuleEnabled(b.layer, b.category, b.rule_id, b.enabled);
+    return c.json({ L1_rules: rc.L1_rules, L2_rules: rc.L2_rules });
+  });
+  console2.put("/api/rules/deny_mode", async (c) => {
+    const b = await c.req.json();
+    const rc = updateRuleDenyMode(b.layer, b.category, b.rule_id, b.deny_mode);
+    return c.json({ L1_rules: rc.L1_rules, L2_rules: rc.L2_rules });
+  });
+  console2.put("/api/rules/skip_l3", async (c) => {
+    const b = await c.req.json();
+    const rc = updateRuleSkipL3(b.layer, b.category, b.rule_id, b.skip_l3_on_disabled);
+    return c.json({ L1_rules: rc.L1_rules, L2_rules: rc.L2_rules });
+  });
+  console2.put("/api/categories/enabled", async (c) => {
+    const b = await c.req.json();
+    const rc = updateCategoryEnabled(b.layer, b.category, b.enabled);
+    return c.json({ L1_rules: rc.L1_rules, L2_rules: rc.L2_rules });
+  });
+  console2.post("/api/rules", async (c) => {
+    const b = await c.req.json();
+    const rc = addCustomRule(b.layer, b.category, {
+      pattern: b.pattern,
+      risk_level: b.risk_level,
+      risk_type: b.risk_type,
+      reason: b.reason,
+      keyword: b.keyword,
+      lang: b.lang,
+      path: b.path,
+      desc: b.desc,
+      credential: b.credential,
+      deny_mode: b.deny_mode
+    });
+    return c.json({ L1_rules: rc.L1_rules, L2_rules: rc.L2_rules });
+  });
+  console2.delete("/api/rules", async (c) => {
+    const b = await c.req.json();
+    deleteCustomRule(b.layer, b.category, b.rule_id);
+    const rc = loadRuntimeConfig();
+    return c.json({ L1_rules: rc.L1_rules, L2_rules: rc.L2_rules });
+  });
+  console2.get("/api/skills", (c) => {
+    const rc = loadRuntimeConfig();
+    return c.json({ L3_skills: rc.L3_skills });
+  });
+  console2.put("/api/skills/enabled", async (c) => {
+    const b = await c.req.json();
+    const rc = updateSkillEnabled(b.skill_id, b.enabled);
+    return c.json({ L3_skills: rc.L3_skills });
+  });
+  console2.put("/api/skill-categories/enabled", async (c) => {
+    const b = await c.req.json();
+    const rc = updateSkillCategoryEnabled(b.category, b.enabled);
+    return c.json({ L3_skills: rc.L3_skills });
+  });
+  console2.post("/api/skills", async (c) => {
+    const b = await c.req.json();
+    const rc = addCustomSkill(b.skill_id, b.category || "user_custom", b.keywords || [], b.content);
+    return c.json({ L3_skills: rc.L3_skills });
+  });
+  console2.delete("/api/skills", async (c) => {
+    const b = await c.req.json();
+    deleteCustomSkill(b.skill_id, b.category);
+    const rc = loadRuntimeConfig();
+    return c.json({ L3_skills: rc.L3_skills });
+  });
+  console2.get("/api/skills/:skill_id/content", async (c) => {
+    const skillId = c.req.param("skill_id");
+    if (!/^[A-Za-z0-9_-]+$/.test(skillId)) {
+      return c.json({ error: "invalid skill_id" }, 400);
+    }
+    const skillPath = join5(dirname5(getRuntimeConfigPath()), "agent_moss_skills", `${skillId}.md`);
+    if (!existsSync9(skillPath)) {
+      const builtinPath = join5(__dirname5, "..", "..", "agent_moss", "skills", `${skillId}.md`);
+      if (existsSync9(builtinPath)) return c.text(readFileSync8(builtinPath, "utf-8"));
+      return c.json({ error: "skill not found" }, 404);
+    }
+    return c.text(readFileSync8(skillPath, "utf-8"));
+  });
+  console2.get("/api/config", (c) => {
+    const rc = loadRuntimeConfig();
+    return c.json({ config: rc, config_path: getRuntimeConfigPath() });
+  });
+  console2.get("/api/env-overrides", (c) => {
+    return c.json({ overrides: getEnvOverrides() });
+  });
+  console2.post("/api/reset", (c) => {
+    const defaults = generateSourceDefaults();
+    saveRuntimeConfig(defaults);
+    return c.json({ config: defaults });
+  });
+  console2.get("/api/token-stats", (c) => {
+    const days = parseInt(c.req.query("days") || "7", 10);
+    return c.json(getTokenStats(days));
+  });
+  console2.get("/api/token-stats/recent", (c) => {
+    const limit = parseInt(c.req.query("limit") || "20", 10);
+    return c.json({ records: getRecentRecords(limit) });
+  });
+  console2.get("/api/token-stats/trend", (c) => {
+    const days = parseInt(c.req.query("days") || "7", 10);
+    return c.json(getTokenTrend(days));
+  });
+  console2.post("/api/token-stats/reset", (c) => {
+    resetTokenStats();
+    return c.json({ reset: true });
+  });
+  return console2;
+}
+
 // src/server.ts
 function createApp() {
-  const app = new Hono();
-  app.use("*", cors({ origin: "*", allowMethods: ["GET", "POST", "OPTIONS"], allowHeaders: ["*"] }));
+  const app = new Hono2();
+  app.use("*", cors({ origin: "*", allowMethods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"], allowHeaders: ["*"] }));
   app.use("*", logger());
   app.get("/api/v1/health", healthRoute);
   app.post("/api/v1/analyze", analyzeRoute);
+  app.route("/console", createConsoleRouter());
+  app.get("/console/", (c) => c.redirect("/console"));
   return app;
 }
+async function findFreePort(startPort, host = "127.0.0.1", scan = 100) {
+  for (let port = startPort; port < startPort + scan; port++) {
+    const free = await new Promise((resolve6) => {
+      const server = net.createServer();
+      server.listen(port, host, () => {
+        server.close(() => resolve6(true));
+      });
+      server.on("error", () => resolve6(false));
+    });
+    if (free) {
+      if (port !== startPort) {
+        console.warn(`[AgentMoss] Port ${startPort} in use, using ${port} instead`);
+      }
+      return port;
+    }
+  }
+  return startPort;
+}
+async function startServer(host = "127.0.0.1", port = 9090) {
+  const actualPort = await findFreePort(port, host);
+  const app = createApp();
+  return {
+    port: actualPort,
+    serve: () => {
+      console.log(`AgentMoss HTTP server on ${host}:${actualPort}`);
+      import("@hono/node-server").then(({ serve: honoServe }) => {
+        honoServe({ fetch: app.fetch, hostname: host, port: actualPort });
+      });
+    }
+  };
+}
 
 // src/cli.ts
 function printHelp() {
@@ -3221,10 +3973,14 @@ Commands:
   init                  Generate input.json template
   analyze <input>       Run security analysis on input JSON
   server                Start HTTP API server
+  install               Install systemd service for AgentMoss
 
 Server options:
   --host <host>         Listen host (default: 127.0.0.1)
-  --port <port>         Listen port (default: 9090)
+  --port <port>         Listen port (default: 9090, 0=auto assign)
+
+Install options:
+  --enable              Enable service on boot (systemctl enable)
 `);
 }
 async function main() {
@@ -3288,12 +4044,51 @@ async function main() {
         if (args[i] === "--host" && args[i + 1]) host = args[++i];
         else if (args[i] === "--port" && args[i + 1]) port = parseInt(args[++i], 10);
       }
-      const { serve } = await import("@hono/node-server");
-      const app = createApp();
-      console.log(`AgentMoss HTTP server on ${host}:${port}`);
-      serve({ fetch: app.fetch, hostname: host, port }, (info) => {
-        console.log(`Listening on http://${host}:${port}`);
-      });
+      const server = await startServer(host, port);
+      console.log(`Listening on http://${host}:${server.port}`);
+      server.serve();
+      break;
+    }
+    case "install": {
+      const enable = args.includes("--enable");
+      const { execSync } = await import("child_process");
+      const fs4 = await import("fs");
+      const path3 = await import("path");
+      const { fileURLToPath: fileURLToPath6 } = await import("url");
+      if (process.getuid?.() !== 0) {
+        const sudoArgs = ["sudo", process.execPath, ...process.argv.slice(1)];
+        if (enable) sudoArgs.push("--enable");
+        console.log("\u9700\u8981 root \u6743\u9650\u5B89\u88C5 systemd service\uFF0C\u6B63\u5728\u901A\u8FC7 sudo \u91CD\u65B0\u6267\u884C...");
+        execSync(sudoArgs.join(" "), { stdio: "inherit" });
+        process.exit(0);
+      }
+      const __filename5 = fileURLToPath6(import.meta.url);
+      const __dirname6 = path3.dirname(__filename5);
+      let srcPath = path3.join(__dirname6, "data", "agent_moss.service");
+      if (!fs4.existsSync(srcPath)) {
+        srcPath = path3.join(__dirname6, "..", "src", "data", "agent_moss.service");
+      }
+      if (!fs4.existsSync(srcPath)) {
+        console.error("\u9519\u8BEF\uFF1A\u627E\u4E0D\u5230 agent_moss.service \u6A21\u677F\u6587\u4EF6");
+        process.exit(1);
+      }
+      const which = execSync("which agent-moss 2>/dev/null || true", { encoding: "utf-8" }).trim();
+      const binPath = which || `${process.execPath} ${path3.join(__dirname6, "cli.js")}`;
+      let content = fs4.readFileSync(srcPath, "utf-8");
+      content = content.replace("__AGENT_MOSS_BIN__", binPath);
+      const dst = "/etc/systemd/system/agent_moss.service";
+      fs4.writeFileSync(dst, content, "utf-8");
+      fs4.chmodSync(dst, 420);
+      console.log(`\u2705 \u5DF2\u5B89\u88C5 systemd service: ${dst}`);
+      execSync("systemctl daemon-reload", { stdio: "inherit" });
+      console.log("\u2705 systemctl daemon-reload \u5B8C\u6210");
+      if (enable) {
+        execSync("systemctl enable agent_moss", { stdio: "inherit" });
+        console.log("\u2705 systemctl enable agent_moss \u5B8C\u6210");
+      }
+      console.log("\n\u542F\u52A8\u670D\u52A1\uFF1A  sudo systemctl start agent_moss");
+      console.log("\u67E5\u770B\u72B6\u6001\uFF1A  sudo systemctl status agent_moss");
+      console.log("\u67E5\u770B\u65E5\u5FD7\uFF1A  journalctl -u agent_moss -f");
       break;
     }
     default: