thumbgate 1.1.0 → 1.3.0

package/scripts/prove-packaged-runtime.js

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const http = require('http');
+const net = require('net');
+const { execFileSync } = require('child_process');
+
+const ROOT = path.join(__dirname, '..');
+const DEFAULT_TIMEOUT_MS = 15000;
+const STATUSLINE_INPUT = JSON.stringify({ context_window: { used_percentage: 12 } });
+
+function parseArgs(argv = process.argv.slice(2)) {
+  const parsed = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith('--')) continue;
+    const [rawKey, inlineValue] = token.slice(2).split('=');
+    const key = rawKey.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+    const value = inlineValue !== undefined ? inlineValue : argv[index + 1];
+    parsed[key] = value;
+    if (inlineValue === undefined) index += 1;
+  }
+  return parsed;
+}
+
+function pkgVersion() {
+  return require(path.join(ROOT, 'package.json')).version;
+}
+
+function packCurrentRepo(packDir) {
+  fs.mkdirSync(packDir, { recursive: true });
+  const output = execFileSync('npm', ['pack', '--json', '--pack-destination', packDir], {
+    cwd: ROOT,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  const parsed = JSON.parse(output);
+  const fileName = parsed && parsed[0] && parsed[0].filename;
+  if (!fileName) {
+    throw new Error('npm pack did not return a tarball filename');
+  }
+  return path.join(packDir, fileName);
+}
+
+function installPackage(prefixDir, packageSpec) {
+  fs.mkdirSync(prefixDir, { recursive: true });
+  execFileSync('npm', ['install', '--prefix', prefixDir, '--no-fund', '--no-audit', packageSpec], {
+    cwd: ROOT,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  return path.join(prefixDir, 'node_modules', '.bin', 'thumbgate');
+}
+
+function request(url, timeoutMs = 2000) {
+  return new Promise((resolve, reject) => {
+    const req = http.get(url, (res) => {
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', (chunk) => { body += chunk; });
+      res.on('end', () => resolve({ statusCode: res.statusCode, body }));
+    });
+    req.on('error', reject);
+    req.setTimeout(timeoutMs, () => {
+      req.destroy(new Error(`Timed out requesting ${url}`));
+    });
+  });
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function getAvailablePort() {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.listen(0, '127.0.0.1', () => {
+      const address = server.address();
+      const port = address && address.port;
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve(port);
+      });
+    });
+    server.on('error', reject);
+  });
+}
+
+async function waitForHealthy(origin, expectedVersion, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    try {
+      const response = await request(`${origin}/health`);
+      if (response.statusCode === 200) {
+        const body = JSON.parse(response.body);
+        if (body.version === expectedVersion) {
+          return body;
+        }
+      }
+    } catch {
+      // Keep polling until the detached API server comes online.
+    }
+    await sleep(250);
+  }
+  throw new Error(`Timed out waiting for packaged runtime health at ${origin}`);
+}
+
+function renderStatusline(runtimeBin, projectDir, env) {
+  return execFileSync(runtimeBin, ['statusline-render'], {
+    cwd: projectDir,
+    env,
+    encoding: 'utf8',
+    input: STATUSLINE_INPUT,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    timeout: 10000,
+  });
+}
+
+function runtimeStatePath(homeDir) {
+  return path.join(homeDir, '.thumbgate', 'runtime', 'statusline-api.json');
+}
+
+async function stopDetachedRuntime(homeDir) {
+  try {
+    const state = JSON.parse(fs.readFileSync(runtimeStatePath(homeDir), 'utf8'));
+    const pid = Number(state && state.pid);
+    if (!Number.isInteger(pid) || pid <= 0) return;
+    try {
+      process.kill(pid, 'SIGTERM');
+    } catch {
+      return;
+    }
+    for (let attempt = 0; attempt < 10; attempt += 1) {
+      await sleep(100);
+      try {
+        process.kill(pid, 0);
+      } catch {
+        return;
+      }
+    }
+    try {
+      process.kill(pid, 'SIGKILL');
+    } catch {
+      // Ignore cleanup races.
+    }
+  } catch {
+    // No runtime state means nothing to clean up.
+  }
+}
+
+async function runPackagedRuntimeSmoke(options = {}) {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'thumbgate-packaged-runtime-'));
+  const homeDir = path.join(tempRoot, 'home');
+  const projectDir = path.join(tempRoot, 'project');
+  const packDir = path.join(tempRoot, 'pack');
+  const runtimeDir = path.join(tempRoot, 'runtime');
+  const expectedVersion = options.expectedVersion || pkgVersion();
+  const feedbackDir = path.join(projectDir, '.thumbgate');
+  fs.mkdirSync(homeDir, { recursive: true });
+  fs.mkdirSync(projectDir, { recursive: true });
+  fs.mkdirSync(feedbackDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(feedbackDir, 'feedback-log.jsonl'),
+    [
+      JSON.stringify({ signal: 'positive', timestamp: '2026-04-08T20:00:00.000Z', context: 'packaged runtime smoke pass' }),
+      JSON.stringify({ signal: 'negative', timestamp: '2026-04-08T20:01:00.000Z', context: 'packaged runtime smoke fail path' }),
+    ].join('\n') + '\n'
+  );
+
+  try {
+    const packageSpec = options.packageSpec || packCurrentRepo(packDir);
+    const runtimeBin = installPackage(runtimeDir, packageSpec);
+    if (!fs.existsSync(runtimeBin)) {
+      throw new Error(`Installed runtime binary is missing: ${runtimeBin}`);
+    }
+
+    const port = await getAvailablePort();
+    const origin = `http://127.0.0.1:${port}`;
+    const env = {
+      ...process.env,
+      HOME: homeDir,
+      THUMBGATE_PROJECT_DIR: projectDir,
+      THUMBGATE_LOCAL_API_ORIGIN: origin,
+      THUMBGATE_API_KEY: 'tg_packaged_runtime_smoke',
+      NO_COLOR: '1',
+    };
+
+    const initialStatusline = renderStatusline(runtimeBin, projectDir, env);
+    if (!initialStatusline.includes(`ThumbGate v${expectedVersion}`)) {
+      throw new Error(`Statusline version mismatch before boot: ${initialStatusline.trim()}`);
+    }
+    if (!/(Dashboard|Dashboard…)/.test(initialStatusline) || !/(Lessons|Lessons…)/.test(initialStatusline)) {
+      throw new Error(`Statusline missing dashboard affordances before boot: ${initialStatusline.trim()}`);
+    }
+
+    const health = await waitForHealthy(origin, expectedVersion, Number(options.timeoutMs || DEFAULT_TIMEOUT_MS));
+    const dashboard = await request(`${origin}/dashboard`);
+    const lessons = await request(`${origin}/lessons`);
+    if (dashboard.statusCode !== 200) {
+      throw new Error(`Packaged dashboard returned ${dashboard.statusCode}`);
+    }
+    if (lessons.statusCode !== 200) {
+      throw new Error(`Packaged lessons returned ${lessons.statusCode}`);
+    }
+
+    const readyStatusline = renderStatusline(runtimeBin, projectDir, env);
+    if (!readyStatusline.includes(`${origin}/dashboard`)) {
+      throw new Error(`Ready statusline missing dashboard URL: ${readyStatusline.trim()}`);
+    }
+    if (!readyStatusline.includes(`${origin}/lessons`)) {
+      throw new Error(`Ready statusline missing lessons URL: ${readyStatusline.trim()}`);
+    }
+    if (!readyStatusline.includes(`${origin}/feedback/quick?signal=up`)) {
+      throw new Error(`Ready statusline missing thumbs-up URL: ${readyStatusline.trim()}`);
+    }
+    if (!readyStatusline.includes(`${origin}/feedback/quick?signal=down`)) {
+      throw new Error(`Ready statusline missing thumbs-down URL: ${readyStatusline.trim()}`);
+    }
+
+    return {
+      packageSpec,
+      expectedVersion,
+      origin,
+      health,
+    };
+  } finally {
+    await stopDetachedRuntime(homeDir);
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+}
+
+async function main() {
+  const args = parseArgs();
+  const result = await runPackagedRuntimeSmoke({
+    packageSpec: args.packageSpec,
+    expectedVersion: args.expectedVersion,
+    timeoutMs: args.timeoutMs,
+  });
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+}
+
+if (require.main === module) {
+  main().catch((error) => {
+    process.stderr.write(`${error.message || String(error)}\n`);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  getAvailablePort,
+  packCurrentRepo,
+  runPackagedRuntimeSmoke,
+  waitForHealthy,
+};

package/scripts/prove-runtime.js

@@ -5,6 +5,7 @@ const os = require('os');
 const path = require('path');
 
 const { buildManagedScheduleCommand } = require('./schedule-manager');
+const { runPackagedRuntimeSmoke } = require('./prove-packaged-runtime');
 
 const ROOT = path.join(__dirname, '..');
 const RUNNER_PATH = require.resolve('./async-job-runner');
@@ -275,6 +276,18 @@ async function run() {
         }
       },
     },
+    {
+      id: 'RUNTIME-07',
+      desc: 'packaged thumbgate runtime boots local API and serves dashboard affordances',
+      fn: async () => {
+        const result = await runPackagedRuntimeSmoke({
+          expectedVersion: require(path.join(ROOT, 'package.json')).version,
+        });
+        if (!result.health || result.health.version !== require(path.join(ROOT, 'package.json')).version) {
+          throw new Error('Packaged runtime health version did not match package.json');
+        }
+      },
+    },
   ];
 
   console.log('Interruptible Runtime - Proof Gate\n');

package/scripts/published-cli.js

@@ -13,6 +13,10 @@ function runtimePrefixDir(prefixDir) {
   return prefixDir || path.join(os.homedir(), '.thumbgate', 'runtime');
 }
 
+function installedRuntimeBin(prefixDir) {
+  return path.join(runtimePrefixDir(prefixDir), 'node_modules', '.bin', 'thumbgate');
+}
+
 function publishedCliArgs(pkgVersion, commandArgs = [], options = {}) {
   return [
     'exec',
@@ -29,7 +33,11 @@ function publishedCliArgs(pkgVersion, commandArgs = [], options = {}) {
 
 function publishedCliShellCommand(pkgVersion, commandArgs = [], options = {}) {
   const prefixDir = runtimePrefixDir(options.prefixDir);
-  return `mkdir -p ${shellQuote(prefixDir)} && exec npm ${publishedCliArgs(pkgVersion, commandArgs, { prefixDir }).map(shellQuote).join(' ')}`;
+  const runtimeBin = installedRuntimeBin(prefixDir);
+  const escapedArgs = commandArgs.map(shellQuote).join(' ');
+  const fastPath = `[ -x ${shellQuote(runtimeBin)} ] && exec ${shellQuote(runtimeBin)}${escapedArgs ? ` ${escapedArgs}` : ''}`;
+  const installPath = `mkdir -p ${shellQuote(prefixDir)} && exec npm ${publishedCliArgs(pkgVersion, commandArgs, { prefixDir }).map(shellQuote).join(' ')}`;
+  return `${fastPath} || ${installPath}`;
 }
 
 function runPublishedCli(pkgVersion, commandArgs = [], options = {}) {
@@ -55,6 +63,7 @@ function runPublishedCliHelp(pkgVersion, options = {}) {
 module.exports = {
   publishedCliArgs,
   publishedCliShellCommand,
+  installedRuntimeBin,
   runtimePrefixDir,
   runPublishedCli,
   runPublishedCliHelp,

package/scripts/rate-limiter.js

@@ -10,9 +10,9 @@ const {
 const USAGE_FILE = path.join(process.env.HOME || '/tmp', '.thumbgate', 'usage-limits.json');
 
 const FREE_TIER_LIMITS = {
-  capture_feedback: { daily: Infinity, label: 'feedback captures' },
+  capture_feedback: { daily: 3, label: 'feedback captures' },
   search_lessons: { daily: 5, label: 'lesson searches' },
-  search_thumbgate: { daily: 10, label: 'ThumbGate searches' },
+  search_thumbgate: { daily: 5, label: 'ThumbGate searches' },
   commerce_recall: { daily: 5, label: 'commerce recalls' },
   export_dpo: { daily: 0, label: 'DPO exports (Pro only)' },
   export_databricks: { daily: 0, label: 'Databricks exports (Pro only)' },
@@ -83,7 +83,7 @@ function checkLimit(action, authContext) {
   const current = usage.counts[action] || 0;
 
   if (current >= dailyLimit) {
-    return { allowed: false, message: UPGRADE_MESSAGE, used: current, limit: dailyLimit };
+    return { allowed: false, message: `Free tier limit reached. Upgrade to Pro for unlimited: https://thumbgate-production.up.railway.app/pro\n${UPGRADE_MESSAGE}`, used: current, limit: dailyLimit };
   }
 
   // Increment

package/scripts/statusline-links.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const http = require('http');
+const { spawn } = require('child_process');
+
+const { getHomeDir, getRuntimeDir, resolveProjectDir } = require('./feedback-paths');
+const { resolveProKey } = require('./pro-local-dashboard');
+
+const DEFAULT_ORIGIN = 'http://localhost:3456';
+const DEFAULT_TIMEOUT_MS = 150;
+const DEFAULT_BOOT_GRACE_MS = 5000;
+const PKG_ROOT = path.join(__dirname, '..');
+
+function parseOrigin(origin) {
+  const url = new URL(origin || DEFAULT_ORIGIN);
+  return {
+    origin: url.origin,
+    host: url.hostname,
+    port: Number(url.port || (url.protocol === 'https:' ? 443 : 80)),
+    protocol: url.protocol,
+  };
+}
+
+function isLoopbackHost(host) {
+  return host === 'localhost' || host === '127.0.0.1' || host === '::1';
+}
+
+function runtimeStatePath(options = {}) {
+  return path.join(getRuntimeDir(options), 'statusline-api.json');
+}
+
+function readRuntimeState(options = {}) {
+  try {
+    return JSON.parse(fs.readFileSync(runtimeStatePath(options), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeRuntimeState(payload, options = {}) {
+  const targetPath = runtimeStatePath(options);
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+  fs.writeFileSync(targetPath, JSON.stringify(payload, null, 2) + '\n');
+  return targetPath;
+}
+
+function isPidAlive(pid) {
+  const numericPid = Number(pid);
+  if (!Number.isInteger(numericPid) || numericPid <= 0) return false;
+  try {
+    process.kill(numericPid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function shouldReuseBootingState(state, now = Date.now()) {
+  if (!state || !isPidAlive(state.pid)) return false;
+  const startedAt = Date.parse(state.startedAt || 0);
+  if (!Number.isFinite(startedAt)) return true;
+  return now - startedAt < DEFAULT_BOOT_GRACE_MS;
+}
+
+function requestOk(url, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    const req = http.get(url, (res) => {
+      res.resume();
+      resolve(res.statusCode >= 200 && res.statusCode < 500);
+    });
+    req.on('error', () => resolve(false));
+    req.setTimeout(timeoutMs, () => {
+      req.destroy();
+      resolve(false);
+    });
+  });
+}
+
+async function probeLocalServer(origin, options = {}) {
+  const timeoutMs = Number(options.timeoutMs || DEFAULT_TIMEOUT_MS);
+  return requestOk(`${origin}/health`, timeoutMs);
+}
+
+function launchLocalServer(options = {}) {
+  const env = options.env || process.env;
+  const origin = parseOrigin(options.origin || env.THUMBGATE_LOCAL_API_ORIGIN || DEFAULT_ORIGIN);
+  const homeDir = options.homeDir || getHomeDir({ env });
+  const resolvedKey = (options.resolveKey || resolveProKey)({ env, homeDir });
+  const projectDir = resolveProjectDir({ env, cwd: options.cwd || process.cwd() });
+  const childEnv = {
+    ...env,
+    HOST: origin.host,
+    PORT: String(origin.port),
+    THUMBGATE_LOCAL_API_ORIGIN: origin.origin,
+    THUMBGATE_PROJECT_DIR: projectDir,
+    THUMBGATE_PRO_MODE: '1',
+  };
+
+  if (resolvedKey && resolvedKey.key) {
+    childEnv.THUMBGATE_API_KEY = resolvedKey.key;
+  }
+
+  const child = spawn(
+    process.execPath,
+    [path.join(PKG_ROOT, 'bin', 'cli.js'), 'start-api'],
+    {
+      cwd: projectDir,
+      env: childEnv,
+      detached: true,
+      stdio: 'ignore',
+    }
+  );
+  child.unref();
+
+  const state = {
+    pid: child.pid,
+    projectDir,
+    origin: origin.origin,
+    startedAt: new Date().toISOString(),
+  };
+  writeRuntimeState(state, { env, home: homeDir });
+  return state;
+}
+
+function buildLinkState({
+  ready,
+  booting,
+  origin,
+  canBootstrap,
+}) {
+  if (ready) {
+    return {
+      state: 'ready',
+      dashboardLabel: 'Dashboard',
+      lessonsLabel: 'Lessons',
+      upLabel: '👍',
+      downLabel: '👎',
+      dashboardUrl: `${origin}/dashboard`,
+      lessonsUrl: `${origin}/lessons`,
+      upUrl: `${origin}/feedback/quick?signal=up`,
+      downUrl: `${origin}/feedback/quick?signal=down`,
+    };
+  }
+
+  if (booting) {
+    return {
+      state: 'booting',
+      dashboardLabel: 'Dashboard…',
+      lessonsLabel: 'Lessons…',
+      upLabel: '👍',
+      downLabel: '👎',
+      dashboardUrl: '',
+      lessonsUrl: '',
+      upUrl: '',
+      downUrl: '',
+    };
+  }
+
+  return {
+    state: canBootstrap ? 'offline' : 'unavailable',
+    dashboardLabel: canBootstrap ? 'Dash: thumbgate pro' : 'Dashboard',
+    lessonsLabel: 'Learn: thumbgate lessons',
+    upLabel: '👍',
+    downLabel: '👎',
+    dashboardUrl: '',
+    lessonsUrl: '',
+    upUrl: '',
+    downUrl: '',
+  };
+}
+
+async function getStatuslineLinks(options = {}) {
+  const env = options.env || process.env;
+  if (env._TEST_THUMBGATE_STATUSLINE_LINKS_JSON) {
+    return JSON.parse(env._TEST_THUMBGATE_STATUSLINE_LINKS_JSON);
+  }
+
+  const homeDir = options.homeDir || getHomeDir({ env });
+  const parsedOrigin = parseOrigin(options.origin || env.THUMBGATE_LOCAL_API_ORIGIN || DEFAULT_ORIGIN);
+  const origin = parsedOrigin.origin;
+  const allowLocalBootstrap = isLoopbackHost(parsedOrigin.host);
+  const probe = options.probeLocalServer || probeLocalServer;
+  const resolveKey = options.resolveKey || resolveProKey;
+  const startServer = options.launchLocalServer || launchLocalServer;
+  const key = resolveKey({ env, homeDir });
+  const canBootstrap = allowLocalBootstrap && Boolean(key && key.key);
+
+  const ready = allowLocalBootstrap ? await probe(origin, options) : false;
+  if (ready) {
+    return buildLinkState({ ready: true, booting: false, origin, canBootstrap });
+  }
+
+  const state = readRuntimeState({ env, home: homeDir });
+  if (shouldReuseBootingState(state)) {
+    return buildLinkState({ ready: false, booting: true, origin, canBootstrap });
+  }
+
+  if (canBootstrap) {
+    startServer({
+      env,
+      homeDir,
+      origin,
+      cwd: options.cwd || process.cwd(),
+      resolveKey: () => key,
+    });
+    return buildLinkState({ ready: false, booting: true, origin, canBootstrap });
+  }
+
+  return buildLinkState({ ready: false, booting: false, origin, canBootstrap });
+}
+
+if (require.main === module) {
+  getStatuslineLinks()
+    .then((payload) => {
+      process.stdout.write(JSON.stringify(payload));
+    })
+    .catch(() => {
+      process.exit(0);
+    });
+}
+
+module.exports = {
+  buildLinkState,
+  getStatuslineLinks,
+  isPidAlive,
+  launchLocalServer,
+  parseOrigin,
+  isLoopbackHost,
+  probeLocalServer,
+  readRuntimeState,
+  runtimeStatePath,
+  shouldReuseBootingState,
+  writeRuntimeState,
+};

package/scripts/statusline-local-stats.js

@@ -3,8 +3,10 @@
 
 const { analyzeFeedback } = require('./feedback-loop');
 const { normalizeStatsPayload } = require('./hook-thumbgate-cache-updater');
+const { syncClaudeHistoryFeedback } = require('./claude-feedback-sync');
 
 try {
+  syncClaudeHistoryFeedback();
   const stats = analyzeFeedback();
   const payload = {
     ...normalizeStatsPayload(stats),