shadow-claw 1.23.3 → 1.24.0

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

@@ -382,4 +382,76 @@ describe("shadow-claw-git", () => {
 
     document.body.removeChild(el);
   });
+
+  it("handles setDefaultAccount and deleteAccount", async () => {
+    const el = new ShadowClawGit();
+    document.body.appendChild(el);
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    await el.render();
+
+    el.accounts = [
+      {
+        id: "acc-1",
+        label: "Account 1",
+        hostPattern: "github.com",
+        authMode: "token",
+      } as any,
+      {
+        id: "acc-2",
+        label: "Account 2",
+        hostPattern: "gitlab.com",
+        authMode: "token",
+      } as any,
+    ];
+    el.defaultAccountId = "acc-1";
+
+    await el.setDefaultAccount("acc-2");
+    expect(el.defaultAccountId).toBe("acc-2");
+
+    await el.deleteAccount("acc-1");
+    expect(el.accounts.find((a) => a.id === "acc-1")).toBeUndefined();
+    expect(el.defaultAccountId).toBe("acc-2");
+
+    document.body.removeChild(el);
+  });
+
+  it("handles saveGitSettings with custom proxy and author info", async () => {
+    const { setConfig } = await import("../../../db/setConfig.js");
+    const el = new ShadowClawGit();
+    document.body.appendChild(el);
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    await el.render();
+    el.db = {} as any;
+
+    const customRadio = el.shadowRoot?.querySelector(
+      '[data-setting="git-proxy-custom"]',
+    ) as HTMLInputElement;
+    if (customRadio) customRadio.checked = true;
+
+    const authorNameInput = el.shadowRoot?.querySelector(
+      '[data-setting="git-author-name-input"]',
+    ) as HTMLInputElement;
+    if (authorNameInput) authorNameInput.value = "Custom Author";
+
+    const authorEmailInput = el.shadowRoot?.querySelector(
+      '[data-setting="git-author-email-input"]',
+    ) as HTMLInputElement;
+    if (authorEmailInput) authorEmailInput.value = "author@example.com";
+
+    await el.saveGitSettings();
+
+    expect(setConfig).toHaveBeenCalledWith(el.db, "git_cors_proxy", "custom");
+    expect(setConfig).toHaveBeenCalledWith(
+      el.db,
+      "git_author_name",
+      "Custom Author",
+    );
+    expect(setConfig).toHaveBeenCalledWith(
+      el.db,
+      "git_author_email",
+      "author@example.com",
+    );
+
+    document.body.removeChild(el);
+  });
 });

package/src/components/settings/shadow-claw-integrations/connection-test-auth.test.ts

@@ -1,55 +1,45 @@
-import { describe, expect, it } from "@jest/globals";
-
 import { resolveConnectionTestAuth } from "./connection-test-auth.js";
 
 describe("resolveConnectionTestAuth", () => {
-  it("uses pending oauth token when provided", () => {
+  it("resolves oauth authType with trimmed access token", () => {
     const result = resolveConnectionTestAuth({
       authMode: "oauth",
-      pendingOauthAccessToken: "oauth-token",
+      pendingOauthAccessToken: "  my-access-token  ",
+      passwordInput: "",
     });
-
     expect(result).toEqual({
       authType: "oauth",
-      accessToken: "oauth-token",
+      accessToken: "my-access-token",
     });
   });
 
-  it("requires a fresh oauth token and does not reuse stored encrypted credentials", () => {
-    const result = resolveConnectionTestAuth({
+  it("returns error when oauth access token is missing or empty", () => {
+    const result: any = resolveConnectionTestAuth({
       authMode: "oauth",
-      pendingOauthAccessToken: "",
-      hasStoredOauthCredential: true,
-    });
-
-    expect(result).toEqual({
-      error:
-        "OAuth access token is missing. Click Connect OAuth first (or save and reconnect).",
+      pendingOauthAccessToken: "   ",
+      passwordInput: "",
     });
+    expect(result.error).toContain("OAuth access token is missing");
   });
 
-  it("uses entered password for basic auth", () => {
+  it("resolves basic_userpass authType with trimmed password", () => {
     const result = resolveConnectionTestAuth({
-      authMode: "basic",
-      passwordInput: "app-password",
+      authMode: "password",
+      pendingOauthAccessToken: "",
+      passwordInput: "  secret-password  ",
     });
-
     expect(result).toEqual({
       authType: "basic_userpass",
-      password: "app-password",
+      password: "secret-password",
     });
   });
 
-  it("requires explicit password entry and does not decrypt stored secret", () => {
-    const result = resolveConnectionTestAuth({
-      authMode: "basic",
-      passwordInput: "",
-      hasStoredPasswordCredential: true,
-    });
-
-    expect(result).toEqual({
-      error:
-        "Password/app password is missing. Enter it to test this connection.",
+  it("returns error when password is missing or empty", () => {
+    const result: any = resolveConnectionTestAuth({
+      authMode: "password",
+      pendingOauthAccessToken: "",
+      passwordInput: "   ",
     });
+    expect(result.error).toContain("Password/app password is missing");
   });
 });

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

@@ -384,4 +384,120 @@ describe("shadow-claw-integrations", () => {
 
     document.body.removeChild(el);
   });
+
+  it("handles testConnectionFromForm with success and error responses", async () => {
+    const el = new ShadowClawIntegrations();
+    document.body.appendChild(el);
+    await el.connectedCallback();
+
+    el.manifests = [
+      {
+        id: "imap",
+        name: "IMAP",
+        configurableFields: ["host", "port", "mailboxPath"],
+        description: "",
+      } as any,
+    ];
+    (getEmailPluginManifest as jest.Mock).mockReturnValue(el.manifests[0]);
+    el.showForm(null);
+
+    const slot = el.shadowRoot?.querySelector(
+      '[data-region="connection-form"]',
+    ) as HTMLElement;
+
+    const userInput = slot.querySelector("#int-username") as HTMLInputElement;
+    if (userInput) userInput.value = "user@test.com";
+
+    const hostInput = slot.querySelector("#cfg-host") as HTMLInputElement;
+    if (hostInput) hostInput.value = "imap.test.com";
+
+    const passInput = slot.querySelector("#int-password") as HTMLInputElement;
+    if (passInput) passInput.value = "secret-pass";
+
+    const { resolveConnectionTestAuth } =
+      await import("./connection-test-auth.js");
+    (resolveConnectionTestAuth as jest.Mock<any>).mockReturnValue({
+      authType: "basic_userpass",
+      password: "secret-pass",
+    });
+
+    // Mock fetch for /integrations/email/read success
+    (global.fetch as any) = (jest.fn() as any).mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: async () => ({ count: 5 }),
+    });
+
+    await el.testConnectionFromForm(slot);
+    expect(global.fetch).toHaveBeenCalledWith(
+      "/integrations/email/read",
+      expect.objectContaining({ method: "POST" }),
+    );
+
+    // Mock fetch for failure
+    (global.fetch as any) = (jest.fn() as any).mockResolvedValueOnce({
+      ok: false,
+      status: 401,
+      statusText: "Unauthorized",
+      json: async () => ({ error: "Auth failed" }),
+    });
+
+    await el.testConnectionFromForm(slot);
+
+    // Toggle connection test
+    el.connections = [
+      {
+        id: "conn-1",
+        label: "My IMAP",
+        pluginId: "imap",
+        enabled: true,
+        config: {},
+        credentialRef: null,
+        createdAt: 0,
+        updatedAt: 0,
+      } as any,
+    ];
+    const { upsertEmailConnection } =
+      await import("../../../subsystems/email/connections.js");
+    await el.toggleConnection("conn-1");
+    expect(upsertEmailConnection).toHaveBeenCalledWith(
+      el.db,
+      expect.objectContaining({
+        id: "conn-1",
+        enabled: false,
+      }),
+    );
+
+    // OAuth connect from form tests
+    const oauthSlot = document.createElement("div");
+    oauthSlot.innerHTML = `
+      <select id="int-oauth-provider"><option value="google">Google</option></select>
+      <input id="int-oauth-client-id" value="client-id-123" />
+      <input id="int-oauth-client-secret" value="secret-xyz" />
+      <input id="int-oauth-scope" value="https://mail.google.com/" />
+      <div data-region="oauth-status"></div>
+      <button data-action="connect-oauth"></button>
+    `;
+    el.shadowRoot?.appendChild(oauthSlot);
+
+    (global.fetch as any) = jest.fn<any>().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        authUrl: "https://accounts.google.com/o/oauth2/auth",
+      }),
+    });
+
+    const windowOpenSpy = jest
+      .spyOn(window, "open")
+      .mockImplementation(() => null);
+    await el.connectOAuthFromForm(oauthSlot);
+    expect(global.fetch).toHaveBeenCalledWith(
+      "/oauth/authorize",
+      expect.objectContaining({ method: "POST" }),
+    );
+    windowOpenSpy.mockRestore();
+
+    document.body.removeChild(el);
+  });
 });

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

@@ -4,61 +4,153 @@ import {
 } from "./model-ranking.js";
 
 describe("model-ranking", () => {
-  it("detects instruction-oriented local IDs", () => {
-    expect(
-      isLikelyInstructionModelId("onnx-community/gemma-3-1b-it-ONNX"),
-    ).toBe(true);
-    expect(isLikelyInstructionModelId("onnx-community/Qwen3-0.6B-ONNX")).toBe(
-      true,
-    );
-    expect(isLikelyInstructionModelId("some-org/base-embedding-model")).toBe(
-      false,
-    );
+  describe("isLikelyInstructionModelId", () => {
+    it("identifies instruction/chat model names correctly", () => {
+      expect(isLikelyInstructionModelId("meta-llama/Llama-3-8B-Instruct")).toBe(
+        true,
+      );
+      expect(isLikelyInstructionModelId("google/gemma-2-2b-it")).toBe(true);
+      expect(isLikelyInstructionModelId("mistralai/Mistral-7B-Chat-v0.3")).toBe(
+        true,
+      );
+      expect(isLikelyInstructionModelId("org/model-assistant-v1")).toBe(true);
+      expect(isLikelyInstructionModelId("org/model-tool-v2")).toBe(true);
+      expect(
+        isLikelyInstructionModelId("onnx-community/Qwen2.5-0.5B-Instruct"),
+      ).toBe(true);
+      expect(
+        isLikelyInstructionModelId("deepseek-ai/deepseek-r1-distill-qwen-1.5b"),
+      ).toBe(true);
+    });
+
+    it("returns false for non-instruction base model names", () => {
+      expect(isLikelyInstructionModelId("bert-base-uncased")).toBe(false);
+      expect(isLikelyInstructionModelId("gpt2")).toBe(false);
+      expect(isLikelyInstructionModelId("t5-small")).toBe(false);
+    });
   });
 
-  it("ranks small ONNX instruction models above larger ones for browser provider", () => {
-    const small = {
-      id: "onnx-community/Qwen3-0.6B-ONNX",
-      supportsTools: true,
-      contextLength: 32768,
-    };
-    const medium = {
-      id: "onnx-community/gemma-3-1b-it-ONNX",
-      supportsTools: true,
-      contextLength: 32768,
-    };
-    const large = {
-      id: "onnx-community/gemma-4-E4B-it-ONNX",
-      supportsTools: true,
-      contextLength: 131072,
-    };
+  describe("compareLocalModelCandidates", () => {
+    it("prioritizes models supporting tools over unsupported", () => {
+      const a = {
+        id: "model-a-instruct-onnx-0.5b",
+        supportsTools: true,
+        contextLength: 8192,
+      };
+      const b = {
+        id: "model-b-instruct-onnx-0.5b",
+        supportsTools: false,
+        contextLength: 8192,
+      };
 
-    expect(
-      compareLocalModelCandidates(small, medium, "transformers_js_browser"),
-    ).toBeLessThan(0);
-    expect(
-      compareLocalModelCandidates(medium, large, "transformers_js_browser"),
-    ).toBeLessThan(0);
-  });
+      expect(compareLocalModelCandidates(a, b, "local")).toBeLessThan(0);
+      expect(compareLocalModelCandidates(b, a, "local")).toBeGreaterThan(0);
+    });
+
+    it("ranks smaller quantized ONNX models higher for transformers_js_browser", () => {
+      const smallOnnx = {
+        id: "onnx-community/Qwen2.5-0.5B-Instruct-q4",
+        supportsTools: true,
+        contextLength: 32768,
+      };
+      const largeNonOnnx = {
+        id: "meta-llama/Llama-3-8B-Instruct",
+        supportsTools: true,
+        contextLength: 8192,
+      };
+
+      expect(
+        compareLocalModelCandidates(
+          smallOnnx,
+          largeNonOnnx,
+          "transformers_js_browser",
+        ),
+      ).toBeLessThan(0);
+    });
+
+    it("handles various model sizes (0.7b, 1.1b, 1.5b, 7b, unstated size)", () => {
+      const m07 = {
+        id: "model-0.7b-onnx",
+        supportsTools: true,
+        contextLength: 4096,
+      };
+      const m11 = {
+        id: "model-1.1b-onnx",
+        supportsTools: true,
+        contextLength: 4096,
+      };
+      const m15 = {
+        id: "model-1.5b-onnx",
+        supportsTools: true,
+        contextLength: 4096,
+      };
+      const m7b = {
+        id: "model-7b-onnx",
+        supportsTools: true,
+        contextLength: 4096,
+      };
+      const mNoSize = {
+        id: "model-onnx",
+        supportsTools: true,
+        contextLength: 4096,
+      };
+
+      expect(compareLocalModelCandidates(m07, m11, "local")).toBeLessThan(0);
+      expect(compareLocalModelCandidates(m11, m15, "local")).toBeLessThan(0);
+      expect(compareLocalModelCandidates(m15, mNoSize, "local")).toBeLessThan(
+        0,
+      );
+      expect(compareLocalModelCandidates(mNoSize, m7b, "local")).toBeLessThan(
+        0,
+      );
+    });
+
+    it("handles Gemma style E2B/E4B IDs and tie-breaking by context length and id", () => {
+      const gemma = {
+        id: "google/gemma-e2b-it-onnx",
+        supportsTools: true,
+        contextLength: 8192,
+      };
+      const gemmaHighCtx = {
+        id: "google/gemma-e2b-it-onnx",
+        supportsTools: true,
+        contextLength: 16384,
+      };
+
+      // Equal score -> higher context length wins (score negative)
+      expect(
+        compareLocalModelCandidates(gemmaHighCtx, gemma, "local"),
+      ).toBeLessThan(0);
+
+      // Same context length -> alphabetical tie break
+      const m1 = {
+        id: "model-1-onnx-0.5b",
+        supportsTools: true,
+        contextLength: 4096,
+      };
+      const m2 = {
+        id: "model-2-onnx-0.5b",
+        supportsTools: true,
+        contextLength: 4096,
+      };
+      expect(compareLocalModelCandidates(m1, m2, "local")).toBeLessThan(0);
+    });
 
-  it("de-prioritizes non-ONNX candidates for browser provider", () => {
-    const onnxCandidate = {
-      id: "onnx-community/Llama-3.2-1B-Instruct-ONNX",
-      supportsTools: true,
-      contextLength: 16384,
-    };
-    const nonOnnxCandidate = {
-      id: "google/gemma-4-E2B-it",
-      supportsTools: true,
-      contextLength: 131072,
-    };
+    it("scores reasoning/thinking models appropriately", () => {
+      const normal = {
+        id: "qwen-0.5b-onnx-q4",
+        supportsTools: true,
+        contextLength: 8192,
+      };
+      const thinking = {
+        id: "qwen-0.5b-thinking-onnx-q4",
+        supportsTools: true,
+        contextLength: 8192,
+      };
 
-    expect(
-      compareLocalModelCandidates(
-        onnxCandidate,
-        nonOnnxCandidate,
-        "transformers_js_browser",
-      ),
-    ).toBeLessThan(0);
+      expect(
+        compareLocalModelCandidates(normal, thinking, "local"),
+      ).toBeLessThan(0);
+    });
   });
 });