shadow-claw 1.40.0 → 1.41.0

package/src/core/orchestrator/utils/operations/room.test.ts

@@ -1,16 +1,37 @@
-import { jest } from "@jest/globals";
-
-import { createRoom, inviteToRoom, leaveRoom } from "./room.js";
+import { describe, expect, it, jest } from "@jest/globals";
+import type { RoomInvitePayload } from "../../../../subsystems/channels/peer-protocol.js";
+import type { RoomManager } from "../../../../subsystems/channels/room-manager.js";
+import type { RoomMeta } from "../../../../subsystems/channels/types.js";
+import type { EventBus } from "../EventBus.js";
+import {
+  createRoom,
+  handleRoomInvite,
+  inviteToRoom,
+  joinRoomViaLink,
+  leaveRoom,
+  listRooms,
+} from "./room.js";
 
 function makeState() {
+  const mockRoom: RoomMeta = {
+    roomId: "room1",
+    name: "test-room",
+    hostPeerId: "peer-host",
+    createdAt: Date.now(),
+    members: [],
+  };
+
   return {
-    events: { emit: jest.fn() } as any,
+    events: {
+      emit: jest.fn<(...args: unknown[]) => unknown>(),
+    } as unknown as EventBus,
     roomManager: {
-      createRoom: jest.fn().mockReturnValue({ roomId: "room1" }),
-      invite: jest.fn().mockReturnValue(true),
-      leaveRoom: jest.fn(),
-      list: jest.fn().mockReturnValue([]),
-    } as any,
+      createRoom: jest.fn<() => RoomMeta>().mockReturnValue(mockRoom),
+      invite: jest.fn<() => boolean>().mockReturnValue(true),
+      joinRoom: jest.fn<() => RoomMeta>().mockReturnValue(mockRoom),
+      leaveRoom: jest.fn<() => void>(),
+      list: jest.fn<() => RoomMeta[]>().mockReturnValue([mockRoom]),
+    } as unknown as RoomManager,
   };
 }
 
@@ -19,7 +40,9 @@ describe("room operations", () => {
     const state = makeState();
     const room = createRoom(state, "test-room");
     expect(room.roomId).toBe("room1");
-    expect(state.events.emit).toHaveBeenCalledWith("rooms-changed", []);
+    expect(state.events.emit).toHaveBeenCalledWith("rooms-changed", [
+      expect.objectContaining({ roomId: "room1" }),
+    ]);
   });
 
   it("inviteToRoom delegates", () => {
@@ -28,10 +51,50 @@ describe("room operations", () => {
     expect(state.roomManager.invite).toHaveBeenCalledWith("room1", "peer1");
   });
 
+  it("joinRoomViaLink delegates and emits", () => {
+    const state = makeState();
+    const room = joinRoomViaLink(state, "room1", "peer-host", "test-room");
+    expect(room.roomId).toBe("room1");
+    expect(state.roomManager.joinRoom).toHaveBeenCalledWith(
+      "room1",
+      "peer-host",
+      "test-room",
+    );
+    expect(state.events.emit).toHaveBeenCalledWith("rooms-changed", [
+      expect.objectContaining({ roomId: "room1" }),
+    ]);
+  });
+
   it("leaveRoom delegates and emits", () => {
     const state = makeState();
     leaveRoom(state, "room1");
     expect(state.roomManager.leaveRoom).toHaveBeenCalledWith("room1");
-    expect(state.events.emit).toHaveBeenCalledWith("rooms-changed", []);
+    expect(state.events.emit).toHaveBeenCalledWith("rooms-changed", [
+      expect.objectContaining({ roomId: "room1" }),
+    ]);
+  });
+
+  it("listRooms returns rooms from roomManager", () => {
+    const state = makeState();
+    const rooms = listRooms(state);
+    expect(rooms).toHaveLength(1);
+    expect(rooms[0].roomId).toBe("room1");
+    expect(state.roomManager.list).toHaveBeenCalled();
+  });
+
+  it("handleRoomInvite emits room-invite event", () => {
+    const state = {
+      events: {
+        emit: jest.fn<(...args: unknown[]) => unknown>(),
+      } as unknown as EventBus,
+    };
+    const invite: RoomInvitePayload = {
+      roomId: "room2",
+      roomName: "invited-room",
+      hostPeerId: "peer-host-2",
+      fromPeerId: "peer-from-2",
+    };
+    handleRoomInvite(state, invite);
+    expect(state.events.emit).toHaveBeenCalledWith("room-invite", invite);
   });
 });

package/src/core/orchestrator/utils/operations/task.test.ts

@@ -1,86 +1,482 @@
-import { beforeEach, describe, expect, it, jest } from "@jest/globals";
-
+/** @jest-environment node */
 import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  jest,
+} from "@jest/globals";
+import type { Task } from "../../../../db/types.js";
+import type { OrchestratorState } from "../../orchestrator-state.js";
+
+const mockRunTask = jest.fn<() => Promise<void>>();
+const mockShowToast = jest.fn();
+
+jest.unstable_mockModule("../../../../stores/orchestrator.js", () => ({
+  orchestratorStore: {
+    runTask: mockRunTask,
+  },
+}));
+
+jest.unstable_mockModule("../../../../ui/toast.js", () => ({
+  showToast: mockShowToast,
+}));
+
+const {
   deleteTaskFromServer,
+  getTaskFetchOptions,
+  runTaskAsScheduled,
   shouldStartLocalScheduler,
   syncTaskToServer,
-} from "./task.js";
+  warnIfNoPushSubscription,
+} = await import("./task.js");
 
 describe("task operations", () => {
+  let mockFetch: jest.Mock<
+    (url: string, init?: RequestInit) => Promise<Response>
+  >;
+  let originalNavigator: unknown;
+
   beforeEach(() => {
-    (globalThis as any).fetch = (jest.fn() as any).mockResolvedValue({
-      ok: true,
-    });
+    jest.clearAllMocks();
+    originalNavigator = globalThis.navigator;
+
+    mockFetch = jest.fn(
+      async () =>
+        ({
+          ok: true,
+          status: 200,
+        }) as Response,
+    );
+
+    (globalThis as Record<string, unknown>).fetch = mockFetch;
   });
 
-  it("shouldStartLocalScheduler returns true if serviceWorker missing", async () => {
+  afterEach(() => {
     Object.defineProperty(globalThis, "navigator", {
-      value: { serviceWorker: undefined },
+      value: originalNavigator,
       configurable: true,
     });
-    expect(await shouldStartLocalScheduler()).toBe(true);
   });
 
-  it("syncTaskToServer includes subscriberId in request body", async () => {
-    await syncTaskToServer(
-      { taskServerUrl: "/schedule", taskServerEnabled: true } as any,
-      {
+  describe("getTaskFetchOptions & syncTaskToServer", () => {
+    it("getTaskFetchOptions defaults baseOptions to empty object", () => {
+      const opts = getTaskFetchOptions("http://localhost:8888");
+      expect(opts).toEqual(
+        expect.objectContaining({
+          targetAddressSpace: "loopback",
+        }),
+      );
+    });
+
+    const defaultState: Pick<
+      OrchestratorState,
+      "taskServerUrl" | "taskServerEnabled" | "pushSubscriptionWarned"
+    > = {
+      taskServerUrl: "http://localhost:8888",
+      taskServerEnabled: true,
+      pushSubscriptionWarned: true,
+    };
+
+    const scheduledTask: Task = {
+      id: "t1",
+      groupId: "br:main",
+      prompt: "hello",
+      schedule: "*/5 * * * *",
+      enabled: true,
+      lastRun: null,
+      createdAt: 1,
+    };
+
+    it("silently succeeds when taskServerEnabled is false", async () => {
+      const result = await syncTaskToServer(
+        { ...defaultState, taskServerEnabled: false },
+        scheduledTask,
+      );
+      expect(result).toBe(true);
+      expect(mockFetch).not.toHaveBeenCalled();
+    });
+
+    it("calls deleteTaskFromServer if task has no schedule", async () => {
+      const unscheduledTask: Task = { ...scheduledTask, schedule: "" };
+      const result = await syncTaskToServer(
+        defaultState,
+        unscheduledTask,
+        "sub-del",
+      );
+      expect(result).toBe(true);
+      expect(mockFetch).toHaveBeenCalledWith(
+        "http://localhost:8888/tasks/t1?subscriberId=sub-del",
+        expect.objectContaining({ method: "DELETE" }),
+      );
+    });
+
+    it("syncs task to server and sets loopback targetAddressSpace for localhost / loopback IPs", async () => {
+      for (const host of ["localhost", "127.0.0.1", "[::1]"]) {
+        mockFetch.mockClear();
+        await syncTaskToServer(
+          { ...defaultState, taskServerUrl: `http://${host}:8888/` },
+          scheduledTask,
+        );
+        expect(mockFetch).toHaveBeenCalledWith(
+          `http://${host}:8888/tasks`,
+          expect.objectContaining({
+            method: "POST",
+            targetAddressSpace: "loopback",
+          }),
+        );
+      }
+    });
+
+    it("sets private targetAddressSpace for private IP ranges and internal domains", async () => {
+      const privateHosts = [
+        "10.0.0.1",
+        "172.16.0.1",
+        "172.31.255.255",
+        "192.168.1.1",
+        "my-server.local",
+        "server.lan",
+        "box.home",
+        "cluster.internal",
+        "singlelabelhost",
+      ];
+
+      for (const host of privateHosts) {
+        mockFetch.mockClear();
+        await syncTaskToServer(
+          { ...defaultState, taskServerUrl: `http://${host}:9000` },
+          scheduledTask,
+          "sub-private",
+        );
+        expect(mockFetch).toHaveBeenCalledWith(
+          `http://${host}:9000/tasks`,
+          expect.objectContaining({
+            targetAddressSpace: "private",
+          }),
+        );
+      }
+    });
+
+    it("does not set targetAddressSpace for public hosts", async () => {
+      await syncTaskToServer(
+        { ...defaultState, taskServerUrl: "https://api.example.com" },
+        scheduledTask,
+      );
+      expect(mockFetch).toHaveBeenCalledWith(
+        "https://api.example.com/tasks",
+        expect.not.objectContaining({
+          targetAddressSpace: expect.anything(),
+        }),
+      );
+    });
+
+    it("handles invalid URLs in getTaskFetchOptions without throwing", async () => {
+      await syncTaskToServer(
+        { ...defaultState, taskServerUrl: "http://[invalid-ipv6" },
+        scheduledTask,
+      );
+      expect(mockFetch).toHaveBeenCalled();
+    });
+
+    it("uses fallback origin when location is undefined and uses location.origin when defined", () => {
+      const optsWithoutLoc = getTaskFetchOptions("/relative-path");
+      expect(optsWithoutLoc).toBeDefined();
+
+      Object.defineProperty(globalThis, "location", {
+        value: { origin: "http://example.org" },
+        configurable: true,
+      });
+      try {
+        const optsWithLoc = getTaskFetchOptions("/relative-path");
+        expect(optsWithLoc).toBeDefined();
+      } finally {
+        delete (globalThis as Record<string, unknown>).location;
+      }
+    });
+
+    it("returns false and logs error when server rejects sync", async () => {
+      mockFetch.mockResolvedValueOnce({ ok: false, status: 500 } as Response);
+      const consoleError = jest
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+
+      const result = await syncTaskToServer(defaultState, scheduledTask);
+      expect(result).toBe(false);
+      expect(consoleError).toHaveBeenCalledWith(
+        "Server rejected task sync:",
+        500,
+      );
+
+      consoleError.mockRestore();
+    });
+
+    it("returns false and logs error when fetch throws", async () => {
+      mockFetch.mockRejectedValueOnce(new Error("Network failed"));
+      const consoleError = jest
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+
+      const result = await syncTaskToServer(defaultState, scheduledTask);
+      expect(result).toBe(false);
+      expect(consoleError).toHaveBeenCalledWith(
+        "Failed to sync task to server:",
+        expect.any(Error),
+      );
+
+      consoleError.mockRestore();
+    });
+  });
+
+  describe("deleteTaskFromServer", () => {
+    const defaultState: Pick<
+      OrchestratorState,
+      "taskServerUrl" | "taskServerEnabled"
+    > = {
+      taskServerUrl: "http://localhost:8888/",
+      taskServerEnabled: true,
+    };
+
+    it("silently succeeds when taskServerEnabled is false", async () => {
+      const result = await deleteTaskFromServer(
+        { ...defaultState, taskServerEnabled: false },
+        "t1",
+      );
+      expect(result).toBe(true);
+      expect(mockFetch).not.toHaveBeenCalled();
+    });
+
+    it("deletes task without subscriberId suffix", async () => {
+      const result = await deleteTaskFromServer(defaultState, "t1");
+      expect(result).toBe(true);
+      expect(mockFetch).toHaveBeenCalledWith(
+        "http://localhost:8888/tasks/t1",
+        expect.objectContaining({ method: "DELETE" }),
+      );
+    });
+
+    it("returns false when delete request fails", async () => {
+      mockFetch.mockResolvedValueOnce({ ok: false, status: 404 } as Response);
+      const consoleError = jest
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+
+      const result = await deleteTaskFromServer(defaultState, "t1");
+      expect(result).toBe(false);
+      expect(consoleError).toHaveBeenCalledWith(
+        "Server rejected task deletion:",
+        404,
+      );
+
+      consoleError.mockRestore();
+    });
+
+    it("returns false when delete request throws", async () => {
+      mockFetch.mockRejectedValueOnce(new Error("Connection reset"));
+      const consoleError = jest
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+
+      const result = await deleteTaskFromServer(defaultState, "t1");
+      expect(result).toBe(false);
+      expect(consoleError).toHaveBeenCalledWith(
+        "Failed to delete task from server:",
+        expect.any(Error),
+      );
+
+      consoleError.mockRestore();
+    });
+  });
+
+  describe("runTaskAsScheduled", () => {
+    it("refuses to run if task has no groupId", async () => {
+      const consoleError = jest
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+      const state = { schedulerTriggeredGroups: new Set<string>() };
+
+      await runTaskAsScheduled(state, {
         id: "t1",
-        groupId: "br:main",
-        prompt: "hello",
-        schedule: "*/5 * * * *",
+        prompt: "do something",
+        schedule: "* * * * *",
         enabled: true,
         lastRun: null,
         createdAt: 1,
-      } as any,
-      "sub-1",
-    );
+      } as Task);
 
-    expect((globalThis as any).fetch).toHaveBeenCalledWith(
-      "/schedule/tasks",
-      expect.objectContaining({ method: "POST" }),
-    );
+      expect(consoleError).toHaveBeenCalled();
+      expect(mockRunTask).not.toHaveBeenCalled();
+      expect(state.schedulerTriggeredGroups.size).toBe(0);
 
-    const body = JSON.parse((globalThis as any).fetch.mock.calls[0][1].body);
-    expect(body.subscriberId).toBe("sub-1");
-  });
+      consoleError.mockRestore();
+    });
 
-  it("deleteTaskFromServer includes subscriberId query parameter", async () => {
-    await deleteTaskFromServer(
-      { taskServerUrl: "/schedule", taskServerEnabled: true } as any,
-      "t1",
-      "sub-2",
-    );
+    it("adds groupId to schedulerTriggeredGroups and cleans up in finally", async () => {
+      const state = { schedulerTriggeredGroups: new Set<string>() };
+      let hadGroupDuringExecution = false;
 
-    expect((globalThis as any).fetch).toHaveBeenCalledWith(
-      "/schedule/tasks/t1?subscriberId=sub-2",
-      expect.objectContaining({ method: "DELETE" }),
-    );
-  });
+      mockRunTask.mockImplementationOnce(async () => {
+        hadGroupDuringExecution = state.schedulerTriggeredGroups.has("br:main");
+      });
 
-  it("syncTaskToServer sets targetAddressSpace private for local hostnames", async () => {
-    await syncTaskToServer(
-      {
-        taskServerUrl: "https://hostname:8888/schedule",
-        taskServerEnabled: true,
-      } as any,
-      {
-        id: "t2",
+      const task: Task = {
+        id: "t1",
         groupId: "br:main",
-        prompt: "hello",
-        schedule: "*/5 * * * *",
+        prompt: "do something",
+        schedule: "* * * * *",
         enabled: true,
         lastRun: null,
         createdAt: 1,
-      } as any,
-    );
+      };
 
-    expect((globalThis as any).fetch).toHaveBeenCalledWith(
-      "https://hostname:8888/schedule/tasks",
-      expect.objectContaining({
-        method: "POST",
-        targetAddressSpace: "private",
-      }),
-    );
+      await runTaskAsScheduled(state, task);
+
+      expect(hadGroupDuringExecution).toBe(true);
+      expect(state.schedulerTriggeredGroups.has("br:main")).toBe(false);
+    });
+  });
+
+  describe("shouldStartLocalScheduler", () => {
+    it("returns true if navigator is undefined", async () => {
+      Object.defineProperty(globalThis, "navigator", {
+        value: undefined,
+        configurable: true,
+      });
+      expect(await shouldStartLocalScheduler()).toBe(true);
+    });
+
+    it("returns true if navigator.serviceWorker is missing", async () => {
+      Object.defineProperty(globalThis, "navigator", {
+        value: {},
+        configurable: true,
+      });
+      expect(await shouldStartLocalScheduler()).toBe(true);
+    });
+
+    it("returns true if push subscription is missing", async () => {
+      Object.defineProperty(globalThis, "navigator", {
+        value: {
+          serviceWorker: {
+            ready: Promise.resolve({
+              pushManager: {
+                getSubscription: async () => null,
+              },
+            }),
+          },
+        },
+        configurable: true,
+      });
+      expect(await shouldStartLocalScheduler()).toBe(true);
+    });
+
+    it("returns false if push subscription is active", async () => {
+      Object.defineProperty(globalThis, "navigator", {
+        value: {
+          serviceWorker: {
+            ready: Promise.resolve({
+              pushManager: {
+                getSubscription: async () => ({
+                  endpoint: "https://push.example.com",
+                }),
+              },
+            }),
+          },
+        },
+        configurable: true,
+      });
+      expect(await shouldStartLocalScheduler()).toBe(false);
+    });
+
+    it("returns true if service worker check throws", async () => {
+      Object.defineProperty(globalThis, "navigator", {
+        value: {
+          serviceWorker: {
+            ready: Promise.reject(new Error("Worker rejected")),
+          },
+        },
+        configurable: true,
+      });
+      expect(await shouldStartLocalScheduler()).toBe(true);
+    });
+  });
+
+  describe("warnIfNoPushSubscription", () => {
+    it("returns early if pushSubscriptionWarned is already true", async () => {
+      const state = { pushSubscriptionWarned: true };
+      await warnIfNoPushSubscription(state);
+      expect(mockShowToast).not.toHaveBeenCalled();
+    });
+
+    it("returns early if navigator or serviceWorker is undefined", async () => {
+      Object.defineProperty(globalThis, "navigator", {
+        value: undefined,
+        configurable: true,
+      });
+      const state = { pushSubscriptionWarned: false };
+      await warnIfNoPushSubscription(state);
+      expect(mockShowToast).not.toHaveBeenCalled();
+
+      Object.defineProperty(globalThis, "navigator", {
+        value: {},
+        configurable: true,
+      });
+      await warnIfNoPushSubscription(state);
+      expect(mockShowToast).not.toHaveBeenCalled();
+    });
+
+    it("shows toast warning when no push subscription exists", async () => {
+      Object.defineProperty(globalThis, "navigator", {
+        value: {
+          serviceWorker: {
+            ready: Promise.resolve({
+              pushManager: {
+                getSubscription: async () => null,
+              },
+            }),
+          },
+        },
+        configurable: true,
+      });
+      const state = { pushSubscriptionWarned: false };
+      await warnIfNoPushSubscription(state);
+
+      expect(state.pushSubscriptionWarned).toBe(true);
+      expect(mockShowToast).toHaveBeenCalledWith(
+        expect.stringContaining("Push notifications are not enabled"),
+        { type: "warning" },
+      );
+    });
+
+    it("does not warn when active push subscription exists", async () => {
+      Object.defineProperty(globalThis, "navigator", {
+        value: {
+          serviceWorker: {
+            ready: Promise.resolve({
+              pushManager: {
+                getSubscription: async () => ({ endpoint: "active" }),
+              },
+            }),
+          },
+        },
+        configurable: true,
+      });
+      const state = { pushSubscriptionWarned: false };
+      await warnIfNoPushSubscription(state);
+
+      expect(mockShowToast).not.toHaveBeenCalled();
+    });
+
+    it("ignores errors thrown during serviceWorker check", async () => {
+      Object.defineProperty(globalThis, "navigator", {
+        value: {
+          serviceWorker: {
+            ready: Promise.reject(new Error("Push API denied")),
+          },
+        },
+        configurable: true,
+      });
+      const state = { pushSubscriptionWarned: false };
+      await expect(warnIfNoPushSubscription(state)).resolves.not.toThrow();
+    });
   });
 });

package/src/core/orchestrator/utils/operations/task.ts

@@ -4,7 +4,7 @@ import { showToast } from "../../../../ui/toast.js";
 import type { Task } from "../../../../db/types.js";
 import type { OrchestratorState } from "../../orchestrator-state.js";
 
-function getTaskFetchOptions(
+export function getTaskFetchOptions(
   url: string,
   baseOptions: RequestInit = {},
 ): RequestInit {