@token-dashboard/typeless-usage-uploader 0.1.1 → 0.1.4

package/dist/runtime-config.js

@@ -1,158 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import {
-  CLI_NAME,
-  DEFAULT_BACKEND_URL,
-  DEFAULT_CONFIG_FILE,
-  DEFAULT_INSTALL_ROOT,
-  DEFAULT_LAUNCHD_LABEL,
-  DEFAULT_LAUNCH_AGENT_PATH,
-  DEFAULT_STATE_DB,
-  DEFAULT_STDERR_LOG_PATH,
-  DEFAULT_STDOUT_LOG_PATH,
-  DEFAULT_TYPELESS_DB_PATH,
-  DEFAULT_TYPELESS_STORAGE_PATH,
-  STATUS_ONLINE_THRESHOLD_SECONDS,
-} from './constants.js';
-import { stableStringify } from './utils.js';
-
-const DEFAULT_INSTALL_ROOT_BASE = path.basename(DEFAULT_INSTALL_ROOT);
-
-export function deriveEnvSuffix(installRoot) {
-  const base = path.basename(installRoot);
-  if (!base.startsWith(`${DEFAULT_INSTALL_ROOT_BASE}-`)) return '';
-  const envName = base.slice(DEFAULT_INSTALL_ROOT_BASE.length + 1);
-  return envName ? `-${envName}` : '';
-}
-
-export function defaultRuntimeConfig(configFile = DEFAULT_CONFIG_FILE) {
-  const installRoot = path.dirname(configFile);
-  const envSuffix = deriveEnvSuffix(installRoot);
-  const launchdLabel = `${DEFAULT_LAUNCHD_LABEL}${envSuffix}`;
-  return {
-    configFile,
-    installRoot,
-    backendUrl: DEFAULT_BACKEND_URL,
-    intervalSeconds: 300,
-    typelessDbPath: DEFAULT_TYPELESS_DB_PATH,
-    typelessStoragePath: DEFAULT_TYPELESS_STORAGE_PATH,
-    stateDbPath: path.join(installRoot, path.basename(DEFAULT_STATE_DB)),
-    nodePath: process.execPath,
-    entryFile: '',
-    localBinDir: path.join(installRoot, 'bin'),
-    localBinPath: path.join(installRoot, 'bin', CLI_NAME),
-    homeBinLink: path.join(os.homedir(), 'bin', `${CLI_NAME}${envSuffix}`),
-    stdoutLogPath: path.join(installRoot, 'logs', path.basename(DEFAULT_STDOUT_LOG_PATH)),
-    stderrLogPath: path.join(installRoot, 'logs', path.basename(DEFAULT_STDERR_LOG_PATH)),
-    launchdLabel,
-    plistPath: path.join(installRoot, 'launchd', `${launchdLabel}.plist`),
-    launchAgentPath: path.join(
-      path.dirname(DEFAULT_LAUNCH_AGENT_PATH),
-      `${launchdLabel}.plist`,
-    ),
-    autoStartOnLogin: true,
-  };
-}
-
-export function normalizeRuntimeConfig(runtime) {
-  const installRoot = runtime.installRoot || DEFAULT_INSTALL_ROOT;
-  const envSuffix = deriveEnvSuffix(installRoot);
-  const launchdLabel = runtime.launchdLabel || `${DEFAULT_LAUNCHD_LABEL}${envSuffix}`;
-  const localBinDir = runtime.localBinDir || path.join(installRoot, 'bin');
-  return {
-    ...runtime,
-    configFile: runtime.configFile || DEFAULT_CONFIG_FILE,
-    installRoot,
-    backendUrl: runtime.backendUrl?.trim()
-      ? runtime.backendUrl.replace(/\/+$/, '')
-      : null,
-    intervalSeconds: Number(runtime.intervalSeconds) || 300,
-    typelessDbPath: runtime.typelessDbPath || DEFAULT_TYPELESS_DB_PATH,
-    typelessStoragePath:
-      runtime.typelessStoragePath || DEFAULT_TYPELESS_STORAGE_PATH,
-    stateDbPath: runtime.stateDbPath || path.join(installRoot, 'state.sqlite'),
-    nodePath: runtime.nodePath || process.execPath,
-    entryFile: runtime.entryFile || '',
-    localBinDir,
-    localBinPath: runtime.localBinPath || path.join(localBinDir, CLI_NAME),
-    homeBinLink:
-      runtime.homeBinLink || path.join(os.homedir(), 'bin', `${CLI_NAME}${envSuffix}`),
-    stdoutLogPath: runtime.stdoutLogPath || path.join(installRoot, 'logs', 'stdout.log'),
-    stderrLogPath: runtime.stderrLogPath || path.join(installRoot, 'logs', 'stderr.log'),
-    launchdLabel,
-    plistPath:
-      runtime.plistPath || path.join(installRoot, 'launchd', `${launchdLabel}.plist`),
-    launchAgentPath:
-      runtime.launchAgentPath ||
-      path.join(path.dirname(DEFAULT_LAUNCH_AGENT_PATH), `${launchdLabel}.plist`),
-    autoStartOnLogin:
-      runtime.autoStartOnLogin === undefined ? true : Boolean(runtime.autoStartOnLogin),
-  };
-}
-
-export function loadRuntimeConfig(configFile = DEFAULT_CONFIG_FILE) {
-  const runtime = defaultRuntimeConfig(configFile);
-  try {
-    const payload = JSON.parse(fs.readFileSync(configFile, 'utf8'));
-    if (!payload || typeof payload !== 'object') return runtime;
-    return normalizeRuntimeConfig({ ...runtime, ...payload, configFile });
-  } catch {
-    return runtime;
-  }
-}
-
-export function saveRuntimeConfig(runtime) {
-  const normalized = normalizeRuntimeConfig(runtime);
-  fs.mkdirSync(path.dirname(normalized.configFile), { recursive: true });
-  fs.mkdirSync(path.dirname(normalized.stdoutLogPath), { recursive: true });
-  fs.writeFileSync(normalized.configFile, `${stableStringify({
-    backendUrl: normalized.backendUrl,
-    intervalSeconds: normalized.intervalSeconds,
-    typelessDbPath: normalized.typelessDbPath,
-    typelessStoragePath: normalized.typelessStoragePath,
-    stateDbPath: normalized.stateDbPath,
-    installRoot: normalized.installRoot,
-    nodePath: normalized.nodePath,
-    entryFile: normalized.entryFile,
-    localBinDir: normalized.localBinDir,
-    localBinPath: normalized.localBinPath,
-    homeBinLink: normalized.homeBinLink,
-    stdoutLogPath: normalized.stdoutLogPath,
-    stderrLogPath: normalized.stderrLogPath,
-    launchdLabel: normalized.launchdLabel,
-    plistPath: normalized.plistPath,
-    launchAgentPath: normalized.launchAgentPath,
-    autoStartOnLogin: normalized.autoStartOnLogin,
-  })}\n`);
-  return normalized;
-}
-
-export function mergeRuntimeConfig(configFile, overrides = {}) {
-  const base = loadRuntimeConfig(configFile);
-  return normalizeRuntimeConfig({ ...base, ...overrides, configFile });
-}
-
-export function formatStatusOutput(runtime, status) {
-  return {
-    configExists: fs.existsSync(runtime.configFile),
-    loaded: status.loaded,
-    running: status.running,
-    pid: status.pid,
-    state: status.state,
-    lastExitCode: status.lastExitCode,
-    backendUrl: runtime.backendUrl,
-    intervalSeconds: runtime.intervalSeconds,
-    typelessDbPath: runtime.typelessDbPath,
-    typelessStoragePath: runtime.typelessStoragePath,
-    configFile: runtime.configFile,
-    stateDbPath: runtime.stateDbPath,
-    stdoutLogPath: runtime.stdoutLogPath,
-    stderrLogPath: runtime.stderrLogPath,
-    plistPath: runtime.plistPath,
-    launchAgentPath: runtime.launchAgentPath,
-    label: runtime.launchdLabel,
-    autoStartOnLogin: runtime.autoStartOnLogin,
-    onlineThresholdSeconds: STATUS_ONLINE_THRESHOLD_SECONDS,
-  };
-}

package/dist/state-db.js

@@ -1,280 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { Buffer } from 'node:buffer';
-import { DatabaseSync } from 'node:sqlite';
-import {
-  MAX_BATCH_BYTES,
-  MAX_BUFFER_AGE_SECONDS,
-  MAX_EVENTS_PER_BATCH,
-} from './constants.js';
-import { nowTs, stableStringify } from './utils.js';
-
-export class StateDb {
-  constructor(dbPath) {
-    this.dbPath = dbPath;
-    fs.mkdirSync(path.dirname(dbPath), { recursive: true });
-    this.db = new DatabaseSync(dbPath, { readBigInts: true });
-    this.initSchema();
-  }
-
-  close() {
-    this.db.close();
-  }
-
-  initSchema() {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS identity_config (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL,
-        updated_at REAL NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS typeless_event_state (
-        typeless_user_id TEXT NOT NULL,
-        record_uid TEXT NOT NULL,
-        fingerprint TEXT NOT NULL,
-        event_json TEXT NOT NULL,
-        is_deleted INTEGER NOT NULL DEFAULT 0,
-        updated_at REAL NOT NULL,
-        PRIMARY KEY (typeless_user_id, record_uid)
-      );
-
-      CREATE TABLE IF NOT EXISTS pending_batches (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        batch_key TEXT NOT NULL UNIQUE,
-        status TEXT NOT NULL,
-        payload_json TEXT NOT NULL,
-        payload_bytes INTEGER NOT NULL DEFAULT 0,
-        event_count INTEGER NOT NULL DEFAULT 0,
-        attempt_count INTEGER NOT NULL DEFAULT 0,
-        next_retry_at REAL,
-        last_error TEXT,
-        created_at REAL NOT NULL,
-        updated_at REAL NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS upload_checkpoint (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL,
-        updated_at REAL NOT NULL
-      );
-    `);
-  }
-
-  getIdentity() {
-    const rows = this.db.prepare('SELECT key, value FROM identity_config').all();
-    return Object.fromEntries(rows.map((row) => [row.key, row.value]));
-  }
-
-  setIdentity(values) {
-    const ts = nowTs();
-    const upsert = this.db.prepare(`
-      INSERT INTO identity_config(key, value, updated_at)
-      VALUES (?, ?, ?)
-      ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
-    `);
-    const del = this.db.prepare('DELETE FROM identity_config WHERE key = ?');
-    this.db.exec('BEGIN');
-    try {
-      for (const [key, value] of Object.entries(values)) {
-        if (value == null) del.run(key);
-        else upsert.run(key, value, ts);
-      }
-      this.db.exec('COMMIT');
-    } catch (error) {
-      this.db.exec('ROLLBACK');
-      throw error;
-    }
-  }
-
-  getCheckpoint(key) {
-    const row = this.db.prepare('SELECT value FROM upload_checkpoint WHERE key = ?').get(key);
-    return row?.value ?? null;
-  }
-
-  setCheckpoint(key, value) {
-    this.db.prepare(`
-      INSERT INTO upload_checkpoint(key, value, updated_at)
-      VALUES (?, ?, ?)
-      ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
-    `).run(key, value, nowTs());
-  }
-
-  getEventStates(typelessUserId) {
-    return this.db.prepare(`
-      SELECT * FROM typeless_event_state
-      WHERE typeless_user_id = ?
-    `).all(typelessUserId);
-  }
-
-  upsertEventStates(typelessUserId, states) {
-    if (!states.length) return;
-    const ts = nowTs();
-    const stmt = this.db.prepare(`
-      INSERT INTO typeless_event_state(
-        typeless_user_id, record_uid, fingerprint, event_json, is_deleted, updated_at
-      )
-      VALUES (?, ?, ?, ?, ?, ?)
-      ON CONFLICT(typeless_user_id, record_uid) DO UPDATE SET
-        fingerprint = excluded.fingerprint,
-        event_json = excluded.event_json,
-        is_deleted = excluded.is_deleted,
-        updated_at = excluded.updated_at
-    `);
-    this.db.exec('BEGIN');
-    try {
-      for (const state of states) {
-        stmt.run(
-          typelessUserId,
-          state.recordUid,
-          state.fingerprint,
-          stableStringify(state.event),
-          state.isDeleted ? 1 : 0,
-          ts,
-        );
-      }
-      this.db.exec('COMMIT');
-    } catch (error) {
-      this.db.exec('ROLLBACK');
-      throw error;
-    }
-  }
-
-  getBufferingBatch() {
-    const stmt = this.db.prepare(`
-      SELECT * FROM pending_batches
-      WHERE status = 'buffering'
-      ORDER BY id ASC
-      LIMIT 1
-    `);
-    stmt.setReadBigInts(true);
-    return stmt.get() ?? null;
-  }
-
-  saveBufferingPayload(payload) {
-    const existing = this.getBufferingBatch();
-    const payloadJson = stableStringify(payload);
-    const payloadBytes = Buffer.byteLength(payloadJson, 'utf8');
-    const eventCount = payload.events?.length ?? 0;
-    const ts = nowTs();
-    if (existing) {
-      this.db.prepare(`
-        UPDATE pending_batches
-        SET payload_json = ?, payload_bytes = ?, event_count = ?, updated_at = ?
-        WHERE id = ?
-      `).run(payloadJson, payloadBytes, eventCount, ts, existing.id);
-    } else {
-      this.db.prepare(`
-        INSERT INTO pending_batches(
-          batch_key, status, payload_json, payload_bytes, event_count,
-          attempt_count, created_at, updated_at
-        ) VALUES (?, 'buffering', ?, ?, ?, 0, ?, ?)
-      `).run(randomBatchKey(), payloadJson, payloadBytes, eventCount, ts, ts);
-    }
-    return this.getBufferingBatch();
-  }
-
-  sealStaleBatches(force = false) {
-    const selectStmt = this.db.prepare(
-      "SELECT id, created_at FROM pending_batches WHERE status = 'buffering'",
-    );
-    selectStmt.setReadBigInts(true);
-    const rows = selectStmt.all();
-    let sealed = 0;
-    const ts = nowTs();
-    const updateStmt = this.db.prepare(`
-      UPDATE pending_batches
-      SET status = 'pending', updated_at = ?
-      WHERE id = ?
-    `);
-    for (const row of rows) {
-      if (force || ts - Number(row.created_at) >= MAX_BUFFER_AGE_SECONDS) {
-        updateStmt.run(ts, row.id);
-        sealed += 1;
-      }
-    }
-    return sealed;
-  }
-
-  sealBufferIfThresholdHit() {
-    const row = this.getBufferingBatch();
-    if (!row) return false;
-    const shouldSeal =
-      Number(row.event_count) >= MAX_EVENTS_PER_BATCH ||
-      Number(row.payload_bytes) >= MAX_BATCH_BYTES ||
-      nowTs() - Number(row.created_at) >= MAX_BUFFER_AGE_SECONDS;
-    if (shouldSeal) {
-      this.db.prepare(`
-        UPDATE pending_batches
-        SET status = 'pending', updated_at = ?
-        WHERE id = ?
-      `).run(nowTs(), row.id);
-    }
-    return shouldSeal;
-  }
-
-  iterPendingBatches() {
-    const stmt = this.db.prepare(`
-      SELECT * FROM pending_batches
-      WHERE status = 'pending'
-      ORDER BY created_at ASC, id ASC
-    `);
-    stmt.setReadBigInts(true);
-    return stmt.all();
-  }
-
-  markBatchUploaded(batchId) {
-    this.db.prepare('DELETE FROM pending_batches WHERE id = ?').run(batchId);
-  }
-
-  markBatchFailed(batchId, attemptCount, errorMessage) {
-    this.db.prepare(`
-      UPDATE pending_batches
-      SET attempt_count = ?, last_error = ?, updated_at = ?
-      WHERE id = ?
-    `).run(attemptCount, String(errorMessage).slice(0, 1000), nowTs(), batchId);
-  }
-
-  resetBackfillState() {
-    this.db.exec('BEGIN');
-    try {
-      this.db.prepare('DELETE FROM typeless_event_state').run();
-      this.db.prepare('DELETE FROM pending_batches').run();
-      this.db.prepare('DELETE FROM upload_checkpoint').run();
-      this.db.exec('COMMIT');
-    } catch (error) {
-      this.db.exec('ROLLBACK');
-      throw error;
-    }
-  }
-
-  getQueueStats() {
-    const stmt = this.db.prepare(`
-      SELECT
-        COALESCE(SUM(CASE WHEN status = 'buffering' THEN 1 ELSE 0 END), 0) AS buffering_batch_count,
-        COALESCE(SUM(CASE WHEN status = 'pending' AND attempt_count = 0 THEN 1 ELSE 0 END), 0) AS pending_batch_count,
-        COALESCE(SUM(CASE WHEN status = 'pending' AND attempt_count > 0 THEN 1 ELSE 0 END), 0) AS retrying_batch_count,
-        COALESCE(SUM(event_count), 0) AS queued_events,
-        MIN(created_at) AS oldest_created_at
-      FROM pending_batches
-    `);
-    stmt.setReadBigInts(true);
-    const row = stmt.get() ?? {};
-    const oldestCreatedAt =
-      row.oldest_created_at == null ? null : Number(row.oldest_created_at);
-    return {
-      bufferingBatchCount: Number(row.buffering_batch_count ?? 0),
-      pendingBatchCount: Number(row.pending_batch_count ?? 0),
-      retryingBatchCount: Number(row.retrying_batch_count ?? 0),
-      queuedEvents: Number(row.queued_events ?? 0),
-      oldestPendingAgeSeconds:
-        oldestCreatedAt == null
-          ? null
-          : Math.max(0, Math.floor(nowTs() - oldestCreatedAt)),
-    };
-  }
-}
-
-function randomBatchKey() {
-  return `${Date.now().toString(16)}${Math.random().toString(16).slice(2, 14)}`;
-}

package/dist/utils.js

@@ -1,52 +0,0 @@
-import fs from 'node:fs';
-import { Buffer } from 'node:buffer';
-import { createHash } from 'node:crypto';
-
-export function nowTs() {
-  return Date.now() / 1000;
-}
-
-export function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-export function stableStringify(value) {
-  return JSON.stringify(sortForJson(value));
-}
-
-function sortForJson(value) {
-  if (Array.isArray(value)) return value.map(sortForJson);
-  if (value && typeof value === 'object') {
-    return Object.fromEntries(
-      Object.keys(value)
-        .sort()
-        .map((key) => [key, sortForJson(value[key])]),
-    );
-  }
-  return value;
-}
-
-export function sha1(value) {
-  return createHash('sha1').update(Buffer.from(String(value), 'utf8')).digest('hex');
-}
-
-export function isoToEpochMs(value) {
-  if (!value) return null;
-  const timestamp = Date.parse(String(value).replace('Z', '+00:00'));
-  return Number.isNaN(timestamp) ? null : timestamp;
-}
-
-export function readPersistentCollectorId(filePath) {
-  try {
-    const content = fs.readFileSync(filePath, 'utf8').trim();
-    return content || null;
-  } catch {
-    return null;
-  }
-}
-
-export function writePersistentCollectorId(filePath, id) {
-  const tmpPath = `${filePath}.${process.pid}.tmp`;
-  fs.writeFileSync(tmpPath, id, 'utf8');
-  fs.renameSync(tmpPath, filePath);
-}