thumbgate 1.3.0 → 1.4.1

package/scripts/billing-setup.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * billing-setup.js — Wire up hosted billing for the CFO dashboard
+ *
+ * Generates a THUMBGATE_OPERATOR_KEY and stores it locally so that
+ * `node bin/cli.js cfo --today` pulls live revenue from the production server.
+ *
+ * Usage:
+ *   node scripts/billing-setup.js
+ *
+ * After running, set the printed key on Railway:
+ *   railway variables set THUMBGATE_OPERATOR_KEY=<key>
+ * Then redeploy (or let Railway auto-deploy).
+ */
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+const LOCAL_CONFIG_PATH = path.join(os.homedir(), '.config', 'thumbgate', 'operator.json');
+const PROD_URL = 'https://thumbgate-production.up.railway.app';
+
+function generateOperatorKey() {
+  return `tg_op_${crypto.randomBytes(20).toString('hex')}`;
+}
+
+function loadExistingConfig() {
+  try {
+    const raw = fs.readFileSync(LOCAL_CONFIG_PATH, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function saveConfig(config) {
+  const dir = path.dirname(LOCAL_CONFIG_PATH);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(LOCAL_CONFIG_PATH, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 });
+}
+
+async function verifyEndpoint(baseUrl, key) {
+  try {
+    const url = new URL('/v1/billing/summary?window=today', baseUrl);
+    const res = await fetch(url, {
+      method: 'GET',
+      headers: { authorization: `Bearer ${key}`, accept: 'application/json' },
+    });
+    return { status: res.status, ok: res.ok };
+  } catch (err) {
+    return { status: null, ok: false, error: err.message };
+  }
+}
+
+async function main() {
+  const existing = loadExistingConfig();
+
+  if (existing && existing.operatorKey && existing.baseUrl) {
+    console.log('\n✓ Operator config already exists at', LOCAL_CONFIG_PATH);
+    console.log('  Base URL    :', existing.baseUrl);
+    console.log('  Operator key:', existing.operatorKey);
+    console.log('\nTo regenerate, delete the file and re-run this script.');
+
+    // Set env for this process so the verify check works
+    process.env.THUMBGATE_OPERATOR_KEY = existing.operatorKey;
+    process.env.THUMBGATE_BILLING_API_BASE_URL = existing.baseUrl;
+
+    const check = await verifyEndpoint(existing.baseUrl, existing.operatorKey);
+    if (check.ok) {
+      console.log('\n✓ Production endpoint responds OK — hosted billing is active.');
+    } else if (check.status === 403) {
+      console.log('\n⚠ Production endpoint returned 403 — the operator key is not yet set on Railway.');
+      console.log('\nSet it now:\n');
+      console.log(`  railway variables set THUMBGATE_OPERATOR_KEY=${existing.operatorKey}`);
+      console.log('\nThen redeploy (Railway will pick it up automatically).');
+    } else {
+      console.log(`\n⚠ Endpoint check returned status ${check.status || 'error'}: ${check.error || ''}`);
+    }
+    return;
+  }
+
+  const key = generateOperatorKey();
+  const config = {
+    operatorKey: key,
+    baseUrl: process.env.THUMBGATE_BILLING_API_BASE_URL || PROD_URL,
+    createdAt: new Date().toISOString(),
+  };
+
+  saveConfig(config);
+
+  console.log('\n✓ Operator key generated and saved to', LOCAL_CONFIG_PATH);
+  console.log('\n──────────────────────────────────────────────────────');
+  console.log('  THUMBGATE_OPERATOR_KEY =', key);
+  console.log('──────────────────────────────────────────────────────');
+  console.log('\nSet this key on Railway (one-time):');
+  console.log('\n  railway variables set THUMBGATE_OPERATOR_KEY=' + key);
+  console.log('\nOr paste it into the Railway dashboard under Variables.');
+  console.log('\nAfter Railway redeploys, run:\n');
+  console.log('  node bin/cli.js cfo --today\n');
+  console.log('The CFO dashboard will use live production billing data.');
+}
+
+main().catch((err) => {
+  console.error('billing-setup error:', err.message);
+  process.exit(1);
+});

package/scripts/billing.js

@@ -43,6 +43,7 @@ const {
   resolveAnalyticsWindow,
   serializeAnalyticsWindow,
 } = require('./analytics-window');
+const { ensureParentDir } = require('./fs-utils');
 
 // ---------------------------------------------------------------------------
 // Config
@@ -73,15 +74,7 @@ const CONFIG = {
   get NEWSLETTER_SUBSCRIBERS_PATH() {
     return process.env._TEST_NEWSLETTER_SUBSCRIBERS_PATH || path.join(getFeedbackPaths().FEEDBACK_DIR, 'newsletter-subscribers.jsonl');
   },
-  CREDIT_PACKS: {
-    'mistake-free-starter': {
-      id: 'mistake-free-starter',
-      name: 'Mistake-Free Starter Pack',
-      amountCents: 4900,
-      credits: 500,
-      currency: 'USD',
-    }
-  }
+  CREDIT_PACKS: {}
 };
 
 function resolveLegacyBillingPath(fileName) {
@@ -148,13 +141,6 @@ function safeCompareHex(expectedHex, actualHex) {
 // Internal helpers
 // ---------------------------------------------------------------------------
 
-function ensureParentDir(filePath) {
-  const dir = path.dirname(filePath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-}
-
 function sanitizeMetadata(metadata) {
   if (!metadata || typeof metadata !== 'object') return {};
   try {

package/scripts/budget-enforcer.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Budget Enforcer — action count, token, and time limits for agent sessions.
+ *
+ * Competitive parity with LaneKeep's budget system. Tracks:
+ * - max_actions: total tool calls allowed per session
+ * - max_time_minutes: wall-clock session duration cap
+ * - action_count: running count of tool calls in current session
+ *
+ * Budget state persists to ~/.thumbgate/budget-state.json.
+ * Config lives in config/budget.json or can be set via env vars.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const BUDGET_STATE_PATH = process.env.THUMBGATE_BUDGET_STATE_PATH || path.join(
+  process.env.HOME || '/tmp',
+  '.thumbgate',
+  'budget-state.json'
+);
+
+const DEFAULT_BUDGET_CONFIG_PATH = process.env.THUMBGATE_BUDGET_CONFIG_PATH || path.join(
+  __dirname, '..', 'config', 'budget.json'
+);
+
+const DEFAULT_BUDGET = {
+  max_actions: 2000,
+  max_time_minutes: 600, // 10 hours
+  profiles: {
+    strict: { max_actions: 500, max_time_minutes: 150 },
+    guided: { max_actions: 2000, max_time_minutes: 600 },
+    autonomous: { max_actions: 5000, max_time_minutes: 1200 },
+  },
+};
+
+function loadBudgetConfig() {
+  // 1. Environment overrides
+  const envProfile = process.env.THUMBGATE_BUDGET_PROFILE;
+  const envMaxActions = process.env.THUMBGATE_MAX_ACTIONS;
+  const envMaxTime = process.env.THUMBGATE_MAX_TIME_MINUTES;
+
+  // 2. Config file
+  let fileConfig = {};
+  try {
+    if (fs.existsSync(DEFAULT_BUDGET_CONFIG_PATH)) {
+      fileConfig = JSON.parse(fs.readFileSync(DEFAULT_BUDGET_CONFIG_PATH, 'utf8'));
+    }
+  } catch { /* use defaults */ }
+
+  const merged = { ...DEFAULT_BUDGET, ...fileConfig };
+
+  // Apply profile if set
+  if (envProfile && merged.profiles && merged.profiles[envProfile]) {
+    Object.assign(merged, merged.profiles[envProfile]);
+  }
+
+  // Env overrides take final precedence
+  if (envMaxActions) {
+    const parsedMaxActions = parseInt(envMaxActions, 10);
+    if (Number.isFinite(parsedMaxActions) && parsedMaxActions > 0) {
+      merged.max_actions = parsedMaxActions;
+    }
+  }
+  if (envMaxTime) {
+    const parsedMaxTime = parseInt(envMaxTime, 10);
+    if (Number.isFinite(parsedMaxTime) && parsedMaxTime > 0) {
+      merged.max_time_minutes = parsedMaxTime;
+    }
+  }
+
+  return merged;
+}
+
+function loadBudgetState() {
+  try {
+    if (fs.existsSync(BUDGET_STATE_PATH)) {
+      return JSON.parse(fs.readFileSync(BUDGET_STATE_PATH, 'utf8'));
+    }
+  } catch { /* corrupted state — reset */ }
+  return { action_count: 0, session_start: new Date().toISOString() };
+}
+
+function saveBudgetState(state) {
+  const dir = path.dirname(BUDGET_STATE_PATH);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(BUDGET_STATE_PATH, JSON.stringify(state, null, 2));
+}
+
+function resetBudget() {
+  const state = { action_count: 0, session_start: new Date().toISOString() };
+  saveBudgetState(state);
+  return state;
+}
+
+/**
+ * Evaluate budget limits. Called before every gate evaluation.
+ * Returns null if within budget, or a deny result if budget exceeded.
+ */
+function evaluateBudget(toolName, toolInput) {
+  const config = loadBudgetConfig();
+  const state = loadBudgetState();
+
+  // Increment action count
+  state.action_count = (state.action_count || 0) + 1;
+  saveBudgetState(state);
+
+  // Check action limit
+  if (config.max_actions && state.action_count > config.max_actions) {
+    return {
+      decision: 'deny',
+      gate: 'budget-action-limit',
+      message: `Budget exceeded: ${state.action_count}/${config.max_actions} actions used. Session budget is exhausted.`,
+      severity: 'critical',
+      reasoning: `Tool call #${state.action_count} exceeds the configured max_actions limit of ${config.max_actions}.`,
+    };
+  }
+
+  // Check time limit
+  if (config.max_time_minutes && state.session_start) {
+    const elapsedMs = Date.now() - new Date(state.session_start).getTime();
+    const elapsedMinutes = elapsedMs / (60 * 1000);
+    if (elapsedMinutes > config.max_time_minutes) {
+      return {
+        decision: 'deny',
+        gate: 'budget-time-limit',
+        message: `Budget exceeded: session has run ${Math.round(elapsedMinutes)}min, limit is ${config.max_time_minutes}min.`,
+        severity: 'critical',
+        reasoning: `Session duration (${Math.round(elapsedMinutes)}min) exceeds max_time_minutes (${config.max_time_minutes}).`,
+      };
+    }
+  }
+
+  return null; // Within budget
+}
+
+/**
+ * Get current budget status for dashboard/reporting.
+ */
+function getBudgetStatus() {
+  const config = loadBudgetConfig();
+  const state = loadBudgetState();
+  const elapsedMs = state.session_start
+    ? Date.now() - new Date(state.session_start).getTime()
+    : 0;
+  const elapsedMinutes = Math.round(elapsedMs / (60 * 1000));
+
+  return {
+    action_count: state.action_count || 0,
+    max_actions: config.max_actions,
+    actions_remaining: Math.max(0, (config.max_actions || Infinity) - (state.action_count || 0)),
+    actions_pct: config.max_actions ? Math.round(((state.action_count || 0) / config.max_actions) * 100) : 0,
+    elapsed_minutes: elapsedMinutes,
+    max_time_minutes: config.max_time_minutes,
+    time_remaining_minutes: Math.max(0, (config.max_time_minutes || Infinity) - elapsedMinutes),
+    time_pct: config.max_time_minutes ? Math.round((elapsedMinutes / config.max_time_minutes) * 100) : 0,
+    session_start: state.session_start,
+    profile: process.env.THUMBGATE_BUDGET_PROFILE || 'guided',
+  };
+}
+
+module.exports = {
+  evaluateBudget,
+  getBudgetStatus,
+  loadBudgetConfig,
+  loadBudgetState,
+  saveBudgetState,
+  resetBudget,
+  BUDGET_STATE_PATH,
+  DEFAULT_BUDGET_CONFIG_PATH,
+};

package/scripts/build-claude-mcpb.js

@@ -5,6 +5,7 @@ const fs = require('fs');
 const path = require('path');
 const { execFileSync } = require('child_process');
 const {
+  getClaudePluginReviewVersionedAssetName,
   getClaudePluginVersionedAssetName,
 } = require('./distribution-surfaces');
 
@@ -27,6 +28,14 @@ const RUNTIME_COPY_PATHS = [
   'SECURITY.md',
   'server.json',
 ];
+const REVIEW_PACKET_COPY_PATHS = [
+  '.claude-plugin',
+  'docs/CLAUDE_DESKTOP_EXTENSION.md',
+  'README.md',
+  'LICENSE',
+  'SECURITY.md',
+  'server.json',
+];
 
 function readJson(relativePath) {
   return JSON.parse(fs.readFileSync(path.join(PROJECT_ROOT, relativePath), 'utf8'));
@@ -173,17 +182,74 @@ function buildClaudeMcpb(outputDir = DEFAULT_OUTPUT_DIR) {
   };
 }
 
-if (require.main === module) {
-  const outputDir = process.argv[2]
-    ? path.resolve(process.cwd(), process.argv[2])
+function buildClaudeReviewZip(outputDir = DEFAULT_OUTPUT_DIR) {
+  const packageJson = readJson('package.json');
+  const reviewRoot = path.join(outputDir, 'review');
+  const reviewDirName = 'thumbgate-claude-plugin-review';
+  const stageDir = path.join(reviewRoot, reviewDirName);
+  const outputFile = path.join(outputDir, getClaudePluginReviewVersionedAssetName(packageJson.version));
+
+  fs.rmSync(reviewRoot, { recursive: true, force: true });
+  fs.mkdirSync(stageDir, { recursive: true });
+
+  for (const relativePath of REVIEW_PACKET_COPY_PATHS) {
+    copyEntry(relativePath, stageDir);
+  }
+
+  fs.rmSync(outputFile, { force: true });
+  exec('zip', ['-qr', outputFile, reviewDirName], { cwd: reviewRoot });
+
+  return {
+    stageDir,
+    outputFile,
+  };
+}
+
+function resolveBuildRequest(args = [], cwd = process.cwd()) {
+  const mode = args.includes('--review-zip')
+    ? 'review-zip'
+    : args.includes('--all')
+      ? 'all'
+      : 'mcpb';
+  const outputArg = args.find((arg) => !arg.startsWith('--'));
+  const outputDir = outputArg
+    ? path.resolve(cwd, outputArg)
     : DEFAULT_OUTPUT_DIR;
-  const { outputFile } = buildClaudeMcpb(outputDir);
-  console.log(`Built Claude Desktop bundle: ${outputFile}`);
+
+  return { mode, outputDir };
+}
+
+function runBuildRequest({ mode, outputDir }, deps = { buildClaudeMcpb, buildClaudeReviewZip }) {
+  if (mode === 'review-zip') {
+    const { outputFile } = deps.buildClaudeReviewZip(outputDir);
+    return [`Built Claude plugin review zip: ${outputFile}`];
+  }
+
+  if (mode === 'all') {
+    const { outputFile } = deps.buildClaudeMcpb(outputDir);
+    const { outputFile: reviewOutputFile } = deps.buildClaudeReviewZip(outputDir);
+    return [
+      `Built Claude Desktop bundle: ${outputFile}`,
+      `Built Claude plugin review zip: ${reviewOutputFile}`,
+    ];
+  }
+
+  const { outputFile } = deps.buildClaudeMcpb(outputDir);
+  return [`Built Claude Desktop bundle: ${outputFile}`];
+}
+
+if (require.main === module) {
+  for (const line of runBuildRequest(resolveBuildRequest(process.argv.slice(2)))) {
+    console.log(line);
+  }
 }
 
 module.exports = {
   DEFAULT_OUTPUT_DIR,
   buildClaudeMcpbManifest,
+  buildClaudeReviewZip,
   stageClaudeMcpbBundle,
   buildClaudeMcpb,
+  resolveBuildRequest,
+  runBuildRequest,
 };

package/scripts/build-codex-plugin.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const {
+  getCodexPluginVersionedAssetName,
+} = require('./distribution-surfaces');
+
+const PROJECT_ROOT = path.join(__dirname, '..');
+const DEFAULT_OUTPUT_DIR = path.join(PROJECT_ROOT, '.artifacts', 'codex-plugin');
+const BUNDLE_ROOT_NAME = 'thumbgate-codex-plugin';
+const FIXED_BINARY_DIRS = ['/usr/bin', '/bin'];
+
+function readJson(relativePath) {
+  return JSON.parse(fs.readFileSync(path.join(PROJECT_ROOT, relativePath), 'utf8'));
+}
+
+function readText(relativePath) {
+  return fs.readFileSync(path.join(PROJECT_ROOT, relativePath), 'utf8');
+}
+
+function copyEntry(sourceRelativePath, targetRelativePath, stageDir) {
+  const sourcePath = path.join(PROJECT_ROOT, sourceRelativePath);
+  if (!fs.existsSync(sourcePath)) return;
+
+  const targetPath = path.join(stageDir, targetRelativePath || sourceRelativePath);
+  const stat = fs.statSync(sourcePath);
+
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+  if (stat.isDirectory()) {
+    fs.cpSync(sourcePath, targetPath, { recursive: true });
+    return;
+  }
+
+  fs.copyFileSync(sourcePath, targetPath);
+}
+
+function buildStandaloneMarketplace() {
+  const marketplace = readJson('.agents/plugins/marketplace.json');
+  return {
+    ...marketplace,
+    plugins: (marketplace.plugins || []).map((plugin) => ({
+      ...plugin,
+      source: {
+        ...plugin.source,
+        path: './',
+      },
+    })),
+  };
+}
+
+function resolveFixedBinary(binaryName, options = {}) {
+  const accessSync = options.accessSync || fs.accessSync;
+  const dirs = options.dirs || FIXED_BINARY_DIRS;
+
+  for (const dir of dirs) {
+    const binaryPath = path.join(dir, binaryName);
+    try {
+      accessSync(binaryPath, fs.constants.X_OK);
+      return binaryPath;
+    } catch {
+      // Try the next fixed, system-owned directory.
+    }
+  }
+
+  throw new Error(`Unable to find executable ${binaryName} in fixed system paths: ${dirs.join(', ')}`);
+}
+
+function stageCodexPluginBundle(outputDir = DEFAULT_OUTPUT_DIR) {
+  const packageJson = readJson('package.json');
+  const bundleDir = path.join(outputDir, 'bundle');
+  const stageDir = path.join(bundleDir, BUNDLE_ROOT_NAME);
+  const outputFile = path.join(outputDir, getCodexPluginVersionedAssetName(packageJson.version));
+
+  fs.rmSync(outputDir, { recursive: true, force: true });
+  fs.mkdirSync(stageDir, { recursive: true });
+
+  copyEntry('plugins/codex-profile/.codex-plugin', '.codex-plugin', stageDir);
+  copyEntry('plugins/codex-profile/.mcp.json', '.mcp.json', stageDir);
+  copyEntry('plugins/codex-profile/README.md', 'README.md', stageDir);
+  copyEntry('plugins/codex-profile/INSTALL.md', 'INSTALL.md', stageDir);
+  copyEntry('plugins/codex-profile/AGENTS.md', 'AGENTS.md', stageDir);
+  copyEntry('LICENSE', 'LICENSE', stageDir);
+  copyEntry('adapters/codex/config.toml', 'config.toml', stageDir);
+
+  fs.mkdirSync(path.join(stageDir, '.agents', 'plugins'), { recursive: true });
+  fs.writeFileSync(
+    path.join(stageDir, '.agents', 'plugins', 'marketplace.json'),
+    JSON.stringify(buildStandaloneMarketplace(), null, 2) + '\n'
+  );
+
+  return {
+    bundleDir,
+    stageDir,
+    outputFile,
+  };
+}
+
+function buildCodexPlugin(outputDir = DEFAULT_OUTPUT_DIR) {
+  const { bundleDir, stageDir, outputFile } = stageCodexPluginBundle(outputDir);
+  const zipBinary = resolveFixedBinary('zip');
+  const unzipBinary = resolveFixedBinary('unzip');
+
+  execFileSync(zipBinary, ['-qr', outputFile, BUNDLE_ROOT_NAME], {
+    cwd: bundleDir,
+    stdio: 'inherit',
+  });
+
+  const contents = execFileSync(unzipBinary, ['-l', outputFile], {
+    cwd: PROJECT_ROOT,
+    encoding: 'utf8',
+  });
+
+  process.stdout.write(contents);
+
+  return {
+    stageDir,
+    outputFile,
+    contents,
+  };
+}
+
+function isCliEntrypoint(argv = process.argv) {
+  return path.resolve(argv[1] || '') === __filename;
+}
+
+function runCli(argv = process.argv, cwd = process.cwd(), log = console.log) {
+  const outputDir = argv[2]
+    ? path.resolve(cwd, argv[2])
+    : DEFAULT_OUTPUT_DIR;
+  const { outputFile } = buildCodexPlugin(outputDir);
+  log(`Built Codex plugin bundle: ${outputFile}`);
+  return outputFile;
+}
+
+if (isCliEntrypoint()) {
+  runCli();
+}
+
+module.exports = {
+  BUNDLE_ROOT_NAME,
+  DEFAULT_OUTPUT_DIR,
+  FIXED_BINARY_DIRS,
+  buildCodexPlugin,
+  buildStandaloneMarketplace,
+  isCliEntrypoint,
+  resolveFixedBinary,
+  runCli,
+  stageCodexPluginBundle,
+};