shadow-claw 1.23.3 → 1.24.0

package/src/subsystems/tools/cron.test.ts

@@ -0,0 +1,64 @@
+import { matchesCron } from "./cron.js";
+
+describe("matchesCron", () => {
+  it("returns false for invalid or non-5-part expressions", () => {
+    expect(matchesCron("", new Date())).toBe(false);
+    expect(matchesCron(null as any, new Date())).toBe(false);
+    expect(matchesCron("* * *", new Date())).toBe(false);
+    expect(matchesCron("* * * * * *", new Date())).toBe(false);
+  });
+
+  it("matches wildcard expression", () => {
+    expect(matchesCron("* * * * *", new Date())).toBe(true);
+  });
+
+  it("matches exact numbers", () => {
+    // 2026-08-30 14:15:00, Sunday (day 0), August (month 8), day of month 30
+    const testDate = new Date(2026, 7, 30, 14, 15, 0); // Month is 0-indexed in JS Date: 7 = August
+
+    expect(matchesCron("15 14 30 8 0", testDate)).toBe(true);
+    expect(matchesCron("16 14 30 8 0", testDate)).toBe(false);
+  });
+
+  it("matches lists of numbers", () => {
+    const testDate = new Date(2026, 7, 30, 14, 15, 0);
+
+    expect(matchesCron("10,15,20 * * * *", testDate)).toBe(true);
+    expect(matchesCron("10,20,30 * * * *", testDate)).toBe(false);
+  });
+
+  it("matches ranges (N-M)", () => {
+    const testDate = new Date(2026, 7, 30, 14, 15, 0);
+
+    expect(matchesCron("10-20 * * * *", testDate)).toBe(true);
+    expect(matchesCron("20-30 * * * *", testDate)).toBe(false);
+  });
+
+  it("matches steps (*/N)", () => {
+    const testDate = new Date(2026, 7, 30, 14, 15, 0);
+
+    expect(matchesCron("*/5 * * * *", testDate)).toBe(true);
+    expect(matchesCron("*/7 * * * *", testDate)).toBe(false);
+  });
+
+  it("matches range with step (N-M/S)", () => {
+    const testDate = new Date(2026, 7, 30, 14, 15, 0);
+
+    expect(matchesCron("10-20/5 * * * *", testDate)).toBe(true); // 10, 15, 20 -> 15 matches
+    expect(matchesCron("10-20/4 * * * *", testDate)).toBe(false); // 10, 14, 18
+  });
+
+  it("matches start with step (N/S)", () => {
+    const testDate = new Date(2026, 7, 30, 14, 15, 0);
+
+    expect(matchesCron("5/10 * * * *", testDate)).toBe(true); // 5, 15, 25... -> 15 matches
+    expect(matchesCron("6/10 * * * *", testDate)).toBe(false);
+  });
+
+  it("handles invalid step strings", () => {
+    const testDate = new Date(2026, 7, 30, 14, 15, 0);
+
+    expect(matchesCron("*/0 * * * *", testDate)).toBe(false);
+    expect(matchesCron("*/abc * * * *", testDate)).toBe(false);
+  });
+});

package/src/subsystems/tools/declarative.test.ts

@@ -1,11 +1,45 @@
-import { describe, expect, it } from "@jest/globals";
+import { describe, expect, it, jest, beforeEach } from "@jest/globals";
 
-import { parseDeclarativeTool } from "./declarative.js";
+jest.unstable_mockModule("../../db/getConfig.js", () => ({
+  getConfig: jest.fn(),
+}));
 
-describe("parseDeclarativeTool", () => {
-  it("parses a sandboxed javascript tool definition", () => {
-    expect(
-      parseDeclarativeTool(".agents/tools/main/echo.json", {
+jest.unstable_mockModule("../../storage/getGroupDir.js", () => ({
+  getGroupDir: jest.fn(),
+}));
+
+jest.unstable_mockModule("../../storage/readGroupFile.js", () => ({
+  readGroupFile: jest.fn(),
+}));
+
+const { parseDeclarativeTool, loadDeclarativeTools, findDeclarativeTool } =
+  await import("./declarative.js");
+const { getConfig } = await import("../../db/getConfig.js");
+const { getGroupDir } = await import("../../storage/getGroupDir.js");
+const { readGroupFile } = await import("../../storage/readGroupFile.js");
+
+describe("declarative tools", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("parseDeclarativeTool", () => {
+    it("parses a sandboxed javascript tool definition", () => {
+      expect(
+        parseDeclarativeTool(".agents/tools/main/echo.json", {
+          name: "echo",
+          description: "Echo structured input.",
+          input_schema: {
+            type: "object",
+            properties: { value: { type: "string" } },
+            required: ["value"],
+          },
+          execution: {
+            type: "javascript",
+            code: "return JSON.parse(data).value;",
+          },
+        }),
+      ).toEqual({
         name: "echo",
         description: "Echo structured input.",
         input_schema: {
@@ -17,101 +51,233 @@ describe("parseDeclarativeTool", () => {
           type: "javascript",
           code: "return JSON.parse(data).value;",
         },
-      }),
-    ).toEqual({
-      name: "echo",
-      description: "Echo structured input.",
-      input_schema: {
-        type: "object",
-        properties: { value: { type: "string" } },
-        required: ["value"],
-      },
-      execution: {
-        type: "javascript",
-        code: "return JSON.parse(data).value;",
-      },
-      path: ".agents/tools/main/echo.json",
+        path: ".agents/tools/main/echo.json",
+      });
     });
-  });
 
-  it("rejects tools without a sandbox execution recipe", () => {
-    expect(() =>
-      parseDeclarativeTool(".agents/tools/main/echo.json", {
-        name: "echo",
-        description: "Echo structured input.",
+    it("parses a bash tool definition", () => {
+      const tool = parseDeclarativeTool(".agents/tools/main/run_sh.json", {
+        name: "run_sh",
+        description: "Run bash command.",
         input_schema: { type: "object" },
-      }),
-    ).toThrow("execution");
-  });
+        execution: {
+          type: "bash",
+          command: "echo hello",
+        },
+      });
 
-  it("parses a tool executor that delegates to an existing tool", () => {
-    expect(
-      parseDeclarativeTool(".agents/tools/main/repo_status.json", {
+      expect(tool.execution).toEqual({
+        type: "bash",
+        command: "echo hello",
+      });
+    });
+
+    it("parses a tool executor that delegates to an existing tool with inputs", () => {
+      const tool = parseDeclarativeTool(".agents/tools/main/repo_status.json", {
         name: "repo_status",
         description: "Show repository status.",
         input_schema: { type: "object" },
-        execution: { type: "tool", name: "git_status" },
-      }).execution,
-    ).toEqual({ type: "tool", name: "git_status" });
+        execution: {
+          type: "tool",
+          name: "git_status",
+          input: { verbose: true },
+        },
+      });
+
+      expect(tool.execution).toEqual({
+        type: "tool",
+        name: "git_status",
+        input: { verbose: true },
+      });
+    });
+
+    it("rejects invalid value shapes", () => {
+      expect(() => parseDeclarativeTool("test.json", null)).toThrow(
+        "must be a JSON object",
+      );
+      expect(() => parseDeclarativeTool("test.json", "string")).toThrow(
+        "must be a JSON object",
+      );
+    });
+
+    it("rejects invalid tool names", () => {
+      expect(() =>
+        parseDeclarativeTool("test.json", {
+          name: "Invalid-Name!",
+          description: "desc",
+          input_schema: {},
+          execution: {},
+        }),
+      ).toThrow("Tool name is invalid");
+
+      expect(() =>
+        parseDeclarativeTool("test.json", {
+          name: "",
+          description: "desc",
+          input_schema: {},
+          execution: {},
+        }),
+      ).toThrow("Tool name is invalid");
+    });
+
+    it("rejects missing description or input schema", () => {
+      expect(() =>
+        parseDeclarativeTool("test.json", {
+          name: "valid_name",
+          description: "",
+          input_schema: {},
+          execution: {},
+        }),
+      ).toThrow("requires a description");
+
+      expect(() =>
+        parseDeclarativeTool("test.json", {
+          name: "valid_name",
+          description: "desc",
+          input_schema: null,
+          execution: {},
+        }),
+      ).toThrow("requires input_schema");
+    });
+
+    it("rejects invalid execution specifications", () => {
+      expect(() =>
+        parseDeclarativeTool("test.json", {
+          name: "valid_name",
+          description: "desc",
+          input_schema: { type: "object" },
+          execution: null,
+        }),
+      ).toThrow("requires execution");
+
+      expect(() =>
+        parseDeclarativeTool("test.json", {
+          name: "valid_name",
+          description: "desc",
+          input_schema: { type: "object" },
+          execution: { type: "unsupported" },
+        }),
+      ).toThrow("execution type must be bash, javascript, or tool");
+
+      expect(() =>
+        parseDeclarativeTool("test.json", {
+          name: "valid_name",
+          description: "desc",
+          input_schema: { type: "object" },
+          execution: { type: "tool", name: "INVALID-DELEGATE!" },
+        }),
+      ).toThrow("execution requires a valid tool name");
+
+      expect(() =>
+        parseDeclarativeTool("test.json", {
+          name: "valid_name",
+          description: "desc",
+          input_schema: { type: "object" },
+          execution: { type: "bash", command: "   " },
+        }),
+      ).toThrow("execution requires command");
+    });
   });
 
-  it("parses generate_random_number declarative tool definition", () => {
-    const raw = {
-      name: "generate_random_number",
-      description:
-        "Generate a random integer within a specified range (min through max, inclusive).",
-      input_schema: {
-        type: "object",
-        properties: {
-          min: { type: "number", description: "Minimum integer value" },
-          max: { type: "number", description: "Maximum integer value" },
+  describe("loadDeclarativeTools & findDeclarativeTool", () => {
+    it("loads declarative tools from directory tree", async () => {
+      const mockFileHandle = { kind: "file" };
+      const mockToolsDir = {
+        entries: async function* () {
+          yield ["calc.json", mockFileHandle];
+          yield ["invalid.json", mockFileHandle];
+        },
+      };
+      const mockAgentsDir = {
+        getDirectoryHandle: jest.fn().mockImplementation(async (name) => {
+          if (name === "tools") return mockToolsDir;
+          throw new Error("Not found");
+        }),
+      };
+      const mockRoot = {
+        getDirectoryHandle: jest.fn().mockImplementation(async (name) => {
+          if (name === ".agents") return mockAgentsDir;
+          throw new Error("Not found");
+        }),
+      };
+
+      (getGroupDir as jest.Mock<any>).mockResolvedValue(mockRoot);
+      (readGroupFile as jest.Mock<any>).mockImplementation(
+        async (_db: any, _gid: any, path: any) => {
+          if (path === ".agents/tools/calc.json") {
+            return JSON.stringify({
+              name: "calc",
+              description: "Calculate value",
+              input_schema: { type: "object" },
+              execution: { type: "javascript", code: "return 1;" },
+            });
+          }
+          return "{ invalid json }";
         },
-      },
-      execution: {
-        type: "javascript",
-        code: "const input = data ? JSON.parse(data) : {}; const min = typeof input.min === 'number' ? input.min : 1; const max = typeof input.max === 'number' ? input.max : 1000000; return Math.floor(Math.random() * (max - min + 1)) + min;",
-      },
-    };
-
-    expect(
-      parseDeclarativeTool(
-        ".agents/tools/main/generate_random_number.json",
-        raw,
-      ),
-    ).toEqual({
-      ...raw,
-      path: ".agents/tools/main/generate_random_number.json",
+      );
+
+      const { tools, diagnostics } = await loadDeclarativeTools({} as any);
+      expect(tools).toHaveLength(1);
+      expect(tools[0].name).toBe("calc");
+      expect(diagnostics).toHaveLength(1);
     });
-  });
 
-  it("parses tools using parameters and evaluation expression aliases", () => {
-    const raw = {
-      name: "calculate_ore_depth",
-      description: "Calculates ore depth.",
-      parameters: {
-        type: "object",
-        properties: { y: { type: "number" } },
-      },
-      evaluation: {
-        type: "javascript",
-        expression: "return { y: data ? JSON.parse(data).y : 0 };",
-      },
-    };
-
-    expect(
-      parseDeclarativeTool(".agents/tools/main/calculate_ore_depth.json", raw),
-    ).toEqual({
-      name: "calculate_ore_depth",
-      description: "Calculates ore depth.",
-      input_schema: {
-        type: "object",
-        properties: { y: { type: "number" } },
-      },
-      execution: {
-        type: "javascript",
-        code: "return { y: data ? JSON.parse(data).y : 0 };",
-      },
-      path: ".agents/tools/main/calculate_ore_depth.json",
+    it("returns empty tools when agents directory does not exist", async () => {
+      (getGroupDir as jest.Mock<any>).mockResolvedValue({
+        getDirectoryHandle: (jest.fn() as any).mockRejectedValue(
+          new Error("No .agents dir"),
+        ),
+      });
+
+      const { tools, diagnostics } = await loadDeclarativeTools({} as any);
+      expect(tools).toEqual([]);
+      expect(diagnostics).toEqual([]);
+    });
+
+    it("finds declarative tool by name when enabled", async () => {
+      const mockFileHandle = { kind: "file" };
+      const mockToolsDir = {
+        entries: async function* () {
+          yield ["my_tool.json", mockFileHandle];
+        },
+      };
+      const mockAgentsDir = {
+        getDirectoryHandle: (jest.fn() as any).mockResolvedValue(mockToolsDir),
+      };
+      const mockRoot = {
+        getDirectoryHandle: (jest.fn() as any).mockResolvedValue(mockAgentsDir),
+      };
+
+      (getGroupDir as jest.Mock<any>).mockResolvedValue(mockRoot);
+      (readGroupFile as jest.Mock<any>).mockResolvedValue(
+        JSON.stringify({
+          name: "my_tool",
+          description: "My custom tool",
+          input_schema: { type: "object" },
+          execution: { type: "javascript", code: "return true;" },
+        }),
+      );
+      (getConfig as jest.Mock<any>).mockResolvedValue(["my_tool"]);
+
+      const tool = await findDeclarativeTool({} as any, "main", "my_tool");
+      expect(tool?.name).toBe("my_tool");
+
+      // When tool is not in enabled list
+      (getConfig as jest.Mock<any>).mockResolvedValue(["other_tool"]);
+      const disabledTool = await findDeclarativeTool(
+        {} as any,
+        "main",
+        "my_tool",
+      );
+      expect(disabledTool).toBeNull();
+
+      // When searching for non-existent tool
+      const missing = await findDeclarativeTool(
+        {} as any,
+        "main",
+        "non_existent",
+      );
+      expect(missing).toBeNull();
     });
   });
 });

package/src/testing/assets/v86.9pfs/libv86.mjs

@@ -0,0 +1,63 @@
+export class V86 {
+  constructor(options) {
+    this.options = options;
+    this.listeners = new Map();
+    this.serial0_send = (text) => {
+      if (text === "root\n") {
+        setTimeout(() => {
+          this.emitSerial("# ");
+        }, 5);
+      } else if (text && text.includes("sleep")) {
+        // Do not auto-respond to sleep commands to test timeout recovery
+        return;
+      } else if (text && text.includes("__BCDONE_")) {
+        const match = /printf "\\n(__BCDONE_[^%]+)%s\\n"/.exec(text);
+        if (match) {
+          setTimeout(() => {
+            this.emitSerial(`\n${match[1]}0\n`);
+          }, 5);
+        }
+      } else if (text && text.includes("\u0003")) {
+        setTimeout(() => {
+          this.emitSerial("# ");
+        }, 5);
+      }
+    };
+    this.destroy = () => Promise.resolve();
+    this.fs9p = {
+      read_dir: () => [],
+      SearchPath: (path) => ({ id: path === "/home/user" ? 1 : -1 }),
+      IsDirectory: () => true,
+    };
+    this.create_file = () => Promise.resolve();
+    this.read_file = () => Promise.resolve(new Uint8Array([1, 2, 3]));
+
+    // Auto-emit boot sequence
+    setTimeout(() => {
+      this.emitSerial("Booting Linux on ttyS0\nlogin: ");
+    }, 5);
+  }
+
+  add_listener(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, new Set());
+    }
+    this.listeners.get(event).add(listener);
+  }
+
+  remove_listener(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+  }
+
+  emitSerial(text) {
+    const serialListeners = this.listeners.get("serial0-output-byte");
+    if (!serialListeners) return;
+    for (const ch of text) {
+      for (const listener of serialListeners) {
+        listener(ch.charCodeAt(0));
+      }
+    }
+  }
+}
+
+export default V86;

package/src/testing/assets/v86.ext2/libv86.mjs

@@ -0,0 +1,3 @@
+import V86 from "../v86.9pfs/libv86.mjs";
+export { V86 };
+export default V86;

package/src/testing/assets_missing_v86/assets/v86.9pfs/libv86.mjs

@@ -0,0 +1 @@
+export const notV86 = true;