shadow-claw 1.23.3 → 1.24.0

package/src/testing/jest-setup.ts

@@ -74,21 +74,6 @@ class MockWorker {
   terminate() {}
 }
 
-// Add generic Web APIs for JSDOM from Node globals
-globalThis.Response = global.Response;
-globalThis.Request = global.Request;
-globalThis.Headers = global.Headers;
-(globalThis as any).__PRERENDER_MAIN_MEMORY__ = false;
-
-if (typeof (globalThis as any).Worker === "undefined") {
-  (globalThis as any).Worker = MockWorker;
-}
-
-if (typeof globalThis.structuredClone !== "function") {
-  (globalThis as any).structuredClone = <T>(value: T): T =>
-    deserialize(serialize(value));
-}
-
 // Patch TextEncoder
 if (typeof globalThis.TextEncoder === "undefined") {
   (globalThis as any).TextEncoder = class TextEncoder {
@@ -101,10 +86,236 @@ if (typeof globalThis.TextEncoder === "undefined") {
 // Patch TextDecoder
 if (typeof globalThis.TextDecoder === "undefined") {
   (globalThis as any).TextDecoder = class TextDecoder {
-    decode(buf: Uint8Array): string {
-      return Buffer.from(buf).toString("utf-8");
+    decode(buf?: Uint8Array | ArrayBuffer): string {
+      if (!buf) return "";
+      if (buf instanceof Uint8Array) {
+        return Buffer.from(buf).toString("utf-8");
+      }
+      return Buffer.from(new Uint8Array(buf)).toString("utf-8");
+    }
+  };
+}
+
+// Polyfill HTMLDialogElement in JSDOM
+if (typeof globalThis.HTMLDialogElement !== "undefined") {
+  if (!globalThis.HTMLDialogElement.prototype.showModal) {
+    globalThis.HTMLDialogElement.prototype.showModal = function () {
+      this.setAttribute("open", "");
+    };
+  }
+  if (!globalThis.HTMLDialogElement.prototype.close) {
+    globalThis.HTMLDialogElement.prototype.close = function (
+      returnValue?: string,
+    ) {
+      this.removeAttribute("open");
+      if (returnValue !== undefined) {
+        this.returnValue = returnValue;
+      }
+    };
+  }
+}
+
+class MockHeaders {
+  private map = new Map<string, string>();
+  constructor(init?: any) {
+    if (init) {
+      if (typeof init.forEach === "function") {
+        init.forEach((v: string, k: string) =>
+          this.map.set(k.toLowerCase(), v),
+        );
+      } else if (Array.isArray(init)) {
+        for (const [k, v] of init) this.map.set(k.toLowerCase(), String(v));
+      } else if (typeof init === "object") {
+        for (const [k, v] of Object.entries(init)) {
+          if (v != null) this.map.set(k.toLowerCase(), String(v));
+        }
+      }
+    }
+  }
+  get(name: string) {
+    return this.map.get(name.toLowerCase()) ?? null;
+  }
+  set(name: string, value: string) {
+    this.map.set(name.toLowerCase(), String(value));
+  }
+  has(name: string) {
+    return this.map.has(name.toLowerCase());
+  }
+  delete(name: string) {
+    this.map.delete(name.toLowerCase());
+  }
+  forEach(callback: (value: string, key: string) => void) {
+    this.map.forEach((v, k) => callback(v, k));
+  }
+  entries() {
+    return this.map.entries();
+  }
+  keys() {
+    return this.map.keys();
+  }
+  values() {
+    return this.map.values();
+  }
+  [Symbol.iterator]() {
+    return this.map.entries();
+  }
+}
+
+class MockBlob {
+  private parts: any[];
+  public size: number;
+  public type: string;
+  constructor(parts?: any[], options?: { type?: string }) {
+    this.parts = parts || [];
+    this.type = options?.type || "";
+    this.size = this.parts.reduce(
+      (acc, p) =>
+        acc +
+        (p?.byteLength ||
+          p?.length ||
+          (typeof p === "string" ? Buffer.byteLength(p) : 0)),
+      0,
+    );
+  }
+  async arrayBuffer(): Promise<ArrayBuffer> {
+    const combined = new Uint8Array(this.size);
+    let offset = 0;
+    for (const p of this.parts) {
+      if (p instanceof Uint8Array) {
+        combined.set(p, offset);
+        offset += p.byteLength;
+      } else if (p instanceof ArrayBuffer) {
+        combined.set(new Uint8Array(p), offset);
+        offset += p.byteLength;
+      } else if (typeof p === "string") {
+        const encoded = new (globalThis as any).TextEncoder().encode(p);
+        combined.set(encoded, offset);
+        offset += encoded.byteLength;
+      }
+    }
+    return combined.buffer;
+  }
+  async text(): Promise<string> {
+    const ab = await this.arrayBuffer();
+    return new (globalThis as any).TextDecoder().decode(ab);
+  }
+  stream() {
+    let resolved = false;
+    let bytes: Uint8Array | null = null;
+    const blobPromise = this.arrayBuffer().then((ab) => {
+      bytes = new Uint8Array(ab);
+      resolved = true;
+    });
+    return new ReadableStream<Uint8Array>({
+      async start(controller) {
+        if (!resolved) await blobPromise;
+        if (bytes && bytes.byteLength > 0) controller.enqueue(bytes);
+        controller.close();
+      },
+    });
+  }
+}
+
+class MockResponse {
+  body: any;
+  headers: any;
+  status: number;
+  statusText: string;
+  ok: boolean;
+  constructor(body?: any, init?: any) {
+    this.body = body;
+    this.status = init?.status ?? 200;
+    this.statusText = init?.statusText ?? (this.status === 200 ? "OK" : "");
+    this.ok = this.status >= 200 && this.status < 300;
+    const HeadersClass = (globalThis as any).Headers || MockHeaders;
+    this.headers =
+      init?.headers instanceof HeadersClass
+        ? init.headers
+        : new HeadersClass(init?.headers);
+  }
+  async json() {
+    if (typeof this.body === "string") return JSON.parse(this.body);
+    if (this.body instanceof Uint8Array) {
+      return JSON.parse(Buffer.from(this.body).toString("utf-8"));
+    }
+    return this.body;
+  }
+  async text() {
+    if (typeof this.body === "string") return this.body;
+    if (this.body instanceof Uint8Array) {
+      return Buffer.from(this.body).toString("utf-8");
+    }
+    if (this.body && typeof this.body.text === "function") {
+      return this.body.text();
+    }
+    return String(this.body ?? "");
+  }
+  async arrayBuffer() {
+    if (this.body instanceof Uint8Array) {
+      return this.body.buffer.slice(
+        this.body.byteOffset,
+        this.body.byteOffset + this.body.byteLength,
+      );
+    }
+    if (this.body instanceof ArrayBuffer) return this.body;
+    if (this.body && typeof this.body.arrayBuffer === "function") {
+      return this.body.arrayBuffer();
+    }
+    if (typeof this.body === "string") {
+      return new (globalThis as any).TextEncoder().encode(this.body).buffer;
+    }
+    return new ArrayBuffer(0);
+  }
+  async blob() {
+    if (this.body instanceof (globalThis as any).Blob) return this.body;
+    const ab = await this.arrayBuffer();
+    const BlobClass = (globalThis as any).Blob || MockBlob;
+    return new BlobClass([ab]);
+  }
+}
+
+if (typeof (globalThis as any).Headers === "undefined") {
+  (globalThis as any).Headers = MockHeaders;
+  (global as any).Headers = MockHeaders;
+}
+
+if (typeof (globalThis as any).Blob === "undefined") {
+  (globalThis as any).Blob = MockBlob;
+  (global as any).Blob = MockBlob;
+}
+
+if (typeof (globalThis as any).Response === "undefined") {
+  (globalThis as any).Response = MockResponse;
+  (global as any).Response = MockResponse;
+}
+
+if (typeof (globalThis as any).Request === "undefined") {
+  (globalThis as any).Request = class MockRequest {
+    url: string;
+    method: string;
+    headers: any;
+    constructor(input: any, init?: any) {
+      this.url = typeof input === "string" ? input : input?.url || "";
+      this.method = init?.method || "GET";
+      const HeadersClass = (globalThis as any).Headers || MockHeaders;
+      this.headers =
+        init?.headers instanceof HeadersClass
+          ? init.headers
+          : new HeadersClass(init?.headers);
     }
   };
+  (global as any).Request = (globalThis as any).Request;
+}
+
+(globalThis as any).__PRERENDER_MAIN_MEMORY__ = false;
+
+if (typeof (globalThis as any).Worker === "undefined") {
+  (globalThis as any).Worker = MockWorker;
+}
+
+if (typeof globalThis.structuredClone !== "function") {
+  (globalThis as any).structuredClone = <T>(value: T): T =>
+    deserialize(serialize(value));
 }
 
 // Implement a filesystem-aware fetch for component templates/styles
@@ -117,7 +328,7 @@ globalThis.fetch = jest.fn((url: string | URL | Request) => {
       statusText: "OK",
       text: () => Promise.resolve(""),
       json: () => Promise.resolve({}),
-      blob: () => Promise.resolve(new Blob()),
+      blob: () => Promise.resolve(new (globalThis as any).Blob()),
       arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
     } as Response);
   }
@@ -163,7 +374,7 @@ globalThis.fetch = jest.fn((url: string | URL | Request) => {
       ok: true,
       text: () => Promise.resolve(content),
       json: () => Promise.resolve(JSON.parse(content)),
-      blob: () => Promise.resolve(new Blob([content])),
+      blob: () => Promise.resolve(new (globalThis as any).Blob([content])),
       arrayBuffer: () => Promise.resolve(Buffer.from(content).buffer),
     } as Response);
   } catch (err) {
@@ -178,6 +389,66 @@ globalThis.fetch = jest.fn((url: string | URL | Request) => {
 (globalThis as any).WritableStream = WritableStream;
 (globalThis as any).AudioContext = MockAudioContext;
 
+// Polyfill ResizeObserver for JSDOM
+if (typeof globalThis.ResizeObserver === "undefined") {
+  (globalThis as any).ResizeObserver = class MockResizeObserver {
+    callback: ResizeObserverCallback;
+    constructor(callback: ResizeObserverCallback) {
+      this.callback = callback;
+    }
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+  };
+}
+
+const BaseMouseEvent: any =
+  typeof globalThis.MouseEvent !== "undefined"
+    ? globalThis.MouseEvent
+    : typeof globalThis.Event !== "undefined"
+      ? globalThis.Event
+      : class MockEvent {
+          type: string;
+          bubbles: boolean;
+          cancelable: boolean;
+          defaultPrevented = false;
+          constructor(type: string, init?: any) {
+            this.type = type;
+            this.bubbles = init?.bubbles ?? false;
+            this.cancelable = init?.cancelable ?? false;
+          }
+          preventDefault() {
+            this.defaultPrevented = true;
+          }
+          stopPropagation() {}
+        };
+
+if (typeof globalThis.PointerEvent === "undefined") {
+  (globalThis as any).PointerEvent = class PointerEvent extends BaseMouseEvent {
+    pointerId: number;
+    pointerType: string;
+    clientX: number;
+    clientY: number;
+    constructor(type: string, init?: any) {
+      super(type, init);
+      this.pointerId = init?.pointerId ?? 0;
+      this.pointerType = init?.pointerType ?? "mouse";
+      this.clientX = init?.clientX ?? 0;
+      this.clientY = init?.clientY ?? 0;
+    }
+  };
+}
+
+if (typeof globalThis.DragEvent === "undefined") {
+  (globalThis as any).DragEvent = class DragEvent extends BaseMouseEvent {
+    dataTransfer: any;
+    constructor(type: string, init?: any) {
+      super(type, init);
+      this.dataTransfer = init?.dataTransfer ?? null;
+    }
+  };
+}
+
 // Polyfill CSSStyleSheet and adoptedStyleSheets for JSDOM
 if (typeof globalThis.CSSStyleSheet === "undefined") {
   (globalThis as any).CSSStyleSheet = class MockCSSStyleSheet {
@@ -201,24 +472,26 @@ if (typeof globalThis.CSSStyleSheet === "undefined") {
   }
 }
 
-Object.defineProperty(ShadowRoot.prototype, "adoptedStyleSheets", {
-  configurable: true,
-  set(sheets: any[]) {
-    (this as any)._adoptedStyleSheets = sheets;
-    if (Array.isArray(sheets)) {
-      sheets.forEach((sheet) => {
-        if (sheet._css) {
-          const style = document.createElement("style");
-          style.textContent = sheet._css;
-          this.appendChild(style);
-        }
-      });
-    }
-  },
-  get() {
-    return (this as any)._adoptedStyleSheets || [];
-  },
-});
+if (typeof ShadowRoot !== "undefined") {
+  Object.defineProperty(ShadowRoot.prototype, "adoptedStyleSheets", {
+    configurable: true,
+    set(sheets: any[]) {
+      (this as any)._adoptedStyleSheets = sheets;
+      if (Array.isArray(sheets)) {
+        sheets.forEach((sheet) => {
+          if (sheet._css) {
+            const style = document.createElement("style");
+            style.textContent = sheet._css;
+            this.appendChild(style);
+          }
+        });
+      }
+    },
+    get() {
+      return (this as any)._adoptedStyleSheets || [];
+    },
+  });
+}
 
 const originalConsoleError = console.error;
 const originalConsoleWarn = console.warn;
@@ -243,11 +516,14 @@ const expectedLogs = [
   "PeerJsChannel: connected to signaling server",
   "PeerJsChannel: connection opened with",
   "PeerJsChannel: rejecting connection from untrusted peer:",
+  "PeerJsChannel: connection closed with",
   "[WebVM] Ignoring invalid VM boot host:",
   "[WebVM] Ignoring invalid VM relay URL:",
-  "[WebVM:ui] Starting boot - checking assets...",
-  "[WebVM boot] Mode",
-  "[WebVM:ui] Assets not found.",
+  "[WebVM]",
+  "[WebVM:ui]",
+  "[WebVM boot]",
+  "[shadow-claw-a2ui] Failed to load workspace",
+  "[shadow-claw-a2ui] groupId not set, cannot resolve workspace files",
   "Failed to fetch Vertex AI models dynamically:",
   "Vertex AI proxy error:",
   "Error: Not implemented: navigation (except hash changes)",
@@ -276,6 +552,18 @@ const expectedLogs = [
   "[Security] Registration blocked:",
   "[Security] Removing unapproved custom element:",
   "Failed to retrieve local storage handle from DB:",
+  "fetch proxy: config updated",
+  "Error reaching huggingface.co:",
+  "Error reaching hf-mirror.com:",
+  "Hugging Face main domain unreachable",
+  "writePartialMeta error:",
+  "flushChunkToCache error:",
+  "[Proxy] Llamafile runtime:",
+  "[Proxy] Mesh LLM request for model:",
+  "[Proxy] Fetching Mesh LLM catalog...",
+  "Ollama invoke error:",
+  "Ollama models discovery error:",
+  "Failed to check Prompt API onboarding:",
 ];
 
 function isExpectedLog(...args: any[]) {

package/src/testing/mock-v86.mjs

@@ -0,0 +1,49 @@
+export class V86 {
+  constructor(options) {
+    this.options = options;
+    this.listeners = new Map();
+    this.serial0_send = (text) => {
+      if (text === "root\n") {
+        setTimeout(() => {
+          this.emitSerial("# ");
+        }, 10);
+      }
+    };
+    this.destroy = () => Promise.resolve();
+    this.fs9p = {
+      read_dir: () => [],
+      SearchPath: () => ({ id: 1 }),
+      IsDirectory: () => true,
+    };
+    this.create_file = () => Promise.resolve();
+    this.read_file = () => Promise.resolve(new Uint8Array([1, 2, 3]));
+
+    // Auto-emit boot sequence
+    setTimeout(() => {
+      this.emitSerial("Booting Linux...\nlogin: ");
+    }, 10);
+  }
+
+  add_listener(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, new Set());
+    }
+    this.listeners.get(event).add(listener);
+  }
+
+  remove_listener(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+  }
+
+  emitSerial(text) {
+    const serialListeners = this.listeners.get("serial0-output-byte");
+    if (!serialListeners) return;
+    for (const ch of text) {
+      for (const listener of serialListeners) {
+        listener(ch.charCodeAt(0));
+      }
+    }
+  }
+}
+
+export default V86;

package/src/ui/a2ui/types.ts

@@ -423,7 +423,7 @@ export interface ColumnSpec extends ComponentCommon {
   align?: AlignValue;
 }
 
-export type ButtonVariant = "default" | "primary" | "borderless";
+export type ButtonVariant = "default" | "primary" | "secondary" | "borderless";
 
 /**
  * A2UI v1.0 spec §actions: server action event sent when a button is clicked.
@@ -571,6 +571,7 @@ export interface CheckBoxSpec extends ComponentCommon, CheckableComponent {
   component: "CheckBox";
   label: DynamicString;
   value: DynamicBoolean;
+  action?: A2UIActionDescriptor;
 }
 
 export interface ChoicePickerOption {
@@ -592,14 +593,14 @@ export interface SliderSpec extends ComponentCommon, CheckableComponent {
   component: "Slider";
   label?: DynamicString;
   min?: number;
-  max: number;
+  max?: number;
   value: DynamicNumber;
   steps?: number;
 }
 
 export interface DateTimeInputSpec extends ComponentCommon, CheckableComponent {
   component: "DateTimeInput";
-  value: DynamicString;
+  value?: DynamicString;
   enableDate?: boolean;
   enableTime?: boolean;
   min?: DynamicString;

package/src/ui/a2ui/utils/normaliseComponentsToMap.test.ts

@@ -0,0 +1,102 @@
+import { jest } from "@jest/globals";
+import { normaliseComponentsToMap } from "./normaliseComponentsToMap.js";
+
+describe("normaliseComponentsToMap", () => {
+  it("normalises a flat list of component specs", () => {
+    const specs = [
+      { id: "root", component: "Column", children: ["c1", "c2"] },
+      { id: "c1", component: "Text", text: "Hello" },
+      { id: "c2", component: "Button", text: "Submit" },
+    ] as any;
+
+    const map = normaliseComponentsToMap(specs);
+    expect(map["root"]).toEqual(specs[0]);
+    expect(map["c1"]).toEqual(specs[1]);
+    expect(map["c2"]).toEqual(specs[2]);
+  });
+
+  it("walks nested children array objects", () => {
+    const specs = [
+      {
+        id: "root",
+        component: "Column",
+        children: [
+          { id: "nested1", component: "Text", text: "Nested 1" },
+          { id: "nested2", component: "Text", text: "Nested 2" },
+        ],
+      },
+    ] as any;
+
+    const map = normaliseComponentsToMap(specs);
+    expect(map["root"]).toBeDefined();
+    expect(map["nested1"]).toEqual({
+      id: "nested1",
+      component: "Text",
+      text: "Nested 1",
+    });
+    expect(map["nested2"]).toEqual({
+      id: "nested2",
+      component: "Text",
+      text: "Nested 2",
+    });
+  });
+
+  it("does not walk children if children[0] is a template specification", () => {
+    const specs = [
+      {
+        id: "root",
+        component: "Column",
+        children: [{ path: "/items", componentId: "tmpl" }],
+      },
+    ] as any;
+
+    const map = normaliseComponentsToMap(specs);
+    expect(map["root"]).toBeDefined();
+    expect(Object.keys(map)).toEqual(["root"]);
+  });
+
+  it("walks nested child object and nested tabs", () => {
+    const specs = [
+      {
+        id: "card1",
+        component: "Card",
+        child: { id: "cardInner", component: "Text", text: "Inside Card" },
+      },
+      {
+        id: "tabs1",
+        component: "Tabs",
+        tabs: [
+          { title: "Tab 1", child: { id: "tabContent1", component: "Text" } },
+          { title: "Tab 2", child: { id: "tabContent2", component: "Text" } },
+        ],
+      },
+    ] as any;
+
+    const map = normaliseComponentsToMap(specs);
+    expect(map["card1"]).toBeDefined();
+    expect(map["cardInner"]).toBeDefined();
+    expect(map["tabs1"]).toBeDefined();
+    expect(map["tabContent1"]).toBeDefined();
+    expect(map["tabContent2"]).toBeDefined();
+  });
+
+  it("warns and skips components missing id field", () => {
+    const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+    const specs = [
+      null,
+      "invalid-primitive" as any,
+      { component: "Text", text: "No ID" },
+      { customField: 123 },
+    ] as any;
+
+    const map = normaliseComponentsToMap(specs);
+    expect(map).toEqual({});
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining(
+        "Component missing required 'id' field; skipped.",
+      ),
+      expect.anything(),
+    );
+    warnSpy.mockRestore();
+  });
+});

package/src/ui/a2ui/utils/resolveChildIds.test.ts

@@ -0,0 +1,63 @@
+import { jest } from "@jest/globals";
+import { resolveChildIds } from "./resolveChildIds.js";
+
+describe("resolveChildIds", () => {
+  it("returns fixed string array as-is", () => {
+    const children = ["child1", "child2", "child3"];
+    expect(resolveChildIds(children, {})).toEqual([
+      "child1",
+      "child2",
+      "child3",
+    ]);
+  });
+
+  it("handles template specification object and generates dynamic IDs", () => {
+    const template = { path: "/items", componentId: "item" };
+    const dataModel = { items: ["apple", "banana", "cherry"] };
+    expect(resolveChildIds(template, dataModel)).toEqual([
+      "item_0",
+      "item_1",
+      "item_2",
+    ]);
+  });
+
+  it("handles array containing a single template object", () => {
+    const children = [{ path: "/users", componentId: "user_card" }] as any;
+    const dataModel = { users: [{ name: "Alice" }, { name: "Bob" }] };
+    expect(resolveChildIds(children, dataModel)).toEqual([
+      "user_card_0",
+      "user_card_1",
+    ]);
+  });
+
+  it("handles array containing nested component objects with IDs", () => {
+    const children = [
+      { id: "comp1", component: "Text" },
+      { id: "comp2", component: "Button" },
+    ] as any;
+    expect(resolveChildIds(children, {})).toEqual(["comp1", "comp2"]);
+  });
+
+  it("returns empty array for nested component objects without IDs", () => {
+    const children = [{ component: "Text" }] as any;
+    expect(resolveChildIds(children, {})).toEqual([]);
+  });
+
+  it("warns and returns empty array if template path does not resolve to an array", () => {
+    const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+    const template = { path: "/notAnArray", componentId: "item" };
+    const dataModel = { notAnArray: "string value" };
+
+    expect(resolveChildIds(template, dataModel)).toEqual([]);
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining(
+        'ChildList template path "/notAnArray" did not resolve to an array.',
+      ),
+    );
+    warnSpy.mockRestore();
+  });
+
+  it("handles empty array gracefully", () => {
+    expect(resolveChildIds([], {})).toEqual([]);
+  });
+});

package/src/ui/a2ui/utils/resolveDynamicNumber.test.ts

@@ -9,7 +9,19 @@ describe("resolveDynamicNumber", () => {
     expect(resolveDynamicNumber({ path: "/n" }, { n: 7 })).toBe(7);
   });
 
-  it("returns 0 for null", () => {
+  it("resolves a $dataModel reference", () => {
+    expect(resolveDynamicNumber({ $dataModel: "/count" }, { count: 99 })).toBe(
+      99,
+    );
+  });
+
+  it("returns 0 for null or undefined", () => {
     expect(resolveDynamicNumber(null, {})).toBe(0);
+    expect(resolveDynamicNumber(undefined, {})).toBe(0);
+  });
+
+  it("returns 0 for invalid objects without path or $dataModel", () => {
+    expect(resolveDynamicNumber({} as any, {})).toBe(0);
+    expect(resolveDynamicNumber("not-a-number" as any, {})).toBe(0);
   });
 });