shadow-claw 1.23.3 → 1.24.0

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

@@ -1,5 +1,8 @@
+import { CONFIG_KEYS } from "../../config/config.js";
 import { effect } from "../../core/effect.js";
 import { getDb } from "../../db/db.js";
+import { getConfig } from "../../db/getConfig.js";
+import { isTruthyConfigValue } from "../../common/utils/config-value.mjs";
 
 import { setSanitizedHtml } from "../../security/trusted-types.js";
 import { copyGroupEntry } from "../../storage/copyGroupEntry.js";
@@ -1575,34 +1578,195 @@ export class ShadowClawFiles extends ShadowClawElement {
     return false;
   }
 
+  async promptUploadConflict(
+    fileName: string,
+    existingNames: Set<string>,
+  ): Promise<
+    { action: "overwrite" } | { action: "rename"; name: string } | null
+  > {
+    const root = this.shadowRoot;
+    if (!root) {
+      return null;
+    }
+
+    const dialog = root.querySelector(".files__upload-conflict-dialog");
+    const messageEl = root.querySelector(".files__upload-conflict-message");
+    const renameInput = root.querySelector(
+      ".files__upload-conflict-rename-input",
+    );
+    const form = root.querySelector(".files__upload-conflict-form");
+    const cancelBtn = root.querySelector(".files__upload-conflict-cancel");
+    const overwriteBtn = root.querySelector(
+      ".files__upload-conflict-overwrite",
+    );
+
+    if (
+      !(dialog instanceof HTMLDialogElement) ||
+      !(form instanceof HTMLFormElement) ||
+      !(renameInput instanceof HTMLInputElement)
+    ) {
+      return null;
+    }
+
+    const targetDirName =
+      orchestratorStore.currentPath === "."
+        ? "Root"
+        : orchestratorStore.currentPath;
+
+    if (messageEl instanceof HTMLElement) {
+      messageEl.textContent = `"${fileName}" already exists in "${targetDirName}". Please rename or choose to overwrite.`;
+    }
+
+    renameInput.value = fileName;
+
+    return new Promise((resolve) => {
+      let resolved = false;
+
+      const cleanup = () => {
+        form.removeEventListener("submit", handleSubmit);
+        cancelBtn?.removeEventListener("click", handleCancel);
+        overwriteBtn?.removeEventListener("click", handleOverwrite);
+        dialog.removeEventListener("cancel", handleCancel);
+        dialog.removeEventListener("close", handleClose);
+      };
+
+      const finish = (
+        result:
+          | { action: "overwrite" }
+          | { action: "rename"; name: string }
+          | null,
+      ) => {
+        if (resolved) {
+          return;
+        }
+        resolved = true;
+        cleanup();
+        if (typeof dialog.close === "function") {
+          dialog.close();
+        } else {
+          dialog.removeAttribute("open");
+        }
+        resolve(result);
+      };
+
+      const handleSubmit = (event: Event) => {
+        event.preventDefault();
+        const nextName = renameInput.value.trim();
+        if (!nextName) {
+          showWarning("Please enter a name", 3000);
+          return;
+        }
+
+        if (nextName.includes("/") || nextName.includes("\\")) {
+          showWarning("Use only a name, not a path", 3500);
+          return;
+        }
+
+        if (existingNames.has(nextName) || existingNames.has(`${nextName}/`)) {
+          showWarning(
+            `"${nextName}" already exists. Please choose a different name.`,
+            4000,
+          );
+          renameInput.select();
+          return;
+        }
+
+        finish({ action: "rename", name: nextName });
+      };
+
+      const handleOverwrite = (event: Event) => {
+        event.preventDefault();
+        finish({ action: "overwrite" });
+      };
+
+      const handleCancel = (event: Event) => {
+        event.preventDefault();
+        finish(null);
+      };
+
+      const handleClose = () => {
+        finish(null);
+      };
+
+      form.addEventListener("submit", handleSubmit);
+      cancelBtn?.addEventListener("click", handleCancel);
+      overwriteBtn?.addEventListener("click", handleOverwrite);
+      dialog.addEventListener("cancel", handleCancel);
+      dialog.addEventListener("close", handleClose);
+
+      if (typeof dialog.showModal === "function") {
+        dialog.showModal();
+      } else {
+        dialog.setAttribute("open", "");
+      }
+      renameInput.select();
+    });
+  }
+
   async uploadFileList(db: ShadowClawDatabase, files: FileList | File[]) {
     const fileList: File[] = Array.from(files) as File[];
     if (fileList.length === 0) {
       return;
     }
 
+    const appendUlid = await getConfig(db, CONFIG_KEYS.FILES_UPLOAD_APPEND_ULID)
+      .then((val) => isTruthyConfigValue(val, false))
+      .catch(() => false);
+
     const groupId = orchestratorStore.activeGroupId;
     const currentPath = orchestratorStore.currentPath;
     const count = fileList.length;
 
     filesUiStore.startUpload(count);
 
+    const existingNames = new Set(orchestratorStore.files);
+    let uploadedCount = 0;
+
     try {
       for (let i = 0; i < count; i++) {
         const file = fileList[i];
-        const filename =
-          currentPath === "."
-            ? `${ulid()}-${file.name}`
-            : `${currentPath}/${ulid()}-${file.name}`;
+        let filename = appendUlid ? `${ulid()}-${file.name}` : file.name;
+
+        const hasConflict =
+          existingNames.has(filename) || existingNames.has(`${filename}/`);
+
+        if (hasConflict) {
+          const decision = await this.promptUploadConflict(
+            filename,
+            existingNames,
+          );
+          if (!decision) {
+            filesUiStore.setUploadCompleted(i + 1);
+            continue;
+          }
 
-        await uploadGroupFile(db, groupId, filename, file);
+          if (decision.action === "rename") {
+            filename = decision.name;
+          } else if (decision.action === "overwrite") {
+            const targetPath =
+              currentPath === "." ? filename : `${currentPath}/${filename}`;
+            await this.removePageAssignmentIfNeeded(db, targetPath);
+          }
+        }
+
+        const fullPath =
+          currentPath === "." ? filename : `${currentPath}/${filename}`;
+
+        await uploadGroupFile(db, groupId, fullPath, file);
+        existingNames.add(filename);
+        uploadedCount++;
         filesUiStore.setUploadCompleted(i + 1);
       }
 
       // Reload files
       await orchestratorStore.loadFiles(db);
 
-      showSuccess(`Uploaded ${count} file${count === 1 ? "" : "s"}`, 3000);
+      if (uploadedCount > 0) {
+        showSuccess(
+          `Uploaded ${uploadedCount} file${uploadedCount === 1 ? "" : "s"}`,
+          3000,
+        );
+      }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
 

package/src/components/shadow-claw-pages/utils/resolveWorkspaceLinkPath.test.ts

@@ -36,6 +36,37 @@ describe("resolveWorkspaceLinkPath", () => {
     expect(result).toBe("docs/guide.md");
   });
 
+  it("resolves relative image link in file directory", () => {
+    const result = resolveWorkspaceLinkPath(
+      "01M1A1R4Y708YJNPGV2NHQKYF7-IMG_0233.jpeg",
+      "index.md",
+      groupId,
+      origin,
+    );
+    expect(result).toBe("01M1A1R4Y708YJNPGV2NHQKYF7-IMG_0233.jpeg");
+  });
+
+  it("resolves relative links when subpath base tag is active", () => {
+    document.querySelectorAll("base").forEach((el) => el.remove());
+    const baseEl = document.createElement("base");
+    baseEl.setAttribute("href", "/shadow-claw/");
+    document.head.appendChild(baseEl);
+    (globalThis as any).__applyBasePathCacheReset?.();
+
+    try {
+      const result = resolveWorkspaceLinkPath(
+        "01M1A1R4Y708YJNPGV2NHQKYF7-IMG_0233.jpeg",
+        "index.md",
+        groupId,
+        origin,
+      );
+      expect(result).toBe("01M1A1R4Y708YJNPGV2NHQKYF7-IMG_0233.jpeg");
+    } finally {
+      baseEl.remove();
+      (globalThis as any).__applyBasePathCacheReset?.();
+    }
+  });
+
   it("returns null if link points to external origin", () => {
     const result = resolveWorkspaceLinkPath(
       "https://example.com/page",

package/src/components/shadow-claw-pages/utils/resolveWorkspaceLinkPath.ts

@@ -1,4 +1,5 @@
 import {
+  applyBasePath,
   getFileRouteDirPath,
   getWorkspaceRouteRequestPath,
   resolveHrefAgainstRoute,
@@ -43,7 +44,7 @@ export function resolveWorkspaceLinkPath(
     }
   }
 
-  const routeDir = getFileRouteDirPath(groupId, filePath);
+  const routeDir = applyBasePath(getFileRouteDirPath(groupId, filePath));
   const resolved = resolveHrefAgainstRoute(
     trimmed,
     routeDir,

package/src/components/shadow-claw-pages/utils/rewriteWorkspacePreviewHtml.test.ts

@@ -42,4 +42,19 @@ describe("rewriteWorkspacePreviewHtml", () => {
     );
     expect(rewritten).toContain('href="https://example.com/docs"');
   });
+
+  it("rewrites relative markdown links to subpath-prefixed workspace routes", () => {
+    const html =
+      '<p><a href="01M1A1R4Y708YJNPGV2NHQKYF7-IMG_0233.jpeg">01M1A1R4Y708YJNPGV2NHQKYF7-IMG_0233.jpeg</a></p>';
+    const rewritten = rewriteWorkspacePreviewHtml(
+      html,
+      "index.md",
+      "/shadow-claw/files/br:main/",
+      groupId,
+      origin,
+    );
+    expect(rewritten).toContain(
+      'href="/shadow-claw/files/br:main/01M1A1R4Y708YJNPGV2NHQKYF7-IMG_0233.jpeg"',
+    );
+  });
 });

package/src/components/shadow-claw-pdf-viewer/utils/installGetOrInsertComputedPolyfill.test.ts

@@ -0,0 +1,65 @@
+import { jest } from "@jest/globals";
+import { installGetOrInsertComputedPolyfill } from "./installGetOrInsertComputedPolyfill.js";
+
+describe("installGetOrInsertComputedPolyfill", () => {
+  let originalMapMethod: any;
+  let originalWeakMapMethod: any;
+
+  beforeEach(() => {
+    originalMapMethod = (Map.prototype as any).getOrInsertComputed;
+    originalWeakMapMethod = (WeakMap.prototype as any).getOrInsertComputed;
+    delete (Map.prototype as any).getOrInsertComputed;
+    delete (WeakMap.prototype as any).getOrInsertComputed;
+  });
+
+  afterEach(() => {
+    if (originalMapMethod) {
+      (Map.prototype as any).getOrInsertComputed = originalMapMethod;
+    } else {
+      delete (Map.prototype as any).getOrInsertComputed;
+    }
+
+    if (originalWeakMapMethod) {
+      (WeakMap.prototype as any).getOrInsertComputed = originalWeakMapMethod;
+    } else {
+      delete (WeakMap.prototype as any).getOrInsertComputed;
+    }
+  });
+
+  it("installs polyfill on Map and WeakMap prototypes and computes missing values", () => {
+    installGetOrInsertComputedPolyfill();
+
+    const map = new Map<string, number>();
+    const compute = jest.fn(() => 42);
+
+    const val1 = (map as any).getOrInsertComputed("foo", compute);
+    expect(val1).toBe(42);
+    expect(compute).toHaveBeenCalledTimes(1);
+
+    // Second call should return cached value without computing
+    const val2 = (map as any).getOrInsertComputed("foo", compute);
+    expect(val2).toBe(42);
+    expect(compute).toHaveBeenCalledTimes(1);
+
+    const weakMap = new WeakMap<object, string>();
+    const keyObj = {};
+    const weakCompute = jest.fn(() => "computed");
+
+    const wVal1 = (weakMap as any).getOrInsertComputed(keyObj, weakCompute);
+    expect(wVal1).toBe("computed");
+    expect(weakCompute).toHaveBeenCalledTimes(1);
+
+    const wVal2 = (weakMap as any).getOrInsertComputed(keyObj, weakCompute);
+    expect(wVal2).toBe("computed");
+    expect(weakCompute).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not overwrite existing getOrInsertComputed", () => {
+    const existing = jest.fn();
+    (Map.prototype as any).getOrInsertComputed = existing;
+
+    installGetOrInsertComputedPolyfill();
+
+    expect((Map.prototype as any).getOrInsertComputed).toBe(existing);
+  });
+});

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

@@ -496,6 +496,13 @@
           </div>
         </details>
 
+        <details class="settings-collapsible">
+          <summary>🎛️ Control Plane</summary>
+          <div class="settings-collapsible-content">
+            <shadow-claw-control-plane></shadow-claw-control-plane>
+          </div>
+        </details>
+
         <details class="settings-collapsible">
           <summary>📧 Email</summary>
           <div class="settings-collapsible-content">

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

@@ -136,6 +136,23 @@ jest.unstable_mockModule(
   },
 );
 
+jest.unstable_mockModule(
+  "../settings/shadow-claw-control-plane/shadow-claw-control-plane.js",
+  () => {
+    class MockControlPlane extends HTMLElement {
+      render = jest.fn();
+      constructor() {
+        super();
+        this.attachShadow({ mode: "open" });
+      }
+    }
+
+    customElements.define("shadow-claw-control-plane", MockControlPlane);
+
+    return { ShadowClawControlPlane: MockControlPlane };
+  },
+);
+
 jest.unstable_mockModule(
   "../settings/shadow-claw-notifications/shadow-claw-notifications.js",
   () => {
@@ -812,4 +829,208 @@ describe("shadow-claw-settings", () => {
 
     document.body.removeChild(el);
   });
+
+  it("handles onChatSplitViewToggle and dispatches event", async () => {
+    const el = new ShadowClawSettings() as any;
+    el.db = {};
+    const events: any[] = [];
+    el.addEventListener("chat-split-view-change", (e: any) =>
+      events.push(e.detail),
+    );
+
+    await el.onChatSplitViewToggle(true);
+
+    expect((globalThis as any)._mockSetConfig).toHaveBeenCalledWith(
+      expect.anything(),
+      "chat_split_view_enabled",
+      "true",
+    );
+    expect(events).toEqual([{ enabled: true }]);
+  });
+
+  it("handles onPagesAutoRefreshInputChange and dispatches event", async () => {
+    const el = new ShadowClawSettings() as any;
+    el.db = {};
+    const events: any[] = [];
+    const listener = (e: any) => events.push(e.detail);
+    window.addEventListener("shadow-claw-pages-auto-refresh-change", listener);
+
+    try {
+      await el.onPagesAutoRefreshInputChange(30);
+
+      expect((globalThis as any)._mockSetConfig).toHaveBeenCalledWith(
+        expect.anything(),
+        "pages_auto_refresh_interval",
+        "30",
+      );
+      expect(events).toEqual([{ interval: 30 }]);
+    } finally {
+      window.removeEventListener(
+        "shadow-claw-pages-auto-refresh-change",
+        listener,
+      );
+    }
+  });
+
+  it("handles sidebar navigation visibility toggles", async () => {
+    const el = new ShadowClawSettings() as any;
+    el.db = {};
+
+    await el.onSidebarHideChatToggle(true);
+    expect((globalThis as any)._mockSetConfig).toHaveBeenCalledWith(
+      expect.anything(),
+      "sidebar_chat_hidden",
+      "true",
+    );
+
+    await el.onSidebarHideFilesToggle(true);
+    expect((globalThis as any)._mockSetConfig).toHaveBeenCalledWith(
+      expect.anything(),
+      "sidebar_files_hidden",
+      "true",
+    );
+
+    await el.onSidebarHideTasksToggle(true);
+    expect((globalThis as any)._mockSetConfig).toHaveBeenCalledWith(
+      expect.anything(),
+      "sidebar_tasks_hidden",
+      "true",
+    );
+  });
+
+  it("handles replaceConfigEntries with transaction", async () => {
+    const el = new ShadowClawSettings() as any;
+    const mockStore = {
+      clear: jest.fn(),
+      put: jest.fn(),
+    };
+    const mockTx = {
+      objectStore: jest.fn(() => mockStore),
+      oncomplete: null as any,
+      onerror: null as any,
+    };
+    el.db = {
+      transaction: jest.fn(() => {
+        setTimeout(() => mockTx.oncomplete?.(), 0);
+        return mockTx;
+      }),
+    };
+
+    await el.replaceConfigEntries([
+      { key: "k1", value: "v1" },
+      { key: "k2", value: "v2" },
+    ]);
+
+    expect(mockStore.clear).toHaveBeenCalled();
+    expect(mockStore.put).toHaveBeenCalledWith({ key: "k1", value: "v1" });
+    expect(mockStore.put).toHaveBeenCalledWith({ key: "k2", value: "v2" });
+  });
+
+  it("returns null when promptForPlaintextBackupHandle encounters AbortError", async () => {
+    const el = new ShadowClawSettings() as any;
+    const abortErr = new Error("User canceled");
+    abortErr.name = "AbortError";
+
+    (globalThis as any).showSaveFilePicker = (
+      jest.fn() as any
+    ).mockRejectedValue(abortErr);
+
+    const handle = await el.promptForPlaintextBackupHandle();
+    expect(handle).toBeNull();
+
+    delete (globalThis as any).showSaveFilePicker;
+  });
+
+  it("handles activity log, chat split view, prerender skeleton, and pages auto refresh settings", async () => {
+    const el = new ShadowClawSettings() as any;
+    el.db = {} as any;
+
+    await el.onActivityLogDiskLoggingToggle(true);
+    expect((globalThis as any)._mockSetConfig).toHaveBeenCalledWith(
+      el.db,
+      "activity_log_disk_logging_enabled",
+      "true",
+    );
+
+    const splitEventSpy = jest.fn();
+    el.addEventListener("chat-split-view-change", splitEventSpy);
+    await el.onChatSplitViewToggle(true);
+    expect(splitEventSpy).toHaveBeenCalled();
+    expect((globalThis as any)._mockSetConfig).toHaveBeenCalledWith(
+      el.db,
+      "chat_split_view_enabled",
+      "true",
+    );
+
+    await el.onOverridePrerenderSkeletonToggle(true);
+    expect((globalThis as any)._mockSetConfig).toHaveBeenCalledWith(
+      el.db,
+      "override_prerender_skeleton",
+      "true",
+    );
+
+    await el.onPagesAutoRefreshInputChange(30);
+    expect((globalThis as any)._mockSetConfig).toHaveBeenCalledWith(
+      el.db,
+      "pages_auto_refresh_interval",
+      "30",
+    );
+
+    // Sidebar visibility toggles
+    await el.onSidebarHideChatToggle(true);
+    expect((globalThis as any)._mockSetConfig).toHaveBeenCalledWith(
+      el.db,
+      "sidebar_chat_hidden",
+      "true",
+    );
+
+    await el.onSidebarHideFilesToggle(true);
+    expect((globalThis as any)._mockSetConfig).toHaveBeenCalledWith(
+      el.db,
+      "sidebar_files_hidden",
+      "true",
+    );
+
+    await el.onSidebarHidePagesToggle(true);
+    expect((globalThis as any)._mockSetConfig).toHaveBeenCalledWith(
+      el.db,
+      "sidebar_pages_hidden",
+      "true",
+    );
+
+    await el.onSidebarHideTasksToggle(true);
+    expect((globalThis as any)._mockSetConfig).toHaveBeenCalledWith(
+      el.db,
+      "sidebar_tasks_hidden",
+      "true",
+    );
+
+    // Backup / Restore / Clear methods
+    (global.URL.createObjectURL as any) = jest
+      .fn<any>()
+      .mockReturnValue("blob:settings-backup");
+    (global.URL.revokeObjectURL as any) = jest.fn();
+    el.getAllConfigEntries = jest
+      .fn<any>()
+      .mockResolvedValue([{ key: "k", value: "v" }]);
+    el.replaceConfigEntries = jest.fn<any>().mockResolvedValue(undefined);
+    el.closeDialog = jest.fn();
+
+    // confirmBackup
+    await el.confirmBackup();
+    expect(el.closeDialog).toHaveBeenCalledWith(".settings__backup-dialog");
+
+    // confirmClear
+    await el.confirmClear();
+    expect(el.replaceConfigEntries).toHaveBeenCalledWith([]);
+
+    // confirmRestore
+    el.pendingRestoreFile = {
+      name: "backup.json",
+      text: async () =>
+        JSON.stringify({ configEntries: [{ key: "k2", value: "v2" }] }),
+    } as any;
+    await el.confirmRestore();
+    expect(el.replaceConfigEntries).toHaveBeenCalled();
+  });
 });

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

@@ -38,6 +38,8 @@ const settingsTabLoaders: Record<string, (() => Promise<unknown>)[]> = {
     () => import("../settings/shadow-claw-accounts/shadow-claw-accounts.js"),
     () =>
       import("../settings/shadow-claw-mcp-remote/shadow-claw-mcp-remote.js"),
+    () =>
+      import("../settings/shadow-claw-control-plane/shadow-claw-control-plane.js"),
     () =>
       import("../settings/shadow-claw-integrations/shadow-claw-integrations.js"),
     () =>