thumbgate 0.9.9 → 0.9.11

package/scripts/license.js

@@ -3,42 +3,71 @@ const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 
-const LICENSE_PATH = path.join(process.env.HOME || process.env.USERPROFILE || '.', '.thumbgate', 'license.json');
-const VALID_PREFIXES = ['rlhf_', 'tg_pro_', 'tg_'];
+const VALID_PREFIXES = ['tg_pro_', 'tg_'];
+const LEGACY_COMPATIBLE_KEY = /^[a-z]{4,16}_[a-f0-9]{24,}$/i;
+
+function getLicensePath(homeDir = process.env.HOME || process.env.USERPROFILE || '.') {
+  return path.join(homeDir, '.thumbgate', 'license.json');
+}
+
+const LICENSE_PATH = getLicensePath();
 
 function isValidKey(key) {
-  return key && VALID_PREFIXES.some((p) => key.startsWith(p));
+  return Boolean(
+    key
+    && (
+      VALID_PREFIXES.some((p) => key.startsWith(p))
+      || LEGACY_COMPATIBLE_KEY.test(key)
+    )
+  );
 }
 
-function verifyLicense() {
-  const envKey = process.env.THUMBGATE_API_KEY || process.env.THUMBGATE_PRO_KEY;
+function verifyLicense(options = {}) {
+  const envKey = [
+    process.env.THUMBGATE_API_KEY,
+    process.env.THUMBGATE_PRO_KEY,
+    ...Object.entries(process.env)
+      .filter(([name]) => /(?:_API_KEY|_PRO_KEY)$/.test(name))
+      .map(([, value]) => value),
+  ].find((value) => isValidKey(value));
   if (isValidKey(envKey)) {
     return { valid: true, source: 'env', key: envKey };
   }
+
+  const licensePath = getLicensePath(options.homeDir);
   try {
-    if (fs.existsSync(LICENSE_PATH)) {
-      const data = JSON.parse(fs.readFileSync(LICENSE_PATH, 'utf8'));
+    if (fs.existsSync(licensePath)) {
+      const data = JSON.parse(fs.readFileSync(licensePath, 'utf8'));
       if (isValidKey(data.key)) {
-        return { valid: true, source: 'file', key: data.key, activatedAt: data.activatedAt };
+        return {
+          valid: true,
+          source: 'file',
+          key: data.key,
+          activatedAt: data.activatedAt,
+          path: licensePath,
+        };
       }
     }
   } catch (_) {}
+
   return { valid: false, source: null };
 }
 
-function isProLicensed() {
-  return verifyLicense().valid;
+function isProLicensed(options) {
+  return verifyLicense(options).valid;
 }
 
-function activateLicense(key) {
+function activateLicense(key, options = {}) {
   if (!isValidKey(key)) {
-    return { success: false, error: 'Invalid key format. Expected rlhf_... or tg_pro_...' };
+    return { success: false, error: 'Invalid key format. Expected tg_... or tg_pro_...' };
   }
-  const dir = path.dirname(LICENSE_PATH);
+
+  const licensePath = getLicensePath(options.homeDir);
+  const dir = path.dirname(licensePath);
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
   const data = { key, activatedAt: new Date().toISOString(), version: require('../package.json').version };
-  fs.writeFileSync(LICENSE_PATH, JSON.stringify(data, null, 2));
-  return { success: true, path: LICENSE_PATH };
+  fs.writeFileSync(licensePath, JSON.stringify(data, null, 2));
+  return { success: true, path: licensePath };
 }
 
 function generateLicenseKey(email) {
@@ -47,4 +76,13 @@ function generateLicenseKey(email) {
   return `tg_pro_${hash}`;
 }
 
-module.exports = { verifyLicense, isProLicensed, activateLicense, generateLicenseKey, isValidKey, VALID_PREFIXES, LICENSE_PATH };
+module.exports = {
+  verifyLicense,
+  isProLicensed,
+  activateLicense,
+  generateLicenseKey,
+  isValidKey,
+  VALID_PREFIXES,
+  LICENSE_PATH,
+  getLicensePath,
+};

package/scripts/mcp-config.js

@@ -3,6 +3,9 @@
 const fs = require('fs');
 const path = require('path');
 const { execFileSync } = require('child_process');
+const { publishedCliArgs, runPublishedCliHelp } = require('./published-cli');
+const DEFAULT_PKG_ROOT = path.join(__dirname, '..');
+const cliAvailabilityCache = new Map();
 
 function isSourceCheckout(pkgRoot) {
   return fs.existsSync(path.join(pkgRoot, '.git'));
@@ -17,17 +20,40 @@ function parseWorktreePaths(raw) {
 }
 
 function resolveStableSourceRoot(pkgRoot) {
-  if (!isSourceCheckout(pkgRoot)) {
+  const effectivePkgRoot =
+    typeof pkgRoot === 'string' && pkgRoot.trim() ? pkgRoot : DEFAULT_PKG_ROOT;
+
+  if (!isSourceCheckout(effectivePkgRoot)) {
     return null;
   }
 
+  let preferredBasenames = [];
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(effectivePkgRoot, 'package.json'), 'utf8'));
+    const packageName = String(pkg && pkg.name || '').trim().toLowerCase();
+    if (packageName) {
+      preferredBasenames.push(packageName);
+      preferredBasenames.push(packageName.replace(/[^a-z0-9]+/g, ''));
+    }
+  } catch (_) {
+    preferredBasenames = [];
+  }
+
   try {
-    const output = execFileSync('git', ['-C', pkgRoot, 'worktree', 'list', '--porcelain'], {
+    const output = execFileSync('git', ['-C', effectivePkgRoot, 'worktree', 'list', '--porcelain'], {
       encoding: 'utf8',
       stdio: ['ignore', 'pipe', 'ignore'],
     });
     const worktreePaths = parseWorktreePaths(output);
 
+    for (const worktreePath of worktreePaths) {
+      const baseName = path.basename(worktreePath).toLowerCase();
+      const normalizedBaseName = baseName.replace(/[^a-z0-9]+/g, '');
+      if (preferredBasenames.includes(baseName) || preferredBasenames.includes(normalizedBaseName)) {
+        return worktreePath;
+      }
+    }
+
     for (const worktreePath of worktreePaths) {
       const gitPath = path.join(worktreePath, '.git');
       if (!fs.existsSync(gitPath)) {
@@ -38,10 +64,10 @@ function resolveStableSourceRoot(pkgRoot) {
       }
     }
   } catch (_) {
-    return pkgRoot;
+    return effectivePkgRoot;
   }
 
-  return pkgRoot;
+  return effectivePkgRoot;
 }
 
 function resolveGitCommonDir(dirPath) {
@@ -76,7 +102,7 @@ function resolveLocalServerPath(pkgRoot, scope = 'project') {
 function portableMcpEntry(pkgVersion) {
   return {
     command: 'npx',
-    args: ['-y', `thumbgate@${pkgVersion}`, 'serve'],
+    args: publishedCliArgs(pkgVersion, ['serve']),
   };
 }
 
@@ -90,7 +116,7 @@ function localMcpEntry(pkgRoot, scope = 'project') {
 const publicationCache = new Map();
 
 function publishedVersionOverride() {
-  const override = String(process.env.MCP_MEMORY_GATEWAY_PUBLISH_STATE || '').trim().toLowerCase();
+  const override = String(process.env.THUMBGATE_PUBLISH_STATE || '').trim().toLowerCase();
   if (override === 'published') {
     return true;
   }
@@ -125,17 +151,53 @@ function isVersionPublished(pkgVersion) {
   return published;
 }
 
+function publishedCliOverride() {
+  const override = String(process.env.THUMBGATE_PUBLISHED_CLI_STATE || '').trim().toLowerCase();
+  if (override === 'available') {
+    return true;
+  }
+  if (override === 'unavailable') {
+    return false;
+  }
+  return null;
+}
+
+function publishedCliAvailable(pkgVersion) {
+  if (!isVersionPublished(pkgVersion)) {
+    return false;
+  }
+  const override = publishedCliOverride();
+  if (override !== null) {
+    return override;
+  }
+  if (cliAvailabilityCache.has(pkgVersion)) {
+    return cliAvailabilityCache.get(pkgVersion);
+  }
+
+  let available = false;
+  try {
+    runPublishedCliHelp(pkgVersion, { timeout: 8000 });
+    available = true;
+  } catch (_) {
+    available = false;
+  }
+
+  cliAvailabilityCache.set(pkgVersion, available);
+  return available;
+}
+
 function resolveMcpEntry({ pkgRoot, pkgVersion, scope = 'project', targetDir = pkgRoot }) {
   if (!isSourceCheckout(pkgRoot)) {
     return portableMcpEntry(pkgVersion);
   }
-  if (scope === 'project' && !isSameCheckoutFamily(pkgRoot, targetDir) && isVersionPublished(pkgVersion)) {
+  if (scope === 'project' && !isSameCheckoutFamily(pkgRoot, targetDir) && publishedCliAvailable(pkgVersion)) {
     return portableMcpEntry(pkgVersion);
   }
   return localMcpEntry(pkgRoot, scope);
 }
 
 module.exports = {
+  publishedCliAvailable,
   isVersionPublished,
   isSourceCheckout,
   isSameCheckoutFamily,

package/scripts/memory-migration.js

@@ -253,7 +253,7 @@ function migrateAllMemory() {
  */
 function generateComparisonData() {
   const health = checkMemoryHealth();
-  const feedbackDir = process.env.THUMBGATE_FEEDBACK_DIR || path.join(process.cwd(), '.rlhf');
+  const feedbackDir = process.env.THUMBGATE_FEEDBACK_DIR || path.join(process.cwd(), '.thumbgate');
   let lessonCount = 0;
   const lessonsPath = path.join(feedbackDir, 'lessons-index.jsonl');
   if (fs.existsSync(lessonsPath)) {

package/scripts/money-watcher.js

@@ -6,10 +6,19 @@
 
 'use strict';
 
+const fs = require('node:fs');
+const path = require('node:path');
 const { getOperationalBillingSummary } = require('./operational-summary');
 
-function getCommercialRevenueSnapshot(summary) {
-  const revenue = summary.revenue || {};
+const DEFAULT_STATE_PATH = path.resolve(__dirname, '..', '.thumbgate', 'commercial-watch-state.json');
+const DEFAULT_ALERT_LOG_PATH = path.resolve(__dirname, '..', '.thumbgate', 'commercial-alerts.jsonl');
+
+function ensureParentDir(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
+function getCommercialRevenueSnapshot(summary = {}) {
+  const revenue = summary && typeof summary === 'object' ? summary.revenue || {} : {};
   return {
     paidOrders: revenue.paidOrders || 0,
     bookedRevenueCents: revenue.bookedRevenueCents || 0,
@@ -18,10 +27,86 @@ function getCommercialRevenueSnapshot(summary) {
   };
 }
 
-async function watchMoney(intervalMs = 10000) {
+function readSnapshotState(statePath = DEFAULT_STATE_PATH) {
+  try {
+    if (!fs.existsSync(statePath)) {
+      return null;
+    }
+    return JSON.parse(fs.readFileSync(statePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeSnapshotState(snapshot, statePath = DEFAULT_STATE_PATH) {
+  ensureParentDir(statePath);
+  fs.writeFileSync(statePath, `${JSON.stringify(snapshot, null, 2)}\n`, 'utf8');
+  return statePath;
+}
+
+function buildCommercialAlert(previousSnapshot = {}, currentSnapshot = {}, meta = {}) {
+  const newPaidOrders = (currentSnapshot.paidOrders || 0) - (previousSnapshot.paidOrders || 0);
+  const newBookedRevenueCents = (currentSnapshot.bookedRevenueCents || 0) - (previousSnapshot.bookedRevenueCents || 0);
+
+  if (newPaidOrders <= 0 && newBookedRevenueCents <= 0) {
+    return null;
+  }
+
+  return {
+    detectedAt: new Date().toISOString(),
+    source: meta.source || null,
+    fallbackReason: meta.fallbackReason || null,
+    newPaidOrders,
+    newBookedRevenueCents,
+    latestPaidAt: currentSnapshot.latestPaidAt || null,
+    latestPaidOrder: currentSnapshot.latestPaidOrder || null,
+    paidOrders: currentSnapshot.paidOrders || 0,
+    bookedRevenueCents: currentSnapshot.bookedRevenueCents || 0,
+  };
+}
+
+function recordCommercialAlert(alert, alertLogPath = DEFAULT_ALERT_LOG_PATH) {
+  ensureParentDir(alertLogPath);
+  fs.appendFileSync(alertLogPath, `${JSON.stringify(alert)}\n`, 'utf8');
+  return alertLogPath;
+}
+
+async function checkForCommercialChange(options = {}) {
+  const statePath = options.statePath || DEFAULT_STATE_PATH;
+  const alertLogPath = options.alertLogPath || DEFAULT_ALERT_LOG_PATH;
+  const previousSnapshot = options.previousSnapshot || readSnapshotState(statePath) || getCommercialRevenueSnapshot();
+  const summaryResolver = options.getSummary || getOperationalBillingSummary;
+  const { source, summary, fallbackReason } = await summaryResolver();
+  const currentSnapshot = getCommercialRevenueSnapshot(summary);
+  const alert = buildCommercialAlert(previousSnapshot, currentSnapshot, {
+    source,
+    fallbackReason,
+  });
+
+  writeSnapshotState(currentSnapshot, statePath);
+  if (alert) {
+    recordCommercialAlert(alert, alertLogPath);
+  }
+
+  return {
+    changed: Boolean(alert),
+    alert,
+    previousSnapshot,
+    currentSnapshot,
+    source,
+    fallbackReason: fallbackReason || null,
+    statePath,
+    alertLogPath,
+  };
+}
+
+async function watchMoney(intervalMs = 10000, options = {}) {
   console.log('👀 Money Watcher activated. Polling billing summary for commercial changes...');
   const initialState = await getOperationalBillingSummary();
-  let initialSnapshot = getCommercialRevenueSnapshot(initialState.summary);
+  let initialSnapshot = options.initialSnapshot
+    || readSnapshotState(options.statePath || DEFAULT_STATE_PATH)
+    || getCommercialRevenueSnapshot(initialState.summary);
+  writeSnapshotState(initialSnapshot, options.statePath || DEFAULT_STATE_PATH);
   let polling = false;
 
   return setInterval(async () => {
@@ -30,21 +115,18 @@ async function watchMoney(intervalMs = 10000) {
     try {
       const { source, summary, fallbackReason } = await getOperationalBillingSummary();
       const currentSnapshot = getCommercialRevenueSnapshot(summary);
+      const alert = buildCommercialAlert(initialSnapshot, currentSnapshot, {
+        source,
+        fallbackReason,
+      });
+      writeSnapshotState(currentSnapshot, options.statePath || DEFAULT_STATE_PATH);
 
-      const newPaidOrders = currentSnapshot.paidOrders - initialSnapshot.paidOrders;
-      const newBookedRevenue = currentSnapshot.bookedRevenueCents - initialSnapshot.bookedRevenueCents;
-
-      if (newPaidOrders > 0 || newBookedRevenue > 0) {
+      if (alert) {
+        recordCommercialAlert(alert, options.alertLogPath || DEFAULT_ALERT_LOG_PATH);
         console.log('\n🚨🚨🚨 COMMERCIAL ALERT: NET-NEW PAID ACTIVITY DETECTED! 🚨🚨🚨');
         console.log('Operational billing summary:');
         console.log(JSON.stringify({
-          source,
-          fallbackReason,
-          newPaidOrders,
-          newBookedRevenueCents: newBookedRevenue,
-          latestPaidAt: currentSnapshot.latestPaidAt,
-          latestPaidOrder: currentSnapshot.latestPaidOrder,
-          bookedRevenueCents: currentSnapshot.bookedRevenueCents,
+          ...alert,
           activeKeys: summary.keys.active,
           totalUsage: summary.keys.totalUsage,
         }, null, 2));
@@ -58,14 +140,82 @@ async function watchMoney(intervalMs = 10000) {
   }, intervalMs);
 }
 
+function parseArgs(argv = []) {
+  const options = {
+    once: false,
+    intervalMs: 10000,
+    statePath: DEFAULT_STATE_PATH,
+    alertLogPath: DEFAULT_ALERT_LOG_PATH,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = String(argv[index] || '').trim();
+
+    if (arg === '--once') {
+      options.once = true;
+      continue;
+    }
+
+    if (arg === '--interval-ms' && argv[index + 1]) {
+      options.intervalMs = Number.parseInt(argv[index + 1], 10) || options.intervalMs;
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--interval-ms=')) {
+      options.intervalMs = Number.parseInt(arg.split('=').slice(1).join('='), 10) || options.intervalMs;
+      continue;
+    }
+
+    if (arg === '--state-path' && argv[index + 1]) {
+      options.statePath = path.resolve(String(argv[index + 1]));
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--state-path=')) {
+      options.statePath = path.resolve(arg.split('=').slice(1).join('='));
+      continue;
+    }
+
+    if (arg === '--alert-log-path' && argv[index + 1]) {
+      options.alertLogPath = path.resolve(String(argv[index + 1]));
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--alert-log-path=')) {
+      options.alertLogPath = path.resolve(arg.split('=').slice(1).join('='));
+    }
+  }
+
+  return options;
+}
+
 if (require.main === module) {
-  watchMoney().catch((err) => {
+  const options = parseArgs(process.argv.slice(2));
+  const runner = options.once
+    ? checkForCommercialChange(options).then((result) => {
+      console.log(JSON.stringify(result, null, 2));
+      return result;
+    })
+    : watchMoney(options.intervalMs, options);
+
+  runner.catch((err) => {
     console.error(err && err.message ? err.message : err);
     process.exit(1);
   });
 }
 
 module.exports = {
+  DEFAULT_ALERT_LOG_PATH,
+  DEFAULT_STATE_PATH,
+  buildCommercialAlert,
+  checkForCommercialChange,
   getCommercialRevenueSnapshot,
+  parseArgs,
+  readSnapshotState,
+  recordCommercialAlert,
   watchMoney,
+  writeSnapshotState,
 };