shadow-claw 1.23.3 → 1.24.0

package/src/core/app-routes.test.ts

@@ -5,6 +5,7 @@ import {
   getDeploymentNamespace,
   getFileRouteDirPath,
   getWorkspaceRouteRequestPath,
+  isPossibleAppRoute,
   parseRouteFromUrl,
   resolveHrefAgainstRoute,
 } from "./app-routes.js";
@@ -148,11 +149,17 @@ describe("app-routes", () => {
   describe("applyBasePath", () => {
     // Reset cached base path between tests
     beforeEach(() => {
+      document.querySelectorAll("base").forEach((el) => el.remove());
       // Force-reset the module-level cache so each sub-test starts fresh.
       // We do this by temporarily reassigning window.location via jsdom.
       (globalThis as any).__applyBasePathCacheReset?.();
     });
 
+    afterEach(() => {
+      document.querySelectorAll("base").forEach((el) => el.remove());
+      (globalThis as any).__applyBasePathCacheReset?.();
+    });
+
     it("returns path unchanged when base is root", () => {
       // In jsdom the default base path resolves to "/"
       expect(applyBasePath("/chat")).toBe("/chat");
@@ -191,6 +198,55 @@ describe("app-routes", () => {
         anchor: undefined,
       });
     });
+
+    it("handles explicit subpath <base href> tag correctly for all workspace routes", () => {
+      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 {
+        expect(getAppBasePath()).toBe("/shadow-claw/");
+
+        // Workspace file route extraction with subpath prefix
+        expect(
+          getWorkspaceRouteRequestPath(
+            "/shadow-claw/files/main/01M1A1R4Y708YJNPGV2NHQKYF7-IMG_0233.jpeg",
+          ),
+        ).toEqual({
+          groupId: "br:main",
+          path: "01M1A1R4Y708YJNPGV2NHQKYF7-IMG_0233.jpeg",
+        });
+
+        // isPossibleAppRoute validation
+        expect(
+          isPossibleAppRoute(
+            "/shadow-claw/files/main/01M1A1R4Y708YJNPGV2NHQKYF7-IMG_0233.jpeg",
+          ),
+        ).toBe(true);
+
+        // Path without base prefix should NOT match app routes
+        expect(
+          isPossibleAppRoute(
+            "/files/main/01M1A1R4Y708YJNPGV2NHQKYF7-IMG_0233.jpeg",
+          ),
+        ).toBe(false);
+
+        // resolveHrefAgainstRoute with subpath routeDir
+        const resolved = resolveHrefAgainstRoute(
+          "01M1A1R4Y708YJNPGV2NHQKYF7-IMG_0233.jpeg",
+          applyBasePath(getFileRouteDirPath("br:main", "index.md")),
+          "http://localhost",
+        );
+        expect(resolved?.pathname).toBe(
+          "/shadow-claw/files/main/01M1A1R4Y708YJNPGV2NHQKYF7-IMG_0233.jpeg",
+        );
+      } finally {
+        baseEl.remove();
+        (globalThis as any).__applyBasePathCacheReset?.();
+      }
+    });
   });
 
   describe("pretty path routing", () => {

package/src/core/app-routes.ts

@@ -551,7 +551,14 @@ export function getFileRouteDirPath(groupId: string, filePath: string): string {
 export function getWorkspaceRouteRequestPath(
   pathname: string,
 ): { groupId: string; path: string } | null {
-  const parts = pathname
+  let relativePath = pathname;
+  const basePath = getAppBasePath();
+
+  if (basePath !== "/" && relativePath.startsWith(basePath)) {
+    relativePath = "/" + relativePath.slice(basePath.length);
+  }
+
+  const parts = relativePath
     .split("/")
     .filter(Boolean)
     .map((part) => decodePathSegment(part));

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);
+  });
+});

package/src/core/backup-controller.ts

@@ -0,0 +1,137 @@
+/**
+ * ShadowClaw — Client-Side Backup Controller
+ *
+ * Orchestrates workspace file backups from the browser client's OPFS / local storage
+ * to the server via the `/api/backup/*` REST endpoints.
+ */
+
+import { ulid } from "../utils/ulid.js";
+
+export interface BackupProgress {
+  current: number;
+  total: number;
+  file: string;
+}
+
+export interface BackupControllerOptions {
+  clientId: string;
+  token?: string;
+  serverBaseUrl?: string;
+  fileEnumerator?: () => Promise<string[]>;
+  fileReader?: (path: string) => Promise<string | Uint8Array | null>;
+  onProgress?: (progress: BackupProgress) => void;
+}
+
+export interface BackupInitiateResult {
+  success: boolean;
+  backupId: string;
+  fileCount: number;
+  totalBytes: number;
+}
+
+export class BackupController {
+  private _clientId: string;
+  private _token?: string;
+  private _serverBaseUrl: string;
+  private _fileEnumerator: () => Promise<string[]>;
+  private _fileReader: (path: string) => Promise<string | Uint8Array | null>;
+  private _onProgress?: (progress: BackupProgress) => void;
+
+  constructor(options: BackupControllerOptions) {
+    this._clientId = options.clientId;
+    this._token = options.token;
+    this._serverBaseUrl = options.serverBaseUrl || "";
+    this._fileEnumerator = options.fileEnumerator || (async () => []);
+    this._fileReader = options.fileReader || (async () => null);
+    this._onProgress = options.onProgress;
+  }
+
+  public async initiate(): Promise<BackupInitiateResult> {
+    const backupId = ulid();
+    const files = await this._fileEnumerator();
+    let totalBytes = 0;
+    let uploadedCount = 0;
+
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+    };
+    if (this._token) {
+      headers["x-control-token"] = this._token;
+    }
+
+    for (let i = 0; i < files.length; i++) {
+      const filePath = files[i];
+      const data = await this._fileReader(filePath);
+
+      if (data === null || data === undefined) {
+        continue;
+      }
+
+      let contentStr: string;
+      let encoding = "utf-8";
+
+      if (typeof data === "string") {
+        contentStr = data;
+        totalBytes += Buffer.from(data, "utf-8").length;
+      } else {
+        contentStr = Buffer.from(data).toString("base64");
+        encoding = "base64";
+        totalBytes += data.byteLength || data.length || 0;
+      }
+
+      const uploadUrl = `${this._serverBaseUrl}/api/backup/upload`;
+      const res = await fetch(uploadUrl, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          clientId: this._clientId,
+          backupId,
+          path: filePath,
+          content: contentStr,
+          encoding,
+        }),
+      });
+
+      if (!res.ok) {
+        const errorText = await res.text().catch(() => res.statusText);
+        throw new Error(
+          `Upload failed for ${filePath} (${res.status}): ${errorText}`,
+        );
+      }
+
+      uploadedCount++;
+      this._onProgress?.({
+        current: uploadedCount,
+        total: files.length,
+        file: filePath,
+      });
+    }
+
+    // Finalize backup
+    const completeUrl = `${this._serverBaseUrl}/api/backup/complete`;
+    const completeRes = await fetch(completeUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        clientId: this._clientId,
+        backupId,
+        fileCount: uploadedCount,
+        totalBytes,
+      }),
+    });
+
+    if (!completeRes.ok) {
+      const errorText = await completeRes
+        .text()
+        .catch(() => completeRes.statusText);
+      throw new Error(`Failed to complete backup: ${errorText}`);
+    }
+
+    return {
+      success: true,
+      backupId,
+      fileCount: uploadedCount,
+      totalBytes,
+    };
+  }
+}