recker 1.0.20-next.de24f7d → 1.0.20-next.e194d90

package/dist/cache/file-storage.js

@@ -1,50 +1,195 @@
-import { mkdir, readFile, writeFile, unlink, rm } from 'node:fs/promises';
+import { promises as fs, existsSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
-import { createHash } from 'node:crypto';
-import { existsSync } from 'node:fs';
-export class FileStorage {
-    dir;
-    constructor(baseDir = '.recker/cache') {
-        this.dir = baseDir;
+import { tmpdir } from 'node:os';
+export class FileSystemStorage {
+    cacheDir;
+    defaultTtl;
+    cleanupInterval;
+    maxSize;
+    cleanupTimer = null;
+    constructor(options = {}) {
+        this.cacheDir = options.path || join(tmpdir(), 'recker-cache');
+        this.defaultTtl = options.ttl ?? 300000;
+        this.cleanupInterval = options.cleanupInterval ?? 60000;
+        this.maxSize = options.maxSize ?? 0;
+        this.initCacheDir();
+        if (this.cleanupInterval > 0) {
+            this.cleanupTimer = setInterval(() => this.cleanupExpired(), this.cleanupInterval);
+            this.cleanupTimer.unref();
+        }
     }
-    getHash(key) {
-        return createHash('md5').update(key).digest('hex');
+    initCacheDir() {
+        if (!existsSync(this.cacheDir)) {
+            mkdirSync(this.cacheDir, { recursive: true });
+        }
     }
-    getPath(key) {
-        return join(this.dir, `${this.getHash(key)}.json`);
+    getFilePath(key) {
+        const safeKey = Buffer.from(key).toString('base64url');
+        return join(this.cacheDir, safeKey + '.json');
     }
-    async ensureDir() {
-        if (!existsSync(this.dir)) {
-            await mkdir(this.dir, { recursive: true });
+    async isExpired(filePath, entry) {
+        const now = Date.now();
+        if (entry.expires && now > entry.expires) {
+            return true;
+        }
+        try {
+            const stats = await fs.stat(filePath);
+            const fileAge = now - stats.mtimeMs;
+            if (fileAge > (entry.maxAge ? entry.maxAge * 1000 : this.defaultTtl)) {
+                return true;
+            }
         }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return true;
+            }
+            throw error;
+        }
+        return false;
     }
     async get(key) {
+        const filePath = this.getFilePath(key);
         try {
-            const path = this.getPath(key);
-            if (!existsSync(path))
+            const fileContent = await fs.readFile(filePath, 'utf8');
+            const entry = JSON.parse(fileContent);
+            if (await this.isExpired(filePath, entry)) {
+                await this.delete(key);
                 return undefined;
-            const content = await readFile(path, 'utf-8');
-            const data = JSON.parse(content);
-            return data;
+            }
+            return entry;
         }
         catch (error) {
-            return undefined;
+            if (error.code === 'ENOENT') {
+                return undefined;
+            }
+            else if (error instanceof SyntaxError) {
+                await this.delete(key);
+                return undefined;
+            }
+            throw error;
         }
     }
-    async set(key, entry, ttl) {
-        await this.ensureDir();
-        const path = this.getPath(key);
-        await writeFile(path, JSON.stringify(entry), 'utf-8');
+    async set(key, value, ttl) {
+        const filePath = this.getFilePath(key);
+        const effectiveTtl = ttl ?? this.defaultTtl;
+        const now = Date.now();
+        if (!value.expires || value.expires < now) {
+            value.expires = now + effectiveTtl;
+        }
+        const fileContent = JSON.stringify(value);
+        try {
+            await fs.writeFile(filePath, fileContent, 'utf8');
+            if (this.maxSize > 0) {
+                await this.enforceMaxSize();
+            }
+        }
+        catch (error) {
+            console.error(`Error writing cache file ${filePath}:`, error);
+        }
     }
     async delete(key) {
-        const path = this.getPath(key);
-        if (existsSync(path)) {
-            await unlink(path);
+        const filePath = this.getFilePath(key);
+        try {
+            await fs.unlink(filePath);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                console.error(`Error deleting cache file ${filePath}:`, error);
+            }
+        }
+    }
+    async clear(prefix) {
+        const files = await fs.readdir(this.cacheDir);
+        for (const file of files) {
+            const filePath = join(this.cacheDir, file);
+            const key = Buffer.from(file.replace(/\.json$/, ''), 'base64url').toString('utf8');
+            if (!prefix || key.startsWith(prefix)) {
+                try {
+                    await fs.unlink(filePath);
+                }
+                catch (error) {
+                    console.error(`Error clearing cache file ${filePath}:`, error);
+                }
+            }
+        }
+    }
+    async size() {
+        const files = await fs.readdir(this.cacheDir);
+        return files.length;
+    }
+    async keys() {
+        const files = await fs.readdir(this.cacheDir);
+        const keys = [];
+        for (const file of files) {
+            keys.push(Buffer.from(file.replace(/\.json$/, ''), 'base64url').toString('utf8'));
+        }
+        return keys;
+    }
+    async cleanupExpired() {
+        const files = await fs.readdir(this.cacheDir);
+        const now = Date.now();
+        const candidates = [];
+        for (const file of files) {
+            const filePath = join(this.cacheDir, file);
+            try {
+                const stats = await fs.stat(filePath);
+                const fileContent = await fs.readFile(filePath, 'utf8');
+                const entry = JSON.parse(fileContent);
+                if (entry.expires && now > entry.expires) {
+                    await fs.unlink(filePath);
+                    continue;
+                }
+                if (!entry.expires && (now - stats.mtimeMs) > this.defaultTtl) {
+                    await fs.unlink(filePath);
+                    continue;
+                }
+                candidates.push({ path: filePath, entry, mtimeMs: stats.mtimeMs });
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT' && error instanceof SyntaxError) {
+                    console.error(`Warning: Corrupted cache file ${filePath}, deleting...`, error);
+                }
+                await fs.unlink(filePath).catch(() => { });
+            }
+        }
+        if (this.maxSize > 0) {
+            await this.enforceMaxSize();
+        }
+    }
+    async enforceMaxSize() {
+        if (this.maxSize <= 0)
+            return;
+        let files = await fs.readdir(this.cacheDir);
+        if (files.length <= this.maxSize)
+            return;
+        const fileStats = await Promise.all(files.map(async (file) => {
+            const filePath = join(this.cacheDir, file);
+            try {
+                const stats = await fs.stat(filePath);
+                return { path: filePath, mtimeMs: stats.mtimeMs };
+            }
+            catch {
+                return null;
+            }
+        }));
+        const validFiles = fileStats.filter(s => s !== null);
+        validFiles.sort((a, b) => a.mtimeMs - b.mtimeMs);
+        while (validFiles.length > this.maxSize) {
+            const oldestFile = validFiles.shift();
+            if (oldestFile) {
+                try {
+                    await fs.unlink(oldestFile.path);
+                }
+                catch (error) {
+                    console.error(`Error enforcing maxSize for file ${oldestFile.path}:`, error);
+                }
+            }
         }
     }
-    async clear() {
-        if (existsSync(this.dir)) {
-            await rm(this.dir, { recursive: true, force: true });
+    shutdown() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = null;
         }
     }
 }

package/dist/cache/memory-limits.d.ts

@@ -18,4 +18,3 @@ export declare function getHeapStats(): {
     heapLimit: number;
     heapRatio: number;
 };
-//# sourceMappingURL=memory-limits.d.ts.map

package/dist/cache/memory-storage.d.ts

@@ -130,4 +130,3 @@ export declare class MemoryStorage implements CacheStorage {
     private memoryHealthCheck;
     private cleanupExpired;
 }
-//# sourceMappingURL=memory-storage.d.ts.map

package/dist/cache/redis-storage.d.ts

@@ -13,4 +13,3 @@ export declare class RedisStorage implements CacheStorage {
     delete(key: string): Promise<void>;
 }
 export {};
-//# sourceMappingURL=redis-storage.d.ts.map

package/dist/cli/handler.d.ts

@@ -4,8 +4,9 @@ interface RequestOptions {
     headers: Record<string, string>;
     body?: any;
     verbose?: boolean;
+    quiet?: boolean;
+    output?: string;
     presetConfig?: any;
 }
 export declare function handleRequest(options: RequestOptions): Promise<void>;
 export {};
-//# sourceMappingURL=handler.d.ts.map

package/dist/cli/handler.js

@@ -17,7 +17,14 @@ async function initDependencies() {
 }
 export async function handleRequest(options) {
     await initDependencies();
-    const spinner = ora({
+    if (options.quiet) {
+        process.stdout.on('error', (err) => {
+            if (err.code === 'EPIPE') {
+                process.exit(0);
+            }
+        });
+    }
+    const spinner = options.quiet ? null : ora({
         text: `${colors.bold(options.method)} ${colors.cyan(options.url)}`,
         color: 'cyan',
         spinner: 'dots'
@@ -64,7 +71,24 @@ export async function handleRequest(options) {
             body: requestBody
         });
         const duration = Math.round(performance.now() - start);
-        spinner.stop();
+        spinner?.stop();
+        const contentType = response.headers.get('content-type') || '';
+        const text = await response.text();
+        if (options.quiet) {
+            if (options.output) {
+                const fsPromises = await import('node:fs/promises');
+                await fsPromises.writeFile(options.output, text);
+                if (!response.ok) {
+                    process.exit(1);
+                }
+                return;
+            }
+            process.stdout.write(text);
+            if (!response.ok) {
+                process.exit(1);
+            }
+            return;
+        }
         const statusColor = response.ok ? colors.green : colors.red;
         console.log(`${statusColor(colors.bold(response.status))} ${statusColor(response.statusText)} ` +
             `${colors.gray(`(${duration}ms)`)}`);
@@ -86,8 +110,12 @@ export async function handleRequest(options) {
             });
             console.log(colors.gray('------------------------\n'));
         }
-        const contentType = response.headers.get('content-type') || '';
-        const text = await response.text();
+        if (options.output) {
+            const fsPromises = await import('node:fs/promises');
+            await fsPromises.writeFile(options.output, text);
+            console.log(colors.green(`✓ Saved to ${options.output}`));
+            return;
+        }
         if (!text)
             return;
         if (contentType.includes('application/json')) {
@@ -105,7 +133,10 @@ export async function handleRequest(options) {
         }
     }
     catch (error) {
-        spinner.fail(colors.red('Request Failed'));
+        if (options.quiet) {
+            process.exit(1);
+        }
+        spinner?.fail(colors.red('Request Failed'));
         throw error;
     }
 }

package/dist/cli/index.d.ts

@@ -1,3 +1 @@
-#!/usr/bin/env node
 export {};
-//# sourceMappingURL=index.d.ts.map