@ipv9/tokentracker-cli 0.39.37 → 0.39.39

package/src/commands/device-login.js

@@ -1,161 +0,0 @@
-"use strict";
-
-const os = require("node:os");
-const path = require("node:path");
-const fs = require("node:fs/promises");
-
-const { readJson, writeJson } = require("../lib/fs");
-const { resolveTrackerPaths } = require("../lib/tracker-paths");
-
-const DEFAULT_BASE_URL = "https://srctyff5.us-east.insforge.app";
-const POLL_INTERVAL_MS = 5_000;
-const ABSOLUTE_TIMEOUT_MS = 16 * 60 * 1000; // matches the 15-min server window with a small buffer
-
-function readBaseUrl(config) {
-  return (
-    process.env.TOKENTRACKER_BASE_URL ||
-    process.env.TOKENTRACKER_API_URL ||
-    config?.baseUrl ||
-    DEFAULT_BASE_URL
-  );
-}
-
-async function authorize({ baseUrl, clientInfo }) {
-  const res = await fetch(`${baseUrl}/functions/tokentracker-device-flow-authorize`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ client_info: clientInfo }),
-  });
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`authorize failed (HTTP ${res.status}): ${text.slice(0, 200)}`);
-  }
-  return res.json();
-}
-
-async function pollOnce({ baseUrl, deviceCode }) {
-  const res = await fetch(`${baseUrl}/functions/tokentracker-device-flow-poll`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ device_code: deviceCode }),
-  });
-  const data = await res.json().catch(() => ({}));
-  // 404 = unknown, 410 = expired, 200 = {status, user_id?, device_token?}.
-  // Anything else (502 from a misconfigured edge, 5xx during deploy, …) must
-  // bubble up as a network-style error — masking it as "unknown" would tell
-  // the user their device_code was evicted when it wasn't.
-  if (!res.ok && res.status !== 404 && res.status !== 410) {
-    throw new Error(`poll HTTP ${res.status}: ${(data?.error ?? "").toString().slice(0, 200)}`);
-  }
-  return {
-    status: data.status ?? "unknown",
-    user_id: data.user_id ?? null,
-    deviceToken: data.device_token ?? data.deviceToken ?? null,
-    deviceId: data.device_id ?? data.deviceId ?? null,
-    httpStatus: res.status,
-  };
-}
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-async function cmdDeviceLogin(argv = [], options = {}) {
-  const opts = parseArgs(argv);
-  const home = options.home || os.homedir();
-  const sleepFn = options.sleep || sleep;
-  const { trackerDir } = await resolveTrackerPaths({ home });
-  const configPath = path.join(trackerDir, "config.json");
-  const config = (await readJson(configPath)) || {};
-  const baseUrl = opts.baseUrl || readBaseUrl(config);
-
-  const clientInfo = `${os.platform()}-${os.arch()} ${os.hostname()}`;
-  process.stdout.write(`Requesting device code from ${baseUrl}...\n`);
-  const authResp = await authorize({ baseUrl, clientInfo });
-
-  if (opts.json) {
-    process.stdout.write(JSON.stringify(authResp, null, 2) + "\n");
-  } else {
-    process.stdout.write(
-      [
-        "",
-        "  Sign in from a browser:",
-        `    ${authResp.verification_uri_complete || authResp.verification_uri}`,
-        "",
-        `  Or visit ${authResp.verification_uri} and enter the code:`,
-        "",
-        `      ${authResp.user_code}`,
-        "",
-        `  This code expires in ${Math.round(authResp.expires_in / 60)} minutes.`,
-        "  Polling every 5 seconds until you approve…",
-        "",
-      ].join("\n"),
-    );
-  }
-
-  const startedAt = Date.now();
-  let consecutiveErrors = 0;
-  const MAX_BACKOFF_MS = 30_000;
-  while (Date.now() - startedAt < ABSOLUTE_TIMEOUT_MS) {
-    // Exponential backoff on consecutive network failures (capped at 30s) so
-    // a flaky network doesn't hammer the server at the full 5s cadence for
-    // the entire 15-minute window. ±20% jitter on retries prevents
-    // thundering-herd reconnects when many CLIs lose connectivity at once.
-    let wait =
-      consecutiveErrors === 0
-        ? POLL_INTERVAL_MS
-        : Math.min(POLL_INTERVAL_MS * Math.pow(2, consecutiveErrors - 1), MAX_BACKOFF_MS);
-    if (consecutiveErrors > 0) {
-      const jitter = wait * 0.2 * (Math.random() * 2 - 1);
-      wait = Math.max(POLL_INTERVAL_MS, wait + jitter);
-    }
-    await sleepFn(wait);
-    let result;
-    try {
-      result = await pollOnce({ baseUrl, deviceCode: authResp.device_code });
-      consecutiveErrors = 0;
-    } catch (e) {
-      consecutiveErrors++;
-      process.stderr.write(`poll error (retry ${consecutiveErrors}): ${e?.message || e}\n`);
-      continue;
-    }
-    if (result.status === "approved" && result.user_id) {
-      if (!result.deviceToken) {
-        throw new Error("device login approved but server did not return a device token");
-      }
-      const next = {
-        ...config,
-        baseUrl,
-        user_id: result.user_id,
-        deviceToken: result.deviceToken,
-        deviceId: result.deviceId || config.deviceId,
-        device_login_at: new Date().toISOString(),
-      };
-      await writeJson(configPath, next);
-      process.stdout.write(`\n✓ Approved. device token written to ${configPath}\n`);
-      return;
-    }
-    if (result.status === "expired") {
-      throw new Error("device_code expired — re-run `tracker device-login`");
-    }
-    if (result.status === "unknown") {
-      throw new Error("device_code is unknown — server may have evicted it");
-    }
-    // status === "pending" → just keep polling silently
-  }
-  throw new Error("device-login timed out without approval");
-}
-
-function parseArgs(argv) {
-  const out = { json: false, baseUrl: null };
-  for (let i = 0; i < argv.length; i++) {
-    const a = argv[i];
-    if (a === "--json") out.json = true;
-    else if (a === "--base-url") {
-      out.baseUrl = argv[++i] || null;
-    } else throw new Error(`Unknown option: ${a}`);
-  }
-  return out;
-}
-
-module.exports = { cmdDeviceLogin, authorize, pollOnce };

package/src/lib/upload-throttle.js

@@ -1,148 +0,0 @@
-const DEFAULTS = {
-  intervalMs: 30 * 60_000,
-  jitterMsMax: 60_000,
-  backlogBytes: 1_000_000,
-  batchSize: 300,
-  maxBatchesSmall: 2,
-  maxBatchesLarge: 4,
-  backoffInitialMs: 60_000,
-  backoffMaxMs: 30 * 60_000,
-};
-
-function normalizeState(raw) {
-  const s = raw && typeof raw === "object" ? raw : {};
-  return {
-    version: 1,
-    lastSuccessMs: toSafeInt(s.lastSuccessMs),
-    nextAllowedAtMs: toSafeInt(s.nextAllowedAtMs),
-    backoffUntilMs: toSafeInt(s.backoffUntilMs),
-    backoffStep: toSafeInt(s.backoffStep),
-    lastErrorAt: typeof s.lastErrorAt === "string" ? s.lastErrorAt : null,
-    lastError: typeof s.lastError === "string" ? s.lastError : null,
-    updatedAt: typeof s.updatedAt === "string" ? s.updatedAt : null,
-  };
-}
-
-function decideAutoUpload({ nowMs, pendingBytes, state, config }) {
-  const cfg = { ...DEFAULTS, ...(config || {}) };
-  const s = normalizeState(state);
-  const pending = Number(pendingBytes || 0);
-
-  if (pending <= 0) {
-    return {
-      allowed: false,
-      reason: "no-pending",
-      maxBatches: 0,
-      batchSize: cfg.batchSize,
-      blockedUntilMs: 0,
-    };
-  }
-
-  const blockedUntilMs = Math.max(s.nextAllowedAtMs || 0, s.backoffUntilMs || 0);
-  if (blockedUntilMs > 0 && nowMs < blockedUntilMs) {
-    return {
-      allowed: false,
-      reason: "throttled",
-      maxBatches: 0,
-      batchSize: cfg.batchSize,
-      blockedUntilMs,
-    };
-  }
-
-  const maxBatches = pending >= cfg.backlogBytes ? cfg.maxBatchesLarge : cfg.maxBatchesSmall;
-  return {
-    allowed: true,
-    reason: "allowed",
-    maxBatches,
-    batchSize: cfg.batchSize,
-    blockedUntilMs: 0,
-  };
-}
-
-function recordUploadSuccess({ nowMs, state, config, randInt }) {
-  const cfg = { ...DEFAULTS, ...(config || {}) };
-  const s = normalizeState(state);
-  const jitter =
-    typeof randInt === "function" ? randInt(0, cfg.jitterMsMax) : randomInt(0, cfg.jitterMsMax);
-  const nextAllowedAtMs = nowMs + cfg.intervalMs + jitter;
-
-  return {
-    ...s,
-    lastSuccessMs: nowMs,
-    nextAllowedAtMs,
-    backoffUntilMs: 0,
-    backoffStep: 0,
-    lastErrorAt: null,
-    lastError: null,
-    updatedAt: new Date(nowMs).toISOString(),
-  };
-}
-
-function recordUploadFailure({ nowMs, state, error, config }) {
-  const cfg = { ...DEFAULTS, ...(config || {}) };
-  const s = normalizeState(state);
-
-  const retryAfterMs = toSafeInt(error?.retryAfterMs);
-  const status = toSafeInt(error?.status);
-
-  let backoffMs = 0;
-  if (retryAfterMs > 0) {
-    backoffMs = Math.min(cfg.backoffMaxMs, Math.max(cfg.backoffInitialMs, retryAfterMs));
-  } else {
-    const step = Math.min(10, Math.max(0, s.backoffStep || 0));
-    backoffMs = Math.min(cfg.backoffMaxMs, cfg.backoffInitialMs * Math.pow(2, step));
-  }
-
-  const backoffUntilMs = nowMs + backoffMs;
-  const nextAllowedAtMs = Math.max(s.nextAllowedAtMs || 0, backoffUntilMs);
-
-  return {
-    ...s,
-    nextAllowedAtMs,
-    backoffUntilMs,
-    backoffStep: Math.min(20, (s.backoffStep || 0) + 1),
-    lastErrorAt: new Date(nowMs).toISOString(),
-    lastError: truncate(String(error?.message || "upload failed"), 200),
-    updatedAt: new Date(nowMs).toISOString(),
-  };
-}
-
-function parseRetryAfterMs(headerValue, nowMs = Date.now()) {
-  if (typeof headerValue !== "string" || headerValue.trim().length === 0) return null;
-  const v = headerValue.trim();
-  const seconds = Number(v);
-  if (Number.isFinite(seconds) && seconds >= 0) return Math.floor(seconds * 1000);
-  const d = new Date(v);
-  if (Number.isNaN(d.getTime())) return null;
-  const delta = d.getTime() - nowMs;
-  return delta > 0 ? delta : 0;
-}
-
-function randomInt(min, maxInclusive) {
-  const lo = Math.floor(min);
-  const hi = Math.floor(maxInclusive);
-  if (hi <= lo) return lo;
-  return lo + Math.floor(Math.random() * (hi - lo + 1));
-}
-
-function toSafeInt(v) {
-  const n = Number(v);
-  if (!Number.isFinite(n)) return 0;
-  if (n <= 0) return 0;
-  return Math.floor(n);
-}
-
-function truncate(s, maxLen) {
-  if (typeof s !== "string") return "";
-  if (s.length <= maxLen) return s;
-  return s.slice(0, maxLen - 1) + "…";
-}
-
-module.exports = {
-  DEFAULTS,
-  normalizeState,
-  decideAutoUpload,
-  recordUploadSuccess,
-  recordUploadFailure,
-  parseRetryAfterMs,
-};