@aprovan/patchwork 0.1.0 → 0.1.1

package/packages/compiler/src/index.ts

@@ -24,7 +24,7 @@
  */
 
 // Core compiler
-export { createCompiler } from './compiler.js';
+export { createCompiler } from "./compiler.js";
 
 // Schemas (Zod validation)
 export {
@@ -45,7 +45,7 @@ export {
   // Defaults
   DEFAULT_IMAGE_CONFIG,
   DEFAULT_CLI_IMAGE_CONFIG,
-} from './schemas.js';
+} from "./schemas.js";
 
 // Types
 export type {
@@ -72,7 +72,7 @@ export type {
   BridgeMessageType,
   ServiceCallPayload,
   ServiceResultPayload,
-} from './types.js';
+} from "./types.js";
 
 // Images
 export {
@@ -86,18 +86,18 @@ export {
   fetchPackageJson,
   setCdnBaseUrl,
   getCdnBaseUrl,
-} from './images/index.js';
+} from "./images/index.js";
 
 // Transforms
 export {
   cdnTransformPlugin,
   generateImportMap,
   vfsPlugin,
-} from './transforms/index.js';
+} from "./transforms/index.js";
 export type {
   CdnTransformOptions,
   VFSPluginOptions,
-} from './transforms/index.js';
+} from "./transforms/index.js";
 
 // VFS
 export {
@@ -107,16 +107,15 @@ export {
   resolveEntry,
   detectMainFile,
   IndexedDBBackend,
-  LocalFSBackend,
-  S3Backend,
-} from './vfs/index.js';
+  HttpBackend,
+} from "./vfs/index.js";
 export type {
   VirtualFile,
   VirtualProject,
-  StorageBackend,
-  LocalFSConfig,
-  S3Config,
-} from './vfs/index.js';
+  ChangeRecord,
+  HttpBackendConfig,
+  VFSStoreOptions,
+} from "./vfs/index.js";
 
 // Mount utilities
 export {
@@ -138,4 +137,4 @@ export {
   ParentBridge,
   createIframeServiceProxy,
   generateIframeBridgeScript,
-} from './mount/index.js';
+} from "./mount/index.js";

package/packages/compiler/src/vfs/backends/http.ts

@@ -0,0 +1,139 @@
+import type {
+  DirEntry,
+  FileStats,
+  FSProvider,
+  WatchCallback,
+  WatchEventType,
+} from "../core/types.js";
+import { createDirEntry, createFileStats } from "../core/utils.js";
+
+export interface HttpBackendConfig {
+  baseUrl: string;
+}
+
+interface StatResponse {
+  size: number;
+  mtime: string;
+  isFile: boolean;
+  isDirectory: boolean;
+}
+
+interface WatchEvent {
+  type: WatchEventType;
+  path: string;
+  mtime: string;
+}
+
+/**
+ * HTTP-based FSProvider for connecting to remote servers (e.g., stitchery)
+ */
+export class HttpBackend implements FSProvider {
+  constructor(private config: HttpBackendConfig) {}
+
+  async readFile(path: string): Promise<string> {
+    const res = await fetch(this.url(path));
+    if (!res.ok) throw new Error(`ENOENT: ${path}`);
+    return res.text();
+  }
+
+  async writeFile(path: string, content: string): Promise<void> {
+    const res = await fetch(this.url(path), {
+      method: "PUT",
+      body: content,
+      headers: { "Content-Type": "text/plain" },
+    });
+    if (!res.ok) throw new Error(`Failed to write: ${path}`);
+  }
+
+  async unlink(path: string): Promise<void> {
+    const res = await fetch(this.url(path), { method: "DELETE" });
+    if (!res.ok) throw new Error(`Failed to delete: ${path}`);
+  }
+
+  async stat(path: string): Promise<FileStats> {
+    const res = await fetch(this.url(path, { stat: "true" }));
+    if (!res.ok) throw new Error(`ENOENT: ${path}`);
+    const data: StatResponse = await res.json();
+    return createFileStats(data.size, new Date(data.mtime), data.isDirectory);
+  }
+
+  async mkdir(path: string, options?: { recursive?: boolean }): Promise<void> {
+    const params: Record<string, string> = { mkdir: "true" };
+    if (options?.recursive) params.recursive = "true";
+    const res = await fetch(this.url(path, params), { method: "POST" });
+    if (!res.ok) throw new Error(`Failed to mkdir: ${path}`);
+  }
+
+  async readdir(path: string): Promise<DirEntry[]> {
+    const res = await fetch(this.url(path, { readdir: "true" }));
+    if (!res.ok) throw new Error(`ENOENT: ${path}`);
+    const entries: Array<{ name: string; isDirectory: boolean }> =
+      await res.json();
+    return entries.map((e) => createDirEntry(e.name, e.isDirectory));
+  }
+
+  async rmdir(path: string, options?: { recursive?: boolean }): Promise<void> {
+    const params: Record<string, string> = {};
+    if (options?.recursive) params.recursive = "true";
+    const res = await fetch(this.url(path, params), { method: "DELETE" });
+    if (!res.ok) throw new Error(`Failed to rmdir: ${path}`);
+  }
+
+  async exists(path: string): Promise<boolean> {
+    const res = await fetch(this.url(path), { method: "HEAD" });
+    return res.ok;
+  }
+
+  watch(path: string, callback: WatchCallback): () => void {
+    const controller = new AbortController();
+    this.startWatch(path, callback, controller.signal);
+    return () => controller.abort();
+  }
+
+  private async startWatch(
+    path: string,
+    callback: WatchCallback,
+    signal: AbortSignal,
+  ): Promise<void> {
+    try {
+      const res = await fetch(this.url("", { watch: path }), { signal });
+      if (!res.ok) return;
+      const reader = res.body?.getReader();
+      if (!reader) return;
+
+      const decoder = new TextDecoder();
+      let buffer = "";
+
+      while (!signal.aborted) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            try {
+              const event: WatchEvent = JSON.parse(line.slice(6));
+              callback(event.type, event.path);
+            } catch {
+              // Ignore parse errors
+            }
+          }
+        }
+      }
+    } catch {
+      // Connection closed or aborted
+    }
+  }
+
+  private url(path: string, params?: Record<string, string>): string {
+    const baseUrl = this.config.baseUrl.replace(/\/+$/, "");
+    const cleanPath = path.replace(/^\/+/, "");
+    const base = cleanPath ? `${baseUrl}/${cleanPath}` : baseUrl;
+    if (!params) return base;
+    const query = new URLSearchParams(params).toString();
+    return `${base}?${query}`;
+  }
+}

package/packages/compiler/src/vfs/backends/indexeddb.ts

@@ -1,28 +1,49 @@
-import type { StorageBackend } from '../types.js';
+import type { DirEntry, FileStats, FSProvider } from '../core/types.js';
+import {
+  basename,
+  createDirEntry,
+  createFileStats,
+  dirname,
+  normalizePath,
+} from '../core/utils.js';
 
 const DB_NAME = 'patchwork-vfs';
-const STORE_NAME = 'files';
+const DB_VERSION = 2;
+const FILES_STORE = 'files';
+const DIRS_STORE = 'dirs';
+
+interface FileRecord {
+  content: string;
+  mtime: number;
+}
 
 function openDB(): Promise<IDBDatabase> {
   return new Promise((resolve, reject) => {
-    const request = indexedDB.open(DB_NAME, 1);
+    const request = indexedDB.open(DB_NAME, DB_VERSION);
     request.onerror = () => reject(request.error);
     request.onsuccess = () => resolve(request.result);
-    request.onupgradeneeded = () => {
-      request.result.createObjectStore(STORE_NAME);
+    request.onupgradeneeded = (event) => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(FILES_STORE)) {
+        db.createObjectStore(FILES_STORE);
+      }
+      if (!db.objectStoreNames.contains(DIRS_STORE)) {
+        db.createObjectStore(DIRS_STORE);
+      }
     };
   });
 }
 
 function withStore<T>(
+  storeName: string,
   mode: IDBTransactionMode,
   fn: (store: IDBObjectStore) => IDBRequest<T>,
 ): Promise<T> {
   return openDB().then(
     (db) =>
       new Promise((resolve, reject) => {
-        const tx = db.transaction(STORE_NAME, mode);
-        const store = tx.objectStore(STORE_NAME);
+        const tx = db.transaction(storeName, mode);
+        const store = tx.objectStore(storeName);
         const request = fn(store);
         request.onerror = () => reject(request.error);
         request.onsuccess = () => resolve(request.result);
@@ -30,37 +51,177 @@ function withStore<T>(
   );
 }
 
-export class IndexedDBBackend implements StorageBackend {
+export class IndexedDBBackend implements FSProvider {
   constructor(private prefix = 'vfs') {}
 
   private key(path: string): string {
-    return `${this.prefix}:${path}`;
+    return `${this.prefix}:${normalizePath(path)}`;
+  }
+
+  async readFile(path: string): Promise<string> {
+    const record = await withStore<FileRecord | undefined>(
+      FILES_STORE,
+      'readonly',
+      (store) => store.get(this.key(path)),
+    );
+    if (!record) throw new Error(`ENOENT: ${path}`);
+    return record.content;
   }
 
-  async get(path: string): Promise<string | null> {
-    const result = await withStore('readonly', (store) =>
-      store.get(this.key(path)),
+  async writeFile(path: string, content: string): Promise<void> {
+    const dir = dirname(normalizePath(path));
+    if (dir && !(await this.dirExists(dir))) {
+      throw new Error(`ENOENT: ${dir}`);
+    }
+    const record: FileRecord = { content, mtime: Date.now() };
+    await withStore(FILES_STORE, 'readwrite', (store) =>
+      store.put(record, this.key(path)),
     );
-    return result ?? null;
   }
 
-  async put(path: string, content: string): Promise<void> {
-    await withStore('readwrite', (store) => store.put(content, this.key(path)));
+  async unlink(path: string): Promise<void> {
+    await withStore(FILES_STORE, 'readwrite', (store) =>
+      store.delete(this.key(path)),
+    );
   }
 
-  async delete(path: string): Promise<void> {
-    await withStore('readwrite', (store) => store.delete(this.key(path)));
+  async stat(path: string): Promise<FileStats> {
+    const normalized = normalizePath(path);
+    const record = await withStore<FileRecord | undefined>(
+      FILES_STORE,
+      'readonly',
+      (store) => store.get(this.key(normalized)),
+    );
+    if (record) {
+      return createFileStats(
+        record.content.length,
+        new Date(record.mtime),
+        false,
+      );
+    }
+    if (await this.dirExists(normalized)) {
+      return createFileStats(0, new Date(), true);
+    }
+    throw new Error(`ENOENT: ${path}`);
+  }
+
+  async mkdir(path: string, options?: { recursive?: boolean }): Promise<void> {
+    const normalized = normalizePath(path);
+    if (await this.dirExists(normalized)) return;
+
+    const parent = dirname(normalized);
+    if (parent && !(await this.dirExists(parent))) {
+      if (options?.recursive) {
+        await this.mkdir(parent, options);
+      } else {
+        throw new Error(`ENOENT: ${parent}`);
+      }
+    }
+
+    await withStore(DIRS_STORE, 'readwrite', (store) =>
+      store.put(Date.now(), this.key(normalized)),
+    );
+  }
+
+  async readdir(path: string): Promise<DirEntry[]> {
+    const normalized = normalizePath(path);
+    if (normalized && !(await this.dirExists(normalized))) {
+      throw new Error(`ENOENT: ${path}`);
+    }
+
+    const prefix = normalized ? `${this.key(normalized)}/` : `${this.prefix}:`;
+    const entries = new Map<string, boolean>();
+
+    const fileKeys = await withStore<IDBValidKey[]>(
+      FILES_STORE,
+      'readonly',
+      (store) => store.getAllKeys(),
+    );
+    for (const key of fileKeys as string[]) {
+      if (key.startsWith(prefix)) {
+        const rest = key.slice(prefix.length);
+        const name = rest.split('/')[0];
+        if (name && !rest.includes('/')) entries.set(name, false);
+      }
+    }
+
+    const dirKeys = await withStore<IDBValidKey[]>(
+      DIRS_STORE,
+      'readonly',
+      (store) => store.getAllKeys(),
+    );
+    for (const key of dirKeys as string[]) {
+      if (key.startsWith(prefix)) {
+        const rest = key.slice(prefix.length);
+        const name = rest.split('/')[0];
+        if (name && !rest.includes('/')) entries.set(name, true);
+      }
+    }
+
+    return Array.from(entries).map(([name, isDir]) =>
+      createDirEntry(name, isDir),
+    );
   }
 
-  async list(prefix?: string): Promise<string[]> {
-    const keyPrefix = prefix ? this.key(prefix) : this.key('');
-    const allKeys = await withStore('readonly', (store) => store.getAllKeys());
-    return (allKeys as string[])
-      .filter((k) => k.startsWith(keyPrefix))
-      .map((k) => k.slice(this.prefix.length + 1));
+  async rmdir(path: string, options?: { recursive?: boolean }): Promise<void> {
+    const normalized = normalizePath(path);
+    if (!(await this.dirExists(normalized))) {
+      throw new Error(`ENOENT: ${path}`);
+    }
+
+    const prefix = `${this.key(normalized)}/`;
+
+    if (options?.recursive) {
+      const fileKeys = await withStore<IDBValidKey[]>(
+        FILES_STORE,
+        'readonly',
+        (store) => store.getAllKeys(),
+      );
+      for (const key of fileKeys as string[]) {
+        if (key.startsWith(prefix)) {
+          await withStore(FILES_STORE, 'readwrite', (store) =>
+            store.delete(key),
+          );
+        }
+      }
+
+      const dirKeys = await withStore<IDBValidKey[]>(
+        DIRS_STORE,
+        'readonly',
+        (store) => store.getAllKeys(),
+      );
+      for (const key of dirKeys as string[]) {
+        if (key.startsWith(prefix)) {
+          await withStore(DIRS_STORE, 'readwrite', (store) =>
+            store.delete(key),
+          );
+        }
+      }
+    }
+
+    await withStore(DIRS_STORE, 'readwrite', (store) =>
+      store.delete(this.key(normalized)),
+    );
   }
 
   async exists(path: string): Promise<boolean> {
-    return (await this.get(path)) !== null;
+    const normalized = normalizePath(path);
+    const record = await withStore<FileRecord | undefined>(
+      FILES_STORE,
+      'readonly',
+      (store) => store.get(this.key(normalized)),
+    );
+    if (record) return true;
+    return this.dirExists(normalized);
+  }
+
+  private async dirExists(path: string): Promise<boolean> {
+    if (!path) return true; // Root always exists
+    const result = await withStore<number | undefined>(
+      DIRS_STORE,
+      'readonly',
+      (store) => store.get(this.key(path)),
+    );
+    return result !== undefined;
   }
 }

package/packages/compiler/src/vfs/backends/memory.ts

@@ -0,0 +1,166 @@
+import type { DirEntry, FileStats, FSProvider, WatchCallback } from '../core/types.js';
+import {
+  basename,
+  createDirEntry,
+  createFileStats,
+  dirname,
+  normalizePath,
+} from '../core/utils.js';
+
+interface FileEntry {
+  content: string;
+  mtime: Date;
+}
+
+/**
+ * In-memory FSProvider implementation.
+ * Useful for tests and ephemeral file systems.
+ */
+export class MemoryBackend implements FSProvider {
+  private files = new Map<string, FileEntry>();
+  private dirs = new Set<string>(['']);
+  private watchers = new Map<string, Set<WatchCallback>>();
+
+  async readFile(path: string): Promise<string> {
+    const entry = this.files.get(normalizePath(path));
+    if (!entry) throw new Error(`ENOENT: ${path}`);
+    return entry.content;
+  }
+
+  async writeFile(path: string, content: string): Promise<void> {
+    const normalized = normalizePath(path);
+    const dir = dirname(normalized);
+    if (dir && !this.dirs.has(dir)) {
+      throw new Error(`ENOENT: ${dir}`);
+    }
+    const isNew = !this.files.has(normalized);
+    this.files.set(normalized, { content, mtime: new Date() });
+    this.emit(isNew ? 'create' : 'update', normalized);
+  }
+
+  async unlink(path: string): Promise<void> {
+    const normalized = normalizePath(path);
+    if (!this.files.delete(normalized)) {
+      throw new Error(`ENOENT: ${path}`);
+    }
+    this.emit('delete', normalized);
+  }
+
+  async stat(path: string): Promise<FileStats> {
+    const normalized = normalizePath(path);
+    const entry = this.files.get(normalized);
+    if (entry) {
+      return createFileStats(entry.content.length, entry.mtime, false);
+    }
+    if (this.dirs.has(normalized)) {
+      return createFileStats(0, new Date(), true);
+    }
+    throw new Error(`ENOENT: ${path}`);
+  }
+
+  async mkdir(path: string, options?: { recursive?: boolean }): Promise<void> {
+    const normalized = normalizePath(path);
+    if (this.dirs.has(normalized)) return;
+
+    const parent = dirname(normalized);
+    if (parent && !this.dirs.has(parent)) {
+      if (options?.recursive) {
+        await this.mkdir(parent, options);
+      } else {
+        throw new Error(`ENOENT: ${parent}`);
+      }
+    }
+    this.dirs.add(normalized);
+  }
+
+  async readdir(path: string): Promise<DirEntry[]> {
+    const normalized = normalizePath(path);
+    if (!this.dirs.has(normalized)) {
+      throw new Error(`ENOENT: ${path}`);
+    }
+
+    const prefix = normalized ? `${normalized}/` : '';
+    const entries = new Map<string, boolean>();
+
+    for (const filePath of this.files.keys()) {
+      if (filePath.startsWith(prefix)) {
+        const rest = filePath.slice(prefix.length);
+        const name = rest.split('/')[0];
+        if (name) entries.set(name, false);
+      }
+    }
+
+    for (const dirPath of this.dirs) {
+      if (dirPath.startsWith(prefix) && dirPath !== normalized) {
+        const rest = dirPath.slice(prefix.length);
+        const name = rest.split('/')[0];
+        if (name) entries.set(name, true);
+      }
+    }
+
+    return Array.from(entries).map(([name, isDir]) =>
+      createDirEntry(name, isDir),
+    );
+  }
+
+  async rmdir(path: string, options?: { recursive?: boolean }): Promise<void> {
+    const normalized = normalizePath(path);
+    if (!this.dirs.has(normalized)) {
+      throw new Error(`ENOENT: ${path}`);
+    }
+
+    const prefix = `${normalized}/`;
+    const hasChildren =
+      [...this.files.keys()].some((p) => p.startsWith(prefix)) ||
+      [...this.dirs].some((d) => d.startsWith(prefix));
+
+    if (hasChildren && !options?.recursive) {
+      throw new Error(`ENOTEMPTY: ${path}`);
+    }
+
+    if (options?.recursive) {
+      for (const filePath of this.files.keys()) {
+        if (filePath.startsWith(prefix)) {
+          this.files.delete(filePath);
+          this.emit('delete', filePath);
+        }
+      }
+      for (const dirPath of this.dirs) {
+        if (dirPath.startsWith(prefix)) {
+          this.dirs.delete(dirPath);
+        }
+      }
+    }
+
+    this.dirs.delete(normalized);
+  }
+
+  async exists(path: string): Promise<boolean> {
+    const normalized = normalizePath(path);
+    return this.files.has(normalized) || this.dirs.has(normalized);
+  }
+
+  watch(path: string, callback: WatchCallback): () => void {
+    const normalized = normalizePath(path);
+    let callbacks = this.watchers.get(normalized);
+    if (!callbacks) {
+      callbacks = new Set();
+      this.watchers.set(normalized, callbacks);
+    }
+    callbacks.add(callback);
+    return () => callbacks!.delete(callback);
+  }
+
+  private emit(event: 'create' | 'update' | 'delete', path: string): void {
+    // Notify watchers for this path and all parent paths
+    let current = path;
+    while (true) {
+      const callbacks = this.watchers.get(current);
+      if (callbacks) {
+        for (const cb of callbacks) cb(event, path);
+      }
+      if (!current) break;
+      current = dirname(current);
+    }
+  }
+}

package/packages/compiler/src/vfs/core/index.ts

@@ -0,0 +1,26 @@
+export type {
+  ChangeRecord,
+  ConflictRecord,
+  ConflictStrategy,
+  DirEntry,
+  FileStats,
+  FSProvider,
+  SyncEngine,
+  SyncEventCallback,
+  SyncEventType,
+  SyncResult,
+  SyncStatus,
+  WatchCallback,
+  WatchEventType,
+} from './types.js';
+
+export {
+  basename,
+  createDirEntry,
+  createFileStats,
+  dirname,
+  join,
+  normalizePath,
+} from './utils.js';
+
+export { VirtualFS } from './virtual-fs.js';