@slock-ai/daemon 0.46.1 → 0.46.2-staging.20260509074830

package/dist/{chunk-XW57NR6Y.js → chunk-FG5JGA67.js}

@@ -6830,6 +6830,7 @@ function acquireDaemonMachineLock(options) {
 import { appendFileSync, mkdirSync as mkdirSync6, readdirSync as readdirSync3, rmSync as rmSync3, statSync as statSync4, writeFileSync as writeFileSync9 } from "fs";
 import path13 from "path";
 var DEFAULT_MAX_FILE_BYTES = 5 * 1024 * 1024;
+var DEFAULT_MAX_FILE_AGE_MS = 5 * 60 * 1e3;
 var DEFAULT_MAX_FILES = 8;
 var DIAGNOSTIC_ID_ATTRS = /* @__PURE__ */ new Set([
   "serverId",
@@ -6846,14 +6847,25 @@ var DIAGNOSTIC_ID_ATTRS = /* @__PURE__ */ new Set([
 var LocalRotatingTraceSink = class {
   traceDir;
   maxFileBytes;
+  maxFileAgeMs;
   maxFiles;
+  nowMsProvider;
   currentFile = null;
+  currentFileOpenedAtMs = null;
   currentSize = 0;
   sequence = 0;
   constructor(options) {
     this.traceDir = path13.join(options.machineDir, "traces");
     this.maxFileBytes = Math.max(1024, Math.floor(options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES));
+    const baseAgeMs = Math.max(1e3, Math.floor(options.maxFileAgeMs ?? DEFAULT_MAX_FILE_AGE_MS));
+    const ageJitterMs = Math.max(0, Math.floor(options.maxFileAgeJitterMs ?? 0));
+    this.maxFileAgeMs = baseAgeMs + ageJitterMs;
     this.maxFiles = Math.max(1, Math.floor(options.maxFiles ?? DEFAULT_MAX_FILES));
+    this.nowMsProvider = options.nowMsProvider ?? Date.now;
+  }
+  /** Exposed for observability — the effective rotation age after jitter. */
+  getMaxFileAgeMs() {
+    return this.maxFileAgeMs;
   }
   record(span) {
     try {
@@ -6870,13 +6882,16 @@ var LocalRotatingTraceSink = class {
   }
   ensureFile(nextBytes) {
     mkdirSync6(this.traceDir, { recursive: true, mode: 448 });
-    if (!this.currentFile || this.currentSize + nextBytes > this.maxFileBytes) {
+    const nowMs = this.nowMsProvider();
+    const shouldRotateForAge = this.currentFileOpenedAtMs !== null && nowMs - this.currentFileOpenedAtMs >= this.maxFileAgeMs;
+    if (!this.currentFile || this.currentSize + nextBytes > this.maxFileBytes || shouldRotateForAge) {
       this.currentFile = path13.join(
         this.traceDir,
-        `daemon-trace-${safeTimestamp(Date.now())}-${process.pid}-${String(this.sequence++).padStart(4, "0")}.jsonl`
+        `daemon-trace-${safeTimestamp(nowMs)}-${process.pid}-${String(this.sequence++).padStart(4, "0")}.jsonl`
       );
       writeFileSync9(this.currentFile, "", { flag: "a", mode: 384 });
       this.currentSize = statSync4(this.currentFile).size;
+      this.currentFileOpenedAtMs = nowMs;
       this.pruneOldFiles();
     }
   }
@@ -6961,7 +6976,7 @@ function isDiagnosticIdAttr(key) {
 }
 
 // src/traceBundleUpload.ts
-import { createHash as createHash2, randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
 import { gzipSync } from "zlib";
 import { mkdir as mkdir2, readFile as readFile2, readdir as readdir3, stat as stat3, writeFile as writeFile2 } from "fs/promises";
 import path14 from "path";
@@ -7090,6 +7105,35 @@ async function uploadWithSignedCapability({
   return { capability, session, uploadResponse };
 }
 
+// src/traceJitter.ts
+import { createHash as createHash2 } from "crypto";
+var INITIAL_UPLOAD_DELAY_SPAN_MS = 3e4;
+var UPLOAD_INTERVAL_JITTER_SPAN_MS = 6e4;
+var MAX_FILE_AGE_JITTER_SPAN_MS = 6e4;
+function computeTraceJitter(lockId) {
+  const seed = createHash2("sha256").update(lockId).digest();
+  return {
+    initialUploadDelayMs: seed.readUInt32BE(0) % INITIAL_UPLOAD_DELAY_SPAN_MS,
+    uploadIntervalJitterMs: seed.readUInt32BE(4) % UPLOAD_INTERVAL_JITTER_SPAN_MS,
+    maxFileAgeJitterMs: seed.readUInt32BE(8) % MAX_FILE_AGE_JITTER_SPAN_MS
+  };
+}
+var NO_JITTER = {
+  initialUploadDelayMs: 0,
+  uploadIntervalJitterMs: 0,
+  maxFileAgeJitterMs: 0
+};
+function bucketDelayMs(delayMs) {
+  if (delayMs < 1e3) return "0-1s";
+  if (delayMs < 5e3) return "1-5s";
+  if (delayMs < 15e3) return "5-15s";
+  if (delayMs < 3e4) return "15-30s";
+  if (delayMs < 6e4) return "30-60s";
+  if (delayMs < 3e5) return "60s-5m";
+  if (delayMs < 6e5) return "5-10m";
+  return "10m+";
+}
+
 // src/traceBundleUpload.ts
 var TRACE_UPLOAD_SCOPE = "daemon-trace-bundle:create";
 var DEFAULT_UPLOAD_INTERVAL_MS = 5 * 60 * 1e3;
@@ -7097,30 +7141,66 @@ var DEFAULT_MIN_FILE_AGE_MS = 60 * 1e3;
 var DEFAULT_MAX_FILES_PER_RUN = 4;
 var DaemonTraceBundleUploader = class {
   options;
-  timer = null;
+  jitter;
+  timers;
+  initialDelayTimer = null;
+  intervalTimer = null;
+  stopped = false;
   constructor(options) {
     this.options = options;
+    this.jitter = options.jitter ?? (options.lockId ? computeTraceJitter(options.lockId) : NO_JITTER);
+    this.timers = options.timers ?? {
+      setTimeout: globalThis.setTimeout.bind(globalThis),
+      setInterval: globalThis.setInterval.bind(globalThis),
+      clearTimeout: globalThis.clearTimeout.bind(globalThis),
+      clearInterval: globalThis.clearInterval.bind(globalThis)
+    };
   }
   start() {
-    if (this.timer) return;
-    void this.uploadOnce();
-    this.timer = setInterval(() => {
-      void this.uploadOnce();
-    }, this.options.intervalMs ?? readPositiveIntegerEnv2("SLOCK_DAEMON_TRACE_UPLOAD_INTERVAL_MS", DEFAULT_UPLOAD_INTERVAL_MS));
+    if (this.stopped) return;
+    if (this.initialDelayTimer || this.intervalTimer) return;
+    const initialDelayMs = this.jitter.initialUploadDelayMs;
+    this.initialDelayTimer = this.timers.setTimeout(() => {
+      this.initialDelayTimer = null;
+      if (this.stopped) return;
+      void this.uploadOnce("initial");
+      this.scheduleNextTick();
+    }, initialDelayMs);
   }
   stop() {
-    if (!this.timer) return;
-    clearInterval(this.timer);
-    this.timer = null;
+    this.stopped = true;
+    if (this.initialDelayTimer) {
+      this.timers.clearTimeout(this.initialDelayTimer);
+      this.initialDelayTimer = null;
+    }
+    if (this.intervalTimer) {
+      this.timers.clearTimeout(this.intervalTimer);
+      this.intervalTimer = null;
+    }
   }
-  async uploadOnce() {
+  /**
+   * Drive a single upload pass. `trigger` is surfaced as a span attribute so
+   * we can distinguish startup drain vs steady-state ticks in ScopeDB.
+   */
+  async uploadOnce(trigger = "manual") {
     const files = await this.findUploadCandidates();
     let uploaded = 0;
     for (const file of files.slice(0, this.options.maxFilesPerRun ?? DEFAULT_MAX_FILES_PER_RUN)) {
-      if (await this.uploadFile(file)) uploaded += 1;
+      if (await this.uploadFile(file, trigger)) uploaded += 1;
     }
     return { attempted: files.length, uploaded };
   }
+  scheduleNextTick() {
+    if (this.stopped) return;
+    const baseIntervalMs = this.options.intervalMs ?? readPositiveIntegerEnv2("SLOCK_DAEMON_TRACE_UPLOAD_INTERVAL_MS", DEFAULT_UPLOAD_INTERVAL_MS);
+    const nextMs = baseIntervalMs + this.jitter.uploadIntervalJitterMs;
+    this.intervalTimer = this.timers.setTimeout(() => {
+      this.intervalTimer = null;
+      if (this.stopped) return;
+      void this.uploadOnce("interval");
+      this.scheduleNextTick();
+    }, nextMs);
+  }
   async findUploadCandidates() {
     const traceDir = path14.join(this.options.machineDir, "traces");
     let names;
@@ -7147,13 +7227,16 @@ var DaemonTraceBundleUploader = class {
     }
     return candidates;
   }
-  async uploadFile(file) {
+  async uploadFile(file, trigger) {
     const span = this.options.tracer?.startSpan("daemon.bundle.upload", {
       surface: "daemon",
       kind: "producer",
       attrs: {
         file_present: true,
-        worker_url_present: Boolean(this.options.workerUrl)
+        worker_url_present: Boolean(this.options.workerUrl),
+        upload_trigger: trigger,
+        initial_delay_ms_bucket: bucketDelayMs(this.jitter.initialUploadDelayMs),
+        interval_jitter_ms_bucket: bucketDelayMs(this.jitter.uploadIntervalJitterMs)
       }
     });
     try {
@@ -7229,7 +7312,7 @@ var DaemonTraceBundleUploader = class {
   }
 };
 function sha256Hex(body) {
-  return createHash2("sha256").update(body).digest("hex");
+  return createHash3("sha256").update(body).digest("hex");
 }
 function readPositiveIntegerEnv2(name, fallback) {
   const value = process.env[name];
@@ -7239,6 +7322,7 @@ function readPositiveIntegerEnv2(name, fallback) {
 }
 
 // src/core.ts
+var DEFAULT_TRACE_UPLOAD_URL = "https://slock-trace-upload.botiverse.dev";
 var DAEMON_CLI_USAGE = "Usage: slock-daemon --server-url <url> --api-key <key>";
 function parseDaemonCliArgs(args) {
   let serverUrl = "";
@@ -7459,11 +7543,18 @@ var DaemonCore = class {
     if (!this.options.localTrace) return false;
     return process.env.SLOCK_DAEMON_LOCAL_TRACE !== "0";
   }
+  resolveTraceJitter() {
+    const lockId = this.machineLock?.lockId;
+    return lockId ? computeTraceJitter(lockId) : NO_JITTER;
+  }
   installLocalTraceSink(machineDir) {
     if (!this.shouldEnableLocalTrace()) return;
+    const jitter = this.resolveTraceJitter();
     this.localTraceSink = new LocalRotatingTraceSink({
       machineDir,
       maxFileBytes: this.options.localTraceMaxFileBytes ?? readPositiveIntegerEnv3("SLOCK_DAEMON_TRACE_MAX_FILE_BYTES", 5 * 1024 * 1024),
+      maxFileAgeMs: this.options.localTraceMaxFileAgeMs ?? readPositiveIntegerEnv3("SLOCK_DAEMON_TRACE_MAX_FILE_AGE_MS", 5 * 60 * 1e3),
+      maxFileAgeJitterMs: jitter.maxFileAgeJitterMs,
       maxFiles: this.options.localTraceMaxFiles ?? readPositiveIntegerEnv3("SLOCK_DAEMON_TRACE_MAX_FILES", 8)
     });
     this.tracer = new BasicTracer({
@@ -7474,15 +7565,16 @@ var DaemonCore = class {
   installTraceBundleUploader(machineDir) {
     if (!this.shouldEnableLocalTrace()) return;
     if (this.traceBundleUploader) return;
-    const workerUrl = process.env.SLOCK_DAEMON_TRACE_UPLOAD_URL;
-    if (!workerUrl) return;
+    if (process.env.SLOCK_DAEMON_TRACE_UPLOAD_DISABLED === "1") return;
+    const workerUrl = process.env.SLOCK_DAEMON_TRACE_UPLOAD_URL || DEFAULT_TRACE_UPLOAD_URL;
     this.traceBundleUploader = new DaemonTraceBundleUploader({
       machineDir,
       serverUrl: this.options.serverUrl,
       apiKey: this.options.apiKey,
       workerUrl,
       tracer: this.tracer,
-      currentFileProvider: () => this.localTraceSink?.getCurrentFile() ?? null
+      currentFileProvider: () => this.localTraceSink?.getCurrentFile() ?? null,
+      lockId: this.machineLock?.lockId
     });
     this.traceBundleUploader.start();
   }

package/dist/core.js

@@ -9,7 +9,7 @@ import {
   resolveSlockCliPath,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories
-} from "./chunk-XW57NR6Y.js";
+} from "./chunk-FG5JGA67.js";
 import {
   subscribeDaemonLogs
 } from "./chunk-Z3PCMYZO.js";

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   DAEMON_CLI_USAGE,
   DaemonCore,
   parseDaemonCliArgs
-} from "./chunk-XW57NR6Y.js";
+} from "./chunk-FG5JGA67.js";
 import "./chunk-Z3PCMYZO.js";
 
 // src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slock-ai/daemon",
-  "version": "0.46.1",
+  "version": "0.46.2-staging.20260509074830",
   "type": "module",
   "bin": {
     "slock-daemon": "dist/index.js"