@walkhi/code-relax 0.1.0-beta.2 → 0.1.0-beta.20

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

@@ -0,0 +1,125 @@
+import { randomUUID } from 'node:crypto';
+
+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 [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 user_id,client_id FROM relay_usage_actions
+      WHERE computer_id=? AND kind='turn' AND action_key=?`, [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();
+      await pool.execute(`INSERT INTO relay_usage_sessions
+        (id,kind,external_key,user_id,computer_id,client_id,started_at,confirmed_until,charged_seconds)
+        VALUES (?,'task',?,?,?,?,UTC_TIMESTAMP(3),UTC_TIMESTAMP(3),0)`, [id, externalKey, connection.userId, computerId, clientId]);
+      connection.usageSessionId = id;
+      return;
+    }
+    const id = connection.usageSessionId;
+    const db = await pool.getConnection();
+    try {
+      await db.beginTransaction();
+      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 elapsedMs = Math.max(0, epoch(now) - epoch(row.confirmed_until));
+      const seconds = Math.min(elapsedMs, 20000) / 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 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, userId = '') {
+  if (userId) {
+    const [users] = await pool.execute(`SELECT u.id,i.normalized_value AS email,
+      COALESCE(t.task_seconds,0) AS task_seconds,
+      COALESCE(t.message_count,0) AS message_count,COALESCE(t.turn_count,0) AS turn_count
+      FROM users u JOIN user_login_identities i ON i.user_id=u.id AND i.kind='email'
+      LEFT JOIN relay_usage_totals t ON t.user_id=u.id WHERE u.id=?`, [userId]);
+    if (!users.length) return null;
+    const [computers] = await pool.execute(`SELECT c.id AS computer_id,
+      COALESCE(s.task_seconds,0) AS 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 computers c
+      LEFT JOIN (SELECT computer_id,
+        SUM(charged_seconds) AS task_seconds,
+        MAX(started_at) AS last_used_at FROM relay_usage_sessions WHERE user_id=? GROUP BY computer_id) s ON s.computer_id=c.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 user_id=? GROUP BY computer_id) a ON a.computer_id=c.id
+      WHERE s.computer_id IS NOT NULL OR a.computer_id IS NOT NULL
+      ORDER BY last_used_at DESC`, [userId, userId]);
+    return { user: users[0], computers };
+  }
+  const offset = (page - 1) * 30;
+  const [counts] = await pool.query(`SELECT COUNT(*) AS total FROM user_login_identities WHERE kind='email'`);
+  const [rows] = await pool.execute(`SELECT u.id,i.normalized_value AS email,
+    COALESCE(t.task_seconds,0) AS task_seconds,
+    COALESCE(t.message_count,0) AS message_count,COALESCE(t.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 users u JOIN user_login_identities i ON i.user_id=u.id AND i.kind='email'
+    LEFT JOIN relay_usage_totals t ON t.user_id=u.id
+    LEFT JOIN (SELECT user_id,MAX(started_at) AS last_used_at FROM relay_usage_sessions GROUP BY user_id) s ON s.user_id=u.id
+    LEFT JOIN (SELECT user_id,MAX(occurred_at) AS last_used_at FROM relay_usage_actions GROUP BY user_id) a ON a.user_id=u.id
+    ORDER BY task_seconds DESC,last_used_at DESC,u.id LIMIT ? OFFSET ?`, [30, offset]);
+  return { page, pageSize: 30, total: counts[0].total, rows };
+}