@unbrained/pm-cli 2026.6.12 → 2026.6.16

package/dist/cli-bundle/chunks/{chunk-GKIZW7SM.js → chunk-764O7EUA.js}

@@ -1,6 +1,6 @@
 import {
   nowIso
-} from "./chunk-IUKD4W6Z.js";
+} from "./chunk-OY3P2I6B.js";
 import {
   EXIT_CODE,
   appendLineAtomic,
@@ -11,13 +11,13 @@ import {
   resolveTelemetryErrorCategory,
   writeFileAtomic,
   writeSettings
-} from "./chunk-FY4SPXSC.js";
+} from "./chunk-LV5FFQ7M.js";
 
 // dist/core/telemetry/observability.js
 !(function() {
   try {
     var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "346cb9f1-80e5-5ecd-9e59-a39375359717");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "6be38f3d-f66d-5637-a917-0e6c7bb49a9b");
   } catch (e2) {
   }
 })();
@@ -75,8 +75,8 @@ function normalizeErrorCode(errorCode2) {
 function deriveTelemetryCommandTaxonomy(commandPath) {
   const normalizedPath = normalizeCommandPath(commandPath);
   const tokens = normalizedPath.length > 0 ? normalizedPath.split(" ") : ["<unknown>"];
-  const root = tokens[0] ?? "<unknown>";
-  const leaf = tokens[tokens.length - 1] ?? root;
+  const root = tokens[0];
+  const leaf = tokens[tokens.length - 1];
   let family = "other";
   if (SETUP_ROOT_COMMANDS.has(root)) {
     family = "setup";
@@ -144,13 +144,10 @@ function inferTelemetryErrorCode(params) {
   if (message.startsWith("invalid ") || message.includes(" must be ") || message.includes(" requires ")) {
     return "invalid_argument_value";
   }
-  if (message.includes("strict create mode requires concrete values for --")) {
-    return "missing_required_option";
-  }
   if (message.includes("either as positional") && message.includes("not both")) {
     return "invalid_command_usage";
   }
-  const exitCode = Number.isFinite(params.exitCode) ? Math.max(0, Math.trunc(params.exitCode ?? 0)) : void 0;
+  const exitCode = Number.isFinite(params.exitCode) ? Math.max(0, Math.trunc(params.exitCode)) : void 0;
   if (exitCode === EXIT_CODE.USAGE) {
     return "invalid_command_usage";
   }
@@ -213,12 +210,15 @@ import path from "node:path";
 !(function() {
   try {
     var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "8431b32d-4a71-59da-ace6-b292ce6d0a3a");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "0499331c-7c90-573a-9b07-2437c7ac8072");
   } catch (e2) {
   }
 })();
 var TELEMETRY_QUEUE_RELATIVE_PATH = path.join("runtime", "telemetry", "events.jsonl");
 var TELEMETRY_STATE_RELATIVE_PATH = path.join("runtime", "telemetry", "state.json");
+var TELEMETRY_OTEL_SPANS_RELATIVE_PATH = path.join("runtime", "telemetry", "otel-spans.jsonl");
+var TELEMETRY_OTEL_SPANS_FLUSH_BATCH_SIZE = 8;
+var TELEMETRY_OTEL_SPANS_MAX_PENDING = 500;
 var TELEMETRY_SCHEMA_VERSION = 1;
 var TELEMETRY_CLIENT_SCHEMA_VERSION = 1;
 var TELEMETRY_FLUSH_BATCH_SIZE = 100;
@@ -274,6 +274,9 @@ var PRIVATE_IP_PATTERN = /\b(?:10\.(?:25[0-5]|2[0-4]\d|[01]?\d?\d)\.(?:25[0-5]|2
 function queuePath(globalPmRoot) {
   return path.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH);
 }
+function otelSpansQueuePath(globalPmRoot) {
+  return path.join(globalPmRoot, TELEMETRY_OTEL_SPANS_RELATIVE_PATH);
+}
 function telemetryRuntimeDirectory(globalPmRoot) {
   return path.dirname(queuePath(globalPmRoot));
 }
@@ -531,7 +534,7 @@ function parseBooleanTrueLike(value) {
   return BOOLEAN_TRUE_VALUES.has((value ?? "").trim().toLowerCase());
 }
 function normalizePmVersion(value) {
-  const trimmed = value?.trim() ?? "";
+  const trimmed = typeof value === "string" ? value.trim() : "";
   return trimmed.length > 0 ? trimmed : "0.0.0";
 }
 function normalizeTelemetryErrorCode(value) {
@@ -540,7 +543,7 @@ function normalizeTelemetryErrorCode(value) {
 }
 function normalizeTelemetryExitCode(exitCode, ok) {
   if (Number.isFinite(exitCode)) {
-    return Math.max(0, Math.trunc(exitCode ?? 0));
+    return Math.max(0, Math.trunc(exitCode));
   }
   return ok ? 0 : 1;
 }
@@ -622,8 +625,9 @@ function hashCommandArgs(installationId, args) {
   };
 }
 function hashTelemetryErrorFingerprint(installationId, command, errorCode2, errorMessage) {
-  const normalizedMessage = sanitizeString(errorMessage ?? "", "redacted");
-  const fingerprintSource = `${command}\0${errorCode2 ?? "unknown_error"}\0${normalizedMessage}`;
+  const normalizedMessage = sanitizeString(typeof errorMessage === "string" ? errorMessage : "", "redacted");
+  const normalizedCode = typeof errorCode2 === "string" && errorCode2.length > 0 ? errorCode2 : "unknown_error";
+  const fingerprintSource = `${command}\0${normalizedCode}\0${normalizedMessage}`;
   return hashWithInstallationId(installationId, fingerprintSource);
 }
 function telemetryDisabledByEnvironment() {
@@ -679,9 +683,9 @@ function otlpIntAttribute(key, value) {
     value: { intValue: String(Math.max(0, Math.trunc(value))) }
   };
 }
-async function exportLocalOtelSpan(activeCommand, outcome, finishedAtIso, durationMs) {
+function buildOtelSpanRequest(activeCommand, outcome, finishedAtIso, durationMs) {
   if (typeof activeCommand.otel_traces_endpoint !== "string" || activeCommand.otel_traces_endpoint.trim().length === 0 || typeof activeCommand.otel_trace_id !== "string" || activeCommand.otel_trace_id.length === 0 || typeof activeCommand.otel_span_id !== "string" || activeCommand.otel_span_id.length === 0) {
-    return;
+    return null;
   }
   const serviceNameCandidate = sanitizeString((process.env[OTEL_SERVICE_NAME_ENV] ?? "").trim());
   const serviceName = serviceNameCandidate.length > 0 ? serviceNameCandidate : "pm-cli";
@@ -737,7 +741,7 @@ async function exportLocalOtelSpan(activeCommand, outcome, finishedAtIso, durati
                 attributes,
                 status: {
                   code: outcome.ok ? 1 : 2,
-                  message: outcome.ok ? "" : sanitizeString(outcome.error ?? "command_failed")
+                  message: outcome.ok ? "" : sanitizeString(typeof outcome.error === "string" ? outcome.error : "command_failed")
                 }
               }
             ]
@@ -746,17 +750,7 @@ async function exportLocalOtelSpan(activeCommand, outcome, finishedAtIso, durati
       }
     ]
   };
-  const response = await fetch(activeCommand.otel_traces_endpoint, {
-    method: "POST",
-    headers: {
-      "content-type": "application/json"
-    },
-    body: JSON.stringify(payload),
-    signal: AbortSignal.timeout(TELEMETRY_HTTP_TIMEOUT_MS)
-  });
-  if (!response.ok) {
-    throw new Error(`local_otel_export_http_${response.status}`);
-  }
+  return { endpoint: activeCommand.otel_traces_endpoint, payload };
 }
 function summarizeResult(result, captureLevel = "redacted") {
   if (result === null || result === void 0) {
@@ -782,7 +776,7 @@ function summarizeResult(result, captureLevel = "redacted") {
     let previewBytes = 0;
     for (const key of keys.slice(0, 25)) {
       const sanitizedValue = sanitizeValue(record[key], key, captureLevel);
-      const entrySize = JSON.stringify(sanitizedValue)?.length ?? 0;
+      const entrySize = JSON.stringify(sanitizedValue).length;
       if (previewBytes + entrySize > TELEMETRY_RESULT_PREVIEW_MAX_BYTES) {
         sanitized[key] = "[preview_truncated]";
         break;
@@ -999,16 +993,19 @@ function nextRetryIso(attempts) {
   const delay = Math.min(TELEMETRY_RETRY_BASE_DELAY_MS * 2 ** Math.max(attempts - 1, 0), TELEMETRY_MAX_RETRY_DELAY_MS);
   return new Date(Date.now() + delay).toISOString();
 }
-function isDueForRetry(entry) {
-  if (typeof entry.next_attempt_after !== "string" || entry.next_attempt_after.trim().length === 0) {
+function isDueForRetryAt(nextAttemptAfter) {
+  if (typeof nextAttemptAfter !== "string" || nextAttemptAfter.trim().length === 0) {
     return true;
   }
-  const dueAtMs = Date.parse(entry.next_attempt_after);
+  const dueAtMs = Date.parse(nextAttemptAfter);
   if (Number.isNaN(dueAtMs)) {
     return true;
   }
   return dueAtMs <= Date.now();
 }
+function isDueForRetry(entry) {
+  return isDueForRetryAt(entry.next_attempt_after);
+}
 function retentionCutoffMs(retentionDays) {
   const normalizedDays = Number.isFinite(retentionDays) ? Math.max(1, Math.trunc(retentionDays)) : 1;
   return Date.now() - normalizedDays * MILLISECONDS_PER_DAY;
@@ -1068,6 +1065,174 @@ function sleep(milliseconds) {
     setTimeout(resolve, milliseconds);
   });
 }
+async function enqueuePendingOtelSpan(globalPmRoot, request) {
+  const pending = {
+    id: crypto.randomUUID(),
+    endpoint: request.endpoint,
+    payload: request.payload,
+    enqueued_at: nowIso(),
+    attempts: 0
+  };
+  const serialized = JSON.stringify(pending);
+  if (serialized.length > TELEMETRY_MAX_EVENT_BYTES) {
+    return;
+  }
+  await withQueueMutation(async () => {
+    await appendLineAtomic(otelSpansQueuePath(globalPmRoot), serialized);
+  });
+}
+function backfillPendingOtelSpanId(entry) {
+  const material = JSON.stringify([entry.endpoint, entry.enqueued_at, entry.payload]);
+  return crypto.createHash("sha256").update(material).digest("hex").slice(0, 32);
+}
+function parsePendingOtelSpanLines(raw) {
+  const entries = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed === "object" && typeof parsed.endpoint === "string" && parsed.endpoint.trim().length > 0 && "payload" in parsed && typeof parsed.attempts === "number" && Number.isFinite(parsed.attempts)) {
+        if (typeof parsed.id !== "string" || parsed.id.length === 0) {
+          parsed.id = backfillPendingOtelSpanId(parsed);
+        }
+        entries.push(parsed);
+      }
+    } catch {
+    }
+  }
+  return entries;
+}
+function isExpiredPendingOtelSpan(entry, cutoffMs) {
+  if (typeof entry.enqueued_at !== "string" || entry.enqueued_at.trim().length === 0) {
+    return false;
+  }
+  const enqueuedAtMs = Date.parse(entry.enqueued_at);
+  if (Number.isNaN(enqueuedAtMs)) {
+    return false;
+  }
+  return enqueuedAtMs < cutoffMs;
+}
+function prunePendingOtelSpans(entries, retentionDays) {
+  const cutoffMs = retentionCutoffMs(retentionDays);
+  const retained = [];
+  let prunedCount = 0;
+  for (const entry of entries) {
+    const oversized = JSON.stringify(entry).length > TELEMETRY_MAX_EVENT_BYTES;
+    if (oversized || isExpiredPendingOtelSpan(entry, cutoffMs) || entry.attempts >= TELEMETRY_MAX_QUEUE_ENTRY_ATTEMPTS) {
+      prunedCount += 1;
+      continue;
+    }
+    retained.push(entry);
+  }
+  if (retained.length > TELEMETRY_OTEL_SPANS_MAX_PENDING) {
+    const overflow = retained.length - TELEMETRY_OTEL_SPANS_MAX_PENDING;
+    prunedCount += overflow;
+    return { entries: retained.slice(overflow), prunedCount };
+  }
+  return { entries: retained, prunedCount };
+}
+async function rewritePendingOtelSpans(globalPmRoot, entries) {
+  const serialized = entries.map((entry) => JSON.stringify(entry)).join("\n");
+  const contents = serialized.length > 0 ? `${serialized}
+` : "";
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      await writeFileAtomic(otelSpansQueuePath(globalPmRoot), contents);
+      return;
+    } catch (error) {
+      const retryDelay = TELEMETRY_QUEUE_REWRITE_RETRY_DELAYS_MS[attempt];
+      if (retryDelay === void 0 || !isRetryableQueueRewriteError(error)) {
+        throw error;
+      }
+      await sleep(retryDelay);
+    }
+  }
+}
+async function reconcilePendingOtelSpansAfterFlush(globalPmRoot, retentionDays, succeededIds, failedUpdates) {
+  return withQueueMutation(async () => {
+    const raw = await readFileIfExists(otelSpansQueuePath(globalPmRoot));
+    const current = raw === null ? [] : parsePendingOtelSpanLines(raw);
+    const reconciled = [];
+    for (const entry of current) {
+      if (succeededIds.has(entry.id)) {
+        continue;
+      }
+      const failure = failedUpdates.get(entry.id);
+      reconciled.push(failure ? { ...entry, attempts: failure.attempts, next_attempt_after: failure.next_attempt_after } : entry);
+    }
+    const { entries: retained } = prunePendingOtelSpans(reconciled, retentionDays);
+    await rewritePendingOtelSpans(globalPmRoot, retained);
+    return retained.length;
+  });
+}
+async function flushPendingOtelSpans(globalPmRoot, retentionDays) {
+  const raw = await readFileIfExists(otelSpansQueuePath(globalPmRoot));
+  if (raw === null || raw.trim().length === 0) {
+    await writeRuntimeState(globalPmRoot, { pending_otel_spans: 0 });
+    return;
+  }
+  const entries = parsePendingOtelSpanLines(raw);
+  const { entries: retained, prunedCount } = prunePendingOtelSpans(entries, retentionDays);
+  const due = retained.filter((entry) => isDueForRetryAt(entry.next_attempt_after)).slice(0, TELEMETRY_OTEL_SPANS_FLUSH_BATCH_SIZE);
+  if (due.length === 0) {
+    const remaining2 = prunedCount > 0 ? await reconcilePendingOtelSpansAfterFlush(globalPmRoot, retentionDays, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Map()) : retained.length;
+    await writeRuntimeState(globalPmRoot, { pending_otel_spans: remaining2 });
+    return;
+  }
+  const attemptTime = nowIso();
+  const succeededIds = /* @__PURE__ */ new Set();
+  const failedUpdates = /* @__PURE__ */ new Map();
+  let succeededCount = 0;
+  let lastError;
+  await Promise.all(due.map(async (span) => {
+    try {
+      const response = await fetch(span.endpoint, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(span.payload),
+        signal: AbortSignal.timeout(TELEMETRY_HTTP_TIMEOUT_MS)
+      });
+      if (!response.ok) {
+        throw new Error(`local_otel_export_http_${response.status}`);
+      }
+      succeededIds.add(span.id);
+      succeededCount += 1;
+    } catch (error) {
+      lastError = error instanceof Error ? sanitizeString(error.message, "redacted") : "local_otel_export_failed";
+      const nextAttempts = span.attempts + 1;
+      failedUpdates.set(span.id, { attempts: nextAttempts, next_attempt_after: nextRetryIso(nextAttempts) });
+    }
+  }));
+  const remaining = await reconcilePendingOtelSpansAfterFlush(globalPmRoot, retentionDays, succeededIds, failedUpdates);
+  const statePatch = {
+    pending_otel_spans: remaining,
+    last_otel_attempt_at: attemptTime
+  };
+  if (succeededCount > 0) {
+    statePatch.last_otel_success_at = attemptTime;
+  }
+  if (lastError !== void 0) {
+    statePatch.last_otel_failure_at = attemptTime;
+    statePatch.last_otel_failure_error = lastError;
+  } else if (remaining === 0) {
+    statePatch.last_otel_failure_at = void 0;
+    statePatch.last_otel_failure_error = void 0;
+  }
+  await writeRuntimeState(globalPmRoot, statePatch);
+}
+async function flushTelemetryArtifacts(globalPmRoot, endpoint, retentionDays) {
+  try {
+    await flushQueue(globalPmRoot, endpoint, retentionDays);
+  } catch {
+  }
+  try {
+    await flushPendingOtelSpans(globalPmRoot, retentionDays);
+  } catch {
+  }
+}
 async function cleanupTelemetryQueueTempOrphans(globalPmRoot, maxAgeMs = TELEMETRY_QUEUE_TMP_ORPHAN_MAX_AGE_MS) {
   try {
     const dirPath = telemetryRuntimeDirectory(globalPmRoot);
@@ -1084,10 +1249,16 @@ async function cleanupTelemetryQueueTempOrphans(globalPmRoot, maxAgeMs = TELEMET
   }
 }
 async function withQueueMutation(operation) {
-  const run = _queueMutationPromise.catch(() => {
-  }).then(operation);
-  _queueMutationPromise = run.catch(() => {
-  });
+  const run = _queueMutationPromise.catch(
+    /* c8 ignore next */
+    () => {
+    }
+  ).then(operation);
+  _queueMutationPromise = run.catch(
+    /* c8 ignore next */
+    () => {
+    }
+  );
   return run;
 }
 async function readCurrentQueueEntries(globalPmRoot) {
@@ -1150,9 +1321,7 @@ async function flushQueue(globalPmRoot, endpoint, retentionDays) {
   }
   const { entries: retainedEntries, prunedCount } = pruneExpiredQueueEntries(queueEntries, retentionDays);
   if (retainedEntries.length === 0) {
-    if (prunedCount > 0) {
-      await rewriteQueue(globalPmRoot, []);
-    }
+    await rewriteQueue(globalPmRoot, []);
     await writeRuntimeState(globalPmRoot, {
       endpoint: normalizedEndpoint,
       queue_entries: 0
@@ -1327,17 +1496,18 @@ async function flushQueueWithProcessLock(globalPmRoot, endpoint, retentionDays)
     return;
   }
   try {
-    await flushQueue(globalPmRoot, endpoint, retentionDays);
+    await flushTelemetryArtifacts(globalPmRoot, endpoint, retentionDays);
   } finally {
-    await rm(flushLockPath(globalPmRoot), { recursive: true, force: true }).catch(() => {
-    });
+    try {
+      await rm(flushLockPath(globalPmRoot), { recursive: true, force: true });
+    } catch {
+    }
   }
 }
 function scheduleTelemetryFlush(globalPmRoot, endpoint, retentionDays) {
   if (shouldFlushInline()) {
     const previousFlush = _lastFlushPromise;
-    const nextFlush = flushQueue(globalPmRoot, endpoint, retentionDays).catch(() => {
-    });
+    const nextFlush = flushTelemetryArtifacts(globalPmRoot, endpoint, retentionDays);
     _lastFlushPromise = Promise.allSettled([previousFlush, nextFlush]).then(() => {
     });
     return;
@@ -1494,14 +1664,16 @@ async function finishTelemetryCommand(activeCommand, outcome) {
       })
     };
     await enqueueTelemetryEvent(activeCommand.global_pm_root, event);
-    scheduleTelemetryFlush(activeCommand.global_pm_root, activeCommand.endpoint, activeCommand.retention_days);
-    void exportLocalOtelSpan(activeCommand, {
+    const otelRequest = buildOtelSpanRequest(activeCommand, {
       ...outcome,
       exit_code: normalizedExitCode,
       error_code: normalizedErrorCode,
       error_category: normalizedErrorCategory
-    }, finishedAt, durationMs).catch(() => {
-    });
+    }, finishedAt, durationMs);
+    if (otelRequest) {
+      await enqueuePendingOtelSpan(activeCommand.global_pm_root, otelRequest);
+    }
+    scheduleTelemetryFlush(activeCommand.global_pm_root, activeCommand.endpoint, activeCommand.retention_days);
   } catch {
   }
 }
@@ -1527,7 +1699,7 @@ async function emitTelemetryErrorEvent(context) {
       errorCode: context.error_code,
       errorMessage: context.error_message,
       exitCode: context.exit_code
-    })) ?? "unknown_error";
+    }));
     const normalizedErrorCategory = context.error_category ?? resolveTelemetryErrorCategory(normalizedErrorCode);
     const normalizedExitCode = normalizeTelemetryExitCode(context.exit_code, false);
     const normalizedCommand = context.command.trim().length > 0 ? context.command : "<unknown>";
@@ -1576,9 +1748,10 @@ export {
   deriveTelemetryCommandResolution,
   TELEMETRY_SCHEMA_VERSION,
   TELEMETRY_MAX_QUEUE_ENTRY_ATTEMPTS,
+  PM_TELEMETRY_SOURCE_CONTEXT_VALUES,
   flushTelemetryQueueNow,
   startTelemetryCommand,
   finishTelemetryCommand,
   emitTelemetryErrorEvent
 };
-//# sourceMappingURL=chunk-GKIZW7SM.js.map
+//# sourceMappingURL=chunk-764O7EUA.js.map