thumbgate 1.28.4 → 1.29.2

package/scripts/buyer-paths.js

@@ -0,0 +1,102 @@
+'use strict';
+
+const DEFAULT_APP_ORIGIN = 'https://thumbgate.ai';
+
+function normalizeAppOrigin(value = DEFAULT_APP_ORIGIN) {
+  const parsed = new URL(String(value || DEFAULT_APP_ORIGIN));
+  if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+    throw new Error('Buyer-path app origin must use http or https.');
+  }
+  parsed.pathname = '/';
+  parsed.search = '';
+  parsed.hash = '';
+  return parsed.origin;
+}
+
+function buildBuyerUrl(pathname, params = {}, appOrigin = DEFAULT_APP_ORIGIN) {
+  const normalizedOrigin = normalizeAppOrigin(appOrigin);
+  const url = new URL(pathname, `${normalizedOrigin}/`);
+  if (url.origin !== normalizedOrigin) {
+    throw new Error('Buyer URL must remain on the configured first-party origin.');
+  }
+  for (const [key, value] of Object.entries(params || {})) {
+    if (value === undefined || value === null || String(value).trim() === '') continue;
+    url.searchParams.set(key, String(value).trim());
+  }
+  return url.toString();
+}
+
+function buildProBuyerUrl({
+  billingCycle = 'monthly',
+  appOrigin = DEFAULT_APP_ORIGIN,
+  source = null,
+  medium = null,
+  campaign = null,
+  content = null,
+} = {}) {
+  return buildBuyerUrl('/go/pro', {
+    plan_id: 'pro',
+    billing_cycle: billingCycle === 'annual' ? 'annual' : 'monthly',
+    utm_source: source,
+    utm_medium: medium,
+    utm_campaign: campaign,
+    utm_content: content,
+  }, appOrigin);
+}
+
+function buildDiagnosticBuyerUrl({
+  appOrigin = DEFAULT_APP_ORIGIN,
+  source = null,
+  medium = null,
+  campaign = null,
+  content = null,
+} = {}) {
+  return buildBuyerUrl('/diagnostic', {
+    plan_id: 'sprint_diagnostic',
+    utm_source: source,
+    utm_medium: medium,
+    utm_campaign: campaign,
+    utm_content: content,
+  }, appOrigin);
+}
+
+function buildSprintBuyerUrl({
+  appOrigin = DEFAULT_APP_ORIGIN,
+  source = null,
+  medium = null,
+  campaign = null,
+  content = null,
+} = {}) {
+  return buildBuyerUrl('/go/sprint', {
+    plan_id: 'workflow_sprint',
+    utm_source: source,
+    utm_medium: medium,
+    utm_campaign: campaign,
+    utm_content: content,
+  }, appOrigin);
+}
+
+function buildEnterpriseBuyerUrl({ appOrigin = DEFAULT_APP_ORIGIN } = {}) {
+  const url = new URL('/', `${normalizeAppOrigin(appOrigin)}/`);
+  url.hash = 'workflow-sprint-intake';
+  return url.toString();
+}
+
+function isFirstPartyBuyerUrl(value, appOrigin = DEFAULT_APP_ORIGIN) {
+  try {
+    return new URL(value).origin === normalizeAppOrigin(appOrigin);
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  DEFAULT_APP_ORIGIN,
+  buildBuyerUrl,
+  buildDiagnosticBuyerUrl,
+  buildEnterpriseBuyerUrl,
+  buildProBuyerUrl,
+  buildSprintBuyerUrl,
+  isFirstPartyBuyerUrl,
+  normalizeAppOrigin,
+};

package/scripts/cli-feedback.js

@@ -98,13 +98,13 @@ function formatCliOutput(result) {
   const isDown = ['down', 'negative', 'thumbs_down'].includes(feedbackSignal);
 
   // Header
-  if (feedbackResult?.duplicate) {
+  if (feedbackResult?.duplicate && feedbackResult.accepted === true) {
     lines.push(`${Y}${BD}Feedback already captured${RST}`);
     const feedbackId = feedbackResult.feedbackEvent?.id;
     const memoryId = feedbackResult.memoryRecord?.id;
     if (feedbackId) lines.push(`${D}  Feedback ID: ${feedbackId}${RST}`);
     if (memoryId) lines.push(`${D}  Memory ID  : ${memoryId}${RST}`);
-  } else if (feedbackResult && feedbackResult.accepted !== false) {
+  } else if (feedbackResult?.accepted === true) {
     lines.push(`${isDown ? R : G}${BD}${isDown ? '👎 Thumbs down recorded' : '👍 Thumbs up recorded'}${RST}`);
     const feedbackId = feedbackResult.feedbackEvent?.id || feedbackResult.id;
     const memoryId = feedbackResult.memoryRecord?.id || feedbackResult.memoryId;

package/scripts/commercial-offer.js

@@ -1,7 +1,15 @@
 'use strict';
 
-const PRO_MONTHLY_PAYMENT_LINK = 'https://thumbgate.ai/go/pro?utm_source=offer';
-const PRO_ANNUAL_PAYMENT_LINK = 'https://buy.stripe.com/3cI8wPfCYaPs2dzdKz3sI07';
+const { buildProBuyerUrl } = require('./buyer-paths');
+
+const PRO_MONTHLY_PAYMENT_LINK = buildProBuyerUrl({
+  billingCycle: 'monthly',
+  source: 'offer',
+});
+const PRO_ANNUAL_PAYMENT_LINK = buildProBuyerUrl({
+  billingCycle: 'annual',
+  source: 'offer',
+});
 
 const PRO_MONTHLY_PRICE_ID = 'price_1THQY7GGBpd520QYHoS7RG0J';
 const PRO_ANNUAL_PRICE_ID = 'price_1THQZ7GGBpd520QYxzDRnxhB';
@@ -14,12 +22,11 @@ const TEAM_ANNUAL_PRICE_DOLLARS = 588;
 const TEAM_MIN_SEATS = 3;
 
 const PRO_PRICE_LABEL = '$19/mo or $149/yr (individual)';
-// Enterprise is the contact-sales tier (absorbs the former Team workflow + the
-// regulated-industry lane). Pricing is scoped after intake — no self-serve seat
-// price is surfaced. The dormant TEAM_* Stripe constants below remain only as
-// inert billing plumbing pending a dedicated cleanup; they are no longer a
-// customer-facing tier.
-const ENTERPRISE_PRICE_LABEL = 'Custom pricing, scoped after intake — Enterprise agent governance';
+// The Enterprise Workflow Gate is the one promoted public service offer. The
+// dormant TEAM_* Stripe constants below remain only as inert billing plumbing
+// pending a dedicated cleanup; they are no longer a customer-facing tier.
+const ENTERPRISE_PRICE_LABEL = 'Enterprise Workflow Gate — $499 one-time for one supported workflow';
+const ENTERPRISE_ENTRY_URL = 'https://thumbgate.ai/pricing';
 
 function normalizePlanId(value) {
   const text = String(value || '').trim().toLowerCase();
@@ -74,7 +81,7 @@ function buildCaptureReceipt({ signal, feedbackId, memoryId, actionType } = {})
     `  Solo Pro       : ${PRO_PRICE_LABEL} for recall, dashboard, adapters, and exports`,
     `  Upgrade        : ${trackedProUrl('cli_capture_receipt', actionType || normalizedSignal.toLowerCase())}`,
     `  Enterprise     : ${ENTERPRISE_PRICE_LABEL}; start with one repeated workflow failure`,
-    '                   https://thumbgate.ai/#workflow-sprint-intake',
+    `                   ${ENTERPRISE_ENTRY_URL}`,
     '',
   ];
   return lines.join('\n');
@@ -107,7 +114,7 @@ function buildStatsReceipt(stats = {}) {
   lines.push('  Show the buyer     : npx thumbgate cost');
   lines.push('  Pro recall value   : keep lessons/rules searchable, exportable, and visible');
   lines.push(`  Solo Pro           : ${trackedProUrl('cli_stats_receipt', 'proof_seen')}`);
-  lines.push('  Enterprise         : https://thumbgate.ai/#workflow-sprint-intake');
+  lines.push(`  Enterprise         : ${ENTERPRISE_ENTRY_URL}`);
   lines.push('');
   return lines.join('\n');
 }
@@ -125,6 +132,7 @@ module.exports = {
   TEAM_MIN_SEATS,
   PRO_PRICE_LABEL,
   ENTERPRISE_PRICE_LABEL,
+  ENTERPRISE_ENTRY_URL,
   normalizePlanId,
   normalizeBillingCycle,
   normalizeSeatCount,

package/scripts/durability/step.js

@@ -107,7 +107,34 @@ function errMessage(err) {
   return err?.message ?? err;
 }
 
-function handleStepError({ err, attempt, retries, classify, backoffMs, name, onRetry, onFail, logger }) {
+function retryAfterMs(err) {
+  const raw = err?.retryAfterMs
+    ?? err?.headers?.['retry-after-ms']
+    ?? err?.headers?.['retry-after'];
+  if (raw === undefined || raw === null || raw === '') return null;
+  const numeric = Number(raw);
+  if (Number.isFinite(numeric)) {
+    return String(raw).includes('.') || err?.headers?.['retry-after'] !== undefined
+      ? Math.max(0, numeric * 1000)
+      : Math.max(0, numeric);
+  }
+  const dateMs = Date.parse(raw);
+  return Number.isNaN(dateMs) ? null : Math.max(0, dateMs - Date.now());
+}
+
+function handleStepError({
+  err,
+  attempt,
+  retries,
+  classify,
+  backoffMs,
+  name,
+  onRetry,
+  onFail,
+  logger,
+  jitterRatio,
+  randomFn,
+}) {
   const verdict = classify(err);
   const terminal = verdict === 'fail' || attempt >= retries;
   if (terminal) {
@@ -117,7 +144,11 @@ function handleStepError({ err, attempt, retries, classify, backoffMs, name, onR
     }
     return { terminal: true };
   }
-  const waitMs = backoffMs[Math.min(attempt, backoffMs.length - 1)];
+  const configuredWait = backoffMs[Math.min(attempt, backoffMs.length - 1)];
+  const serverWait = retryAfterMs(err);
+  const baseWait = serverWait === null ? configuredWait : Math.max(configuredWait, serverWait);
+  const jitter = jitterRatio > 0 ? baseWait * jitterRatio * ((randomFn() * 2) - 1) : 0;
+  const waitMs = Math.max(0, Math.round(baseWait + jitter));
   if (typeof onRetry === 'function') onRetry({ name, attempt, err, waitMs, verdict });
   if (typeof logger === 'function') {
     logger(`[step:${name}] RETRY attempt=${attempt} waitMs=${waitMs} err=${errMessage(err)}`);
@@ -126,10 +157,9 @@ function handleStepError({ err, attempt, retries, classify, backoffMs, name, onR
 }
 
 async function runStep(name, options, fn) {
-  if (typeof options === 'function') {
-    fn = options;
-    options = {};
-  }
+  const invocation = normalizeStepInvocation(options, fn);
+  options = invocation.options;
+  fn = invocation.fn;
   const {
     retries = 3,
     backoffMs = DEFAULT_BACKOFF_MS,
@@ -139,33 +169,112 @@ async function runStep(name, options, fn) {
     onFail,
     logger,
     sleepFn = sleep,
+    sideEffect = false,
+    idempotencyKey: stepIdempotencyKey,
+    maxElapsedMs = Infinity,
+    jitterRatio = 0,
+    randomFn = Math.random,
   } = options || {};
 
-  if (typeof fn !== 'function') {
-    throw new TypeError(`runStep(${name}): fn must be a function`);
-  }
+  validateStepConfiguration(name, fn, {
+    sideEffect,
+    stepIdempotencyKey,
+    maxElapsedMs,
+  });
 
   let lastErr;
+  const startedAt = Date.now();
   for (let attempt = 0; attempt <= retries; attempt++) {
-    if (typeof onAttempt === 'function') onAttempt({ name, attempt });
+    const context = {
+      name,
+      attempt,
+      idempotencyKey: stepIdempotencyKey || null,
+      elapsedMs: Date.now() - startedAt,
+    };
+    callIfFunction(onAttempt, context);
     try {
-      return await fn({ attempt });
+      return await fn(context);
     } catch (err) {
       lastErr = err;
       const outcome = handleStepError({
-        err, attempt, retries, classify, backoffMs, name, onRetry, onFail, logger,
+        err,
+        attempt,
+        retries,
+        classify,
+        backoffMs,
+        name,
+        onRetry,
+        onFail,
+        logger,
+        jitterRatio: Math.max(0, Number(jitterRatio) || 0),
+        randomFn,
       });
       if (outcome.terminal) throw err;
+      enforceRetryBudget({
+        err,
+        attempt,
+        name,
+        onFail,
+        startedAt,
+        waitMs: outcome.waitMs,
+        maxElapsedMs,
+      });
       await sleepFn(outcome.waitMs);
     }
   }
   throw lastErr;
 }
 
+function normalizeStepInvocation(options, fn) {
+  if (typeof options === 'function') return { options: {}, fn: options };
+  return { options: options || {}, fn };
+}
+
+function validateStepConfiguration(name, fn, options) {
+  if (typeof fn !== 'function') {
+    throw new TypeError(`runStep(${name}): fn must be a function`);
+  }
+  if (options.sideEffect && !String(options.stepIdempotencyKey || '').trim()) {
+    const error = new Error(`runStep(${name}): side-effecting steps require idempotencyKey`);
+    error.code = 'THUMBGATE_IDEMPOTENCY_KEY_REQUIRED';
+    error.nonRetryable = true;
+    throw error;
+  }
+  if (!Number.isFinite(Number(options.maxElapsedMs)) && options.maxElapsedMs !== Infinity) {
+    throw new TypeError(`runStep(${name}): maxElapsedMs must be finite or Infinity`);
+  }
+}
+
+function callIfFunction(callback, payload) {
+  if (typeof callback === 'function') callback(payload);
+}
+
+function enforceRetryBudget({
+  err,
+  attempt,
+  name,
+  onFail,
+  startedAt,
+  waitMs,
+  maxElapsedMs,
+}) {
+  if (Date.now() - startedAt + waitMs <= maxElapsedMs) return;
+  err.code = err.code || 'THUMBGATE_RETRY_BUDGET_EXHAUSTED';
+  err.retryBudgetExhausted = true;
+  callIfFunction(onFail, {
+    name,
+    attempt,
+    err,
+    verdict: 'retry_budget_exhausted',
+  });
+  throw err;
+}
+
 module.exports = {
   runStep,
   idempotencyKey,
   defaultClassify,
   TRANSIENT_CODES,
   DEFAULT_BACKOFF_MS,
+  retryAfterMs,
 };