fenneckit 1.0.3 → 1.2.0

package/bin/fenneckit

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-require('../lib/fenneckit.js')
+import '../libs/fenneckit.js'

package/index.js

@@ -1,3 +1,3 @@
-import { newLabs, getStoreState, clearStore, } from "./libs/labs.js";
+import { newLabs } from "./libs/labs.js";
 import { testing } from "./libs/testing.js";
-export { newLabs, testing, getStoreState, clearStore };
+export { newLabs, testing };

package/libs/fenneckit.js

@@ -61,7 +61,7 @@ Usage:
         return;
     }
     if (args.includes("--version") || args.includes("-v")) {
-        console.log("FennecKit 🦊 v1.1.0-beta");
+        console.log("FennecKit 🦊 v1.0.4");
         return;
     }
     const singleFile = args.find(a => !a.startsWith("-"));

package/libs/labs.js

@@ -1,38 +1,306 @@
 /*==================================
 * Copyright 2026 lasith ruwantha amrwansha
-* Written by 2026/09/17
+* Written by 2026/09/20
 * Author: ruwantha amrwansha
 * Library: FennecKit 🦊
-* Version: 1.1.0-beta (with clearStore feature)
 *===================================*/
-import { access, writeFile } from "fs/promises";
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync, } from "crypto";
+import report from "../utility/report.js";
 import path from "path";
-const d = new Date();
-const nowDate = d.toISOString().split('T')[0].replaceAll('-', '/');
-const Store = new Map();
-const headOfRepotPath = `
-# FennecKit 🦊 Report
-
-**🚀 Version:** 1.1.0-beta
-**⏰ Date:** ${nowDate}
-**✨ Features:** Zero Config • Sequential Labs • Inter-Lab Data Sharing • Store Management
-
----\n\n
-`;
-async function writeRepot(data) {
-    const repotPath = path.join(process.cwd(), "fenneckit.md");
-    try {
-        await access(repotPath);
-        await writeFile(repotPath, data, { flag: 'a' });
+class SecretVault {
+    vault = new Map();
+    masterKey;
+    cipher = "aes-256-gcm";
+    keyLength = 32;
+    ivLength = 16;
+    constructor(password = "fenneckit-default") {
+        this.masterKey = scryptSync(password, "salt", this.keyLength);
+    }
+    encrypt(data) {
+        const iv = randomBytes(this.ivLength);
+        const cipher = createCipheriv(this.cipher, this.masterKey, iv);
+        let encrypted = cipher.update(data, "utf8");
+        encrypted = Buffer.concat([encrypted, cipher.final()]);
+        const tag = cipher.getAuthTag();
+        return { encrypted, iv, tag };
+    }
+    decrypt(data, iv, tag) {
+        const decipher = createDecipheriv(this.cipher, this.masterKey, iv);
+        decipher.setAuthTag(tag);
+        let decrypted = decipher.update(data);
+        decrypted = Buffer.concat([decrypted, decipher.final()]);
+        return decrypted.toString("utf8");
+    }
+    set(key, value) {
+        const { encrypted, iv, tag } = this.encrypt(value);
+        const stored = Buffer.concat([iv, tag, encrypted]);
+        this.vault.set(key, stored);
+    }
+    get(key) {
+        const stored = this.vault.get(key);
+        if (!stored)
+            return undefined;
+        try {
+            const iv = stored.slice(0, this.ivLength);
+            const tag = stored.slice(this.ivLength, this.ivLength + 16);
+            const encrypted = stored.slice(this.ivLength + 16);
+            return this.decrypt(encrypted, iv, tag);
+        }
+        catch {
+            console.error(`Failed to decrypt secret: ${key}`);
+            return undefined;
+        }
+    }
+    delete(key) {
+        this.vault.delete(key);
+    }
+    clear() {
+        this.vault.clear();
+    }
+    keys() {
+        return Array.from(this.vault.keys());
+    }
+}
+class NamespacedStore {
+    data = new Map();
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+    set(key, value) {
+        this.data.set(key, value);
+    }
+    get(key) {
+        return this.data.get(key);
+    }
+    delete(key) {
+        this.data.delete(key);
+    }
+    clear(key) {
+        if (key) {
+            this.data.delete(key);
+        }
+        else {
+            this.data.clear();
+        }
+    }
+    keys() {
+        return Array.from(this.data.keys());
+    }
+    entries() {
+        return Array.from(this.data.entries());
+    }
+    has(key) {
+        return this.data.has(key);
+    }
+    toJSON() {
+        const obj = {};
+        for (const [key, value] of this.data) {
+            obj[key] = value;
+        }
+        return obj;
+    }
+}
+class AuditLog {
+    entries = [];
+    record(entry) {
+        this.entries.push(entry);
+    }
+    getLog() {
+        return [...this.entries];
+    }
+    getLast(n) {
+        return this.entries.slice(-n);
+    }
+    filterByKey(key) {
+        return this.entries.filter((e) => e.key === key);
+    }
+    filterByOperation(op) {
+        return this.entries.filter((e) => e.operation === op);
+    }
+    filterByNamespace(ns) {
+        return this.entries.filter((e) => e.namespace === ns);
+    }
+    export(format) {
+        if (format === "json") {
+            return JSON.stringify(this.entries, null, 2);
+        }
+        if (format === "csv") {
+            const headers = [
+                "timestamp",
+                "lab",
+                "test",
+                "operation",
+                "namespace",
+                "key",
+                "dataType",
+                "success",
+            ].join(",");
+            const rows = this.entries.map((e) => [
+                e.timestamp,
+                e.lab,
+                e.test,
+                e.operation,
+                e.namespace || "",
+                e.key,
+                e.dataType,
+                e.success ? "true" : "false",
+            ].join(","));
+            return [headers, ...rows].join("\n");
+        }
+        return "";
+    }
+    clear() {
+        this.entries = [];
+    }
+}
+class HttpKit {
+    authHeader = null;
+    requestHistory = [];
+    baseHeaders = {
+        "Content-Type": "application/json",
+        "User-Agent": "FennecKit/1.2.0",
+    };
+    setAuth(type, credentials) {
+        this.authHeader = { type, value: credentials };
     }
-    catch {
-        await writeFile(repotPath, headOfRepotPath + data);
+    clearAuth() {
+        this.authHeader = null;
+    }
+    getAuthHeader() {
+        if (!this.authHeader)
+            return {};
+        if (this.authHeader.type === "bearer") {
+            return { Authorization: `Bearer ${this.authHeader.value}` };
+        }
+        else if (this.authHeader.type === "api-key") {
+            return { "X-API-Key": this.authHeader.value };
+        }
+        else if (this.authHeader.type === "basic") {
+            return { Authorization: `Basic ${this.authHeader.value}` };
+        }
+        return {};
+    }
+    async makeRequest(method, url, body, options = {}) {
+        const startTime = Date.now();
+        const requestId = `req_\( {Date.now()}_ \){Math.random().toString(36).substr(2, 9)}`;
+        const headers = {
+            ...this.baseHeaders,
+            ...this.getAuthHeader(),
+            ...(options.headers || {}),
+        };
+        // Use AbortController for timeout (RequestInit does not support `timeout`)
+        const controller = new AbortController();
+        const timeoutMs = options.timeout ?? 30000;
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        const reqConfig = {
+            method,
+            headers,
+            signal: controller.signal,
+            redirect: options.followRedirects !== false ? "follow" : "manual",
+        };
+        if (body) {
+            reqConfig.body = typeof body === "string" ? body : JSON.stringify(body);
+        }
+        let lastError = null;
+        const maxRetries = options.retry?.max || 1;
+        const retryDelay = options.retry?.delay || 1000;
+        try {
+            for (let attempt = 0; attempt < maxRetries; attempt++) {
+                try {
+                    const response = await fetch(url, reqConfig);
+                    const duration = Date.now() - startTime;
+                    let data = null;
+                    const contentType = response.headers.get("content-type");
+                    if (contentType?.includes("application/json")) {
+                        data = await response.json();
+                    }
+                    else {
+                        data = await response.text();
+                    }
+                    const httpResponse = {
+                        status: response.status,
+                        statusText: response.statusText,
+                        headers: Object.fromEntries(response.headers.entries()),
+                        data,
+                        raw: response,
+                    };
+                    this.recordRequest({
+                        id: requestId,
+                        timestamp: new Date().toISOString(),
+                        method,
+                        url,
+                        status: response.status,
+                        duration,
+                        headers,
+                        requestBody: body,
+                        responseBody: data,
+                    });
+                    return httpResponse;
+                }
+                catch (error) {
+                    lastError = error;
+                    if (attempt < maxRetries - 1) {
+                        await new Promise((resolve) => setTimeout(resolve, retryDelay));
+                    }
+                }
+            }
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+        const duration = Date.now() - startTime;
+        this.recordRequest({
+            id: requestId,
+            timestamp: new Date().toISOString(),
+            method,
+            url,
+            status: 0,
+            duration,
+            headers,
+            requestBody: body,
+            error: lastError?.message,
+        });
+        throw lastError || new Error(`HTTP request failed: ${method} ${url}`);
+    }
+    recordRequest(req) {
+        this.requestHistory.push(req);
+    }
+    async get(url, options) {
+        return this.makeRequest("GET", url, undefined, options);
+    }
+    async post(url, body, options) {
+        return this.makeRequest("POST", url, body, options);
+    }
+    async put(url, body, options) {
+        return this.makeRequest("PUT", url, body, options);
+    }
+    async patch(url, body, options) {
+        return this.makeRequest("PATCH", url, body, options);
+    }
+    async delete(url, options) {
+        return this.makeRequest("DELETE", url, undefined, options);
+    }
+    getRequestHistory() {
+        return [...this.requestHistory];
+    }
+    clearHistory() {
+        this.requestHistory = [];
+    }
+    getLastRequest() {
+        return this.requestHistory[this.requestHistory.length - 1];
     }
 }
 export async function newLabs(name, fn, retCount = 0) {
     let logs = `## ${name} 🌏\n\n\`\`\`\n`;
     let currentTest = "";
+    const Store = new Map();
+    const secretVault = new SecretVault();
+    const namespaces = new Map();
     const temp = new Map();
+    const http = new HttpKit();
+    const audit = new AuditLog();
+    const ttlMap = new Map();
     const Context = {
         out: () => {
             throw new Error("__Lab_Out__");
@@ -66,26 +334,91 @@ export async function newLabs(name, fn, retCount = 0) {
             logs += `[🟡] ${currentTest}: ${msg}\n`;
             console.log(`  ⚠️ [Warning] ${currentTest} -> ${msg}`);
         },
+        // Store
         setStore: (key, value) => {
             logs += `[⚙️] [STORE] set "${key}"\n`;
             Store.set(key, value);
+            audit.record({
+                timestamp: new Date().toISOString(),
+                lab: name,
+                test: currentTest,
+                operation: "set",
+                key,
+                dataType: typeof value,
+                success: true,
+            });
         },
         getStore: (key) => {
             logs += `[⚙️] [STORE] get "${key}"\n`;
+            audit.record({
+                timestamp: new Date().toISOString(),
+                lab: name,
+                test: currentTest,
+                operation: "get",
+                key,
+                dataType: "unknown",
+                success: true,
+            });
             return Store.get(key);
         },
         clearStore: (key) => {
             if (key) {
                 logs += `[⚙️] [STORE] cleared key "${key}"\n`;
-                console.log(`  🧹 [Store] Cleared: "${key}"`);
                 Store.delete(key);
             }
             else {
                 logs += `[⚙️] [STORE] cleared all data\n`;
-                console.log(`  🧹 [Store] Cleared all Store data`);
                 Store.clear();
             }
         },
+        // Secrets
+        setSecret: (key, value) => {
+            logs += `[🔐] [SECRET] set "${key}"\n`;
+            secretVault.set(key, value);
+            audit.record({
+                timestamp: new Date().toISOString(),
+                lab: name,
+                test: currentTest,
+                operation: "setSecret",
+                key,
+                dataType: "secret",
+                success: true,
+            });
+        },
+        getSecret: (key) => {
+            logs += `[🔐] [SECRET] get "${key}"\n`;
+            audit.record({
+                timestamp: new Date().toISOString(),
+                lab: name,
+                test: currentTest,
+                operation: "getSecret",
+                key,
+                dataType: "secret",
+                success: true,
+            });
+            return secretVault.get(key);
+        },
+        clearSecret: (key) => {
+            if (key) {
+                logs += `[🔐] [SECRET] cleared key "${key}"\n`;
+                secretVault.delete(key);
+            }
+            else {
+                logs += `[🔐] [SECRET] cleared all data\n`;
+                secretVault.clear();
+            }
+        },
+        // Namespaces
+        namespace: (ns) => {
+            if (!namespaces.has(ns)) {
+                namespaces.set(ns, new NamespacedStore(ns));
+            }
+            return namespaces.get(ns);
+        },
+        getNamespace: (ns) => {
+            return namespaces.get(ns);
+        },
+        // Temp
         setTemp: (key, value) => {
             logs += `[⏱️] [TEMP] set "${key}"\n`;
             temp.set(key, value);
@@ -94,6 +427,34 @@ export async function newLabs(name, fn, retCount = 0) {
             logs += `[⏱️] [TEMP] get "${key}"\n`;
             return temp.get(key);
         },
+        http,
+        audit,
+        // TTL
+        setStoreWithTTL: (key, value, ttlMs) => {
+            Context.setStore(key, value);
+            const existingTimer = ttlMap.get(key);
+            if (existingTimer)
+                clearTimeout(existingTimer);
+            const timer = setTimeout(() => {
+                Store.delete(key);
+                ttlMap.delete(key);
+                logs += `[⏰] [TTL] expired key "${key}"\n`;
+            }, ttlMs);
+            ttlMap.set(key, timer);
+        },
+        setSecretWithTTL: (key, value, ttlMs) => {
+            Context.setSecret(key, value);
+            const existingTimer = ttlMap.get(`secret:${key}`);
+            if (existingTimer)
+                clearTimeout(existingTimer);
+            const timer = setTimeout(() => {
+                secretVault.delete(key);
+                ttlMap.delete(`secret:${key}`);
+                logs += `[⏰] [TTL] expired secret "${key}"\n`;
+            }, ttlMs);
+            ttlMap.set(`secret:${key}`, timer);
+        },
+        // Testing
         test: async (testName, testFn) => {
             currentTest = testName;
             try {
@@ -103,7 +464,7 @@ export async function newLabs(name, fn, retCount = 0) {
                 console.log(`  🐛 [Bug Exception] in "${testName}":`, e.message || e);
                 throw e;
             }
-        }
+        },
     };
     console.log(`\n🔬 [Lab Initiated]: ${name}`);
     try {
@@ -113,36 +474,22 @@ export async function newLabs(name, fn, retCount = 0) {
         if (err.message === "__Lab_Out__") {
             logs += "```\n";
             temp.clear();
-            return await writeRepot(logs);
+            ttlMap.forEach((timer) => clearTimeout(timer));
+            // Write report here
+            return;
         }
         else if (err.message === "__Restart__") {
+            // Fixed: was newLabsV12
             return newLabs(name, fn, retCount + 1);
         }
         console.log(`❌ [Lab Failed]: ${name}\n`);
-        await writeRepot(logs + "```\n");
         temp.clear();
+        ttlMap.forEach((timer) => clearTimeout(timer));
         return;
     }
     logs += "```\n";
+    await report(logs);
     console.log(`✅ [Lab Success]: ${name} completed successfully.\n`);
     temp.clear();
-    await writeRepot(logs);
-}
-// Global Store hadels
-export function clearStore(key) {
-    if (key) {
-        Store.delete(key);
-        console.log(`🧹 [Global] Cleared store key: "${key}"`);
-    }
-    else {
-        Store.clear();
-        console.log(`🧹 [Global] Cleared all Store data`);
-    }
-}
-export function getStoreState() {
-    return new Map(Store);
+    ttlMap.forEach((timer) => clearTimeout(timer));
 }
-process.on('exit', () => {
-    console.log("[⛔] All Labs stopped");
-    Store.clear();
-});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fenneckit",
-  "version": "1.0.3",
+  "version": "1.2.0",
   "description": "A tiny, fast & adorable testing kit. Lightweight test framework with zero config – easy to hold, easy to run.",
   "keywords": [
     "testing",
@@ -34,11 +34,12 @@
     "build": "tsc",
     "test": "cd test && node ../dist/libs/fenneckit.js"
   },
-  "bin":{
-   "fenneckit": "./bin/fenneckit"
+  "bin": {
+    "fenneckit": "./bin/fenneckit"
   },
   "dependencies": {
     "chalk": "^6.0.0",
+    "crypto": "^1.0.1",
     "fs-extra": "^11.4.0",
     "path": "^0.12.7"
   },

package/utility/report.js

@@ -0,0 +1,26 @@
+import { access, writeFile } from "fs/promises";
+import path from "path";
+const d = new Date();
+const nowDate = d.toISOString().split('T')[0].replaceAll('-', '/');
+const Store = new Map();
+const headOfRepotPath = `
+# FennecKit 🦊 Report
+
+**🚀 Version:** 1.2.0
+
+**⏰ Date:** ${nowDate}
+
+**✨ Features:** Zero Config • Sequential Labs • Inter-Lab Data Sharing • Store Management
+
+---\n\n
+`;
+export default async function report(data) {
+    const repotPath = path.join(process.cwd(), "fenneckit.md");
+    try {
+        await access(repotPath);
+        await writeFile(repotPath, data, { flag: 'a' });
+    }
+    catch {
+        await writeFile(repotPath, headOfRepotPath + data);
+    }
+}