shadow-claw 1.23.3 → 1.24.0

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

@@ -98,6 +98,10 @@ const mockSetMaxTokens = jest.fn(async () => {});
 const mockSetRateLimitCallsPerMinute = jest.fn(async () => {});
 const mockSetRateLimitAutoAdapt = jest.fn(async () => {});
 const mockSetReasoningEffort = jest.fn(async () => {});
+const mockSetMaxIterations = jest.fn(async () => {});
+const mockSetLlamafileSettings = jest.fn(async () => {});
+const mockSetContextCompressionEnabled = jest.fn(async () => {});
+const mockSetStreamingEnabled = jest.fn(async () => {});
 
 jest.unstable_mockModule(
   "../../../core/orchestrator/utils/operations/provider.js",
@@ -128,7 +132,7 @@ jest.unstable_mockModule(
     getProviderRuntimeHeaders: jest.fn().mockReturnValue({}),
     setProvider: mockSetProvider,
     setBedrockSettings: mockSetBedrockSettings,
-    setLlamafileSettings: jest.fn(async () => {}),
+    setLlamafileSettings: mockSetLlamafileSettings,
     setMeshLlmSettings: jest.fn(async () => {}),
     setModel: jest.fn(async () => {}),
     setAssistantName: jest.fn(async () => {}),
@@ -151,11 +155,11 @@ jest.unstable_mockModule(
     setGitProxyUrl: jest.fn(async () => {}),
     setProxyUrl: jest.fn(async () => {}),
     setVmInternetAccess: jest.fn(async () => {}),
-    setStreamingEnabled: jest.fn(async () => {}),
+    setStreamingEnabled: mockSetStreamingEnabled,
     setUseProxy: jest.fn(async () => {}),
     setVMBashFullInternetAccess: jest.fn(async () => {}),
-    setContextCompressionEnabled: jest.fn(async () => {}),
-    setMaxIterations: jest.fn(async () => {}),
+    setContextCompressionEnabled: mockSetContextCompressionEnabled,
+    setMaxIterations: mockSetMaxIterations,
   }),
 );
 
@@ -196,6 +200,7 @@ const { setConfig } = await import("../../../db/setConfig.js");
 
 function createOrchestratorStub(overrides = {}) {
   const base = {
+    setApiKey: jest.fn<any>().mockResolvedValue(undefined),
     setProvider: jest.fn<any>().mockResolvedValue(undefined),
     setModel: jest.fn<any>().mockResolvedValue(undefined),
     setAssistantName: jest.fn<any>().mockResolvedValue(undefined),
@@ -819,4 +824,302 @@ describe("shadow-claw-llm", () => {
 
     document.body.removeChild(el);
   });
+
+  it("saves subagent max parallel, workspace mode, and reasoning effort", async () => {
+    const el = new ShadowClawLlm() as any;
+    el.db = {};
+    el.orchestrator = createOrchestratorStub();
+    document.body.appendChild(el);
+    await el.render();
+
+    const maxParallelInput = el.shadowRoot?.querySelector(
+      '[data-setting="subagent-max-parallel-input"]',
+    ) as HTMLInputElement | null;
+    if (maxParallelInput) {
+      maxParallelInput.value = "8";
+    }
+    await el.saveSubagentMaxParallel();
+    expect(setConfig).toHaveBeenCalledWith(
+      expect.anything(),
+      "subagent_max_parallel",
+      "8",
+    );
+
+    const wsModeSelect = el.shadowRoot?.querySelector(
+      '[data-setting="subagent-workspace-mode-select"]',
+    ) as HTMLSelectElement | null;
+    if (wsModeSelect) {
+      wsModeSelect.value = "isolated";
+    }
+    await el.saveSubagentWorkspaceMode();
+    expect(setConfig).toHaveBeenCalledWith(
+      expect.anything(),
+      "subagent_workspace_mode",
+      "isolated",
+    );
+
+    const reasoningSelect = el.shadowRoot?.querySelector(
+      '[data-setting="reasoning-effort-select"]',
+    ) as HTMLSelectElement | null;
+    if (reasoningSelect) {
+      reasoningSelect.value = "high";
+    }
+    await el.saveReasoningEffort();
+    expect(mockSetReasoningEffort).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      "high",
+    );
+
+    document.body.removeChild(el);
+  });
+
+  it("saves max iterations and context compression settings", async () => {
+    const el = new ShadowClawLlm() as any;
+    el.db = {};
+    const orch = createOrchestratorStub();
+    (orchestratorStore as any).orchestrator = orch;
+    document.body.appendChild(el);
+    await el.render();
+
+    const maxIterInput = el.shadowRoot?.querySelector(
+      '[data-setting="max-iterations-input"]',
+    ) as HTMLInputElement | null;
+    if (maxIterInput) {
+      maxIterInput.value = "100";
+    }
+    await el.saveMaxIterations();
+    expect(mockSetMaxIterations).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      100,
+    );
+
+    await el.onContextCompressionToggle(true);
+    expect(mockSetContextCompressionEnabled).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      true,
+    );
+
+    document.body.removeChild(el);
+  });
+
+  it("saves rate limit settings and applies recommended max tokens", async () => {
+    const el = new ShadowClawLlm() as any;
+    el.db = {};
+    const orch = createOrchestratorStub();
+    (orchestratorStore as any).orchestrator = orch;
+    document.body.appendChild(el);
+    await el.render();
+
+    const rateInput = el.shadowRoot?.querySelector(
+      '[data-setting="rate-limit-calls-per-minute-input"]',
+    ) as HTMLInputElement | null;
+    const adaptInput = el.shadowRoot?.querySelector(
+      '[data-setting="rate-limit-auto-adapt-toggle"]',
+    ) as HTMLInputElement | null;
+
+    if (rateInput) rateInput.value = "30";
+    if (adaptInput) adaptInput.checked = true;
+
+    await el.saveRateLimitSettings();
+    expect(mockSetRateLimitCallsPerMinute).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      30,
+    );
+    expect(mockSetRateLimitAutoAdapt).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      true,
+    );
+
+    const maxTokensInput = el.shadowRoot?.querySelector(
+      '[data-setting="max-tokens-input"]',
+    ) as HTMLInputElement | null;
+    await el.applyRecommendedMaxTokens();
+    expect(maxTokensInput?.value).toBeTruthy();
+
+    document.body.removeChild(el);
+  });
+
+  it("saves bedrock and llamafile settings", async () => {
+    const el = new ShadowClawLlm() as any;
+    el.db = {};
+    const orch = createOrchestratorStub();
+    (orchestratorStore as any).orchestrator = orch;
+    document.body.appendChild(el);
+    await el.render();
+
+    const regionInput = el.shadowRoot?.querySelector(
+      '[data-setting="bedrock-region-input"]',
+    ) as HTMLInputElement | null;
+    const profileInput = el.shadowRoot?.querySelector(
+      '[data-setting="bedrock-profile-input"]',
+    ) as HTMLInputElement | null;
+
+    if (regionInput) regionInput.value = "us-west-2";
+    if (profileInput) profileInput.value = "default";
+
+    await el.saveBedrockSettings();
+    expect(mockSetBedrockSettings).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      expect.objectContaining({ region: "us-west-2", profile: "default" }),
+    );
+
+    const modeInput = el.shadowRoot?.querySelector(
+      '[data-setting="llamafile-mode-select"]',
+    ) as HTMLSelectElement | null;
+    const hostInput = el.shadowRoot?.querySelector(
+      '[data-setting="llamafile-host-input"]',
+    ) as HTMLInputElement | null;
+    const portInput = el.shadowRoot?.querySelector(
+      '[data-setting="llamafile-port-input"]',
+    ) as HTMLInputElement | null;
+    const offlineInput = el.shadowRoot?.querySelector(
+      '[data-setting="llamafile-offline-toggle"]',
+    ) as HTMLInputElement | null;
+
+    if (modeInput) modeInput.value = "server";
+    if (hostInput) hostInput.value = "http://127.0.0.1";
+    if (portInput) portInput.value = "8080";
+    if (offlineInput) offlineInput.checked = true;
+
+    await el.saveLlamafileSettings();
+    expect(mockSetLlamafileSettings).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      expect.objectContaining({
+        mode: "server",
+        host: "http://127.0.0.1",
+        port: 8080,
+        offline: true,
+      }),
+    );
+
+    document.body.removeChild(el);
+  });
+
+  it("handles saveReasoningEffort, saveSubagentMaxParallel, and onStreamingToggle", async () => {
+    const orch = createOrchestratorStub();
+    (orchestratorStore as any).orchestrator = orch;
+
+    const el = new ShadowClawLlm() as any;
+    document.body.appendChild(el);
+    await el.render();
+
+    // 1. saveReasoningEffort
+    const select = el.shadowRoot?.querySelector(
+      '[data-setting="reasoning-effort-select"]',
+    ) as HTMLSelectElement | null;
+    if (select) select.value = "high";
+    await el.saveReasoningEffort();
+    expect(mockSetReasoningEffort).toHaveBeenCalledWith(
+      orch,
+      expect.anything(),
+      "high",
+    );
+
+    // 2. saveSubagentMaxParallel
+    const parallelInput = el.shadowRoot?.querySelector(
+      '[data-setting="subagent-max-parallel-input"]',
+    ) as HTMLInputElement | null;
+    if (parallelInput) parallelInput.value = "5";
+    await el.saveSubagentMaxParallel();
+    expect(setConfig).toHaveBeenCalledWith(
+      expect.anything(),
+      "subagent_max_parallel",
+      "5",
+    );
+
+    // 3. onStreamingToggle
+    await el.onStreamingToggle(true);
+    expect(mockSetStreamingEnabled).toHaveBeenCalled();
+
+    // 4. saveMaxIterations
+    const maxIterInput = el.shadowRoot?.querySelector(
+      '[data-setting="max-iterations-input"]',
+    ) as HTMLInputElement | null;
+    if (maxIterInput) maxIterInput.value = "42";
+    await el.saveMaxIterations();
+    expect(mockSetMaxIterations).toHaveBeenCalledWith(
+      orch,
+      expect.anything(),
+      42,
+    );
+
+    // 5. saveMaxTokens
+    const maxTokensInput = el.shadowRoot?.querySelector(
+      '[data-setting="max-tokens-input"]',
+    ) as HTMLInputElement | null;
+    if (maxTokensInput) maxTokensInput.value = "2048";
+    await el.saveMaxTokens();
+    expect(mockSetMaxTokens).toHaveBeenCalledWith(
+      orch,
+      expect.anything(),
+      2048,
+    );
+
+    // 6. saveSubagentWorkspaceMode
+    const wsModeSelect = el.shadowRoot?.querySelector(
+      '[data-setting="subagent-workspace-mode-select"]',
+    ) as HTMLSelectElement | null;
+    if (wsModeSelect) wsModeSelect.value = "isolated";
+    await el.saveSubagentWorkspaceMode();
+    expect(setConfig).toHaveBeenCalledWith(
+      expect.anything(),
+      "subagent_workspace_mode",
+      "isolated",
+    );
+
+    // 7. saveApiKey
+    const keyInput = el.shadowRoot?.querySelector(
+      '[data-setting="api-key-input"]',
+    ) as HTMLInputElement | null;
+    const providerSelect = el.shadowRoot?.querySelector(
+      '[data-setting="provider-select"]',
+    ) as HTMLSelectElement | null;
+    if (keyInput) keyInput.value = "sk-test-key-123";
+    if (providerSelect) providerSelect.value = "provider-a";
+    await el.saveApiKey();
+    expect(orch.setApiKey).toHaveBeenCalledWith(
+      expect.anything(),
+      "sk-test-key-123",
+    );
+
+    // 8. saveBuiltinAiSettings
+    await el.saveBuiltinAiSettings();
+    expect(setConfig).toHaveBeenCalled();
+
+    // 9. saveTransformersJsSettings
+    await el.saveTransformersJsSettings();
+    expect(setConfig).toHaveBeenCalled();
+
+    // 10. showLlamafileHelpDialog
+    el.requestAppDialog = jest.fn<any>().mockResolvedValue(undefined);
+    await el.showLlamafileHelpDialog("connection refused");
+    expect(el.requestAppDialog).toHaveBeenCalled();
+
+    // 11. saveMeshLlmSettings
+    const hostInput = el.shadowRoot?.querySelector(
+      '[data-setting="mesh-llm-host-input"]',
+    ) as HTMLInputElement | null;
+    if (hostInput) hostInput.value = "http://localhost:11434";
+    await el.saveMeshLlmSettings();
+
+    // 12. updateModelSelector dynamic models
+    (global.fetch as any) = jest.fn<any>().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        models: [{ id: "dynamic-model-1", name: "Dynamic Model 1" }],
+      }),
+    });
+    orch.getProvider.mockReturnValue("bedrock_proxy");
+    el.updateModelSelector();
+
+    document.body.removeChild(el);
+  });
 });

package/src/components/settings/shadow-claw-llm/shadow-claw-llm.ts

@@ -318,16 +318,16 @@ export class ShadowClawLlm extends ShadowClawElement {
     }
 
     const modeInput = root.querySelector(
-      '[data-setting="llamafile-mode"]',
+      '[data-setting="llamafile-mode"], [data-setting="llamafile-mode-select"]',
     ) as HTMLSelectElement | null;
     const hostInput = root.querySelector(
-      '[data-setting="llamafile-host"]',
+      '[data-setting="llamafile-host"], [data-setting="llamafile-host-input"]',
     ) as HTMLInputElement | null;
     const portInput = root.querySelector(
-      '[data-setting="llamafile-port"]',
+      '[data-setting="llamafile-port"], [data-setting="llamafile-port-input"]',
     ) as HTMLInputElement | null;
     const offlineInput = root.querySelector(
-      '[data-setting="llamafile-offline"]',
+      '[data-setting="llamafile-offline"], [data-setting="llamafile-offline-toggle"]',
     ) as HTMLInputElement | null;
 
     if (modeInput) {
@@ -1694,16 +1694,16 @@ export class ShadowClawLlm extends ShadowClawElement {
     }
 
     const modeInput = root.querySelector(
-      '[data-setting="llamafile-mode"]',
+      '[data-setting="llamafile-mode"], [data-setting="llamafile-mode-select"]',
     ) as HTMLSelectElement | null;
     const hostInput = root.querySelector(
-      '[data-setting="llamafile-host"]',
+      '[data-setting="llamafile-host"], [data-setting="llamafile-host-input"]',
     ) as HTMLInputElement | null;
     const portInput = root.querySelector(
-      '[data-setting="llamafile-port"]',
+      '[data-setting="llamafile-port"], [data-setting="llamafile-port-input"]',
     ) as HTMLInputElement | null;
     const offlineInput = root.querySelector(
-      '[data-setting="llamafile-offline"]',
+      '[data-setting="llamafile-offline"], [data-setting="llamafile-offline-toggle"]',
     ) as HTMLInputElement | null;
 
     if (!modeInput || !hostInput || !portInput || !offlineInput) {

package/src/components/settings/shadow-claw-mcp-remote/shadow-claw-mcp-remote.test.ts

@@ -291,4 +291,35 @@ describe("shadow-claw-mcp-remote", () => {
 
     document.body.removeChild(el);
   });
+
+  it("handles deleteConnection, reconnectOAuth, and testConnection", async () => {
+    mockDeleteConnection.mockResolvedValue(true);
+    mockReconnectMcpOAuth.mockResolvedValue({ success: true });
+    mockTestConnection.mockResolvedValue({
+      success: true,
+      toolCount: 2,
+      toolNames: ["search", "fetch"],
+      steps: [{ step: "Ping", status: "ok" }],
+    });
+
+    const el = new ShadowClawMcpRemote() as any;
+    document.body.appendChild(el);
+    await el.connectedCallback();
+    el.db = {} as any;
+    el.connections = [{ id: "conn-1", label: "My Connection" }];
+
+    // 1. Delete connection
+    await el.deleteConnection("conn-1");
+    expect(mockDeleteConnection).toHaveBeenCalledWith(el.db, "conn-1");
+
+    // 2. Reconnect OAuth
+    await el.reconnectOAuth("conn-1");
+    expect(mockReconnectMcpOAuth).toHaveBeenCalledWith(el.db, "conn-1");
+
+    // 3. Test connection
+    await el.testConnection("conn-1");
+    expect(mockTestConnection).toHaveBeenCalledWith(el.db, "conn-1");
+
+    document.body.removeChild(el);
+  });
 });

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

@@ -198,4 +198,190 @@ describe("shadow-claw-peerjs", () => {
       "http://localhost/?peer=test",
     );
   });
+
+  it("should show room QR code", async () => {
+    const el = new ShadowClawPeerJs() as any;
+    document.body.appendChild(el);
+    await el.connectedCallback();
+
+    const room = { roomId: "room-1", name: "Room One" };
+    await el.showRoomQr(room);
+
+    const group = el.shadowRoot?.querySelector(
+      '[data-info="room-qr-group"]',
+    ) as HTMLElement;
+    const label = el.shadowRoot?.querySelector('[data-info="room-qr-label"]');
+    expect(group.hidden).toBe(false);
+    expect(label?.textContent).toContain("Room One");
+
+    document.body.removeChild(el);
+  });
+
+  it("should add and remove trusted peer rows", async () => {
+    const el = new ShadowClawPeerJs() as any;
+    document.body.appendChild(el);
+    await el.connectedCallback();
+
+    const initialRows =
+      el.shadowRoot?.querySelectorAll(".peerjs-trusted-peer-row").length || 0;
+    el._appendTrustedPeerRow("peer-xyz", "Peer XYZ");
+
+    const newRows = el.shadowRoot?.querySelectorAll(".peerjs-trusted-peer-row");
+    expect(newRows.length).toBe(initialRows + 1);
+
+    // Remove row
+    const removeBtn = newRows[newRows.length - 1].querySelector(
+      ".save-btn--danger",
+    ) as HTMLButtonElement;
+    removeBtn?.click();
+
+    expect(
+      el.shadowRoot?.querySelectorAll(".peerjs-trusted-peer-row").length,
+    ).toBe(initialRows);
+
+    document.body.removeChild(el);
+  });
+
+  it("should copy room URL and generate trusted peer options with aliases", async () => {
+    const el = new ShadowClawPeerJs() as any;
+    document.body.appendChild(el);
+    await el.connectedCallback();
+
+    const mockClipboard = {
+      writeText: jest.fn<any>().mockResolvedValue(undefined),
+    };
+    Object.assign(navigator, { clipboard: mockClipboard });
+
+    const options = el._trustedPeerOptions();
+    expect(options.length).toBeGreaterThan(0);
+
+    document.body.removeChild(el);
+  });
+
+  it("handles copyPeerId and copyPeerUrl", async () => {
+    const el = new ShadowClawPeerJs() as any;
+    document.body.appendChild(el);
+    await el.connectedCallback();
+
+    const mockClipboard = {
+      writeText: jest.fn<any>().mockResolvedValue(undefined),
+    };
+    Object.assign(navigator, { clipboard: mockClipboard });
+
+    // 1. Copy Peer ID
+    const peerIdInput = el.shadowRoot?.querySelector(
+      '[data-setting="peerjs-my-peer-id-input"]',
+    ) as HTMLInputElement;
+    if (peerIdInput) peerIdInput.value = "my-test-peer";
+    await el.copyPeerId();
+    expect(mockClipboard.writeText).toHaveBeenCalledWith("my-test-peer");
+
+    // 2. Copy Peer URL
+    el._currentPeerUrl = "http://localhost/?peer=my-test-peer";
+    await el.copyPeerUrl();
+    expect(mockClipboard.writeText).toHaveBeenCalledWith(
+      "http://localhost/?peer=my-test-peer",
+    );
+
+    document.body.removeChild(el);
+  });
+
+  it("handles savePeerJsConfig", async () => {
+    const el = new ShadowClawPeerJs() as any;
+    document.body.appendChild(el);
+    await el.connectedCallback();
+
+    const hostInput = el.shadowRoot?.querySelector(
+      '[data-setting="peerjs-server-host-input"]',
+    ) as HTMLInputElement;
+    const portInput = el.shadowRoot?.querySelector(
+      '[data-setting="peerjs-server-port-input"]',
+    ) as HTMLInputElement;
+
+    if (hostInput) hostInput.value = "peer.example.com";
+    if (portInput) portInput.value = "9001";
+
+    await el.savePeerJsConfig();
+    expect(mockConfigurePeerJs).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      "test-peer-id",
+      expect.any(Array),
+      "peer.example.com",
+      9001,
+      "/myapp",
+      false,
+    );
+
+    document.body.removeChild(el);
+  });
+
+  it("handles copyRoomUrl, showRoomQr, updateConnectionStatus, and updateQrCode", async () => {
+    const el = new ShadowClawPeerJs() as any;
+    document.body.appendChild(el);
+    await el.connectedCallback();
+
+    const mockClipboard = {
+      writeText: jest.fn<any>().mockResolvedValue(undefined),
+    };
+    Object.assign(navigator, { clipboard: mockClipboard });
+
+    // 1. copyRoomUrl
+    el._currentRoomUrl = "http://localhost/?room=test-room";
+    await el.copyRoomUrl();
+    expect(mockClipboard.writeText).toHaveBeenCalledWith(
+      "http://localhost/?room=test-room",
+    );
+
+    // 2. showRoomQr
+    const room = {
+      roomId: "room-1",
+      name: "Test Room",
+      members: [],
+      createdAt: 0,
+      updatedAt: 0,
+    };
+    await el.showRoomQr(room);
+    expect(el._currentRoomUrl).toContain("room-1");
+
+    // 4. renderRooms
+    const { listRooms } =
+      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" },
+          { peerId: "peer-remote-1", alias: "Agent Remote", kind: "agent" },
+        ],
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      },
+      {
+        roomId: "room-guest-2",
+        name: "Guest Room",
+        hostPeerId: "peer-other",
+        members: [{ peerId: "peer-other", alias: "Other", kind: "human" }],
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      },
+    ];
+    (listRooms as jest.Mock<any>).mockReturnValue(testRooms);
+
+    let roomsContainer = el.shadowRoot?.querySelector(
+      '[data-info="rooms-list"]',
+    );
+    if (!roomsContainer) {
+      roomsContainer = document.createElement("div");
+      roomsContainer.setAttribute("data-info", "rooms-list");
+      el.shadowRoot?.appendChild(roomsContainer);
+    }
+
+    el.renderRooms();
+    expect(roomsContainer.querySelectorAll(".peerjs-room-card").length).toBe(2);
+
+    document.body.removeChild(el);
+  });
 });

package/src/components/settings/shadow-claw-storage/shadow-claw-storage.html

@@ -54,5 +54,22 @@
         files directly accessible on your disk.
       </div>
     </div>
+
+    <div class="form-group">
+      <div class="form-toggle">
+        <input
+          data-setting="files-upload-append-ulid-toggle"
+          id="files-upload-append-ulid-toggle"
+          type="checkbox"
+        />
+        <label class="form-label" for="files-upload-append-ulid-toggle">
+          Append unique ID (ULID) to uploaded file names
+        </label>
+      </div>
+      <div class="form-helper">
+        When enabled, uploads automatically prefix file names with a ULID (e.g.
+        01J...-filename.ext). Default: disabled.
+      </div>
+    </div>
   </div>
 </template>