thumbgate 1.28.3 → 1.29.1

package/scripts/jsonl-window.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const fs = require('node:fs');
+
+/**
+ * Read recent JSONL rows since `sinceMs`, scanning at most maxBytes from EOF.
+ * Avoids loading multi-MB ledgers entirely into memory (export timeout fix).
+ */
+function readJsonlSinceTail(filePath, {
+  sinceMs = 0,
+  limit = 1000,
+  maxBytes = 8 * 1024 * 1024,
+  timestampKeys = ['timestamp', 'receivedAt', 'ts', 'createdAt'],
+} = {}) {
+  if (!filePath || !fs.existsSync(filePath)) {
+    return { rows: [], totalAfterSince: 0, truncated: false, scannedBytes: 0 };
+  }
+
+  let stat;
+  try {
+    stat = fs.statSync(filePath);
+  } catch {
+    return { rows: [], totalAfterSince: 0, truncated: false, scannedBytes: 0 };
+  }
+
+  const size = stat.size || 0;
+  if (size === 0) {
+    return { rows: [], totalAfterSince: 0, truncated: false, scannedBytes: 0 };
+  }
+
+  const scanBytes = Math.min(size, Math.max(64 * 1024, maxBytes));
+  const start = Math.max(0, size - scanBytes);
+  let buf;
+  try {
+    const fd = fs.openSync(filePath, 'r');
+    try {
+      buf = Buffer.alloc(scanBytes);
+      fs.readSync(fd, buf, 0, scanBytes, start);
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch {
+    return { rows: [], totalAfterSince: 0, truncated: false, scannedBytes: 0 };
+  }
+
+  let text = buf.toString('utf8');
+  // If we started mid-file, drop the partial first line.
+  if (start > 0) {
+    const nl = text.indexOf('\n');
+    text = nl >= 0 ? text.slice(nl + 1) : '';
+  }
+
+  const matched = [];
+  for (const line of text.split('\n')) {
+    if (!line) continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    let parsed = NaN;
+    for (const key of timestampKeys) {
+      const raw = obj && obj[key];
+      if (raw == null) continue;
+      parsed = typeof raw === 'number' ? raw : Date.parse(raw);
+      if (Number.isFinite(parsed)) break;
+    }
+    // Preserve since filter: only include rows with a parseable timestamp
+    // inside the window. Legacy/malformed lines without timestamps must not
+    // inflate totalAfterSince or journey summaries.
+    if (Number.isFinite(parsed) && parsed >= sinceMs) {
+      matched.push(obj);
+    }
+  }
+
+  const totalAfterSince = matched.length;
+  const rows = matched.slice(-Math.max(1, limit));
+  return {
+    rows,
+    totalAfterSince,
+    truncated: totalAfterSince > rows.length || start > 0,
+    scannedBytes: scanBytes,
+  };
+}
+
+module.exports = {
+  readJsonlSinceTail,
+};

package/scripts/lesson-embedding-index.js

@@ -99,16 +99,12 @@ function isEmbedderAvailable() {
     const cfg = resolveGeminiEmbeddingConfig();
     if (cfg && cfg.enabled && cfg.apiKey) return true;
   } catch { /* policy module unavailable */ }
-  // Local transformers path
-  try {
-    require.resolve('@huggingface/transformers');
-    return true;
-  } catch { /* not installed */ }
-  return false;
+  // The zero-dependency feature-hash provider is always available locally.
+  return true;
 }
 
 function defaultEmbedder() {
-  // Lazy: do not pull in LanceDB/transformers at module require time.
+  // Lazy: do not pull in LanceDB or optional embedding providers at module require time.
   const { embed } = require('./vector-store');
   return embed;
 }

package/scripts/meta-agent-loop.js

@@ -581,6 +581,20 @@ async function main() {
   const args = process.argv.slice(2);
   const dryRun = args.includes('--dry-run');
   const verbose = args.includes('--verbose') || args.includes('-v');
+  let hookMode = args.includes('--hook');
+
+  // Settings may already be cached by a running agent process. Detect the
+  // current Stop payload as well, so the legacy command (without --hook) is
+  // immediately JSON-safe before the host reloads its settings.
+  if (!hookMode && !process.stdin.isTTY) {
+    try {
+      const raw = fs.readFileSync(0, 'utf8');
+      const payload = raw ? JSON.parse(raw) : {};
+      hookMode = payload.hook_event_name === 'Stop';
+    } catch {
+      // Normal CLI invocation with empty/non-JSON stdin.
+    }
+  }
 
   if (args.includes('--status')) {
     const status = getMetaAgentStatus();
@@ -593,9 +607,13 @@ async function main() {
   }
 
   const mode = dryRun ? 'DRY RUN' : 'LIVE';
-  console.log(`Meta-agent loop starting [${mode}]...`);
+  if (!hookMode) console.log(`Meta-agent loop starting [${mode}]...`);
+
+  const manifest = await runMetaAgentLoop({ dryRun, verbose: hookMode ? false : true });
 
-  const manifest = await runMetaAgentLoop({ dryRun, verbose: verbose || true });
+  // Stop hooks may emit only empty stdout or a valid JSON object. The loop's
+  // work is intentionally silent in hook mode.
+  if (hookMode) return;
 
   console.log(`Run ID        : ${manifest.runId}`);
   console.log(`Analysis mode : ${manifest.analysisMode}`);

package/scripts/observability-env.js

@@ -0,0 +1,139 @@
+'use strict';
+
+/**
+ * Load operator-local observability credentials into process.env.
+ *
+ * Sources (first wins per key, never overwrite an already-set env var):
+ *  1. process.env
+ *  2. ~/.config/thumbgate/observability.json
+ *  3. ~/.config/thumbgate/operator.json (operatorKey / baseUrl only)
+ *  4. Stripe managed secret files via resolveStripeSecretKey
+ *
+ * The JSON file is gitignored operator state. Never print secret values.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const OBSERVABILITY_CONFIG_PATH = path.join(os.homedir(), '.config', 'thumbgate', 'observability.json');
+const OPERATOR_CONFIG_PATH = path.join(os.homedir(), '.config', 'thumbgate', 'operator.json');
+
+const JSON_KEY_TO_ENV = Object.freeze({
+  stripeSecretKey: 'STRIPE_SECRET_KEY',
+  plausibleApiKey: 'PLAUSIBLE_API_KEY',
+  plausibleSiteId: 'PLAUSIBLE_SITE_ID',
+  plausibleSiteIds: 'PLAUSIBLE_SITE_IDS',
+  plausibleRegisteredDomains: 'THUMBGATE_PLAUSIBLE_REGISTERED_DOMAINS',
+  posthogPersonalApiKey: 'POSTHOG_PERSONAL_API_KEY',
+  posthogProjectId: 'POSTHOG_PROJECT_ID',
+  operatorKey: 'THUMBGATE_OPERATOR_KEY',
+  apiKey: 'THUMBGATE_API_KEY',
+  publicAppOrigin: 'THUMBGATE_PUBLIC_APP_ORIGIN',
+  billingApiBaseUrl: 'THUMBGATE_BILLING_API_BASE_URL',
+});
+
+function normalizeText(value) {
+  if (value === undefined || value === null) return null;
+  const text = String(value).trim();
+  return text || null;
+}
+
+function readJsonFile(filePath) {
+  try {
+    if (!filePath || !fs.existsSync(filePath)) return null;
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function applyJsonToEnv(json, env) {
+  if (!json || typeof json !== 'object') return [];
+  const applied = [];
+  for (const [jsonKey, envKey] of Object.entries(JSON_KEY_TO_ENV)) {
+    if (normalizeText(env[envKey])) continue;
+    const value = normalizeText(json[jsonKey]);
+    if (!value) continue;
+    env[envKey] = value;
+    applied.push(envKey);
+  }
+  return applied;
+}
+
+function loadObservabilityEnv({
+  env = process.env,
+  observabilityPath = OBSERVABILITY_CONFIG_PATH,
+  operatorPath = OPERATOR_CONFIG_PATH,
+  applyStripeManagedFiles = true,
+} = {}) {
+  const applied = [];
+
+  const observability = readJsonFile(observabilityPath);
+  applied.push(...applyJsonToEnv(observability, env));
+
+  const operator = readJsonFile(operatorPath);
+  if (operator) {
+    if (!normalizeText(env.THUMBGATE_OPERATOR_KEY) && normalizeText(operator.operatorKey)) {
+      env.THUMBGATE_OPERATOR_KEY = String(operator.operatorKey).trim();
+      applied.push('THUMBGATE_OPERATOR_KEY');
+    }
+    if (!normalizeText(env.THUMBGATE_BILLING_API_BASE_URL) && normalizeText(operator.baseUrl)) {
+      env.THUMBGATE_BILLING_API_BASE_URL = String(operator.baseUrl).trim();
+      applied.push('THUMBGATE_BILLING_API_BASE_URL');
+    }
+  }
+
+  if (applyStripeManagedFiles && !normalizeText(env.STRIPE_SECRET_KEY)) {
+    try {
+      const { resolveStripeSecretKey } = require('./stripe-credentials');
+      const resolved = resolveStripeSecretKey({ env });
+      if (resolved.secretKey) {
+        env.STRIPE_SECRET_KEY = resolved.secretKey;
+        applied.push('STRIPE_SECRET_KEY');
+      }
+    } catch {
+      // stripe-credentials optional at load time
+    }
+  }
+
+  // Product-primary Plausible domain is always part of the registered set for
+  // doctor/automation unless the operator explicitly overrides site id.
+  if (!normalizeText(env.PLAUSIBLE_SITE_ID) && !normalizeText(env.THUMBGATE_PLAUSIBLE_REGISTERED_DOMAINS)) {
+    env.THUMBGATE_PLAUSIBLE_REGISTERED_DOMAINS = 'thumbgate.ai,thumbgate-production.up.railway.app';
+    applied.push('THUMBGATE_PLAUSIBLE_REGISTERED_DOMAINS');
+  }
+
+  return {
+    applied: [...new Set(applied)],
+    observabilityPath,
+    operatorPath,
+    hasStripe: Boolean(normalizeText(env.STRIPE_SECRET_KEY)),
+    hasPlausible: Boolean(normalizeText(env.PLAUSIBLE_API_KEY) && normalizeText(env.PLAUSIBLE_SITE_ID)),
+    hasPosthog: Boolean(normalizeText(env.POSTHOG_PERSONAL_API_KEY) && normalizeText(env.POSTHOG_PROJECT_ID)),
+    hasOperator: Boolean(normalizeText(env.THUMBGATE_OPERATOR_KEY) || normalizeText(env.THUMBGATE_API_KEY)),
+  };
+}
+
+function observabilityConfigTemplate() {
+  return {
+    stripeSecretKey: '',
+    plausibleApiKey: '',
+    plausibleSiteId: 'thumbgate.ai',
+    plausibleRegisteredDomains: 'thumbgate.ai,thumbgate-production.up.railway.app',
+    posthogPersonalApiKey: '',
+    posthogProjectId: '',
+    publicAppOrigin: 'https://thumbgate.ai',
+    billingApiBaseUrl: 'https://thumbgate-production.up.railway.app',
+  };
+}
+
+module.exports = {
+  OBSERVABILITY_CONFIG_PATH,
+  OPERATOR_CONFIG_PATH,
+  JSON_KEY_TO_ENV,
+  loadObservabilityEnv,
+  observabilityConfigTemplate,
+  readJsonFile,
+  normalizeText,
+};

package/scripts/observability-setup.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const {
+  OBSERVABILITY_CONFIG_PATH,
+  observabilityConfigTemplate,
+  loadObservabilityEnv,
+} = require('./observability-env');
+
+function ensureDir(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
+function main(argv = process.argv.slice(2)) {
+  const write = argv.includes('--write');
+  const print = argv.includes('--print') || !write;
+  const template = observabilityConfigTemplate();
+
+  if (print && !write) {
+    process.stdout.write(`${JSON.stringify(template, null, 2)}\n`);
+    process.stdout.write(
+      `\n# Write to ${OBSERVABILITY_CONFIG_PATH} with --write after filling secrets.\n` +
+      '# Never commit this file. Doctor/revenue tools load it automatically.\n'
+    );
+  }
+
+  if (write) {
+    ensureDir(OBSERVABILITY_CONFIG_PATH);
+    if (fs.existsSync(OBSERVABILITY_CONFIG_PATH)) {
+      process.stderr.write(`Refusing to overwrite existing ${OBSERVABILITY_CONFIG_PATH}\n`);
+      process.exitCode = 2;
+      return;
+    }
+    fs.writeFileSync(OBSERVABILITY_CONFIG_PATH, `${JSON.stringify(template, null, 2)}\n`, { mode: 0o600 });
+    process.stdout.write(`Wrote template ${OBSERVABILITY_CONFIG_PATH}\n`);
+  }
+
+  const status = loadObservabilityEnv({ env: { ...process.env } });
+  process.stdout.write(JSON.stringify({
+    configPath: OBSERVABILITY_CONFIG_PATH,
+    hasStripe: status.hasStripe,
+    hasPlausible: status.hasPlausible,
+    hasPosthog: status.hasPosthog,
+    hasOperator: status.hasOperator,
+  }, null, 2) + '\n');
+}
+
+if (require('node:path').resolve(process.argv[1] || '') === require('node:path').resolve(__filename)) {
+  main();
+}
+
+module.exports = { main };

package/scripts/plausible-domain-config.js

@@ -30,7 +30,11 @@ function getConfiguredRegisteredDomains(env = process.env) {
     ...splitDomains(env.PLAUSIBLE_REGISTERED_DOMAINS),
   ].map(normalizeDomain).filter(Boolean);
 
+  // Both product surfaces are first-class Plausible site ids for ThumbGate.
+  // Emitting data-domain=thumbgate.ai while only registering the Railway host
+  // previously made primary-domain traffic invisible to automation.
   return [...new Set([
+    PRIMARY_PLAUSIBLE_DOMAIN,
     FALLBACK_REGISTERED_PLAUSIBLE_DOMAIN,
     ...configured,
   ])];