@agenshield/daemon 0.4.3 → 0.5.0

package/index.js

@@ -5422,6 +5422,20 @@ function mapSearchResult(result) {
 function isTextMime(mime) {
   return mime.startsWith("text/") || mime === "application/json" || mime === "text/yaml" || mime === "text/toml";
 }
+var IMAGE_EXT_MAP = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".webp": "image/webp",
+  ".ico": "image/x-icon"
+};
+function isImageExt(filePath) {
+  const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+  return IMAGE_EXT_MAP[ext] ?? null;
+}
+var MAX_IMAGE_SIZE = 5e5;
 function getMarketplaceDir() {
   return path11.join(os4.homedir(), CONFIG_DIR2, MARKETPLACE_DIR);
 }
@@ -5444,9 +5458,19 @@ async function downloadAndExtractZip(slug) {
     const filename = zipPath.split("/").pop() || "";
     if (filename.startsWith(".")) continue;
     const mimeType = guessContentType(zipPath);
-    if (!isTextMime(mimeType)) continue;
-    const content = await zipEntry.async("text");
-    files.push({ name: zipPath, type: mimeType, content });
+    if (isTextMime(mimeType)) {
+      const content = await zipEntry.async("text");
+      files.push({ name: zipPath, type: mimeType, content });
+      continue;
+    }
+    const imageMime = isImageExt(zipPath);
+    if (imageMime) {
+      const buf = await zipEntry.async("nodebuffer");
+      if (buf.length <= MAX_IMAGE_SIZE) {
+        const dataUri = `data:${imageMime};base64,${buf.toString("base64")}`;
+        files.push({ name: zipPath, type: imageMime, content: dataUri });
+      }
+    }
   }
   return files;
 }
@@ -5528,6 +5552,34 @@ function getDownloadedSkillMeta(slug) {
   }
   return null;
 }
+function inlineImagesInMarkdown(markdown, files) {
+  const imageMap = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const mime = isImageExt(file.name);
+    if (mime && file.content.startsWith("data:")) {
+      imageMap.set(file.name, file.content);
+      const basename2 = file.name.split("/").pop() ?? "";
+      if (basename2 && !imageMap.has(basename2)) {
+        imageMap.set(basename2, file.content);
+      }
+    }
+  }
+  if (imageMap.size === 0) return markdown;
+  return markdown.replace(
+    /!\[([^\]]*)\]\(([^)]+)\)/g,
+    (_match, alt, src) => {
+      if (src.startsWith("http://") || src.startsWith("https://") || src.startsWith("data:")) {
+        return _match;
+      }
+      const normalized = src.replace(/^\.\//, "");
+      const dataUri = imageMap.get(src) ?? imageMap.get(normalized) ?? imageMap.get(normalized.split("/").pop() ?? "");
+      if (dataUri) {
+        return `![${alt}](${dataUri})`;
+      }
+      return _match;
+    }
+  );
+}
 async function searchMarketplace(query) {
   const cacheKey = `search:${query}`;
   const cached = getCached(cacheKey);
@@ -5612,6 +5664,9 @@ async function getMarketplaceSkill(slug) {
     }
   }
   const tags = tagsFromRecord(skill.tags);
+  if (readme && files.length > 0) {
+    readme = inlineImagesInMarkdown(readme, files);
+  }
   const mapped = {
     name: skill.displayName,
     slug: skill.slug,
@@ -5749,1063 +5804,1203 @@ async function getCachedAnalysis2(skillName, publisher) {
   };
 }
 
-// libs/shield-daemon/src/routes/skills.ts
-async function skillsRoutes(app) {
-  app.get("/skills", async (_request, reply) => {
-    const approved = listApproved();
-    const quarantined = listQuarantined();
-    const downloaded = listDownloadedSkills();
-    const approvedNames = new Set(approved.map((a) => a.name));
-    const availableDownloads = downloaded.filter((d) => !approvedNames.has(d.slug));
-    const skillsDir2 = getSkillsDir();
-    const data = [
-      // Approved → active
-      ...approved.map((a) => ({
-        name: a.name,
-        source: "user",
-        status: "active",
-        path: path12.join(skillsDir2 ?? "", a.name),
-        publisher: a.publisher,
-        description: void 0
-      })),
-      // Quarantined
-      ...quarantined.map((q) => ({
-        name: q.name,
-        source: "quarantine",
-        status: "quarantined",
-        path: q.originalPath,
-        description: void 0
-      })),
-      // Downloaded (not installed) → available
-      ...availableDownloads.map((d) => ({
-        name: d.slug,
-        source: "marketplace",
-        status: "downloaded",
-        description: d.description,
-        path: "",
-        publisher: d.author
-      }))
-    ];
-    return reply.send({ data });
-  });
-  app.get("/skills/quarantined", async (_request, reply) => {
-    const quarantined = listQuarantined();
-    return reply.send({ quarantined });
-  });
-  app.get(
-    "/skills/:name",
-    async (request, reply) => {
-      const { name } = request.params;
-      if (!name || typeof name !== "string") {
-        return reply.code(400).send({ error: "Skill name is required" });
-      }
-      const analysis = getCachedAnalysis(name);
-      const approved = listApproved();
-      const entry = approved.find((s) => s.name === name);
-      return reply.send({
-        success: true,
-        data: {
-          name,
-          analysis: analysis ?? null,
-          publisher: entry?.publisher ?? null
-        }
-      });
+// libs/shield-broker/dist/index.js
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import * as net2 from "node:net";
+import { randomUUID as randomUUID3 } from "node:crypto";
+var MAX_OUTPUT_SIZE = 10 * 1024 * 1024;
+var execAsync = promisify(exec);
+var BrokerClient = class {
+  socketPath;
+  httpHost;
+  httpPort;
+  timeout;
+  preferSocket;
+  constructor(options = {}) {
+    this.socketPath = options.socketPath || "/var/run/agenshield/agenshield.sock";
+    this.httpHost = options.httpHost || "localhost";
+    this.httpPort = options.httpPort || 5201;
+    this.timeout = options.timeout || 3e4;
+    this.preferSocket = options.preferSocket ?? true;
+  }
+  /**
+   * Make an HTTP request through the broker
+   */
+  async httpRequest(params, options) {
+    return this.request("http_request", params, options);
+  }
+  /**
+   * Read a file through the broker
+   */
+  async fileRead(params, options) {
+    return this.request("file_read", params, options);
+  }
+  /**
+   * Write a file through the broker
+   */
+  async fileWrite(params, options) {
+    return this.request("file_write", params, {
+      ...options,
+      channel: "socket"
+      // file_write only allowed via socket
+    });
+  }
+  /**
+   * List files through the broker
+   */
+  async fileList(params, options) {
+    return this.request("file_list", params, options);
+  }
+  /**
+   * Execute a command through the broker
+   */
+  async exec(params, options) {
+    return this.request("exec", params, {
+      ...options,
+      channel: "socket"
+      // exec only allowed via socket
+    });
+  }
+  /**
+   * Open a URL through the broker
+   */
+  async openUrl(params, options) {
+    return this.request("open_url", params, options);
+  }
+  /**
+   * Inject a secret through the broker
+   */
+  async secretInject(params, options) {
+    return this.request("secret_inject", params, {
+      ...options,
+      channel: "socket"
+      // secret_inject only allowed via socket
+    });
+  }
+  /**
+   * Ping the broker
+   */
+  async ping(echo, options) {
+    return this.request("ping", { echo }, options);
+  }
+  /**
+   * Install a skill through the broker
+   * Socket-only operation due to privileged file operations
+   */
+  async skillInstall(params, options) {
+    return this.request("skill_install", params, {
+      ...options,
+      channel: "socket"
+      // skill_install only allowed via socket
+    });
+  }
+  /**
+   * Uninstall a skill through the broker
+   * Socket-only operation due to privileged file operations
+   */
+  async skillUninstall(params, options) {
+    return this.request("skill_uninstall", params, {
+      ...options,
+      channel: "socket"
+      // skill_uninstall only allowed via socket
+    });
+  }
+  /**
+   * Check if the broker is available
+   */
+  async isAvailable() {
+    try {
+      await this.ping();
+      return true;
+    } catch {
+      return false;
     }
-  );
-  app.post(
-    "/skills/:name/analyze",
-    async (request, reply) => {
-      const { name } = request.params;
-      const { content, metadata } = request.body ?? {};
-      if (!name || typeof name !== "string") {
-        return reply.code(400).send({ error: "Skill name is required" });
-      }
-      clearCachedAnalysis(name);
-      if (content) {
-        const analysis = analyzeSkill(name, content, metadata);
-        return reply.send({ success: true, data: { analysis } });
-      }
-      return reply.send({
-        success: true,
-        data: {
-          analysis: {
-            status: "pending",
-            analyzerId: "agenshield",
-            commands: []
-          }
+  }
+  /**
+   * Make a request to the broker
+   */
+  async request(method, params, options) {
+    const channel = options?.channel || (this.preferSocket ? "socket" : "http");
+    const timeout = options?.timeout || this.timeout;
+    if (channel === "socket") {
+      try {
+        return await this.socketRequest(method, params, timeout);
+      } catch (error) {
+        if (!options?.channel) {
+          return await this.httpRequest_internal(method, params, timeout);
         }
-      });
-    }
-  );
-  app.post(
-    "/skills/:name/approve",
-    async (request, reply) => {
-      const { name } = request.params;
-      if (!name || typeof name !== "string") {
-        return reply.code(400).send({ error: "Skill name is required" });
-      }
-      const result = approveSkill(name);
-      if (!result.success) {
-        return reply.code(404).send({ error: result.error });
-      }
-      return reply.send({ success: true, message: `Skill "${name}" approved` });
-    }
-  );
-  app.delete(
-    "/skills/:name",
-    async (request, reply) => {
-      const { name } = request.params;
-      if (!name || typeof name !== "string") {
-        return reply.code(400).send({ error: "Skill name is required" });
-      }
-      const result = rejectSkill(name);
-      if (!result.success) {
-        return reply.code(404).send({ error: result.error });
+        throw error;
       }
-      return reply.send({ success: true, message: `Skill "${name}" rejected and deleted` });
+    } else {
+      return await this.httpRequest_internal(method, params, timeout);
     }
-  );
-  app.post(
-    "/skills/:name/revoke",
-    async (request, reply) => {
-      const { name } = request.params;
-      if (!name || typeof name !== "string") {
-        return reply.code(400).send({ error: "Skill name is required" });
-      }
-      const result = revokeSkill(name);
-      if (!result.success) {
-        return reply.code(500).send({ error: result.error });
-      }
-      return reply.send({ success: true, message: `Skill "${name}" approval revoked` });
-    }
-  );
-  app.put(
-    "/skills/:name/toggle",
-    async (request, reply) => {
-      const { name } = request.params;
-      if (!name || typeof name !== "string") {
-        return reply.code(400).send({ error: "Skill name is required" });
-      }
-      const skillsDir2 = getSkillsDir();
-      if (!skillsDir2) {
-        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 socketGroup = process.env["AGENSHIELD_SOCKET_GROUP"] || "clawshield";
-      const skillDir = path12.join(skillsDir2, name);
-      const isInstalled = fs13.existsSync(skillDir);
-      if (isInstalled) {
-        try {
-          fs13.rmSync(skillDir, { recursive: true, force: true });
-          removeSkillWrapper(name, binDir);
-          removeSkillEntry(name);
-          removeSkillPolicy(name);
-          removeFromApprovedList(name);
-          console.log(`[Skills] Disabled marketplace skill: ${name}`);
-          return reply.send({ success: true, action: "disabled", name });
-        } catch (err) {
-          console.error("[Skills] Disable failed:", err.message);
-          return reply.code(500).send({ error: `Disable failed: ${err.message}` });
-        }
-      } else {
-        const meta = getDownloadedSkillMeta(name);
-        if (!meta) {
-          return reply.code(404).send({ error: "Skill not found in download cache" });
-        }
-        const files = getDownloadedSkillFiles(name);
-        if (files.length === 0) {
-          return reply.code(404).send({ error: "No files in download cache for this skill" });
-        }
-        try {
-          addToApprovedList(name, meta.author);
-          fs13.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");
-          }
-          try {
-            execSync8(`chown -R root:${socketGroup} "${skillDir}"`, { stdio: "pipe" });
-            execSync8(`chmod -R a+rX,go-w "${skillDir}"`, { stdio: "pipe" });
-          } catch {
-          }
-          createSkillWrapper(name, binDir);
-          addSkillEntry(name);
-          addSkillPolicy(name);
-          console.log(`[Skills] Enabled marketplace skill: ${name}`);
-          return reply.send({ success: true, action: "enabled", name });
-        } catch (err) {
+  }
+  /**
+   * Make a request via Unix socket
+   */
+  async socketRequest(method, params, timeout) {
+    return new Promise((resolve3, reject) => {
+      const socket = net2.createConnection(this.socketPath);
+      const id = randomUUID3();
+      let responseData = "";
+      let timeoutId;
+      socket.on("connect", () => {
+        const request = {
+          jsonrpc: "2.0",
+          id,
+          method,
+          params
+        };
+        socket.write(JSON.stringify(request) + "\n");
+        timeoutId = setTimeout(() => {
+          socket.destroy();
+          reject(new Error("Request timeout"));
+        }, timeout);
+      });
+      socket.on("data", (data) => {
+        responseData += data.toString();
+        const newlineIndex = responseData.indexOf("\n");
+        if (newlineIndex !== -1) {
+          clearTimeout(timeoutId);
+          socket.end();
           try {
-            if (fs13.existsSync(skillDir)) {
-              fs13.rmSync(skillDir, { recursive: true, force: true });
+            const response = JSON.parse(
+              responseData.slice(0, newlineIndex)
+            );
+            if (response.error) {
+              const error = new Error(response.error.message);
+              error.code = response.error.code;
+              reject(error);
+            } else {
+              resolve3(response.result);
             }
-            removeFromApprovedList(name);
-          } catch {
+          } catch (error) {
+            reject(new Error("Invalid response from broker"));
           }
-          console.error("[Skills] Enable failed:", err.message);
-          return reply.code(500).send({ error: `Enable failed: ${err.message}` });
         }
+      });
+      socket.on("error", (error) => {
+        clearTimeout(timeoutId);
+        reject(error);
+      });
+    });
+  }
+  /**
+   * Make a request via HTTP
+   */
+  async httpRequest_internal(method, params, timeout) {
+    const url = `http://${this.httpHost}:${this.httpPort}/rpc`;
+    const id = randomUUID3();
+    const request = {
+      jsonrpc: "2.0",
+      id,
+      method,
+      params
+    };
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(request),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new Error(`HTTP error: ${response.status}`);
       }
-    }
-  );
-  app.post(
-    "/skills/install",
-    { preHandler: [requireAuth] },
-    async (request, reply) => {
-      const { name, files, publisher } = request.body ?? {};
-      if (!name || typeof name !== "string") {
-        return reply.code(400).send({ error: "Skill name is required" });
-      }
-      if (!Array.isArray(files) || files.length === 0) {
-        return reply.code(400).send({ error: "Files array is required" });
-      }
-      const combinedContent = files.map((f) => f.content).join("\n");
-      const skillMdFile = files.find((f) => f.name === "SKILL.md");
-      let metadata;
-      if (skillMdFile) {
-        const parsed = parseSkillMd(skillMdFile.content);
-        metadata = parsed?.metadata;
-      }
-      const analysis = analyzeSkill(name, combinedContent, metadata);
-      if (analysis.vulnerability?.level === "critical") {
-        return reply.code(400).send({ error: "Critical vulnerability detected", analysis });
-      }
-      const skillsDir2 = getSkillsDir();
-      if (!skillsDir2) {
-        return reply.code(500).send({ error: "Skills directory not configured" });
+      const jsonResponse = await response.json();
+      if (jsonResponse.error) {
+        const error = new Error(jsonResponse.error.message);
+        error.code = jsonResponse.error.code;
+        throw error;
       }
-      const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
-      const binDir = path12.join(agentHome, "bin");
-      const socketGroup = process.env["AGENSHIELD_SOCKET_GROUP"] || "clawshield";
-      const skillDir = path12.join(skillsDir2, name);
-      try {
-        addToApprovedList(name, publisher);
-        fs13.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");
-        }
-        try {
-          execSync8(`chown -R root:${socketGroup} "${skillDir}"`, { stdio: "pipe" });
-          execSync8(`chmod -R a+rX,go-w "${skillDir}"`, { stdio: "pipe" });
-        } catch {
-        }
-        createSkillWrapper(name, binDir);
-        addSkillPolicy(name);
-        return reply.send({ success: true, name, analysis });
-      } catch (err) {
-        try {
-          if (fs13.existsSync(skillDir)) {
-            fs13.rmSync(skillDir, { recursive: true, force: true });
-          }
-          removeFromApprovedList(name);
-        } catch {
-        }
-        console.error("[Skills] Install failed:", err.message);
-        return reply.code(500).send({
-          error: `Installation failed: ${err.message}`
-        });
+      return jsonResponse.result;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error.name === "AbortError") {
+        throw new Error("Request timeout");
       }
+      throw error;
     }
-  );
-}
+  }
+};
 
-// libs/shield-daemon/src/routes/exec.ts
-import * as fs14 from "node:fs";
-import * as path13 from "node:path";
-var ALLOWED_COMMANDS_PATH2 = "/opt/agenshield/config/allowed-commands.json";
-var BIN_DIRS = [
-  "/usr/bin",
-  "/usr/local/bin",
-  "/opt/homebrew/bin",
-  "/usr/sbin",
-  "/usr/local/sbin"
-];
-var binCache = null;
-var BIN_CACHE_TTL = 6e4;
-var VALID_NAME = /^[a-zA-Z0-9_-]+$/;
-function loadConfig2() {
-  if (!fs14.existsSync(ALLOWED_COMMANDS_PATH2)) {
-    return { version: "1.0.0", commands: [] };
+// libs/shield-daemon/src/services/broker-bridge.ts
+var brokerClient = null;
+function getBrokerClient() {
+  if (!brokerClient) {
+    brokerClient = new BrokerClient({
+      socketPath: process.env["AGENSHIELD_SOCKET"] || "/var/run/agenshield/agenshield.sock",
+      httpHost: "localhost",
+      httpPort: 5201,
+      // Broker uses 5201, daemon uses 5200
+      timeout: 6e4,
+      // 60s timeout for file operations
+      preferSocket: true
+    });
   }
+  return brokerClient;
+}
+async function isBrokerAvailable() {
   try {
-    const content = fs14.readFileSync(ALLOWED_COMMANDS_PATH2, "utf-8");
-    return JSON.parse(content);
+    const client = getBrokerClient();
+    return await client.isAvailable();
   } catch {
-    return { version: "1.0.0", commands: [] };
+    return false;
   }
 }
-function saveConfig2(config) {
-  const dir = path13.dirname(ALLOWED_COMMANDS_PATH2);
-  if (!fs14.existsSync(dir)) {
-    fs14.mkdirSync(dir, { recursive: true });
-  }
-  fs14.writeFileSync(ALLOWED_COMMANDS_PATH2, JSON.stringify(config, null, 2) + "\n", "utf-8");
+async function installSkillViaBroker(slug, files, options = {}) {
+  const client = getBrokerClient();
+  const brokerFiles = files.map((file) => ({
+    name: file.name,
+    content: file.content,
+    base64: false
+  }));
+  const result = await client.skillInstall({
+    slug,
+    files: brokerFiles,
+    createWrapper: options.createWrapper ?? true,
+    agentHome: options.agentHome,
+    socketGroup: options.socketGroup
+  });
+  return result;
 }
-function scanSystemBins() {
-  const pathDirs = (process.env.PATH ?? "").split(":").filter(Boolean);
-  const allDirs = [.../* @__PURE__ */ new Set([...BIN_DIRS, ...pathDirs])];
-  const seen = /* @__PURE__ */ new Set();
-  const results = [];
-  for (const dir of allDirs) {
-    try {
-      if (!fs14.existsSync(dir)) continue;
-      const entries = fs14.readdirSync(dir);
-      for (const entry of entries) {
-        if (seen.has(entry)) continue;
-        const fullPath = path13.join(dir, entry);
-        try {
-          const stat = fs14.statSync(fullPath);
-          if (stat.isFile() && (stat.mode & 73) !== 0) {
-            seen.add(entry);
-            results.push({ name: entry, path: fullPath });
-          }
-        } catch {
-        }
-      }
-    } catch {
+async function uninstallSkillViaBroker(slug, options = {}) {
+  const client = getBrokerClient();
+  const result = await client.skillUninstall({
+    slug,
+    removeWrapper: options.removeWrapper ?? true,
+    agentHome: options.agentHome
+  });
+  return result;
+}
+
+// libs/shield-daemon/src/routes/skills.ts
+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 entries = fs13.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const found = findSkillMdRecursive(path12.join(dir, entry.name), depth + 1);
+      if (found) return found;
     }
+  } catch {
   }
-  return results.sort((a, b) => a.name.localeCompare(b.name));
+  return null;
 }
-async function execRoutes(app) {
-  app.get("/exec/system-bins", async () => {
-    const now = Date.now();
-    if (binCache && now - binCache.cachedAt < BIN_CACHE_TTL) {
-      return { success: true, data: { bins: binCache.bins } };
+function readSkillDescription(skillDir) {
+  try {
+    const mdPath = findSkillMdRecursive(skillDir);
+    if (!mdPath) return void 0;
+    const content = fs13.readFileSync(mdPath, "utf-8");
+    const parsed = parseSkillMd(content);
+    return parsed?.metadata?.description ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function skillsRoutes(app) {
+  app.get("/skills", async (_request, reply) => {
+    const approved = listApproved();
+    const quarantined = listQuarantined();
+    const downloaded = listDownloadedSkills();
+    const skillsDir2 = getSkillsDir();
+    const approvedNames = new Set(approved.map((a) => a.name));
+    const availableDownloads = downloaded.filter((d) => !approvedNames.has(d.slug));
+    const quarantinedNames = new Set(quarantined.map((q) => q.name));
+    let onDiskNames = [];
+    if (skillsDir2) {
+      try {
+        onDiskNames = fs13.readdirSync(skillsDir2, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      } catch {
+      }
     }
-    const bins = scanSystemBins();
-    binCache = { bins, cachedAt: now };
-    return { success: true, data: { bins } };
+    const workspaceNames = onDiskNames.filter(
+      (n) => !approvedNames.has(n) && !quarantinedNames.has(n)
+    );
+    const data = [
+      // Approved → active (with descriptions from SKILL.md)
+      ...approved.map((a) => ({
+        name: a.name,
+        source: "user",
+        status: "active",
+        path: path12.join(skillsDir2 ?? "", a.name),
+        publisher: a.publisher,
+        description: skillsDir2 ? readSkillDescription(path12.join(skillsDir2, a.name)) : void 0
+      })),
+      // Quarantined
+      ...quarantined.map((q) => ({
+        name: q.name,
+        source: "quarantine",
+        status: "quarantined",
+        path: q.originalPath,
+        description: void 0
+      })),
+      // Workspace: on disk but not approved or quarantined
+      ...workspaceNames.map((name) => ({
+        name,
+        source: "workspace",
+        status: "workspace",
+        path: path12.join(skillsDir2 ?? "", name),
+        description: skillsDir2 ? readSkillDescription(path12.join(skillsDir2, name)) : void 0
+      })),
+      // Downloaded (not installed) → available
+      ...availableDownloads.map((d) => ({
+        name: d.slug,
+        source: "marketplace",
+        status: "downloaded",
+        description: d.description,
+        path: "",
+        publisher: d.author
+      }))
+    ];
+    return reply.send({ data });
   });
-  app.get("/exec/allowed-commands", async () => {
-    const config = loadConfig2();
-    return {
-      success: true,
-      data: {
-        commands: config.commands
-      }
-    };
+  app.get("/skills/quarantined", async (_request, reply) => {
+    const quarantined = listQuarantined();
+    return reply.send({ quarantined });
   });
-  app.post("/exec/allowed-commands", async (request) => {
-    const { name, paths, category } = request.body;
-    if (!name || !VALID_NAME.test(name)) {
-      return {
-        success: false,
-        error: {
-          code: "INVALID_NAME",
-          message: "Command name must be alphanumeric with hyphens/underscores only"
+  app.get(
+    "/skills/:name",
+    async (request, reply) => {
+      const { name } = request.params;
+      if (!name || typeof name !== "string") {
+        return reply.code(400).send({ error: "Skill name is required" });
+      }
+      const analysis = getCachedAnalysis(name);
+      const approved = listApproved();
+      const quarantined = listQuarantined();
+      const entry = approved.find((s) => s.name === name);
+      const qEntry = quarantined.find((q) => q.name === name);
+      const skillsDir2 = getSkillsDir();
+      let source = "user";
+      let status = "active";
+      let skillPath = "";
+      if (qEntry) {
+        source = "quarantine";
+        status = "quarantined";
+        skillPath = qEntry.originalPath;
+      } else if (entry) {
+        source = "user";
+        status = "active";
+        skillPath = skillsDir2 ? path12.join(skillsDir2, name) : "";
+      } else if (skillsDir2) {
+        source = "workspace";
+        status = "workspace";
+        skillPath = path12.join(skillsDir2, name);
+      }
+      let content = "";
+      let metadata;
+      const dirToRead = skillPath || (skillsDir2 ? path12.join(skillsDir2, name) : "");
+      if (dirToRead) {
+        try {
+          const mdPath = findSkillMdRecursive(dirToRead);
+          if (mdPath) {
+            content = fs13.readFileSync(mdPath, "utf-8");
+            const parsed = parseSkillMd(content);
+            metadata = parsed?.metadata;
+          }
+        } catch {
         }
-      };
-    }
-    if (!paths || !Array.isArray(paths) || paths.length === 0) {
-      return {
-        success: false,
-        error: {
-          code: "INVALID_PATHS",
-          message: "At least one absolute path is required"
+      }
+      if (!content) {
+        try {
+          const localMeta = getDownloadedSkillMeta(name);
+          if (localMeta) {
+            const localFiles = getDownloadedSkillFiles(name);
+            const readmeFile = localFiles.find((f) => /readme|skill\.md/i.test(f.name));
+            if (readmeFile?.content) {
+              content = readmeFile.content;
+              if (!metadata) {
+                const parsed = parseSkillMd(content);
+                metadata = parsed?.metadata;
+              }
+            }
+          }
+        } catch {
         }
-      };
-    }
-    for (const p of paths) {
-      if (!path13.isAbsolute(p)) {
-        return {
-          success: false,
-          error: {
-            code: "INVALID_PATH",
-            message: `Path must be absolute: ${p}`
+      }
+      const description = dirToRead ? readSkillDescription(dirToRead) : void 0;
+      if (content) {
+        try {
+          const cachedFiles = getDownloadedSkillFiles(name);
+          if (cachedFiles.length > 0) {
+            content = inlineImagesInMarkdown(content, cachedFiles);
           }
-        };
+        } catch {
+        }
       }
-    }
-    const config = loadConfig2();
-    const existing = config.commands.find((c) => c.name === name);
-    if (existing) {
-      return {
-        success: false,
-        error: {
-          code: "ALREADY_EXISTS",
-          message: `Command '${name}' already exists in dynamic allowlist`
+      return reply.send({
+        success: true,
+        data: {
+          name,
+          source,
+          status,
+          path: skillPath,
+          description,
+          content,
+          metadata: metadata ?? null,
+          analysis: analysis ?? null,
+          publisher: entry?.publisher ?? null
         }
-      };
+      });
     }
-    const newCommand = {
-      name,
-      paths,
-      addedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      addedBy: "admin",
-      ...category ? { category } : {}
-    };
-    config.commands.push(newCommand);
-    saveConfig2(config);
-    return {
-      success: true,
-      data: newCommand
-    };
-  });
-  app.delete("/exec/allowed-commands/:name", async (request) => {
-    const { name } = request.params;
-    const config = loadConfig2();
-    const index = config.commands.findIndex((c) => c.name === name);
-    if (index === -1) {
-      return {
-        success: false,
-        error: {
-          code: "NOT_FOUND",
-          message: `Command '${name}' not found in dynamic allowlist`
+  );
+  app.post(
+    "/skills/:name/analyze",
+    async (request, reply) => {
+      const { name } = request.params;
+      const { content, metadata } = request.body ?? {};
+      if (!name || typeof name !== "string") {
+        return reply.code(400).send({ error: "Skill name is required" });
+      }
+      clearCachedAnalysis(name);
+      if (content) {
+        const analysis = analyzeSkill(name, content, metadata);
+        return reply.send({ success: true, data: { analysis } });
+      }
+      return reply.send({
+        success: true,
+        data: {
+          analysis: {
+            status: "pending",
+            analyzerId: "agenshield",
+            commands: []
+          }
         }
-      };
-    }
-    config.commands.splice(index, 1);
-    saveConfig2(config);
-    return {
-      success: true,
-      data: { removed: name }
-    };
-  });
-}
-
-// libs/shield-daemon/src/routes/discovery.ts
-import { scanDiscovery } from "@agenshield/sandbox";
-var CACHE_TTL = 6e4;
-var cache2 = null;
-async function discoveryRoutes(app) {
-  app.get("/discovery/scan", async (request) => {
-    const refresh = request.query.refresh === "true";
-    const scanSkills2 = request.query.scanSkills !== "false";
-    const now = Date.now();
-    if (!refresh && cache2 && now - cache2.cachedAt < CACHE_TTL) {
-      return { success: true, data: cache2.result };
+      });
     }
-    const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || void 0;
-    const result = scanDiscovery({
-      agentHome,
-      workspaceDir: agentHome ? `${agentHome}/workspace` : void 0,
-      scanSkills: scanSkills2 && !!agentHome
-    });
-    cache2 = { result, cachedAt: Date.now() };
-    return { success: true, data: result };
-  });
-}
-
-// libs/shield-daemon/src/routes/auth.ts
-import {
-  UnlockRequestSchema,
-  SetupPasscodeRequestSchema,
-  ChangePasscodeRequestSchema
-} from "@agenshield/ipc";
-async function authRoutes(app) {
-  app.get("/auth/status", async () => {
-    const passcodeSet = await isPasscodeSet();
-    const protectionEnabled = isProtectionEnabled();
-    const allowAnonymousReadOnly = isAnonymousReadOnlyAllowed();
-    const lockoutStatus = isLockedOut();
-    return {
-      passcodeSet,
-      protectionEnabled,
-      allowAnonymousReadOnly,
-      lockedOut: lockoutStatus.locked,
-      lockedUntil: lockoutStatus.lockedUntil
-    };
-  });
+  );
   app.post(
-    "/auth/unlock",
+    "/skills/:name/approve",
     async (request, reply) => {
-      const parseResult = UnlockRequestSchema.safeParse(request.body);
-      if (!parseResult.success) {
-        reply.code(400);
-        return {
-          success: false,
-          error: "Invalid request: " + parseResult.error.message
-        };
-      }
-      const { passcode } = parseResult.data;
-      const lockoutStatus = isLockedOut();
-      if (lockoutStatus.locked) {
-        reply.code(429);
-        return {
-          success: false,
-          error: "Too many failed attempts. Try again later.",
-          remainingAttempts: 0
-        };
-      }
-      const passcodeSet = await isPasscodeSet();
-      if (!passcodeSet) {
-        reply.code(400);
-        return {
-          success: false,
-          error: "Passcode not configured. Use /auth/setup first."
-        };
+      const { name } = request.params;
+      if (!name || typeof name !== "string") {
+        return reply.code(400).send({ error: "Skill name is required" });
       }
-      const valid = await checkPasscode(passcode);
-      if (!valid) {
-        const remainingAttempts = recordFailedAttempt();
-        reply.code(401);
-        return {
-          success: false,
-          error: "Invalid passcode",
-          remainingAttempts
-        };
+      const result = approveSkill(name);
+      if (!result.success) {
+        return reply.code(404).send({ error: result.error });
       }
-      clearFailedAttempts();
-      const sessionManager = getSessionManager();
-      const session = sessionManager.createSession();
-      return {
-        success: true,
-        token: session.token,
-        expiresAt: session.expiresAt
-      };
+      return reply.send({ success: true, message: `Skill "${name}" approved` });
     }
   );
-  app.post(
-    "/auth/lock",
+  app.delete(
+    "/skills/:name",
     async (request, reply) => {
-      const token = request.body?.token || extractToken(request);
-      if (!token) {
-        reply.code(400);
-        return { success: false };
+      const { name } = request.params;
+      if (!name || typeof name !== "string") {
+        return reply.code(400).send({ error: "Skill name is required" });
       }
-      const sessionManager = getSessionManager();
-      const invalidated = sessionManager.invalidateSession(token);
-      return { success: invalidated };
+      const result = rejectSkill(name);
+      if (!result.success) {
+        return reply.code(404).send({ error: result.error });
+      }
+      return reply.send({ success: true, message: `Skill "${name}" rejected and deleted` });
     }
   );
   app.post(
-    "/auth/setup",
+    "/skills/:name/revoke",
     async (request, reply) => {
-      const parseResult = SetupPasscodeRequestSchema.safeParse(request.body);
-      if (!parseResult.success) {
-        reply.code(400);
-        return {
-          success: false,
-          error: "Invalid request: " + parseResult.error.message
-        };
-      }
-      const { passcode, enableProtection = true } = parseResult.data;
-      const alreadySet = await isPasscodeSet();
-      if (alreadySet) {
-        reply.code(409);
-        return {
-          success: false,
-          error: "Passcode already configured. Use /auth/change to update."
-        };
+      const { name } = request.params;
+      if (!name || typeof name !== "string") {
+        return reply.code(400).send({ error: "Skill name is required" });
       }
-      await setPasscode(passcode);
-      if (enableProtection) {
-        setProtectionEnabled(true);
+      const result = revokeSkill(name);
+      if (!result.success) {
+        return reply.code(500).send({ error: result.error });
       }
-      return { success: true };
+      return reply.send({ success: true, message: `Skill "${name}" approval revoked` });
     }
   );
-  app.post(
-    "/auth/change",
+  app.put(
+    "/skills/:name/toggle",
     async (request, reply) => {
-      const parseResult = ChangePasscodeRequestSchema.safeParse(request.body);
-      if (!parseResult.success) {
-        reply.code(400);
-        return {
-          success: false,
-          error: "Invalid request: " + parseResult.error.message
-        };
+      const { name } = request.params;
+      if (!name || typeof name !== "string") {
+        return reply.code(400).send({ error: "Skill name is required" });
       }
-      const { oldPasscode, newPasscode } = parseResult.data;
-      const passcodeSet = await isPasscodeSet();
-      if (!passcodeSet) {
-        reply.code(400);
-        return {
-          success: false,
-          error: "Passcode not configured. Use /auth/setup first."
-        };
+      const skillsDir2 = getSkillsDir();
+      if (!skillsDir2) {
+        return reply.code(500).send({ error: "Skills directory not configured" });
       }
-      if (!isRunningAsRoot()) {
-        if (!oldPasscode) {
-          reply.code(400);
-          return {
-            success: false,
-            error: "Old passcode required"
-          };
+      const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
+      const binDir = path12.join(agentHome, "bin");
+      const socketGroup = process.env["AGENSHIELD_SOCKET_GROUP"] || "clawshield";
+      const skillDir = path12.join(skillsDir2, name);
+      const isInstalled = fs13.existsSync(skillDir);
+      if (isInstalled) {
+        try {
+          const brokerAvailable = await isBrokerAvailable();
+          if (brokerAvailable) {
+            await uninstallSkillViaBroker(name, {
+              removeWrapper: true,
+              agentHome
+            });
+          } else {
+            fs13.rmSync(skillDir, { recursive: true, force: true });
+            removeSkillWrapper(name, binDir);
+          }
+          removeSkillEntry(name);
+          removeSkillPolicy(name);
+          removeFromApprovedList(name);
+          console.log(`[Skills] Disabled marketplace skill: ${name}`);
+          return reply.send({ success: true, action: "disabled", name });
+        } catch (err) {
+          console.error("[Skills] Disable failed:", err.message);
+          return reply.code(500).send({ error: `Disable failed: ${err.message}` });
         }
-        const valid = await checkPasscode(oldPasscode);
-        if (!valid) {
-          const remainingAttempts = recordFailedAttempt();
-          reply.code(401);
-          return {
-            success: false,
-            error: "Invalid old passcode"
-          };
+      } else {
+        const meta = getDownloadedSkillMeta(name);
+        if (!meta) {
+          return reply.code(404).send({ error: "Skill not found in download cache" });
+        }
+        const files = getDownloadedSkillFiles(name);
+        if (files.length === 0) {
+          return reply.code(404).send({ error: "No files in download cache for this skill" });
+        }
+        try {
+          addToApprovedList(name, meta.author);
+          const brokerAvailable = await isBrokerAvailable();
+          if (brokerAvailable) {
+            const brokerResult = await installSkillViaBroker(
+              name,
+              files.map((f) => ({ name: f.name, content: f.content })),
+              { createWrapper: true, agentHome, socketGroup }
+            );
+            if (!brokerResult.installed) {
+              throw new Error("Broker failed to install skill files");
+            }
+          } else {
+            fs13.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");
+            }
+            try {
+              execSync8(`chown -R root:${socketGroup} "${skillDir}"`, { stdio: "pipe" });
+              execSync8(`chmod -R a+rX,go-w "${skillDir}"`, { stdio: "pipe" });
+            } catch {
+            }
+            createSkillWrapper(name, binDir);
+          }
+          addSkillEntry(name);
+          addSkillPolicy(name);
+          console.log(`[Skills] Enabled marketplace skill: ${name}`);
+          return reply.send({ success: true, action: "enabled", name });
+        } catch (err) {
+          try {
+            if (fs13.existsSync(skillDir)) {
+              fs13.rmSync(skillDir, { recursive: true, force: true });
+            }
+            removeFromApprovedList(name);
+          } catch {
+          }
+          console.error("[Skills] Enable failed:", err.message);
+          return reply.code(500).send({ error: `Enable failed: ${err.message}` });
         }
-        clearFailedAttempts();
       }
-      await setPasscode(newPasscode);
-      const sessionManager = getSessionManager();
-      sessionManager.clearAllSessions();
-      return { success: true };
     }
   );
   app.post(
-    "/auth/refresh",
+    "/skills/install",
+    { preHandler: [requireAuth] },
     async (request, reply) => {
-      const token = extractToken(request);
-      if (!token) {
-        reply.code(401);
-        return {
-          success: false,
-          error: "No token provided"
-        };
+      const { name, files, publisher } = request.body ?? {};
+      if (!name || typeof name !== "string") {
+        return reply.code(400).send({ error: "Skill name is required" });
       }
-      const sessionManager = getSessionManager();
-      const refreshed = sessionManager.refreshSession(token);
-      if (!refreshed) {
-        reply.code(401);
-        return {
-          success: false,
-          error: "Invalid or expired token"
-        };
+      if (!Array.isArray(files) || files.length === 0) {
+        return reply.code(400).send({ error: "Files array is required" });
       }
-      return {
-        success: true,
-        token: refreshed.token,
-        expiresAt: refreshed.expiresAt
-      };
-    }
-  );
-  app.post(
-    "/auth/enable",
-    async (request, reply) => {
-      const passcodeSet = await isPasscodeSet();
-      if (!passcodeSet) {
-        reply.code(400);
-        return {
-          success: false,
-          error: "Passcode not configured. Use /auth/setup first."
-        };
+      const combinedContent = files.map((f) => f.content).join("\n");
+      const skillMdFile = files.find((f) => f.name === "SKILL.md");
+      let metadata;
+      if (skillMdFile) {
+        const parsed = parseSkillMd(skillMdFile.content);
+        metadata = parsed?.metadata;
       }
-      setProtectionEnabled(true);
-      return { success: true };
-    }
-  );
-  app.post(
-    "/auth/disable",
-    async (request, reply) => {
-      if (!isRunningAsRoot()) {
-        const token = extractToken(request);
-        if (!token) {
-          reply.code(401);
-          return {
-            success: false,
-            error: "Authentication required to disable protection"
-          };
-        }
-        const sessionManager = getSessionManager();
-        const session = sessionManager.validateSession(token);
-        if (!session) {
-          reply.code(401);
-          return {
-            success: false,
-            error: "Invalid or expired token"
-          };
-        }
+      const analysis = analyzeSkill(name, combinedContent, metadata);
+      if (analysis.vulnerability?.level === "critical") {
+        return reply.code(400).send({ error: "Critical vulnerability detected", analysis });
       }
-      setProtectionEnabled(false);
-      return { success: true };
-    }
-  );
-  app.post(
-    "/auth/anonymous-readonly",
-    async (request, reply) => {
-      if (!isRunningAsRoot()) {
-        const token = extractToken(request);
-        if (!token) {
-          reply.code(401);
-          return {
-            success: false,
-            error: "Authentication required to change anonymous access"
-          };
+      const skillsDir2 = getSkillsDir();
+      if (!skillsDir2) {
+        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 socketGroup = process.env["AGENSHIELD_SOCKET_GROUP"] || "clawshield";
+      const skillDir = path12.join(skillsDir2, name);
+      try {
+        addToApprovedList(name, publisher);
+        fs13.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 sessionManager = getSessionManager();
-        const session = sessionManager.validateSession(token);
-        if (!session) {
-          reply.code(401);
-          return {
-            success: false,
-            error: "Invalid or expired token"
-          };
+        try {
+          execSync8(`chown -R root:${socketGroup} "${skillDir}"`, { stdio: "pipe" });
+          execSync8(`chmod -R a+rX,go-w "${skillDir}"`, { stdio: "pipe" });
+        } catch {
         }
+        createSkillWrapper(name, binDir);
+        addSkillPolicy(name);
+        return reply.send({ success: true, name, analysis });
+      } catch (err) {
+        try {
+          if (fs13.existsSync(skillDir)) {
+            fs13.rmSync(skillDir, { recursive: true, force: true });
+          }
+          removeFromApprovedList(name);
+        } catch {
+        }
+        console.error("[Skills] Install failed:", err.message);
+        return reply.code(500).send({
+          error: `Installation failed: ${err.message}`
+        });
       }
-      const { allowed } = request.body;
-      if (typeof allowed !== "boolean") {
-        reply.code(400);
-        return {
-          success: false,
-          error: 'Invalid request: "allowed" must be a boolean'
-        };
-      }
-      setAnonymousReadOnly(allowed);
-      return { success: true, allowAnonymousReadOnly: allowed };
     }
   );
 }
 
-// libs/shield-daemon/src/routes/secrets.ts
-import { isSecretEnvVar } from "@agenshield/sandbox";
-import crypto4 from "node:crypto";
-function maskValue(value) {
-  if (value.length <= 4) return "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022";
-  return "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022" + value.slice(-4);
+// libs/shield-daemon/src/routes/exec.ts
+import * as fs14 from "node:fs";
+import * as path13 from "node:path";
+var ALLOWED_COMMANDS_PATH2 = "/opt/agenshield/config/allowed-commands.json";
+var BIN_DIRS = [
+  "/usr/bin",
+  "/usr/local/bin",
+  "/opt/homebrew/bin",
+  "/usr/sbin",
+  "/usr/local/sbin"
+];
+var binCache = null;
+var BIN_CACHE_TTL = 6e4;
+var VALID_NAME = /^[a-zA-Z0-9_-]+$/;
+function loadConfig2() {
+  if (!fs14.existsSync(ALLOWED_COMMANDS_PATH2)) {
+    return { version: "1.0.0", commands: [] };
+  }
+  try {
+    const content = fs14.readFileSync(ALLOWED_COMMANDS_PATH2, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { version: "1.0.0", commands: [] };
+  }
 }
-function toMasked(secret) {
-  return {
-    id: secret.id,
-    name: secret.name,
-    policyIds: secret.policyIds,
-    maskedValue: maskValue(secret.value),
-    createdAt: secret.createdAt
-  };
+function saveConfig2(config) {
+  const dir = path13.dirname(ALLOWED_COMMANDS_PATH2);
+  if (!fs14.existsSync(dir)) {
+    fs14.mkdirSync(dir, { recursive: true });
+  }
+  fs14.writeFileSync(ALLOWED_COMMANDS_PATH2, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
-async function secretsRoutes(app) {
-  app.get("/secrets", async () => {
-    const vault = getVault();
-    const secrets = await vault.get("secrets") ?? [];
-    return { data: secrets.map(toMasked) };
-  });
-  app.get("/secrets/env", async () => {
-    const names = /* @__PURE__ */ new Set();
-    for (const key of Object.keys(process.env)) {
-      if (process.env[key] && isSecretEnvVar(key)) {
-        names.add(key);
+function scanSystemBins() {
+  const pathDirs = (process.env.PATH ?? "").split(":").filter(Boolean);
+  const allDirs = [.../* @__PURE__ */ new Set([...BIN_DIRS, ...pathDirs])];
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const dir of allDirs) {
+    try {
+      if (!fs14.existsSync(dir)) continue;
+      const entries = fs14.readdirSync(dir);
+      for (const entry of entries) {
+        if (seen.has(entry)) continue;
+        const fullPath = path13.join(dir, entry);
+        try {
+          const stat = fs14.statSync(fullPath);
+          if (stat.isFile() && (stat.mode & 73) !== 0) {
+            seen.add(entry);
+            results.push({ name: entry, path: fullPath });
+          }
+        } catch {
+        }
       }
+    } catch {
     }
-    const userSecrets = process.env["AGENSHIELD_USER_SECRETS"];
-    if (userSecrets) {
-      for (const name of userSecrets.split(",").filter(Boolean)) {
-        names.add(name);
-      }
+  }
+  return results.sort((a, b) => a.name.localeCompare(b.name));
+}
+async function execRoutes(app) {
+  app.get("/exec/system-bins", async () => {
+    const now = Date.now();
+    if (binCache && now - binCache.cachedAt < BIN_CACHE_TTL) {
+      return { success: true, data: { bins: binCache.bins } };
     }
-    return { data: Array.from(names).sort((a, b) => a.localeCompare(b)) };
+    const bins = scanSystemBins();
+    binCache = { bins, cachedAt: now };
+    return { success: true, data: { bins } };
   });
-  app.post(
-    "/secrets",
-    async (request) => {
-      const { name, value, policyIds } = request.body;
-      if (!name?.trim() || !value?.trim()) {
-        return { success: false, error: "Name and value are required" };
+  app.get("/exec/allowed-commands", async () => {
+    const config = loadConfig2();
+    return {
+      success: true,
+      data: {
+        commands: config.commands
       }
-      const vault = getVault();
-      const secrets = await vault.get("secrets") ?? [];
-      const newSecret = {
-        id: crypto4.randomUUID(),
-        name: name.trim(),
-        value,
-        policyIds: policyIds ?? [],
-        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  });
+  app.post("/exec/allowed-commands", async (request) => {
+    const { name, paths, category } = request.body;
+    if (!name || !VALID_NAME.test(name)) {
+      return {
+        success: false,
+        error: {
+          code: "INVALID_NAME",
+          message: "Command name must be alphanumeric with hyphens/underscores only"
+        }
       };
-      secrets.push(newSecret);
-      await vault.set("secrets", secrets);
-      return { data: toMasked(newSecret) };
     }
-  );
-  app.patch(
-    "/secrets/:id",
-    async (request) => {
-      const { id } = request.params;
-      const { policyIds } = request.body;
-      const vault = getVault();
-      const secrets = await vault.get("secrets") ?? [];
-      const idx = secrets.findIndex((s) => s.id === id);
-      if (idx === -1) return { success: false, error: "Secret not found" };
-      secrets[idx].policyIds = policyIds ?? [];
-      await vault.set("secrets", secrets);
-      return { data: toMasked(secrets[idx]) };
+    if (!paths || !Array.isArray(paths) || paths.length === 0) {
+      return {
+        success: false,
+        error: {
+          code: "INVALID_PATHS",
+          message: "At least one absolute path is required"
+        }
+      };
     }
-  );
-  app.delete(
-    "/secrets/:id",
-    async (request) => {
-      const { id } = request.params;
-      const vault = getVault();
-      const secrets = await vault.get("secrets") ?? [];
-      const filtered = secrets.filter((s) => s.id !== id);
-      if (filtered.length === secrets.length) {
-        return { success: false, error: "Secret not found" };
+    for (const p of paths) {
+      if (!path13.isAbsolute(p)) {
+        return {
+          success: false,
+          error: {
+            code: "INVALID_PATH",
+            message: `Path must be absolute: ${p}`
+          }
+        };
       }
-      await vault.set("secrets", filtered);
-      return { deleted: true };
     }
-  );
+    const config = loadConfig2();
+    const existing = config.commands.find((c) => c.name === name);
+    if (existing) {
+      return {
+        success: false,
+        error: {
+          code: "ALREADY_EXISTS",
+          message: `Command '${name}' already exists in dynamic allowlist`
+        }
+      };
+    }
+    const newCommand = {
+      name,
+      paths,
+      addedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      addedBy: "admin",
+      ...category ? { category } : {}
+    };
+    config.commands.push(newCommand);
+    saveConfig2(config);
+    return {
+      success: true,
+      data: newCommand
+    };
+  });
+  app.delete("/exec/allowed-commands/:name", async (request) => {
+    const { name } = request.params;
+    const config = loadConfig2();
+    const index = config.commands.findIndex((c) => c.name === name);
+    if (index === -1) {
+      return {
+        success: false,
+        error: {
+          code: "NOT_FOUND",
+          message: `Command '${name}' not found in dynamic allowlist`
+        }
+      };
+    }
+    config.commands.splice(index, 1);
+    saveConfig2(config);
+    return {
+      success: true,
+      data: { removed: name }
+    };
+  });
 }
 
-// libs/shield-daemon/src/routes/marketplace.ts
-import * as fs15 from "node:fs";
-import * as path14 from "node:path";
-
-// libs/shield-broker/dist/index.js
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-import * as net2 from "node:net";
-import { randomUUID as randomUUID3 } from "node:crypto";
-var MAX_OUTPUT_SIZE = 10 * 1024 * 1024;
-var execAsync = promisify(exec);
-var BrokerClient = class {
-  socketPath;
-  httpHost;
-  httpPort;
-  timeout;
-  preferSocket;
-  constructor(options = {}) {
-    this.socketPath = options.socketPath || "/var/run/agenshield/agenshield.sock";
-    this.httpHost = options.httpHost || "localhost";
-    this.httpPort = options.httpPort || 5201;
-    this.timeout = options.timeout || 3e4;
-    this.preferSocket = options.preferSocket ?? true;
-  }
-  /**
-   * Make an HTTP request through the broker
-   */
-  async httpRequest(params, options) {
-    return this.request("http_request", params, options);
-  }
-  /**
-   * Read a file through the broker
-   */
-  async fileRead(params, options) {
-    return this.request("file_read", params, options);
-  }
-  /**
-   * Write a file through the broker
-   */
-  async fileWrite(params, options) {
-    return this.request("file_write", params, {
-      ...options,
-      channel: "socket"
-      // file_write only allowed via socket
-    });
-  }
-  /**
-   * List files through the broker
-   */
-  async fileList(params, options) {
-    return this.request("file_list", params, options);
-  }
-  /**
-   * Execute a command through the broker
-   */
-  async exec(params, options) {
-    return this.request("exec", params, {
-      ...options,
-      channel: "socket"
-      // exec only allowed via socket
-    });
-  }
-  /**
-   * Open a URL through the broker
-   */
-  async openUrl(params, options) {
-    return this.request("open_url", params, options);
-  }
-  /**
-   * Inject a secret through the broker
-   */
-  async secretInject(params, options) {
-    return this.request("secret_inject", params, {
-      ...options,
-      channel: "socket"
-      // secret_inject only allowed via socket
-    });
-  }
-  /**
-   * Ping the broker
-   */
-  async ping(echo, options) {
-    return this.request("ping", { echo }, options);
-  }
-  /**
-   * Install a skill through the broker
-   * Socket-only operation due to privileged file operations
-   */
-  async skillInstall(params, options) {
-    return this.request("skill_install", params, {
-      ...options,
-      channel: "socket"
-      // skill_install only allowed via socket
-    });
-  }
-  /**
-   * Uninstall a skill through the broker
-   * Socket-only operation due to privileged file operations
-   */
-  async skillUninstall(params, options) {
-    return this.request("skill_uninstall", params, {
-      ...options,
-      channel: "socket"
-      // skill_uninstall only allowed via socket
+// libs/shield-daemon/src/routes/discovery.ts
+import { scanDiscovery } from "@agenshield/sandbox";
+var CACHE_TTL = 6e4;
+var cache2 = null;
+async function discoveryRoutes(app) {
+  app.get("/discovery/scan", async (request) => {
+    const refresh = request.query.refresh === "true";
+    const scanSkills2 = request.query.scanSkills !== "false";
+    const now = Date.now();
+    if (!refresh && cache2 && now - cache2.cachedAt < CACHE_TTL) {
+      return { success: true, data: cache2.result };
+    }
+    const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || void 0;
+    const result = scanDiscovery({
+      agentHome,
+      workspaceDir: agentHome ? `${agentHome}/workspace` : void 0,
+      scanSkills: scanSkills2 && !!agentHome
     });
-  }
-  /**
-   * Check if the broker is available
-   */
-  async isAvailable() {
-    try {
-      await this.ping();
-      return true;
-    } catch {
-      return false;
+    cache2 = { result, cachedAt: Date.now() };
+    return { success: true, data: result };
+  });
+}
+
+// libs/shield-daemon/src/routes/auth.ts
+import {
+  UnlockRequestSchema,
+  SetupPasscodeRequestSchema,
+  ChangePasscodeRequestSchema
+} from "@agenshield/ipc";
+async function authRoutes(app) {
+  app.get("/auth/status", async () => {
+    const passcodeSet = await isPasscodeSet();
+    const protectionEnabled = isProtectionEnabled();
+    const allowAnonymousReadOnly = isAnonymousReadOnlyAllowed();
+    const lockoutStatus = isLockedOut();
+    return {
+      passcodeSet,
+      protectionEnabled,
+      allowAnonymousReadOnly,
+      lockedOut: lockoutStatus.locked,
+      lockedUntil: lockoutStatus.lockedUntil
+    };
+  });
+  app.post(
+    "/auth/unlock",
+    async (request, reply) => {
+      const parseResult = UnlockRequestSchema.safeParse(request.body);
+      if (!parseResult.success) {
+        reply.code(400);
+        return {
+          success: false,
+          error: "Invalid request: " + parseResult.error.message
+        };
+      }
+      const { passcode } = parseResult.data;
+      const lockoutStatus = isLockedOut();
+      if (lockoutStatus.locked) {
+        reply.code(429);
+        return {
+          success: false,
+          error: "Too many failed attempts. Try again later.",
+          remainingAttempts: 0
+        };
+      }
+      const passcodeSet = await isPasscodeSet();
+      if (!passcodeSet) {
+        reply.code(400);
+        return {
+          success: false,
+          error: "Passcode not configured. Use /auth/setup first."
+        };
+      }
+      const valid = await checkPasscode(passcode);
+      if (!valid) {
+        const remainingAttempts = recordFailedAttempt();
+        reply.code(401);
+        return {
+          success: false,
+          error: "Invalid passcode",
+          remainingAttempts
+        };
+      }
+      clearFailedAttempts();
+      const sessionManager = getSessionManager();
+      const session = sessionManager.createSession();
+      return {
+        success: true,
+        token: session.token,
+        expiresAt: session.expiresAt
+      };
+    }
+  );
+  app.post(
+    "/auth/lock",
+    async (request, reply) => {
+      const token = request.body?.token || extractToken(request);
+      if (!token) {
+        reply.code(400);
+        return { success: false };
+      }
+      const sessionManager = getSessionManager();
+      const invalidated = sessionManager.invalidateSession(token);
+      return { success: invalidated };
+    }
+  );
+  app.post(
+    "/auth/setup",
+    async (request, reply) => {
+      const parseResult = SetupPasscodeRequestSchema.safeParse(request.body);
+      if (!parseResult.success) {
+        reply.code(400);
+        return {
+          success: false,
+          error: "Invalid request: " + parseResult.error.message
+        };
+      }
+      const { passcode, enableProtection = true } = parseResult.data;
+      const alreadySet = await isPasscodeSet();
+      if (alreadySet) {
+        reply.code(409);
+        return {
+          success: false,
+          error: "Passcode already configured. Use /auth/change to update."
+        };
+      }
+      await setPasscode(passcode);
+      if (enableProtection) {
+        setProtectionEnabled(true);
+      }
+      return { success: true };
     }
-  }
-  /**
-   * Make a request to the broker
-   */
-  async request(method, params, options) {
-    const channel = options?.channel || (this.preferSocket ? "socket" : "http");
-    const timeout = options?.timeout || this.timeout;
-    if (channel === "socket") {
-      try {
-        return await this.socketRequest(method, params, timeout);
-      } catch (error) {
-        if (!options?.channel) {
-          return await this.httpRequest_internal(method, params, timeout);
+  );
+  app.post(
+    "/auth/change",
+    async (request, reply) => {
+      const parseResult = ChangePasscodeRequestSchema.safeParse(request.body);
+      if (!parseResult.success) {
+        reply.code(400);
+        return {
+          success: false,
+          error: "Invalid request: " + parseResult.error.message
+        };
+      }
+      const { oldPasscode, newPasscode } = parseResult.data;
+      const passcodeSet = await isPasscodeSet();
+      if (!passcodeSet) {
+        reply.code(400);
+        return {
+          success: false,
+          error: "Passcode not configured. Use /auth/setup first."
+        };
+      }
+      if (!isRunningAsRoot()) {
+        if (!oldPasscode) {
+          reply.code(400);
+          return {
+            success: false,
+            error: "Old passcode required"
+          };
         }
-        throw error;
+        const valid = await checkPasscode(oldPasscode);
+        if (!valid) {
+          const remainingAttempts = recordFailedAttempt();
+          reply.code(401);
+          return {
+            success: false,
+            error: "Invalid old passcode"
+          };
+        }
+        clearFailedAttempts();
       }
-    } else {
-      return await this.httpRequest_internal(method, params, timeout);
+      await setPasscode(newPasscode);
+      const sessionManager = getSessionManager();
+      sessionManager.clearAllSessions();
+      return { success: true };
     }
-  }
-  /**
-   * Make a request via Unix socket
-   */
-  async socketRequest(method, params, timeout) {
-    return new Promise((resolve3, reject) => {
-      const socket = net2.createConnection(this.socketPath);
-      const id = randomUUID3();
-      let responseData = "";
-      let timeoutId;
-      socket.on("connect", () => {
-        const request = {
-          jsonrpc: "2.0",
-          id,
-          method,
-          params
+  );
+  app.post(
+    "/auth/refresh",
+    async (request, reply) => {
+      const token = extractToken(request);
+      if (!token) {
+        reply.code(401);
+        return {
+          success: false,
+          error: "No token provided"
         };
-        socket.write(JSON.stringify(request) + "\n");
-        timeoutId = setTimeout(() => {
-          socket.destroy();
-          reject(new Error("Request timeout"));
-        }, timeout);
-      });
-      socket.on("data", (data) => {
-        responseData += data.toString();
-        const newlineIndex = responseData.indexOf("\n");
-        if (newlineIndex !== -1) {
-          clearTimeout(timeoutId);
-          socket.end();
-          try {
-            const response = JSON.parse(
-              responseData.slice(0, newlineIndex)
-            );
-            if (response.error) {
-              const error = new Error(response.error.message);
-              error.code = response.error.code;
-              reject(error);
-            } else {
-              resolve3(response.result);
-            }
-          } catch (error) {
-            reject(new Error("Invalid response from broker"));
-          }
+      }
+      const sessionManager = getSessionManager();
+      const refreshed = sessionManager.refreshSession(token);
+      if (!refreshed) {
+        reply.code(401);
+        return {
+          success: false,
+          error: "Invalid or expired token"
+        };
+      }
+      return {
+        success: true,
+        token: refreshed.token,
+        expiresAt: refreshed.expiresAt
+      };
+    }
+  );
+  app.post(
+    "/auth/enable",
+    async (request, reply) => {
+      const passcodeSet = await isPasscodeSet();
+      if (!passcodeSet) {
+        reply.code(400);
+        return {
+          success: false,
+          error: "Passcode not configured. Use /auth/setup first."
+        };
+      }
+      setProtectionEnabled(true);
+      return { success: true };
+    }
+  );
+  app.post(
+    "/auth/disable",
+    async (request, reply) => {
+      if (!isRunningAsRoot()) {
+        const token = extractToken(request);
+        if (!token) {
+          reply.code(401);
+          return {
+            success: false,
+            error: "Authentication required to disable protection"
+          };
+        }
+        const sessionManager = getSessionManager();
+        const session = sessionManager.validateSession(token);
+        if (!session) {
+          reply.code(401);
+          return {
+            success: false,
+            error: "Invalid or expired token"
+          };
         }
-      });
-      socket.on("error", (error) => {
-        clearTimeout(timeoutId);
-        reject(error);
-      });
-    });
-  }
-  /**
-   * Make a request via HTTP
-   */
-  async httpRequest_internal(method, params, timeout) {
-    const url = `http://${this.httpHost}:${this.httpPort}/rpc`;
-    const id = randomUUID3();
-    const request = {
-      jsonrpc: "2.0",
-      id,
-      method,
-      params
-    };
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-    try {
-      const response = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(request),
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      if (!response.ok) {
-        throw new Error(`HTTP error: ${response.status}`);
       }
-      const jsonResponse = await response.json();
-      if (jsonResponse.error) {
-        const error = new Error(jsonResponse.error.message);
-        error.code = jsonResponse.error.code;
-        throw error;
+      setProtectionEnabled(false);
+      return { success: true };
+    }
+  );
+  app.post(
+    "/auth/anonymous-readonly",
+    async (request, reply) => {
+      if (!isRunningAsRoot()) {
+        const token = extractToken(request);
+        if (!token) {
+          reply.code(401);
+          return {
+            success: false,
+            error: "Authentication required to change anonymous access"
+          };
+        }
+        const sessionManager = getSessionManager();
+        const session = sessionManager.validateSession(token);
+        if (!session) {
+          reply.code(401);
+          return {
+            success: false,
+            error: "Invalid or expired token"
+          };
+        }
+      }
+      const { allowed } = request.body;
+      if (typeof allowed !== "boolean") {
+        reply.code(400);
+        return {
+          success: false,
+          error: 'Invalid request: "allowed" must be a boolean'
+        };
+      }
+      setAnonymousReadOnly(allowed);
+      return { success: true, allowAnonymousReadOnly: allowed };
+    }
+  );
+}
+
+// libs/shield-daemon/src/routes/secrets.ts
+import { isSecretEnvVar } from "@agenshield/sandbox";
+import crypto4 from "node:crypto";
+function maskValue(value) {
+  if (value.length <= 4) return "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022";
+  return "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022" + value.slice(-4);
+}
+function toMasked(secret) {
+  return {
+    id: secret.id,
+    name: secret.name,
+    policyIds: secret.policyIds,
+    maskedValue: maskValue(secret.value),
+    createdAt: secret.createdAt
+  };
+}
+async function secretsRoutes(app) {
+  app.get("/secrets", async () => {
+    const vault = getVault();
+    const secrets = await vault.get("secrets") ?? [];
+    return { data: secrets.map(toMasked) };
+  });
+  app.get("/secrets/env", async () => {
+    const names = /* @__PURE__ */ new Set();
+    for (const key of Object.keys(process.env)) {
+      if (process.env[key] && isSecretEnvVar(key)) {
+        names.add(key);
       }
-      return jsonResponse.result;
-    } catch (error) {
-      clearTimeout(timeoutId);
-      if (error.name === "AbortError") {
-        throw new Error("Request timeout");
+    }
+    const userSecrets = process.env["AGENSHIELD_USER_SECRETS"];
+    if (userSecrets) {
+      for (const name of userSecrets.split(",").filter(Boolean)) {
+        names.add(name);
       }
-      throw error;
     }
-  }
-};
-
-// libs/shield-daemon/src/services/broker-bridge.ts
-var brokerClient = null;
-function getBrokerClient() {
-  if (!brokerClient) {
-    brokerClient = new BrokerClient({
-      socketPath: process.env["AGENSHIELD_SOCKET"] || "/var/run/agenshield/agenshield.sock",
-      httpHost: "localhost",
-      httpPort: 5201,
-      // Broker uses 5201, daemon uses 5200
-      timeout: 6e4,
-      // 60s timeout for file operations
-      preferSocket: true
-    });
-  }
-  return brokerClient;
-}
-async function isBrokerAvailable() {
-  try {
-    const client = getBrokerClient();
-    return await client.isAvailable();
-  } catch {
-    return false;
-  }
-}
-async function installSkillViaBroker(slug, files, options = {}) {
-  const client = getBrokerClient();
-  const brokerFiles = files.map((file) => ({
-    name: file.name,
-    content: file.content,
-    base64: false
-  }));
-  const result = await client.skillInstall({
-    slug,
-    files: brokerFiles,
-    createWrapper: options.createWrapper ?? true,
-    agentHome: options.agentHome,
-    socketGroup: options.socketGroup
+    return { data: Array.from(names).sort((a, b) => a.localeCompare(b)) };
   });
-  return result;
+  app.post(
+    "/secrets",
+    async (request) => {
+      const { name, value, policyIds } = request.body;
+      if (!name?.trim() || !value?.trim()) {
+        return { success: false, error: "Name and value are required" };
+      }
+      const vault = getVault();
+      const secrets = await vault.get("secrets") ?? [];
+      const newSecret = {
+        id: crypto4.randomUUID(),
+        name: name.trim(),
+        value,
+        policyIds: policyIds ?? [],
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      secrets.push(newSecret);
+      await vault.set("secrets", secrets);
+      return { data: toMasked(newSecret) };
+    }
+  );
+  app.patch(
+    "/secrets/:id",
+    async (request) => {
+      const { id } = request.params;
+      const { policyIds } = request.body;
+      const vault = getVault();
+      const secrets = await vault.get("secrets") ?? [];
+      const idx = secrets.findIndex((s) => s.id === id);
+      if (idx === -1) return { success: false, error: "Secret not found" };
+      secrets[idx].policyIds = policyIds ?? [];
+      await vault.set("secrets", secrets);
+      return { data: toMasked(secrets[idx]) };
+    }
+  );
+  app.delete(
+    "/secrets/:id",
+    async (request) => {
+      const { id } = request.params;
+      const vault = getVault();
+      const secrets = await vault.get("secrets") ?? [];
+      const filtered = secrets.filter((s) => s.id !== id);
+      if (filtered.length === secrets.length) {
+        return { success: false, error: "Secret not found" };
+      }
+      await vault.set("secrets", filtered);
+      return { deleted: true };
+    }
+  );
 }
 
 // libs/shield-daemon/src/routes/marketplace.ts
+import * as fs15 from "node:fs";
+import * as path14 from "node:path";
 async function marketplaceRoutes(app) {
   app.get(
     "/marketplace/search",
@@ -6841,6 +7036,10 @@ async function marketplaceRoutes(app) {
         if (localMeta) {
           const localFiles = getDownloadedSkillFiles(slug);
           const readmeFile = localFiles.find((f) => /readme|skill\.md/i.test(f.name));
+          let readme = readmeFile?.content;
+          if (readme) {
+            readme = inlineImagesInMarkdown(readme, localFiles);
+          }
           const skill2 = {
             name: localMeta.name,
             slug: localMeta.slug,
@@ -6850,7 +7049,7 @@ async function marketplaceRoutes(app) {
             installs: 0,
             // Not stored locally
             tags: localMeta.tags,
-            readme: readmeFile?.content,
+            readme,
             files: localFiles
           };
           if (localMeta.analysis) {
@@ -7099,6 +7298,120 @@ async function fsRoutes(app) {
   });
 }
 
+// libs/shield-daemon/src/services/activity-log.ts
+import * as fs17 from "node:fs";
+import * as path16 from "node:path";
+var ACTIVITY_FILE = "activity.jsonl";
+var MAX_SIZE_BYTES = 100 * 1024 * 1024;
+var MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+var PRUNE_INTERVAL = 1e3;
+var instance = null;
+function getActivityLog() {
+  if (!instance) {
+    instance = new ActivityLog();
+  }
+  return instance;
+}
+var ActivityLog = class {
+  filePath;
+  writeCount = 0;
+  unsubscribe;
+  constructor() {
+    this.filePath = path16.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");
+    const lines = content.split("\n").filter(Boolean);
+    const events = [];
+    for (const line of lines) {
+      try {
+        const evt = JSON.parse(line);
+        if (evt.type === "heartbeat") continue;
+        events.push(evt);
+      } catch {
+      }
+    }
+    events.reverse();
+    return events.slice(0, limit);
+  }
+  start() {
+    this.pruneOldEntries();
+    this.unsubscribe = daemonEvents.subscribe((event) => {
+      this.append(event);
+    });
+  }
+  stop() {
+    this.unsubscribe?.();
+  }
+  append(event) {
+    const line = JSON.stringify(event) + "\n";
+    fs17.appendFileSync(this.filePath, line, "utf-8");
+    this.writeCount++;
+    if (this.writeCount % PRUNE_INTERVAL === 0) {
+      this.rotate();
+    }
+  }
+  rotate() {
+    try {
+      const stat = fs17.statSync(this.filePath);
+      if (stat.size > MAX_SIZE_BYTES) {
+        this.truncateBySize();
+      }
+    } catch {
+    }
+    this.pruneOldEntries();
+  }
+  /** Keep newest half of lines when file exceeds size limit */
+  truncateBySize() {
+    const content = fs17.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");
+  }
+  /** Remove entries older than 24 hours */
+  pruneOldEntries() {
+    if (!fs17.existsSync(this.filePath)) return;
+    const content = fs17.readFileSync(this.filePath, "utf-8");
+    const lines = content.split("\n").filter(Boolean);
+    const cutoff = Date.now() - MAX_AGE_MS;
+    const kept = lines.filter((line) => {
+      try {
+        const evt = JSON.parse(line);
+        return new Date(evt.timestamp).getTime() >= cutoff;
+      } catch {
+        return false;
+      }
+    });
+    if (kept.length < lines.length) {
+      fs17.writeFileSync(this.filePath, kept.join("\n") + "\n", "utf-8");
+    }
+  }
+};
+
+// libs/shield-daemon/src/routes/activity.ts
+async function activityRoutes(app) {
+  app.get(
+    "/activity",
+    async (request) => {
+      const authenticated = isAuthenticated(request);
+      const raw = Number(request.query.limit) || 500;
+      const limit = Math.min(Math.max(raw, 1), 1e4);
+      const events = getActivityLog().getHistory(limit);
+      if (authenticated) {
+        return { data: events };
+      }
+      const stripped = events.map((e) => ({
+        type: e.type,
+        timestamp: e.timestamp,
+        data: {}
+      }));
+      return { data: stripped };
+    }
+  );
+}
+
 // libs/shield-daemon/src/routes/rpc.ts
 function globToRegex(pattern) {
   const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, ".").replace(/{{GLOBSTAR}}/g, ".*");
@@ -7297,7 +7610,7 @@ async function registerRoutes(app) {
   });
   app.addHook("onResponse", (request, reply, done) => {
     if (!request.url.startsWith("/sse") && !request.url.startsWith("/rpc") && !request.url.includes(".") && !request.url.endsWith("/health")) {
-      if (request.method === "GET" && request.url.startsWith("/api/status") && reply.statusCode === 200) {
+      if (request.method === "GET" && (request.url.startsWith("/api/status") || request.url.startsWith("/api/activity")) && reply.statusCode === 200) {
         done();
         return;
       }
@@ -7350,28 +7663,29 @@ async function registerRoutes(app) {
       await api.register(secretsRoutes);
       await api.register(marketplaceRoutes);
       await api.register(fsRoutes);
+      await api.register(activityRoutes);
     },
     { prefix: API_PREFIX }
   );
 }
 
 // libs/shield-daemon/src/static.ts
-import * as fs17 from "node:fs";
-import * as path16 from "node:path";
+import * as fs18 from "node:fs";
+import * as path17 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var __filename = fileURLToPath2(import.meta.url);
-var __dirname = path16.dirname(__filename);
+var __dirname = path17.dirname(__filename);
 function getUiAssetsPath() {
-  const pkgRootPath = path16.join(__dirname, "..", "ui-assets");
-  if (fs17.existsSync(pkgRootPath)) {
+  const pkgRootPath = path17.join(__dirname, "..", "ui-assets");
+  if (fs18.existsSync(pkgRootPath)) {
     return pkgRootPath;
   }
-  const bundledPath = path16.join(__dirname, "ui-assets");
-  if (fs17.existsSync(bundledPath)) {
+  const bundledPath = path17.join(__dirname, "ui-assets");
+  if (fs18.existsSync(bundledPath)) {
     return bundledPath;
   }
-  const devPath = path16.join(__dirname, "..", "..", "..", "dist", "apps", "shield-ui");
-  if (fs17.existsSync(devPath)) {
+  const devPath = path17.join(__dirname, "..", "..", "..", "dist", "apps", "shield-ui");
+  if (fs18.existsSync(devPath)) {
     return devPath;
   }
   return null;
@@ -7430,74 +7744,6 @@ function stopSecurityWatcher() {
   }
 }
 
-// libs/shield-daemon/src/services/activity-log.ts
-import * as fs18 from "node:fs";
-import * as path17 from "node:path";
-var ACTIVITY_FILE = "activity.jsonl";
-var MAX_SIZE_BYTES = 100 * 1024 * 1024;
-var MAX_AGE_MS = 24 * 60 * 60 * 1e3;
-var PRUNE_INTERVAL = 1e3;
-var ActivityLog = class {
-  filePath;
-  writeCount = 0;
-  unsubscribe;
-  constructor() {
-    this.filePath = path17.join(getConfigDir(), ACTIVITY_FILE);
-  }
-  start() {
-    this.pruneOldEntries();
-    this.unsubscribe = daemonEvents.subscribe((event) => {
-      this.append(event);
-    });
-  }
-  stop() {
-    this.unsubscribe?.();
-  }
-  append(event) {
-    const line = JSON.stringify(event) + "\n";
-    fs18.appendFileSync(this.filePath, line, "utf-8");
-    this.writeCount++;
-    if (this.writeCount % PRUNE_INTERVAL === 0) {
-      this.rotate();
-    }
-  }
-  rotate() {
-    try {
-      const stat = fs18.statSync(this.filePath);
-      if (stat.size > MAX_SIZE_BYTES) {
-        this.truncateBySize();
-      }
-    } catch {
-    }
-    this.pruneOldEntries();
-  }
-  /** Keep newest half of lines when file exceeds size limit */
-  truncateBySize() {
-    const content = fs18.readFileSync(this.filePath, "utf-8");
-    const lines = content.split("\n").filter(Boolean);
-    const keep = lines.slice(Math.floor(lines.length / 2));
-    fs18.writeFileSync(this.filePath, keep.join("\n") + "\n", "utf-8");
-  }
-  /** Remove entries older than 24 hours */
-  pruneOldEntries() {
-    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) => {
-      try {
-        const evt = JSON.parse(line);
-        return new Date(evt.timestamp).getTime() >= cutoff;
-      } catch {
-        return false;
-      }
-    });
-    if (kept.length < lines.length) {
-      fs18.writeFileSync(this.filePath, kept.join("\n") + "\n", "utf-8");
-    }
-  }
-};
-
 // libs/shield-daemon/src/server.ts
 async function createServer(config) {
   const app = Fastify({
@@ -7536,7 +7782,7 @@ async function startServer(config) {
     onQuarantined: (info) => emitSkillQuarantined(info.name, info.reason),
     onApproved: (name) => emitSkillApproved(name)
   }, 3e4);
-  const activityLog = new ActivityLog();
+  const activityLog = getActivityLog();
   activityLog.start();
   try {
     const vault = getVault();