@walkhi/code-relax 0.1.0-beta.23 → 0.1.0-beta.25

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

@@ -1,136 +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 [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 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 };
-}
+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 };
+}

package/dist/src/server.mjs

@@ -299,8 +299,9 @@ async function handleRequest(request, response) {
       return;
     }
 
-    if (request.method === 'GET' && url.pathname === '/api/turn-events') {
-      response.startEvents();
+    if (request.method === 'GET' && url.pathname === '/api/turn-events') {
+      const execution = sharedServer;
+      response.startEvents();
       const listener = ({ method, params }) => {
         if (!['turn/started', 'turn/completed'].includes(method)) return;
         const threadId = params?.threadId, turnId = params?.turn?.id;
@@ -309,11 +310,11 @@ async function handleRequest(request, response) {
         }
       };
       const disconnected = () => response.end();
-      sharedServer.on('notification', listener);
-      sharedServer.on('disconnected', disconnected);
-      response.once('close', () => {
-        sharedServer.off('notification', listener);
-        sharedServer.off('disconnected', disconnected);
+      execution.on('notification', listener);
+      execution.on('disconnected', disconnected);
+      response.once('close', () => {
+        execution.off('notification', listener);
+        execution.off('disconnected', disconnected);
       });
       return;
     }
@@ -375,12 +376,13 @@ async function handleRequest(request, response) {
     }
 
     const timelineMatch = /^\/api\/threads\/([^/]+)\/timeline$/.exec(url.pathname);
-    if (request.method === 'GET' && timelineMatch) {
-      const threadId = decodeURIComponent(timelineMatch[1]);
-      const timeline = normalizeSharedTimeline(await sharedServer.timeline(threadId, sharedHistoryPageOptions()));
-      if (request.socketRequest) {
-        response.on('progress', () => sharedServer.keepSnapshotAlive(threadId, timeline.sync));
-        response.once('close', () => sharedServer.keepSnapshotAlive(threadId, timeline.sync));
+    if (request.method === 'GET' && timelineMatch) {
+      const threadId = decodeURIComponent(timelineMatch[1]);
+      const execution = sharedServer;
+      const timeline = normalizeSharedTimeline(await execution.timeline(threadId, sharedHistoryPageOptions()));
+      if (request.socketRequest) {
+        response.on('progress', () => execution.keepSnapshotAlive(threadId, timeline.sync));
+        response.once('close', () => execution.keepSnapshotAlive(threadId, timeline.sync));
       }
       sendJson(response, 200, timeline);
       return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@walkhi/code-relax",
-  "version": "0.1.0-beta.23",
+  "version": "0.1.0-beta.25",
   "license": "UNLICENSED",
   "type": "module",
   "scripts": {