veryfront 0.0.82 → 0.0.84

package/esm/src/transforms/esm/http-cache.js

@@ -224,16 +224,22 @@ async function cacheHttpModule(url, options) {
     await fs.mkdir(cacheDir, { recursive: true });
     await fs.writeTextFile(cachePath, code);
     if (distributed) {
-        // Store code by URL, by hash (for direct recovery), and URL mapping (for debugging)
-        // Storing code by hash enables recovery without needing URL lookup
+        // Store code by URL, by hash (for direct recovery), and URL mapping (for debugging).
+        // Storing code by hash enables recovery without needing URL lookup.
+        // IMPORTANT: await the writes so other pods can recover this bundle immediately.
+        // Without await, a transform referencing this bundle could reach Redis before
+        // the bundle code does, causing ensureHttpBundlesExist on another pod to miss.
         const hash = simpleHash(normalizedUrl);
-        Promise.all([
-            distributed.set(normalizedUrl, code, DISTRIBUTED_CACHE_TTL_SECONDS),
-            distributed.set(`code:${hash}`, code, DISTRIBUTED_CACHE_TTL_SECONDS),
-            distributed.set(`hash:${hash}`, normalizedUrl, DISTRIBUTED_CACHE_TTL_SECONDS),
-        ]).catch((error) => {
+        try {
+            await Promise.all([
+                distributed.set(normalizedUrl, code, DISTRIBUTED_CACHE_TTL_SECONDS),
+                distributed.set(`code:${hash}`, code, DISTRIBUTED_CACHE_TTL_SECONDS),
+                distributed.set(`hash:${hash}`, normalizedUrl, DISTRIBUTED_CACHE_TTL_SECONDS),
+            ]);
+        }
+        catch (error) {
             logger.debug("[HTTP-CACHE] Distributed cache set failed", { url: normalizedUrl, error });
-        });
+        }
     }
     cachedPaths.set(cacheKey, cachePath);
     return cachePath;
@@ -342,6 +348,26 @@ export async function recoverHttpBundleByHash(hash, cacheDir) {
             await fs.mkdir(absoluteCacheDir, { recursive: true });
             await fs.writeTextFile(cachePath, cachedCode);
             logger.info("[HTTP-CACHE] Bundle recovery successful (direct)", { hash, path: cachePath });
+            // Proactively recover transitive deps so the import retry doesn't
+            // fail again with a different missing bundle.
+            const BUNDLE_RE = /file:\/\/([^"'\s]+veryfront-http-bundle\/http-([a-f0-9]+)\.mjs)/gi;
+            const transitiveDeps = [];
+            let m;
+            while ((m = BUNDLE_RE.exec(cachedCode)) !== null) {
+                const tHash = m[2];
+                if (tHash !== hash) {
+                    transitiveDeps.push({
+                        path: join(absoluteCacheDir, `http-${tHash}.mjs`),
+                        hash: tHash,
+                    });
+                }
+            }
+            if (transitiveDeps.length > 0) {
+                logger.info("[HTTP-CACHE] Recovering transitive deps from last-resort recovery", {
+                    count: transitiveDeps.length,
+                });
+                await ensureHttpBundlesExist(transitiveDeps, cacheDir);
+            }
             return true;
         }
         // Strategy 2: URL lookup then re-fetch (fallback for bundles cached before code:{hash} was added)
@@ -380,69 +406,118 @@ export async function ensureHttpBundlesExist(bundlePaths, cacheDir) {
     if (bundlePaths.length === 0)
         return [];
     const fs = createFileSystem();
-    const _absoluteCacheDir = ensureAbsoluteDir(cacheDir);
-    // Check which bundles exist locally
-    const existenceChecks = await Promise.all(bundlePaths.map(async ({ path, hash }) => ({
-        path,
-        hash,
-        exists: await exists(path),
-    })));
-    const missing = existenceChecks.filter((b) => !b.exists);
-    if (missing.length === 0) {
-        logger.debug("[HTTP-CACHE] All bundles exist locally", { count: bundlePaths.length });
-        return [];
-    }
-    logger.info("[HTTP-CACHE] Fetching missing bundles from distributed cache", {
-        missing: missing.length,
-        total: bundlePaths.length,
-    });
-    const distributed = await getDistributedCache();
-    if (!distributed) {
-        logger.error("[HTTP-CACHE] No distributed cache available for bundle recovery");
-        return missing.map((m) => m.hash);
-    }
-    // Batch fetch from distributed cache
-    const codeKeys = missing.map((m) => `code:${m.hash}`);
-    let codes;
-    try {
-        if (distributed.getBatch) {
-            codes = await distributed.getBatch(codeKeys);
+    const absoluteCacheDir = ensureAbsoluteDir(cacheDir);
+    // Use [a-f0-9]+ to match both hex and decimal hashes consistently
+    const BUNDLE_RE = /file:\/\/([^"'\s]+veryfront-http-bundle\/http-([a-f0-9]+)\.mjs)/gi;
+    const extractBundleRefs = (code) => {
+        const refs = [];
+        const dedup = new Set();
+        let match;
+        while ((match = BUNDLE_RE.exec(code)) !== null) {
+            const hash = match[2];
+            if (!dedup.has(hash)) {
+                dedup.add(hash);
+                refs.push({ hash });
+            }
         }
-        else {
-            // Fallback to individual gets
-            const results = await Promise.all(codeKeys.map(async (key) => [key, await distributed.get(key)]));
-            codes = new Map(results);
+        BUNDLE_RE.lastIndex = 0;
+        return refs;
+    };
+    const pending = bundlePaths.map((b) => ({ hash: b.hash }));
+    const seen = new Set();
+    const failed = new Set();
+    while (pending.length > 0) {
+        const batch = pending.splice(0, pending.length).filter((b) => !seen.has(b.hash));
+        if (batch.length === 0)
+            break;
+        for (const item of batch) {
+            seen.add(item.hash);
         }
-    }
-    catch (error) {
-        logger.error("[HTTP-CACHE] Batch fetch from distributed cache failed", { error });
-        return missing.map((m) => m.hash);
-    }
-    // Write fetched bundles to disk
-    const failed = [];
-    await Promise.all(missing.map(async ({ path, hash }) => {
-        const code = codes.get(`code:${hash}`);
-        if (!code) {
-            logger.warn("[HTTP-CACHE] Bundle not found in distributed cache", { hash });
-            failed.push(hash);
-            return;
+        // Check which bundles exist locally using canonical paths derived from
+        // cacheDir + hash. Don't trust caller-provided paths — they may reference
+        // a different pod's absolute directory.
+        const existenceChecks = await Promise.all(batch.map(async ({ hash }) => ({
+            hash,
+            canonicalPath: join(absoluteCacheDir, `http-${hash}.mjs`),
+            exists: await exists(join(absoluteCacheDir, `http-${hash}.mjs`)),
+        })));
+        const missing = existenceChecks.filter((b) => !b.exists);
+        if (missing.length === 0)
+            continue;
+        logger.info("[HTTP-CACHE] Fetching missing bundles from distributed cache", {
+            missing: missing.length,
+            total: batch.length,
+        });
+        const distributed = await getDistributedCache();
+        if (!distributed) {
+            logger.error("[HTTP-CACHE] No distributed cache available for bundle recovery");
+            for (const m of missing)
+                failed.add(m.hash);
+            continue;
         }
+        // Batch fetch from distributed cache
+        const codeKeys = missing.map((m) => `code:${m.hash}`);
+        let codes;
         try {
-            const dir = path.substring(0, path.lastIndexOf("/"));
-            await fs.mkdir(dir, { recursive: true });
-            await fs.writeTextFile(path, code);
-            logger.debug("[HTTP-CACHE] Wrote bundle to disk", { hash, path });
+            if (distributed.getBatch) {
+                codes = await distributed.getBatch(codeKeys);
+            }
+            else {
+                const results = await Promise.all(codeKeys.map(async (key) => [key, await distributed.get(key)]));
+                codes = new Map(results);
+            }
         }
         catch (error) {
-            logger.error("[HTTP-CACHE] Failed to write bundle to disk", { hash, error });
-            failed.push(hash);
+            logger.error("[HTTP-CACHE] Batch fetch from distributed cache failed", { error });
+            for (const m of missing)
+                failed.add(m.hash);
+            continue;
         }
-    }));
-    if (failed.length > 0) {
-        logger.warn("[HTTP-CACHE] Some bundles could not be recovered", { failed });
+        // Write fetched bundles to disk using canonical paths and scan for transitive deps
+        await Promise.all(missing.map(async ({ hash, canonicalPath }) => {
+            const code = codes.get(`code:${hash}`);
+            if (!code) {
+                // Try single-bundle recovery as last resort
+                const recovered = await recoverHttpBundleByHash(hash, absoluteCacheDir);
+                if (!recovered) {
+                    failed.add(hash);
+                }
+                else {
+                    // Read the recovered bundle to scan for transitive deps
+                    try {
+                        const recoveredCode = await fs.readTextFile(canonicalPath);
+                        for (const ref of extractBundleRefs(recoveredCode)) {
+                            if (!seen.has(ref.hash))
+                                pending.push(ref);
+                        }
+                    }
+                    catch { /* ignore read errors for dep scanning */ }
+                }
+                return;
+            }
+            try {
+                await fs.mkdir(absoluteCacheDir, { recursive: true });
+                await fs.writeTextFile(canonicalPath, code);
+                logger.debug("[HTTP-CACHE] Wrote bundle to disk", { hash, path: canonicalPath });
+                // Scan recovered code for transitive HTTP bundle dependencies.
+                // HTTP bundles import other bundles (e.g., esm.sh packages depending
+                // on other packages). Without this, Pod B recovers only the top-level
+                // bundle and gets "Module not found" for transitive deps at import time.
+                for (const ref of extractBundleRefs(code)) {
+                    if (!seen.has(ref.hash))
+                        pending.push(ref);
+                }
+            }
+            catch (error) {
+                logger.error("[HTTP-CACHE] Failed to write bundle to disk", { hash, error });
+                failed.add(hash);
+            }
+        }));
     }
-    else {
-        logger.info("[HTTP-CACHE] All missing bundles recovered", { count: missing.length });
+    if (failed.size > 0) {
+        logger.warn("[HTTP-CACHE] Some bundles could not be recovered", {
+            failed: Array.from(failed),
+        });
     }
-    return failed;
+    return Array.from(failed);
 }

package/esm/src/utils/index.d.ts

@@ -3,7 +3,7 @@ export * from "./logger/index.js";
 export * from "./constants/index.js";
 export { VERSION } from "./version.js";
 export * from "./paths.js";
-export { type BundleCode as HashBundleCode, computeCodeHash, computeContentHash, computeHash, getContentHash, shortHash, simpleHash, simpleHash as numericHash, } from "./hash-utils.js";
+export { type BundleCode as HashBundleCode, computeCodeHash, computeContentHash, computeHash, getContentHash, shortHash, simpleHash, } from "./hash-utils.js";
 export { MemoCache, memoize, memoizeAsync, simpleHash as memoizeHash } from "./memoize.js";
 export * from "./path-utils.js";
 export * from "./format-utils.js";

package/esm/src/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,cAAc,YAAY,CAAC;AAE3B,OAAO,EACL,KAAK,UAAU,IAAI,cAAc,EACjC,eAAe,EACf,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,SAAS,EACT,UAAU,EACV,UAAU,IAAI,WAAW,GAC1B,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,YAAY,EAAE,UAAU,IAAI,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3F,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,cAAc,YAAY,CAAC;AAE3B,OAAO,EACL,KAAK,UAAU,IAAI,cAAc,EACjC,eAAe,EACf,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,SAAS,EACT,UAAU,GACX,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,YAAY,EAAE,UAAU,IAAI,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3F,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC"}

package/esm/src/utils/index.js

@@ -3,7 +3,7 @@ export * from "./logger/index.js";
 export * from "./constants/index.js";
 export { VERSION } from "./version.js";
 export * from "./paths.js";
-export { computeCodeHash, computeContentHash, computeHash, getContentHash, shortHash, simpleHash, simpleHash as numericHash, } from "./hash-utils.js";
+export { computeCodeHash, computeContentHash, computeHash, getContentHash, shortHash, simpleHash, } from "./hash-utils.js";
 export { MemoCache, memoize, memoizeAsync, simpleHash as memoizeHash } from "./memoize.js";
 export * from "./path-utils.js";
 export * from "./format-utils.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veryfront",
-  "version": "0.0.82",
+  "version": "0.0.84",
   "description": "Zero-config React meta-framework for building agentic AI applications",
   "keywords": [
     "react",
@@ -195,6 +195,7 @@
     "picocolors": "^1.1.0",
     "react": "19.1.1",
     "react-dom": "19.1.1",
+    "redis": "*",
     "rehype-highlight": "7.0.2",
     "rehype-slug": "6.0.0",
     "rehype-starry-night": "2.2.0",

package/src/deno.js

@@ -1,6 +1,6 @@
 export default {
   "name": "veryfront",
-  "version": "0.0.82",
+  "version": "0.0.84",
   "nodeModulesDir": "auto",
   "exclude": [
     "npm/",

package/src/proxy/cache/index.ts

@@ -0,0 +1,93 @@
+/**
+ * Token Cache Module
+ *
+ * Provides configurable caching for OAuth tokens.
+ * Supports in-memory (single instance) and Redis (distributed) backends.
+ * Redis cache includes automatic fallback to memory when Redis is unavailable.
+ */
+
+export type {
+  CacheOptions,
+  CacheStats,
+  MemoryCacheOptions,
+  RedisCacheOptions,
+  TokenCache,
+  TokenCacheEntry,
+} from "./types.js";
+export { MemoryCache } from "./memory-cache.js";
+export { RedisCache } from "./redis-cache.js";
+export { ResilientCache } from "./resilient-cache.js";
+
+import type { CacheOptions, TokenCache } from "./types.js";
+import { MemoryCache } from "./memory-cache.js";
+import { RedisCache } from "./redis-cache.js";
+import { ResilientCache } from "./resilient-cache.js";
+import { getEnv } from "../../src/platform/compat/process.js";
+import { proxyLogger } from "../logger.js";
+import { withSpan } from "../tracing.js";
+
+const logger = proxyLogger.child({ module: "cache" });
+
+/**
+ * Create a token cache based on configuration.
+ *
+ * @example
+ * ```typescript
+ * // In-memory cache (default)
+ * const cache = createCache({ type: "memory" });
+ *
+ * // Redis cache for distributed deployments
+ * const cache = createCache({
+ *   type: "redis",
+ *   options: { url: "redis://localhost:6379" }
+ * });
+ * ```
+ */
+export async function createCache(options: CacheOptions): Promise<TokenCache> {
+  return withSpan("cache.create", async () => {
+    switch (options.type) {
+      case "redis":
+        return new RedisCache(options.options);
+      case "memory":
+      default:
+        return new MemoryCache(options.options);
+    }
+  }, { "cache.type": options.type });
+}
+
+/**
+ * Create cache from environment variables.
+ *
+ * Environment variables:
+ * - CACHE_TYPE: "memory" or "redis" (default: "memory")
+ * - REDIS_URL: Redis connection URL (required if CACHE_TYPE=redis)
+ * - REDIS_PREFIX: Key prefix (default: "vf:token:")
+ *
+ * When CACHE_TYPE=redis, automatically wraps with ResilientCache for
+ * graceful fallback to memory when Redis is unavailable.
+ */
+export async function createCacheFromEnv(): Promise<TokenCache> {
+  return withSpan("cache.createFromEnv", async () => {
+    const cacheType = getEnv("CACHE_TYPE") || "memory";
+
+    if (cacheType === "redis") {
+      const url = getEnv("REDIS_URL");
+      if (!url) {
+        logger.warn("[Cache] CACHE_TYPE=redis but REDIS_URL not set, falling back to memory");
+        return new MemoryCache();
+      }
+
+      const redisCache = new RedisCache({
+        url,
+        prefix: getEnv("REDIS_PREFIX") || "vf:token:",
+      });
+
+      // Wrap Redis with resilient fallback to memory cache
+      // This ensures the proxy continues to function when Redis is unavailable
+      logger.info("[Cache] Using Redis with memory fallback (ResilientCache)");
+      return new ResilientCache(redisCache, new MemoryCache());
+    }
+
+    return new MemoryCache();
+  }, { "cache.type": getEnv("CACHE_TYPE") || "memory" });
+}

package/src/proxy/cache/memory-cache.ts

@@ -0,0 +1,120 @@
+/**
+ * In-Memory Token Cache - single-instance deployments.
+ */
+import * as dntShim from "../../_dnt.shims.js";
+
+
+import type { CacheStats, MemoryCacheOptions, TokenCache, TokenCacheEntry } from "./types.js";
+import { withSpan } from "../tracing.js";
+
+const DEFAULT_MAX_SIZE = 1000;
+const DEFAULT_CLEANUP_INTERVAL = 60_000;
+
+export class MemoryCache implements TokenCache {
+  private cache = new Map<string, TokenCacheEntry>();
+  private hits = 0;
+  private misses = 0;
+  private maxSize: number;
+  private cleanupTimer: ReturnType<typeof dntShim.setInterval> | null = null;
+
+  constructor(options: MemoryCacheOptions = {}) {
+    this.maxSize = options.maxSize ?? DEFAULT_MAX_SIZE;
+    const interval = options.cleanupInterval ?? DEFAULT_CLEANUP_INTERVAL;
+    this.cleanupTimer = dntShim.setInterval(() => this.cleanup(), interval);
+  }
+
+  get(key: string): Promise<TokenCacheEntry | null> {
+    return withSpan("cache.memory.get", async () => {
+      const entry = this.cache.get(key);
+
+      if (!entry) {
+        this.misses++;
+        return null;
+      }
+
+      if (Date.now() >= entry.expiresAt) {
+        this.cache.delete(key);
+        this.misses++;
+        return null;
+      }
+
+      this.hits++;
+      return entry;
+    }, { "cache.key": key });
+  }
+
+  set(key: string, entry: TokenCacheEntry): Promise<void> {
+    return withSpan("cache.memory.set", async () => {
+      if (this.cache.size >= this.maxSize) {
+        const firstKey = this.cache.keys().next().value;
+        if (firstKey) {
+          this.cache.delete(firstKey);
+        }
+      }
+      this.cache.set(key, entry);
+    }, { "cache.key": key });
+  }
+
+  delete(key: string): Promise<void> {
+    return withSpan("cache.memory.delete", async () => {
+      this.cache.delete(key);
+    }, { "cache.key": key });
+  }
+
+  clear(): Promise<void> {
+    return withSpan("cache.memory.clear", async () => {
+      this.cache.clear();
+      this.hits = 0;
+      this.misses = 0;
+    });
+  }
+
+  has(key: string): Promise<boolean> {
+    return withSpan("cache.memory.has", async () => {
+      const entry = this.cache.get(key);
+      if (!entry) return false;
+
+      if (Date.now() >= entry.expiresAt) {
+        this.cache.delete(key);
+        return false;
+      }
+
+      return true;
+    }, { "cache.key": key });
+  }
+
+  stats(): Promise<CacheStats> {
+    return withSpan("cache.memory.stats", async () => ({
+      hits: this.hits,
+      misses: this.misses,
+      size: this.cache.size,
+      type: "memory" as const,
+    }));
+  }
+
+  close(): Promise<void> {
+    return withSpan("cache.memory.close", async () => {
+      if (this.cleanupTimer) {
+        clearInterval(this.cleanupTimer);
+        this.cleanupTimer = null;
+      }
+      this.cache.clear();
+    });
+  }
+
+  private cleanup(): void {
+    const now = Date.now();
+    let cleaned = 0;
+
+    for (const [key, entry] of this.cache.entries()) {
+      if (now >= entry.expiresAt) {
+        this.cache.delete(key);
+        cleaned++;
+      }
+    }
+
+    if (cleaned > 0) {
+      console.log(`[MemoryCache] Cleaned ${cleaned} expired entries`);
+    }
+  }
+}