@saptools/cf-inspector 0.3.4 → 0.3.6

package/README.md

@@ -109,7 +109,7 @@ cf-inspector snapshot --port 9229 \
 | `--port <number>` | Local port the inspector or tunnel listens on. **Required** unless `--app/--region/--org/--space` are all set |
 | `--bp <file:line>` | **Required.** Source location to break at. Pass multiple times to race several locations — the first one to hit wins |
 | `--condition <expr>` | Only pause when this JS expression evaluates truthy in the paused frame. Errors in the condition are silently treated as `false` by V8 |
-| `--capture <expr,…>` | Top-level comma-separated expressions to evaluate in the paused frame; nested commas inside objects, arrays, calls, or strings are preserved |
+| `--capture <expr,…>` | Top-level comma-separated expressions to evaluate in the paused frame; nested commas inside objects, arrays, calls, or strings are preserved. Object results are materialized to JSON strings when serializable, with fallback to CDP descriptions for non-serializable values |
 | `--timeout <seconds>` | How long to wait for the breakpoint to hit (default: `30`) |
 | `--remote-root <value>` | Optional path-mapping anchor: literal path or `regex:<pattern>` / `/pattern/flags` |
 | `--no-json` | Print a human-readable summary instead of JSON |

package/dist/cli.js

@@ -1232,6 +1232,123 @@ function evalResultToCaptured(expression, result) {
   }
   return buildCaptured("undefined");
 }
+function objectIdFromEvalResult(result) {
+  const inner = result.result;
+  if (inner?.type !== "object") {
+    return void 0;
+  }
+  const objectId = inner.objectId;
+  if (typeof objectId !== "string" || objectId.length === 0) {
+    return void 0;
+  }
+  return objectId;
+}
+function parseQuotedString(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return typeof parsed === "string" ? parsed : value;
+  } catch {
+    return value;
+  }
+}
+function parseNumericIndex(name) {
+  const parsed = Number.parseInt(name, 10);
+  if (!Number.isInteger(parsed) || parsed < 0 || parsed.toString() !== name) {
+    return void 0;
+  }
+  return parsed;
+}
+function scalarFromVariable(variable) {
+  const value = variable.value;
+  if (variable.type === "string") {
+    return parseQuotedString(value);
+  }
+  if (variable.type === "number") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : value;
+  }
+  if (variable.type === "boolean") {
+    if (value === "true") {
+      return true;
+    }
+    if (value === "false") {
+      return false;
+    }
+  }
+  if (variable.type === "undefined") {
+    return "[undefined]";
+  }
+  if (variable.type === "bigint") {
+    return value;
+  }
+  return value === "null" ? null : value;
+}
+function toStructuredValue(variable) {
+  const children = variable.children;
+  if (children === void 0 || children.length === 0) {
+    return scalarFromVariable(variable);
+  }
+  const indexed = children.flatMap((child) => {
+    const index = parseNumericIndex(child.name);
+    if (index === void 0) {
+      return [];
+    }
+    return [[index, toStructuredValue(child)]];
+  });
+  if (indexed.length > 0) {
+    const maxIndex = Math.max(...indexed.map(([index]) => index));
+    const out2 = Array.from({ length: maxIndex + 1 }, () => null);
+    for (const [index, entry] of indexed) {
+      out2[index] = entry;
+    }
+    return out2;
+  }
+  const out = {};
+  for (const child of children) {
+    out[child.name] = toStructuredValue(child);
+  }
+  return out;
+}
+async function renderObjectCapture(session, objectId) {
+  try {
+    const properties = await captureProperties(session, objectId, MAX_SCOPE_VARIABLES, MAX_VARIABLE_DEPTH);
+    const structured = {};
+    for (const variable of properties) {
+      structured[variable.name] = toStructuredValue(variable);
+    }
+    return JSON.stringify(structured);
+  } catch {
+    return void 0;
+  }
+}
+function normalizeRenderedObjectCapture(rendered, original) {
+  if (rendered === "{}" && original !== "Object") {
+    return void 0;
+  }
+  if (original.startsWith("Array(") && rendered === '{"length":0}') {
+    return "[]";
+  }
+  return rendered;
+}
+async function withSerializedObjectCapture(session, expression, evalResult, captured) {
+  if (captured.error !== void 0 || captured.value === void 0) {
+    return captured;
+  }
+  const objectId = objectIdFromEvalResult(evalResult);
+  if (objectId === void 0) {
+    return captured;
+  }
+  const rendered = await renderObjectCapture(session, objectId);
+  if (rendered === void 0) {
+    return captured;
+  }
+  const normalized = normalizeRenderedObjectCapture(rendered, captured.value);
+  if (normalized === void 0) {
+    return captured;
+  }
+  const value = sanitizeValue(expression, normalized);
+  return captured.type === void 0 ? { expression, value } : { expression, value, type: captured.type };
+}
 async function captureSnapshot(session, pause, options = {}) {
   const top = pause.callFrames[0];
   let topFrame;
@@ -1250,7 +1367,8 @@ async function captureSnapshot(session, pause, options = {}) {
         options.captures.map(async (expression) => {
           try {
             const result = await evaluateOnFrame(session, top.callFrameId, expression);
-            return evalResultToCaptured(expression, result);
+            const captured = evalResultToCaptured(expression, result);
+            return await withSerializedObjectCapture(session, expression, result, captured);
           } catch (err) {
             const message = err instanceof Error ? err.message : String(err);
             return { expression, error: message };