shadow-claw 1.23.4 → 1.24.0

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

@@ -45,6 +45,8 @@ jest.unstable_mockModule("../../stores/orchestrator.js", () => ({
     toggleTask: jest.fn(),
     getTasksByGroupId: jest.fn(() => []),
     getTaskServerTerminalInstance: jest.fn(() => null),
+    reorderTasks: jest.fn(),
+    restoreTasksFromBackup: jest.fn(),
   },
 }));
 
@@ -261,5 +263,410 @@ describe("shadow-claw-tasks", () => {
         }),
       );
     });
+
+    it("manages tools editor UI interactions (remove, modify, suppress)", () => {
+      const el = new ShadowClawTasks();
+      document.body.appendChild(el);
+
+      el.editingTools = [
+        {
+          name: "test_tool",
+          input: { a: 1 },
+          suppressOutput: false,
+          suppressToast: false,
+        },
+      ];
+
+      el.renderToolsEditor();
+      const toolsList = el.shadowRoot?.querySelector(
+        ".tasks__tools-list",
+      ) as HTMLElement;
+      expect(toolsList.querySelectorAll(".tasks__tool-item").length).toBe(1);
+
+      // Modify tool name
+      const nameInput = toolsList.querySelector(
+        ".tasks__form-input",
+      ) as HTMLInputElement;
+      nameInput.value = "updated_tool";
+      nameInput.dispatchEvent(new Event("input"));
+      expect(el.editingTools[0].name).toBe("updated_tool");
+
+      // Modify textarea params
+      const textarea = toolsList.querySelector(
+        ".tasks__form-textarea",
+      ) as HTMLTextAreaElement;
+      textarea.value = '{"foo": "bar"}';
+      textarea.dispatchEvent(new Event("change"));
+      expect(el.editingTools[0].input).toEqual({ foo: "bar" });
+
+      // Toggle suppress
+      const suppressCheckbox = toolsList.querySelector(
+        ".tasks__tool-suppress input",
+      ) as HTMLInputElement;
+      suppressCheckbox.checked = true;
+      suppressCheckbox.dispatchEvent(new Event("change"));
+      expect(el.editingTools[0].suppressOutput).toBe(true);
+
+      // Remove tool
+      const removeBtn = toolsList.querySelector(
+        ".tasks__tool-remove-btn",
+      ) as HTMLButtonElement;
+      removeBtn.click();
+      expect(el.editingTools.length).toBe(0);
+
+      document.body.removeChild(el);
+    });
+
+    it("renders tasks and binds action buttons (toggle, copy, run, edit, delete)", async () => {
+      const el = new ShadowClawTasks();
+      const container = document.createElement("div");
+      container.className = "tasks__list";
+      const countEl = document.createElement("span");
+      countEl.className = "tasks__count";
+      el.shadowRoot?.replaceChildren(countEl, container);
+
+      const db = {} as any;
+      const tasks = [
+        {
+          id: "task-1",
+          name: "Daily Job",
+          schedule: "0 0 * * *",
+          prompt: "check status",
+          enabled: true,
+          type: "prompt",
+          freshContext: true,
+        },
+      ];
+      (orchestratorStore as any).tasks = tasks;
+
+      await el.updateTaskList(db);
+      expect(container.querySelectorAll(".tasks__item").length).toBe(1);
+
+      const item = container.querySelector(".tasks__item") as HTMLElement;
+      const toggleInput = item.querySelector(
+        ".tasks__toggle-input",
+      ) as HTMLInputElement;
+      toggleInput.checked = false;
+      toggleInput.dispatchEvent(new Event("change"));
+      expect(orchestratorStore.toggleTask).toHaveBeenCalledWith(
+        db,
+        tasks[0],
+        false,
+      );
+
+      const runBtn = item.querySelector(".tasks__run-btn") as HTMLButtonElement;
+      runBtn.click();
+      expect(orchestratorStore.runTask).toHaveBeenCalledWith(tasks[0], true);
+    });
+
+    it("handles restore with valid and invalid files", async () => {
+      const el = new ShadowClawTasks();
+      const db = {} as any;
+
+      // 1. No file selected
+      const emptyInput = document.createElement("input");
+      emptyInput.type = "file";
+      await el.handleRestore(db, emptyInput);
+
+      // 2. Valid JSON file
+      const backupData = [
+        {
+          id: "restored-1",
+          schedule: "0 0 * * *",
+          prompt: "daily report",
+          enabled: true,
+        },
+      ];
+      const validFile = new File([JSON.stringify(backupData)], "backup.json", {
+        type: "application/json",
+      });
+      const fileInput = document.createElement("input");
+      fileInput.type = "file";
+      Object.defineProperty(fileInput, "files", { value: [validFile] });
+
+      await el.handleRestore(db, fileInput);
+      expect(orchestratorStore.upsertTask).toHaveBeenCalled();
+    });
+
+    it("handles preview link clicks and opens in file viewer", async () => {
+      const el = new ShadowClawTasks();
+      const db = {} as any;
+
+      const link = document.createElement("a");
+      link.setAttribute("href", "docs/spec.md");
+      const targetDiv = document.createElement("div");
+      targetDiv.appendChild(link);
+
+      const event = new MouseEvent("click", {
+        bubbles: true,
+        cancelable: true,
+      });
+      Object.defineProperty(event, "target", { value: link });
+      Object.defineProperty(event, "button", { value: 0 });
+
+      const fileViewerMod = await import("../../stores/file-viewer.js");
+      await el.handlePreviewLinkClick(event, db);
+      expect(fileViewerMod.fileViewerStore.openFile).toHaveBeenCalledWith(
+        db,
+        "docs/spec.md",
+        "default",
+      );
+    });
+
+    it("cleans up on disconnectedCallback", () => {
+      const el = new ShadowClawTasks();
+      const cleanupMock = jest.fn();
+      el.cleanup = cleanupMock;
+      el.disconnectedCallback();
+      expect(cleanupMock).toHaveBeenCalledTimes(1);
+    });
+
+    it("renders tools preview for tool task chains", () => {
+      const el = new ShadowClawTasks();
+      const tools = [
+        { name: "read_file", input: { path: "hello.txt" } },
+        { name: "write_file", input: { path: "out.txt", content: "$pipe" } },
+      ];
+      const previewHtml = el.renderToolsPreview(tools);
+      expect(previewHtml).toContain("read_file");
+      expect(previewHtml).toContain("write_file");
+      expect(previewHtml).toContain("hello.txt");
+    });
+
+    it("handles clear all tasks when confirmed", async () => {
+      const el = new ShadowClawTasks();
+      const db = {} as any;
+      window.confirm = jest.fn(() => true);
+
+      await el.handleClearAll(db);
+      expect(orchestratorStore.clearAllTasks).toHaveBeenCalledWith(db);
+
+      window.confirm = jest.fn(() => false);
+      (orchestratorStore.clearAllTasks as any).mockClear();
+      await el.handleClearAll(db);
+      expect(orchestratorStore.clearAllTasks).not.toHaveBeenCalled();
+    });
+
+    it("handles edit submission for prompt and tool tasks", async () => {
+      const el = new ShadowClawTasks();
+      const db = {} as any;
+
+      const form = document.createElement("form");
+      const scheduleInput = document.createElement("input");
+      scheduleInput.name = "schedule";
+      scheduleInput.value = "*/15 * * * *";
+
+      const promptInput = document.createElement("textarea");
+      promptInput.name = "prompt";
+      promptInput.value = "Run automated scan";
+
+      const freshContextInput = document.createElement("input");
+      freshContextInput.name = "freshContext";
+      freshContextInput.type = "checkbox";
+      freshContextInput.checked = true;
+
+      const subagentInput = document.createElement("input");
+      subagentInput.name = "subagent";
+      subagentInput.type = "checkbox";
+      subagentInput.checked = false;
+
+      const promptRadio = document.createElement("input");
+      promptRadio.name = "taskType";
+      promptRadio.value = "prompt";
+      promptRadio.checked = true;
+
+      form.append(
+        scheduleInput,
+        promptInput,
+        freshContextInput,
+        subagentInput,
+        promptRadio,
+      );
+
+      const dialog = document.createElement("dialog");
+      dialog.close = jest.fn();
+      el.shadowRoot?.appendChild(dialog);
+
+      await el.handleEditSubmit(db, form);
+      expect(orchestratorStore.upsertTask).toHaveBeenCalledWith(
+        db,
+        expect.objectContaining({
+          schedule: "*/15 * * * *",
+          prompt: "Run automated scan",
+          freshContext: true,
+          type: "prompt",
+        }),
+      );
+    });
+
+    it("handles copyId, delete, reorder, restore, and renderPreview", async () => {
+      const el = new ShadowClawTasks() as any;
+      const db = {} as any;
+
+      // 1. Copy ID
+      const mockClipboard = {
+        writeText: jest.fn<any>().mockResolvedValue(undefined),
+      };
+      Object.assign(navigator, { clipboard: mockClipboard });
+      await el.handleCopyId("task-123");
+      expect(mockClipboard.writeText).toHaveBeenCalledWith("task-123");
+
+      // 2. Delete task with confirmation
+      el.requestConfirmation = jest.fn<any>().mockResolvedValue(true);
+      await el.handleDelete(db, "task-123");
+      expect(orchestratorStore.deleteTask).toHaveBeenCalledWith(db, "task-123");
+
+      // 3. Reorder tasks
+      await el.handleReorder("t1", "t2", ["t2", "t1"]);
+      expect(orchestratorStore.reorderTasks).toHaveBeenCalledWith(
+        expect.anything(),
+        "default",
+        ["t2", "t1"],
+      );
+
+      // 4. Restore tasks from JSON
+      const restoreFile = {
+        name: "tasks-backup.json",
+        text: jest
+          .fn<() => Promise<string>>()
+          .mockResolvedValue(JSON.stringify([{ id: "t1" }])),
+      };
+      const restoreInput = {
+        files: [restoreFile],
+        value: "tasks-backup.json",
+      } as any;
+      await el.handleRestore(db, restoreInput);
+      expect(orchestratorStore.restoreTasksFromBackup).toHaveBeenCalledWith(
+        db,
+        [{ id: "t1" }],
+      );
+
+      // 5. Render preview
+      const emptyPreview = await el.renderPreview("");
+      expect(emptyPreview).toContain("No content");
+
+      const shortPreview = await el.renderPreview("Short prompt");
+      expect(shortPreview).toContain("tasks__prompt");
+
+      const longPreview = await el.renderPreview(
+        "Long\nmulti-line\nprompt",
+        true,
+      );
+      expect(longPreview).toContain("tasks__content-details");
+    });
+
+    it("handles keyboard navigation, announcement, and autoscroll", async () => {
+      const el = new ShadowClawTasks() as any;
+      document.body.appendChild(el);
+
+      // 1. _announce
+      const liveRegion = document.createElement("div");
+      liveRegion.id = "live-region";
+      el.shadowRoot?.appendChild(liveRegion);
+      el._announce("Task test announcement");
+
+      // 2. Keyboard grab and navigation
+      (orchestratorStore as any).tasks = [
+        { id: "t1", name: "Task 1", prompt: "Hello 1" },
+        { id: "t2", name: "Task 2", prompt: "Hello 2" },
+      ];
+
+      // Grab with 'm'
+      const keyM = new KeyboardEvent("keydown", { key: "m", cancelable: true });
+      el._handleKeyboard(keyM, "t1", "Task 1");
+      expect(el._keyboardGrabbedId).toBe("t1");
+
+      // Move down with ArrowDown
+      const keyDown = new KeyboardEvent("keydown", {
+        key: "ArrowDown",
+        cancelable: true,
+      });
+      el._handleKeyboard(keyDown, "t1", "Task 1");
+
+      // Drop with Space
+      const keySpace = new KeyboardEvent("keydown", {
+        key: " ",
+        cancelable: true,
+      });
+      el._handleKeyboard(keySpace, "t1", "Task 1");
+      expect(el._keyboardGrabbedId).toBeNull();
+
+      // Cancel with Escape
+      el._keyboardGrabbedId = "t1";
+      const keyEsc = new KeyboardEvent("keydown", {
+        key: "Escape",
+        cancelable: true,
+      });
+      el._handleKeyboard(keyEsc, "t1", "Task 1");
+      expect(el._keyboardGrabbedId).toBeNull();
+
+      // Navigation when not grabbed
+      const item1 = document.createElement("div");
+      item1.className = "tasks__item";
+      item1.setAttribute("tabindex", "0");
+      const item2 = document.createElement("div");
+      item2.className = "tasks__item";
+      item2.setAttribute("tabindex", "0");
+      el.shadowRoot?.appendChild(item1);
+      el.shadowRoot?.appendChild(item2);
+
+      const navDown = new KeyboardEvent("keydown", {
+        key: "ArrowDown",
+        cancelable: true,
+      });
+      Object.defineProperty(navDown, "target", { value: item1 });
+      el._handleKeyboard(navDown, "t1", "Task 1");
+
+      // 3. Autoscroll
+      let content = el.shadowRoot?.querySelector(
+        ".tasks__content",
+      ) as HTMLElement;
+      if (!content) {
+        content = document.createElement("div");
+        content.className = "tasks__content";
+        el.shadowRoot?.appendChild(content);
+      }
+      content.getBoundingClientRect = () =>
+        ({ top: 100, bottom: 500, height: 400 }) as any;
+
+      el._updateAutoScrollSpeed(110); // Near top
+      expect(el._autoScrollActive).toBe(true);
+      el._stopAutoScroll();
+      expect(el._autoScrollActive).toBe(false);
+
+      // 4. Focus navigation
+      el._focusNext(item1);
+      el._focusPrev(item2);
+      el._focusNextItem(item1);
+      el._focusPrevItem(item2);
+
+      // 5. Touch events and findTouch
+      if (el.shadowRoot) {
+        (el.shadowRoot as any).elementFromPoint = jest.fn(() => item1);
+      }
+      const listEl = document.createElement("div");
+      listEl.className = "tasks__list";
+      el.shadowRoot?.appendChild(listEl);
+      el._bindTouchListEvents(listEl);
+
+      el._touchId = 123;
+      el._touchDraggedTaskId = "t1";
+      const fakeTouch = { identifier: 123, clientX: 50, clientY: 150 };
+      const touchMoveEvt = new Event("touchmove") as any;
+      touchMoveEvt.touches = [fakeTouch];
+      touchMoveEvt.changedTouches = [fakeTouch];
+      listEl.dispatchEvent(touchMoveEvt);
+
+      const touchEndEvt = new Event("touchend") as any;
+      touchEndEvt.touches = [];
+      touchEndEvt.changedTouches = [fakeTouch];
+      listEl.dispatchEvent(touchEndEvt);
+
+      const touchCancelEvt = new Event("touchcancel") as any;
+      listEl.dispatchEvent(touchCancelEvt);
+
+      el.cleanup = jest.fn();
+      document.body.removeChild(el);
+    });
   });
 });

package/src/components/shadow-claw-terminal/utils/consumeEscapeSequence.test.ts

@@ -0,0 +1,58 @@
+import { consumeEscapeSequence } from "./consumeEscapeSequence.js";
+
+describe("consumeEscapeSequence", () => {
+  it("handles end of string right after escape character", () => {
+    const res = consumeEscapeSequence("\x1b", 0);
+    expect(res).toEqual({ action: "ignore", nextIndex: 1, incomplete: true });
+  });
+
+  describe("CSI sequences (\\x1b[)", () => {
+    it("handles clear-screen sequence ending with J (e.g. \\x1b[2J)", () => {
+      const res = consumeEscapeSequence("\x1b[2JHello", 0);
+      expect(res).toEqual({ action: "clear-screen", nextIndex: 4 });
+    });
+
+    it("handles clear-line sequence ending with K (e.g. \\x1b[K)", () => {
+      const res = consumeEscapeSequence("\x1b[KRest", 0);
+      expect(res).toEqual({ action: "clear-line", nextIndex: 3 });
+    });
+
+    it("handles other CSI sequences (e.g. color \\x1b[31m)", () => {
+      const res = consumeEscapeSequence("\x1b[31mRed text", 0);
+      expect(res).toEqual({ action: "ignore", nextIndex: 5 });
+    });
+
+    it("handles incomplete CSI sequence at end of buffer", () => {
+      const res = consumeEscapeSequence("\x1b[31", 0);
+      expect(res).toEqual({ action: "ignore", nextIndex: 4, incomplete: true });
+    });
+  });
+
+  describe("OSC sequences (\\x1b])", () => {
+    it("handles OSC sequence terminated by BEL (\\u0007)", () => {
+      const res = consumeEscapeSequence("\x1b]0;Title\u0007Remaining", 0);
+      expect(res).toEqual({ action: "ignore", nextIndex: 10 });
+    });
+
+    it("handles OSC sequence terminated by ST (\\u001b\\\\)", () => {
+      const res = consumeEscapeSequence("\x1b]0;Title\u001b\\Remaining", 0);
+      expect(res).toEqual({ action: "ignore", nextIndex: 11 });
+    });
+
+    it("handles incomplete OSC sequence at end of buffer", () => {
+      const res = consumeEscapeSequence("\x1b]0;Incomplete", 0);
+      expect(res).toEqual({
+        action: "ignore",
+        nextIndex: 14,
+        incomplete: true,
+      });
+    });
+  });
+
+  describe("Other escape sequences", () => {
+    it("handles simple 2-char escape sequence (e.g. \\x1bM)", () => {
+      const res = consumeEscapeSequence("\x1bMRest", 0);
+      expect(res).toEqual({ action: "ignore", nextIndex: 2 });
+    });
+  });
+});

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

@@ -461,4 +461,84 @@ describe("shadow-claw-tools", () => {
 
     document.body.removeChild(el);
   });
+
+  it("handles handleAddTool, handleCloneTool, handleRestore, and handleSaveProfile", async () => {
+    const el = new ShadowClawTools() as any;
+    document.body.appendChild(el);
+    await el.connectedCallback();
+    const db = {} as any;
+
+    const dialog = el.shadowRoot?.querySelector(".tools__dialog");
+    if (dialog) (dialog as any).close = jest.fn();
+    const cloneDialog = el.shadowRoot?.querySelector(".tools__clone-dialog");
+    if (cloneDialog) (cloneDialog as any).close = jest.fn();
+    const profileDialog = el.shadowRoot?.querySelector(
+      ".tools__profile-dialog",
+    );
+    if (profileDialog) (profileDialog as any).close = jest.fn();
+
+    // 1. Add Tool validation
+    const form = document.createElement("form");
+    form.innerHTML = `
+      <input name="name" value="" />
+      <input name="description" value="" />
+    `;
+    await el.handleAddTool(db, form);
+    expect(toolsStore.addCustomTool).not.toHaveBeenCalled();
+
+    // 2. Add Tool success
+    form.innerHTML = `
+      <input name="name" value="unique_tool" />
+      <input name="description" value="A unique tool" />
+      <input name="input_schema" value='{"type":"object"}' />
+    `;
+    await el.handleAddTool(db, form);
+    expect(toolsStore.addCustomTool).toHaveBeenCalledWith(
+      db,
+      expect.objectContaining({ name: "unique_tool" }),
+    );
+
+    // 3. Clone Tool
+    const cloneForm = document.createElement("form");
+    cloneForm.innerHTML = `
+      <input name="source" value="bash" />
+      <input name="name" value="bash_copy" />
+      <input name="description" value="Cloned bash" />
+    `;
+    await el.handleCloneTool(db, cloneForm);
+    expect(toolsStore.cloneTool).toHaveBeenCalledWith(
+      db,
+      "bash",
+      "bash_copy",
+      "Cloned bash",
+    );
+
+    // 4. Restore backup
+    const restoreFile = {
+      text: jest
+        .fn<() => Promise<string>>()
+        .mockResolvedValue(JSON.stringify({ tools: [] })),
+    };
+    const restoreInput = {
+      files: [restoreFile],
+      value: "backup.json",
+    } as any;
+    await el.handleRestore(db, restoreInput);
+    expect(toolsStore.importBackup).toHaveBeenCalled();
+
+    // 5. Save Profile
+    const profileForm = document.createElement("form");
+    profileForm.innerHTML = `
+      <input name="name" value="Dev Profile" />
+      <input name="providerId" value="anthropic" />
+      <input name="model" value="claude-3" />
+    `;
+    await el.handleSaveProfile(db, profileForm);
+    expect(toolsStore.addProfile).toHaveBeenCalledWith(
+      db,
+      expect.objectContaining({ name: "Dev Profile", providerId: "anthropic" }),
+    );
+
+    document.body.removeChild(el);
+  });
 });

package/src/config/config.ts

@@ -1035,6 +1035,10 @@ export const CONFIG_KEYS = {
   CHAT_SPLIT_VIEW_HEIGHT: "chat_split_view_height",
   COMPACTION_ENGINE_PREFERENCE: "compaction_engine_preference",
   CONTEXT_COMPRESSION_ENABLED: "context_compression_enabled",
+  CONTROL_PLANE_CLIENT_ID: "control_plane_client_id",
+  CONTROL_PLANE_ENABLED: "control_plane_enabled",
+  CONTROL_PLANE_TRANSPORT: "control_plane_transport",
+  CONTROL_PLANE_URL: "control_plane_url",
   CONVERSATIONS_HEIGHT: "conversations_height",
   CUSTOM_TOOLS: "custom_tools",
   DB_MIGRATED_FROM_LEGACY: "db_migrated_from_legacy",
@@ -1185,3 +1189,9 @@ export const DEFAULT_TASK_SERVER_ENABLED = false;
 
 /** Default Files Upload Append ULID */
 export const DEFAULT_FILES_UPLOAD_APPEND_ULID = false;
+
+/** Default Control Plane Enabled (opt-in) */
+export const DEFAULT_CONTROL_PLANE_ENABLED = false;
+
+/** Default Control Plane Transport ("sse" or "websocket") */
+export const DEFAULT_CONTROL_PLANE_TRANSPORT = "sse";

package/src/core/backup-controller.test.ts

@@ -0,0 +1,101 @@
+import { jest } from "@jest/globals";
+import { BackupController } from "./backup-controller.js";
+
+describe("backup-controller", () => {
+  let mockFetch: jest.Mock<any>;
+
+  beforeEach(() => {
+    mockFetch = jest.fn() as any;
+    (globalThis as any).fetch = mockFetch;
+  });
+
+  it("enumerates files, uploads each, and completes the backup", async () => {
+    const mockFiles: Record<string, string> = {
+      "MEMORY.md": "# Memory content",
+      "src/index.ts": "console.log('hello');",
+    };
+
+    mockFetch.mockImplementation(async (url: string, init: any) => {
+      const urlStr = url.toString();
+      if (urlStr.includes("/api/backup/upload")) {
+        return {
+          ok: true,
+          status: 200,
+          json: async () => ({ success: true }),
+        };
+      }
+      if (urlStr.includes("/api/backup/complete")) {
+        const body = JSON.parse(init.body);
+        return {
+          ok: true,
+          status: 200,
+          json: async () => ({
+            success: true,
+            backupId: body.backupId,
+            fileCount: body.fileCount,
+            totalBytes: body.totalBytes,
+          }),
+        };
+      }
+      return { ok: false, status: 404 };
+    });
+
+    const progressUpdates: any[] = [];
+    const controller = new BackupController({
+      clientId: "test-client-backup",
+      token: "secret-token",
+      serverBaseUrl: "http://127.0.0.1:8888",
+      fileEnumerator: async () => Object.keys(mockFiles),
+      fileReader: async (path: string) => mockFiles[path] || null,
+      onProgress: (p) => progressUpdates.push(p),
+    });
+
+    const result = await controller.initiate();
+
+    expect(result.success).toBe(true);
+    expect(result.fileCount).toBe(2);
+    expect(result.totalBytes).toBeGreaterThan(0);
+    expect(result.backupId).toBeTruthy();
+
+    // Verify upload calls
+    expect(mockFetch).toHaveBeenCalledWith(
+      expect.stringContaining("/api/backup/upload"),
+      expect.objectContaining({
+        method: "POST",
+        headers: expect.objectContaining({
+          "x-control-token": "secret-token",
+        }),
+      }),
+    );
+
+    // Verify complete call
+    expect(mockFetch).toHaveBeenCalledWith(
+      expect.stringContaining("/api/backup/complete"),
+      expect.objectContaining({
+        method: "POST",
+        headers: expect.objectContaining({
+          "x-control-token": "secret-token",
+        }),
+      }),
+    );
+
+    expect(progressUpdates.length).toBe(2);
+  });
+
+  it("handles upload failure gracefully", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 500,
+      text: async () => "Internal Server Error",
+    });
+
+    const controller = new BackupController({
+      clientId: "test-err-client",
+      serverBaseUrl: "http://127.0.0.1:8888",
+      fileEnumerator: async () => ["file1.txt"],
+      fileReader: async () => "content",
+    });
+
+    await expect(controller.initiate()).rejects.toThrow(/Upload failed/i);
+  });
+});