@aprovan/mcp-app-server 0.1.0-dev.4d82df8

package/src/widget-store/index.ts

@@ -0,0 +1,10 @@
+export { WidgetStore, getWidgetStore, resetWidgetStore } from "./store.js";
+export { LocalFileBackend } from "./local-backend.js";
+export type {
+  FSProvider,
+  FileStats,
+  DirEntry,
+  StoredWidget,
+  StoredWidgetInfo,
+  WidgetStoreOptions,
+} from "./types.js";

package/src/widget-store/local-backend.ts

@@ -0,0 +1,77 @@
+import { readFile, writeFile, unlink, stat, mkdir, readdir, rm, access } from "node:fs/promises";
+import { join, dirname, normalize } from "node:path";
+import type { DirEntry, FileStats, FSProvider } from "./types.js";
+
+function createDirEntry(name: string, isDir: boolean): DirEntry {
+  return {
+    name,
+    isFile: () => !isDir,
+    isDirectory: () => isDir,
+  };
+}
+
+function createFileStats(size: number, mtime: Date, isDir: boolean): FileStats {
+  return {
+    size,
+    mtime,
+    isFile: () => !isDir,
+    isDirectory: () => isDir,
+  };
+}
+
+export class LocalFileBackend implements FSProvider {
+  constructor(private basePath: string) {}
+
+  private resolve(path: string): string {
+    return join(this.basePath, normalize(path));
+  }
+
+  async readFile(path: string): Promise<string> {
+    return readFile(this.resolve(path), "utf-8");
+  }
+
+  async writeFile(path: string, content: string): Promise<void> {
+    const fullPath = this.resolve(path);
+    await mkdir(dirname(fullPath), { recursive: true });
+    await writeFile(fullPath, content, "utf-8");
+  }
+
+  async unlink(path: string): Promise<void> {
+    await unlink(this.resolve(path));
+  }
+
+  async stat(path: string): Promise<FileStats> {
+    const fullPath = this.resolve(path);
+    const s = await stat(fullPath);
+    return createFileStats(s.size, s.mtime, s.isDirectory());
+  }
+
+  async mkdir(path: string, options?: { recursive?: boolean }): Promise<void> {
+    await mkdir(this.resolve(path), options);
+  }
+
+  async readdir(path: string): Promise<DirEntry[]> {
+    const fullPath = this.resolve(path);
+    const entries = await readdir(fullPath, { withFileTypes: true });
+    return entries.map((e) =>
+      createDirEntry(e.name, e.isDirectory()),
+    );
+  }
+
+  async rmdir(path: string, options?: { recursive?: boolean }): Promise<void> {
+    if (options?.recursive) {
+      await rm(this.resolve(path), { recursive: true, force: true });
+    } else {
+      await rm(this.resolve(path), { force: true });
+    }
+  }
+
+  async exists(path: string): Promise<boolean> {
+    try {
+      await access(this.resolve(path));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

package/src/widget-store/store.ts

@@ -0,0 +1,242 @@
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { LocalFileBackend } from "./local-backend.js";
+import type { FSProvider, StoredWidget, StoredWidgetInfo, WidgetStoreOptions } from "./types.js";
+import type { Manifest, VirtualFile } from "@aprovan/patchwork-compiler";
+
+const WIDGETS_PREFIX = "widgets";
+const FILES_SUBDIR = "files";
+const RESOURCE_URI_PREFIX = "ui://widgets/";
+
+function getDefaultStorageDir(): string {
+  // Use WIDGET_STORE_PATH env var, or fall back to ~/.patchwork/widget-store
+  return process.env["WIDGET_STORE_PATH"] ?? join(homedir(), ".patchwork", "widget-store");
+}
+
+interface StoredManifest extends Manifest {
+  entry: string;
+  createdAt: number;
+}
+
+/**
+ * Persistent store for **raw, uncompiled** widget source files.
+ *
+ * Widgets are saved as their original `.tsx`/`.ts` files plus a `manifest.json`;
+ * compilation happens in the browser via the shared `@aprovan/patchwork-compiler`
+ * runtime when the widget is rendered. Layout:
+ *
+ * ```
+ * widgets/<name>/<hash>/
+ *   files/main.tsx
+ *   files/price-card.tsx
+ *   manifest.json   { ...manifest, entry, createdAt }
+ * ```
+ */
+export class WidgetStore {
+  private provider: FSProvider;
+  private storageDir: string;
+
+  constructor(options: WidgetStoreOptions = {}) {
+    this.storageDir = resolve(options.storageDir ?? getDefaultStorageDir());
+    this.provider = options.backend ?? new LocalFileBackend(this.storageDir);
+  }
+
+  private fullPath(virtualPath: string): string {
+    return join(WIDGETS_PREFIX, virtualPath);
+  }
+
+  private async readFilesRecursive(dir: string, base = ""): Promise<VirtualFile[]> {
+    const files: VirtualFile[] = [];
+    let entries;
+    try {
+      entries = await this.provider.readdir(dir);
+    } catch {
+      return files;
+    }
+    for (const entry of entries) {
+      const childDir = join(dir, entry.name);
+      const relPath = base ? `${base}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        files.push(...(await this.readFilesRecursive(childDir, relPath)));
+      } else {
+        const content = await this.provider.readFile(childDir);
+        files.push({ path: relPath, content });
+      }
+    }
+    return files;
+  }
+
+  async saveWidget(
+    hash: string,
+    files: VirtualFile[],
+    manifest: Manifest,
+    entry: string,
+  ): Promise<StoredWidget> {
+    const widgetDir = `${manifest.name}/${hash}`;
+    const createdAt = Date.now();
+
+    await Promise.all(
+      files.map((file) =>
+        this.provider.writeFile(
+          this.fullPath(`${widgetDir}/${FILES_SUBDIR}/${file.path}`),
+          file.content,
+        ),
+      ),
+    );
+
+    const storedManifest: StoredManifest = { ...manifest, entry, createdAt };
+    await this.provider.writeFile(
+      this.fullPath(`${widgetDir}/manifest.json`),
+      JSON.stringify(storedManifest),
+    );
+
+    return {
+      path: this.fullPath(widgetDir),
+      resourceUri: `${RESOURCE_URI_PREFIX}${widgetDir}/view.html`,
+      files,
+      entry,
+      manifest,
+      createdAt,
+    };
+  }
+
+  async getWidget(name: string, hash: string): Promise<StoredWidget | null> {
+    const widgetDir = `${name}/${hash}`;
+    const manifestVirtualPath = this.fullPath(`${widgetDir}/manifest.json`);
+
+    const exists = await this.provider.exists(manifestVirtualPath);
+    if (!exists) return null;
+
+    const files = await this.readFilesRecursive(this.fullPath(`${widgetDir}/${FILES_SUBDIR}`));
+
+    let manifest: Manifest;
+    let entry = files[0]?.path ?? "main.tsx";
+    let createdAt = Date.now();
+    try {
+      const raw = await this.provider.readFile(manifestVirtualPath);
+      const parsed = JSON.parse(raw) as Partial<StoredManifest>;
+      manifest = {
+        name: (parsed.name as string) ?? name,
+        version: (parsed.version as string) ?? "0.1.0",
+        platform: parsed.platform ?? "browser",
+        image: (parsed.image as string) ?? "@aprovan/patchwork-image-shadcn",
+        description: parsed.description,
+        services: parsed.services,
+      };
+      if (parsed.entry) entry = parsed.entry;
+      if (typeof parsed.createdAt === "number") createdAt = parsed.createdAt;
+    } catch {
+      manifest = {
+        name,
+        version: "0.1.0",
+        platform: "browser",
+        image: "@aprovan/patchwork-image-shadcn",
+      };
+    }
+
+    return {
+      path: this.fullPath(widgetDir),
+      resourceUri: `${RESOURCE_URI_PREFIX}${widgetDir}/view.html`,
+      files,
+      entry,
+      manifest,
+      createdAt,
+    };
+  }
+
+  async listWidgets(): Promise<StoredWidgetInfo[]> {
+    const results: StoredWidgetInfo[] = [];
+    const rootPath = this.fullPath("");
+
+    try {
+      const names = await this.provider.readdir(rootPath);
+      for (const nameEntry of names) {
+        if (!nameEntry.isDirectory()) continue;
+        const name = nameEntry.name;
+
+        try {
+          const hashes = await this.provider.readdir(join(rootPath, name));
+          for (const hashEntry of hashes) {
+            if (!hashEntry.isDirectory()) continue;
+            const hash = hashEntry.name;
+            const manifestVirtualPath = this.fullPath(`${name}/${hash}/manifest.json`);
+
+            let manifest: Partial<StoredManifest> = {};
+            try {
+              const raw = await this.provider.readFile(manifestVirtualPath);
+              manifest = JSON.parse(raw) as Partial<StoredManifest>;
+            } catch {
+              continue;
+            }
+
+            results.push({
+              path: this.fullPath(`${name}/${hash}`),
+              resourceUri: `${RESOURCE_URI_PREFIX}${name}/${hash}/view.html`,
+              name: manifest.name ?? name,
+              version: manifest.version ?? "0.1.0",
+              description: manifest.description,
+              services: manifest.services,
+              entry: manifest.entry,
+              createdAt: manifest.createdAt ?? 0,
+            });
+          }
+        } catch {
+          continue;
+        }
+      }
+    } catch {
+      return results;
+    }
+
+    return results.sort((a, b) => b.createdAt - a.createdAt);
+  }
+
+  async deleteWidget(name: string, hash: string): Promise<boolean> {
+    const widgetDir = this.fullPath(`${name}/${hash}`);
+    const exists = await this.provider.exists(widgetDir);
+    if (!exists) return false;
+
+    await this.provider.rmdir(widgetDir, { recursive: true });
+    return true;
+  }
+
+  async hasWidget(name: string, hash: string): Promise<boolean> {
+    return this.provider.exists(this.fullPath(`${name}/${hash}/manifest.json`));
+  }
+
+  resourceUriFor(name: string, hash: string): string {
+    return `${RESOURCE_URI_PREFIX}${name}/${hash}/view.html`;
+  }
+
+  async loadAll(): Promise<StoredWidget[]> {
+    const infos = await this.listWidgets();
+    const widgets: StoredWidget[] = [];
+
+    for (const info of infos) {
+      const uriPath = info.resourceUri.replace(RESOURCE_URI_PREFIX, "").replace(/\/view\.html$/, "");
+      const parts = uriPath.split("/");
+      const name = parts[0];
+      const hash = parts[1];
+
+      if (!name || !hash) continue;
+
+      const widget = await this.getWidget(name, hash);
+      if (widget) widgets.push(widget);
+    }
+
+    return widgets;
+  }
+}
+
+let _instance: WidgetStore | null = null;
+
+export function getWidgetStore(options?: WidgetStoreOptions): WidgetStore {
+  if (!_instance) {
+    _instance = new WidgetStore(options);
+  }
+  return _instance;
+}
+
+export function resetWidgetStore(): void {
+  _instance = null;
+}

package/src/widget-store/types.ts

@@ -0,0 +1,53 @@
+import type { Manifest, VirtualFile } from "@aprovan/patchwork-compiler";
+
+export interface FileStats {
+  size: number;
+  mtime: Date;
+  isFile(): boolean;
+  isDirectory(): boolean;
+}
+
+export interface DirEntry {
+  name: string;
+  isFile(): boolean;
+  isDirectory(): boolean;
+}
+
+export interface FSProvider {
+  readFile(path: string, encoding?: "utf8" | "base64"): Promise<string>;
+  writeFile(path: string, content: string): Promise<void>;
+  unlink(path: string): Promise<void>;
+  stat(path: string): Promise<FileStats>;
+  mkdir(path: string, options?: { recursive?: boolean }): Promise<void>;
+  readdir(path: string): Promise<DirEntry[]>;
+  rmdir(path: string, options?: { recursive?: boolean }): Promise<void>;
+  exists(path: string): Promise<boolean>;
+}
+
+export interface StoredWidget {
+  /** Storage path of the widget directory (e.g. "widgets/timer/abc123"). */
+  path: string;
+  resourceUri: string;
+  /** Raw, uncompiled widget source files. Compilation happens in the browser. */
+  files: VirtualFile[];
+  /** Entry file path within {@link files} (e.g. "main.tsx"). */
+  entry: string;
+  manifest: Manifest;
+  createdAt: number;
+}
+
+export interface StoredWidgetInfo {
+  path: string;
+  resourceUri: string;
+  name: string;
+  version: string;
+  description?: string;
+  services?: string[];
+  entry?: string;
+  createdAt: number;
+}
+
+export interface WidgetStoreOptions {
+  storageDir?: string;
+  backend?: FSProvider;
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "moduleResolution": "bundler",
+    "module": "ESNext"
+  },
+  "include": ["src/**/*"]
+}

package/tsup.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts', 'src/server.ts'],
+  format: ['esm'],
+  target: 'node20',
+  clean: true,
+  dts: true,
+  splitting: false,
+  sourcemap: true,
+  shims: true,
+  skipNodeModulesBundle: true,
+  loader: { '.html': 'text' },
+});

package/vite.runtime.config.ts

@@ -0,0 +1,28 @@
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vite";
+
+const here = (p: string) => fileURLToPath(new URL(p, import.meta.url));
+
+/**
+ * Builds the browser widget runtime (src/runtime) into dist/runtime.
+ *
+ * This is the shared runtime host page that fetches a widget's raw source and
+ * compiles + mounts it in the browser via @aprovan/patchwork-compiler. It is
+ * served statically by the widget server. No React plugin is needed here — the
+ * host page is framework-agnostic; the widget's React is preloaded from the CDN
+ * by the compiler at mount time.
+ */
+export default defineConfig({
+  root: here("src/runtime"),
+  base: "./",
+  build: {
+    outDir: here("dist/runtime"),
+    emptyOutDir: true,
+    // esm.sh modules don't ship the modulepreload polyfill target.
+    modulePreload: false,
+    rollupOptions: {
+      input: here("src/runtime/index.html"),
+    },
+  },
+  logLevel: "warn",
+});

package/vite.shell.config.ts

@@ -0,0 +1,30 @@
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vite";
+
+const here = (p: string) => fileURLToPath(new URL(p, import.meta.url));
+
+/**
+ * Builds the MCP App "shell" (src/shell) into a single self-contained IIFE at
+ * dist/shell/shell.js.
+ *
+ * The shell runs inside Claude's strict-CSP resource sandbox: it bundles the
+ * ext-apps client (no wasm/eval) to perform the host handshake and bridge the
+ * widget, and embeds the CSP-free runtime iframe that does the actual compile.
+ * Served statically by the widget server at /shell.
+ */
+export default defineConfig({
+  build: {
+    outDir: here("dist/shell"),
+    emptyOutDir: true,
+    lib: {
+      entry: here("src/shell/main.ts"),
+      formats: ["iife"],
+      name: "PatchworkShell",
+      fileName: () => "shell.js",
+    },
+    rollupOptions: {
+      output: { inlineDynamicImports: true },
+    },
+  },
+  logLevel: "warn",
+});

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    exclude: ["e2e/**", "node_modules/**"],
+  },
+});