@agenshield/daemon 0.5.0 → 0.6.0

package/main.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // libs/shield-daemon/src/main.ts
-import * as fs20 from "node:fs";
+import * as fs21 from "node:fs";
 
 // libs/shield-daemon/src/config/paths.ts
 import * as path from "node:path";
@@ -86,7 +86,7 @@ function updateConfig(updates) {
 }
 
 // libs/shield-daemon/src/server.ts
-import * as fs19 from "node:fs";
+import * as fs20 from "node:fs";
 import Fastify from "fastify";
 import cors from "@fastify/cors";
 import fastifyStatic from "@fastify/static";
@@ -213,8 +213,8 @@ async function statusRoutes(app) {
 }
 
 // libs/shield-daemon/src/routes/config.ts
-import * as fs6 from "node:fs";
-import * as path5 from "node:path";
+import * as fs7 from "node:fs";
+import * as path7 from "node:path";
 
 // libs/shield-daemon/src/vault/index.ts
 import * as fs3 from "node:fs";
@@ -518,8 +518,30 @@ function getSessionManager() {
 import { execSync as execSync2 } from "node:child_process";
 import * as os3 from "node:os";
 import * as fs4 from "node:fs";
+import * as path4 from "node:path";
 var noop = { warn() {
 } };
+var TRAVERSAL_PERMS = "search";
+var WORLD_TRAVERSABLE_PATHS = /* @__PURE__ */ new Set([
+  "/",
+  "/Users",
+  "/tmp",
+  "/private",
+  "/private/tmp",
+  "/private/var",
+  "/var",
+  "/opt",
+  "/usr",
+  "/usr/local",
+  "/Applications",
+  "/Library",
+  "/System",
+  "/Volumes"
+]);
+function normalizePath(p) {
+  if (p === "/") return p;
+  return p.replace(/\/+$/, "") || "/";
+}
 function stripGlobToBasePath(pattern) {
   let p = pattern;
   if (p.startsWith("~")) {
@@ -531,7 +553,7 @@ function stripGlobToBasePath(pattern) {
     if (/[*?[]/.test(seg)) break;
     base.push(seg);
   }
-  return base.length === 0 ? "/" : base.join("/") || "/";
+  return normalizePath(base.length === 0 ? "/" : base.join("/") || "/");
 }
 function operationsToAclPerms(operations) {
   const perms = [];
@@ -589,49 +611,69 @@ function removeGroupAcl(targetPath, groupName, log = noop) {
     log.warn(`[acl] failed to read ACLs on ${targetPath}: ${err.message}`);
   }
 }
-function syncFilesystemPolicyAcls(oldPolicies, newPolicies, groupName, logger) {
-  const log = logger ?? noop;
-  const oldFs = oldPolicies.filter((p) => p.target === "filesystem");
-  const newFs = newPolicies.filter((p) => p.target === "filesystem");
-  const oldMap = new Map(oldFs.map((p) => [p.id, p]));
-  const newMap = new Map(newFs.map((p) => [p.id, p]));
-  for (const [id, oldP] of oldMap) {
-    if (!newMap.has(id)) {
-      for (const pattern of oldP.patterns) {
-        removeGroupAcl(stripGlobToBasePath(pattern), groupName, log);
-      }
+function getAncestorsNeedingTraversal(targetPath) {
+  const ancestors = [];
+  let dir = path4.dirname(targetPath);
+  while (dir !== targetPath && dir !== "/") {
+    if (!WORLD_TRAVERSABLE_PATHS.has(dir)) {
+      ancestors.push(dir);
     }
+    targetPath = dir;
+    dir = path4.dirname(dir);
   }
-  for (const [id, newP] of newMap) {
-    if (!oldMap.has(id)) {
-      const perms = operationsToAclPerms(newP.operations ?? []);
-      if (!perms) continue;
-      for (const pattern of newP.patterns) {
-        addGroupAcl(stripGlobToBasePath(pattern), groupName, perms, log);
-      }
+  return ancestors;
+}
+function mergePerms(a, b) {
+  const set = /* @__PURE__ */ new Set([
+    ...a.split(",").filter(Boolean),
+    ...b.split(",").filter(Boolean)
+  ]);
+  return [...set].join(",");
+}
+function computeAclMap(policies) {
+  const aclMap = /* @__PURE__ */ new Map();
+  for (const policy of policies) {
+    const perms = operationsToAclPerms(policy.operations ?? []);
+    if (!perms) continue;
+    for (const pattern of policy.patterns) {
+      const target = stripGlobToBasePath(pattern);
+      const existing = aclMap.get(target);
+      aclMap.set(target, existing ? mergePerms(existing, perms) : perms);
     }
   }
-  for (const [id, newP] of newMap) {
-    const oldP = oldMap.get(id);
-    if (!oldP) continue;
-    const patternsChanged = JSON.stringify(oldP.patterns) !== JSON.stringify(newP.patterns);
-    const opsChanged = JSON.stringify(oldP.operations ?? []) !== JSON.stringify(newP.operations ?? []);
-    if (patternsChanged || opsChanged) {
-      for (const pattern of oldP.patterns) {
-        removeGroupAcl(stripGlobToBasePath(pattern), groupName, log);
-      }
-      const perms = operationsToAclPerms(newP.operations ?? []);
-      if (!perms) continue;
-      for (const pattern of newP.patterns) {
-        addGroupAcl(stripGlobToBasePath(pattern), groupName, perms, log);
+  for (const policy of policies) {
+    const perms = operationsToAclPerms(policy.operations ?? []);
+    if (!perms) continue;
+    for (const pattern of policy.patterns) {
+      const target = stripGlobToBasePath(pattern);
+      for (const ancestor of getAncestorsNeedingTraversal(target)) {
+        if (!aclMap.has(ancestor)) {
+          aclMap.set(ancestor, TRAVERSAL_PERMS);
+        }
       }
     }
   }
+  return aclMap;
+}
+function syncFilesystemPolicyAcls(oldPolicies, newPolicies, groupName, logger) {
+  const log = logger ?? noop;
+  const oldFs = oldPolicies.filter((p) => p.target === "filesystem");
+  const newFs = newPolicies.filter((p) => p.target === "filesystem");
+  const oldAclMap = computeAclMap(oldFs);
+  const newAclMap = computeAclMap(newFs);
+  for (const oldPath of oldAclMap.keys()) {
+    if (!newAclMap.has(oldPath)) {
+      removeGroupAcl(oldPath, groupName, log);
+    }
+  }
+  for (const [targetPath, perms] of newAclMap) {
+    addGroupAcl(targetPath, groupName, perms, log);
+  }
 }
 
 // libs/shield-daemon/src/command-sync.ts
 import * as fs5 from "node:fs";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 import { execSync as execSync3 } from "node:child_process";
 var noop2 = { warn() {
 }, info() {
@@ -664,7 +706,7 @@ var ALL_PROXIED_COMMANDS = [
 function resolveCommandPaths(name) {
   const paths = [];
   for (const dir of BIN_SEARCH_DIRS) {
-    const candidate = path4.join(dir, name);
+    const candidate = path5.join(dir, name);
     try {
       if (fs5.existsSync(candidate)) {
         const stat = fs5.statSync(candidate);
@@ -678,7 +720,7 @@ function resolveCommandPaths(name) {
   if (paths.length === 0) {
     try {
       const result = execSync3(`which ${name} 2>/dev/null`, { encoding: "utf-8" }).trim();
-      if (result && path4.isAbsolute(result)) {
+      if (result && path5.isAbsolute(result)) {
         paths.push(result);
       }
     } catch {
@@ -720,15 +762,26 @@ function syncCommandPolicies(policies, logger) {
     version: "1.0.0",
     commands
   };
+  const json = JSON.stringify(config, null, 2) + "\n";
   try {
-    const dir = path4.dirname(ALLOWED_COMMANDS_PATH);
+    const dir = path5.dirname(ALLOWED_COMMANDS_PATH);
     if (!fs5.existsSync(dir)) {
       fs5.mkdirSync(dir, { recursive: true });
     }
-    fs5.writeFileSync(ALLOWED_COMMANDS_PATH, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    fs5.writeFileSync(ALLOWED_COMMANDS_PATH, json, "utf-8");
     log.info(`[command-sync] wrote ${commands.length} commands to allowlist`);
-  } catch (err) {
-    log.warn(`[command-sync] failed to write allowlist: ${err.message}`);
+  } catch {
+    try {
+      execSync3(`sudo -n tee "${ALLOWED_COMMANDS_PATH}" > /dev/null`, {
+        input: json,
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 5e3
+      });
+      log.info(`[command-sync] wrote ${commands.length} commands to allowlist (via sudo)`);
+    } catch (sudoErr) {
+      log.warn(`[command-sync] cannot write to ${ALLOWED_COMMANDS_PATH} \u2014 fix with: sudo chmod 775 ${path5.dirname(ALLOWED_COMMANDS_PATH)}`);
+      log.warn(`[command-sync] error: ${sudoErr.message}`);
+    }
   }
 }
 function installWrappersInDir(binDir, log) {
@@ -736,24 +789,38 @@ function installWrappersInDir(binDir, log) {
   if (!fs5.existsSync(binDir)) {
     try {
       fs5.mkdirSync(binDir, { recursive: true, mode: 493 });
-    } catch (err) {
-      log.warn(`[command-sync] failed to create bin dir ${binDir}: ${err.message}`);
-      return;
+    } catch {
+      try {
+        execSync3(`sudo -n mkdir -p "${binDir}" && sudo -n chmod 755 "${binDir}"`, {
+          stdio: "pipe",
+          timeout: 5e3
+        });
+      } catch (sudoErr) {
+        log.warn(`[command-sync] failed to create bin dir ${binDir}: ${sudoErr.message}`);
+        return;
+      }
     }
   }
+  if (!fs5.existsSync(shieldExecPath)) {
+    log.warn(`[command-sync] shield-exec not found at ${shieldExecPath}, skipping wrapper installation`);
+    return;
+  }
   for (const cmd of ALL_PROXIED_COMMANDS) {
-    const wrapperPath = path4.join(binDir, cmd);
+    const wrapperPath = path5.join(binDir, cmd);
     if (fs5.existsSync(wrapperPath)) {
       continue;
     }
     try {
-      if (fs5.existsSync(shieldExecPath)) {
-        fs5.symlinkSync(shieldExecPath, wrapperPath);
-      } else {
-        log.warn(`[command-sync] shield-exec not found at ${shieldExecPath}, skipping ${cmd} wrapper`);
+      fs5.symlinkSync(shieldExecPath, wrapperPath);
+    } catch {
+      try {
+        execSync3(`sudo -n ln -s "${shieldExecPath}" "${wrapperPath}"`, {
+          stdio: "pipe",
+          timeout: 5e3
+        });
+      } catch (sudoErr) {
+        log.warn(`[command-sync] failed to create wrapper ${wrapperPath}: ${sudoErr.message}`);
       }
-    } catch (err) {
-      log.warn(`[command-sync] failed to create wrapper ${wrapperPath}: ${err.message}`);
     }
   }
 }
@@ -764,12 +831,12 @@ function ensureWrappersInstalled(state, logger) {
     log.warn("[command-sync] no agent user in state, skipping wrapper installation");
     return;
   }
-  const agentBinDir = path4.join(agentUser.homeDir, "bin");
+  const agentBinDir = path5.join(agentUser.homeDir, "bin");
   log.info(`[command-sync] ensuring wrappers in agent bin: ${agentBinDir}`);
   installWrappersInDir(agentBinDir, log);
   const agentHomeEnv = process.env["AGENSHIELD_AGENT_HOME"];
   if (agentHomeEnv && agentHomeEnv !== agentUser.homeDir) {
-    const envBinDir = path4.join(agentHomeEnv, "bin");
+    const envBinDir = path5.join(agentHomeEnv, "bin");
     log.info(`[command-sync] ensuring wrappers in env agent bin: ${envBinDir}`);
     installWrappersInDir(envBinDir, log);
   }
@@ -779,6 +846,90 @@ function syncCommandPoliciesAndWrappers(policies, state, logger) {
   ensureWrappersInstalled(state, logger);
 }
 
+// libs/shield-daemon/src/policy-sync.ts
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
+import { execSync as execSync4 } from "node:child_process";
+var noop3 = { warn() {
+}, info() {
+} };
+var BROKER_POLICIES_DIR = "/opt/agenshield/policies";
+var USER_POLICIES_FILE = path6.join(BROKER_POLICIES_DIR, "custom", "user-policies.json");
+var BROKER_TARGETS = /* @__PURE__ */ new Set(["url", "command", "skill"]);
+function normalizeUrlPatterns(pattern) {
+  let p = pattern.trim();
+  p = p.replace(/\/+$/, "");
+  if (!p.match(/^(\*|https?):\/\//i)) {
+    p = `https://${p}`;
+  }
+  if (p.endsWith("*")) {
+    const base = p.replace(/\/\*+$/, "");
+    if (base !== p) {
+      return [base, p];
+    }
+    return [p];
+  }
+  return [p, `${p}/**`];
+}
+function inferOperations(target) {
+  switch (target) {
+    case "url":
+      return ["http_request", "open_url"];
+    case "command":
+      return ["exec"];
+    case "skill":
+      return ["skill_install", "skill_uninstall"];
+    default:
+      return ["*"];
+  }
+}
+function toBrokerRule(policy) {
+  let patterns;
+  if (policy.target === "url") {
+    patterns = policy.patterns.flatMap(normalizeUrlPatterns);
+    patterns = [...new Set(patterns)];
+  } else {
+    patterns = [...policy.patterns];
+  }
+  return {
+    id: policy.id,
+    name: policy.name,
+    action: policy.action,
+    target: policy.target,
+    operations: policy.operations?.length ? [...policy.operations] : inferOperations(policy.target),
+    patterns,
+    enabled: policy.enabled,
+    priority: policy.priority ?? 0
+  };
+}
+function syncPoliciesToBrokerDir(policies, logger) {
+  const log = logger ?? noop3;
+  const applicable = policies.filter((p) => BROKER_TARGETS.has(p.target));
+  const rules = applicable.map(toBrokerRule);
+  const payload = { rules };
+  const json = JSON.stringify(payload, null, 2) + "\n";
+  try {
+    const dir = path6.dirname(USER_POLICIES_FILE);
+    if (!fs6.existsSync(dir)) {
+      fs6.mkdirSync(dir, { recursive: true });
+    }
+    fs6.writeFileSync(USER_POLICIES_FILE, json, "utf-8");
+    log.info(`[policy-sync] wrote ${rules.length} user policies to broker dir`);
+  } catch {
+    try {
+      execSync4(`sudo -n tee "${USER_POLICIES_FILE}" > /dev/null`, {
+        input: json,
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 5e3
+      });
+      log.info(`[policy-sync] wrote ${rules.length} user policies to broker dir (via sudo)`);
+    } catch (sudoErr) {
+      log.warn(`[policy-sync] cannot write to ${USER_POLICIES_FILE} \u2014 fix with: sudo chmod 775 ${path6.dirname(USER_POLICIES_FILE)}`);
+      log.warn(`[policy-sync] error: ${sudoErr.message}`);
+    }
+  }
+}
+
 // libs/shield-daemon/src/routes/config.ts
 async function configRoutes(app) {
   app.get("/config", async () => {
@@ -801,6 +952,7 @@ async function configRoutes(app) {
             syncFilesystemPolicyAcls(oldPolicies, updated.policies, wsGroup.name, app.log);
           }
           syncCommandPoliciesAndWrappers(updated.policies, state, app.log);
+          syncPoliciesToBrokerDir(updated.policies, app.log);
         }
         return {
           success: true,
@@ -826,6 +978,7 @@ async function configRoutes(app) {
         syncFilesystemPolicyAcls(oldConfig.policies, [], wsGroup.name, app.log);
       }
       syncCommandPoliciesAndWrappers([], state, app.log);
+      syncPoliciesToBrokerDir([], app.log);
       saveConfig(getDefaultConfig());
       const vault = getVault();
       await vault.destroy();
@@ -843,7 +996,7 @@ async function configRoutes(app) {
   });
   app.get("/config/openclaw", async (_request, reply) => {
     const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
-    const configDir = path5.join(agentHome, ".openclaw");
+    const configDir = path7.join(agentHome, ".openclaw");
     const configFiles = readConfigDir(configDir);
     return reply.send({ configDir, files: configFiles });
   });
@@ -855,7 +1008,7 @@ async function configRoutes(app) {
         return reply.code(400).send({ error: "original query param required" });
       }
       const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
-      const agentConfigDir = path5.join(agentHome, ".openclaw");
+      const agentConfigDir = path7.join(agentHome, ".openclaw");
       const diff = diffConfigDirs(original, agentConfigDir);
       return reply.send({ diff });
     }
@@ -865,27 +1018,27 @@ var SKIP_DIRS = /* @__PURE__ */ new Set(["skills", "node_modules", ".git", "dist
 function readConfigDir(dir, base) {
   const result = {};
   const root = base ?? dir;
-  if (!fs6.existsSync(dir)) {
+  if (!fs7.existsSync(dir)) {
     return result;
   }
   let entries;
   try {
-    entries = fs6.readdirSync(dir, { withFileTypes: true });
+    entries = fs7.readdirSync(dir, { withFileTypes: true });
   } catch {
     return result;
   }
   for (const entry of entries) {
     if (entry.isDirectory()) {
       if (SKIP_DIRS.has(entry.name)) continue;
-      const sub = readConfigDir(path5.join(dir, entry.name), root);
+      const sub = readConfigDir(path7.join(dir, entry.name), root);
       Object.assign(result, sub);
     } else if (entry.isFile()) {
-      const ext = path5.extname(entry.name).toLowerCase();
+      const ext = path7.extname(entry.name).toLowerCase();
       if ([".json", ".yaml", ".yml", ".toml", ".txt", ".md", ".conf", ""].includes(ext)) {
-        const filePath = path5.join(dir, entry.name);
-        const relPath = path5.relative(root, filePath);
+        const filePath = path7.join(dir, entry.name);
+        const relPath = path7.relative(root, filePath);
         try {
-          result[relPath] = fs6.readFileSync(filePath, "utf-8");
+          result[relPath] = fs7.readFileSync(filePath, "utf-8");
         } catch {
         }
       }
@@ -1005,10 +1158,10 @@ function emitSecurityWarning(warning) {
 function emitSecurityCritical(issue) {
   daemonEvents.broadcast("security:critical", { message: issue });
 }
-function emitApiRequest(method, path18, statusCode, duration, requestBody, responseBody) {
+function emitApiRequest(method, path20, statusCode, duration, requestBody, responseBody) {
   daemonEvents.broadcast("api:request", {
     method,
-    path: path18,
+    path: path20,
     statusCode,
     duration,
     ...requestBody !== void 0 && { requestBody },
@@ -1215,16 +1368,16 @@ var PROTECTED_ROUTES = [
   { method: "POST", path: "/api/config/factory-reset" },
   { method: "POST", path: "/api/skills/install" }
 ];
-function isProtectedRoute(method, path18) {
+function isProtectedRoute(method, path20) {
   return PROTECTED_ROUTES.some(
-    (route) => route.method === method && path18.startsWith(route.path)
+    (route) => route.method === method && path20.startsWith(route.path)
   );
 }
 function createAuthHook() {
   return async (request, reply) => {
     const method = request.method;
-    const path18 = request.url.split("?")[0];
-    if (!isProtectedRoute(method, path18)) {
+    const path20 = request.url.split("?")[0];
+    if (!isProtectedRoute(method, path20)) {
       return;
     }
     if (!isAuthenticated(request)) {
@@ -2056,8 +2209,8 @@ function getMCPState() {
 }
 
 // libs/shield-daemon/src/services/integration-skills.ts
-import * as fs8 from "node:fs";
-import * as path7 from "node:path";
+import * as fs9 from "node:fs";
+import * as path9 from "node:path";
 
 // libs/shield-skills/dist/index.js
 import * as path22 from "node:path";
@@ -2122,9 +2275,9 @@ var __skills_dirname = path22.dirname(fileURLToPath(import.meta.url));
 var BUILTIN_SKILLS_DIR = path22.resolve(__skills_dirname, "..", "skills");
 
 // libs/shield-daemon/src/watchers/skills.ts
-import * as fs7 from "node:fs";
-import * as path6 from "node:path";
-import { execSync as execSync4 } from "node:child_process";
+import * as fs8 from "node:fs";
+import * as path8 from "node:path";
+import { execSync as execSync5 } from "node:child_process";
 var APPROVED_SKILLS_PATH = "/opt/agenshield/config/approved-skills.json";
 var QUARANTINE_DIR = "/opt/agenshield/quarantine/skills";
 var DEBOUNCE_MS = 500;
@@ -2135,8 +2288,8 @@ var skillsDir = "";
 var callbacks = {};
 function loadApprovedSkills() {
   try {
-    if (fs7.existsSync(APPROVED_SKILLS_PATH)) {
-      const content = fs7.readFileSync(APPROVED_SKILLS_PATH, "utf-8");
+    if (fs8.existsSync(APPROVED_SKILLS_PATH)) {
+      const content = fs8.readFileSync(APPROVED_SKILLS_PATH, "utf-8");
       return JSON.parse(content);
     }
   } catch {
@@ -2145,10 +2298,10 @@ function loadApprovedSkills() {
 }
 function saveApprovedSkills(skills) {
   try {
-    const dir = path6.dirname(APPROVED_SKILLS_PATH);
-    fs7.mkdirSync(dir, { recursive: true });
+    const dir = path8.dirname(APPROVED_SKILLS_PATH);
+    fs8.mkdirSync(dir, { recursive: true });
     const content = JSON.stringify(skills, null, 2);
-    fs7.writeFileSync(APPROVED_SKILLS_PATH, content, "utf-8");
+    fs8.writeFileSync(APPROVED_SKILLS_PATH, content, "utf-8");
   } catch (err) {
     console.error("Failed to save approved skills:", err.message);
   }
@@ -2159,16 +2312,16 @@ function isApproved(skillName) {
 }
 function quarantineSkill(skillName, skillPath) {
   try {
-    const quarantinePath = path6.join(QUARANTINE_DIR, skillName);
-    if (!fs7.existsSync(QUARANTINE_DIR)) {
-      fs7.mkdirSync(QUARANTINE_DIR, { recursive: true, mode: 448 });
+    const quarantinePath = path8.join(QUARANTINE_DIR, skillName);
+    if (!fs8.existsSync(QUARANTINE_DIR)) {
+      fs8.mkdirSync(QUARANTINE_DIR, { recursive: true, mode: 448 });
     }
-    if (fs7.existsSync(quarantinePath)) {
-      fs7.rmSync(quarantinePath, { recursive: true, force: true });
+    if (fs8.existsSync(quarantinePath)) {
+      fs8.rmSync(quarantinePath, { recursive: true, force: true });
     }
-    execSync4(`mv "${skillPath}" "${quarantinePath}"`, { stdio: "pipe" });
-    execSync4(`chown -R root:wheel "${quarantinePath}"`, { stdio: "pipe" });
-    execSync4(`chmod -R 700 "${quarantinePath}"`, { stdio: "pipe" });
+    execSync5(`mv "${skillPath}" "${quarantinePath}"`, { stdio: "pipe" });
+    execSync5(`chown -R root:wheel "${quarantinePath}"`, { stdio: "pipe" });
+    execSync5(`chmod -R 700 "${quarantinePath}"`, { stdio: "pipe" });
     const info = {
       name: skillName,
       quarantinedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -2183,16 +2336,16 @@ function quarantineSkill(skillName, skillPath) {
   }
 }
 function scanSkills() {
-  if (!skillsDir || !fs7.existsSync(skillsDir)) {
+  if (!skillsDir || !fs8.existsSync(skillsDir)) {
     return;
   }
   try {
-    const entries = fs7.readdirSync(skillsDir, { withFileTypes: true });
+    const entries = fs8.readdirSync(skillsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const skillName = entry.name;
       if (!isApproved(skillName)) {
-        const fullPath = path6.join(skillsDir, skillName);
+        const fullPath = path8.join(skillsDir, skillName);
         const info = quarantineSkill(skillName, fullPath);
         if (info && callbacks.onQuarantined) {
           callbacks.onQuarantined(info);
@@ -2225,8 +2378,8 @@ function startSkillsWatcher(watchDir, cbs = {}, pollIntervalMs = 3e4) {
   callbacks = cbs;
   scanSkills();
   try {
-    if (fs7.existsSync(skillsDir)) {
-      watcher = fs7.watch(skillsDir, { persistent: false }, handleFsEvent);
+    if (fs8.existsSync(skillsDir)) {
+      watcher = fs8.watch(skillsDir, { persistent: false }, handleFsEvent);
       watcher.on("error", (err) => {
         console.warn("[SkillsWatcher] fs.watch error, falling back to polling:", err.message);
         watcher?.close();
@@ -2258,9 +2411,9 @@ function stopSkillsWatcher() {
 }
 function approveSkill(skillName) {
   try {
-    const quarantinedPath = path6.join(QUARANTINE_DIR, skillName);
-    const destPath = path6.join(skillsDir, skillName);
-    if (!fs7.existsSync(quarantinedPath)) {
+    const quarantinedPath = path8.join(QUARANTINE_DIR, skillName);
+    const destPath = path8.join(skillsDir, skillName);
+    if (!fs8.existsSync(quarantinedPath)) {
       return { success: false, error: `Skill "${skillName}" not found in quarantine` };
     }
     const approved = loadApprovedSkills();
@@ -2271,9 +2424,9 @@ function approveSkill(skillName) {
       });
       saveApprovedSkills(approved);
     }
-    execSync4(`mv "${quarantinedPath}" "${destPath}"`, { stdio: "pipe" });
-    execSync4(`chown -R root:wheel "${destPath}"`, { stdio: "pipe" });
-    execSync4(`chmod -R a+rX,go-w "${destPath}"`, { stdio: "pipe" });
+    execSync5(`mv "${quarantinedPath}" "${destPath}"`, { stdio: "pipe" });
+    execSync5(`chown -R root:wheel "${destPath}"`, { stdio: "pipe" });
+    execSync5(`chmod -R a+rX,go-w "${destPath}"`, { stdio: "pipe" });
     if (callbacks.onApproved) {
       callbacks.onApproved(skillName);
     }
@@ -2285,11 +2438,11 @@ function approveSkill(skillName) {
 }
 function rejectSkill(skillName) {
   try {
-    const quarantinedPath = path6.join(QUARANTINE_DIR, skillName);
-    if (!fs7.existsSync(quarantinedPath)) {
+    const quarantinedPath = path8.join(QUARANTINE_DIR, skillName);
+    if (!fs8.existsSync(quarantinedPath)) {
       return { success: false, error: `Skill "${skillName}" not found in quarantine` };
     }
-    fs7.rmSync(quarantinedPath, { recursive: true, force: true });
+    fs8.rmSync(quarantinedPath, { recursive: true, force: true });
     console.log(`[SkillsWatcher] Rejected and deleted skill: ${skillName}`);
     return { success: true };
   } catch (err) {
@@ -2301,8 +2454,8 @@ function revokeSkill(skillName) {
     const approved = loadApprovedSkills();
     const filtered = approved.filter((s) => s.name !== skillName);
     saveApprovedSkills(filtered);
-    const skillPath = path6.join(skillsDir, skillName);
-    if (fs7.existsSync(skillPath)) {
+    const skillPath = path8.join(skillsDir, skillName);
+    if (fs8.existsSync(skillPath)) {
       quarantineSkill(skillName, skillPath);
     }
     console.log(`[SkillsWatcher] Revoked approval for skill: ${skillName}`);
@@ -2314,17 +2467,17 @@ function revokeSkill(skillName) {
 function listQuarantined() {
   const results = [];
   try {
-    if (!fs7.existsSync(QUARANTINE_DIR)) {
+    if (!fs8.existsSync(QUARANTINE_DIR)) {
       return results;
     }
-    const entries = fs7.readdirSync(QUARANTINE_DIR, { withFileTypes: true });
+    const entries = fs8.readdirSync(QUARANTINE_DIR, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const stat = fs7.statSync(path6.join(QUARANTINE_DIR, entry.name));
+        const stat = fs8.statSync(path8.join(QUARANTINE_DIR, entry.name));
         results.push({
           name: entry.name,
           quarantinedAt: stat.mtime.toISOString(),
-          originalPath: path6.join(skillsDir, entry.name),
+          originalPath: path8.join(skillsDir, entry.name),
           reason: "Skill not in approved list"
         });
       }
@@ -2361,15 +2514,15 @@ function removeFromApprovedList(skillName) {
 // libs/shield-daemon/src/services/integration-skills.ts
 var AGENCO_SKILL_NAME = "agenco-secure-integrations";
 function copyDirSync(src, dest) {
-  fs8.mkdirSync(dest, { recursive: true });
-  const entries = fs8.readdirSync(src, { withFileTypes: true });
+  fs9.mkdirSync(dest, { recursive: true });
+  const entries = fs9.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path7.join(src, entry.name);
-    const destPath = path7.join(dest, entry.name);
+    const srcPath = path9.join(src, entry.name);
+    const destPath = path9.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirSync(srcPath, destPath);
     } else {
-      fs8.copyFileSync(srcPath, destPath);
+      fs9.copyFileSync(srcPath, destPath);
     }
   }
 }
@@ -2379,9 +2532,9 @@ async function provisionAgenCoSkill() {
     console.warn("[IntegrationSkills] Skills directory not configured \u2014 skipping provision");
     return { installed: false };
   }
-  const destDir = path7.join(skillsDir2, AGENCO_SKILL_NAME);
-  const srcDir = path7.join(BUILTIN_SKILLS_DIR, AGENCO_SKILL_NAME);
-  if (fs8.existsSync(destDir)) {
+  const destDir = path9.join(skillsDir2, AGENCO_SKILL_NAME);
+  const srcDir = path9.join(BUILTIN_SKILLS_DIR, AGENCO_SKILL_NAME);
+  if (fs9.existsSync(destDir)) {
     return { installed: false };
   }
   try {
@@ -2392,8 +2545,8 @@ async function provisionAgenCoSkill() {
   } catch (err) {
     console.error(`[IntegrationSkills] Failed to install "${AGENCO_SKILL_NAME}":`, err.message);
     try {
-      if (fs8.existsSync(destDir)) {
-        fs8.rmSync(destDir, { recursive: true, force: true });
+      if (fs9.existsSync(destDir)) {
+        fs9.rmSync(destDir, { recursive: true, force: true });
       }
       removeFromApprovedList(AGENCO_SKILL_NAME);
     } catch {
@@ -2408,12 +2561,12 @@ async function provisionIntegrationSkill(integrationSlug) {
     return { installed: false };
   }
   const skillName = `integration-${integrationSlug}`;
-  const destDir = path7.join(skillsDir2, skillName);
-  const srcDir = path7.join(BUILTIN_SKILLS_DIR, skillName);
-  if (fs8.existsSync(destDir)) {
+  const destDir = path9.join(skillsDir2, skillName);
+  const srcDir = path9.join(BUILTIN_SKILLS_DIR, skillName);
+  if (fs9.existsSync(destDir)) {
     return { installed: false };
   }
-  if (!fs8.existsSync(srcDir)) {
+  if (!fs9.existsSync(srcDir)) {
     return { installed: false };
   }
   try {
@@ -2424,8 +2577,8 @@ async function provisionIntegrationSkill(integrationSlug) {
   } catch (err) {
     console.error(`[IntegrationSkills] Failed to install "${skillName}":`, err.message);
     try {
-      if (fs8.existsSync(destDir)) {
-        fs8.rmSync(destDir, { recursive: true, force: true });
+      if (fs9.existsSync(destDir)) {
+        fs9.rmSync(destDir, { recursive: true, force: true });
       }
       removeFromApprovedList(skillName);
     } catch {
@@ -4948,15 +5101,15 @@ async function agencoRoutes(app) {
 }
 
 // libs/shield-daemon/src/routes/skills.ts
-import * as fs13 from "node:fs";
-import * as path12 from "node:path";
-import { execSync as execSync8 } from "node:child_process";
+import * as fs14 from "node:fs";
+import * as path14 from "node:path";
+import { execSync as execSync9 } from "node:child_process";
 import { parseSkillMd } from "@agenshield/sandbox";
 
 // libs/shield-daemon/src/services/skill-analyzer.ts
-import * as fs9 from "node:fs";
-import * as path8 from "node:path";
-import { execSync as execSync5 } from "node:child_process";
+import * as fs10 from "node:fs";
+import * as path10 from "node:path";
+import { execSync as execSync6 } from "node:child_process";
 var ANALYSIS_CACHE_PATH = "/opt/agenshield/config/skill-analyses.json";
 var COMMAND_PATTERNS = [
   // Bash-style: command at start of line or after pipe/semicolon
@@ -5017,8 +5170,8 @@ var IGNORE_WORDS = /* @__PURE__ */ new Set([
 ]);
 function loadCache() {
   try {
-    if (fs9.existsSync(ANALYSIS_CACHE_PATH)) {
-      return JSON.parse(fs9.readFileSync(ANALYSIS_CACHE_PATH, "utf-8"));
+    if (fs10.existsSync(ANALYSIS_CACHE_PATH)) {
+      return JSON.parse(fs10.readFileSync(ANALYSIS_CACHE_PATH, "utf-8"));
     }
   } catch {
   }
@@ -5026,18 +5179,18 @@ function loadCache() {
 }
 function saveCache(cache3) {
   try {
-    const dir = path8.dirname(ANALYSIS_CACHE_PATH);
-    if (!fs9.existsSync(dir)) {
-      fs9.mkdirSync(dir, { recursive: true });
+    const dir = path10.dirname(ANALYSIS_CACHE_PATH);
+    if (!fs10.existsSync(dir)) {
+      fs10.mkdirSync(dir, { recursive: true });
     }
-    fs9.writeFileSync(ANALYSIS_CACHE_PATH, JSON.stringify(cache3, null, 2) + "\n", "utf-8");
+    fs10.writeFileSync(ANALYSIS_CACHE_PATH, JSON.stringify(cache3, null, 2) + "\n", "utf-8");
   } catch (err) {
     console.error("[SkillAnalyzer] Failed to save cache:", err.message);
   }
 }
 function resolveCommand(name) {
   try {
-    const result = execSync5(`which ${name} 2>/dev/null`, { encoding: "utf-8" }).trim();
+    const result = execSync6(`which ${name} 2>/dev/null`, { encoding: "utf-8" }).trim();
     return result || void 0;
   } catch {
     return void 0;
@@ -5172,33 +5325,33 @@ function clearCachedAnalysis(skillName) {
 }
 
 // libs/shield-daemon/src/services/skill-lifecycle.ts
-import * as fs10 from "node:fs";
-import * as path9 from "node:path";
-import { execSync as execSync6 } from "node:child_process";
+import * as fs11 from "node:fs";
+import * as path11 from "node:path";
+import { execSync as execSync7 } from "node:child_process";
 function createSkillWrapper(name, binDir) {
-  if (!fs10.existsSync(binDir)) {
-    fs10.mkdirSync(binDir, { recursive: true });
+  if (!fs11.existsSync(binDir)) {
+    fs11.mkdirSync(binDir, { recursive: true });
   }
-  const wrapperPath = path9.join(binDir, name);
+  const wrapperPath = path11.join(binDir, name);
   const wrapperContent = `#!/bin/bash
 # ${name} skill wrapper - policy-enforced execution
 # Ensure accessible working directory
 if ! /bin/pwd > /dev/null 2>&1; then cd ~ 2>/dev/null || cd /; fi
 exec /opt/agenshield/bin/shield-client skill run "${name}" "$@"
 `;
-  fs10.writeFileSync(wrapperPath, wrapperContent, { mode: 493 });
+  fs11.writeFileSync(wrapperPath, wrapperContent, { mode: 493 });
   const socketGroup = process.env["AGENSHIELD_SOCKET_GROUP"] || "clawshield";
   try {
-    execSync6(`chown root:${socketGroup} "${wrapperPath}"`, { stdio: "pipe" });
-    execSync6(`chmod 755 "${wrapperPath}"`, { stdio: "pipe" });
+    execSync7(`chown root:${socketGroup} "${wrapperPath}"`, { stdio: "pipe" });
+    execSync7(`chmod 755 "${wrapperPath}"`, { stdio: "pipe" });
   } catch {
   }
 }
 function removeSkillWrapper(name, binDir) {
-  const wrapperPath = path9.join(binDir, name);
+  const wrapperPath = path11.join(binDir, name);
   try {
-    if (fs10.existsSync(wrapperPath)) {
-      fs10.unlinkSync(wrapperPath);
+    if (fs11.existsSync(wrapperPath)) {
+      fs11.unlinkSync(wrapperPath);
     }
   } catch {
   }
@@ -5231,18 +5384,18 @@ function removeSkillPolicy(name) {
 }
 
 // libs/shield-daemon/src/services/openclaw-config.ts
-import * as fs11 from "node:fs";
-import * as path10 from "node:path";
-import { execSync as execSync7 } from "node:child_process";
+import * as fs12 from "node:fs";
+import * as path12 from "node:path";
+import { execSync as execSync8 } from "node:child_process";
 function getOpenClawConfigPath() {
   const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
-  return path10.join(agentHome, ".openclaw", "openclaw.json");
+  return path12.join(agentHome, ".openclaw", "openclaw.json");
 }
 function readConfig() {
   const configPath = getOpenClawConfigPath();
   try {
-    if (fs11.existsSync(configPath)) {
-      return JSON.parse(fs11.readFileSync(configPath, "utf-8"));
+    if (fs12.existsSync(configPath)) {
+      return JSON.parse(fs12.readFileSync(configPath, "utf-8"));
     }
   } catch {
     console.warn("[OpenClawConfig] Failed to read openclaw.json, starting fresh");
@@ -5251,14 +5404,14 @@ function readConfig() {
 }
 function writeConfig(config) {
   const configPath = getOpenClawConfigPath();
-  fs11.mkdirSync(path10.dirname(configPath), { recursive: true });
-  fs11.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+  fs12.mkdirSync(path12.dirname(configPath), { recursive: true });
+  fs12.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
   const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
-  const brokerUser = path10.basename(agentHome) + "_broker";
+  const brokerUser = path12.basename(agentHome) + "_broker";
   const socketGroup = process.env["AGENSHIELD_SOCKET_GROUP"] || "clawshield";
   try {
-    execSync7(`chown ${brokerUser}:${socketGroup} "${configPath}"`, { stdio: "pipe" });
-    execSync7(`chmod 664 "${configPath}"`, { stdio: "pipe" });
+    execSync8(`chown ${brokerUser}:${socketGroup} "${configPath}"`, { stdio: "pipe" });
+    execSync8(`chmod 664 "${configPath}"`, { stdio: "pipe" });
   } catch {
   }
 }
@@ -5287,8 +5440,8 @@ function removeSkillEntry(slug) {
 }
 
 // libs/shield-daemon/src/services/marketplace.ts
-import * as fs12 from "node:fs";
-import * as path11 from "node:path";
+import * as fs13 from "node:fs";
+import * as path13 from "node:path";
 import * as os4 from "node:os";
 import { CONFIG_DIR as CONFIG_DIR2, MARKETPLACE_DIR } from "@agenshield/ipc";
 var cache = /* @__PURE__ */ new Map();
@@ -5312,35 +5465,35 @@ var ANALYSIS_TIMEOUT = 4 * 6e4;
 var SEARCH_CACHE_TTL = 6e4;
 var DETAIL_CACHE_TTL = 5 * 6e4;
 var SHORT_TIMEOUT = 1e4;
-async function convexAction(path18, args, timeout) {
+async function convexAction(path20, args, timeout) {
   const res = await fetch(`${CONVEX_BASE}/api/action`, {
     method: "POST",
     signal: AbortSignal.timeout(timeout),
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ path: path18, args, format: "json" })
+    body: JSON.stringify({ path: path20, args, format: "json" })
   });
   if (!res.ok) {
-    throw new Error(`Convex action ${path18} returned ${res.status}`);
+    throw new Error(`Convex action ${path20} returned ${res.status}`);
   }
   const body = await res.json();
   if (body.status === "error") {
-    throw new Error(`Convex action ${path18}: ${body.errorMessage ?? "unknown error"}`);
+    throw new Error(`Convex action ${path20}: ${body.errorMessage ?? "unknown error"}`);
   }
   return body.value;
 }
-async function convexQuery(path18, args, timeout) {
+async function convexQuery(path20, args, timeout) {
   const res = await fetch(`${CONVEX_BASE}/api/query`, {
     method: "POST",
     signal: AbortSignal.timeout(timeout),
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ path: path18, args, format: "json" })
+    body: JSON.stringify({ path: path20, args, format: "json" })
   });
   if (!res.ok) {
-    throw new Error(`Convex query ${path18} returned ${res.status}`);
+    throw new Error(`Convex query ${path20} returned ${res.status}`);
   }
   const body = await res.json();
   if (body.status === "error") {
-    throw new Error(`Convex query ${path18}: ${body.errorMessage ?? "unknown error"}`);
+    throw new Error(`Convex query ${path20}: ${body.errorMessage ?? "unknown error"}`);
   }
   return body.value;
 }
@@ -5401,7 +5554,7 @@ function isImageExt(filePath) {
 }
 var MAX_IMAGE_SIZE = 5e5;
 function getMarketplaceDir() {
-  return path11.join(os4.homedir(), CONFIG_DIR2, MARKETPLACE_DIR);
+  return path13.join(os4.homedir(), CONFIG_DIR2, MARKETPLACE_DIR);
 }
 async function downloadAndExtractZip(slug) {
   const url = `${CLAWHUB_DOWNLOAD_BASE}/download?slug=${encodeURIComponent(slug)}`;
@@ -5439,39 +5592,39 @@ async function downloadAndExtractZip(slug) {
   return files;
 }
 function storeDownloadedSkill(slug, meta, files) {
-  const dir = path11.join(getMarketplaceDir(), slug);
-  const filesDir = path11.join(dir, "files");
-  fs12.mkdirSync(filesDir, { recursive: true });
+  const dir = path13.join(getMarketplaceDir(), slug);
+  const filesDir = path13.join(dir, "files");
+  fs13.mkdirSync(filesDir, { recursive: true });
   const fullMeta = { ...meta, downloadedAt: (/* @__PURE__ */ new Date()).toISOString() };
-  fs12.writeFileSync(path11.join(dir, "metadata.json"), JSON.stringify(fullMeta, null, 2), "utf-8");
+  fs13.writeFileSync(path13.join(dir, "metadata.json"), JSON.stringify(fullMeta, null, 2), "utf-8");
   for (const file of files) {
-    const filePath = path11.join(filesDir, file.name);
-    fs12.mkdirSync(path11.dirname(filePath), { recursive: true });
-    fs12.writeFileSync(filePath, file.content, "utf-8");
+    const filePath = path13.join(filesDir, file.name);
+    fs13.mkdirSync(path13.dirname(filePath), { recursive: true });
+    fs13.writeFileSync(filePath, file.content, "utf-8");
   }
   console.log(`[Marketplace] Stored ${files.length} files for ${slug}`);
 }
 function updateDownloadedAnalysis(slug, analysis) {
-  const metaPath = path11.join(getMarketplaceDir(), slug, "metadata.json");
+  const metaPath = path13.join(getMarketplaceDir(), slug, "metadata.json");
   try {
-    if (!fs12.existsSync(metaPath)) return;
-    const meta = JSON.parse(fs12.readFileSync(metaPath, "utf-8"));
+    if (!fs13.existsSync(metaPath)) return;
+    const meta = JSON.parse(fs13.readFileSync(metaPath, "utf-8"));
     meta.analysis = analysis;
-    fs12.writeFileSync(metaPath, JSON.stringify(meta, null, 2), "utf-8");
+    fs13.writeFileSync(metaPath, JSON.stringify(meta, null, 2), "utf-8");
   } catch {
   }
 }
 function listDownloadedSkills() {
   const baseDir = getMarketplaceDir();
-  if (!fs12.existsSync(baseDir)) return [];
+  if (!fs13.existsSync(baseDir)) return [];
   const results = [];
   try {
-    const entries = fs12.readdirSync(baseDir, { withFileTypes: true });
+    const entries = fs13.readdirSync(baseDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const metaPath = path11.join(baseDir, entry.name, "metadata.json");
+      const metaPath = path13.join(baseDir, entry.name, "metadata.json");
       try {
-        const meta = JSON.parse(fs12.readFileSync(metaPath, "utf-8"));
+        const meta = JSON.parse(fs13.readFileSync(metaPath, "utf-8"));
         results.push({
           slug: meta.slug,
           name: meta.name,
@@ -5488,17 +5641,17 @@ function listDownloadedSkills() {
   return results;
 }
 function getDownloadedSkillFiles(slug) {
-  const filesDir = path11.join(getMarketplaceDir(), slug, "files");
-  if (!fs12.existsSync(filesDir)) return [];
+  const filesDir = path13.join(getMarketplaceDir(), slug, "files");
+  if (!fs13.existsSync(filesDir)) return [];
   const files = [];
   function walk(dir, prefix) {
-    const entries = fs12.readdirSync(dir, { withFileTypes: true });
+    const entries = fs13.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
       if (entry.isDirectory()) {
-        walk(path11.join(dir, entry.name), rel);
+        walk(path13.join(dir, entry.name), rel);
       } else {
-        const content = fs12.readFileSync(path11.join(dir, entry.name), "utf-8");
+        const content = fs13.readFileSync(path13.join(dir, entry.name), "utf-8");
         files.push({ name: rel, type: guessContentType(entry.name), content });
       }
     }
@@ -5507,10 +5660,10 @@ function getDownloadedSkillFiles(slug) {
   return files;
 }
 function getDownloadedSkillMeta(slug) {
-  const metaPath = path11.join(getMarketplaceDir(), slug, "metadata.json");
+  const metaPath = path13.join(getMarketplaceDir(), slug, "metadata.json");
   try {
-    if (fs12.existsSync(metaPath)) {
-      return JSON.parse(fs12.readFileSync(metaPath, "utf-8"));
+    if (fs13.existsSync(metaPath)) {
+      return JSON.parse(fs13.readFileSync(metaPath, "utf-8"));
     }
   } catch {
   }
@@ -6047,13 +6200,13 @@ function findSkillMdRecursive(dir, depth = 0) {
   if (depth > 3) return null;
   try {
     for (const name of ["SKILL.md", "skill.md", "README.md", "readme.md"]) {
-      const candidate = path12.join(dir, name);
-      if (fs13.existsSync(candidate)) return candidate;
+      const candidate = path14.join(dir, name);
+      if (fs14.existsSync(candidate)) return candidate;
     }
-    const entries = fs13.readdirSync(dir, { withFileTypes: true });
+    const entries = fs14.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const found = findSkillMdRecursive(path12.join(dir, entry.name), depth + 1);
+      const found = findSkillMdRecursive(path14.join(dir, entry.name), depth + 1);
       if (found) return found;
     }
   } catch {
@@ -6064,7 +6217,7 @@ function readSkillDescription(skillDir) {
   try {
     const mdPath = findSkillMdRecursive(skillDir);
     if (!mdPath) return void 0;
-    const content = fs13.readFileSync(mdPath, "utf-8");
+    const content = fs14.readFileSync(mdPath, "utf-8");
     const parsed = parseSkillMd(content);
     return parsed?.metadata?.description ?? void 0;
   } catch {
@@ -6083,7 +6236,7 @@ async function skillsRoutes(app) {
     let onDiskNames = [];
     if (skillsDir2) {
       try {
-        onDiskNames = fs13.readdirSync(skillsDir2, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+        onDiskNames = fs14.readdirSync(skillsDir2, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
       } catch {
       }
     }
@@ -6096,9 +6249,9 @@ async function skillsRoutes(app) {
         name: a.name,
         source: "user",
         status: "active",
-        path: path12.join(skillsDir2 ?? "", a.name),
+        path: path14.join(skillsDir2 ?? "", a.name),
         publisher: a.publisher,
-        description: skillsDir2 ? readSkillDescription(path12.join(skillsDir2, a.name)) : void 0
+        description: skillsDir2 ? readSkillDescription(path14.join(skillsDir2, a.name)) : void 0
       })),
       // Quarantined
       ...quarantined.map((q) => ({
@@ -6113,8 +6266,8 @@ async function skillsRoutes(app) {
         name,
         source: "workspace",
         status: "workspace",
-        path: path12.join(skillsDir2 ?? "", name),
-        description: skillsDir2 ? readSkillDescription(path12.join(skillsDir2, name)) : void 0
+        path: path14.join(skillsDir2 ?? "", name),
+        description: skillsDir2 ? readSkillDescription(path14.join(skillsDir2, name)) : void 0
       })),
       // Downloaded (not installed) → available
       ...availableDownloads.map((d) => ({
@@ -6155,20 +6308,20 @@ async function skillsRoutes(app) {
       } else if (entry) {
         source = "user";
         status = "active";
-        skillPath = skillsDir2 ? path12.join(skillsDir2, name) : "";
+        skillPath = skillsDir2 ? path14.join(skillsDir2, name) : "";
       } else if (skillsDir2) {
         source = "workspace";
         status = "workspace";
-        skillPath = path12.join(skillsDir2, name);
+        skillPath = path14.join(skillsDir2, name);
       }
       let content = "";
       let metadata;
-      const dirToRead = skillPath || (skillsDir2 ? path12.join(skillsDir2, name) : "");
+      const dirToRead = skillPath || (skillsDir2 ? path14.join(skillsDir2, name) : "");
       if (dirToRead) {
         try {
           const mdPath = findSkillMdRecursive(dirToRead);
           if (mdPath) {
-            content = fs13.readFileSync(mdPath, "utf-8");
+            content = fs14.readFileSync(mdPath, "utf-8");
             const parsed = parseSkillMd(content);
             metadata = parsed?.metadata;
           }
@@ -6297,10 +6450,10 @@ async function skillsRoutes(app) {
         return reply.code(500).send({ error: "Skills directory not configured" });
       }
       const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
-      const binDir = path12.join(agentHome, "bin");
+      const binDir = path14.join(agentHome, "bin");
       const socketGroup = process.env["AGENSHIELD_SOCKET_GROUP"] || "clawshield";
-      const skillDir = path12.join(skillsDir2, name);
-      const isInstalled = fs13.existsSync(skillDir);
+      const skillDir = path14.join(skillsDir2, name);
+      const isInstalled = fs14.existsSync(skillDir);
       if (isInstalled) {
         try {
           const brokerAvailable = await isBrokerAvailable();
@@ -6310,7 +6463,7 @@ async function skillsRoutes(app) {
               agentHome
             });
           } else {
-            fs13.rmSync(skillDir, { recursive: true, force: true });
+            fs14.rmSync(skillDir, { recursive: true, force: true });
             removeSkillWrapper(name, binDir);
           }
           removeSkillEntry(name);
@@ -6344,15 +6497,15 @@ async function skillsRoutes(app) {
               throw new Error("Broker failed to install skill files");
             }
           } else {
-            fs13.mkdirSync(skillDir, { recursive: true });
+            fs14.mkdirSync(skillDir, { recursive: true });
             for (const file of files) {
-              const filePath = path12.join(skillDir, file.name);
-              fs13.mkdirSync(path12.dirname(filePath), { recursive: true });
-              fs13.writeFileSync(filePath, file.content, "utf-8");
+              const filePath = path14.join(skillDir, file.name);
+              fs14.mkdirSync(path14.dirname(filePath), { recursive: true });
+              fs14.writeFileSync(filePath, file.content, "utf-8");
             }
             try {
-              execSync8(`chown -R root:${socketGroup} "${skillDir}"`, { stdio: "pipe" });
-              execSync8(`chmod -R a+rX,go-w "${skillDir}"`, { stdio: "pipe" });
+              execSync9(`chown -R root:${socketGroup} "${skillDir}"`, { stdio: "pipe" });
+              execSync9(`chmod -R a+rX,go-w "${skillDir}"`, { stdio: "pipe" });
             } catch {
             }
             createSkillWrapper(name, binDir);
@@ -6363,8 +6516,8 @@ async function skillsRoutes(app) {
           return reply.send({ success: true, action: "enabled", name });
         } catch (err) {
           try {
-            if (fs13.existsSync(skillDir)) {
-              fs13.rmSync(skillDir, { recursive: true, force: true });
+            if (fs14.existsSync(skillDir)) {
+              fs14.rmSync(skillDir, { recursive: true, force: true });
             }
             removeFromApprovedList(name);
           } catch {
@@ -6402,20 +6555,20 @@ async function skillsRoutes(app) {
         return reply.code(500).send({ error: "Skills directory not configured" });
       }
       const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
-      const binDir = path12.join(agentHome, "bin");
+      const binDir = path14.join(agentHome, "bin");
       const socketGroup = process.env["AGENSHIELD_SOCKET_GROUP"] || "clawshield";
-      const skillDir = path12.join(skillsDir2, name);
+      const skillDir = path14.join(skillsDir2, name);
       try {
         addToApprovedList(name, publisher);
-        fs13.mkdirSync(skillDir, { recursive: true });
+        fs14.mkdirSync(skillDir, { recursive: true });
         for (const file of files) {
-          const filePath = path12.join(skillDir, file.name);
-          fs13.mkdirSync(path12.dirname(filePath), { recursive: true });
-          fs13.writeFileSync(filePath, file.content, "utf-8");
+          const filePath = path14.join(skillDir, file.name);
+          fs14.mkdirSync(path14.dirname(filePath), { recursive: true });
+          fs14.writeFileSync(filePath, file.content, "utf-8");
         }
         try {
-          execSync8(`chown -R root:${socketGroup} "${skillDir}"`, { stdio: "pipe" });
-          execSync8(`chmod -R a+rX,go-w "${skillDir}"`, { stdio: "pipe" });
+          execSync9(`chown -R root:${socketGroup} "${skillDir}"`, { stdio: "pipe" });
+          execSync9(`chmod -R a+rX,go-w "${skillDir}"`, { stdio: "pipe" });
         } catch {
         }
         createSkillWrapper(name, binDir);
@@ -6423,8 +6576,8 @@ async function skillsRoutes(app) {
         return reply.send({ success: true, name, analysis });
       } catch (err) {
         try {
-          if (fs13.existsSync(skillDir)) {
-            fs13.rmSync(skillDir, { recursive: true, force: true });
+          if (fs14.existsSync(skillDir)) {
+            fs14.rmSync(skillDir, { recursive: true, force: true });
           }
           removeFromApprovedList(name);
         } catch {
@@ -6439,8 +6592,8 @@ async function skillsRoutes(app) {
 }
 
 // libs/shield-daemon/src/routes/exec.ts
-import * as fs14 from "node:fs";
-import * as path13 from "node:path";
+import * as fs15 from "node:fs";
+import * as path15 from "node:path";
 var ALLOWED_COMMANDS_PATH2 = "/opt/agenshield/config/allowed-commands.json";
 var BIN_DIRS = [
   "/usr/bin",
@@ -6453,22 +6606,22 @@ var binCache = null;
 var BIN_CACHE_TTL = 6e4;
 var VALID_NAME = /^[a-zA-Z0-9_-]+$/;
 function loadConfig2() {
-  if (!fs14.existsSync(ALLOWED_COMMANDS_PATH2)) {
+  if (!fs15.existsSync(ALLOWED_COMMANDS_PATH2)) {
     return { version: "1.0.0", commands: [] };
   }
   try {
-    const content = fs14.readFileSync(ALLOWED_COMMANDS_PATH2, "utf-8");
+    const content = fs15.readFileSync(ALLOWED_COMMANDS_PATH2, "utf-8");
     return JSON.parse(content);
   } catch {
     return { version: "1.0.0", commands: [] };
   }
 }
 function saveConfig2(config) {
-  const dir = path13.dirname(ALLOWED_COMMANDS_PATH2);
-  if (!fs14.existsSync(dir)) {
-    fs14.mkdirSync(dir, { recursive: true });
+  const dir = path15.dirname(ALLOWED_COMMANDS_PATH2);
+  if (!fs15.existsSync(dir)) {
+    fs15.mkdirSync(dir, { recursive: true });
   }
-  fs14.writeFileSync(ALLOWED_COMMANDS_PATH2, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  fs15.writeFileSync(ALLOWED_COMMANDS_PATH2, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
 function scanSystemBins() {
   const pathDirs = (process.env.PATH ?? "").split(":").filter(Boolean);
@@ -6477,13 +6630,13 @@ function scanSystemBins() {
   const results = [];
   for (const dir of allDirs) {
     try {
-      if (!fs14.existsSync(dir)) continue;
-      const entries = fs14.readdirSync(dir);
+      if (!fs15.existsSync(dir)) continue;
+      const entries = fs15.readdirSync(dir);
       for (const entry of entries) {
         if (seen.has(entry)) continue;
-        const fullPath = path13.join(dir, entry);
+        const fullPath = path15.join(dir, entry);
         try {
-          const stat = fs14.statSync(fullPath);
+          const stat = fs15.statSync(fullPath);
           if (stat.isFile() && (stat.mode & 73) !== 0) {
             seen.add(entry);
             results.push({ name: entry, path: fullPath });
@@ -6536,7 +6689,7 @@ async function execRoutes(app) {
       };
     }
     for (const p of paths) {
-      if (!path13.isAbsolute(p)) {
+      if (!path15.isAbsolute(p)) {
         return {
           success: false,
           error: {
@@ -6963,8 +7116,8 @@ async function secretsRoutes(app) {
 }
 
 // libs/shield-daemon/src/routes/marketplace.ts
-import * as fs15 from "node:fs";
-import * as path14 from "node:path";
+import * as fs16 from "node:fs";
+import * as path16 from "node:path";
 async function marketplaceRoutes(app) {
   app.get(
     "/marketplace/search",
@@ -7160,9 +7313,9 @@ async function marketplaceRoutes(app) {
           return reply.code(500).send({ error: "Skills directory not configured" });
         }
         const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
-        const binDir = path14.join(agentHome, "bin");
+        const binDir = path16.join(agentHome, "bin");
         const socketGroup = process.env["AGENSHIELD_SOCKET_GROUP"] || "clawshield";
-        skillDir = path14.join(skillsDir2, slug);
+        skillDir = path16.join(skillsDir2, slug);
         emitSkillInstallProgress(slug, "approve", "Pre-approving skill");
         addToApprovedList(slug, publisher);
         logs.push("Skill pre-approved");
@@ -7205,8 +7358,8 @@ async function marketplaceRoutes(app) {
         });
       } catch (err) {
         try {
-          if (skillDir && fs15.existsSync(skillDir)) {
-            fs15.rmSync(skillDir, { recursive: true, force: true });
+          if (skillDir && fs16.existsSync(skillDir)) {
+            fs16.rmSync(skillDir, { recursive: true, force: true });
           }
           removeFromApprovedList(slug);
         } catch {
@@ -7229,18 +7382,18 @@ async function marketplaceRoutes(app) {
 }
 
 // libs/shield-daemon/src/routes/fs.ts
-import * as fs16 from "node:fs";
-import * as path15 from "node:path";
+import * as fs17 from "node:fs";
+import * as path17 from "node:path";
 import * as os5 from "node:os";
 var MAX_ENTRIES = 200;
 async function fsRoutes(app) {
   app.get("/fs/browse", async (request) => {
     const dirPath = request.query.path || os5.homedir();
     const showHidden = request.query.showHidden === "true";
-    const resolvedPath = path15.resolve(dirPath);
+    const resolvedPath = path17.resolve(dirPath);
     let dirents;
     try {
-      dirents = fs16.readdirSync(resolvedPath, { withFileTypes: true });
+      dirents = fs17.readdirSync(resolvedPath, { withFileTypes: true });
     } catch {
       return { success: true, data: { entries: [] } };
     }
@@ -7249,7 +7402,7 @@ async function fsRoutes(app) {
       if (!showHidden && dirent.name.startsWith(".")) continue;
       entries.push({
         name: dirent.name,
-        path: path15.join(resolvedPath, dirent.name),
+        path: path17.join(resolvedPath, dirent.name),
         type: dirent.isDirectory() ? "directory" : "file"
       });
       if (entries.length >= MAX_ENTRIES) break;
@@ -7263,8 +7416,8 @@ async function fsRoutes(app) {
 }
 
 // libs/shield-daemon/src/services/activity-log.ts
-import * as fs17 from "node:fs";
-import * as path16 from "node:path";
+import * as fs18 from "node:fs";
+import * as path18 from "node:path";
 var ACTIVITY_FILE = "activity.jsonl";
 var MAX_SIZE_BYTES = 100 * 1024 * 1024;
 var MAX_AGE_MS = 24 * 60 * 60 * 1e3;
@@ -7281,12 +7434,12 @@ var ActivityLog = class {
   writeCount = 0;
   unsubscribe;
   constructor() {
-    this.filePath = path16.join(getConfigDir(), ACTIVITY_FILE);
+    this.filePath = path18.join(getConfigDir(), ACTIVITY_FILE);
   }
   /** Read historical events from the JSONL file, newest first */
   getHistory(limit = 500) {
-    if (!fs17.existsSync(this.filePath)) return [];
-    const content = fs17.readFileSync(this.filePath, "utf-8");
+    if (!fs18.existsSync(this.filePath)) return [];
+    const content = fs18.readFileSync(this.filePath, "utf-8");
     const lines = content.split("\n").filter(Boolean);
     const events = [];
     for (const line of lines) {
@@ -7311,7 +7464,7 @@ var ActivityLog = class {
   }
   append(event) {
     const line = JSON.stringify(event) + "\n";
-    fs17.appendFileSync(this.filePath, line, "utf-8");
+    fs18.appendFileSync(this.filePath, line, "utf-8");
     this.writeCount++;
     if (this.writeCount % PRUNE_INTERVAL === 0) {
       this.rotate();
@@ -7319,7 +7472,7 @@ var ActivityLog = class {
   }
   rotate() {
     try {
-      const stat = fs17.statSync(this.filePath);
+      const stat = fs18.statSync(this.filePath);
       if (stat.size > MAX_SIZE_BYTES) {
         this.truncateBySize();
       }
@@ -7329,15 +7482,15 @@ var ActivityLog = class {
   }
   /** Keep newest half of lines when file exceeds size limit */
   truncateBySize() {
-    const content = fs17.readFileSync(this.filePath, "utf-8");
+    const content = fs18.readFileSync(this.filePath, "utf-8");
     const lines = content.split("\n").filter(Boolean);
     const keep = lines.slice(Math.floor(lines.length / 2));
-    fs17.writeFileSync(this.filePath, keep.join("\n") + "\n", "utf-8");
+    fs18.writeFileSync(this.filePath, keep.join("\n") + "\n", "utf-8");
   }
   /** Remove entries older than 24 hours */
   pruneOldEntries() {
-    if (!fs17.existsSync(this.filePath)) return;
-    const content = fs17.readFileSync(this.filePath, "utf-8");
+    if (!fs18.existsSync(this.filePath)) return;
+    const content = fs18.readFileSync(this.filePath, "utf-8");
     const lines = content.split("\n").filter(Boolean);
     const cutoff = Date.now() - MAX_AGE_MS;
     const kept = lines.filter((line) => {
@@ -7349,7 +7502,7 @@ var ActivityLog = class {
       }
     });
     if (kept.length < lines.length) {
-      fs17.writeFileSync(this.filePath, kept.join("\n") + "\n", "utf-8");
+      fs18.writeFileSync(this.filePath, kept.join("\n") + "\n", "utf-8");
     }
   }
 };
@@ -7396,11 +7549,11 @@ function normalizeUrlTarget(url) {
   const trimmed = url.trim();
   try {
     const parsed = new URL(trimmed);
-    let path18 = parsed.pathname;
-    if (path18.length > 1) {
-      path18 = path18.replace(/\/+$/, "");
+    let path20 = parsed.pathname;
+    if (path20.length > 1) {
+      path20 = path20.replace(/\/+$/, "");
     }
-    return `${parsed.protocol}//${parsed.host}${path18}${parsed.search}`;
+    return `${parsed.protocol}//${parsed.host}${path20}${parsed.search}`;
   } catch {
     return trimmed.replace(/\/+$/, "");
   }
@@ -7634,22 +7787,22 @@ async function registerRoutes(app) {
 }
 
 // libs/shield-daemon/src/static.ts
-import * as fs18 from "node:fs";
-import * as path17 from "node:path";
+import * as fs19 from "node:fs";
+import * as path19 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var __filename = fileURLToPath2(import.meta.url);
-var __dirname = path17.dirname(__filename);
+var __dirname = path19.dirname(__filename);
 function getUiAssetsPath() {
-  const pkgRootPath = path17.join(__dirname, "..", "ui-assets");
-  if (fs18.existsSync(pkgRootPath)) {
+  const pkgRootPath = path19.join(__dirname, "..", "ui-assets");
+  if (fs19.existsSync(pkgRootPath)) {
     return pkgRootPath;
   }
-  const bundledPath = path17.join(__dirname, "ui-assets");
-  if (fs18.existsSync(bundledPath)) {
+  const bundledPath = path19.join(__dirname, "ui-assets");
+  if (fs19.existsSync(bundledPath)) {
     return bundledPath;
   }
-  const devPath = path17.join(__dirname, "..", "..", "..", "dist", "apps", "shield-ui");
-  if (fs18.existsSync(devPath)) {
+  const devPath = path19.join(__dirname, "..", "..", "..", "dist", "apps", "shield-ui");
+  if (fs19.existsSync(devPath)) {
     return devPath;
   }
   return null;
@@ -7738,8 +7891,8 @@ async function startServer(config) {
   startSecurityWatcher(1e4);
   const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
   const skillsDir2 = `${agentHome}/.openclaw/skills`;
-  if (!fs19.existsSync(skillsDir2)) {
-    fs19.mkdirSync(skillsDir2, { recursive: true, mode: 493 });
+  if (!fs20.existsSync(skillsDir2)) {
+    fs20.mkdirSync(skillsDir2, { recursive: true, mode: 493 });
     console.log(`[Daemon] Created skills directory: ${skillsDir2}`);
   }
   startSkillsWatcher(skillsDir2, {
@@ -7775,10 +7928,10 @@ async function main() {
   ensureConfigDir();
   const config = loadConfig();
   const pidPath = getPidPath();
-  fs20.writeFileSync(pidPath, process.pid.toString(), "utf-8");
+  fs21.writeFileSync(pidPath, process.pid.toString(), "utf-8");
   const cleanup = () => {
-    if (fs20.existsSync(pidPath)) {
-      fs20.unlinkSync(pidPath);
+    if (fs21.existsSync(pidPath)) {
+      fs21.unlinkSync(pidPath);
     }
     process.exit(0);
   };