sentinelayer-cli 0.30.12 → 0.30.14

package/src/session/listener.js

@@ -38,6 +38,10 @@ function normalizePositiveInteger(value, fallbackValue) {
   return Math.floor(normalized);
 }
 
+function isListenerStopDirective(event = {}) {
+  return normalizeString(event?.event) === "listener_stop";
+}
+
 function isPlainObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -255,6 +259,8 @@ export async function listenSessionEvents({
   _readCursor = readSyncCursor,
   _writeCursor = writeSyncCursor,
   _sleep = defaultSleep,
+  _setInterval = setInterval,
+  _clearInterval = clearInterval,
   _nowMs = Date.now,
 } = {}) {
   const normalizedSessionId = normalizeString(sessionId);
@@ -394,6 +400,7 @@ export async function listenSessionEvents({
     const visibleEvents = [];
     let preStartEventCount = 0;
     for (const event of events) {
+      if (!isPlainObject(event)) continue;
       const timestampMs = eventTimestampMs(event);
       if (!timestampMs || timestampMs < startedAtMs) {
         preStartEventCount += 1;
@@ -402,6 +409,7 @@ export async function listenSessionEvents({
       if (isRecentActivity(activityMs, observedAtMs, activeWindowMs)) {
         lastHumanActivityMs = Math.max(lastHumanActivityMs, activityMs);
       }
+      if (timestampMs && timestampMs < startedAtMs && isListenerStopDirective(event)) continue;
       if (isSessionListenerLifecycleEvent(event)) continue;
       if (!eventMatchesAgent(event, normalizedAgentId)) continue;
       visibleEvents.push(event);
@@ -441,9 +449,14 @@ export async function listenSessionEvents({
       if (emittedKeys.has(key)) continue;
       matched += 1;
       if (!shouldEmitBatch && eventTimestampMs(event) < startedAtMs) continue;
-      await onEvent(event);
       emittedKeys.add(key);
-      emitted += 1;
+      try {
+        await onEvent(event);
+        emitted += 1;
+      } catch (error) {
+        emittedKeys.delete(key);
+        throw error;
+      }
     }
 
     if (nextCursor && nextCursor !== cursor) {
@@ -473,6 +486,32 @@ export async function listenSessionEvents({
     return humanActive;
   }
 
+  let streamHeartbeatTimer = null;
+  let streamHeartbeatInFlight = false;
+  const streamHeartbeatMs = Math.max(1_000, Math.min(idleSleepMs, 60_000));
+
+  function stopStreamHeartbeatTimer() {
+    if (!streamHeartbeatTimer) return;
+    _clearInterval(streamHeartbeatTimer);
+    streamHeartbeatTimer = null;
+  }
+
+  function startStreamHeartbeatTimer() {
+    stopStreamHeartbeatTimer();
+    streamHeartbeatTimer = _setInterval(async () => {
+      if (signal?.aborted || streamHeartbeatInFlight) return;
+      streamHeartbeatInFlight = true;
+      try {
+        await notifyHeartbeat({ nextPollMs: null });
+      } finally {
+        streamHeartbeatInFlight = false;
+      }
+    }, streamHeartbeatMs);
+    if (streamHeartbeatTimer && typeof streamHeartbeatTimer.unref === "function") {
+      streamHeartbeatTimer.unref();
+    }
+  }
+
   await notifyLifecycle(
     lifecycleSnapshot("started", {
       startedAt: new Date(startedAtMs).toISOString(),
@@ -484,6 +523,7 @@ export async function listenSessionEvents({
     if (normalizedTransport !== "poll") {
       streamAttempted = true;
       activeTransport = "stream";
+      startStreamHeartbeatTimer();
       const streamResult = await _stream(normalizedSessionId, {
         targetPath,
         since: cursor,
@@ -502,6 +542,8 @@ export async function listenSessionEvents({
         onHeartbeat: async () => {
           await notifyHeartbeat({ nextPollMs: null });
         },
+      }).finally(() => {
+        stopStreamHeartbeatTimer();
       });
       if (!streamResult?.ok) {
         streamFallbackReason = normalizeString(streamResult?.reason) || lastReason || "stream_failed";

package/src/session/rotating-log.js

@@ -0,0 +1,181 @@
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import util from "node:util";
+
+export const DEFAULT_ROTATING_LOG_MAX_BYTES = 5 * 1024 * 1024;
+export const DEFAULT_ROTATING_LOG_MAX_FILES = 5;
+
+function normalizeString(value) {
+  return String(value || "").trim();
+}
+
+function normalizePositiveInteger(value, fallbackValue) {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric) || numeric <= 0) {
+    return fallbackValue;
+  }
+  return Math.max(1, Math.floor(numeric));
+}
+
+export function normalizeRotatingLogOptions({
+  maxBytes = DEFAULT_ROTATING_LOG_MAX_BYTES,
+  maxFiles = DEFAULT_ROTATING_LOG_MAX_FILES,
+} = {}) {
+  return {
+    maxBytes: normalizePositiveInteger(maxBytes, DEFAULT_ROTATING_LOG_MAX_BYTES),
+    maxFiles: normalizePositiveInteger(maxFiles, DEFAULT_ROTATING_LOG_MAX_FILES),
+  };
+}
+
+export function rotateLogFileIfNeeded(logPath, options = {}) {
+  const normalizedLogPath = normalizeString(logPath);
+  if (!normalizedLogPath) {
+    return { rotated: false, reason: "missing_log_path" };
+  }
+
+  const { maxBytes, maxFiles } = normalizeRotatingLogOptions(options);
+  let currentSize = 0;
+  try {
+    currentSize = fs.statSync(normalizedLogPath).size;
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return { rotated: false, reason: "missing_file", maxBytes, maxFiles };
+    }
+    throw error;
+  }
+
+  if (currentSize < maxBytes) {
+    return { rotated: false, reason: "under_limit", size: currentSize, maxBytes, maxFiles };
+  }
+
+  fs.mkdirSync(path.dirname(normalizedLogPath), { recursive: true });
+  const backupCount = Math.max(0, maxFiles - 1);
+  if (backupCount === 0) {
+    fs.rmSync(normalizedLogPath, { force: true });
+    return { rotated: true, reason: "removed_active", size: currentSize, maxBytes, maxFiles };
+  }
+
+  fs.rmSync(`${normalizedLogPath}.${backupCount}`, { force: true });
+  for (let index = backupCount - 1; index >= 1; index -= 1) {
+    const from = `${normalizedLogPath}.${index}`;
+    const to = `${normalizedLogPath}.${index + 1}`;
+    if (fs.existsSync(from)) {
+      fs.renameSync(from, to);
+    }
+  }
+  fs.renameSync(normalizedLogPath, `${normalizedLogPath}.1`);
+  return { rotated: true, reason: "rotated", size: currentSize, maxBytes, maxFiles };
+}
+
+export function appendRotatingLogLine(logPath, line = "", options = {}) {
+  const normalizedLogPath = normalizeString(logPath);
+  if (!normalizedLogPath) {
+    return { written: false, reason: "missing_log_path" };
+  }
+  fs.mkdirSync(path.dirname(normalizedLogPath), { recursive: true });
+  const rotation = rotateLogFileIfNeeded(normalizedLogPath, options);
+  fs.appendFileSync(normalizedLogPath, `${redactLogSecrets(line)}\n`, "utf-8");
+  return { written: true, rotation };
+}
+
+function normalizeLogChunk(chunk, encoding = "utf8") {
+  if (Buffer.isBuffer(chunk)) {
+    return chunk.toString(typeof encoding === "string" ? encoding : "utf8");
+  }
+  return String(chunk ?? "");
+}
+
+export function formatConsoleLogLine(parts = []) {
+  return parts.map((part) => (typeof part === "string" ? part : util.inspect(part))).join(" ");
+}
+
+export function redactLogSecrets(value = "") {
+  return String(value ?? "")
+    .replace(/\bbearer\s+[a-z0-9._~+/=-]+\b/gi, "bearer [REDACTED]")
+    .replace(
+      /\b([a-z0-9_.-]*(?:token|secret|password|api[_-]?key|access[_-]?token|refresh[_-]?token|id[_-]?token)[a-z0-9_.-]*)\b\s*[:=]\s*["']?[^"'\s,;]+["']?/gi,
+      "$1=[REDACTED]",
+    )
+    .replace(/\beyJ[a-z0-9_-]{8,}\.[a-z0-9_-]{10,}\.[a-z0-9_-]{10,}\b/gi, "[REDACTED_JWT]");
+}
+
+export function installRotatingConsoleLog({
+  logPath,
+  maxBytes = DEFAULT_ROTATING_LOG_MAX_BYTES,
+  maxFiles = DEFAULT_ROTATING_LOG_MAX_FILES,
+  tee = true,
+  now = () => new Date(),
+  onError = null,
+  captureConsoleError = true,
+  captureStderr = true,
+} = {}) {
+  const normalizedLogPath = normalizeString(logPath);
+  if (!normalizedLogPath) {
+    return () => {};
+  }
+
+  const options = normalizeRotatingLogOptions({ maxBytes, maxFiles });
+  const originalLog = console.log;
+  const originalError = console.error;
+  const originalStderrWrite = process.stderr.write;
+  let warned = false;
+  const writeLogLine = (line) => {
+    try {
+      appendRotatingLogLine(
+        normalizedLogPath,
+        `${now().toISOString()} ${line}`,
+        options,
+      );
+    } catch (error) {
+      if (!warned) {
+        warned = true;
+        if (typeof onError === "function") {
+          onError(error);
+        }
+      }
+    }
+  };
+
+  console.log = (...parts) => {
+    if (tee) {
+      originalLog(...parts);
+    }
+    writeLogLine(formatConsoleLogLine(parts));
+  };
+
+  if (captureStderr) {
+    process.stderr.write = function rotatingStderrWrite(chunk, encoding, callback) {
+      const text = normalizeLogChunk(chunk, encoding).replace(/\s+$/u, "");
+      if (text) {
+        writeLogLine(`[stderr] ${text}`);
+      }
+      if (!tee) {
+        if (typeof encoding === "function") {
+          encoding();
+        } else if (typeof callback === "function") {
+          callback();
+        }
+        return true;
+      }
+      return originalStderrWrite.apply(process.stderr, arguments);
+    };
+  }
+
+  if (captureConsoleError) {
+    console.error = (...parts) => {
+      if (tee) {
+        originalError(...parts);
+      }
+      if (!captureStderr || !tee) {
+        writeLogLine(`[stderr] ${formatConsoleLogLine(parts)}`);
+      }
+    };
+  }
+
+  return () => {
+    console.log = originalLog;
+    console.error = originalError;
+    process.stderr.write = originalStderrWrite;
+  };
+}

package/src/session/sync.js

@@ -461,7 +461,13 @@ function abortRequestController(controller, reason) {
 function cancelResponseBody(response) {
   try {
     if (response?.body && typeof response.body.cancel === "function") {
-      void response.body.cancel();
+      if (response.body.locked) return;
+      const cancellation = response.body.cancel();
+      if (cancellation && typeof cancellation.catch === "function") {
+        void cancellation.catch(() => {
+          // Best-effort socket/body cleanup only.
+        });
+      }
     }
   } catch {
     // Best-effort socket/body cleanup only.