@wrongstack/tools 0.299.0 → 0.301.0

package/dist/replace.js

@@ -27,6 +27,81 @@ var DANGEROUS_PATTERNS = [
   // Greedy quantifier inside lookahead/lookbehind — (?!.*a+)
   /[([][^)\]]*[+*][^)\]]*[)\]][^)]*\?\??/
 ];
+function hasAmbiguousQuantifiedAlternation(pattern) {
+  for (let i = 0; i < pattern.length; i++) {
+    if (pattern[i] !== "(") continue;
+    if (i > 0 && pattern[i - 1] === "\\") continue;
+    let depth = 0;
+    let inClass = false;
+    let j = i;
+    for (; j < pattern.length; j++) {
+      const ch = pattern[j];
+      if (ch === "\\") {
+        j++;
+        continue;
+      }
+      if (inClass) {
+        if (ch === "]") inClass = false;
+        continue;
+      }
+      if (ch === "[") {
+        inClass = true;
+        continue;
+      }
+      if (ch === "(") depth++;
+      else if (ch === ")") {
+        depth--;
+        if (depth === 0) break;
+      }
+    }
+    if (j >= pattern.length) return false;
+    const next = pattern[j + 1];
+    if (next !== "+" && next !== "*" && next !== "{") continue;
+    let inner = pattern.slice(i + 1, j);
+    inner = inner.replace(/^\?(?::|<?[=!])/u, "");
+    const branches = [];
+    let current = "";
+    let d = 0;
+    let cls = false;
+    for (let k = 0; k < inner.length; k++) {
+      const ch = inner[k];
+      if (ch === "\\") {
+        current += ch + (inner[k + 1] ?? "");
+        k++;
+        continue;
+      }
+      if (cls) {
+        if (ch === "]") cls = false;
+        current += ch;
+        continue;
+      }
+      if (ch === "[") {
+        cls = true;
+        current += ch;
+        continue;
+      }
+      if (ch === "(") d++;
+      if (ch === ")") d--;
+      if (ch === "|" && d === 0) {
+        branches.push(current);
+        current = "";
+        continue;
+      }
+      current += ch;
+    }
+    branches.push(current);
+    if (branches.length < 2) continue;
+    for (let a = 0; a < branches.length; a++) {
+      for (let b = a + 1; b < branches.length; b++) {
+        const x = branches[a];
+        const y = branches[b];
+        if (x === "" || y === "") return true;
+        if (x === y || x.startsWith(y) || y.startsWith(x)) return true;
+      }
+    }
+  }
+  return false;
+}
 function compileUserRegex(pattern, flags) {
   if (typeof pattern !== "string") {
     return { ok: false, reason: "pattern must be a string" };
@@ -45,6 +120,12 @@ function compileUserRegex(pattern, flags) {
       };
     }
   }
+  if (hasAmbiguousQuantifiedAlternation(pattern)) {
+    return {
+      ok: false,
+      reason: "pattern quantifies an alternation with overlapping branches \u2014 rewrite so no two branches can match the same text"
+    };
+  }
   try {
     return { ok: true, regex: new RegExp(pattern, flags) };
   } catch (err) {

package/dist/skill.js

@@ -1,6 +1,11 @@
 // src/skill.ts
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import {
+  missingRequiredRuntimeTools,
+  missingRuntimeCapabilities,
+  runtimeToolReferencesFromText
+} from "@wrongstack/core/agent-catalog";
 import { SKILL_LIMITS, stripFrontmatter } from "@wrongstack/core/skills";
 import { ToolValidationError } from "@wrongstack/core/types";
 var MAX_BODY_CHARS = SKILL_LIMITS.MAX_SKILL_BODY_CHARS;
@@ -44,12 +49,37 @@ function makeSkillTool(skillLoader) {
           field: "name"
         });
       }
+      const availableToolNames = (ctx?.catalogTools ?? ctx?.tools ?? []).map((tool) => tool.name);
+      const missingCapabilities = missingRuntimeCapabilities(
+        manifest.requiredCapabilities,
+        availableToolNames
+      );
+      const missingTools = missingRequiredRuntimeTools(manifest.requiredTools, availableToolNames);
+      if (missingCapabilities.length > 0 || missingTools.length > 0) {
+        throw new ToolValidationError({
+          message: `skill "${name}" is unavailable in this runtime; ` + [
+            missingCapabilities.length > 0 ? `missing capabilities: ${missingCapabilities.join(", ")}` : "",
+            missingTools.length > 0 ? `missing tools: ${missingTools.join(", ")}` : ""
+          ].filter(Boolean).join("; "),
+          field: "name"
+        });
+      }
       const dir = path.dirname(manifest.path);
       let loadedResource;
       if (input.resource?.trim()) {
         loadedResource = await loadResource(dir, input.resource.trim());
       }
       const raw = await skillLoader.readBody(name);
+      const missingBodyTools = missingRequiredRuntimeTools(
+        runtimeToolReferencesFromText(raw),
+        availableToolNames
+      );
+      if (missingBodyTools.length > 0) {
+        throw new ToolValidationError({
+          message: `skill "${name}" references unregistered tools: ${missingBodyTools.join(", ")}`,
+          field: "name"
+        });
+      }
       const body = stripFrontmatter(raw).trim().slice(0, MAX_BODY_CHARS);
       const resources = loadedResource ? [] : await listResources(dir);
       try {
@@ -108,9 +138,26 @@ async function loadResource(skillDir, rel) {
       field: "resource"
     });
   }
+  let realPath;
+  let realRoot;
+  try {
+    realRoot = await fs.realpath(root);
+    realPath = await fs.realpath(absPath);
+  } catch {
+    throw new ToolValidationError({
+      message: `skill: resource "${rel}" not readable`,
+      field: "resource"
+    });
+  }
+  if (realPath !== realRoot && !realPath.startsWith(realRoot + path.sep)) {
+    throw new ToolValidationError({
+      message: `skill: resource "${rel}" resolves outside the skill directory`,
+      field: "resource"
+    });
+  }
   let buf;
   try {
-    buf = await fs.readFile(absPath);
+    buf = await fs.readFile(realPath);
   } catch {
     throw new ToolValidationError({
       message: `skill: resource "${rel}" not readable`,
@@ -121,7 +168,9 @@ async function loadResource(skillDir, rel) {
   const truncated = raw.length > MAX_RESOURCE_CHARS;
   return {
     rel: norm,
-    absPath,
+    // The canonical path — the one actually opened, and the one a follow-up
+    // `bash` invocation should use.
+    absPath: realPath,
     content: truncated ? raw.slice(0, MAX_RESOURCE_CHARS) : raw,
     bytes: buf.length,
     truncated

package/dist/test.js

@@ -669,7 +669,7 @@ var ProcessRegistryImpl = class {
     const p = this.processes.get(pid);
     if (!p) return false;
     if (p.killed) return true;
-    if (p.protected) return false;
+    if (p.protected && opts.includeProtected !== true) return false;
     if (opts.preserveBackground && p.background) return false;
     const { force = false, graceMs = DEFAULT_GRACE_MS } = opts;
     const isWin2 = os.platform() === "win32";
@@ -720,9 +720,13 @@ var ProcessRegistryImpl = class {
   killAll(opts = {}) {
     const pids = Array.from(this.processes.keys());
     const killed = [];
+    const includeProtected = opts.includeProtected === true;
     for (const pid of pids) {
       const p = this.processes.get(pid);
-      if (p && !p.protected && this.kill(pid, opts)) killed.push(pid);
+      if (!p) continue;
+      if (p.protected && !includeProtected) continue;
+      if (opts.preserveBackground && p.background) continue;
+      if (this.kill(pid, opts)) killed.push(pid);
     }
     return killed;
   }

package/dist/tool-help.js

@@ -31,7 +31,7 @@ var toolHelpTool = {
     const format = input.format ?? "short";
     const includeExamples = input.include_examples ?? false;
     if (input.tool) {
-      const tool = ctx.tools.find((t) => t.name === input.tool);
+      const tool = (ctx.catalogTools ?? ctx.tools).find((t) => t.name === input.tool);
       if (!tool) {
         return {
           tool: input.tool,
@@ -56,7 +56,7 @@ var toolHelpTool = {
         total: 1
       };
     }
-    const allTools = ctx.tools.map((t) => ({
+    const allTools = (ctx.catalogTools ?? ctx.tools).map((t) => ({
       name: t.name,
       description: t.description,
       usageHint: t.usageHint ?? "",

package/dist/tool-search.js

@@ -40,7 +40,7 @@ var toolSearchTool = {
   },
   async execute(input, ctx) {
     const limit = Math.min(input.limit ?? 20, 100);
-    const tools = ctx.tools;
+    const tools = ctx.catalogTools ?? ctx.tools;
     const query = input.query?.toLowerCase() ?? "";
     const filtered = tools.filter((t) => {
       if (query && !t.name.toLowerCase().includes(query) && !t.description.toLowerCase().includes(query)) {

package/dist/tool-tier.d.ts

@@ -1,5 +1,5 @@
-import type { ConcreteTokenSavingTier, Tool } from '@wrongstack/core/types';
 import type { ToolRegistry } from '@wrongstack/core/registry';
+import type { ConcreteTokenSavingTier, Tool } from '@wrongstack/core/types';
 /**
  * Select built-in tools for a concrete token-saving tier while preserving the
  * order and instances supplied by the caller.