@walkhi/code-relax 0.1.0-beta.8 → 0.1.0-beta.81

package/dist/src/self-relay/usage-daily.mjs

@@ -0,0 +1,55 @@
+const dayMs = 86400000;
+const chinaOffsetMs = 8 * 3600000;
+
+export function usageDaySlices(start, end) {
+  const slices = [];
+  for (let cursor = start; cursor < end;) {
+    const date = new Date(cursor + chinaOffsetMs).toISOString().slice(0, 10);
+    const nextDay = Date.parse(`${date}T00:00:00Z`) + dayMs - chinaOffsetMs;
+    const until = Math.min(end, nextDay);
+    slices.push({ date, start: cursor, end: until });
+    cursor = until;
+  }
+  return slices;
+}
+
+const readIntervals = value => Array.isArray(value) ? value : JSON.parse(value || '[]');
+
+export function mergeUsageIntervals(existing, start, end) {
+  const sorted = [...existing, [start, end]].sort((a, b) => a[0] - b[0]);
+  const merged = [];
+  for (const range of sorted) {
+    const last = merged.at(-1);
+    if (last && range[0] <= last[1]) last[1] = Math.max(last[1], range[1]);
+    else merged.push([...range]);
+  }
+  return { intervals: merged, seconds: merged.reduce((sum, [from, until]) => sum + until - from, 0) / 1000 };
+}
+
+export async function recordDailyUsage(db, userId, computerId, free, start, end, now) {
+  for (const slice of usageDaySlices(start, end)) {
+    await db.execute(`INSERT IGNORE INTO relay_usage_user_days
+      (user_id,usage_date,intervals,updated_at) VALUES (?,?,'[]',?)`, [userId, slice.date, now]);
+    const [userRows] = await db.execute(`SELECT intervals FROM relay_usage_user_days
+      WHERE user_id=? AND usage_date=? FOR UPDATE`, [userId, slice.date]);
+    const user = mergeUsageIntervals(readIntervals(userRows[0].intervals), slice.start, slice.end);
+    await db.execute(`UPDATE relay_usage_user_days SET intervals=?,task_seconds=?,updated_at=?
+      WHERE user_id=? AND usage_date=?`,
+      [JSON.stringify(user.intervals), user.seconds, now, userId, slice.date]);
+
+    await db.execute(`INSERT IGNORE INTO relay_usage_computer_days
+      (computer_id,usage_date,intervals,free_intervals,updated_at) VALUES (?,?,'[]','[]',?)`,
+      [computerId, slice.date, now]);
+    const [computerRows] = await db.execute(`SELECT intervals,free_intervals FROM relay_usage_computer_days
+      WHERE computer_id=? AND usage_date=? FOR UPDATE`, [computerId, slice.date]);
+    const computer = mergeUsageIntervals(readIntervals(computerRows[0].intervals), slice.start, slice.end);
+    const freeIntervals = readIntervals(computerRows[0].free_intervals);
+    const freeComputer = free ? mergeUsageIntervals(freeIntervals, slice.start, slice.end) : null;
+    await db.execute(`UPDATE relay_usage_computer_days SET intervals=?,task_seconds=?,
+      free_intervals=?,free_task_seconds=COALESCE(?,free_task_seconds),updated_at=?
+      WHERE computer_id=? AND usage_date=?`,
+      [JSON.stringify(computer.intervals), computer.seconds,
+        JSON.stringify(freeComputer?.intervals || freeIntervals), freeComputer?.seconds ?? null,
+        now, computerId, slice.date]);
+  }
+}

package/dist/src/self-relay/usage-meter.mjs

@@ -0,0 +1,141 @@
+import { randomUUID } from 'node:crypto';
+import { recordDailyUsage } from './usage-daily.mjs';
+
+const epoch = value => new Date(`${value.replace(' ', 'T')}Z`).getTime();
+
+// Count confirmed intervals only; a lost connection never creates estimated time.
+export function usageMeter(pool) {
+  async function action(connection, computerId, clientId, kind, key) {
+    if (!connection.userId || !['message', 'turn'].includes(kind) || typeof key !== 'string' || !key || key.length > 128) return;
+    const column = kind === 'message' ? 'message_count' : 'turn_count';
+    const db = await pool.getConnection();
+    try {
+      await db.beginTransaction();
+      const [users] = await db.execute("SELECT id FROM users WHERE id=? AND status='active' FOR UPDATE", [connection.userId]);
+      if (!users.length) { await db.commit(); return false; }
+      const [result] = await db.execute(`INSERT IGNORE INTO relay_usage_actions
+        (computer_id,kind,action_key,user_id,client_id,occurred_at)
+        VALUES (?,?,?,?,?,UTC_TIMESTAMP(3))`,
+        [computerId, kind, key, connection.userId, clientId]);
+      if (result.affectedRows === 1) {
+        await db.execute(`INSERT INTO relay_usage_totals (user_id,${column},updated_at)
+          VALUES (?,1,UTC_TIMESTAMP(3)) ON DUPLICATE KEY UPDATE ${column}=${column}+1,
+          updated_at=VALUES(updated_at)`, [connection.userId]);
+        await db.execute(`INSERT INTO relay_usage_computer_totals (computer_id,${column},updated_at)
+          VALUES (?,1,UTC_TIMESTAMP(3)) ON DUPLICATE KEY UPDATE ${column}=${column}+1,
+          updated_at=VALUES(updated_at)`, [computerId]);
+      }
+      await db.commit();
+      return result.affectedRows === 1;
+    } catch (error) { await db.rollback(); throw error; }
+    finally { db.release(); }
+  }
+  async function turnOrigin(computerId, key) {
+    const [rows] = await pool.execute(`SELECT a.user_id,a.client_id FROM relay_usage_actions a JOIN users u ON u.id=a.user_id
+      WHERE a.computer_id=? AND a.kind='turn' AND a.action_key=? AND u.status='active'`, [computerId, key]);
+    return rows[0] ? { userId: rows[0].user_id, clientId: rows[0].client_id } : null;
+  }
+  async function pulse(connection, active, computerId, clientId, externalKey = null) {
+    if (!connection.userId) return;
+    if (!active && !connection.usageSessionId) return;
+    if (active && !connection.usageSessionId) {
+      const id = randomUUID();
+      const [inserted] = await pool.execute(`INSERT INTO relay_usage_sessions
+        (id,kind,external_key,user_id,computer_id,client_id,started_at,confirmed_until,charged_seconds)
+        SELECT ?,'task',?,?,?,?,UTC_TIMESTAMP(3),UTC_TIMESTAMP(3),0 FROM users WHERE id=? AND status='active'`, [id, externalKey, connection.userId, computerId, clientId, connection.userId]);
+      if (!inserted.affectedRows) return;
+      connection.usageSessionId = id;
+      return;
+    }
+    const id = connection.usageSessionId;
+    const db = await pool.getConnection();
+    try {
+      await db.beginTransaction();
+      const [users] = await db.execute("SELECT id FROM users WHERE id=? AND status='active' FOR UPDATE", [connection.userId]);
+      if (!users.length) { await db.commit(); connection.usageSessionId = undefined; return; }
+      const [rows] = await db.execute('SELECT user_id,computer_id,confirmed_until,ended_at FROM relay_usage_sessions WHERE id=? FOR UPDATE', [id]);
+      const row = rows[0];
+      if (!row || row.ended_at) throw new Error('Invalid relay usage session');
+      const [clock] = await db.query('SELECT UTC_TIMESTAMP(3) AS now');
+      const now = clock[0].now;
+      const nowMs = epoch(now);
+      const chargeStart = Math.max(epoch(row.confirmed_until), nowMs - 20000);
+      const seconds = Math.max(0, nowMs - chargeStart) / 1000;
+      const [plans] = await db.execute('SELECT tier,valid_until FROM relay_usage_entitlements WHERE user_id=?', [row.user_id]);
+      const subscribed = plans[0]?.tier === 'subscriber' && plans[0].valid_until && epoch(plans[0].valid_until) > epoch(now);
+      const freeSeconds = subscribed ? 0 : seconds;
+      await db.execute(`UPDATE relay_usage_sessions SET confirmed_until=?,ended_at=?,charged_seconds=charged_seconds+?,
+        free_charged_seconds=free_charged_seconds+? WHERE id=?`, [now, active ? null : now, seconds, freeSeconds, id]);
+      if (seconds > 0) {
+        await recordDailyUsage(db, row.user_id, row.computer_id, !subscribed,
+          chargeStart, nowMs, now);
+        await db.execute(`INSERT INTO relay_usage_totals (user_id,task_seconds,updated_at)
+          VALUES (?,?,?) ON DUPLICATE KEY UPDATE task_seconds=task_seconds+VALUES(task_seconds),
+          updated_at=VALUES(updated_at)`, [row.user_id, seconds, now]);
+        await db.execute(`INSERT INTO relay_usage_computer_totals (computer_id,task_seconds,free_task_seconds,updated_at)
+          VALUES (?,?,?,?) ON DUPLICATE KEY UPDATE task_seconds=task_seconds+VALUES(task_seconds),
+          free_task_seconds=free_task_seconds+VALUES(free_task_seconds),updated_at=VALUES(updated_at)`,
+          [row.computer_id, seconds, freeSeconds, now]);
+      }
+      await db.commit();
+      if (!active) connection.usageSessionId = undefined;
+    } catch (error) { await db.rollback(); throw error; }
+    finally { db.release(); }
+  }
+
+  async function lost(connection) {
+    const id = connection.usageSessionId;
+    connection.usageSessionId = undefined;
+    if (!id) return;
+    await pool.execute(`UPDATE relay_usage_sessions SET ended_at=confirmed_until
+      WHERE id=? AND ended_at IS NULL`, [id]);
+  }
+
+  return { action, turnOrigin, pulse, lost };
+}
+
+export async function usageReport(pool, page, view = 'user') {
+  if (view === 'computer') {
+    const offset = (page - 1) * 30;
+    const [counts] = await pool.query(`SELECT COUNT(*) AS total FROM relay_usage_computer_days
+      WHERE usage_date=DATE(UTC_TIMESTAMP() + INTERVAL 8 HOUR) AND task_seconds>0`);
+    const [rows] = await pool.execute(`SELECT c.id,
+      d.task_seconds AS today_task_seconds,
+      d.free_task_seconds AS today_free_task_seconds,
+      COALESCE(a.message_count,0) AS message_count,
+      COALESCE(a.turn_count,0) AS turn_count,
+      COALESCE(GREATEST(s.last_used_at,a.last_used_at),s.last_used_at,a.last_used_at) AS last_used_at
+      FROM relay_usage_computer_days d JOIN computers c ON c.id=d.computer_id
+      LEFT JOIN (SELECT computer_id,SUM(kind='message') AS message_count,
+        SUM(kind='turn') AS turn_count,MAX(occurred_at) AS last_used_at FROM relay_usage_actions
+        WHERE occurred_at >= DATE(UTC_TIMESTAMP() + INTERVAL 8 HOUR) - INTERVAL 8 HOUR
+          AND occurred_at < DATE(UTC_TIMESTAMP() + INTERVAL 8 HOUR) + INTERVAL 16 HOUR
+        GROUP BY computer_id) a ON a.computer_id=c.id
+      LEFT JOIN (SELECT computer_id,MAX(confirmed_until) AS last_used_at
+        FROM relay_usage_sessions GROUP BY computer_id) s ON s.computer_id=c.id
+      WHERE d.usage_date=DATE(UTC_TIMESTAMP() + INTERVAL 8 HOUR) AND d.task_seconds>0
+      ORDER BY d.task_seconds DESC,c.id LIMIT ? OFFSET ?`, [30, offset]);
+    return { page, pageSize: 30, total: counts[0].total, rows };
+  }
+  const offset = (page - 1) * 30;
+  const [counts] = await pool.query(`SELECT COUNT(*) AS total FROM relay_usage_user_days d
+    JOIN user_login_identities i ON i.user_id=d.user_id AND i.kind='email'
+    WHERE d.usage_date=DATE(UTC_TIMESTAMP() + INTERVAL 8 HOUR) AND d.task_seconds>0`);
+  const [rows] = await pool.execute(`SELECT u.id,i.normalized_value AS email,
+    d.task_seconds AS today_task_seconds,
+    COALESCE(a.message_count,0) AS message_count,
+    COALESCE(a.turn_count,0) AS turn_count,
+    COALESCE(GREATEST(s.last_used_at,a.last_used_at),s.last_used_at,a.last_used_at) AS last_used_at
+    FROM relay_usage_user_days d JOIN users u ON u.id=d.user_id
+    JOIN user_login_identities i ON i.user_id=u.id AND i.kind='email'
+    LEFT JOIN (SELECT user_id,SUM(kind='message') AS message_count,
+      SUM(kind='turn') AS turn_count,MAX(occurred_at) AS last_used_at FROM relay_usage_actions
+      WHERE occurred_at >= DATE(UTC_TIMESTAMP() + INTERVAL 8 HOUR) - INTERVAL 8 HOUR
+        AND occurred_at < DATE(UTC_TIMESTAMP() + INTERVAL 8 HOUR) + INTERVAL 16 HOUR
+      GROUP BY user_id) a ON a.user_id=u.id
+    LEFT JOIN (SELECT user_id,MAX(confirmed_until) AS last_used_at
+      FROM relay_usage_sessions GROUP BY user_id) s ON s.user_id=u.id
+    WHERE d.usage_date=DATE(UTC_TIMESTAMP() + INTERVAL 8 HOUR) AND d.task_seconds>0
+    ORDER BY d.task_seconds DESC,u.id LIMIT ? OFFSET ?`, [30, offset]);
+  return { page, pageSize: 30, total: counts[0].total, rows };
+}