shadow-claw 1.51.0 → 1.52.1

package/src/common/utils/frontmatter.test.ts

@@ -1,5 +1,6 @@
 import {
   createFrontmatterDetailsElement,
+  createFrontmatterElement,
   PostFrontmatter,
   renderFrontmatterMarkup,
   splitFrontmatter,
@@ -24,6 +25,60 @@ describe("frontmatter utilities", () => {
     expect(parsed.content.trim()).toBe("# Heading");
   });
 
+  it("handles markdown with no frontmatter or empty input in splitFrontmatter", () => {
+    const emptyParsed = splitFrontmatter("");
+    expect(emptyParsed.data).toEqual({});
+    expect(emptyParsed.content).toBe("");
+
+    const plainParsed = splitFrontmatter("Just plain markdown");
+    expect(plainParsed.data).toEqual({});
+    expect(plainParsed.content).toBe("Just plain markdown");
+  });
+
+  describe("createFrontmatterElement", () => {
+    it("renders header with title and updated timestamp", () => {
+      const element = createFrontmatterElement(
+        {
+          title: "My Article",
+          updated: "2026-03-15T10:00:00Z",
+          created: "2026-01-01T10:00:00Z",
+        } as PostFrontmatter,
+        document,
+      );
+
+      expect(element.tagName.toLowerCase()).toBe("header");
+      expect(element.getAttribute("class")).toBe("markdown-frontmatter");
+
+      const title = element.querySelector("h1");
+      expect(title?.textContent).toBe("My Article");
+      expect(title?.getAttribute("class")).toBe("markdown-frontmatter__title");
+
+      const time = element.querySelector("time");
+      expect(time?.getAttribute("datetime")).toBe("2026-03-15T10:00:00Z");
+      expect(time?.textContent).toBeDefined();
+    });
+
+    it("falls back to created timestamp when updated is missing", () => {
+      const element = createFrontmatterElement(
+        {
+          created: "2026-01-01T10:00:00Z",
+        } as PostFrontmatter,
+        document,
+      );
+
+      const title = element.querySelector("h1");
+      expect(title).toBeNull();
+
+      const time = element.querySelector("time");
+      expect(time?.getAttribute("datetime")).toBe("2026-01-01T10:00:00Z");
+    });
+
+    it("renders empty header container when no title or timestamp is provided", () => {
+      const element = createFrontmatterElement({} as PostFrontmatter, document);
+      expect(element.children.length).toBe(0);
+    });
+  });
+
   it("builds frontmatter DOM element using createElement semantics", () => {
     const element = createFrontmatterDetailsElement(
       { title: "Post", slug: "post" } as PostFrontmatter,
@@ -43,6 +98,16 @@ describe("frontmatter utilities", () => {
     expect(code?.textContent).toContain('"slug": "post"');
   });
 
+  it("throws in createFrontmatterDetailsElement if documentInstance is invalid", () => {
+    expect(() =>
+      createFrontmatterDetailsElement({} as PostFrontmatter, null as any),
+    ).toThrow("A valid documentInstance is required");
+
+    expect(() =>
+      createFrontmatterDetailsElement({} as PostFrontmatter, {} as any),
+    ).toThrow("A valid documentInstance is required");
+  });
+
   it("serializes markup in browser via DOM outerHTML", () => {
     const html = renderFrontmatterMarkup(
       { title: "Browser Title" } as PostFrontmatter,
@@ -58,6 +123,58 @@ describe("frontmatter utilities", () => {
     expect(html).toContain(""title": "Browser Title"");
   });
 
+  it("uses global document by default in renderFrontmatterMarkup", () => {
+    const html = renderFrontmatterMarkup(
+      { title: "Default Document" } as PostFrontmatter,
+      createFrontmatterElement,
+    );
+    expect(html).toContain("markdown-frontmatter");
+    expect(html).toContain("Default Document");
+  });
+
+  it("falls back to XMLSerializer when outerHTML is not available", () => {
+    const customRenderer = (_data: any, doc: Document) => {
+      const el = doc.createElement("section");
+      el.setAttribute("class", "xml-fallback");
+      Object.defineProperty(el, "outerHTML", {
+        value: undefined,
+        configurable: true,
+      });
+      return el;
+    };
+
+    const html = renderFrontmatterMarkup(
+      {} as PostFrontmatter,
+      customRenderer,
+      { documentInstance: document },
+    );
+    expect(html).toContain('class="xml-fallback"');
+  });
+
+  it("throws when no serializer is available", () => {
+    const customRenderer = () => {
+      const el = { outerHTML: undefined };
+      return el as any;
+    };
+
+    const fakeDoc = {
+      createElement: () => ({}),
+      defaultView: {},
+    } as any;
+
+    const originalXml = (globalThis as any).XMLSerializer;
+    try {
+      delete (globalThis as any).XMLSerializer;
+      expect(() =>
+        renderFrontmatterMarkup({} as PostFrontmatter, customRenderer, {
+          documentInstance: fakeDoc,
+        }),
+      ).toThrow("No serializer available for frontmatter DOM element.");
+    } finally {
+      (globalThis as any).XMLSerializer = originalXml;
+    }
+  });
+
   it("serializes markup via injected serializer for xmldom-style usage", () => {
     const fakeDocument = {
       createTextNode(text: string) {

package/src/components/common/help/providers.test.ts

@@ -89,4 +89,71 @@ describe("provider help", () => {
       dialog.details?.some((line) => line.includes("Runtime missing")),
     ).toBe(true);
   });
+
+  it("checks isLlamafileResolutionError", async () => {
+    const { isLlamafileResolutionError } = await import("./llamafile.js");
+    expect(isLlamafileResolutionError("assets/cache/llamafile not found")).toBe(
+      true,
+    );
+    expect(
+      isLlamafileResolutionError(
+        "missing or invalid 'model' parameter for cli mode",
+      ),
+    ).toBe(true);
+    expect(
+      isLlamafileResolutionError("failed to list llamafile binaries"),
+    ).toBe(true);
+    expect(isLlamafileResolutionError("some random error")).toBe(false);
+  });
+
+  it("checks isTransformersJsResolutionError", async () => {
+    const { isTransformersJsResolutionError } =
+      await import("./transformers.js");
+    expect(
+      isTransformersJsResolutionError(
+        "transformers.js runtime is not installed",
+      ),
+    ).toBe(true);
+    expect(
+      isTransformersJsResolutionError("transformers.js runtime is unavailable"),
+    ).toBe(true);
+    expect(
+      isTransformersJsResolutionError(
+        "no supported transformers.js model loader",
+      ),
+    ).toBe(true);
+    expect(
+      isTransformersJsResolutionError(
+        "cannot find package @huggingface/transformers",
+      ),
+    ).toBe(true);
+    expect(isTransformersJsResolutionError("network error")).toBe(false);
+  });
+
+  it("builds dialogs for api-key-invalid and provider-unreachable", () => {
+    const invalidDialog = buildProviderHelpDialogOptions(
+      "openrouter",
+      "api-key-invalid",
+    );
+    expect(invalidDialog.title).toContain("Authentication Failed");
+
+    const localUnreachable = buildProviderHelpDialogOptions(
+      "transformers_js_local",
+      "provider-unreachable",
+    );
+    expect(localUnreachable.title).toContain("Not Reachable");
+    expect(localUnreachable.details?.some((d) => d.includes("npm start"))).toBe(
+      true,
+    );
+
+    const remoteUnreachable = buildProviderHelpDialogOptions(
+      "openrouter",
+      "provider-unreachable",
+    );
+    expect(
+      remoteUnreachable.details?.some((d) =>
+        d.includes("internet connectivity"),
+      ),
+    ).toBe(true);
+  });
 });

package/src/components/common/shadow-claw-provider-model-picker/shadow-claw-provider-model-picker.test.ts

@@ -158,4 +158,125 @@ describe("shadow-claw-provider-model-picker", () => {
 
     el.remove();
   });
+
+  it("handles getValue, setLabels, and invalidateProviderModels", async () => {
+    const el = new ShadowClawProviderModelPicker();
+    document.body.appendChild(el);
+
+    el.setValue({ providerId: "prov-1", modelId: "mod-1" });
+    expect(el.getValue()).toEqual({ providerId: "prov-1", modelId: "mod-1" });
+
+    el.setLabels({
+      providerLabel: "Custom Provider Label",
+      modelLabel: "Custom Model Label",
+    });
+    const root = el.shadowRoot;
+    expect(root?.textContent).toContain("Custom Provider Label");
+
+    el.invalidateProviderModels("prov-1");
+    el.invalidateProviderModels();
+
+    el.remove();
+  });
+
+  it("handles various model tool badges and context window structures", async () => {
+    const el = new ShadowClawProviderModelPicker();
+    document.body.appendChild(el);
+
+    el.setProviders([
+      {
+        id: "multi-models",
+        name: "Multi Models",
+        models: [
+          {
+            id: "no-tools",
+            name: "No Tools",
+            supports_tools: false,
+            context_window: 4096,
+          },
+          {
+            id: "supported-params",
+            name: "Params",
+            supported_parameters: ["tools"],
+            context_length: 8192,
+          },
+          {
+            id: "no-params",
+            name: "No Params",
+            supported_parameters: ["temperature"],
+          },
+          {
+            id: "provider-list",
+            name: "With Provider List",
+            providers: [{ supports_tools: false, context_length: 16384 }],
+          },
+          {
+            id: "provider-tools",
+            name: "With Provider Tools",
+            providers: [{ supports_tools: true, context_length: 32768 }],
+          },
+          { name: "Only Name" },
+        ],
+      } as any,
+    ]);
+
+    el.setValue({ providerId: "multi-models", modelId: "no-tools" });
+    await el.render();
+
+    const root = el.shadowRoot;
+    const modelSelect = root?.querySelector(
+      '[data-role="model-select"]',
+    ) as HTMLSelectElement;
+    expect(modelSelect).not.toBeNull();
+    const options = Array.from(modelSelect.options).map((o) => o.textContent);
+    expect(options.some((t) => t?.includes("🚫🛠️"))).toBe(true);
+    expect(options.some((t) => t?.includes("🛠️"))).toBe(true);
+
+    el.remove();
+  });
+
+  it("handles loader failure and custom model input events", async () => {
+    const el = new ShadowClawProviderModelPicker();
+    document.body.appendChild(el);
+
+    const failingLoader = jest
+      .fn<() => Promise<any[]>>()
+      .mockRejectedValue(new Error("Network fail"));
+    el.setModelLoader(failingLoader as any);
+    el.setProviders([
+      { id: "dynamic", name: "Dynamic", modelsUrl: "https://fail.test" } as any,
+    ]);
+
+    el.setValue({ providerId: "dynamic", modelId: null });
+    await el.render();
+    await Promise.resolve();
+    await Promise.resolve();
+
+    const root = el.shadowRoot;
+    const modelSelect = root?.querySelector(
+      '[data-role="model-select"]',
+    ) as HTMLSelectElement;
+    if (modelSelect) {
+      modelSelect.value = "__custom__";
+      modelSelect.dispatchEvent(new Event("change"));
+    }
+
+    const customInput = root?.querySelector(
+      '[data-role="custom-model-input"]',
+    ) as HTMLInputElement;
+    const listener = jest.fn();
+    el.addEventListener("provider-model-change", listener as EventListener);
+
+    if (customInput) {
+      customInput.value = "typed-model";
+      customInput.dispatchEvent(new Event("input"));
+      expect(listener).toHaveBeenCalledWith(
+        expect.objectContaining({
+          detail: { providerId: "dynamic", modelId: "typed-model" },
+        }),
+      );
+    }
+
+    el.remove();
+  });
 });

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

@@ -423,4 +423,135 @@ describe("shadow-claw-accounts", () => {
 
     document.body.removeChild(el);
   });
+
+  it("updates an existing account and supports basic auth", async () => {
+    const el = new ShadowClawAccounts();
+    document.body.appendChild(el);
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    await el.render();
+    el.db = {} as any;
+
+    el.accounts = [
+      {
+        id: "acct-existing",
+        label: "Old Label",
+        service: "GitHub",
+        hostPattern: "api.github.com",
+        authMode: "token",
+        token: "old-token",
+      } as any,
+    ];
+
+    el.showAccountForm("acct-existing");
+
+    const root = el.shadowRoot!;
+    (
+      root.querySelector('[data-field="acct-label"]') as HTMLInputElement
+    ).value = "Updated Label";
+    (
+      root.querySelector('[data-field="acct-auth-mode"]') as HTMLSelectElement
+    ).value = "basic";
+    (
+      root.querySelector(
+        '[data-field="acct-basic-username"]',
+      ) as HTMLInputElement
+    ).value = "admin";
+    (
+      root.querySelector('[data-field="acct-token"]') as HTMLInputElement
+    ).value = "secret-pass";
+
+    await el.saveAccountForm();
+
+    expect(showSuccess).toHaveBeenCalledWith("Account updated", 3000);
+    const updated = el.accounts.find((a) => a.id === "acct-existing");
+    expect(updated?.label).toBe("Updated Label");
+    expect(updated?.authMode).toBe("basic");
+    expect(updated?.basicUsername).toBe("admin");
+
+    document.body.removeChild(el);
+  });
+
+  it("handles validation errors when saving account", async () => {
+    const el = new ShadowClawAccounts();
+    document.body.appendChild(el);
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    await el.render();
+    el.db = {} as any;
+
+    el.showAccountForm("new");
+    const root = el.shadowRoot!;
+
+    // 1. Missing label/service/host
+    (
+      root.querySelector('[data-field="acct-label"]') as HTMLInputElement
+    ).value = "";
+    await el.saveAccountForm();
+    expect(showError).toHaveBeenCalledWith(
+      "Label, Service, and Host Pattern are required.",
+      4000,
+    );
+
+    // Fill required base fields
+    (
+      root.querySelector('[data-field="acct-label"]') as HTMLInputElement
+    ).value = "Test";
+    (
+      root.querySelector('[data-field="acct-service"]') as HTMLInputElement
+    ).value = "Service";
+    (root.querySelector('[data-field="acct-host"]') as HTMLInputElement).value =
+      "example.com";
+    (
+      root.querySelector('[data-field="acct-auth-mode"]') as HTMLSelectElement
+    ).value = "oauth";
+
+    // 2. OAuth mode missing client ID
+    (
+      root.querySelector(
+        '[data-field="acct-oauth-provider"]',
+      ) as HTMLSelectElement
+    ).value = "github";
+    (
+      root.querySelector(
+        '[data-field="acct-oauth-client-id"]',
+      ) as HTMLInputElement
+    ).value = "";
+    await el.saveAccountForm();
+    expect(showError).toHaveBeenCalledWith(
+      "OAuth client ID is required for OAuth mode.",
+      4000,
+    );
+
+    document.body.removeChild(el);
+  });
+
+  it("handles error when setConfig fails during saveAccountForm", async () => {
+    const el = new ShadowClawAccounts();
+    document.body.appendChild(el);
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    await el.render();
+    el.db = {} as any;
+
+    el.showAccountForm("new");
+    const root = el.shadowRoot!;
+    (
+      root.querySelector('[data-field="acct-label"]') as HTMLInputElement
+    ).value = "Faulty";
+    (
+      root.querySelector('[data-field="acct-service"]') as HTMLInputElement
+    ).value = "Service";
+    (root.querySelector('[data-field="acct-host"]') as HTMLInputElement).value =
+      "example.com";
+
+    (setConfig as jest.Mock).mockRejectedValueOnce(
+      new Error("Database write error"),
+    );
+    await el.saveAccountForm();
+
+    expect(showError).toHaveBeenCalledWith(
+      expect.stringContaining("Database write error"),
+      6000,
+    );
+
+    document.body.removeChild(el);
+  });
 });

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

@@ -7,6 +7,9 @@ jest.unstable_mockModule("../../../config/config.js", () => ({
     GIT_CORS_PROXY: "git_cors_proxy",
     GIT_ACCOUNTS: "git_accounts",
     GIT_DEFAULT_ACCOUNT: "git_default_account",
+    GIT_TOKEN: "git_token",
+    GIT_USERNAME: "git_username",
+    GIT_PASSWORD: "git_password",
   },
   getProviderTokenAuthScheme: (
     providerId: string,
@@ -454,4 +457,131 @@ describe("shadow-claw-git", () => {
 
     document.body.removeChild(el);
   });
+
+  it("handles saveAccountForm validation, edit existing account, and oauth missing token", async () => {
+    const el = new ShadowClawGit();
+    document.body.appendChild(el);
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    await el.render();
+    el.db = {} as any;
+
+    // 1. Missing label and hostPattern
+    el.showAccountForm("new");
+    const slot = el.shadowRoot?.querySelector(
+      '[data-region="account-form-slot"]',
+    ) as HTMLElement;
+    expect(slot).toBeDefined();
+
+    const labelInput = slot.querySelector(
+      '[data-field="acct-label"]',
+    ) as HTMLInputElement;
+    const hostInput = slot.querySelector(
+      '[data-field="acct-host"]',
+    ) as HTMLInputElement;
+    const authModeSelect = slot.querySelector(
+      '[data-field="acct-auth-mode"]',
+    ) as HTMLSelectElement;
+
+    labelInput.value = "";
+    hostInput.value = "";
+    await el.saveAccountForm();
+
+    // 2. OAuth mode with no token
+    labelInput.value = "OAuth Acc";
+    hostInput.value = "github.com";
+    authModeSelect.value = "oauth";
+    await el.saveAccountForm();
+
+    el.accounts = [
+      {
+        id: "acc-edit",
+        label: "Old Label",
+        hostPattern: "github.com",
+        authMode: "token",
+        token: "old-token",
+      } as any,
+    ];
+    el.showAccountForm("acc-edit");
+
+    const editLabelInput = slot.querySelector(
+      '[data-field="acct-label"]',
+    ) as HTMLInputElement;
+    const editHostInput = slot.querySelector(
+      '[data-field="acct-host"]',
+    ) as HTMLInputElement;
+    const editAuthModeSelect = slot.querySelector(
+      '[data-field="acct-auth-mode"]',
+    ) as HTMLSelectElement;
+    const editTokenInput = slot.querySelector(
+      '[data-field="acct-token"]',
+    ) as HTMLInputElement;
+    const editPassInput = slot.querySelector(
+      '[data-field="acct-password"]',
+    ) as HTMLInputElement;
+    const editUserInput = slot.querySelector(
+      '[data-field="acct-username"]',
+    ) as HTMLInputElement;
+
+    editLabelInput.value = "New Label";
+    editHostInput.value = "github.com/org";
+    editAuthModeSelect.value = "token";
+    editTokenInput.value = "new-token-raw";
+    editPassInput.value = "new-pass-raw";
+    editUserInput.value = "new-user";
+
+    await el.saveAccountForm();
+
+    const edited = el.accounts.find((a) => a.id === "acc-edit");
+    expect(edited).toBeDefined();
+    expect(edited?.label).toBe("New Label");
+    expect(edited?.hostPattern).toBe("github.com/org");
+    expect(edited?.username).toBe("new-user");
+
+    document.body.removeChild(el);
+  });
+
+  it("migrates legacy account configuration when accounts list is empty", async () => {
+    const { getConfig } = await import("../../../db/getConfig.js");
+    const { setConfig } = await import("../../../db/setConfig.js");
+
+    (getConfig as any).mockImplementation(async (_db: any, key: string) => {
+      if (key === "git_token") return "legacy-enc-token";
+      if (key === "git_username") return "legacy-user";
+      if (key === "git_password") return "legacy-enc-pass";
+      return undefined;
+    });
+
+    const el = new ShadowClawGit();
+    document.body.appendChild(el);
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    el.db = {} as any;
+    el.accounts = [];
+
+    await el.migrateLegacyAccount();
+
+    expect(el.accounts).toHaveLength(1);
+    expect(el.accounts[0].token).toBe("legacy-enc-token");
+    expect(el.accounts[0].username).toBe("legacy-user");
+    expect(el.defaultAccountId).toBe("legacy-migrated");
+    expect(setConfig).toHaveBeenCalledWith(el.db, "git_accounts", el.accounts);
+
+    document.body.removeChild(el);
+  });
+
+  it("handles deleteAccount when removing the only account", async () => {
+    const el = new ShadowClawGit();
+    document.body.appendChild(el);
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    el.db = {} as any;
+    el.accounts = [
+      { id: "single-acc", label: "Single", hostPattern: "gh.com" } as any,
+    ];
+    el.defaultAccountId = "single-acc";
+
+    await el.deleteAccount("single-acc");
+    expect(el.accounts).toHaveLength(0);
+    expect(el.defaultAccountId).toBe("");
+
+    document.body.removeChild(el);
+  });
 });

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

@@ -42,4 +42,16 @@ describe("resolveConnectionTestAuth", () => {
     });
     expect(result.error).toContain("Password/app password is missing");
   });
+
+  it("handles undefined pendingOauthAccessToken and passwordInput safely", () => {
+    const resOAuth: any = resolveConnectionTestAuth({
+      authMode: "oauth",
+    } as any);
+    expect(resOAuth.error).toContain("OAuth access token is missing");
+
+    const resPass: any = resolveConnectionTestAuth({
+      authMode: "password",
+    } as any);
+    expect(resPass.error).toContain("Password/app password is missing");
+  });
 });