@walkhi/code-relax 0.1.0-beta.3 → 0.1.0-beta.30

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 };
+}

package/dist/src/self-relay/windows-route-helper.mjs

@@ -1,75 +1,75 @@
-import net from 'node:net';
-
-const pipePath = String.raw`\\.\pipe\CodeRelaxRtcRouteHelper`;
-
-export function createWindowsRouteHelper({ enabled = false, token = '', iceServers = [], report = () => {} } = {}) {
-  const addresses = new Set();
-  const routeAddresses = new Set(iceServers.map(stunAddress).filter(publicIpv4));
-  let chain = Promise.resolve();
-  const enqueue = task => chain = chain.then(task, task);
-  if (!enabled || process.platform !== 'win32') return { prepare() { return Promise.resolve(); }, include() { return Promise.resolve(); } };
-  if (!/^[A-Za-z0-9_-]{32,128}$/.test(token)) throw new Error('Windows RTC 路由辅助凭据无效');
-  const add = values => enqueue(async () => {
-    for (const value of values) addresses.add(value);
-    if (!values.length) return;
-    const result = await request({ token, action: 'add', addresses: [...addresses], ttlSeconds: 120 });
-    if (!result.ok) throw new Error(result.error || 'Windows RTC 路由辅助不可用');
-    report('windows-route-helper', { count: addresses.size });
-  });
-  return {
-    prepare() { return add([...routeAddresses]); },
-    include(message) {
-      const discovered = candidateAddresses(message);
-      return add(discovered.filter(value => !addresses.has(value)));
-    }
-  };
-}
-
-function stunAddress(value) {
-  const match = /^stun:([^:]+):\d{1,5}$/i.exec(value || '');
-  return match?.[1] || '';
-}
-
-function candidateAddresses(message) {
-  const text = message?.kind === 'candidate' ? message.candidate : ['offer', 'answer'].includes(message?.kind) ? message.sdp : '';
-  const result = new Set();
-  for (const line of String(text || '').split(/\r?\n/)) {
-    const parts = line.trim().replace(/^a=/, '').split(/\s+/);
-    if (parts[0]?.startsWith('candidate:') && parts[6] === 'typ' && publicIpv4(parts[4])) result.add(parts[4]);
-  }
-  return [...result];
-}
-
-function publicIpv4(value) {
-  const parts = String(value).split('.').map(Number);
-  if (parts.length !== 4 || parts.some(part => !Number.isInteger(part) || part < 0 || part > 255)) return false;
-  const [a, b] = parts;
-  return a !== 0 && a !== 10 && a !== 127 && a < 224 && !(a === 169 && b === 254) && !(a === 172 && b >= 16 && b <= 31) &&
-    !(a === 192 && b === 168) && !(a === 100 && b >= 64 && b <= 127) && !(a === 198 && (b === 18 || b === 19));
-}
-
-function request(value) {
-  return new Promise((resolve, reject) => {
-    const socket = net.createConnection(pipePath);
-    let text = '';
-    let settled = false;
-    const rejectOnce = error => { if (!settled) { settled = true; reject(error); } };
-    const resolveOnce = result => { if (!settled) { settled = true; resolve(result); } };
-    socket.setTimeout(3000);
-    socket.setEncoding('utf8');
-    socket.once('connect', () => socket.write(`${JSON.stringify(value)}\n`));
-    socket.on('data', chunk => {
-      text += chunk;
-      const line = text.indexOf('\n');
-      if (line < 0) return;
-      try { resolveOnce(JSON.parse(text.slice(0, line))); socket.end(); }
-      catch { rejectOnce(new Error('Windows RTC 路由辅助响应无效')); socket.destroy(); }
-    });
-    socket.once('timeout', () => socket.destroy(new Error('Windows RTC 路由辅助超时')));
-    socket.once('error', rejectOnce);
-    socket.once('close', hadError => {
-      if (hadError || settled) return;
-      rejectOnce(new Error('Windows RTC 路由辅助响应无效'));
-    });
-  });
-}
+import net from 'node:net';
+
+const pipePath = String.raw`\\.\pipe\CodeRelaxRtcRouteHelper`;
+
+export function createWindowsRouteHelper({ enabled = false, token = '', iceServers = [], report = () => {} } = {}) {
+  const addresses = new Set();
+  const routeAddresses = new Set(iceServers.map(stunAddress).filter(publicIpv4));
+  let chain = Promise.resolve();
+  const enqueue = task => chain = chain.then(task, task);
+  if (!enabled || process.platform !== 'win32') return { prepare() { return Promise.resolve(); }, include() { return Promise.resolve(); } };
+  if (!/^[A-Za-z0-9_-]{32,128}$/.test(token)) throw new Error('Windows RTC 路由辅助凭据无效');
+  const add = values => enqueue(async () => {
+    for (const value of values) addresses.add(value);
+    if (!values.length) return;
+    const result = await request({ token, action: 'add', addresses: [...addresses], ttlSeconds: 120 });
+    if (!result.ok) throw new Error(result.error || 'Windows RTC 路由辅助不可用');
+    report('windows-route-helper', { count: addresses.size });
+  });
+  return {
+    prepare() { return add([...routeAddresses]); },
+    include(message) {
+      const discovered = candidateAddresses(message);
+      return add(discovered.filter(value => !addresses.has(value)));
+    }
+  };
+}
+
+function stunAddress(value) {
+  const match = /^stun:([^:]+):\d{1,5}$/i.exec(value || '');
+  return match?.[1] || '';
+}
+
+function candidateAddresses(message) {
+  const text = message?.kind === 'candidate' ? message.candidate : ['offer', 'answer'].includes(message?.kind) ? message.sdp : '';
+  const result = new Set();
+  for (const line of String(text || '').split(/\r?\n/)) {
+    const parts = line.trim().replace(/^a=/, '').split(/\s+/);
+    if (parts[0]?.startsWith('candidate:') && parts[6] === 'typ' && publicIpv4(parts[4])) result.add(parts[4]);
+  }
+  return [...result];
+}
+
+function publicIpv4(value) {
+  const parts = String(value).split('.').map(Number);
+  if (parts.length !== 4 || parts.some(part => !Number.isInteger(part) || part < 0 || part > 255)) return false;
+  const [a, b] = parts;
+  return a !== 0 && a !== 10 && a !== 127 && a < 224 && !(a === 169 && b === 254) && !(a === 172 && b >= 16 && b <= 31) &&
+    !(a === 192 && b === 168) && !(a === 100 && b >= 64 && b <= 127) && !(a === 198 && (b === 18 || b === 19));
+}
+
+function request(value) {
+  return new Promise((resolve, reject) => {
+    const socket = net.createConnection(pipePath);
+    let text = '';
+    let settled = false;
+    const rejectOnce = error => { if (!settled) { settled = true; reject(error); } };
+    const resolveOnce = result => { if (!settled) { settled = true; resolve(result); } };
+    socket.setTimeout(3000);
+    socket.setEncoding('utf8');
+    socket.once('connect', () => socket.write(`${JSON.stringify(value)}\n`));
+    socket.on('data', chunk => {
+      text += chunk;
+      const line = text.indexOf('\n');
+      if (line < 0) return;
+      try { resolveOnce(JSON.parse(text.slice(0, line))); socket.end(); }
+      catch { rejectOnce(new Error('Windows RTC 路由辅助响应无效')); socket.destroy(); }
+    });
+    socket.once('timeout', () => socket.destroy(new Error('Windows RTC 路由辅助超时')));
+    socket.once('error', rejectOnce);
+    socket.once('close', hadError => {
+      if (hadError || settled) return;
+      rejectOnce(new Error('Windows RTC 路由辅助响应无效'));
+    });
+  });
+}

package/dist/src/self-relay/wire.mjs

@@ -1,36 +1,36 @@
-import { randomBytes, createHash, timingSafeEqual } from 'node:crypto';
-import { WebSocket } from 'ws';
-
-export const secret = () => randomBytes(32).toString('base64url');
-export const digest = value => createHash('sha256').update(value).digest('hex');
-export const validSecret = value => typeof value === 'string' && /^[\w-]{43}$/.test(value);
-export function matches(value, hash) {
-  return validSecret(value) && typeof hash === 'string' && timingSafeEqual(Buffer.from(digest(value)), Buffer.from(hash));
-}
-export function send(socket, message) {
-  if (socket.readyState !== WebSocket.OPEN) return false;
-  if (socket.bufferedAmount > 64 * 1024 * 1024) { socket.close(1013, 'Receiver too slow'); return false; }
-  socket.send(JSON.stringify(message)); return true;
-}
-export function decode(bytes, binary) {
-  if (binary) throw new Error('Text frames required');
-  const value = JSON.parse(bytes.toString());
-  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('Object required');
-  return value;
-}
-export function loopbackUrl(value, pathname) {
-  const url = new URL(value);
-  if (url.protocol !== 'ws:' || url.hostname !== '127.0.0.1' || url.pathname !== pathname || url.search || url.hash || url.username || url.password) {
-    throw new Error('本地原型仅接受指定路径的 ws://127.0.0.1 地址');
-  }
-  return url.href;
-}
-
-export function relayAddress(value) {
-  const url = new URL(value);
-  if (url.protocol === 'ws:') return loopbackUrl(value, '/relay');
-  if (url.protocol !== 'wss:' || url.pathname !== '/relay' || url.search || url.hash || url.username || url.password) {
-    throw new Error('远程中继必须使用无查询凭据的 wss://主机/relay 地址');
-  }
-  return url.href;
-}
+import { randomBytes, createHash, timingSafeEqual } from 'node:crypto';
+import { WebSocket } from 'ws';
+
+export const secret = () => randomBytes(32).toString('base64url');
+export const digest = value => createHash('sha256').update(value).digest('hex');
+export const validSecret = value => typeof value === 'string' && /^[\w-]{43}$/.test(value);
+export function matches(value, hash) {
+  return validSecret(value) && typeof hash === 'string' && timingSafeEqual(Buffer.from(digest(value)), Buffer.from(hash));
+}
+export function send(socket, message) {
+  if (socket.readyState !== WebSocket.OPEN) return false;
+  if (socket.bufferedAmount > 64 * 1024 * 1024) { socket.close(1013, 'Receiver too slow'); return false; }
+  socket.send(JSON.stringify(message)); return true;
+}
+export function decode(bytes, binary) {
+  if (binary) throw new Error('Text frames required');
+  const value = JSON.parse(bytes.toString());
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('Object required');
+  return value;
+}
+export function loopbackUrl(value, pathname) {
+  const url = new URL(value);
+  if (url.protocol !== 'ws:' || url.hostname !== '127.0.0.1' || url.pathname !== pathname || url.search || url.hash || url.username || url.password) {
+    throw new Error('本地原型仅接受指定路径的 ws://127.0.0.1 地址');
+  }
+  return url.href;
+}
+
+export function relayAddress(value) {
+  const url = new URL(value);
+  if (url.protocol === 'ws:') return loopbackUrl(value, '/relay');
+  if (url.protocol !== 'wss:' || url.pathname !== '/relay' || url.search || url.hash || url.username || url.password) {
+    throw new Error('远程中继必须使用无查询凭据的 wss://主机/relay 地址');
+  }
+  return url.href;
+}