tempest-express-sdk 0.7.0 → 0.9.0

package/dist/index.cjs

@@ -5,7 +5,9 @@ var zodToOpenapi = require('@asteasolutions/zod-to-openapi');
 var zod = require('zod');
 var tempestDbJs = require('tempest-db-js');
 var crypto = require('crypto');
+var child_process = require('child_process');
 var os = require('os');
+var util = require('util');
 var promises = require('fs/promises');
 var path = require('path');
 var express2 = require('express');
@@ -7011,6 +7013,7 @@ var HTTPClient = class {
     return this.request("DELETE", url, init);
   }
 };
+var execFileAsync = util.promisify(child_process.execFile);
 function readCpu() {
   const cores = os.cpus().length;
   const load1 = os.loadavg()[0] ?? 0;
@@ -7039,7 +7042,27 @@ function readSystem() {
     uptimeSeconds: process.uptime()
   };
 }
-function toPrometheus(snapshot = readSystem()) {
+async function readGpus() {
+  try {
+    const { stdout } = await execFileAsync("nvidia-smi", [
+      "--query-gpu=index,utilization.gpu,memory.used,memory.total,temperature.gpu",
+      "--format=csv,noheader,nounits"
+    ]);
+    return stdout.trim().split("\n").filter((line) => line.trim().length > 0).map((line) => {
+      const [index, util, used, total, temp] = line.split(",").map((v) => Number(v.trim()));
+      return {
+        index: index ?? 0,
+        utilizationPercent: util ?? 0,
+        memoryUsedMb: used ?? 0,
+        memoryTotalMb: total ?? 0,
+        temperatureC: temp ?? 0
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+function toPrometheus(snapshot = readSystem(), gpus = []) {
   const lines = [
     "# HELP process_cpu_load_percent 1-minute load average as percent of cores",
     "# TYPE process_cpu_load_percent gauge",
@@ -7054,6 +7077,29 @@ function toPrometheus(snapshot = readSystem()) {
     "# TYPE process_uptime_seconds counter",
     `process_uptime_seconds ${snapshot.uptimeSeconds}`
   ];
+  if (gpus.length > 0) {
+    lines.push(
+      "# HELP gpu_utilization_percent GPU utilization percent",
+      "# TYPE gpu_utilization_percent gauge"
+    );
+    for (const gpu of gpus) {
+      lines.push(`gpu_utilization_percent{gpu="${gpu.index}"} ${gpu.utilizationPercent}`);
+    }
+    lines.push(
+      "# HELP gpu_memory_used_mb GPU memory used in MiB",
+      "# TYPE gpu_memory_used_mb gauge"
+    );
+    for (const gpu of gpus) {
+      lines.push(`gpu_memory_used_mb{gpu="${gpu.index}"} ${gpu.memoryUsedMb}`);
+    }
+    lines.push(
+      "# HELP gpu_temperature_celsius GPU core temperature",
+      "# TYPE gpu_temperature_celsius gauge"
+    );
+    for (const gpu of gpus) {
+      lines.push(`gpu_temperature_celsius{gpu="${gpu.index}"} ${gpu.temperatureC}`);
+    }
+  }
   return `${lines.join("\n")}
 `;
 }
@@ -7061,6 +7107,7 @@ var MetricsUtils = {
   cpu: readCpu,
   memory: readMemory,
   system: readSystem,
+  gpus: readGpus,
   toPrometheus
 };
 
@@ -7329,6 +7376,76 @@ function makeSessionMiddleware(service, options = {}) {
   };
 }
 
+// src/sessions/redisStore.ts
+var RedisSessionStore = class {
+  /**
+   * @param client - A connected node-redis v4 (or compatible) client.
+   * @param prefix - Key prefix. Default `sess:`.
+   */
+  constructor(client, prefix = "sess:") {
+    this.client = client;
+    this.prefix = prefix;
+  }
+  client;
+  prefix;
+  key(idHash) {
+    return `${this.prefix}${idHash}`;
+  }
+  userKey(userId) {
+    return `${this.prefix}user:${userId}`;
+  }
+  async get(idHash) {
+    const raw = await this.client.get(this.key(idHash));
+    if (raw === null) return null;
+    const session = JSON.parse(raw);
+    if (session.expiresAt <= Date.now()) {
+      await this.delete(idHash);
+      return null;
+    }
+    return session;
+  }
+  async set(session) {
+    const ttlSeconds = Math.max(1, Math.ceil((session.expiresAt - Date.now()) / 1e3));
+    await this.client.set(this.key(session.idHash), JSON.stringify(session), {
+      EX: ttlSeconds
+    });
+    await this.client.sAdd(this.userKey(session.userId), session.idHash);
+  }
+  async delete(idHash) {
+    const raw = await this.client.get(this.key(idHash));
+    await this.client.del(this.key(idHash));
+    if (raw) {
+      const session = JSON.parse(raw);
+      await this.client.sRem(this.userKey(session.userId), idHash);
+    }
+  }
+  async deleteByUser(userId) {
+    const ids = await this.client.sMembers(this.userKey(userId));
+    let count = 0;
+    for (const idHash of ids) {
+      await this.client.del(this.key(idHash));
+      await this.client.sRem(this.userKey(userId), idHash);
+      count += 1;
+    }
+    return count;
+  }
+  async listByUser(userId) {
+    const ids = await this.client.sMembers(this.userKey(userId));
+    const sessions = [];
+    const now = Date.now();
+    for (const idHash of ids) {
+      const raw = await this.client.get(this.key(idHash));
+      if (raw === null) {
+        await this.client.sRem(this.userKey(userId), idHash);
+        continue;
+      }
+      const session = JSON.parse(raw);
+      if (session.expiresAt > now) sessions.push(session);
+    }
+    return sessions.sort((a, b) => a.createdAt - b.createdAt);
+  }
+};
+
 // src/sse/eventStream.ts
 var ServerSentEvent = class {
   constructor(init) {
@@ -7501,6 +7618,92 @@ var SSEBroker = class {
   }
 };
 
+// src/sse/redisBroker.ts
+var RedisSSEBroker = class {
+  /**
+   * @param publisher - The main Redis client (used to `publish`).
+   * @param subscriber - A dedicated subscriber connection (`client.duplicate()`).
+   * @param options - Channel prefix + per-stream options.
+   */
+  constructor(publisher, subscriber, options = {}) {
+    this.publisher = publisher;
+    this.subscriber = subscriber;
+    this.prefix = options.prefix ?? "sse:";
+    const { prefix: _p, ...streamOptions } = options;
+    this.streamOptions = streamOptions;
+  }
+  publisher;
+  subscriber;
+  local = /* @__PURE__ */ new Map();
+  prefix;
+  streamOptions;
+  channelKey(channel) {
+    return `${this.prefix}${channel}`;
+  }
+  /** Emit a decoded payload to every local stream on a channel. */
+  emitLocal(channel, data, event) {
+    const set = this.local.get(channel);
+    if (!set) return;
+    for (const stream of set) stream.publish(data, event);
+  }
+  /**
+   * Register a subscriber stream, subscribing to the Redis channel on first use.
+   *
+   * @param channel - The channel name.
+   * @returns A fresh {@link EventStream} to serve to the client.
+   */
+  async register(channel) {
+    const stream = new EventStream(this.streamOptions);
+    let set = this.local.get(channel);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.local.set(channel, set);
+      await this.subscriber.subscribe(this.channelKey(channel), (raw) => {
+        try {
+          const { data, event } = JSON.parse(raw);
+          this.emitLocal(channel, data, event);
+        } catch {
+        }
+      });
+    }
+    set.add(stream);
+    return stream;
+  }
+  /**
+   * Remove a subscriber stream; unsubscribe from Redis when the last leaves.
+   *
+   * @param channel - The channel name.
+   * @param stream - The stream to remove.
+   */
+  async unregister(channel, stream) {
+    const set = this.local.get(channel);
+    if (!set) return;
+    set.delete(stream);
+    stream.close();
+    if (set.size === 0) {
+      this.local.delete(channel);
+      await this.subscriber.unsubscribe(this.channelKey(channel));
+    }
+  }
+  /** Local subscriber count on `channel` (this replica only). */
+  localSubscribers(channel) {
+    return this.local.get(channel)?.size ?? 0;
+  }
+  /**
+   * Publish to every subscriber across all replicas.
+   *
+   * @param channel - The channel name.
+   * @param data - The payload (JSON-encoded).
+   * @param event - Optional event name.
+   */
+  async publish(channel, data, event) {
+    await this.publisher.publish(
+      this.channelKey(channel),
+      JSON.stringify({ data, ...event ? { event } : {} })
+    );
+  }
+};
+
 // src/websockets/schemas.ts
 var wsEnvelopeSchema = zod.z.object({
   type: zod.z.string().openapi({ description: "Message type discriminator." }),
@@ -9161,6 +9364,16 @@ function makeHealthRouter(options = {}) {
   });
   return router;
 }
+function makeMetricsRouter(options = {}) {
+  const path = options.path ?? "/metrics";
+  const router = express2.Router();
+  if (options.guard) router.use(path, options.guard);
+  router.get(path, async (_req, res) => {
+    const gpus = options.includeGpu ? await MetricsUtils.gpus() : [];
+    res.type("text/plain").send(MetricsUtils.toPrometheus(MetricsUtils.system(), gpus));
+  });
+  return router;
+}
 var logger3 = new JSONLogger("tempest_express_sdk.api.server");
 function corsMiddleware(origins) {
   const allowAll = origins === "*";
@@ -9227,7 +9440,7 @@ function runServer(app, options = {}) {
 }
 
 // src/version.ts
-var VERSION = "0.7.0";
+var VERSION = "0.9.0";
 
 Object.defineProperty(exports, "OpenAPIRegistry", {
   enumerable: true,
@@ -9422,6 +9635,8 @@ exports.PasswordUtils = PasswordUtils;
 exports.REQUEST_ID_HEADER = REQUEST_ID_HEADER;
 exports.RabbitBroker = RabbitBroker;
 exports.RedisCacheManager = RedisCacheManager;
+exports.RedisSSEBroker = RedisSSEBroker;
+exports.RedisSessionStore = RedisSessionStore;
 exports.Region = Region;
 exports.RetryPolicy = RetryPolicy;
 exports.SSEBroker = SSEBroker;
@@ -9496,6 +9711,7 @@ exports.makeAuthRouter = makeAuthRouter;
 exports.makeFlagGuard = makeFlagGuard;
 exports.makeHealthRouter = makeHealthRouter;
 exports.makeJwtAuthMiddleware = makeJwtAuthMiddleware;
+exports.makeMetricsRouter = makeMetricsRouter;
 exports.makeSessionMiddleware = makeSessionMiddleware;
 exports.makeTwilioWebhookRouter = makeTwilioWebhookRouter;
 exports.makeUnhandledExceptionHandler = makeUnhandledExceptionHandler;