shadow-claw 1.51.0 → 1.52.1

package/src/components/settings/shadow-claw-peerjs/shadow-claw-peerjs.test.ts

@@ -384,4 +384,131 @@ describe("shadow-claw-peerjs", () => {
 
     document.body.removeChild(el);
   });
+
+  it("handles room card button actions: invite, link/qr, and disband/leave", async () => {
+    const el = new ShadowClawPeerJs() as any;
+    document.body.appendChild(el);
+    await el.connectedCallback();
+
+    const { listRooms, inviteToRoom, leaveRoom } =
+      await import("../../../core/orchestrator/utils/operations/room.js");
+
+    const testRooms = [
+      {
+        roomId: "room-host-1",
+        name: "My Host Room",
+        hostPeerId: "test-peer-id",
+        members: [{ peerId: "test-peer-id", alias: "Host Me", kind: "human" }],
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      },
+    ];
+    (listRooms as jest.Mock<any>).mockReturnValue(testRooms);
+
+    el.renderRooms();
+
+    const card = el.shadowRoot?.querySelector(".peerjs-room-card");
+    expect(card).not.toBeNull();
+
+    // Invite button without selected peer (shows error)
+    const buttons = Array.from(card?.querySelectorAll("button") || []) as any[];
+    const inviteBtn = buttons.find((b: any) => b.textContent === "Invite");
+    const linkBtn = buttons.find((b: any) => b.textContent?.includes("Link"));
+    const disbandBtn = buttons.find((b: any) => b.textContent === "Disband");
+    const select = card?.querySelector("select");
+
+    // 1. Invite without peer
+    if (select) select.value = "";
+    inviteBtn?.dispatchEvent(new Event("click"));
+
+    // 2. Invite with peer
+    if (select) {
+      const opt = document.createElement("option");
+      opt.value = "trusted-1";
+      select.appendChild(opt);
+      select.value = "trusted-1";
+    }
+    inviteBtn?.dispatchEvent(new Event("click"));
+    expect(inviteToRoom).toHaveBeenCalledWith(
+      expect.anything(),
+      "room-host-1",
+      "trusted-1",
+    );
+
+    // 3. Link/QR
+    linkBtn?.dispatchEvent(new Event("click"));
+
+    // 4. Disband
+    disbandBtn?.dispatchEvent(new Event("click"));
+    expect(leaveRoom).toHaveBeenCalledWith(expect.anything(), "room-host-1");
+
+    document.body.removeChild(el);
+  });
+
+  it("handles adding trusted peers and auto-generating Peer ID on save", async () => {
+    const el = new ShadowClawPeerJs() as any;
+    document.body.appendChild(el);
+    await el.connectedCallback();
+
+    const root = el.shadowRoot!;
+    const idInput = root.querySelector(
+      '[data-setting="peerjs-new-trusted-id-input"]',
+    ) as HTMLInputElement;
+    const aliasInput = root.querySelector(
+      '[data-setting="peerjs-new-trusted-alias-input"]',
+    ) as HTMLInputElement;
+    const addBtn = root.querySelector('[data-action="add-trusted-peer"]');
+
+    if (idInput && aliasInput && addBtn) {
+      idInput.value = "peer-abc";
+      aliasInput.value = "Alice";
+      addBtn.dispatchEvent(new Event("click"));
+
+      expect(idInput.value).toBe("");
+      expect(aliasInput.value).toBe("");
+
+      const rows = root.querySelectorAll(".peerjs-trusted-peer-row");
+      expect(rows.length).toBeGreaterThan(0);
+    }
+
+    // Clear myPeerIdInput to test auto-generation
+    const myPeerIdInput = root.querySelector(
+      '[data-setting="peerjs-my-peer-id-input"]',
+    ) as HTMLInputElement;
+    if (myPeerIdInput) {
+      myPeerIdInput.value = "";
+    }
+
+    await el.savePeerJsConfig();
+    expect(mockConfigurePeerJs).toHaveBeenCalled();
+
+    document.body.removeChild(el);
+  });
+
+  it("handles peerAliases in render", async () => {
+    const el = new ShadowClawPeerJs() as any;
+    document.body.appendChild(el);
+    await el.connectedCallback();
+
+    mockGetPeerJsConfig.mockReturnValueOnce({
+      enabled: true,
+      myPeerId: "peer-1",
+      myAlias: "Me",
+      trustedPeerIds: ["peer-2"],
+      peerAliases: { Bob: "peer-2" },
+      serverHost: "localhost",
+      serverPort: 9000,
+      serverPath: "/",
+      serverSecure: false,
+    });
+
+    await el.render();
+
+    const status = el.shadowRoot?.querySelector(
+      '[data-info="peerjs-trusted-ids-status"]',
+    );
+    expect(status?.textContent).toContain("Bob");
+
+    document.body.removeChild(el);
+  });
 });

package/src/components/settings/shadow-claw-storage/shadow-claw-storage.test.ts

@@ -32,6 +32,10 @@ jest.unstable_mockModule(
   }),
 );
 
+jest.unstable_mockModule("../../../storage/selectStorageDirectory.js", () => ({
+  selectStorageDirectory: jest.fn<any>().mockResolvedValue(true),
+}));
+
 jest.unstable_mockModule("../../../db/db.js", () => ({
   getDb: jest.fn<any>().mockResolvedValue({
     transaction: jest.fn(() => ({
@@ -70,6 +74,7 @@ jest.unstable_mockModule("../../../stores/orchestrator.js", () => ({
     storageStatus: { type: "opfs", permission: "granted" },
     resetSiteConfigSeed: jest.fn<any>().mockResolvedValue(undefined),
     loadFiles: jest.fn<any>().mockResolvedValue(undefined),
+    grantStorageAccess: jest.fn<any>().mockResolvedValue(undefined),
   },
 }));
 
@@ -191,4 +196,172 @@ describe("shadow-claw-storage", () => {
       3500,
     );
   });
+
+  it("handles handleChangeStorageDir success and errors", async () => {
+    const { selectStorageDirectory } =
+      await import("../../../storage/selectStorageDirectory.js");
+    const { showError } = await import("../../../ui/toast.js");
+
+    const el = new ShadowClawStorage() as any;
+    el.db = {};
+    el.updateStorageInfo = jest.fn();
+
+    (selectStorageDirectory as jest.Mock<any>).mockResolvedValueOnce(true);
+    await el.handleChangeStorageDir();
+    expect(showSuccess).toHaveBeenCalledWith(
+      "Storage location changed. Existing OPFS files were not moved.",
+      4500,
+    );
+
+    (selectStorageDirectory as jest.Mock<any>).mockRejectedValueOnce(
+      new Error("Directory pick error"),
+    );
+    await el.handleChangeStorageDir();
+    expect(showError).toHaveBeenCalledWith(
+      expect.stringContaining("Directory pick error"),
+      6000,
+    );
+  });
+
+  it("handles errors during storage operations", async () => {
+    const { showError } = await import("../../../ui/toast.js");
+    const { requestPersistentStorage } =
+      await import("../../../storage/requestPersistentStorage.js");
+    const { resetStorageDirectory } =
+      await import("../../../storage/storage.js");
+    const { orchestratorStore } =
+      await import("../../../stores/orchestrator.js");
+
+    const el = new ShadowClawStorage() as any;
+    el.db = {};
+    el.updateStorageInfo = jest.fn();
+    el.requestConfirmation = jest.fn().mockResolvedValue(true);
+
+    // 1. handleRequestPersistent error
+    (requestPersistentStorage as jest.Mock<any>).mockRejectedValueOnce(
+      new Error("Persistent error"),
+    );
+    await el.handleRequestPersistent();
+    expect(showError).toHaveBeenCalledWith(
+      expect.stringContaining("Persistent error"),
+      6000,
+    );
+
+    // 2. handleResetSiteConfig error
+    (
+      orchestratorStore.resetSiteConfigSeed as jest.Mock<any>
+    ).mockRejectedValueOnce(new Error("Site config error"));
+    await el.handleResetSiteConfig();
+    expect(showError).toHaveBeenCalledWith(
+      expect.stringContaining("Site config error"),
+      6000,
+    );
+
+    // 3. handleResetStorageDir error
+    (resetStorageDirectory as jest.Mock<any>).mockRejectedValueOnce(
+      new Error("Reset storage error"),
+    );
+    await el.handleResetStorageDir();
+    expect(showError).toHaveBeenCalledWith(
+      expect.stringContaining("Reset storage error"),
+      6000,
+    );
+
+    // 4. onUploadAppendUlidToggle error
+    (setConfig as jest.Mock<any>).mockRejectedValueOnce(
+      new Error("ULID toggle error"),
+    );
+    await el.onUploadAppendUlidToggle(true);
+    expect(showError).toHaveBeenCalledWith(
+      expect.stringContaining("ULID toggle error"),
+      6000,
+    );
+  });
+
+  it("handles requestConfirmation via appShell and fallback warning", async () => {
+    const { showWarning } = await import("../../../ui/toast.js");
+    const el = new ShadowClawStorage();
+
+    // 1. Fallback when shadow-claw element does not exist
+    const res1 = await el.requestConfirmation({
+      title: "Test",
+      message: "Confirm action?",
+    });
+    expect(res1).toBe(false);
+    expect(showWarning).toHaveBeenCalledWith("Confirm action?", 4500);
+
+    // 2. With appShell requestDialog
+    const appShell = document.createElement("shadow-claw") as any;
+    appShell.requestDialog = jest.fn().mockResolvedValue(true);
+    document.body.appendChild(appShell);
+
+    const res2 = await el.requestConfirmation({
+      title: "Test",
+      message: "Confirm action?",
+    });
+    expect(res2).toBe(true);
+    expect(appShell.requestDialog).toHaveBeenCalledWith(
+      expect.objectContaining({ mode: "confirm", title: "Test" }),
+    );
+
+    document.body.removeChild(appShell);
+  });
+
+  it("handles button clicks in template and early returns when db is null", async () => {
+    const el = new ShadowClawStorage();
+    document.body.appendChild(el);
+    await new Promise((r) => setTimeout(r, 50));
+    el.db = {} as any;
+
+    const root = el.shadowRoot!;
+    const reqBtn = root.querySelector('[data-action="request-persistent"]');
+    const changeBtn = root.querySelector('[data-action="change-storage-dir"]');
+    const resetStorageBtn = root.querySelector(
+      '[data-action="reset-storage-dir"]',
+    );
+    const resetConfigBtn = root.querySelector(
+      '[data-action="reset-site-config"]',
+    );
+    const grantBtn = root.querySelector(
+      '[data-action="grant-storage-permission"]',
+    );
+
+    const handleReqSpy = jest
+      .spyOn(el, "handleRequestPersistent")
+      .mockImplementation(async () => {});
+    const handleChangeSpy = jest
+      .spyOn(el, "handleChangeStorageDir")
+      .mockImplementation(async () => {});
+    const handleResetStorageSpy = jest
+      .spyOn(el, "handleResetStorageDir")
+      .mockImplementation(async () => {});
+    const handleResetConfigSpy = jest
+      .spyOn(el, "handleResetSiteConfig")
+      .mockImplementation(async () => {});
+
+    reqBtn?.dispatchEvent(new Event("click"));
+    expect(handleReqSpy).toHaveBeenCalled();
+
+    changeBtn?.dispatchEvent(new Event("click"));
+    expect(handleChangeSpy).toHaveBeenCalled();
+
+    resetStorageBtn?.dispatchEvent(new Event("click"));
+    expect(handleResetStorageSpy).toHaveBeenCalled();
+
+    resetConfigBtn?.dispatchEvent(new Event("click"));
+    expect(handleResetConfigSpy).toHaveBeenCalled();
+
+    grantBtn?.dispatchEvent(new Event("click"));
+
+    // Early returns when db is null
+    el.db = null;
+    await el.handleChangeStorageDir();
+    await el.handleRequestPersistent();
+    await el.handleResetSiteConfig();
+    await el.handleResetStorageDir();
+    await el.onUploadAppendUlidToggle(true);
+    await el.updateStorageInfo();
+
+    document.body.removeChild(el);
+  });
 });

package/src/components/settings/shadow-claw-task-server/shadow-claw-task-server.test.ts

@@ -110,4 +110,66 @@ describe("shadow-claw-task-server", () => {
     );
     expect(mockEnsureAllConnections).toHaveBeenCalled();
   });
+
+  it("handles event listeners for save button and toggle", async () => {
+    const el = new ShadowClawTaskServer();
+    document.body.appendChild(el);
+    await el.connectedCallback();
+
+    const input = el.shadowRoot?.querySelector(
+      '[data-setting="task-server-url-input"]',
+    ) as HTMLInputElement;
+    input.value = "";
+
+    const saveBtn = el.shadowRoot?.querySelector(
+      '[data-action="save-task-server-url"]',
+    );
+    saveBtn?.dispatchEvent(new Event("click"));
+    await new Promise((r) => setTimeout(r, 10));
+
+    expect(mockSetTaskServerUrl).toHaveBeenCalledWith(
+      orchestratorStore.orchestrator,
+      expect.anything(),
+      "/schedule",
+    );
+
+    const toggle = el.shadowRoot?.querySelector(
+      '[data-setting="task-server-enabled-toggle"]',
+    ) as HTMLInputElement;
+    toggle.checked = true;
+    toggle.dispatchEvent(new Event("change"));
+    await new Promise((r) => setTimeout(r, 10));
+    expect(mockSetTaskServerEnabled).toHaveBeenCalled();
+  });
+
+  it("handles errors during save", async () => {
+    const { showError } = (await import("../../../ui/toast.js")) as any;
+    const el = new ShadowClawTaskServer();
+    document.body.appendChild(el);
+    await el.connectedCallback();
+
+    mockSetTaskServerEnabled.mockRejectedValueOnce(
+      new Error("Save enabled fail"),
+    );
+    await el.saveTaskServerEnabled(true);
+    expect(showError).toHaveBeenCalledWith(
+      expect.stringContaining("Save enabled fail"),
+      6000,
+    );
+
+    mockSetTaskServerUrl.mockRejectedValueOnce(new Error("Save url fail"));
+    await el.saveTaskServerUrl();
+    expect(showError).toHaveBeenCalledWith(
+      expect.stringContaining("Save url fail"),
+      6000,
+    );
+  });
+
+  it("handles early returns when orchestrator is missing", async () => {
+    const el = new ShadowClawTaskServer();
+    el.orchestrator = null;
+    await el.saveTaskServerEnabled(true);
+    await el.saveTaskServerUrl();
+    await el.render();
+  });
 });

package/src/components/settings/shadow-claw-webvm/shadow-claw-webvm.test.ts

@@ -222,4 +222,108 @@ describe("shadow-claw-webvm", () => {
 
     document.body.removeChild(el);
   });
+
+  it("handles validation warnings for invalid inputs", async () => {
+    const { showWarning } = await import("../../../ui/toast.js");
+    const orch = createOrchestratorStub();
+    (orchestratorStore as any).orchestrator = orch;
+    (orchestratorStore as any).ready = true;
+
+    const el = new ShadowClawWebvm();
+    document.body.appendChild(el);
+    await new Promise((r) => setTimeout(r, 50));
+    await el.render();
+
+    // 1. Invalid bash timeout
+    const timeoutInput = el.shadowRoot?.querySelector(
+      '[data-setting="vm-bash-timeout-input"]',
+    ) as HTMLInputElement;
+    if (timeoutInput) {
+      Object.defineProperty(timeoutInput, "value", {
+        value: "invalid",
+        configurable: true,
+      });
+    }
+    await el.saveVMBashTimeout();
+    expect(showWarning).toHaveBeenCalledWith(
+      "Please enter a valid timeout in seconds",
+      3000,
+    );
+
+    // 2. Invalid boot host
+    const bootHostInput = el.shadowRoot?.querySelector(
+      '[data-setting="vm-boot-host-input"]',
+    ) as HTMLInputElement;
+    if (bootHostInput) bootHostInput.value = "ftp://invalid-protocol";
+    await el.saveVMBootHost();
+    expect(showWarning).toHaveBeenCalledWith(
+      "Please enter a valid HTTP(S) boot host URL",
+      3500,
+    );
+
+    // 3. Invalid relay URL
+    const relayInput = el.shadowRoot?.querySelector(
+      '[data-setting="vm-network-relay-url-input"]',
+    ) as HTMLInputElement;
+    if (relayInput) relayInput.value = "ftp://invalid-relay";
+    await el.saveVMNetworkRelayURL();
+    expect(showWarning).toHaveBeenCalledWith(
+      "Please enter a valid ws:// or wss:// relay URL",
+      3500,
+    );
+
+    document.body.removeChild(el);
+  });
+
+  it("handles errors during saving", async () => {
+    const { showError } = await import("../../../ui/toast.js");
+    const orch = createOrchestratorStub();
+    (orchestratorStore as any).orchestrator = orch;
+    (orchestratorStore as any).ready = true;
+
+    const el = new ShadowClawWebvm();
+    document.body.appendChild(el);
+    await new Promise((r) => setTimeout(r, 50));
+    await el.render();
+
+    mockSetVMBashTimeout.mockRejectedValueOnce(
+      new Error("Timeout save failed"),
+    );
+    const timeoutInput = el.shadowRoot?.querySelector(
+      '[data-setting="vm-bash-timeout-input"]',
+    ) as HTMLInputElement;
+    if (timeoutInput) timeoutInput.value = "30";
+    await el.saveVMBashTimeout();
+    expect(showError).toHaveBeenCalledWith(
+      expect.stringContaining("Timeout save failed"),
+      6000,
+    );
+
+    mockSetVMBootHost.mockRejectedValueOnce(new Error("Boot host save failed"));
+    await el.saveVMBootHost();
+    expect(showError).toHaveBeenCalledWith(
+      expect.stringContaining("Boot host save failed"),
+      6000,
+    );
+
+    mockSetVMNetworkRelayURL.mockRejectedValueOnce(
+      new Error("Relay URL save failed"),
+    );
+    await el.saveVMNetworkRelayURL();
+    expect(showError).toHaveBeenCalledWith(
+      expect.stringContaining("Relay URL save failed"),
+      6000,
+    );
+
+    document.body.removeChild(el);
+  });
+
+  it("handles missing orchestrator early returns", async () => {
+    const el = new ShadowClawWebvm();
+    el.orchestrator = null;
+    await el.saveVMBashTimeout();
+    await el.saveVMBootHost();
+    await el.saveVMBootMode();
+    await el.saveVMNetworkRelayURL();
+  });
 });

package/src/components/shadow-claw/shadow-claw.test.ts

@@ -696,4 +696,116 @@ describe("shadow-claw", () => {
       globalThis.matchMedia = originalMatchMedia;
     }
   });
+
+  it("handles disconnectedCallback cleanups", async () => {
+    const component = new ShadowClaw();
+    component.orchestrator = createOrchestratorStub();
+    document.body.appendChild(component);
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    const vmStatusCleanup = jest.fn();
+    const appLifecycleCleanup = jest.fn();
+    const cancelAnimSpy = jest.spyOn(globalThis, "cancelAnimationFrame");
+
+    component.vmStatusCleanup = vmStatusCleanup;
+    component.appLifecycleCleanup = appLifecycleCleanup;
+    component.terminalPlacementFrame = 42;
+    component.popstateListener = jest.fn() as any;
+    component.fallbackClickListenerAttached = true;
+    component.navigationListenerAttached = true;
+
+    component.disconnectedCallback();
+
+    expect(vmStatusCleanup).toHaveBeenCalled();
+    expect(appLifecycleCleanup).toHaveBeenCalled();
+    expect(cancelAnimSpy).toHaveBeenCalledWith(42);
+    expect(component.vmStatusCleanup).toBeNull();
+    expect(component.appLifecycleCleanup).toBeNull();
+    expect(component.terminalPlacementFrame).toBeNull();
+    expect(component.popstateListener).toBeNull();
+    expect(component.fallbackClickListenerAttached).toBe(false);
+    expect(component.navigationListenerAttached).toBe(false);
+
+    document.body.removeChild(component);
+  });
+
+  it("handles navigation handlers, shadowClawNav, and requestDialog", async () => {
+    const component = new ShadowClaw();
+    component.orchestrator = createOrchestratorStub();
+    document.body.appendChild(component);
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    // fallbackClickListener with no targetPath
+    const mockClickEvent = new MouseEvent("click");
+    component.fallbackClickListener(mockClickEvent);
+
+    // handleNavigationApiNavigate
+    component.handleNavigationApiNavigate(new Event("navigate"));
+
+    // shadowClawNav
+    component.shadowClawNav(
+      new CustomEvent("shadow-claw-navigate", { detail: { page: "pages" } }),
+    );
+
+    // requestDialog
+    const promise = component.requestDialog({
+      title: "Test Dialog",
+      message: "Please confirm",
+    });
+    const appDialog = component.shadowRoot?.querySelector(
+      ".app-dialog",
+    ) as HTMLDialogElement;
+    if (appDialog) {
+      appDialog.returnValue = "confirm";
+      appDialog.dispatchEvent(new Event("close"));
+    }
+    const dialogResult = await promise;
+    expect(dialogResult).toBe(true);
+
+    document.body.removeChild(component);
+  });
+
+  it("handles orchestrator vm-status error and tools events", async () => {
+    const stub = createOrchestratorStub();
+    const component = new ShadowClaw();
+    component.orchestrator = stub;
+    document.body.appendChild(component);
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    // Emit vm-status with error when terminalVisible is true
+    component.terminalVisible = true;
+    const vmStatusCallbacks = stub.events.on.mock.calls.filter(
+      ([event]) => event === "vm-status",
+    );
+    for (const [, cb] of vmStatusCallbacks) {
+      cb({ ready: false, booting: false, error: "VM Crash", mode: "disabled" });
+    }
+    expect(component.terminalVisible).toBe(false);
+
+    // Emit provider-help
+    const providerHelpCallbacks = stub.events.on.mock.calls.filter(
+      ([event]) => event === "provider-help",
+    );
+    for (const [, cb] of providerHelpCallbacks) {
+      cb({ providerId: "test-prov", reason: "quota", helpType: "rate_limit" });
+    }
+
+    // Emit room-invite
+    const roomInviteCallbacks = stub.events.on.mock.calls.filter(
+      ([event]) => event === "room-invite",
+    );
+    for (const [, cb] of roomInviteCallbacks) {
+      cb({ roomId: "r1", hostPeerId: "p1" });
+    }
+
+    // Emit ask-user
+    const askUserCallbacks = stub.events.on.mock.calls.filter(
+      ([event]) => event === "ask-user",
+    );
+    for (const [, cb] of askUserCallbacks) {
+      cb({ id: "q1", groupId: "g1", question: "Continue?" });
+    }
+
+    document.body.removeChild(component);
+  });
 });