chrome-ext-ci-cd 1.0.0

package/lib/init.js

@@ -0,0 +1,232 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { parseArgs } = require('node:util');
+
+// --- Constants ---
+
+const TEMPLATE_DIR = path.join(__dirname, '..', 'templates');
+
+const FILES_TO_SCAFFOLD = [
+  { src: 'release.yml', dest: '.github/workflows/release.yml', label: 'GitHub Actions workflow' },
+  { src: 'extensionignore', dest: '.extensionignore', label: 'Extension ignore patterns' },
+  { src: 'nvmrc', dest: '.nvmrc', label: 'Node version file' },
+];
+
+const SCRIPTS_TO_INJECT = {
+  'ext:validate': 'chrome-ext-ci-cd validate',
+  'ext:package': 'chrome-ext-ci-cd package',
+  'ext:release:patch': 'chrome-ext-ci-cd release patch',
+  'ext:release:minor': 'chrome-ext-ci-cd release minor',
+  'ext:release:major': 'chrome-ext-ci-cd release major',
+};
+
+// --- Pure Init Function ---
+
+function init(projectDir, options) {
+  var dir = projectDir || process.cwd();
+  var opts = options || {};
+  var errors = [];
+  var warnings = [];
+  var created = [];
+  var skipped = [];
+  var scriptsAdded = [];
+  var scriptsSkipped = [];
+
+  // --- File scaffolding ---
+  for (var i = 0; i < FILES_TO_SCAFFOLD.length; i++) {
+    var file = FILES_TO_SCAFFOLD[i];
+    var srcPath = path.join(TEMPLATE_DIR, file.src);
+    var destPath = path.join(dir, file.dest);
+
+    // Verify template source exists
+    if (!fs.existsSync(srcPath)) {
+      errors.push('Template not found: ' + file.src + '. Package may be corrupted.');
+      continue;
+    }
+
+    // Check if dest already exists
+    if (fs.existsSync(destPath) && !opts.force) {
+      skipped.push(file.dest);
+      warnings.push('Skipped: ' + file.dest + ' (already exists)');
+      continue;
+    }
+
+    // Create parent directories and copy
+    try {
+      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+      fs.copyFileSync(srcPath, destPath);
+      created.push(file.dest);
+    } catch (e) {
+      errors.push('Failed to create ' + file.dest + ': ' + e.message);
+    }
+  }
+
+  // --- npm scripts injection ---
+  var packageJsonPath = path.join(dir, 'package.json');
+  if (!fs.existsSync(packageJsonPath)) {
+    warnings.push('No package.json found. Skipping npm scripts injection. Run \'npm init\' first.');
+  } else {
+    try {
+      var pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+      if (!pkg.scripts) {
+        pkg.scripts = {};
+      }
+
+      var keys = Object.keys(SCRIPTS_TO_INJECT);
+      for (var j = 0; j < keys.length; j++) {
+        var key = keys[j];
+        if (pkg.scripts[key] !== undefined && !opts.force) {
+          scriptsSkipped.push(key);
+          warnings.push('Skipped script: ' + key + ' (already defined)');
+        } else {
+          pkg.scripts[key] = SCRIPTS_TO_INJECT[key];
+          scriptsAdded.push(key);
+        }
+      }
+
+      // Only write if scripts were added
+      if (scriptsAdded.length > 0) {
+        fs.writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2) + '\n');
+      }
+    } catch (e) {
+      errors.push('Failed to update package.json: ' + e.message);
+    }
+  }
+
+  return {
+    success: errors.length === 0,
+    errors: errors,
+    warnings: warnings,
+    data: {
+      created: created,
+      skipped: skipped,
+      scriptsAdded: scriptsAdded,
+      scriptsSkipped: scriptsSkipped
+    }
+  };
+}
+
+// --- Help ---
+
+function printHelp() {
+  console.log('Usage: chrome-ext-ci-cd init [options]');
+  console.log('');
+  console.log('Scaffold CI/CD files into your Chrome extension project.');
+  console.log('');
+  console.log('Creates:');
+  console.log('  .github/workflows/release.yml   GitHub Actions workflow');
+  console.log('  .extensionignore                Extension ignore patterns');
+  console.log('  .nvmrc                          Node version file');
+  console.log('');
+  console.log('Injects npm scripts into package.json:');
+  console.log('  ext:validate, ext:package, ext:release:patch,');
+  console.log('  ext:release:minor, ext:release:major');
+  console.log('');
+  console.log('Options:');
+  console.log('  --force, -f     Overwrite existing files');
+  console.log('  --help, -h      Show this help message');
+  console.log('');
+  console.log('Examples:');
+  console.log('  chrome-ext-ci-cd init');
+  console.log('  chrome-ext-ci-cd init --force');
+}
+
+// --- CLI Runner ---
+
+function run(args) {
+  var values;
+  try {
+    var parsed = parseArgs({
+      args: args,
+      options: {
+        force: { type: 'boolean', short: 'f', default: false },
+        help: { type: 'boolean', short: 'h', default: false },
+      },
+      allowPositionals: false,
+    });
+    values = parsed.values;
+  } catch (err) {
+    if (err.code === 'ERR_PARSE_ARGS_UNKNOWN_OPTION') {
+      console.error('Unknown option: ' + err.message);
+      console.error('');
+      printHelp();
+      return 1;
+    }
+    throw err;
+  }
+
+  if (values.help) {
+    printHelp();
+    return 0;
+  }
+
+  var result = init(process.cwd(), { force: values.force });
+
+  // Print summary
+  console.log('chrome-ext-ci-cd init');
+  console.log('');
+
+  if (result.data.created.length > 0) {
+    console.log('  Created:');
+    for (var i = 0; i < FILES_TO_SCAFFOLD.length; i++) {
+      var file = FILES_TO_SCAFFOLD[i];
+      if (result.data.created.indexOf(file.dest) !== -1) {
+        console.log('    ' + file.dest.padEnd(38) + '(' + file.label + ')');
+      }
+    }
+    console.log('');
+  }
+
+  if (result.data.skipped.length > 0) {
+    console.log('  Skipped (already exist):');
+    for (var j = 0; j < result.data.skipped.length; j++) {
+      console.log('    ' + result.data.skipped[j]);
+    }
+    console.log('');
+  }
+
+  if (result.data.scriptsAdded.length > 0) {
+    console.log('  npm scripts added to package.json:');
+    console.log('    ' + result.data.scriptsAdded.join(', '));
+    console.log('');
+  }
+
+  if (result.data.scriptsSkipped.length > 0) {
+    console.log('  npm scripts skipped (already defined):');
+    console.log('    ' + result.data.scriptsSkipped.join(', '));
+    console.log('');
+  }
+
+  // Nothing to do
+  if (result.data.created.length === 0 && result.data.scriptsAdded.length === 0 && result.errors.length === 0) {
+    console.log('  Nothing to do. All files already exist. Use --force to overwrite.');
+    console.log('');
+  }
+
+  // Warnings
+  if (result.warnings.length > 0) {
+    for (var k = 0; k < result.warnings.length; k++) {
+      if (result.warnings[k].indexOf('Skipped') === -1) {
+        console.log('  WARN: ' + result.warnings[k]);
+      }
+    }
+  }
+
+  // Errors
+  if (result.errors.length > 0) {
+    for (var m = 0; m < result.errors.length; m++) {
+      console.error('  ERROR: ' + result.errors[m]);
+    }
+    return 1;
+  }
+
+  if (result.data.skipped.length > 0 && result.data.created.length > 0) {
+    console.log('  Tip: Use --force to overwrite existing files.');
+  }
+
+  return 0;
+}
+
+module.exports = { init, run };

package/lib/keygen.js

@@ -0,0 +1,107 @@
+'use strict';
+
+const { parseArgs } = require('node:util');
+const license = require('./license');
+
+// --- Help ---
+
+function printHelp() {
+  console.log('Usage: chrome-ext-ci-cd keygen [options]');
+  console.log('');
+  console.log('Generate a license key. Owner-only command.');
+  console.log('Requires KEYGEN_SECRET environment variable.');
+  console.log('');
+  console.log('Options:');
+  console.log('  --tier <name>         License tier (e.g. starter, pro, team)');
+  console.log('  --customer <name>     Customer or company name');
+  console.log('  --expires <YYYY-MM>   Expiry month (e.g. 2027-03)');
+  console.log('  --help, -h            Show this help message');
+  console.log('');
+  console.log('Examples:');
+  console.log("  KEYGEN_SECRET=... chrome-ext-ci-cd keygen --tier pro --customer 'Acme Corp' --expires 2027-06");
+}
+
+// --- CLI Runner ---
+
+function run(args) {
+  var values;
+  try {
+    var parsed = parseArgs({
+      args: args,
+      options: {
+        tier: { type: 'string' },
+        customer: { type: 'string' },
+        expires: { type: 'string' },
+        help: { type: 'boolean', short: 'h', default: false },
+      },
+      allowPositionals: false,
+    });
+    values = parsed.values;
+  } catch (err) {
+    if (err.code === 'ERR_PARSE_ARGS_UNKNOWN_OPTION') {
+      console.error('Unknown option: ' + err.message);
+      console.error('');
+      printHelp();
+      return 1;
+    }
+    throw err;
+  }
+
+  if (values.help) {
+    printHelp();
+    return 0;
+  }
+
+  // Check KEYGEN_SECRET env var
+  var secret = process.env.KEYGEN_SECRET;
+  if (!secret) {
+    console.error('KEYGEN_SECRET environment variable is required.');
+    console.error('Set it to the signing secret before generating keys.');
+    return 1;
+  }
+
+  // Validate secret matches the embedded HMAC_SECRET
+  if (secret !== license.HMAC_SECRET) {
+    console.error('KEYGEN_SECRET does not match the expected signing secret.');
+    return 1;
+  }
+
+  // Validate required flags
+  if (!values.tier) {
+    console.error('Missing --tier flag. Specify the license tier (e.g. --tier pro).');
+    return 1;
+  }
+
+  if (!values.customer) {
+    console.error('Missing --customer flag. Specify the customer name (e.g. --customer "Acme Corp").');
+    return 1;
+  }
+
+  if (!values.expires) {
+    console.error('Missing --expires flag. Specify expiry month (e.g. --expires 2027-03).');
+    return 1;
+  }
+
+  // Validate expires format
+  if (!/^\d{4}-\d{2}$/.test(values.expires)) {
+    console.error('Invalid --expires format. Use YYYY-MM (e.g. 2027-03).');
+    return 1;
+  }
+
+  // Generate key
+  var key = license.generateKey(secret, values.tier, values.customer, values.expires);
+
+  // Self-validate
+  var check = license.verifyKey(key, secret);
+  if (!check.valid) {
+    console.error('Internal error: generated key failed self-validation. ' + check.error);
+    return 1;
+  }
+
+  console.log(key);
+  return 0;
+}
+
+// --- Exports ---
+
+module.exports = { run: run };

package/lib/license.js

@@ -0,0 +1,199 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+// --- Constants ---
+
+var HMAC_SECRET = 'cecicd-v1-hmac-key';
+
+// --- Config Paths ---
+
+function getConfigDir() {
+  var base = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+  return path.join(base, 'chrome-ext-ci-cd');
+}
+
+// --- Key Operations ---
+
+function generateKey(secret, tier, customer, expiresYYYYMM) {
+  var payload = { tier: tier, customer: customer, exp: expiresYYYYMM };
+  var json = JSON.stringify(payload);
+  var data = Buffer.from(json).toString('base64');
+  var signature = crypto.createHmac('sha256', secret).update(data).digest('hex');
+  return 'CECICD-' + data + '-' + signature;
+}
+
+function parseKey(keyString) {
+  var parts = keyString.split('-');
+  // Format: CECICD-{base64data}-{hex signature (64 chars)}
+  // The base64 data itself may not contain dashes, but the hex is always 64 chars
+  // Split strategy: first part is CECICD, last 64 chars hex part is signature, middle is data
+  if (parts.length < 3 || parts[0] !== 'CECICD') {
+    return { valid: false, error: 'Invalid key format. Expected: CECICD-{data}-{signature}' };
+  }
+
+  // The signature is always the last part (64-char hex string)
+  var signature = parts[parts.length - 1];
+  // The data is everything between CECICD- and the last -signature
+  var data = parts.slice(1, parts.length - 1).join('-');
+
+  if (!data || !signature) {
+    return { valid: false, error: 'Invalid key format. Expected: CECICD-{data}-{signature}' };
+  }
+
+  var decoded;
+  try {
+    decoded = Buffer.from(data, 'base64').toString('utf-8');
+  } catch (e) {
+    return { valid: false, error: 'Invalid key data: corrupted payload' };
+  }
+
+  var parsed;
+  try {
+    parsed = JSON.parse(decoded);
+  } catch (e) {
+    return { valid: false, error: 'Invalid key data: corrupted payload' };
+  }
+
+  if (!parsed.tier || !parsed.customer || !parsed.exp) {
+    return { valid: false, error: 'Invalid key data: missing required fields' };
+  }
+
+  return { valid: true, data: data, signature: signature, payload: parsed };
+}
+
+function verifyKey(keyString, secret) {
+  var parsed = parseKey(keyString);
+  if (!parsed.valid) {
+    return parsed;
+  }
+
+  var expected = crypto.createHmac('sha256', secret).update(parsed.data).digest('hex');
+
+  var sigBuf = Buffer.from(parsed.signature, 'hex');
+  var expBuf = Buffer.from(expected, 'hex');
+
+  if (sigBuf.length !== expBuf.length) {
+    return { valid: false, error: 'Invalid key signature' };
+  }
+
+  if (!crypto.timingSafeEqual(sigBuf, expBuf)) {
+    return { valid: false, error: 'Invalid key signature' };
+  }
+
+  // Check expiry
+  var now = new Date().toISOString().slice(0, 7);
+  if (now > parsed.payload.exp) {
+    return {
+      valid: false,
+      error: 'License expired (valid until ' + parsed.payload.exp + '). Renew your license:\n\n  chrome-ext-ci-cd activate <new-key>',
+      expired: true,
+      payload: parsed.payload
+    };
+  }
+
+  return { valid: true, payload: parsed.payload };
+}
+
+// --- Trial Management ---
+
+function readTrial() {
+  var trialPath = path.join(getConfigDir(), 'trial');
+  if (!fs.existsSync(trialPath)) {
+    return null;
+  }
+  return fs.readFileSync(trialPath, 'utf-8').trim();
+}
+
+function startTrial() {
+  var configDir = getConfigDir();
+  fs.mkdirSync(configDir, { recursive: true });
+  var today = new Date().toISOString().slice(0, 10);
+  var trialPath = path.join(configDir, 'trial');
+  try {
+    fs.writeFileSync(trialPath, today + '\n', { flag: 'wx' });
+  } catch (e) {
+    if (e.code === 'EEXIST') {
+      return fs.readFileSync(trialPath, 'utf-8').trim();
+    }
+    throw e;
+  }
+  return today;
+}
+
+function isTrialValid(startDate) {
+  var start = new Date(startDate);
+  var now = new Date();
+  var diffMs = now.getTime() - start.getTime();
+  var diffDays = diffMs / (1000 * 60 * 60 * 24);
+  return diffDays <= 7;
+}
+
+// --- License Check ---
+
+function readLicense() {
+  var licensePath = path.join(getConfigDir(), 'license');
+  if (!fs.existsSync(licensePath)) {
+    return null;
+  }
+  return fs.readFileSync(licensePath, 'utf-8').trim();
+}
+
+function checkLicense() {
+  var licenseKey = readLicense();
+
+  if (licenseKey) {
+    var result = verifyKey(licenseKey, HMAC_SECRET);
+    if (result.valid) {
+      return {
+        valid: true,
+        tier: result.payload.tier,
+        customer: result.payload.customer,
+        exp: result.payload.exp
+      };
+    }
+    if (result.expired) {
+      return { valid: false, message: result.error };
+    }
+    // Invalid license — fall through to trial check
+  }
+
+  // No license or invalid license — check trial
+  var trialStart = readTrial();
+
+  if (!trialStart) {
+    var started = startTrial();
+    return { valid: true, trial: true, daysLeft: 7 };
+  }
+
+  if (isTrialValid(trialStart)) {
+    var daysLeft = Math.ceil(7 - (Date.now() - new Date(trialStart).getTime()) / 86400000);
+    if (daysLeft < 1) {
+      daysLeft = 1;
+    }
+    return { valid: true, trial: true, daysLeft: daysLeft };
+  }
+
+  return {
+    valid: false,
+    message: 'Trial expired. Activate a license to continue:\n\n  chrome-ext-ci-cd activate <key>'
+  };
+}
+
+// --- Exports ---
+
+module.exports = {
+  getConfigDir: getConfigDir,
+  generateKey: generateKey,
+  parseKey: parseKey,
+  verifyKey: verifyKey,
+  checkLicense: checkLicense,
+  startTrial: startTrial,
+  readTrial: readTrial,
+  isTrialValid: isTrialValid,
+  readLicense: readLicense,
+  HMAC_SECRET: HMAC_SECRET
+};