@questionbase/deskfree 0.3.0-alpha.35 → 0.3.0-alpha.36

package/dist/index.js

@@ -8300,7 +8300,14 @@ var WORKER_TOOLS = {
   UPDATE_FILE: SHARED_TOOLS.UPDATE_FILE,
   COMPLETE_TASK: SHARED_TOOLS.COMPLETE_TASK,
   SEND_MESSAGE: SHARED_TOOLS.SEND_MESSAGE,
-  PROPOSE: SHARED_TOOLS.PROPOSE
+  PROPOSE: SHARED_TOOLS.PROPOSE,
+  READ_SKILL: {
+    name: "deskfree_read_skill_section",
+    description: "Load full instructions for a skill. Use after deskfree_start_task when you need the complete skill guide beyond the critical section summary.",
+    parameters: Type.Object({
+      skillId: Type.String({ description: "Skill ID to load instructions for" })
+    })
+  }
 };
 var CHANNEL_META = {
   name: "DeskFree",
@@ -8901,6 +8908,91 @@ function getDeskFreeContext(sessionKey) {
 <!-- deskfree-plugin:${PLUGIN_VERSION} -->`;
 }
 
+// src/skill-scan-hook.ts
+var SCANNABLE_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".sh", ".py", ".js", ".ts"]);
+var SKILLS_DIR_PATTERN = /(?:^|\/|\\)skills\/[^/\\]+\//;
+function isSkillFile(filePath) {
+  if (!filePath || typeof filePath !== "string") return false;
+  const normalized = filePath.replace(/\\/g, "/");
+  if (!SKILLS_DIR_PATTERN.test(normalized)) return false;
+  const lastDot = normalized.lastIndexOf(".");
+  if (lastDot === -1) return false;
+  const ext = normalized.slice(lastDot).toLowerCase();
+  return SCANNABLE_EXTENSIONS.has(ext);
+}
+var WRITE_TOOL_NAMES = /* @__PURE__ */ new Set(["write", "Write"]);
+var EDIT_TOOL_NAMES = /* @__PURE__ */ new Set(["edit", "Edit"]);
+function extractPath(params) {
+  const p = params["path"] ?? params["file_path"];
+  return typeof p === "string" && p.length > 0 ? p : null;
+}
+function extractContent(toolName, params) {
+  if (WRITE_TOOL_NAMES.has(toolName)) {
+    const c = params["content"];
+    return typeof c === "string" ? c : null;
+  }
+  if (EDIT_TOOL_NAMES.has(toolName)) {
+    const c = params["newText"] ?? params["new_string"];
+    return typeof c === "string" ? c : null;
+  }
+  return null;
+}
+function formatFindings(result) {
+  return result.findings.map(
+    (f) => `  [${f.severity.toUpperCase()}] ${f.description}` + (f.line != null ? ` (line ${f.line})` : "")
+  ).join("\n");
+}
+function createSkillScanHook(scanner, log) {
+  return (event, _ctx) => {
+    const toolName = event["toolName"];
+    if (typeof toolName !== "string") return;
+    if (!WRITE_TOOL_NAMES.has(toolName) && !EDIT_TOOL_NAMES.has(toolName)) {
+      return;
+    }
+    const params = event["params"];
+    if (!params || typeof params !== "object") return;
+    const p = params;
+    const filePath = extractPath(p);
+    if (!filePath) return;
+    if (!isSkillFile(filePath)) return;
+    const content = extractContent(toolName, p);
+    if (!content || content.length === 0) return;
+    const filename = filePath.split("/").pop() ?? "unknown";
+    const inputs = [{ filename, content }];
+    let result;
+    try {
+      result = scanner(inputs);
+    } catch (err) {
+      log.warn(
+        `[skill-scan] Scanner error for ${filePath}: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return;
+    }
+    log.info(
+      `[skill-scan] ${filePath}: verdict=${result.verdict} score=${result.score} findings=${result.findings.length}`
+    );
+    if (result.verdict === "dangerous") {
+      const findings = formatFindings(result);
+      log.warn(`[skill-scan] BLOCKED write to ${filePath}:
+${findings}`);
+      return {
+        block: true,
+        blockReason: `\u{1F6AB} Security scan BLOCKED write to "${filename}" \u2014 dangerous (score: ${result.score}/100)
+
+Findings:
+${findings}
+
+Remove the dangerous patterns and retry.`
+      };
+    }
+    if (result.verdict === "suspicious") {
+      const findings = formatFindings(result);
+      log.warn(`[skill-scan] Suspicious write to ${filePath}:
+${findings}`);
+    }
+  };
+}
+
 // src/tools.ts
 function resolveAccountFromConfig(api) {
   const cfg = api.runtime.config.loadConfig();
@@ -9392,6 +9484,7 @@ function createWorkerTools(api) {
   const account = resolveAccountFromConfig(api);
   if (!account) return null;
   const client = new DeskFreeClient(account.botToken, account.apiUrl);
+  const cachedSkillContext = /* @__PURE__ */ new Map();
   return [
     {
       ...WORKER_TOOLS.START_TASK,
@@ -9402,19 +9495,21 @@ function createWorkerTools(api) {
           const result = await client.claimTask({ taskId, runnerId });
           setActiveTaskId(taskId);
           let skillInstructions = "";
+          cachedSkillContext.clear();
           if (result.skillContext?.length) {
+            for (const s of result.skillContext) {
+              cachedSkillContext.set(s.skillId, { displayName: s.displayName, instructions: s.instructions });
+            }
             skillInstructions = result.skillContext.map(
               (s) => `
-\u26A0\uFE0F SKILL: ${s.displayName}
-${s.criticalSection}
-
-${s.instructions}`
+\u26A0\uFE0F SKILL: ${s.displayName} (ID: ${s.skillId})
+${s.criticalSection}`
             ).join("\n\n---\n");
           }
           const trimmedTask = trimTaskContext(result);
           const taskJson = JSON.stringify(
             {
-              summary: `Claimed task "${result.title}" \u2014 full context loaded${result.skillContext?.length ? ` (${result.skillContext.length} skill${result.skillContext.length > 1 ? "s" : ""} active)` : ""}`,
+              summary: `Claimed task "${result.title}" \u2014 full context loaded${result.skillContext?.length ? ` (${result.skillContext.length} skill${result.skillContext.length > 1 ? "s" : ""} loaded \u2014 use deskfree_read_skill_section for full details)` : ""}`,
               mode: trimmedTask.mode ?? "work",
               nextActions: [
                 "Read the instructions and message history carefully",
@@ -9463,6 +9558,28 @@ ${s.instructions}`
     {
       ...WORKER_TOOLS.PROPOSE,
       execute: makeProposeHandler(client)
+    },
+    {
+      ...WORKER_TOOLS.READ_SKILL,
+      async execute(_id, params) {
+        try {
+          const skillId = validateStringParam(params, "skillId", true);
+          const cached = cachedSkillContext.get(skillId);
+          if (!cached) {
+            return { content: [{ type: "text", text: `Skill ${skillId} not found in current task context. Available: ${[...cachedSkillContext.keys()].join(", ") || "none"}` }] };
+          }
+          return {
+            content: [{
+              type: "text",
+              text: `## ${cached.displayName} \u2014 Full Instructions
+
+${cached.instructions}`
+            }]
+          };
+        } catch (err) {
+          return errorResult(err);
+        }
+      }
     }
   ];
 }
@@ -9574,6 +9691,35 @@ var OfflineQueue = class {
 };
 
 // src/index.ts
+function createLazyScanner(log) {
+  let resolved = false;
+  let scanFn = null;
+  const scannerPath = ["..", "..", "backend", "src", "util", "util.skillScanner"].join("/");
+  import(
+    /* @vite-ignore */
+    scannerPath
+  ).then((mod) => {
+    if (typeof mod.scanSkill === "function") {
+      scanFn = mod.scanSkill;
+      log.info("[deskfree] Skill security scanner loaded");
+    }
+    resolved = true;
+  }).catch(() => {
+    resolved = true;
+    log.warn("[deskfree] Skill scanner not available \u2014 scan hook will pass through");
+  });
+  const safeFallback = (inputs) => ({
+    verdict: "safe",
+    score: 100,
+    findings: [],
+    scannedAt: /* @__PURE__ */ new Date(),
+    filesScanned: inputs.map((i) => i.filename)
+  });
+  return (inputs) => {
+    if (!resolved || !scanFn) return safeFallback(inputs);
+    return scanFn(inputs);
+  };
+}
 var plugin = {
   id: "deskfree",
   name: "DeskFree",
@@ -9593,6 +9739,8 @@ var plugin = {
       }
       return allTools.length > 0 ? allTools : null;
     });
+    const scanner = createLazyScanner(api.logger);
+    api.on("before_tool_call", createSkillScanHook(scanner, api.logger));
     api.on("before_agent_start", (_event, ctx) => {
       return { prependContext: getDeskFreeContext(ctx.sessionKey) };
     });