@agenshield/daemon 0.7.0 → 0.7.1

package/main.js

@@ -1044,10 +1044,7 @@ PLISTEOF`);
 }
 async function startOpenClawServices() {
   try {
-    try {
-      await execAsync3(`sudo launchctl kickstart system/${OPENCLAW_GATEWAY_LABEL}`);
-    } catch {
-    }
+    await execAsync3(`sudo launchctl kickstart system/${OPENCLAW_GATEWAY_LABEL}`);
     return {
       success: true,
       message: "OpenClaw gateway started"
@@ -1062,10 +1059,7 @@ async function startOpenClawServices() {
 }
 async function stopOpenClawServices() {
   try {
-    try {
-      await execAsync3(`sudo launchctl kill SIGTERM system/${OPENCLAW_GATEWAY_LABEL}`);
-    } catch {
-    }
+    await execAsync3(`sudo launchctl kill SIGTERM system/${OPENCLAW_GATEWAY_LABEL}`);
     return {
       success: true,
       message: "OpenClaw gateway stopped"
@@ -1080,10 +1074,7 @@ async function stopOpenClawServices() {
 }
 async function restartOpenClawServices() {
   try {
-    try {
-      await execAsync3(`sudo launchctl kickstart -k system/${OPENCLAW_GATEWAY_LABEL}`);
-    } catch {
-    }
+    await execAsync3(`sudo launchctl kickstart -k system/${OPENCLAW_GATEWAY_LABEL}`);
     return {
       success: true,
       message: "OpenClaw gateway restarted"
@@ -1166,15 +1157,29 @@ function getOpenClawStatusSync() {
 async function getOpenClawDashboardUrl() {
   try {
     const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
-    const agentUsername = path22.basename(agentHome);
-    const { stdout, stderr } = await execAsync3(
-      `sudo -H -u ${agentUsername} ${OPENCLAW_LAUNCHER_PATH} dashboard`,
-      { timeout: 15e3, maxBuffer: 10 * 1024 * 1024 }
-    );
-    const url = stdout.trim();
-    if (!url) {
-      return { success: false, error: stderr.trim() || "No URL returned from openclaw dashboard" };
+    const configPath = path22.join(agentHome, ".openclaw", "openclaw.json");
+    let raw;
+    try {
+      raw = await fs32.readFile(configPath, "utf-8");
+    } catch (err) {
+      if (err.code === "EACCES") {
+        const agentUsername = path22.basename(agentHome);
+        const { stdout } = await execAsync3(
+          `sudo -H -u ${agentUsername} cat "${configPath}"`,
+          { cwd: "/" }
+        );
+        raw = stdout;
+      } else {
+        return { success: false, error: `Cannot read openclaw.json: ${err.message}` };
+      }
+    }
+    const config = JSON.parse(raw);
+    const port = config.gateway?.port;
+    const token = config.gateway?.auth?.token;
+    if (!port || !token) {
+      return { success: false, error: "Gateway port or auth token not found in openclaw.json" };
     }
+    const url = `http://127.0.0.1:${port}/?token=${token}`;
     return { success: true, url };
   } catch (error) {
     return { success: false, error: `Failed to get dashboard URL: ${error.message}` };
@@ -1761,7 +1766,7 @@ var init_secret_sync = __esm({
 });
 
 // libs/shield-daemon/src/main.ts
-import * as fs23 from "node:fs";
+import * as fs24 from "node:fs";
 
 // libs/shield-daemon/src/config/index.ts
 init_paths();
@@ -1769,7 +1774,7 @@ init_defaults();
 init_loader();
 
 // libs/shield-daemon/src/server.ts
-import * as fs21 from "node:fs";
+import * as fs23 from "node:fs";
 import Fastify from "fastify";
 import cors from "@fastify/cors";
 import fastifyStatic from "@fastify/static";
@@ -2141,11 +2146,24 @@ function getOpenClawConfigPath() {
   const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
   return path8.join(agentHome, ".openclaw", "openclaw.json");
 }
-function readConfig() {
+function readOpenClawConfig() {
   const configPath = getOpenClawConfigPath();
   try {
     if (fs8.existsSync(configPath)) {
-      return JSON.parse(fs8.readFileSync(configPath, "utf-8"));
+      try {
+        return JSON.parse(fs8.readFileSync(configPath, "utf-8"));
+      } catch (err) {
+        if (err.code === "EACCES") {
+          const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
+          const agentUsername = path8.basename(agentHome);
+          const raw = execSync6(
+            `sudo -H -u ${agentUsername} cat "${configPath}"`,
+            { encoding: "utf-8", cwd: "/", stdio: ["pipe", "pipe", "pipe"] }
+          );
+          return JSON.parse(raw);
+        }
+        throw err;
+      }
     }
   } catch {
     console.warn("[OpenClawConfig] Failed to read openclaw.json, starting fresh");
@@ -2163,7 +2181,7 @@ function writeConfig(config) {
       const agentUsername = path8.basename(agentHome);
       execSync6(
         `sudo -H -u ${agentUsername} tee "${configPath}" > /dev/null`,
-        { input: JSON.stringify(config, null, 2), stdio: ["pipe", "pipe", "pipe"] }
+        { input: JSON.stringify(config, null, 2), stdio: ["pipe", "pipe", "pipe"], cwd: "/" }
       );
     } else {
       throw err;
@@ -2171,27 +2189,30 @@ function writeConfig(config) {
   }
 }
 function addSkillEntry(slug) {
-  const config = readConfig();
+  const config = readOpenClawConfig();
   if (!config.skills) {
     config.skills = {};
   }
   if (!config.skills.entries) {
     config.skills.entries = {};
   }
-  config.skills.entries[slug] = { enabled: true };
+  const existing = config.skills.entries[slug] ?? {};
+  config.skills.entries[slug] = { ...existing, enabled: true };
   writeConfig(config);
   console.log(`[OpenClawConfig] Added skill entry: ${slug}`);
 }
 function removeSkillEntry(slug) {
-  const config = readConfig();
+  const config = readOpenClawConfig();
   if (config.skills?.entries?.[slug]) {
-    delete config.skills.entries[slug];
+    const existing = config.skills.entries[slug];
+    delete existing.env;
+    config.skills.entries[slug] = { ...existing, enabled: false };
     writeConfig(config);
-    console.log(`[OpenClawConfig] Removed skill entry: ${slug}`);
+    console.log(`[OpenClawConfig] Disabled skill entry: ${slug}`);
   }
 }
 function syncOpenClawFromPolicies(policies) {
-  const config = readConfig();
+  const config = readOpenClawConfig();
   if (!config.skills) config.skills = {};
   const allowBundled = [];
   for (const p of policies) {
@@ -2439,35 +2460,35 @@ var ANALYSIS_TIMEOUT = 4 * 6e4;
 var SEARCH_CACHE_TTL = 6e4;
 var DETAIL_CACHE_TTL = 5 * 6e4;
 var SHORT_TIMEOUT = 1e4;
-async function convexAction(path21, args, timeout) {
+async function convexAction(path24, 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: path21, args, format: "json" })
+    body: JSON.stringify({ path: path24, args, format: "json" })
   });
   if (!res.ok) {
-    throw new Error(`Convex action ${path21} returned ${res.status}`);
+    throw new Error(`Convex action ${path24} returned ${res.status}`);
   }
   const body = await res.json();
   if (body.status === "error") {
-    throw new Error(`Convex action ${path21}: ${body.errorMessage ?? "unknown error"}`);
+    throw new Error(`Convex action ${path24}: ${body.errorMessage ?? "unknown error"}`);
   }
   return body.value;
 }
-async function convexQuery(path21, args, timeout) {
+async function convexQuery(path24, 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: path21, args, format: "json" })
+    body: JSON.stringify({ path: path24, args, format: "json" })
   });
   if (!res.ok) {
-    throw new Error(`Convex query ${path21} returned ${res.status}`);
+    throw new Error(`Convex query ${path24} returned ${res.status}`);
   }
   const body = await res.json();
   if (body.status === "error") {
-    throw new Error(`Convex query ${path21}: ${body.errorMessage ?? "unknown error"}`);
+    throw new Error(`Convex query ${path24}: ${body.errorMessage ?? "unknown error"}`);
   }
   return body.value;
 }
@@ -2669,9 +2690,9 @@ function inlineImagesInMarkdown(markdown, files) {
     const mime = isImageExt(file.name);
     if (mime && file.content.startsWith("data:")) {
       imageMap.set(file.name, file.content);
-      const basename3 = file.name.split("/").pop() ?? "";
-      if (basename3 && !imageMap.has(basename3)) {
-        imageMap.set(basename3, file.content);
+      const basename6 = file.name.split("/").pop() ?? "";
+      if (basename6 && !imageMap.has(basename6)) {
+        imageMap.set(basename6, file.content);
       }
     }
   }
@@ -3197,10 +3218,10 @@ function emitSecurityWarning(warning) {
 function emitSecurityCritical(issue) {
   daemonEvents.broadcast("security:critical", { message: issue });
 }
-function emitApiRequest(method, path21, statusCode, duration, requestBody, responseBody) {
+function emitApiRequest(method, path24, statusCode, duration, requestBody, responseBody) {
   daemonEvents.broadcast("api:request", {
     method,
-    path: path21,
+    path: path24,
     statusCode,
     duration,
     ...requestBody !== void 0 && { requestBody },
@@ -3455,26 +3476,16 @@ function scanSkills() {
 }
 function detectOpenClawMismatches() {
   try {
-    const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
-    const configPath = path11.join(agentHome, ".openclaw", "openclaw.json");
-    if (!fs11.existsSync(configPath)) return;
-    const raw = fs11.readFileSync(configPath, "utf-8");
-    const config = JSON.parse(raw);
-    if (!config.skills?.entries) return;
     const approved = loadApprovedSkills();
     const approvedNames = new Set(approved.map((a) => a.name));
-    const entries = Object.keys(config.skills.entries);
-    let changed = false;
-    for (const name of entries) {
+    const config = readOpenClawConfig();
+    if (!config.skills?.entries) return;
+    for (const name of Object.keys(config.skills.entries)) {
       if (!approvedNames.has(name)) {
-        delete config.skills.entries[name];
-        changed = true;
-        console.log(`[SkillsWatcher] Removed stale openclaw.json entry: ${name}`);
+        removeSkillEntry(name);
+        console.log(`[SkillsWatcher] Disabled stale openclaw.json entry: ${name}`);
       }
     }
-    if (changed) {
-      fs11.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
-    }
   } catch {
   }
 }
@@ -4030,16 +4041,16 @@ var PROTECTED_ROUTES = [
   { method: "POST", path: "/api/skills/install" },
   { method: "GET", path: "/api/openclaw/dashboard-url" }
 ];
-function isProtectedRoute(method, path21) {
+function isProtectedRoute(method, path24) {
   return PROTECTED_ROUTES.some(
-    (route) => route.method === method && path21.startsWith(route.path)
+    (route) => route.method === method && path24.startsWith(route.path)
   );
 }
 function createAuthHook() {
   return async (request2, reply) => {
     const method = request2.method;
-    const path21 = request2.url.split("?")[0];
-    if (!isProtectedRoute(method, path21)) {
+    const path24 = request2.url.split("?")[0];
+    if (!isProtectedRoute(method, path24)) {
       return;
     }
     if (!isAuthenticated(request2)) {
@@ -7538,19 +7549,50 @@ async function agencoRoutes(app) {
 }
 
 // libs/shield-daemon/src/routes/skills.ts
-import * as fs16 from "node:fs";
-import * as path16 from "node:path";
+import * as fs17 from "node:fs";
+import * as path17 from "node:path";
 import { execSync as execSync9 } from "node:child_process";
-import { parseSkillMd as parseSkillMd2 } from "@agenshield/sandbox";
+import { parseSkillMd as parseSkillMd3, stripEnvFromSkillMd as stripEnvFromSkillMd2 } from "@agenshield/sandbox";
 
 // libs/shield-daemon/src/services/skill-lifecycle.ts
 import * as fs14 from "node:fs";
 import * as path14 from "node:path";
 import { execSync as execSync8 } from "node:child_process";
-function createSkillWrapper(name, binDir) {
-  if (!fs14.existsSync(binDir)) {
-    fs14.mkdirSync(binDir, { recursive: true });
+function sudoMkdir(dir, agentUsername) {
+  try {
+    fs14.mkdirSync(dir, { recursive: true });
+  } catch (err) {
+    if (err.code === "EACCES") {
+      execSync8(`sudo -H -u ${agentUsername} /bin/mkdir -p "${dir}"`, { cwd: "/", stdio: "pipe" });
+    } else {
+      throw err;
+    }
+  }
+}
+function sudoWriteFile(filePath, content, agentUsername, mode) {
+  try {
+    fs14.writeFileSync(filePath, content, { mode });
+  } catch (err) {
+    if (err.code === "EACCES") {
+      execSync8(
+        `sudo -H -u ${agentUsername} tee "${filePath}" > /dev/null`,
+        { input: content, cwd: "/", stdio: ["pipe", "pipe", "pipe"] }
+      );
+      if (mode) {
+        try {
+          execSync8(`sudo -H -u ${agentUsername} chmod ${mode.toString(8)} "${filePath}"`, { cwd: "/", stdio: "pipe" });
+        } catch {
+        }
+      }
+    } else {
+      throw err;
+    }
   }
+}
+function createSkillWrapper(name, binDir) {
+  const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
+  const agentUsername = path14.basename(agentHome);
+  sudoMkdir(binDir, agentUsername);
   const wrapperPath = path14.join(binDir, name);
   const wrapperContent = `#!/bin/bash
 # ${name} skill wrapper - policy-enforced execution
@@ -7558,7 +7600,7 @@ function createSkillWrapper(name, binDir) {
 if ! /bin/pwd > /dev/null 2>&1; then cd ~ 2>/dev/null || cd /; fi
 exec /opt/agenshield/bin/shield-client skill run "${name}" "$@"
 `;
-  fs14.writeFileSync(wrapperPath, wrapperContent, { mode: 493 });
+  sudoWriteFile(wrapperPath, wrapperContent, agentUsername, 493);
   const socketGroup = process.env["AGENSHIELD_SOCKET_GROUP"] || "ash_default";
   try {
     execSync8(`chown root:${socketGroup} "${wrapperPath}"`, { stdio: "pipe" });
@@ -7603,8 +7645,8 @@ function removeSkillPolicy(name) {
 }
 
 // libs/shield-daemon/src/routes/marketplace.ts
-import * as fs15 from "node:fs";
-import * as path15 from "node:path";
+import * as fs16 from "node:fs";
+import * as path16 from "node:path";
 
 // libs/shield-broker/dist/index.js
 import { exec as exec4 } from "node:child_process";
@@ -7880,6 +7922,175 @@ async function uninstallSkillViaBroker(slug, options = {}) {
   return result;
 }
 
+// libs/shield-daemon/src/routes/marketplace.ts
+import { stripEnvFromSkillMd } from "@agenshield/sandbox";
+
+// libs/shield-daemon/src/services/skill-deps.ts
+import * as fs15 from "node:fs";
+import * as path15 from "node:path";
+import { parseSkillMd as parseSkillMd2, extractSkillInfo } from "@agenshield/sandbox";
+import { execWithProgress as execWithProgress3 } from "@agenshield/sandbox";
+var SUPPORTED_KINDS = /* @__PURE__ */ new Set(["brew", "npm", "pip"]);
+var SAFE_PACKAGE_RE = /^[a-zA-Z0-9@/_.\-]+$/;
+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 = path15.join(dir, name);
+      if (fs15.existsSync(candidate)) return candidate;
+    }
+    const entries = fs15.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const found = findSkillMdRecursive(path15.join(dir, entry.name), depth + 1);
+      if (found) return found;
+    }
+  } catch {
+  }
+  return null;
+}
+async function executeSkillInstallSteps(options) {
+  const { slug, skillDir, agentHome, agentUsername, onLog } = options;
+  const installed = [];
+  const errors = [];
+  const skillMdPath = findSkillMdRecursive(skillDir);
+  if (!skillMdPath) {
+    return { success: true, installed, errors };
+  }
+  let content;
+  try {
+    content = fs15.readFileSync(skillMdPath, "utf-8");
+  } catch {
+    return { success: true, installed, errors };
+  }
+  const parsed = parseSkillMd2(content);
+  if (!parsed) {
+    return { success: true, installed, errors };
+  }
+  const info = extractSkillInfo(parsed.metadata);
+  const installSteps = info.installSteps;
+  if (!Array.isArray(installSteps) || installSteps.length === 0) {
+    return { success: true, installed, errors };
+  }
+  onLog(`Found ${installSteps.length} dependency install step(s) for ${slug}`);
+  for (const step of installSteps) {
+    const kind = step.kind;
+    const stepId = step.id || kind;
+    if (!SUPPORTED_KINDS.has(kind)) {
+      errors.push(`Unsupported install kind "${kind}" (step: ${stepId})`);
+      continue;
+    }
+    try {
+      switch (kind) {
+        case "brew": {
+          const formula = step.formula;
+          if (!formula) {
+            errors.push(`Brew step "${stepId}" missing formula`);
+            break;
+          }
+          if (!SAFE_PACKAGE_RE.test(formula)) {
+            errors.push(`Unsafe brew formula name: ${formula}`);
+            break;
+          }
+          onLog(`Installing brew formula: ${formula}`);
+          const brewCmd = [
+            `export HOME="${agentHome}"`,
+            `export PATH="${agentHome}/homebrew/bin:${agentHome}/bin:$PATH"`,
+            `brew install ${formula}`
+          ].join(" && ");
+          await execWithProgress3(
+            `sudo -H -u ${agentUsername} /bin/bash --norc --noprofile -c '${brewCmd}'`,
+            onLog,
+            { timeout: 12e4, cwd: "/" }
+          );
+          installed.push(formula);
+          break;
+        }
+        case "npm": {
+          const pkg = step["package"];
+          if (!pkg) {
+            errors.push(`npm step "${stepId}" missing package`);
+            break;
+          }
+          if (!SAFE_PACKAGE_RE.test(pkg)) {
+            errors.push(`Unsafe npm package name: ${pkg}`);
+            break;
+          }
+          onLog(`Installing npm package: ${pkg}`);
+          const npmCmd = [
+            `export HOME="${agentHome}"`,
+            `export PATH="${agentHome}/bin:$PATH"`,
+            `source "${agentHome}/.nvm/nvm.sh" 2>/dev/null || true`,
+            `npm install -g ${pkg}`
+          ].join(" && ");
+          await execWithProgress3(
+            `sudo -H -u ${agentUsername} /bin/bash --norc --noprofile -c '${npmCmd}'`,
+            onLog,
+            { timeout: 6e4, cwd: "/" }
+          );
+          installed.push(pkg);
+          break;
+        }
+        case "pip": {
+          const pkg = step["package"];
+          if (!pkg) {
+            errors.push(`pip step "${stepId}" missing package`);
+            break;
+          }
+          if (!SAFE_PACKAGE_RE.test(pkg)) {
+            errors.push(`Unsafe pip package name: ${pkg}`);
+            break;
+          }
+          onLog(`Installing pip package: ${pkg}`);
+          const pipCmd = [
+            `export HOME="${agentHome}"`,
+            `export PATH="${agentHome}/bin:$PATH"`,
+            `pip install ${pkg}`
+          ].join(" && ");
+          await execWithProgress3(
+            `sudo -H -u ${agentUsername} /bin/bash --norc --noprofile -c '${pipCmd}'`,
+            onLog,
+            { timeout: 6e4, cwd: "/" }
+          );
+          installed.push(pkg);
+          break;
+        }
+      }
+    } catch (err) {
+      const msg = `Failed to install ${kind} dep (step: ${stepId}): ${err.message}`;
+      onLog(msg);
+      errors.push(msg);
+    }
+  }
+  const requiredBins = info.bins;
+  if (requiredBins.length > 0) {
+    onLog(`Verifying required binaries: ${requiredBins.join(", ")}`);
+    for (const bin of requiredBins) {
+      try {
+        const checkCmd = [
+          `export HOME="${agentHome}"`,
+          `export PATH="${agentHome}/homebrew/bin:${agentHome}/bin:$PATH"`,
+          `source "${agentHome}/.nvm/nvm.sh" 2>/dev/null || true`,
+          `which ${bin}`
+        ].join(" && ");
+        await execWithProgress3(
+          `sudo -H -u ${agentUsername} /bin/bash --norc --noprofile -c '${checkCmd}'`,
+          () => {
+          },
+          { timeout: 5e3, cwd: "/" }
+        );
+      } catch {
+        errors.push(`Required binary "${bin}" not found in agent PATH after install`);
+      }
+    }
+  }
+  return {
+    success: errors.length === 0,
+    installed,
+    errors
+  };
+}
+
 // libs/shield-daemon/src/routes/marketplace.ts
 var installInProgress = /* @__PURE__ */ new Set();
 function isInstallInProgress(slug) {
@@ -8134,7 +8345,7 @@ async function marketplaceRoutes(app) {
               error: "Critical vulnerability detected",
               analysis: analysisResult
             });
-            return { success: false, name: slug, analysis: analysisResult, logs };
+            return { success: false, name: slug, analysis: analysisResult, logs, depsSuccess: void 0 };
           }
           emitSkillInstallProgress(slug, "download", "Downloading skill files");
           const skill = await getMarketplaceSkill(slug);
@@ -8144,7 +8355,7 @@ async function marketplaceRoutes(app) {
               name: slug,
               error: "No files available for installation"
             });
-            return { success: false, name: slug, analysis: analysisResult, logs };
+            return { success: false, name: slug, analysis: analysisResult, logs, depsSuccess: void 0 };
           }
           const publisher = skill.author;
           logs.push("Downloaded skill files");
@@ -8153,18 +8364,23 @@ async function marketplaceRoutes(app) {
             throw new Error("Skills directory not configured");
           }
           const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
-          const binDir = path15.join(agentHome, "bin");
+          const agentUsername = path16.basename(agentHome);
+          const binDir = path16.join(agentHome, "bin");
           const socketGroup = process.env["AGENSHIELD_SOCKET_GROUP"] || "ash_default";
-          skillDir = path15.join(skillsDir2, slug);
+          skillDir = path16.join(skillsDir2, slug);
           emitSkillInstallProgress(slug, "approve", "Pre-approving skill");
           addToApprovedList(slug, publisher);
           logs.push("Skill pre-approved");
           emitSkillInstallProgress(slug, "copy", "Writing skill files");
           const brokerAvailable = await isBrokerAvailable();
           if (brokerAvailable) {
+            const sanitizedFiles = files.map((f) => ({
+              name: f.name,
+              content: /SKILL\.md$/i.test(f.name) ? stripEnvFromSkillMd(f.content) : f.content
+            }));
             const brokerResult = await installSkillViaBroker(
               slug,
-              files.map((f) => ({ name: f.name, content: f.content })),
+              sanitizedFiles,
               { createWrapper: true, agentHome, socketGroup }
             );
             if (!brokerResult.installed) {
@@ -8183,18 +8399,45 @@ async function marketplaceRoutes(app) {
             }
           } else {
             console.log(`[Marketplace] Broker unavailable, installing ${slug} directly`);
-            fs15.mkdirSync(skillDir, { recursive: true });
+            sudoMkdir(skillDir, agentUsername);
             for (const file of files) {
-              const filePath = path15.join(skillDir, file.name);
-              const fileDir = path15.dirname(filePath);
+              const filePath = path16.join(skillDir, file.name);
+              const fileDir = path16.dirname(filePath);
               if (fileDir !== skillDir) {
-                fs15.mkdirSync(fileDir, { recursive: true });
+                sudoMkdir(fileDir, agentUsername);
               }
-              fs15.writeFileSync(filePath, file.content, "utf-8");
+              const content = /SKILL\.md$/i.test(file.name) ? stripEnvFromSkillMd(file.content) : file.content;
+              sudoWriteFile(filePath, content, agentUsername);
             }
             createSkillWrapper(slug, binDir);
             logs.push(`Files written directly: ${files.length} files`);
-            logs.push(`Wrapper created: ${path15.join(binDir, slug)}`);
+            logs.push(`Wrapper created: ${path16.join(binDir, slug)}`);
+          }
+          let depsSuccess = true;
+          emitSkillInstallProgress(slug, "deps", "Installing skill dependencies");
+          try {
+            const depsResult = await executeSkillInstallSteps({
+              slug,
+              skillDir,
+              agentHome,
+              agentUsername,
+              onLog: (msg) => emitSkillInstallProgress(slug, "deps", msg)
+            });
+            if (depsResult.installed.length > 0) {
+              logs.push(`Dependencies installed: ${depsResult.installed.join(", ")}`);
+            }
+            if (depsResult.errors.length > 0) {
+              depsSuccess = false;
+              for (const err of depsResult.errors) {
+                emitSkillInstallProgress(slug, "warning", `Dependency warning: ${err}`);
+                logs.push(`Dependency warning: ${err}`);
+              }
+            }
+          } catch (err) {
+            depsSuccess = false;
+            const msg = `Dependency installation failed: ${err.message}`;
+            emitSkillInstallProgress(slug, "warning", msg);
+            logs.push(msg);
           }
           addSkillEntry(slug);
           addSkillPolicy(slug);
@@ -8206,13 +8449,14 @@ async function marketplaceRoutes(app) {
             logs.push("Integrity hash recorded");
           }
           installInProgress.delete(slug);
-          daemonEvents.broadcast("skills:installed", { name: slug, analysis: analysisResult });
+          const depsWarnings = depsSuccess ? void 0 : logs.filter((l) => l.startsWith("Dependency"));
+          daemonEvents.broadcast("skills:installed", { name: slug, analysis: analysisResult, depsWarnings });
           logs.push("Installation complete");
-          return { success: true, name: slug, analysis: analysisResult, logs };
+          return { success: true, name: slug, analysis: analysisResult, logs, depsSuccess };
         } 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 {
@@ -8221,7 +8465,7 @@ async function marketplaceRoutes(app) {
           installInProgress.delete(slug);
           daemonEvents.broadcast("skills:install_failed", { name: slug, error: errorMsg });
           console.error("[Marketplace] Install failed:", errorMsg);
-          return { success: false, name: slug, analysis: analysisResult, logs: [...logs, `Error: ${errorMsg}`] };
+          return { success: false, name: slug, analysis: analysisResult, logs: [...logs, `Error: ${errorMsg}`], depsSuccess: void 0 };
         } finally {
           installInProgress.delete(slug);
         }
@@ -8245,17 +8489,17 @@ async function marketplaceRoutes(app) {
 }
 
 // libs/shield-daemon/src/routes/skills.ts
-function findSkillMdRecursive(dir, depth = 0) {
+function findSkillMdRecursive2(dir, depth = 0) {
   if (depth > 3) return null;
   try {
     for (const name of ["SKILL.md", "skill.md", "README.md", "readme.md"]) {
-      const candidate = path16.join(dir, name);
-      if (fs16.existsSync(candidate)) return candidate;
+      const candidate = path17.join(dir, name);
+      if (fs17.existsSync(candidate)) return candidate;
     }
-    const entries = fs16.readdirSync(dir, { withFileTypes: true });
+    const entries = fs17.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const found = findSkillMdRecursive(path16.join(dir, entry.name), depth + 1);
+      const found = findSkillMdRecursive2(path17.join(dir, entry.name), depth + 1);
       if (found) return found;
     }
   } catch {
@@ -8264,10 +8508,10 @@ function findSkillMdRecursive(dir, depth = 0) {
 }
 function readSkillMetadata(skillDir) {
   try {
-    const mdPath = findSkillMdRecursive(skillDir);
+    const mdPath = findSkillMdRecursive2(skillDir);
     if (!mdPath) return {};
-    const content = fs16.readFileSync(mdPath, "utf-8");
-    const parsed = parseSkillMd2(content);
+    const content = fs17.readFileSync(mdPath, "utf-8");
+    const parsed = parseSkillMd3(content);
     const meta = parsed?.metadata;
     return {
       description: meta?.description,
@@ -8325,7 +8569,7 @@ async function skillsRoutes(app) {
     let onDiskNames = [];
     if (skillsDir2) {
       try {
-        onDiskNames = fs16.readdirSync(skillsDir2, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+        onDiskNames = fs17.readdirSync(skillsDir2, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
       } catch {
       }
     }
@@ -8335,14 +8579,14 @@ async function skillsRoutes(app) {
     const data = [
       // Approved → active (with metadata from SKILL.md + cached analysis)
       ...approved.map((a) => {
-        const meta = skillsDir2 ? readSkillMetadata(path16.join(skillsDir2, a.name)) : {};
+        const meta = skillsDir2 ? readSkillMetadata(path17.join(skillsDir2, a.name)) : {};
         const cached = getCachedAnalysis2(a.name);
         const dlMeta = getDownloadedSkillMeta(a.name);
         return {
           name: a.name,
           source: "user",
           status: "active",
-          path: path16.join(skillsDir2 ?? "", a.name),
+          path: path17.join(skillsDir2 ?? "", a.name),
           publisher: a.publisher,
           description: meta.description,
           version: meta.version,
@@ -8369,12 +8613,12 @@ async function skillsRoutes(app) {
       }),
       // Workspace: on disk but not approved or untrusted
       ...workspaceNames.map((name) => {
-        const meta = skillsDir2 ? readSkillMetadata(path16.join(skillsDir2, name)) : {};
+        const meta = skillsDir2 ? readSkillMetadata(path17.join(skillsDir2, name)) : {};
         return {
           name,
           source: "workspace",
           status: "workspace",
-          path: path16.join(skillsDir2 ?? "", name),
+          path: path17.join(skillsDir2 ?? "", name),
           description: meta.description,
           version: meta.version,
           author: meta.author,
@@ -8405,7 +8649,7 @@ async function skillsRoutes(app) {
       let isWorkspace = false;
       if (!entry && !uEntry && skillsDir2) {
         try {
-          isWorkspace = fs16.existsSync(path16.join(skillsDir2, name));
+          isWorkspace = fs17.existsSync(path17.join(skillsDir2, name));
         } catch {
         }
       }
@@ -8423,13 +8667,13 @@ async function skillsRoutes(app) {
           analysis: buildFullAnalysis(name, dlMeta?.analysis || getCachedAnalysis2(name))
         };
       } else if (entry) {
-        const meta = skillsDir2 ? readSkillMetadata(path16.join(skillsDir2, name)) : {};
+        const meta = skillsDir2 ? readSkillMetadata(path17.join(skillsDir2, name)) : {};
         const cached = getCachedAnalysis2(name);
         summary = {
           name,
           source: "user",
           status: "active",
-          path: skillsDir2 ? path16.join(skillsDir2, name) : "",
+          path: skillsDir2 ? path17.join(skillsDir2, name) : "",
           publisher: entry.publisher,
           description: meta.description,
           version: meta.version,
@@ -8438,12 +8682,12 @@ async function skillsRoutes(app) {
           analysis: buildFullAnalysis(name, dlMeta?.analysis || cached)
         };
       } else if (isWorkspace) {
-        const meta = skillsDir2 ? readSkillMetadata(path16.join(skillsDir2, name)) : {};
+        const meta = skillsDir2 ? readSkillMetadata(path17.join(skillsDir2, name)) : {};
         summary = {
           name,
           source: "workspace",
           status: "workspace",
-          path: skillsDir2 ? path16.join(skillsDir2, name) : "",
+          path: skillsDir2 ? path17.join(skillsDir2, name) : "",
           description: meta.description,
           version: meta.version,
           author: meta.author,
@@ -8468,11 +8712,11 @@ async function skillsRoutes(app) {
         return reply.code(404).send({ error: `Skill "${name}" not found` });
       }
       let content = "";
-      const dirToRead = summary.path || (skillsDir2 ? path16.join(skillsDir2, name) : "");
+      const dirToRead = summary.path || (skillsDir2 ? path17.join(skillsDir2, name) : "");
       if (dirToRead) {
         try {
-          const mdPath = findSkillMdRecursive(dirToRead);
-          if (mdPath) content = fs16.readFileSync(mdPath, "utf-8");
+          const mdPath = findSkillMdRecursive2(dirToRead);
+          if (mdPath) content = fs17.readFileSync(mdPath, "utf-8");
         } catch {
         }
       }
@@ -8510,14 +8754,14 @@ async function skillsRoutes(app) {
       if (!content) {
         const skillsDir2 = getSkillsDir();
         const possibleDirs = [
-          skillsDir2 ? path16.join(skillsDir2, name) : null
+          skillsDir2 ? path17.join(skillsDir2, name) : null
         ].filter(Boolean);
         for (const dir of possibleDirs) {
           try {
-            const mdPath = findSkillMdRecursive(dir);
+            const mdPath = findSkillMdRecursive2(dir);
             if (mdPath) {
-              content = fs16.readFileSync(mdPath, "utf-8");
-              const parsed = parseSkillMd2(content);
+              content = fs17.readFileSync(mdPath, "utf-8");
+              const parsed = parseSkillMd3(content);
               if (parsed?.metadata && !metadata) {
                 metadata = parsed.metadata;
               }
@@ -8532,7 +8776,7 @@ async function skillsRoutes(app) {
             const skillFile = localFiles.find((f) => /skill\.md/i.test(f.name));
             if (skillFile?.content) {
               content = skillFile.content;
-              const parsed = parseSkillMd2(content);
+              const parsed = parseSkillMd3(content);
               if (parsed?.metadata && !metadata) {
                 metadata = parsed.metadata;
               }
@@ -8547,7 +8791,7 @@ async function skillsRoutes(app) {
             const skillFile = freshFiles.find((f) => /skill\.md/i.test(f.name));
             if (skillFile?.content) {
               content = skillFile.content;
-              const parsed = parseSkillMd2(content);
+              const parsed = parseSkillMd3(content);
               if (parsed?.metadata && !metadata) {
                 metadata = parsed.metadata;
               }
@@ -8701,10 +8945,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 = path16.join(agentHome, "bin");
+      const binDir = path17.join(agentHome, "bin");
       const socketGroup = process.env["AGENSHIELD_SOCKET_GROUP"] || "ash_default";
-      const skillDir = path16.join(skillsDir2, name);
-      const isInstalled = fs16.existsSync(skillDir);
+      const skillDir = path17.join(skillsDir2, name);
+      const isInstalled = fs17.existsSync(skillDir);
       if (isInstalled) {
         try {
           const brokerAvailable = await isBrokerAvailable();
@@ -8714,7 +8958,7 @@ async function skillsRoutes(app) {
               agentHome
             });
           } else {
-            fs16.rmSync(skillDir, { recursive: true, force: true });
+            fs17.rmSync(skillDir, { recursive: true, force: true });
             removeSkillWrapper(name, binDir);
           }
           removeSkillEntry(name);
@@ -8759,11 +9003,11 @@ async function skillsRoutes(app) {
               }
             }
           } else {
-            fs16.mkdirSync(skillDir, { recursive: true });
+            fs17.mkdirSync(skillDir, { recursive: true });
             for (const file of files) {
-              const filePath = path16.join(skillDir, file.name);
-              fs16.mkdirSync(path16.dirname(filePath), { recursive: true });
-              fs16.writeFileSync(filePath, file.content, "utf-8");
+              const filePath = path17.join(skillDir, file.name);
+              fs17.mkdirSync(path17.dirname(filePath), { recursive: true });
+              fs17.writeFileSync(filePath, file.content, "utf-8");
             }
             try {
               execSync9(`chown -R root:${socketGroup} "${skillDir}"`, { stdio: "pipe" });
@@ -8781,8 +9025,8 @@ async function skillsRoutes(app) {
           return reply.send({ success: true, action: "enabled", name });
         } catch (err) {
           try {
-            if (fs16.existsSync(skillDir)) {
-              fs16.rmSync(skillDir, { recursive: true, force: true });
+            if (fs17.existsSync(skillDir)) {
+              fs17.rmSync(skillDir, { recursive: true, force: true });
             }
             removeFromApprovedList(name);
           } catch {
@@ -8808,7 +9052,7 @@ async function skillsRoutes(app) {
       const skillMdFile = files.find((f) => f.name === "SKILL.md");
       let metadata;
       if (skillMdFile) {
-        const parsed = parseSkillMd2(skillMdFile.content);
+        const parsed = parseSkillMd3(skillMdFile.content);
         metadata = parsed?.metadata;
       }
       const analysis = analyzeSkill(name, combinedContent, metadata);
@@ -8820,16 +9064,18 @@ 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 = path16.join(agentHome, "bin");
+      const agentUsername = path17.basename(agentHome);
+      const binDir = path17.join(agentHome, "bin");
       const socketGroup = process.env["AGENSHIELD_SOCKET_GROUP"] || "ash_default";
-      const skillDir = path16.join(skillsDir2, name);
+      const skillDir = path17.join(skillsDir2, name);
       try {
         addToApprovedList(name, publisher);
-        fs16.mkdirSync(skillDir, { recursive: true });
+        sudoMkdir(skillDir, agentUsername);
         for (const file of files) {
-          const filePath = path16.join(skillDir, file.name);
-          fs16.mkdirSync(path16.dirname(filePath), { recursive: true });
-          fs16.writeFileSync(filePath, file.content, "utf-8");
+          const filePath = path17.join(skillDir, file.name);
+          sudoMkdir(path17.dirname(filePath), agentUsername);
+          const content = /SKILL\.md$/i.test(file.name) ? stripEnvFromSkillMd2(file.content) : file.content;
+          sudoWriteFile(filePath, content, agentUsername);
         }
         try {
           execSync9(`chown -R root:${socketGroup} "${skillDir}"`, { stdio: "pipe" });
@@ -8843,8 +9089,8 @@ async function skillsRoutes(app) {
         return reply.send({ success: true, name, analysis });
       } catch (err) {
         try {
-          if (fs16.existsSync(skillDir)) {
-            fs16.rmSync(skillDir, { recursive: true, force: true });
+          if (fs17.existsSync(skillDir)) {
+            fs17.rmSync(skillDir, { recursive: true, force: true });
           }
           removeFromApprovedList(name);
         } catch {
@@ -8878,9 +9124,9 @@ async function skillsRoutes(app) {
       }
       try {
         const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
-        const binDir = path16.join(agentHome, "bin");
+        const binDir = path17.join(agentHome, "bin");
         const socketGroup = process.env["AGENSHIELD_SOCKET_GROUP"] || "ash_default";
-        const skillDir = path16.join(getSkillsDir(), name);
+        const skillDir = path17.join(getSkillsDir(), name);
         addToApprovedList(name, meta.author);
         const brokerAvailable = await isBrokerAvailable();
         if (brokerAvailable) {
@@ -8898,11 +9144,11 @@ async function skillsRoutes(app) {
             }
           }
         } else {
-          fs16.mkdirSync(skillDir, { recursive: true });
+          fs17.mkdirSync(skillDir, { recursive: true });
           for (const file of files) {
-            const filePath = path16.join(skillDir, file.name);
-            fs16.mkdirSync(path16.dirname(filePath), { recursive: true });
-            fs16.writeFileSync(filePath, file.content, "utf-8");
+            const filePath = path17.join(skillDir, file.name);
+            fs17.mkdirSync(path17.dirname(filePath), { recursive: true });
+            fs17.writeFileSync(filePath, file.content, "utf-8");
           }
           try {
             execSync9(`chown -R root:${socketGroup} "${skillDir}"`, { stdio: "pipe" });
@@ -8914,7 +9160,7 @@ async function skillsRoutes(app) {
         addSkillEntry(name);
         addSkillPolicy(name);
         syncOpenClawFromPolicies(loadConfig().policies);
-        const unblockHash = computeSkillHash(path16.join(getSkillsDir(), name));
+        const unblockHash = computeSkillHash(path17.join(getSkillsDir(), name));
         if (unblockHash) updateApprovedHash(name, unblockHash);
         console.log(`[Skills] Unblocked and installed skill: ${name}`);
         return reply.send({ success: true, message: `Skill "${name}" approved and installed` });
@@ -8945,7 +9191,7 @@ async function skillsRoutes(app) {
       const skillMdFile = files.find((f) => /skill\.md/i.test(f.name));
       if (skillMdFile) {
         try {
-          const parsed = parseSkillMd2(skillMdFile.content);
+          const parsed = parseSkillMd3(skillMdFile.content);
           if (parsed?.metadata) {
             parsedDescription = parsedDescription || parsed.metadata.description;
             parsedVersion = parsedVersion || parsed.metadata.version;
@@ -8974,10 +9220,10 @@ async function skillsRoutes(app) {
 
 // libs/shield-daemon/src/routes/exec.ts
 init_paths();
-import * as fs17 from "node:fs";
-import * as path17 from "node:path";
+import * as fs18 from "node:fs";
+import * as path18 from "node:path";
 function getAllowedCommandsPath2() {
-  return path17.join(getSystemConfigDir(), "allowed-commands.json");
+  return path18.join(getSystemConfigDir(), "allowed-commands.json");
 }
 var BIN_DIRS = [
   "/usr/bin",
@@ -8990,22 +9236,22 @@ var binCache = null;
 var BIN_CACHE_TTL = 6e4;
 var VALID_NAME = /^[a-zA-Z0-9_-]+$/;
 function loadConfig2() {
-  if (!fs17.existsSync(getAllowedCommandsPath2())) {
+  if (!fs18.existsSync(getAllowedCommandsPath2())) {
     return { version: "1.0.0", commands: [] };
   }
   try {
-    const content = fs17.readFileSync(getAllowedCommandsPath2(), "utf-8");
+    const content = fs18.readFileSync(getAllowedCommandsPath2(), "utf-8");
     return JSON.parse(content);
   } catch {
     return { version: "1.0.0", commands: [] };
   }
 }
 function saveConfig2(config) {
-  const dir = path17.dirname(getAllowedCommandsPath2());
-  if (!fs17.existsSync(dir)) {
-    fs17.mkdirSync(dir, { recursive: true });
+  const dir = path18.dirname(getAllowedCommandsPath2());
+  if (!fs18.existsSync(dir)) {
+    fs18.mkdirSync(dir, { recursive: true });
   }
-  fs17.writeFileSync(getAllowedCommandsPath2(), JSON.stringify(config, null, 2) + "\n", "utf-8");
+  fs18.writeFileSync(getAllowedCommandsPath2(), JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
 function scanSystemBins() {
   const pathDirs = (process.env.PATH ?? "").split(":").filter(Boolean);
@@ -9014,13 +9260,13 @@ function scanSystemBins() {
   const results = [];
   for (const dir of allDirs) {
     try {
-      if (!fs17.existsSync(dir)) continue;
-      const entries = fs17.readdirSync(dir);
+      if (!fs18.existsSync(dir)) continue;
+      const entries = fs18.readdirSync(dir);
       for (const entry of entries) {
         if (seen.has(entry)) continue;
-        const fullPath = path17.join(dir, entry);
+        const fullPath = path18.join(dir, entry);
         try {
-          const stat = fs17.statSync(fullPath);
+          const stat = fs18.statSync(fullPath);
           if (stat.isFile() && (stat.mode & 73) !== 0) {
             seen.add(entry);
             results.push({ name: entry, path: fullPath });
@@ -9073,7 +9319,7 @@ async function execRoutes(app) {
       };
     }
     for (const p of paths) {
-      if (!path17.isAbsolute(p)) {
+      if (!path18.isAbsolute(p)) {
         return {
           success: false,
           error: {
@@ -9569,18 +9815,18 @@ async function secretsRoutes(app) {
 }
 
 // libs/shield-daemon/src/routes/fs.ts
-import * as fs18 from "node:fs";
-import * as path18 from "node:path";
+import * as fs19 from "node:fs";
+import * as path19 from "node:path";
 import * as os6 from "node:os";
 var MAX_ENTRIES = 200;
 async function fsRoutes(app) {
   app.get("/fs/browse", async (request2) => {
     const dirPath = request2.query.path || os6.homedir();
     const showHidden = request2.query.showHidden === "true";
-    const resolvedPath = path18.resolve(dirPath);
+    const resolvedPath = path19.resolve(dirPath);
     let dirents;
     try {
-      dirents = fs18.readdirSync(resolvedPath, { withFileTypes: true });
+      dirents = fs19.readdirSync(resolvedPath, { withFileTypes: true });
     } catch {
       return { success: true, data: { entries: [] } };
     }
@@ -9589,7 +9835,7 @@ async function fsRoutes(app) {
       if (!showHidden && dirent.name.startsWith(".")) continue;
       entries.push({
         name: dirent.name,
-        path: path18.join(resolvedPath, dirent.name),
+        path: path19.join(resolvedPath, dirent.name),
         type: dirent.isDirectory() ? "directory" : "file"
       });
       if (entries.length >= MAX_ENTRIES) break;
@@ -9603,8 +9849,8 @@ async function fsRoutes(app) {
 }
 
 // libs/shield-daemon/src/services/activity-log.ts
-import * as fs19 from "node:fs";
-import * as path19 from "node:path";
+import * as fs20 from "node:fs";
+import * as path20 from "node:path";
 init_paths();
 var ACTIVITY_FILE = "activity.jsonl";
 var MAX_SIZE_BYTES = 100 * 1024 * 1024;
@@ -9622,12 +9868,12 @@ var ActivityLog = class {
   writeCount = 0;
   unsubscribe;
   constructor() {
-    this.filePath = path19.join(getConfigDir(), ACTIVITY_FILE);
+    this.filePath = path20.join(getConfigDir(), ACTIVITY_FILE);
   }
   /** Read historical events from the JSONL file, newest first */
   getHistory(limit = 500) {
-    if (!fs19.existsSync(this.filePath)) return [];
-    const content = fs19.readFileSync(this.filePath, "utf-8");
+    if (!fs20.existsSync(this.filePath)) return [];
+    const content = fs20.readFileSync(this.filePath, "utf-8");
     const lines = content.split("\n").filter(Boolean);
     const events = [];
     for (const line of lines) {
@@ -9652,7 +9898,7 @@ var ActivityLog = class {
   }
   append(event) {
     const line = JSON.stringify(event) + "\n";
-    fs19.appendFileSync(this.filePath, line, "utf-8");
+    fs20.appendFileSync(this.filePath, line, "utf-8");
     this.writeCount++;
     if (this.writeCount % PRUNE_INTERVAL === 0) {
       this.rotate();
@@ -9660,7 +9906,7 @@ var ActivityLog = class {
   }
   rotate() {
     try {
-      const stat = fs19.statSync(this.filePath);
+      const stat = fs20.statSync(this.filePath);
       if (stat.size > MAX_SIZE_BYTES) {
         this.truncateBySize();
       }
@@ -9670,15 +9916,15 @@ var ActivityLog = class {
   }
   /** Keep newest half of lines when file exceeds size limit */
   truncateBySize() {
-    const content = fs19.readFileSync(this.filePath, "utf-8");
+    const content = fs20.readFileSync(this.filePath, "utf-8");
     const lines = content.split("\n").filter(Boolean);
     const keep = lines.slice(Math.floor(lines.length / 2));
-    fs19.writeFileSync(this.filePath, keep.join("\n") + "\n", "utf-8");
+    fs20.writeFileSync(this.filePath, keep.join("\n") + "\n", "utf-8");
   }
   /** Remove entries older than 24 hours */
   pruneOldEntries() {
-    if (!fs19.existsSync(this.filePath)) return;
-    const content = fs19.readFileSync(this.filePath, "utf-8");
+    if (!fs20.existsSync(this.filePath)) return;
+    const content = fs20.readFileSync(this.filePath, "utf-8");
     const lines = content.split("\n").filter(Boolean);
     const cutoff = Date.now() - MAX_AGE_MS;
     const kept = lines.filter((line) => {
@@ -9690,7 +9936,7 @@ var ActivityLog = class {
       }
     });
     if (kept.length < lines.length) {
-      fs19.writeFileSync(this.filePath, kept.join("\n") + "\n", "utf-8");
+      fs20.writeFileSync(this.filePath, kept.join("\n") + "\n", "utf-8");
     }
   }
 };
@@ -9831,11 +10077,11 @@ function normalizeUrlTarget(url) {
   const trimmed = url.trim();
   try {
     const parsed = new URL(trimmed);
-    let path21 = parsed.pathname;
-    if (path21.length > 1) {
-      path21 = path21.replace(/\/+$/, "");
+    let path24 = parsed.pathname;
+    if (path24.length > 1) {
+      path24 = path24.replace(/\/+$/, "");
     }
-    return `${parsed.protocol}//${parsed.host}${path21}${parsed.search}`;
+    return `${parsed.protocol}//${parsed.host}${path24}${parsed.search}`;
   } catch {
     return trimmed.replace(/\/+$/, "");
   }
@@ -10121,8 +10367,8 @@ function matchCommandPattern(pattern, target) {
   const firstSpace = target.indexOf(" ");
   const cmd = firstSpace >= 0 ? target.slice(0, firstSpace) : target;
   if (cmd.startsWith("/")) {
-    const basename3 = cmd.split("/").pop() || cmd;
-    normalizedTarget = firstSpace >= 0 ? basename3 + target.slice(firstSpace) : basename3;
+    const basename6 = cmd.split("/").pop() || cmd;
+    normalizedTarget = firstSpace >= 0 ? basename6 + target.slice(firstSpace) : basename6;
   }
   if (trimmed.endsWith(":*")) {
     const prefix = trimmed.slice(0, -2);
@@ -10173,8 +10419,8 @@ function determineNetworkAccess(_config, matchedPolicy, target) {
   if (matchedPolicy?.networkAccess) return matchedPolicy.networkAccess;
   const cleanTarget = target.startsWith("fork:") ? target.slice(5) : target;
   const cmdPart = cleanTarget.split(" ")[0] || "";
-  const basename3 = cmdPart.includes("/") ? cmdPart.split("/").pop() : cmdPart;
-  if (!NETWORK_COMMANDS.has(basename3.toLowerCase())) return "none";
+  const basename6 = cmdPart.includes("/") ? cmdPart.split("/").pop() : cmdPart;
+  if (!NETWORK_COMMANDS.has(basename6.toLowerCase())) return "none";
   return "proxy";
 }
 async function buildSandboxConfig(config, matchedPolicy, _context, target) {
@@ -10475,22 +10721,22 @@ async function registerRoutes(app) {
 }
 
 // libs/shield-daemon/src/static.ts
-import * as fs20 from "node:fs";
-import * as path20 from "node:path";
+import * as fs21 from "node:fs";
+import * as path21 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var __filename = fileURLToPath2(import.meta.url);
-var __dirname = path20.dirname(__filename);
+var __dirname = path21.dirname(__filename);
 function getUiAssetsPath() {
-  const pkgRootPath = path20.join(__dirname, "..", "ui-assets");
-  if (fs20.existsSync(pkgRootPath)) {
+  const pkgRootPath = path21.join(__dirname, "..", "ui-assets");
+  if (fs21.existsSync(pkgRootPath)) {
     return pkgRootPath;
   }
-  const bundledPath = path20.join(__dirname, "ui-assets");
-  if (fs20.existsSync(bundledPath)) {
+  const bundledPath = path21.join(__dirname, "ui-assets");
+  if (fs21.existsSync(bundledPath)) {
     return bundledPath;
   }
-  const devPath = path20.join(__dirname, "..", "..", "..", "dist", "apps", "shield-ui");
-  if (fs20.existsSync(devPath)) {
+  const devPath = path21.join(__dirname, "..", "..", "..", "dist", "apps", "shield-ui");
+  if (fs21.existsSync(devPath)) {
     return devPath;
   }
   return null;
@@ -10580,8 +10826,8 @@ async function startServer(config) {
   startSecurityWatcher(1e4);
   const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
   const skillsDir2 = `${agentHome}/.openclaw/skills`;
-  if (!fs21.existsSync(skillsDir2)) {
-    fs21.mkdirSync(skillsDir2, { recursive: true, mode: 493 });
+  if (!fs23.existsSync(skillsDir2)) {
+    fs23.mkdirSync(skillsDir2, { recursive: true, mode: 493 });
     console.log(`[Daemon] Created skills directory: ${skillsDir2}`);
   }
   startSkillsWatcher(skillsDir2, {
@@ -10632,10 +10878,10 @@ async function main() {
   ensureConfigDir();
   const config = loadConfig();
   const pidPath = getPidPath();
-  fs23.writeFileSync(pidPath, process.pid.toString(), "utf-8");
+  fs24.writeFileSync(pidPath, process.pid.toString(), "utf-8");
   const cleanup = () => {
-    if (fs23.existsSync(pidPath)) {
-      fs23.unlinkSync(pidPath);
+    if (fs24.existsSync(pidPath)) {
+      fs24.unlinkSync(pidPath);
     }
     process.exit(0);
   };