thumbgate 0.9.10

package/scripts/bot-detector.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const BOT_PATTERNS = [
+  /bot/i, /crawl/i, /spider/i, /slurp/i, /mediapartners/i,
+  /Googlebot/i, /Bingbot/i, /DuckDuckBot/i, /Baiduspider/i,
+  /YandexBot/i, /facebookexternalhit/i, /Twitterbot/i,
+  /LinkedInBot/i, /WhatsApp/i, /Discordbot/i, /TelegramBot/i,
+  /Applebot/i, /PetalBot/i, /SemrushBot/i, /AhrefsBot/i,
+  /MJ12bot/i, /DotBot/i, /Bytespider/i,
+  /GPTBot/i, /ChatGPT/i, /Claude-SearchBot/i, /Anthropic/i, /Perplexity/i,
+  /Google-Extended/i, /CCBot/i, /cohere-ai/i,
+  /HeadlessChrome/i, /PhantomJS/i, /Puppeteer/i, /Playwright/i,
+  /python-requests/i, /node-fetch/i, /wget/i,
+  /Scrapy/i, /HttpClient/i, /Go-http-client/i,
+  /UptimeRobot/i, /Pingdom/i, /StatusCake/i,
+];
+
+const OWNER_EMAILS = ['iganapolsky@gmail.com', 'ig5973700@gmail.com'];
+
+function classifyVisitor(req) {
+  const ua = (req.headers && req.headers['user-agent']) || '';
+  const email = req.email || (req.query && req.query.email) || '';
+
+  for (const pattern of BOT_PATTERNS) {
+    if (pattern.test(ua)) {
+      return { type: 'bot', reason: `UA matches: ${pattern}`, userAgent: ua };
+    }
+  }
+  if (!ua || ua.length < 10) {
+    return { type: 'bot', reason: 'Empty or short user-agent', userAgent: ua };
+  }
+  for (const ownerEmail of OWNER_EMAILS) {
+    if (email && email.toLowerCase().includes(ownerEmail.toLowerCase())) {
+      return { type: 'owner', reason: `Email matches: ${ownerEmail}`, userAgent: ua };
+    }
+  }
+  return { type: 'real_user', reason: 'No bot pattern matched', userAgent: ua };
+}
+
+function shouldExcludeFromAnalytics(req) {
+  const classification = req.visitorClass || classifyVisitor(req);
+  return classification.type === 'bot';
+}
+
+function botFilterMiddleware(req, res, next) {
+  req.visitorClass = classifyVisitor(req);
+  next();
+}
+
+module.exports = { classifyVisitor, botFilterMiddleware, shouldExcludeFromAnalytics, BOT_PATTERNS, OWNER_EMAILS };

package/scripts/budget-guard.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+
+const PROJECT_ROOT = path.join(__dirname, '..');
+const FEEDBACK_DIR = process.env.THUMBGATE_FEEDBACK_DIR || path.join(PROJECT_ROOT, '.claude', 'memory', 'feedback');
+const LEDGER_PATH = path.join(FEEDBACK_DIR, 'budget-ledger.json');
+const LOCK_PATH = `${LEDGER_PATH}.lock`;
+
+function parseMonthlyBudget(rawValue) {
+  const parsed = Number(rawValue);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`Invalid THUMBGATE_MONTHLY_BUDGET_USD value: '${rawValue}'`);
+  }
+  return parsed;
+}
+
+function getMonthlyBudget() {
+  const rawValue = process.env.THUMBGATE_MONTHLY_BUDGET_USD || '10';
+  return parseMonthlyBudget(rawValue);
+}
+
+function currentMonthKey() {
+  const now = new Date();
+  return `${now.getUTCFullYear()}-${String(now.getUTCMonth() + 1).padStart(2, '0')}`;
+}
+
+function loadLedger() {
+  if (!fs.existsSync(LEDGER_PATH)) return { months: {} };
+  return JSON.parse(fs.readFileSync(LEDGER_PATH, 'utf-8'));
+}
+
+function saveLedger(ledger) {
+  fs.mkdirSync(path.dirname(LEDGER_PATH), { recursive: true });
+  fs.writeFileSync(LEDGER_PATH, `${JSON.stringify(ledger, null, 2)}\n`);
+}
+
+function blockMs(ms) {
+  const start = Date.now();
+  while (Date.now() - start < ms) {
+    // Intentional synchronous short wait while lock clears.
+  }
+}
+
+function acquireLock({ timeoutMs = 5000, staleMs = 15000 } = {}) {
+  const startedAt = Date.now();
+  fs.mkdirSync(path.dirname(LOCK_PATH), { recursive: true });
+
+  while (true) {
+    try {
+      return fs.openSync(LOCK_PATH, 'wx');
+    } catch (err) {
+      if (err.code !== 'EEXIST') throw err;
+
+      try {
+        const stat = fs.statSync(LOCK_PATH);
+        if (Date.now() - stat.mtimeMs > staleMs) {
+          fs.rmSync(LOCK_PATH, { force: true });
+          continue;
+        }
+      } catch {
+        // lock disappeared between retries
+      }
+
+      if (Date.now() - startedAt > timeoutMs) {
+        throw new Error('Could not acquire budget ledger lock');
+      }
+      blockMs(20);
+    }
+  }
+}
+
+function releaseLock(lockFd) {
+  try {
+    fs.closeSync(lockFd);
+  } finally {
+    fs.rmSync(LOCK_PATH, { force: true });
+  }
+}
+
+function addSpend({ amountUsd, source, note }) {
+  if (!Number.isFinite(amountUsd) || amountUsd < 0) {
+    throw new Error('amountUsd must be a non-negative number');
+  }
+
+  const budgetUsd = getMonthlyBudget();
+  const lockFd = acquireLock();
+  try {
+    const ledger = loadLedger();
+    const month = currentMonthKey();
+    if (!ledger.months[month]) {
+      ledger.months[month] = {
+        totalUsd: 0,
+        entries: [],
+      };
+    }
+
+    const nextTotal = ledger.months[month].totalUsd + amountUsd;
+    if (nextTotal > budgetUsd) {
+      throw new Error(`Budget exceeded: ${nextTotal.toFixed(2)} > ${budgetUsd.toFixed(2)} USD/month`);
+    }
+
+    ledger.months[month].totalUsd = nextTotal;
+    ledger.months[month].entries.push({
+      ts: new Date().toISOString(),
+      source: source || 'unknown',
+      note: note || '',
+      amountUsd,
+    });
+
+    saveLedger(ledger);
+    return {
+      month,
+      totalUsd: ledger.months[month].totalUsd,
+      budgetUsd,
+    };
+  } finally {
+    releaseLock(lockFd);
+  }
+}
+
+function getBudgetStatus() {
+  const budgetUsd = getMonthlyBudget();
+  const ledger = loadLedger();
+  const month = currentMonthKey();
+  const total = ledger.months[month] ? ledger.months[month].totalUsd : 0;
+  return {
+    month,
+    totalUsd: total,
+    budgetUsd,
+    remainingUsd: Math.max(0, budgetUsd - total),
+  };
+}
+
+function runCli() {
+  const args = process.argv.slice(2);
+  if (args.includes('--status')) {
+    console.log(JSON.stringify(getBudgetStatus(), null, 2));
+    return;
+  }
+
+  const addArg = args.find((a) => a.startsWith('--add='));
+  if (!addArg) {
+    console.log('Usage: node scripts/budget-guard.js --status');
+    console.log('Usage: node scripts/budget-guard.js --add=0.15 --source=paperbanana --note="diagram generation"');
+    process.exit(1);
+  }
+
+  const amountUsd = Number(addArg.replace('--add=', ''));
+  const sourceArg = args.find((a) => a.startsWith('--source='));
+  const noteArg = args.find((a) => a.startsWith('--note='));
+
+  const result = addSpend({
+    amountUsd,
+    source: sourceArg ? sourceArg.replace('--source=', '') : 'unknown',
+    note: noteArg ? noteArg.replace('--note=', '') : '',
+  });
+
+  console.log(JSON.stringify(result, null, 2));
+}
+
+module.exports = {
+  addSpend,
+  getBudgetStatus,
+  getMonthlyBudget,
+  parseMonthlyBudget,
+  LEDGER_PATH,
+  LOCK_PATH,
+};
+
+if (require.main === module) {
+  runCli();
+}

package/scripts/build-claude-mcpb.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const {
+  getClaudePluginVersionedAssetName,
+} = require('./distribution-surfaces');
+
+const PROJECT_ROOT = path.join(__dirname, '..');
+const DEFAULT_OUTPUT_DIR = path.join(PROJECT_ROOT, '.artifacts', 'claude-desktop');
+const RUNTIME_COPY_PATHS = [
+  'bin',
+  'src',
+  'scripts',
+  'adapters',
+  'config',
+  'plugins',
+  'skills',
+  'openapi',
+  'public',
+  '.well-known',
+  '.claude-plugin',
+  'README.md',
+  'LICENSE',
+  'SECURITY.md',
+  'server.json',
+];
+
+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(relativePath, stageDir) {
+  const sourcePath = path.join(PROJECT_ROOT, relativePath);
+  if (!fs.existsSync(sourcePath)) return;
+
+  const targetPath = path.join(stageDir, relativePath);
+  const stat = fs.statSync(sourcePath);
+  if (stat.isDirectory()) {
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+    fs.cpSync(sourcePath, targetPath, { recursive: true });
+    return;
+  }
+
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+  fs.copyFileSync(sourcePath, targetPath);
+}
+
+function exec(command, args, options = {}) {
+  return execFileSync(command, args, {
+    cwd: PROJECT_ROOT,
+    stdio: 'inherit',
+    ...options,
+  });
+}
+
+function buildClaudeMcpbManifest() {
+  const packageJson = readJson('package.json');
+  const pluginManifest = readJson('.claude-plugin/plugin.json');
+  const marketplace = readJson('.claude-plugin/marketplace.json');
+  const { TOOLS } = require(path.join(PROJECT_ROOT, 'scripts', 'tool-registry'));
+
+  const repositoryUrl = String(pluginManifest.repository || packageJson.repository.url).replace(/\.git$/, '');
+  const privacyPolicyUrl = `${packageJson.homepage}/privacy`;
+  const marketplaceEntry = marketplace.plugins[0];
+  const readme = readText('.claude-plugin/README.md')
+    .split('\n')
+    .slice(0, 6)
+    .join(' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+
+  return {
+    manifest_version: '0.3',
+    name: pluginManifest.name,
+    display_name: 'ThumbGate',
+    version: packageJson.version,
+    description: marketplaceEntry.description,
+    long_description: readme,
+    author: {
+      name: pluginManifest.author.name,
+      url: repositoryUrl,
+    },
+    repository: {
+      type: 'git',
+      url: repositoryUrl,
+    },
+    homepage: packageJson.homepage,
+    documentation: `${repositoryUrl}/blob/main/docs/CLAUDE_DESKTOP_EXTENSION.md`,
+    support: `${repositoryUrl}/issues`,
+    icon: 'icon.png',
+    server: {
+      type: 'node',
+      entry_point: 'server/index.js',
+      mcp_config: {
+        command: 'node',
+        args: ['${__dirname}/server/index.js'],
+        env: {},
+      },
+    },
+    tools: TOOLS.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+    })),
+    tools_generated: true,
+    keywords: pluginManifest.keywords,
+    license: packageJson.license,
+    privacy_policies: [privacyPolicyUrl],
+  };
+}
+
+function stageClaudeMcpbBundle(outputDir = DEFAULT_OUTPUT_DIR) {
+  const packageJson = readJson('package.json');
+  const stageDir = path.join(outputDir, 'bundle');
+  const outputFile = path.join(outputDir, getClaudePluginVersionedAssetName(packageJson.version));
+
+  fs.rmSync(outputDir, { recursive: true, force: true });
+  fs.mkdirSync(path.join(stageDir, 'server'), { recursive: true });
+
+  for (const relativePath of RUNTIME_COPY_PATHS) {
+    copyEntry(relativePath, stageDir);
+  }
+
+  copyEntry('package.json', stageDir);
+  copyEntry('package-lock.json', stageDir);
+
+  fs.writeFileSync(
+    path.join(stageDir, 'server', 'index.js'),
+    readText('.claude-plugin/bundle/server/index.js')
+  );
+  fs.writeFileSync(
+    path.join(stageDir, 'icon.png'),
+    fs.readFileSync(path.join(PROJECT_ROOT, '.claude-plugin', 'bundle', 'icon.png'))
+  );
+  fs.writeFileSync(
+    path.join(stageDir, 'README.md'),
+    readText('.claude-plugin/README.md')
+  );
+  fs.writeFileSync(
+    path.join(stageDir, 'manifest.json'),
+    JSON.stringify(buildClaudeMcpbManifest(), null, 2) + '\n'
+  );
+
+  return {
+    stageDir,
+    outputFile,
+  };
+}
+
+function buildClaudeMcpb(outputDir = DEFAULT_OUTPUT_DIR) {
+  const { stageDir, outputFile } = stageClaudeMcpbBundle(outputDir);
+
+  exec('npm', ['ci', '--omit=dev'], { cwd: stageDir });
+  exec('npx', ['-y', '@anthropic-ai/mcpb', 'pack', stageDir, outputFile], { cwd: PROJECT_ROOT });
+
+  const info = execFileSync('npx', ['-y', '@anthropic-ai/mcpb', 'info', outputFile], {
+    cwd: PROJECT_ROOT,
+    encoding: 'utf8',
+  });
+
+  process.stdout.write(info);
+
+  return {
+    stageDir,
+    outputFile,
+    info,
+  };
+}
+
+if (require.main === module) {
+  const outputDir = process.argv[2]
+    ? path.resolve(process.cwd(), process.argv[2])
+    : DEFAULT_OUTPUT_DIR;
+  const { outputFile } = buildClaudeMcpb(outputDir);
+  console.log(`Built Claude Desktop bundle: ${outputFile}`);
+}
+
+module.exports = {
+  DEFAULT_OUTPUT_DIR,
+  buildClaudeMcpbManifest,
+  stageClaudeMcpbBundle,
+  buildClaudeMcpb,
+};

package/scripts/build-metadata.js

@@ -0,0 +1,97 @@
+const fs = require('fs');
+const path = require('path');
+
+const PROJECT_ROOT = path.resolve(__dirname, '..');
+const DEFAULT_BUILD_METADATA_PATH = path.join(PROJECT_ROOT, 'config', 'build-metadata.json');
+
+function normalizeNullableText(value) {
+  if (typeof value !== 'string') {
+    return null;
+  }
+
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function resolveBuildMetadata({ env = process.env, filePath } = {}) {
+  const resolvedPath =
+    normalizeNullableText(filePath) ||
+    normalizeNullableText(env.THUMBGATE_BUILD_METADATA_PATH) ||
+    DEFAULT_BUILD_METADATA_PATH;
+
+  try {
+    const parsed = JSON.parse(fs.readFileSync(resolvedPath, 'utf8'));
+    return {
+      path: resolvedPath,
+      buildSha: normalizeNullableText(parsed.buildSha),
+      generatedAt: normalizeNullableText(parsed.generatedAt),
+    };
+  } catch {
+    return {
+      path: resolvedPath,
+      buildSha: null,
+      generatedAt: null,
+    };
+  }
+}
+
+function writeBuildMetadataFile({ sha, outputPath, generatedAt = new Date().toISOString() }) {
+  const buildSha = normalizeNullableText(sha);
+  if (!buildSha) {
+    throw new Error('A non-empty build SHA is required.');
+  }
+
+  const targetPath = normalizeNullableText(outputPath) || DEFAULT_BUILD_METADATA_PATH;
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+  const payload = {
+    buildSha,
+    generatedAt,
+  };
+  fs.writeFileSync(targetPath, `${JSON.stringify(payload, null, 2)}\n`);
+  return {
+    path: targetPath,
+    ...payload,
+  };
+}
+
+function parseArgs(argv) {
+  const options = {
+    sha: null,
+    outputPath: null,
+    generatedAt: null,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--sha') {
+      options.sha = argv[index + 1] || null;
+      index += 1;
+      continue;
+    }
+    if (arg === '--output') {
+      options.outputPath = argv[index + 1] || null;
+      index += 1;
+      continue;
+    }
+    if (arg === '--generated-at') {
+      options.generatedAt = argv[index + 1] || null;
+      index += 1;
+      continue;
+    }
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return options;
+}
+
+if (require.main === module) {
+  const { sha, outputPath, generatedAt } = parseArgs(process.argv.slice(2));
+  const result = writeBuildMetadataFile({ sha, outputPath, generatedAt: generatedAt || undefined });
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+}
+
+module.exports = {
+  DEFAULT_BUILD_METADATA_PATH,
+  resolveBuildMetadata,
+  writeBuildMetadataFile,
+};