@saptools/cf-live-trace 0.1.4 → 0.1.6

package/dist/cli.js

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
 
+// src/cli.ts
+import process4 from "process";
+
 // src/cli/program.ts
 import process3 from "process";
 import { Command } from "commander";
@@ -52,16 +55,16 @@ async function ensureSshEnabled(target, dependencies = defaultCfDependencies) {
     timeoutMs: CF_SSH_READY_TIMEOUT_MS
   });
 }
-async function tryStartNodeInspector(target, dependencies = defaultCfDependencies) {
+async function startNodeInspector(target, dependencies = defaultCfDependencies) {
+  const redactor = createSecretRedactor([target.email, target.password]);
   try {
-    const redactor = createSecretRedactor([target.email, target.password]);
     const stdout = await dependencies.runCf(
       buildCfSshArgs(target.app, target.instanceIndex, ["-c", buildInspectorSignalCommand()]),
       { ...buildRunOptions(target, redactor), timeoutMs: INSPECTOR_SIGNAL_TIMEOUT_MS }
     );
-    return hasInspectorReadyMarker(stdout);
-  } catch {
-    return false;
+    return hasInspectorReadyMarker(stdout) ? { status: "ready" } : { status: "not-ready", ...optionalDetail(summarizeInspectorStartupOutput(stdout)) };
+  } catch (error) {
+    return { status: "not-ready", ...optionalDetail(redactor(formatErrorMessage(error))) };
   }
 }
 async function openInspectorTunnel(target, dependencies = defaultTunnelDependencies) {
@@ -109,6 +112,8 @@ function spawnPortForward(params) {
     env: buildCfEnv(params.cfHomeDir),
     stdio: ["ignore", "pipe", "pipe"]
   });
+  child.stdout.resume();
+  child.stderr.resume();
   return {
     process: child,
     localPort: params.localPort,
@@ -216,6 +221,7 @@ function resolveTunnelAppName(target) {
   return appName;
 }
 async function raceForwardReadiness(handle, dependencies) {
+  const controller = new AbortController();
   let markFailed = () => {
     return;
   };
@@ -226,11 +232,14 @@ async function raceForwardReadiness(handle, dependencies) {
     handle.process.once("exit", markFailed);
     handle.process.once("error", markFailed);
   });
-  const ready = dependencies.waitForLocalPort(handle.localPort, TUNNEL_READY_TIMEOUT_MS);
-  const outcome = await Promise.race([ready, failedEarly]);
-  handle.process.removeListener("exit", markFailed);
-  handle.process.removeListener("error", markFailed);
-  return outcome;
+  const ready = dependencies.waitForLocalPort(handle.localPort, TUNNEL_READY_TIMEOUT_MS, controller.signal);
+  try {
+    return await Promise.race([ready, failedEarly]);
+  } finally {
+    controller.abort();
+    handle.process.removeListener("exit", markFailed);
+    handle.process.removeListener("error", markFailed);
+  }
 }
 function resolveCommand(command) {
   const resolvedBin = command ?? process.env["CF_LIVE_TRACE_CF_BIN"] ?? "cf";
@@ -258,7 +267,15 @@ function extractErrorDetail(error) {
   if (stderr.length > 0) {
     return stderr;
   }
-  return error["message"] instanceof Error ? error["message"].message : "";
+  const message = error["message"];
+  if (typeof message === "string") {
+    return message.trim();
+  }
+  return message instanceof Error ? message.message.trim() : "";
+}
+function formatErrorMessage(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.trim().length > 0 ? message.trim() : "Unknown error";
 }
 function formatArgs(args) {
   return args.join(" ");
@@ -266,6 +283,13 @@ function formatArgs(args) {
 function hasInspectorReadyMarker(stdout) {
   return stdout.split(/\r?\n/).map((line) => line.trim()).includes("saptools-inspector-ready");
 }
+function summarizeInspectorStartupOutput(stdout) {
+  const markers = stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.startsWith("saptools-inspector-"));
+  return markers.length === 0 ? void 0 : markers.join("; ");
+}
+function optionalDetail(detail) {
+  return detail === void 0 || detail.length === 0 ? {} : { detail };
+}
 function findFreePort() {
   return new Promise((resolve, reject) => {
     const server = createServer();
@@ -283,29 +307,61 @@ function findFreePort() {
     });
   });
 }
-function waitForLocalPort(port, timeoutMs) {
+function waitForLocalPort(port, timeoutMs, signal) {
   const deadline = Date.now() + timeoutMs;
   return new Promise((resolve) => {
+    let activeSocket;
+    let settled = false;
+    let retryTimer;
+    const finish = (ready) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (retryTimer !== void 0) {
+        clearTimeout(retryTimer);
+      }
+      activeSocket?.destroy();
+      activeSocket = void 0;
+      signal?.removeEventListener("abort", onAbort);
+      resolve(ready);
+    };
+    const onAbort = () => {
+      finish(false);
+    };
     const attempt = () => {
+      if (settled) {
+        return;
+      }
       const socket = netConnect({ host: "127.0.0.1", port });
+      activeSocket = socket;
       socket.once("connect", () => {
         socket.destroy();
-        resolve(true);
+        activeSocket = void 0;
+        finish(true);
       });
       socket.once("error", () => {
-        retryPortProbe(socket, deadline, attempt, resolve);
+        activeSocket = void 0;
+        retryPortProbe(socket, deadline, attempt, finish, (timer) => {
+          retryTimer = timer;
+        });
       });
     };
+    if (signal?.aborted === true) {
+      finish(false);
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
     attempt();
   });
 }
-function retryPortProbe(socket, deadline, attempt, resolve) {
+function retryPortProbe(socket, deadline, attempt, finish, setRetryTimer) {
   socket.destroy();
   if (Date.now() >= deadline) {
-    resolve(false);
+    finish(false);
     return;
   }
-  setTimeout(attempt, TUNNEL_READY_POLL_MS);
+  setRetryTimer(setTimeout(attempt, TUNNEL_READY_POLL_MS));
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -579,7 +635,7 @@ function isRecord2(value) {
 
 // src/runtime-source.ts
 var CF_LIVE_TRACE_GLOBAL_NAME = "__SAPTOOLS_CF_LIVE_TRACE__";
-var CF_LIVE_TRACE_RUNTIME_VERSION = 1;
+var CF_LIVE_TRACE_RUNTIME_VERSION = 2;
 var CF_LIVE_TRACE_RUNTIME_SOURCE = `
 (() => {
   const name = '${CF_LIVE_TRACE_GLOBAL_NAME}';
@@ -776,15 +832,12 @@ var CF_LIVE_TRACE_RUNTIME_SOURCE = `
     status() {
       return { installed: state.installed, enabled: state.enabled, queueSize: state.queue.length, droppedCount: state.droppedCount, maxEvents: state.options.maxEvents };
     },
-    uninstall() {
+    async uninstall() {
       state.enabled = false;
-      const requireFn = loadRequire();
-      if (requireFn) {
-        const http = requireFn('http');
-        const https = requireFn('https');
-        if (state.originals.httpServerEmit && http && http.Server) http.Server.prototype.emit = state.originals.httpServerEmit;
-        if (state.originals.httpsServerEmit && https && https.Server) https.Server.prototype.emit = state.originals.httpsServerEmit;
-      }
+      const http = await loadModule('http');
+      const https = await loadModule('https');
+      if (state.originals.httpServerEmit && http && http.Server) http.Server.prototype.emit = state.originals.httpServerEmit;
+      if (state.originals.httpsServerEmit && https && https.Server) https.Server.prototype.emit = state.originals.httpsServerEmit;
       state.installed = false;
       return api.status();
     }
@@ -893,7 +946,7 @@ var DRAIN_TRANSPORT_BODY_LIMIT = 2e4;
 var defaultDependencies = {
   prepareCfSession,
   ensureSshEnabled,
-  tryStartNodeInspector,
+  tryStartNodeInspector: startNodeInspector,
   openInspectorTunnel,
   connectInspector: connectRuntimeInspector,
   setInterval,
@@ -924,6 +977,9 @@ var LiveTraceSession = class {
   async stop(options) {
     this.stopRequested = true;
     if (!this.isRunning()) {
+      if (this.state === "error" && options.reason === "error") {
+        return;
+      }
       this.postState("stopped", `Trace stopped (${options.reason}).`, false, false);
       return;
     }
@@ -946,9 +1002,11 @@ var LiveTraceSession = class {
     } catch (error) {
       this.log(`Live Trace startup failed for ${this.options.target.app}: ${formatError(error)}`);
       await this.stopRuntimeTrace(false);
+      const startupError = toStartupError(error);
       if (!this.shouldStop()) {
-        this.postState("error", "Runtime HTTP trace could not be started.", false, false);
+        this.postState("error", startupError.stateMessage, false, false);
       }
+      throw startupError;
     }
   }
   async startInspector(options) {
@@ -958,7 +1016,7 @@ var LiveTraceSession = class {
       return;
     }
     this.postState("starting-inspector", "Requesting Node Inspector startup.", false, false);
-    await this.dependencies.tryStartNodeInspector(this.options.target);
+    this.reportInspectorStartup(await this.dependencies.tryStartNodeInspector(this.options.target));
     if (this.shouldStop()) {
       return;
     }
@@ -972,8 +1030,10 @@ var LiveTraceSession = class {
       return;
     }
     if (tunnel.status !== "ready") {
-      this.postState("error", "Node Inspector is not reachable on 127.0.0.1:9229.", false, false);
-      return;
+      throw new LiveTraceStartupError(
+        "Node Inspector is not reachable on 127.0.0.1:9229.",
+        "Node Inspector is not reachable on 127.0.0.1:9229."
+      );
     }
     this.tunnelHandle = tunnel.handle;
     this.inspectorClient = await this.dependencies.connectInspector(tunnel.handle.localPort);
@@ -1044,11 +1104,27 @@ var LiveTraceSession = class {
     this.stopPolling();
     this.consecutiveDrainTimeouts = 0;
     const uninstalled = await this.stopInspectorHook(uninstallRuntimeHook);
-    await this.inspectorClient?.close();
+    await this.closeInspectorClient();
+    this.stopTunnel();
+    return uninstalled;
+  }
+  async closeInspectorClient() {
+    const client = this.inspectorClient;
     this.inspectorClient = void 0;
-    this.tunnelHandle?.stop();
+    try {
+      await client?.close();
+    } catch (error) {
+      this.log(`Live Trace inspector close failed for ${this.options.target.app}: ${formatError(error)}`);
+    }
+  }
+  stopTunnel() {
+    const tunnel = this.tunnelHandle;
     this.tunnelHandle = void 0;
-    return uninstalled;
+    try {
+      tunnel?.stop();
+    } catch (error) {
+      this.log(`Live Trace tunnel cleanup failed for ${this.options.target.app}: ${formatError(error)}`);
+    }
   }
   async stopInspectorHook(uninstallRuntimeHook) {
     if (this.inspectorClient === void 0) {
@@ -1092,6 +1168,21 @@ var LiveTraceSession = class {
   log(message) {
     this.options.onLog?.(message);
   }
+  reportInspectorStartup(result) {
+    const normalized = normalizeInspectorStartupResult(result);
+    if (normalized.status === "ready") {
+      return;
+    }
+    const detail = normalized.detail === void 0 ? "" : `: ${normalized.detail}`;
+    this.log(`Node Inspector startup was not confirmed for ${this.options.target.app}${detail}`);
+  }
+};
+var LiveTraceStartupError = class extends Error {
+  constructor(message, stateMessage, cause) {
+    super(message, cause === void 0 ? void 0 : { cause });
+    this.stateMessage = stateMessage;
+  }
+  stateMessage;
 };
 function resolveStartOptions(options) {
   return {
@@ -1114,6 +1205,19 @@ function isEvaluateTimeout(error) {
   const message = error instanceof Error ? error.message : String(error);
   return message.includes("Runtime.evaluate timed out");
 }
+function toStartupError(error) {
+  if (error instanceof LiveTraceStartupError) {
+    return error;
+  }
+  return new LiveTraceStartupError(
+    "Runtime HTTP trace could not be started.",
+    "Runtime HTTP trace could not be started.",
+    error
+  );
+}
+function normalizeInspectorStartupResult(result) {
+  return typeof result === "boolean" ? { status: result ? "ready" : "not-ready" } : result;
+}
 function formatError(error) {
   const message = error instanceof Error ? error.message : String(error);
   return message.trim().length > 0 ? message.trim() : "Unknown error";
@@ -1305,30 +1409,35 @@ async function main(argv) {
 }
 async function runTraceCommand(options) {
   const cfHome = await resolveCfHome(options);
-  const events = [];
-  const eventLimit = createEventLimit(options);
-  const session = new LiveTraceSession({
-    target: { ...options.target, cfHomeDir: cfHome.path },
-    onState: (event) => {
-      if (!options.quiet) {
-        writeProgress(event);
-      }
-    },
-    onLog: (message) => {
-      if (!options.quiet) {
-        writeLog(message);
+  try {
+    const events = [];
+    const eventLimit = createEventLimit(options);
+    const runtimeError = createRuntimeErrorStopWaiter();
+    const session = new LiveTraceSession({
+      target: { ...options.target, cfHomeDir: cfHome.path },
+      onState: (event) => {
+        if (!options.quiet) {
+          writeProgress(event);
+        }
+        runtimeError.report(event);
+      },
+      onLog: (message) => {
+        if (!options.quiet) {
+          writeLog(message);
+        }
+      },
+      onEvents: (batch) => {
+        handleEvents(batch, options, events);
+        eventLimit.check(events.length);
       }
-    },
-    onEvents: (batch) => {
-      handleEvents(batch, options, events);
-      eventLimit.check(events.length);
+    });
+    await runUntilStopped(session, options, eventLimit, runtimeError);
+    if (options.format === "json") {
+      writeJson({ events });
     }
-  });
-  await runUntilStopped(session, options, eventLimit.promise);
-  if (options.format === "json") {
-    writeJson({ events });
+  } finally {
+    await cfHome.dispose();
   }
-  await cfHome.dispose();
 }
 function handleEvents(batch, options, events) {
   for (const event of batch) {
@@ -1341,30 +1450,46 @@ function handleEvents(batch, options, events) {
     }
   }
 }
-async function runUntilStopped(session, options, eventLimit) {
+async function runUntilStopped(session, options, eventLimit, runtimeError) {
   const abort = createAbortPromise();
+  const duration = createDurationStopWaiter(options.limits.durationMs);
   let stopReason = "user";
+  let failed = false;
   try {
     await session.start(options.trace);
-    stopReason = await waitForStop(options, abort.promise, eventLimit);
+    stopReason = await waitForStop([abort, eventLimit, duration, runtimeError]);
+  } catch (error) {
+    failed = true;
+    throw error;
   } finally {
     abort.cleanup();
-    await session.stop({ uninstallRuntimeHook: options.uninstallOnExit, reason: stopReason });
+    duration.cleanup();
+    eventLimit.cleanup();
+    runtimeError.cleanup();
+    await session.stop({ uninstallRuntimeHook: options.uninstallOnExit, reason: failed ? "error" : stopReason });
   }
 }
-async function waitForStop(options, abort, eventLimit) {
-  const waits = [abort, eventLimit];
-  if (options.limits.durationMs !== void 0) {
-    waits.push(waitForDuration(options.limits.durationMs));
-  }
-  return await Promise.race(waits);
+async function waitForStop(waiters) {
+  return await Promise.race(waiters.map((waiter) => waiter.promise));
 }
-function waitForDuration(durationMs) {
-  return new Promise((resolve) => {
-    setTimeout(() => {
+function createDurationStopWaiter(durationMs) {
+  if (durationMs === void 0) {
+    return createNeverStopWaiter();
+  }
+  let timer;
+  const promise = new Promise((resolve) => {
+    timer = setTimeout(() => {
       resolve("duration");
     }, durationMs);
   });
+  return {
+    promise,
+    cleanup: () => {
+      if (timer !== void 0) {
+        clearTimeout(timer);
+      }
+    }
+  };
 }
 function createAbortPromise() {
   let resolveStop = () => {
@@ -1386,12 +1511,50 @@ function createAbortPromise() {
     }
   };
 }
+function createNeverStopWaiter() {
+  return {
+    promise: new Promise(() => {
+      return;
+    }),
+    cleanup: () => {
+      return;
+    }
+  };
+}
+function createRuntimeErrorStopWaiter() {
+  let hasStreamed = false;
+  let settled = false;
+  let rejectStop = () => {
+    return;
+  };
+  const promise = new Promise((_resolve, reject) => {
+    rejectStop = reject;
+  });
+  promise.catch(() => {
+    return;
+  });
+  return {
+    promise,
+    report: (event) => {
+      if (event.state === "streaming") {
+        hasStreamed = true;
+        return;
+      }
+      if (event.state !== "error" || !hasStreamed || settled) {
+        return;
+      }
+      settled = true;
+      rejectStop(new Error(event.message));
+    },
+    cleanup: () => {
+      settled = true;
+    }
+  };
+}
 function createEventLimit(options) {
   if (options.limits.maxEvents === void 0) {
     return {
-      promise: new Promise(() => {
-        return;
-      }),
+      ...createNeverStopWaiter(),
       check: () => {
         return;
       }
@@ -1409,6 +1572,9 @@ function createEventLimit(options) {
       if (options.limits.maxEvents !== void 0 && count >= options.limits.maxEvents) {
         resolveLimit("max-events");
       }
+    },
+    cleanup: () => {
+      return;
     }
   };
 }
@@ -1429,5 +1595,15 @@ async function resolveCfHome(options) {
 }
 
 // src/cli.ts
-await main(process.argv);
+try {
+  await main(process4.argv);
+} catch (error) {
+  process4.stderr.write(`[cf-live-trace] error: ${formatCliError(error)}
+`);
+  process4.exitCode = 1;
+}
+function formatCliError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.trim().length > 0 ? message.trim() : "Unknown error";
+}
 //# sourceMappingURL=cli.js.map