@playq/core 0.2.77

package/dist/scripts/util.js

@@ -0,0 +1,376 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encryptUserInput = encryptUserInput;
+const readline = __importStar(require("readline"));
+const global_1 = require("../global");
+const clipboardy = __importStar(require("clipboardy"));
+const crypto = __importStar(require("crypto"));
+const totpHelper_1 = require("../helper/util/totp/totpHelper");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+let encryptedValue = '';
+let outputValue = '';
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+// Handle Ctrl+C gracefully
+process.on('SIGINT', () => {
+    console.log('\n🚪 Process interrupted by user (Ctrl+C)');
+    rl.close();
+    process.exit(0);
+});
+async function question(prompt) {
+    return new Promise(resolve => {
+        rl.question(prompt, (answer) => {
+            // Check for specific exit commands
+            if (answer.toLowerCase() === 'exit' ||
+                answer.toLowerCase() === 'quit' ||
+                answer.toLowerCase() === 'q' ||
+                answer === '\u001b') {
+                console.log('🚪 Exiting...');
+                rl.close();
+                process.exit(0);
+            }
+            resolve(answer);
+        });
+    });
+}
+async function encryptUserInput() {
+    try {
+        console.log('🔐 PlayQ Utility Helper\n');
+        console.log('💡 Type "exit", "quit", "q", or press Ctrl+C to exit anytime\n');
+        console.log('What would you like to do?');
+        console.log('1. Password (strong encryption)');
+        console.log('2. Text (strong encryption)');
+        console.log('3. Decrypt');
+        console.log('4. Generate 32bit Key');
+        console.log('5. Generate TOTP Code');
+        console.log('6. Generate API Schema from OpenAPI');
+        console.log('7. Exit');
+        const choice = await question('\nEnter your choice (1-7): ');
+        switch (choice) {
+            case '1':
+                await encryptPassword();
+                break;
+            case '2':
+                await encryptText();
+                break;
+            case '3':
+                await decrypt();
+                break;
+            case '4':
+                await generate32ByteKey();
+                break;
+            case '5':
+                await generateTotpCode();
+                break;
+            case '6':
+                await generateApiSchema();
+                break;
+            case '7':
+                console.log('🚪 Goodbye!');
+                return;
+            default:
+                console.log('❌ Invalid choice. Please run again.');
+                break;
+        }
+        // Ask user what to copy to clipboard (only for encryption/decryption operations)
+        if (choice !== '6') { // Skip clipboard for schema generation
+            console.log('\nWhat would you like to copy to clipboard?');
+            console.log('1. Copy encrypted value');
+            console.log('2. Nothing (skip copy)');
+            console.log('3. Exit');
+            const copyChoice = await question('Enter choice (1-3): ');
+            switch (copyChoice) {
+                case '1':
+                    if (encryptedValue) {
+                        await copyToClipboard(encryptedValue, 'Encrypted Password');
+                    }
+                    else if (outputValue) {
+                        await copyToClipboard(outputValue, 'Output Value');
+                    }
+                    else {
+                        console.log('❌ No encrypted / output value to copy');
+                    }
+                    break;
+                case '2':
+                    console.log('📋 Skipped copying to clipboard');
+                    break;
+                case '3':
+                    console.log('🚪 Exiting...');
+                    break;
+                default:
+                    console.log('❌ Invalid choice');
+                    break;
+            }
+        }
+    }
+    catch (error) {
+        console.error('❌ Error:', error);
+    }
+    finally {
+        rl.close();
+    }
+}
+async function copyToClipboard(text, description) {
+    try {
+        await clipboardy.default.write(text);
+        console.log(`✅ ${description} copied to clipboard!`);
+        console.log(`📋 Copied: ${text.length > 50 ? text.substring(0, 50) + '...' : text}`);
+    }
+    catch (error) {
+        console.error('❌ Failed to copy to clipboard:', error);
+        console.log('📝 Manual copy:');
+        console.log(text);
+    }
+}
+async function encryptPassword() {
+    const passwordText = await question('Enter password to encrypt (or "exit" to quit): ');
+    if (!passwordText) {
+        console.log('❌ Password cannot be empty');
+        return;
+    }
+    try {
+        console.log('🔄 Encrypting password...');
+        encryptedValue = await global_1.comm.encryptPassword(passwordText);
+        console.log('\n📋 🔐 Encrypted Password Result:');
+        console.log('='.repeat(50));
+        console.log(encryptedValue);
+        console.log('='.repeat(50));
+    }
+    catch (error) {
+        console.error('❌ Encryption failed:', error);
+    }
+}
+async function encryptText() {
+    const encryptText = await question('Enter text to encrypt (or "exit" to quit): ');
+    if (!encryptText) {
+        console.log('❌ Text cannot be empty');
+        return;
+    }
+    try {
+        console.log('🔄 Encrypting text...');
+        encryptedValue = await global_1.comm.encryptText(encryptText);
+        console.log('\n📋 🔐 Encrypted Text Result:');
+        console.log('='.repeat(50));
+        console.log(encryptedValue);
+        console.log('='.repeat(50));
+    }
+    catch (error) {
+        console.error('❌ Encryption failed:', error);
+    }
+}
+async function decrypt() {
+    const decryptText = await question('Enter text to decrypt (or "exit" to quit): ');
+    if (!decryptText) {
+        console.log('❌ Text cannot be empty');
+        return;
+    }
+    try {
+        console.log('🔄 Decrypting text...');
+        encryptedValue = await global_1.vars.replaceVariables('#{' + decryptText + '}');
+        console.log('\n📋 🔓 Decrypted Text Result:');
+        console.log('='.repeat(50));
+        console.log(encryptedValue);
+        console.log('='.repeat(50));
+    }
+    catch (error) {
+        console.error('❌ Decryption failed:', error);
+    }
+}
+async function generate32ByteKey() {
+    try {
+        const key = crypto.randomBytes(32).toString('hex');
+        encryptedValue = key;
+        console.log('\n🔑 32-byte Key Generated:');
+        console.log('='.repeat(50));
+        console.log(key);
+        console.log('='.repeat(50));
+    }
+    catch (error) {
+        console.error('❌ Failed to generate key:', error);
+    }
+}
+async function generateTotpCode() {
+    try {
+        let secretKey = process.env.PLAYQ_TOTP_SECRET_KEY;
+        if (!secretKey) {
+            const inputSecret = await question('Enter TOTP secret key (or "exit" to quit): ');
+            if (!inputSecret) {
+                throw new Error('❌ TOTP secret key cannot be empty');
+            }
+            process.env.PLAYQ_TOTP_SECRET_KEY = inputSecret;
+            secretKey = inputSecret;
+        }
+        if (secretKey.startsWith("enc.")) {
+            secretKey = global_1.vars.replaceVariables(`#{${secretKey}}`);
+        }
+        // const secret = crypto.randomBytes(20).toString('hex');
+        const totpHelper = new totpHelper_1.TOTPHelper(secretKey);
+        const token = totpHelper.generateToken();
+        outputValue = token;
+        console.log('\n🔑 TOTP Code Generated:');
+        console.log('='.repeat(50));
+        console.log(token);
+        console.log('='.repeat(50));
+    }
+    catch (error) {
+        console.error('❌ Failed to generate TOTP code:', error);
+    }
+}
+async function generateApiSchema() {
+    try {
+        console.log('\n📋 API Schema Generator');
+        console.log('Generate TypeScript schema files from OpenAPI specifications\n');
+        console.log('Select input source:');
+        console.log('1. URL (HTTP/HTTPS)');
+        console.log('2. Local file path');
+        const sourceChoice = await question('Enter choice (1-2): ');
+        let input = '';
+        let url = '';
+        if (sourceChoice === '1') {
+            url = await question('Enter OpenAPI JSON URL: ');
+            if (!url) {
+                console.log('❌ URL cannot be empty');
+                return;
+            }
+        }
+        else if (sourceChoice === '2') {
+            input = await question('Enter path to OpenAPI JSON file: ');
+            if (!input) {
+                console.log('❌ File path cannot be empty');
+                return;
+            }
+        }
+        else {
+            console.log('❌ Invalid choice');
+            return;
+        }
+        const outDir = await question('Enter output directory (default: resources/schemas): ') || 'resources/schemas';
+        const prefix = await question('Enter export name prefix (optional, e.g., "Api"): ') || '';
+        const indexFile = await question('Enter index file name (default: index.ts): ') || 'index.ts';
+        console.log('\n🔄 Generating schema files...');
+        await generateSchemaFiles({
+            input: input || undefined,
+            url: url || undefined,
+            outDir,
+            prefix,
+            indexFile
+        });
+        console.log('✅ Schema generation completed successfully!');
+        outputValue = `Schema files generated in: ${path.resolve(outDir)}`;
+    }
+    catch (error) {
+        console.error('❌ Failed to generate API schema:', error);
+    }
+}
+async function loadOpenApi(args) {
+    if (args.input) {
+        const p = path.resolve(args.input);
+        const raw = fs.readFileSync(p, "utf8");
+        return JSON.parse(raw);
+    }
+    // URL
+    const res = await fetch(args.url, {
+        headers: { Accept: "application/json" },
+    });
+    if (!res.ok) {
+        throw new Error(`Failed to fetch OpenAPI JSON from ${args.url}. HTTP ${res.status}`);
+    }
+    return (await res.json());
+}
+function safeIdent(name) {
+    // Make a valid TS identifier-ish name (keeps underscores)
+    const cleaned = name.replace(/[^a-zA-Z0-9_]/g, "_");
+    // Avoid leading digit
+    if (/^\d/.test(cleaned))
+        return "_" + cleaned;
+    return cleaned;
+}
+function exportNameFor(schemaName, prefix) {
+    // AgentVersion -> AgentVersionSchema, optional prefix -> ApiAgentVersionSchema
+    const base = `${schemaName}Schema`;
+    return prefix ? `${prefix}${base}` : base;
+}
+function ensureOutDir(outDir) {
+    fs.mkdirSync(outDir, { recursive: true });
+}
+function writeSchemaFile(outDir, schemaKey, exportName, schema, openapiVersion) {
+    const fileName = `${schemaKey}.schema.ts`;
+    const fullPath = path.join(outDir, fileName);
+    const content = `/* Auto-generated by PlayQ schema generator - OpenAPI ${openapiVersion} */\n` +
+        `/* Source schema: #/components/schemas/${schemaKey} */\n\n` +
+        `export const ${exportName} = ${JSON.stringify(schema, null, 2)} as const;\n`;
+    fs.writeFileSync(fullPath, content, "utf8");
+}
+function writeIndexFile(outDir, indexFile, entries) {
+    const fullPath = path.join(outDir, indexFile);
+    const lines = entries
+        .sort((a, b) => a.schemaKey.localeCompare(b.schemaKey))
+        .map(e => `export { ${e.exportName} } from "./${e.schemaKey}.schema";`);
+    fs.writeFileSync(fullPath, lines.join("\n") + "\n", "utf8");
+}
+async function generateSchemaFiles(args) {
+    var _a, _b, _c;
+    const doc = await loadOpenApi(args);
+    if (!((_a = doc.openapi) === null || _a === void 0 ? void 0 : _a.startsWith("3.1"))) {
+        // still might work, but you said OAS 3.1 and this generator assumes that
+        console.warn(`⚠️ OpenAPI version is "${doc.openapi}". Generator is optimised for 3.1.x.`);
+    }
+    const schemas = (_c = (_b = doc.components) === null || _b === void 0 ? void 0 : _b.schemas) !== null && _c !== void 0 ? _c : {};
+    const schemaKeys = Object.keys(schemas);
+    if (!schemaKeys.length) {
+        throw new Error(`No components.schemas found in the OpenAPI document.`);
+    }
+    const outDir = path.resolve(args.outDir);
+    ensureOutDir(outDir);
+    const indexEntries = [];
+    for (const rawKey of schemaKeys) {
+        const schemaKey = safeIdent(rawKey);
+        const exportName = exportNameFor(schemaKey, args.prefix);
+        const schema = schemas[rawKey];
+        writeSchemaFile(outDir, schemaKey, exportName, schema, doc.openapi);
+        indexEntries.push({ schemaKey, exportName });
+    }
+    writeIndexFile(outDir, args.indexFile, indexEntries);
+    console.log(`✅ Generated ${schemaKeys.length} schemas into: ${outDir}`);
+    console.log(`✅ Barrel export: ${path.join(outDir, args.indexFile)}`);
+}
+// Main execution
+if (require.main === module) {
+    encryptUserInput();
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@playq/core",
+  "version": "0.2.77",
+  "description": "PlayQ Core (Phase 1) - raw TypeScript sources only.",
+  "files": [
+    "bin",
+    "dist",
+    "src",
+    "tsconfig.json",
+    "cucumber.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json || echo 'Skipping build (non-critical errors)'",
+    "prepublishOnly": "npm run build",
+    "util": "ts-node -r tsconfig-paths/register src/scripts/util.ts"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./src/*": "./src/*",
+    "./dist/*": "./dist/*",
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@e965/xlsx": "^0.20.3",
+    "@faker-js/faker": "^9.6.0",
+    "allure-js-commons": "^2.14.0",
+    "axios": "^1.10.0",
+    "clipboardy": "^4.0.0",
+    "csv-parser": "^3.2.0",
+    "dotenv": "^16.0.3",
+    "minimist": "^1.2.8",
+    "otplib": "^12.0.1",
+    "qrcode": "^1.5.4",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "winston": "^3.8.2",
+    "yargs": "^18.0.0",
+    "ajv": "^8.0.0"
+  },
+  "keywords": [
+    "playwright",
+    "cucumber",
+    "test",
+    "automation",
+    "playq"
+  ],
+  "author": "NCS",
+  "license": "ISC",
+  "peerDependencies": {
+    "@cucumber/cucumber": "^12.1.0",
+    "@playwright/test": "^1.53.1",
+    "playwright": "^1.53.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.27",
+    "typescript": "^5.6.3"
+  },
+  "bin": {
+    "playq": "bin/playq.js"
+  }
+}

package/src/exec/featureFileCache.ts

@@ -0,0 +1,80 @@
+import fs from 'fs';
+import path from 'path';
+import * as vars from '../helper/bundle/vars';
+const config: any = {};
+
+const FEATURE_META_PATH = path.resolve('_Temp/.cache/featureMeta.json');
+
+/**
+ * Returns the path to the cached feature file inside _Temp/execution/
+ */
+export function getCachedFeatureFilePath(originalPath: string): string {
+  const filename = path.basename(originalPath);
+  return path.resolve('_Temp/execution', filename);
+}
+
+/**
+ * Determines if the cached feature should be used.
+ * Checks:
+ *  - config.cucumber.featureFileCache is enabled
+ *  - cached file and metadata exist
+ *  - cached timestamp is newer than original file
+ */
+export function shouldUseCachedFeature(originalPath: string, cachedPath: string): boolean {
+  // Logging for cache check
+  console.log(`🔍 Cache check started for: ${originalPath}`);
+  if (!config?.cucumber?.featureFileCache || vars.getConfigValue('cucumber.featureFileCache')) return false;
+  if (!fs.existsSync(cachedPath)) return false;
+  if (!fs.existsSync(FEATURE_META_PATH)) return false;
+  try {
+    const meta = JSON.parse(fs.readFileSync(FEATURE_META_PATH, 'utf-8'));
+    const originalStats = fs.statSync(originalPath);
+    const cachedMeta = meta[originalPath];
+    console.log(`📄 Cached Meta:`, cachedMeta);
+    if (!cachedMeta) return false;
+    const originalTime = originalStats.mtimeMs;
+    const metaTime = new Date(cachedMeta.updatedAt).getTime();
+    console.log(`📆 Original mtime: ${originalTime} | Cached updatedAt: ${metaTime}`);
+    console.log(`✅ Should use cache: ${metaTime >= originalTime}`);
+    return metaTime >= originalTime;
+  } catch (err) {
+    console.warn(`⚠️ Cache check failed. Proceeding without cache.`, err);
+    return false;
+  }
+}
+
+/**
+ * Updates the feature cache metadata file.
+ * Ensures _Temp/.cache/featureMeta.json exists, and writes { filePath, updatedAt }.
+ */
+export function updateFeatureCacheMeta(originalPath: string, cachedPath: string): void {
+  const dir = path.dirname(FEATURE_META_PATH);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  let meta: Record<string, any> = {};
+  if (fs.existsSync(FEATURE_META_PATH)) {
+    try {
+      meta = JSON.parse(fs.readFileSync(FEATURE_META_PATH, 'utf-8'));
+    } catch {
+      console.warn('⚠️ Failed to parse featureMeta.json. Overwriting.');
+    }
+  }
+  meta[originalPath] = {
+    filePath: cachedPath,
+    updatedAt: new Date().toISOString()
+  };
+  fs.writeFileSync(FEATURE_META_PATH, JSON.stringify(meta, null, 2), 'utf-8');
+  console.log(`💾 Feature cache metadata updated for: ${originalPath}`);
+}
+
+/**
+ * Writes feature content to cache if valid.
+ */
+export function writeFeatureToCache(cachedPath: string, content: string): void {
+  if (!content.trim().startsWith('Feature')) {
+    console.warn(`❌ Skipping cache write: Content does not start with "Feature". Content preview:\n${content.substring(0, 100)}`);
+    return;
+  }
+  fs.writeFileSync(cachedPath, content, 'utf8');
+}