opencode-swarm 7.136.5 → 7.137.0

package/dist/cli/index-cze4bq1x.js

@@ -1,358 +0,0 @@
-// @bun
-// src/telemetry.ts
-import * as fs from "fs";
-import { createWriteStream } from "fs";
-import * as os from "os";
-import * as path from "path";
-var _writeStream = null;
-var _projectDirectory = null;
-var _listeners = [];
-var _disabled = false;
-var _heartbeatTrackingActive = false;
-var _heartbeatListener = null;
-var heartbeatTimestamps = new Map;
-function capHeartbeatMap() {
-  while (heartbeatTimestamps.size >= 500) {
-    const oldestKey = heartbeatTimestamps.keys().next().value;
-    if (oldestKey === undefined)
-      break;
-    heartbeatTimestamps.delete(oldestKey);
-  }
-}
-function startHeartbeatTracking() {
-  if (_heartbeatTrackingActive)
-    return;
-  _heartbeatTrackingActive = true;
-  const listener = (event, data) => {
-    if (event !== "heartbeat")
-      return;
-    const payload = data;
-    if (!payload?.sessionId)
-      return;
-    heartbeatTimestamps.set(payload.sessionId, Date.now());
-    capHeartbeatMap();
-  };
-  _heartbeatListener = listener;
-  addTelemetryListener(listener);
-}
-function getLastHeartbeat(sessionId) {
-  return heartbeatTimestamps.get(sessionId);
-}
-function stopHeartbeatTracking() {
-  _heartbeatTrackingActive = false;
-  if (_heartbeatListener !== null) {
-    const idx = _listeners.indexOf(_heartbeatListener);
-    if (idx >= 0)
-      _listeners.splice(idx, 1);
-    _heartbeatListener = null;
-  }
-}
-function resetHeartbeatTrackingForTesting() {
-  _heartbeatTrackingActive = false;
-  heartbeatTimestamps.clear();
-  if (_heartbeatListener !== null) {
-    const idx = _listeners.indexOf(_heartbeatListener);
-    if (idx >= 0)
-      _listeners.splice(idx, 1);
-    _heartbeatListener = null;
-  }
-}
-var _emitCount = 0;
-var ROTATION_CHECK_INTERVAL = 50;
-function resetTelemetryForTesting() {
-  _disabled = false;
-  _projectDirectory = null;
-  _listeners.length = 0;
-  _emitCount = 0;
-  resetHeartbeatTrackingForTesting();
-  if (_writeStream !== null) {
-    _writeStream.end();
-    _writeStream = null;
-  }
-}
-function initTelemetry(projectDirectory) {
-  if (_writeStream !== null || _disabled) {
-    return;
-  }
-  try {
-    _projectDirectory = projectDirectory;
-    const swarmDir = path.join(projectDirectory, ".swarm");
-    if (!fs.existsSync(swarmDir)) {
-      fs.mkdirSync(swarmDir, { recursive: true });
-    }
-    const telemetryPath = path.join(swarmDir, "telemetry.jsonl");
-    const stream = createWriteStream(telemetryPath, { flags: "a" });
-    stream.on("error", () => {
-      if (_writeStream === stream) {
-        _disabled = true;
-        _writeStream = null;
-      }
-    });
-    _writeStream = stream;
-  } catch {
-    _disabled = true;
-    _writeStream = null;
-  }
-}
-function emit(event, data) {
-  try {
-    if (_disabled || _writeStream === null) {
-      return;
-    }
-    const line = JSON.stringify({
-      timestamp: new Date().toISOString(),
-      event,
-      ...data
-    }) + os.EOL;
-    const stream = _writeStream;
-    stream.write(line, (err) => {
-      if (err && _writeStream === stream) {
-        _disabled = true;
-        _writeStream = null;
-      }
-    });
-    for (const listener of _listeners) {
-      try {
-        listener(event, data);
-      } catch {}
-    }
-    _emitCount++;
-    if (_emitCount >= ROTATION_CHECK_INTERVAL) {
-      _emitCount = 0;
-      _internals.rotateTelemetryIfNeeded();
-    }
-  } catch {}
-}
-function addTelemetryListener(callback) {
-  _listeners.push(callback);
-}
-function rotateTelemetryIfNeeded(maxBytes = 10 * 1024 * 1024) {
-  try {
-    if (_projectDirectory === null) {
-      return;
-    }
-    const telemetryPath = path.join(_projectDirectory, ".swarm", "telemetry.jsonl");
-    if (!fs.existsSync(telemetryPath)) {
-      return;
-    }
-    const stats = fs.statSync(telemetryPath);
-    if (stats.size < maxBytes) {
-      return;
-    }
-    const rotatedPath = path.join(_projectDirectory, ".swarm", "telemetry.jsonl.1");
-    fs.renameSync(telemetryPath, rotatedPath);
-    if (_writeStream !== null) {
-      _writeStream.end();
-      const stream = createWriteStream(telemetryPath, { flags: "a" });
-      stream.on("error", () => {
-        if (_writeStream === stream) {
-          _disabled = true;
-          _writeStream = null;
-        }
-      });
-      _writeStream = stream;
-    }
-  } catch {}
-}
-var telemetry = {
-  sessionStarted(sessionId, agentName) {
-    _internals.emit("session_started", { sessionId, agentName });
-  },
-  sessionEnded(sessionId, reason) {
-    _internals.emit("session_ended", { sessionId, reason });
-  },
-  agentActivated(sessionId, agentName, oldName) {
-    _internals.emit("agent_activated", { sessionId, agentName, oldName });
-  },
-  delegationBegin(sessionId, agentName, taskId) {
-    _internals.emit("delegation_begin", { sessionId, agentName, taskId });
-  },
-  delegationEnd(sessionId, agentName, taskId, result, costFields) {
-    _internals.emit("delegation_end", {
-      sessionId,
-      agentName,
-      taskId,
-      result,
-      tokens_input: costFields?.tokens_input ?? 0,
-      tokens_output: costFields?.tokens_output ?? 0,
-      tokens_reasoning: costFields?.tokens_reasoning ?? 0,
-      tokens_cache: costFields?.tokens_cache ?? 0,
-      cost_usd: costFields?.cost_usd ?? null,
-      cost_source: costFields?.cost_source ?? "unavailable",
-      model: costFields?.model,
-      gate: costFields?.gate,
-      retry_index: costFields?.retry_index
-    });
-  },
-  taskStateChanged(sessionId, taskId, newState, oldState) {
-    _internals.emit("task_state_changed", {
-      sessionId,
-      taskId,
-      newState,
-      oldState
-    });
-  },
-  gatePassed(sessionId, gate, taskId) {
-    _internals.emit("gate_passed", { sessionId, gate, taskId });
-  },
-  gateParseError(taskId, error) {
-    _internals.emit("gate_parse_error", {
-      taskId,
-      errorName: error.name,
-      errorMessage: error.message.slice(0, 200)
-    });
-  },
-  gateFailed(sessionId, gate, taskId, reason) {
-    _internals.emit("gate_failed", { sessionId, gate, taskId, reason });
-  },
-  reviewerGateDecision(sessionId, taskId, blocked, reasonCode, evidenceKind) {
-    _internals.emit("reviewer_gate_decision", {
-      sessionId,
-      gate: "qa_gate",
-      taskId,
-      blocked,
-      allowed: !blocked,
-      reasonCode,
-      evidenceKind
-    });
-  },
-  phaseChanged(sessionId, oldPhase, newPhase) {
-    _internals.emit("phase_changed", { sessionId, oldPhase, newPhase });
-  },
-  budgetUpdated(sessionId, budgetPct, agentName) {
-    _internals.emit("budget_updated", { sessionId, budgetPct, agentName });
-  },
-  modelFallback(sessionId, agentName, fromModel, toModel, reason) {
-    _internals.emit("model_fallback", {
-      sessionId,
-      agentName,
-      fromModel,
-      toModel,
-      reason
-    });
-  },
-  hardLimitHit(sessionId, agentName, limitType, value) {
-    _internals.emit("hard_limit_hit", {
-      sessionId,
-      agentName,
-      limitType,
-      value
-    });
-  },
-  revisionLimitHit(sessionId, agentName) {
-    _internals.emit("revision_limit_hit", { sessionId, agentName });
-  },
-  loopDetected(sessionId, agentName, loopType) {
-    _internals.emit("loop_detected", { sessionId, agentName, loopType });
-  },
-  noOpStrongWarning(sessionId, agentName, count, threshold) {
-    _internals.emit("no_op_strong_warning", {
-      sessionId,
-      agentName,
-      count,
-      threshold
-    });
-  },
-  gateDenialLoop(sessionId, tool, code, count) {
-    _internals.emit("gate_denial_loop", { sessionId, tool, code, count });
-  },
-  executionStallWarning(sessionId, count, threshold) {
-    _internals.emit("execution_stall_warning", {
-      sessionId,
-      count,
-      threshold
-    });
-  },
-  executionStallDenied(sessionId, tool, count, threshold) {
-    _internals.emit("execution_stall_denied", {
-      sessionId,
-      tool,
-      count,
-      threshold
-    });
-  },
-  swarmInternalsReadDenied(sessionId, tool, target) {
-    _internals.emit("swarm_internals_read_denied", {
-      sessionId,
-      tool,
-      target
-    });
-  },
-  scopeViolation(sessionId, agentName, file, reason) {
-    _internals.emit("scope_violation", { sessionId, agentName, file, reason });
-  },
-  qaSkipViolation(sessionId, agentName, skipCount) {
-    _internals.emit("qa_skip_violation", { sessionId, agentName, skipCount });
-  },
-  heartbeat(sessionId) {
-    _internals.emit("heartbeat", { sessionId });
-  },
-  turboModeChanged(sessionId, enabled, agentName) {
-    _internals.emit("turbo_mode_changed", { sessionId, enabled, agentName });
-  },
-  autoOversightEscalation(sessionId, reason, interactionCount, deadlockCount, phase) {
-    _internals.emit("auto_oversight_escalation", {
-      sessionId,
-      reason,
-      interactionCount,
-      deadlockCount,
-      phase
-    });
-  },
-  environmentDetected(sessionId, hostOS, shellFamily, executionMode) {
-    _internals.emit("environment_detected", {
-      sessionId,
-      hostOS,
-      shellFamily,
-      executionMode
-    });
-  },
-  prmPatternDetected(sessionId, pattern, severity, category, stepRange) {
-    _internals.emit("prm_pattern_detected", {
-      sessionId,
-      pattern,
-      severity,
-      category,
-      stepRange
-    });
-  },
-  prmCourseCorrectionInjected(sessionId, pattern, level) {
-    _internals.emit("prm_course_correction_injected", {
-      sessionId,
-      pattern,
-      level
-    });
-  },
-  prmEscalationTriggered(sessionId, pattern, level, occurrenceCount) {
-    _internals.emit("prm_escalation_triggered", {
-      sessionId,
-      pattern,
-      level,
-      occurrenceCount
-    });
-  },
-  prmHardStop(sessionId, pattern, level, occurrenceCount) {
-    _internals.emit("prm_hard_stop", {
-      sessionId,
-      pattern,
-      level,
-      occurrenceCount
-    });
-  },
-  prmHardStopDelivered(sessionId, pattern, level, occurrenceCount) {
-    _internals.emit("prm_hard_stop_delivered", {
-      sessionId,
-      pattern,
-      level,
-      occurrenceCount
-    });
-  }
-};
-var _internals = {
-  telemetry,
-  emit,
-  rotateTelemetryIfNeeded,
-  heartbeatListenerCount: () => _heartbeatListener !== null ? 1 : 0
-};
-
-export { startHeartbeatTracking, getLastHeartbeat, stopHeartbeatTracking, resetHeartbeatTrackingForTesting, ROTATION_CHECK_INTERVAL, resetTelemetryForTesting, initTelemetry, emit, addTelemetryListener, rotateTelemetryIfNeeded, telemetry, _internals };