poe-code 3.0.298 → 3.0.299

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "3.0.298",
+  "version": "3.0.299",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "type": "module",
   "main": "./dist/index.js",

package/packages/cached-resource/dist/api-fetch.d.ts

@@ -3,4 +3,5 @@ interface ApiFetchDeps {
     fetch: (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
 }
 export declare function fetchFromApi<T>(config: Pick<CacheConfig, "apiEndpoint" | "fetchTimeout">, deps?: Partial<ApiFetchDeps>): Promise<T>;
+export declare function validateFetchConfig(config: Pick<CacheConfig, "apiEndpoint" | "fetchTimeout">): void;
 export {};

package/packages/cached-resource/dist/api-fetch.js

@@ -1,7 +1,5 @@
 export async function fetchFromApi(config, deps) {
-    if (!Number.isFinite(config.fetchTimeout) || config.fetchTimeout < 0) {
-        throw new Error("fetchTimeout must be a finite non-negative number");
-    }
+    validateFetchConfig(config);
     const fetchFn = deps?.fetch ?? globalThis.fetch;
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), config.fetchTimeout);
@@ -24,3 +22,14 @@ export async function fetchFromApi(config, deps) {
         clearTimeout(timeoutId);
     }
 }
+export function validateFetchConfig(config) {
+    if (!Number.isFinite(config.fetchTimeout) || config.fetchTimeout < 0) {
+        throw new Error("fetchTimeout must be a finite non-negative number");
+    }
+    try {
+        new URL(config.apiEndpoint);
+    }
+    catch (error) {
+        throw new Error("apiEndpoint must be a valid URL", { cause: error });
+    }
+}

package/packages/cached-resource/dist/cache-orchestrator.js

@@ -1,5 +1,5 @@
 import { loadFromDisk, persist } from "./disk-cache.js";
-import { fetchFromApi } from "./api-fetch.js";
+import { fetchFromApi, validateFetchConfig } from "./api-fetch.js";
 export async function resolveData(bundledData, config, deps, options) {
     if (!Number.isFinite(config.freshTtl) || config.freshTtl < 0) {
         throw new Error("freshTtl must be a finite non-negative number");
@@ -8,6 +8,15 @@ export async function resolveData(bundledData, config, deps, options) {
     if (!forceRefresh) {
         const memoryCached = deps.memoryCache.get(config.cacheName);
         if (memoryCached) {
+            const isStale = Date.now() - memoryCached.timestamp > config.freshTtl;
+            if (isStale && deps.revalidator && !offline && !preferOffline) {
+                deps.revalidator.trigger(config.cacheName, async () => {
+                    const data = await fetchFromApi(config, { fetch: deps.fetch });
+                    const cached = { data, timestamp: Date.now() };
+                    deps.memoryCache.set(config.cacheName, cached);
+                    await persist(data, config, { fs: deps.fs });
+                });
+            }
             return memoryCached;
         }
         const diskCached = await loadFromDisk(config, { fs: deps.fs });
@@ -28,6 +37,10 @@ export async function resolveData(bundledData, config, deps, options) {
     if (offline) {
         return { data: bundledData, timestamp: 0 };
     }
+    if (preferOffline && !forceRefresh) {
+        return { data: bundledData, timestamp: 0 };
+    }
+    validateFetchConfig(config);
     try {
         const data = await fetchFromApi(config, { fetch: deps.fetch });
         const cached = { data, timestamp: Date.now() };

package/packages/cached-resource/dist/disk-cache.js

@@ -2,6 +2,9 @@ import { isAbsolute, join, relative, resolve } from "node:path";
 import { randomUUID } from "node:crypto";
 import os from "node:os";
 const TEMP_WRITE_MAX_ATTEMPTS = 3;
+const CACHE_PATH_ERROR_MESSAGE = "Cache path must remain inside its configured directory.";
+class DiskCacheConfigError extends Error {
+}
 export async function loadFromDisk(config, deps) {
     if (!Number.isFinite(config.staleTtl) || config.staleTtl < 0) {
         throw new Error("staleTtl must be a finite non-negative number");
@@ -18,7 +21,10 @@ export async function loadFromDisk(config, deps) {
         }
         return cached;
     }
-    catch {
+    catch (error) {
+        if (error instanceof DiskCacheConfigError) {
+            throw error;
+        }
         return null;
     }
 }
@@ -32,7 +38,10 @@ export async function persist(data, config, deps) {
         };
         await writeCacheFile(filePath, JSON.stringify(cached), deps.fs);
     }
-    catch {
+    catch (error) {
+        if (error instanceof DiskCacheConfigError) {
+            throw error;
+        }
         // Disk cache writes are best-effort; callers can still use memory or bundled data.
         return;
     }
@@ -54,8 +63,15 @@ export async function removeFromDisk(config, deps) {
 export function resolveCacheDir(appName, deps) {
     const xdgCacheHome = getOwnEnvValue(deps?.env ?? process.env, "XDG_CACHE_HOME");
     const home = deps?.homedir ? deps.homedir() : os.homedir();
-    const cacheRoot = xdgCacheHome ?? join(home, ".cache");
-    const cacheDir = join(cacheRoot, appName);
+    const cacheRoot = xdgCacheHome && xdgCacheHome.trim().length > 0
+        ? xdgCacheHome
+        : join(home, ".cache");
+    if (!isAbsolute(cacheRoot)) {
+        throw new Error("XDG_CACHE_HOME must be an absolute path");
+    }
+    const normalizedAppName = appName.trim();
+    assertSafeAppName(normalizedAppName);
+    const cacheDir = join(cacheRoot, normalizedAppName);
     assertContainedPath(cacheRoot, cacheDir);
     return cacheDir;
 }
@@ -68,7 +84,7 @@ async function resolveCachePath(config, fs) {
             const canonicalExistingPath = await fs.realpath(existingPath);
             const canonicalCacheDir = await fs.realpath(config.cacheDir);
             if (canonicalCacheDir !== resolve(config.cacheDir)) {
-                throw new Error("Cache path must remain inside its configured directory.");
+                throw new DiskCacheConfigError(CACHE_PATH_ERROR_MESSAGE);
             }
             assertContainedPath(canonicalCacheDir, canonicalExistingPath);
             return cachePath;
@@ -116,7 +132,16 @@ async function writeCacheFileOnce(temporaryPath, filePath, content, fs) {
 function assertContainedPath(basePath, targetPath) {
     const relativePath = relative(resolve(basePath), resolve(targetPath));
     if (relativePath === ".." || relativePath.startsWith(`..${pathSeparator()}`) || isAbsolute(relativePath)) {
-        throw new Error("Cache path must remain inside its configured directory.");
+        throw new DiskCacheConfigError(CACHE_PATH_ERROR_MESSAGE);
+    }
+}
+function assertSafeAppName(appName) {
+    if (appName.length === 0 ||
+        appName === "." ||
+        appName === ".." ||
+        appName.includes("/") ||
+        appName.includes("\\")) {
+        throw new Error("appName must be a single non-empty directory name");
     }
 }
 function pathSeparator() {