signetai 0.204.5 → 0.205.0

package/dist/mcp-stdio.js

@@ -49062,6 +49062,303 @@ class DreamingBacklogTokenCache {
   }
 }
 
+// ../../platform/daemon/src/pipeline/dreaming-live-events.ts
+var DREAMING_LIVE_MAX_EVENTS = 256;
+var DREAMING_LIVE_MAX_SUBSCRIBERS = 16;
+var DREAMING_LIVE_MAX_PASSES = 32;
+var DREAMING_LIVE_MAX_EVENT_CHARS = 48000;
+var DREAMING_LIVE_MAX_RAW_CHARS = 16000;
+var DREAMING_LIVE_TERMINAL_RETENTION_MS = 10 * 60000;
+function nowIso() {
+  return new Date().toISOString();
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? { ...value } : {};
+}
+function safeJson(value) {
+  try {
+    const json2 = JSON.stringify(value);
+    return json2 === undefined ? "null" : json2;
+  } catch (error51) {
+    return JSON.stringify({ serializationError: error51 instanceof Error ? error51.message : String(error51) });
+  }
+}
+function truncatedJsonValue(serialized, maxChars) {
+  const base = { truncated: true, originalChars: serialized.length };
+  let preview = serialized.slice(0, Math.max(0, maxChars - safeJson(base).length - 16));
+  let result = { ...base, preview };
+  while (safeJson(result).length > maxChars && preview.length > 0) {
+    preview = preview.slice(0, Math.max(0, preview.length - Math.max(1, Math.ceil(preview.length / 10))));
+    result = { ...base, preview };
+  }
+  return result;
+}
+function boundDreamingLiveValue(value, maxChars = DREAMING_LIVE_MAX_RAW_CHARS) {
+  const json2 = safeJson(value);
+  if (json2.length <= maxChars)
+    return value;
+  return truncatedJsonValue(json2, maxChars);
+}
+function boundString(value, maxChars) {
+  return value.length <= maxChars ? value : `${value.slice(0, maxChars)}…`;
+}
+function boundMetadataString(value, maxChars = 512) {
+  return boundString(value, maxChars);
+}
+function boundNullableMetadataString(value, maxChars) {
+  return value == null ? null : boundString(value, maxChars);
+}
+function boundEventData(value) {
+  const data = {};
+  for (const [key, rawValue] of Object.entries(value)) {
+    if (key === "raw") {
+      data[key] = boundDreamingLiveValue(rawValue, DREAMING_LIVE_MAX_RAW_CHARS);
+    } else if (typeof rawValue === "string") {
+      data[key] = boundString(rawValue, 12000);
+    } else {
+      data[key] = boundDreamingLiveValue(rawValue, 12000);
+    }
+  }
+  const serialized = safeJson(data);
+  if (serialized.length <= DREAMING_LIVE_MAX_EVENT_CHARS)
+    return data;
+  const compact = {};
+  for (const [key, rawValue] of Object.entries(data)) {
+    if (key === "raw") {
+      compact[key] = boundDreamingLiveValue(rawValue, 4000);
+    } else if (typeof rawValue === "string") {
+      compact[key] = boundString(rawValue, 2000);
+    } else {
+      compact[key] = boundDreamingLiveValue(rawValue, 4000);
+    }
+  }
+  const compactSerialized = safeJson(compact);
+  if (compactSerialized.length <= DREAMING_LIVE_MAX_EVENT_CHARS)
+    return compact;
+  return truncatedJsonValue(serialized, DREAMING_LIVE_MAX_EVENT_CHARS);
+}
+function metadataFromInput(input) {
+  return {
+    passId: boundMetadataString(input.passId),
+    agentId: boundMetadataString(input.agentId),
+    mode: boundMetadataString(input.mode),
+    status: "running",
+    startedAt: boundMetadataString(input.startedAt ?? nowIso(), 128),
+    completedAt: null,
+    summary: null,
+    error: null
+  };
+}
+function isTerminal2(status) {
+  return status !== "running";
+}
+function isTerminalEvent(event) {
+  return event.type === "pass_completed" || event.type === "pass_failed";
+}
+
+class DreamingLiveEventHub {
+  passes = new Map;
+  startPass(input) {
+    this.prune();
+    const existing = this.passes.get(input.passId);
+    if (existing) {
+      existing.metadata = {
+        ...existing.metadata,
+        agentId: boundMetadataString(input.agentId),
+        mode: boundMetadataString(input.mode),
+        startedAt: boundMetadataString(input.startedAt ?? existing.metadata.startedAt, 128)
+      };
+      existing.lastTouchedAt = Date.now();
+      return;
+    }
+    if (this.passes.size >= DREAMING_LIVE_MAX_PASSES)
+      return;
+    const pass = {
+      metadata: metadataFromInput(input),
+      nextCursor: 1,
+      events: [],
+      subscribers: new Set,
+      lastTouchedAt: Date.now()
+    };
+    this.passes.set(input.passId, pass);
+    this.append(pass, "pass_started", {
+      agentId: input.agentId,
+      mode: input.mode,
+      startedAt: pass.metadata.startedAt
+    });
+  }
+  ensurePass(input) {
+    const existing = this.passes.get(input.passId);
+    if (!existing) {
+      this.startPass(input);
+      const created = this.passes.get(input.passId);
+      if (created) {
+        created.metadata = {
+          ...created.metadata,
+          status: boundMetadataString(input.status ?? created.metadata.status),
+          completedAt: boundNullableMetadataString(input.completedAt ?? created.metadata.completedAt, 128),
+          summary: boundNullableMetadataString(input.summary ?? created.metadata.summary, 12000),
+          error: boundNullableMetadataString(input.error ?? created.metadata.error, 12000)
+        };
+        this.appendRecoveredTerminal(created);
+      }
+      return;
+    }
+    if (isTerminal2(existing.metadata.status) && (input.status === undefined || input.status === "running")) {
+      existing.lastTouchedAt = Date.now();
+      return;
+    }
+    existing.metadata = {
+      ...existing.metadata,
+      status: boundMetadataString(input.status ?? existing.metadata.status),
+      completedAt: boundNullableMetadataString(input.completedAt ?? existing.metadata.completedAt, 128),
+      summary: boundNullableMetadataString(input.summary ?? existing.metadata.summary, 12000),
+      error: boundNullableMetadataString(input.error ?? existing.metadata.error, 12000)
+    };
+    existing.lastTouchedAt = Date.now();
+    this.appendRecoveredTerminal(existing);
+  }
+  publish(passId, type, data = {}) {
+    const pass = this.passes.get(passId);
+    if (!pass || isTerminal2(pass.metadata.status) && type !== "pass_completed" && type !== "pass_failed")
+      return;
+    this.append(pass, type, data);
+  }
+  finish(passId, status, data = {}) {
+    const pass = this.passes.get(passId);
+    if (!pass)
+      return;
+    if (isTerminal2(pass.metadata.status))
+      return;
+    const completedAt = nowIso();
+    const summary = typeof data.summary === "string" ? boundString(data.summary, 12000) : null;
+    const error51 = typeof data.error === "string" ? boundString(data.error, 12000) : null;
+    pass.metadata = { ...pass.metadata, status, completedAt, summary, error: error51 };
+    this.append(pass, status === "completed" ? "pass_completed" : "pass_failed", {
+      ...data,
+      status,
+      completedAt,
+      ...summary === null ? {} : { summary },
+      ...error51 === null ? {} : { error: error51 }
+    });
+  }
+  getSnapshot(passId) {
+    const pass = this.passes.get(passId);
+    if (!pass)
+      return null;
+    return this.snapshot(pass);
+  }
+  subscribe(passId, afterCursor, listener) {
+    const pass = this.passes.get(passId);
+    if (!pass)
+      return null;
+    if (pass.subscribers.size >= DREAMING_LIVE_MAX_SUBSCRIBERS) {
+      throw new Error("Too many viewers are attached to this Dreaming pass");
+    }
+    pass.subscribers.add(listener);
+    pass.lastTouchedAt = Date.now();
+    const requested = afterCursor ?? 0;
+    const latest = pass.nextCursor - 1;
+    const first = pass.events[0]?.cursor ?? null;
+    let gap = null;
+    if (requested > latest) {
+      gap = {
+        requestedCursor: requested,
+        availableFrom: first,
+        availableTo: latest,
+        reason: "cursor_ahead"
+      };
+    } else if (first !== null && requested < first - 1) {
+      gap = {
+        requestedCursor: requested,
+        availableFrom: first,
+        availableTo: latest,
+        reason: "buffer_exhausted"
+      };
+    }
+    const replay = pass.events.filter((event) => event.cursor > requested);
+    let subscribed = true;
+    return {
+      snapshot: this.snapshot(pass),
+      replay,
+      gap,
+      unsubscribe: () => {
+        if (!subscribed)
+          return;
+        subscribed = false;
+        pass.subscribers.delete(listener);
+        pass.lastTouchedAt = Date.now();
+      }
+    };
+  }
+  getSubscriberCount(passId) {
+    if (passId === undefined)
+      return [...this.passes.values()].reduce((total, pass) => total + pass.subscribers.size, 0);
+    return this.passes.get(passId)?.subscribers.size ?? 0;
+  }
+  reset() {
+    this.passes.clear();
+  }
+  append(pass, type, input) {
+    const event = {
+      passId: pass.metadata.passId,
+      agentId: pass.metadata.agentId,
+      cursor: pass.nextCursor++,
+      timestamp: nowIso(),
+      type,
+      data: boundEventData(asRecord(input))
+    };
+    pass.events.push(event);
+    if (pass.events.length > DREAMING_LIVE_MAX_EVENTS)
+      pass.events.splice(0, pass.events.length - DREAMING_LIVE_MAX_EVENTS);
+    pass.lastTouchedAt = Date.now();
+    for (const listener of [...pass.subscribers]) {
+      try {
+        listener(event);
+      } catch {}
+    }
+  }
+  snapshot(pass) {
+    return {
+      ...pass.metadata,
+      cursor: pass.nextCursor - 1,
+      replayFrom: pass.events[0]?.cursor ?? null,
+      replayTo: pass.events.at(-1)?.cursor ?? null
+    };
+  }
+  appendRecoveredTerminal(pass) {
+    if (!isTerminal2(pass.metadata.status) || pass.events.some((event) => isTerminalEvent(event)))
+      return;
+    this.append(pass, pass.metadata.status === "completed" ? "pass_completed" : "pass_failed", {
+      status: pass.metadata.status,
+      completedAt: pass.metadata.completedAt,
+      ...pass.metadata.summary === null ? {} : { summary: pass.metadata.summary },
+      ...pass.metadata.error === null ? {} : { error: pass.metadata.error }
+    });
+  }
+  prune() {
+    const cutoff = Date.now() - DREAMING_LIVE_TERMINAL_RETENTION_MS;
+    for (const [passId, pass] of this.passes) {
+      if (pass.subscribers.size === 0 && isTerminal2(pass.metadata.status) && pass.lastTouchedAt < cutoff) {
+        this.passes.delete(passId);
+      }
+    }
+    if (this.passes.size < DREAMING_LIVE_MAX_PASSES)
+      return;
+    const candidates2 = [...this.passes.entries()].filter(([, pass]) => pass.subscribers.size === 0).sort(([, left], [, right]) => {
+      const leftTerminal = isTerminal2(left.metadata.status) ? 0 : 1;
+      const rightTerminal = isTerminal2(right.metadata.status) ? 0 : 1;
+      return leftTerminal - rightTerminal || left.lastTouchedAt - right.lastTouchedAt;
+    });
+    for (const [passId] of candidates2) {
+      if (this.passes.size < DREAMING_LIVE_MAX_PASSES)
+        break;
+      this.passes.delete(passId);
+    }
+  }
+}
+var dreamingLiveEvents = new DreamingLiveEventHub;
+
 // ../../node_modules/.bun/js-tiktoken@1.0.21/node_modules/js-tiktoken/dist/chunk-VL2OQCWN.js
 var import_base64_js = __toESM(require_base64_js(), 1);
 var __defProp3 = Object.defineProperty;

package/native-manifest.json

@@ -1,43 +1,43 @@
 {
   "schemaVersion": 1,
-  "version": "0.204.5",
+  "version": "0.205.0",
   "assets": [
     {
       "name": "signet-darwin-arm64",
       "platform": "darwin-arm64",
-      "sha256": "e5043117edd929228aef331293d3e8cb9fb370c9f27162f0f9787ebe6acfcdc4",
-      "size": 140013088
+      "sha256": "e42ec2e6c14f508555c7d8541988c3d3665967a66bb329e375201db2f59c08f8",
+      "size": 140062624
     },
     {
       "name": "signet-darwin-x64",
       "platform": "darwin-x64",
-      "sha256": "e169bbde63261ad68b9e4fb67b01a46522fd9a3255d89faca6cd967030018b58",
-      "size": 144869952
+      "sha256": "9baa2a2de27cbfc4f86f7232da386b24694fb848ac0198ef10bdf42c622c6b6f",
+      "size": 144919104
     },
     {
       "name": "signet-linux-arm64",
       "platform": "linux-arm64",
-      "sha256": "381cffba0e803d3640f711499178ba24b61dd907129c1f6fdff7c4cee9ac30c5",
-      "size": 184465846
+      "sha256": "6334b1297b638777d4080dd7c39638f9748f11c90b556b7cbaf394b1bd03179b",
+      "size": 184508656
     },
     {
       "name": "signet-linux-x64",
       "platform": "linux-x64",
-      "sha256": "6ff1e08f4ffa9585fcc3edfa308a9d51ba314ef681a62a3559ef8049855d0149",
-      "size": 186839213
+      "sha256": "72f0f586bee2ed9bc53e272890253fed89f0e4336a2590cbdf6e023c51701e36",
+      "size": 186882023
     },
     {
       "name": "signet-win32-x64.exe",
       "platform": "win32-x64",
-      "sha256": "ea4eddc12a38298d1dbc2ecd7c589cb1d3e92118584d51cee5980a9853a6ae96",
-      "size": 194911744
+      "sha256": "504ae86fefd1ec69f0fc3e73cde4f8fd13ffacd3bc2ef6103a673d0c6d85bdaf",
+      "size": 194954752
     }
   ],
   "components": {
     "connectors": {
-      "url": "signet-connectors-0.204.5.tar.gz",
-      "sha256": "ff7041466138922ea9be222f8651f32be720692a7aad8286aea65c357e3c29fe",
-      "size": 21945
+      "url": "signet-connectors-0.205.0.tar.gz",
+      "sha256": "d2b9c818c1bbce8e7210c9afe6c97301c7d3d0ea71acae92e24c7e0c8f05e251",
+      "size": 21943
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signetai",
-  "version": "0.204.5",
+  "version": "0.205.0",
   "description": "Signet native CLI installer wrapper",
   "type": "module",
   "bin": {
@@ -65,10 +65,10 @@
     "access": "public"
   },
   "optionalDependencies": {
-    "signetai-darwin-arm64": "https://github.com/Signet-AI/signetai/releases/download/v0.204.5/signetai-darwin-arm64-0.204.5.tgz",
-    "signetai-darwin-x64": "https://github.com/Signet-AI/signetai/releases/download/v0.204.5/signetai-darwin-x64-0.204.5.tgz",
-    "signetai-linux-arm64": "https://github.com/Signet-AI/signetai/releases/download/v0.204.5/signetai-linux-arm64-0.204.5.tgz",
-    "signetai-linux-x64": "https://github.com/Signet-AI/signetai/releases/download/v0.204.5/signetai-linux-x64-0.204.5.tgz",
-    "signetai-win32-x64": "https://github.com/Signet-AI/signetai/releases/download/v0.204.5/signetai-win32-x64-0.204.5.tgz"
+    "signetai-darwin-arm64": "https://github.com/Signet-AI/signetai/releases/download/v0.205.0/signetai-darwin-arm64-0.205.0.tgz",
+    "signetai-darwin-x64": "https://github.com/Signet-AI/signetai/releases/download/v0.205.0/signetai-darwin-x64-0.205.0.tgz",
+    "signetai-linux-arm64": "https://github.com/Signet-AI/signetai/releases/download/v0.205.0/signetai-linux-arm64-0.205.0.tgz",
+    "signetai-linux-x64": "https://github.com/Signet-AI/signetai/releases/download/v0.205.0/signetai-linux-x64-0.205.0.tgz",
+    "signetai-win32-x64": "https://github.com/Signet-AI/signetai/releases/download/v0.205.0/signetai-win32-x64-0.205.0.tgz"
   }
 }