playwright-codegen-pro-core 1.0.0

package/lib/tools/trace/traceAttachments.js

@@ -0,0 +1,69 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var traceAttachments_exports = {};
+__export(traceAttachments_exports, {
+  traceAttachment: () => traceAttachment,
+  traceAttachments: () => traceAttachments
+});
+module.exports = __toCommonJS(traceAttachments_exports);
+var import_traceUtils = require("./traceUtils");
+async function traceAttachments() {
+  const trace = await (0, import_traceUtils.loadTrace)();
+  if (!trace.model.attachments.length) {
+    console.log("  No attachments");
+    return;
+  }
+  console.log(`  ${"#".padStart(4)} ${"Name".padEnd(40)} ${"Content-Type".padEnd(30)} ${"Action".padEnd(8)}`);
+  console.log(`  ${"\u2500".repeat(4)} ${"\u2500".repeat(40)} ${"\u2500".repeat(30)} ${"\u2500".repeat(8)}`);
+  for (let i = 0; i < trace.model.attachments.length; i++) {
+    const a = trace.model.attachments[i];
+    const actionOrdinal = trace.callIdToOrdinal.get(a.callId);
+    console.log(`  ${(i + 1 + ".").padStart(4)} ${a.name.padEnd(40)} ${a.contentType.padEnd(30)} ${(actionOrdinal !== void 0 ? String(actionOrdinal) : a.callId).padEnd(8)}`);
+  }
+}
+async function traceAttachment(attachmentId, options) {
+  const trace = await (0, import_traceUtils.loadTrace)();
+  const ordinal = parseInt(attachmentId, 10);
+  const attachment = !isNaN(ordinal) && ordinal >= 1 && ordinal <= trace.model.attachments.length ? trace.model.attachments[ordinal - 1] : void 0;
+  if (!attachment) {
+    console.error(`Attachment '${attachmentId}' not found. Use 'trace attachments' to see available attachments.`);
+    process.exitCode = 1;
+    return;
+  }
+  let content;
+  if (attachment.sha1) {
+    const blob = await trace.loader.resourceForSha1(attachment.sha1);
+    if (blob)
+      content = Buffer.from(await blob.arrayBuffer());
+  } else if (attachment.base64) {
+    content = Buffer.from(attachment.base64, "base64");
+  }
+  if (!content) {
+    console.error(`Could not extract attachment content.`);
+    process.exitCode = 1;
+    return;
+  }
+  const outFile = await (0, import_traceUtils.saveOutputFile)(attachment.name, content, options.output);
+  console.log(`  Attachment saved to ${outFile}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  traceAttachment,
+  traceAttachments
+});

package/lib/tools/trace/traceCli.js

@@ -0,0 +1,80 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var traceCli_exports = {};
+__export(traceCli_exports, {
+  addTraceCommands: () => addTraceCommands
+});
+module.exports = __toCommonJS(traceCli_exports);
+var import_traceOpen = require("./traceOpen");
+var import_traceActions = require("./traceActions");
+var import_traceRequests = require("./traceRequests");
+var import_traceConsole = require("./traceConsole");
+var import_traceErrors = require("./traceErrors");
+var import_traceSnapshot = require("./traceSnapshot");
+var import_traceScreenshot = require("./traceScreenshot");
+var import_traceAttachments = require("./traceAttachments");
+var import_installSkill = require("./installSkill");
+function addTraceCommands(program, logErrorAndExit) {
+  const traceCommand = program.command("trace").description("inspect trace files from the command line");
+  traceCommand.command("open <trace>").description("extract trace file for inspection").action((trace) => {
+    (0, import_traceOpen.traceOpen)(trace).catch(logErrorAndExit);
+  });
+  traceCommand.command("actions").description("list actions in the trace").option("--grep <pattern>", "filter actions by title pattern").option("--errors-only", "only show failed actions").action((options) => {
+    (0, import_traceActions.traceActions)(options).catch(logErrorAndExit);
+  });
+  traceCommand.command("action <action-id>").description("show details of a specific action").action((actionId) => {
+    (0, import_traceActions.traceAction)(actionId).catch(logErrorAndExit);
+  });
+  traceCommand.command("requests").description("show network requests").option("--grep <pattern>", "filter by URL pattern").option("--method <method>", "filter by HTTP method").option("--status <code>", "filter by status code").option("--failed", "only show failed requests (status >= 400)").action((options) => {
+    (0, import_traceRequests.traceRequests)(options).catch(logErrorAndExit);
+  });
+  traceCommand.command("request <request-id>").description("show details of a specific network request").action((requestId) => {
+    (0, import_traceRequests.traceRequest)(requestId).catch(logErrorAndExit);
+  });
+  traceCommand.command("console").description("show console messages").option("--errors-only", "only show errors").option("--warnings", "show errors and warnings").option("--browser", "only browser console messages").option("--stdio", "only stdout/stderr").action((options) => {
+    (0, import_traceConsole.traceConsole)(options).catch(logErrorAndExit);
+  });
+  traceCommand.command("errors").description("show errors with stack traces").action(() => {
+    (0, import_traceErrors.traceErrors)().catch(logErrorAndExit);
+  });
+  traceCommand.command("snapshot <action-id>").description("run a playwright-cli command against a DOM snapshot").option("--name <name>", "snapshot phase: before, input, or after").option("--serve", "serve snapshot on localhost and keep running").allowUnknownOption(true).allowExcessArguments(true).action(async (actionId, options, cmd) => {
+    try {
+      const browserArgs = cmd.args.slice(1);
+      await (0, import_traceSnapshot.traceSnapshot)(actionId, { ...options, browserArgs });
+    } catch (e) {
+      logErrorAndExit(e);
+    }
+  });
+  traceCommand.command("screenshot <action-id>").description("save screencast screenshot for an action").option("-o, --output <path>", "output file path").action((actionId, options) => {
+    (0, import_traceScreenshot.traceScreenshot)(actionId, options).catch(logErrorAndExit);
+  });
+  traceCommand.command("attachments").description("list trace attachments").action(() => {
+    (0, import_traceAttachments.traceAttachments)().catch(logErrorAndExit);
+  });
+  traceCommand.command("attachment <attachment-id>").description("extract a trace attachment by its number").option("-o, --output <path>", "output file path").action((attachmentId, options) => {
+    (0, import_traceAttachments.traceAttachment)(attachmentId, options).catch(logErrorAndExit);
+  });
+  traceCommand.command("install-skill").description("install SKILL.md for LLM integration").action(() => {
+    (0, import_installSkill.installSkill)().catch(logErrorAndExit);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addTraceCommands
+});

package/lib/tools/trace/traceConsole.js

@@ -0,0 +1,97 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var traceConsole_exports = {};
+__export(traceConsole_exports, {
+  traceConsole: () => traceConsole
+});
+module.exports = __toCommonJS(traceConsole_exports);
+var import_traceUtils = require("./traceUtils");
+async function traceConsole(options) {
+  const trace = await (0, import_traceUtils.loadTrace)();
+  const model = trace.model;
+  const items = [];
+  for (const event of model.events) {
+    if (event.type === "console") {
+      if (options.stdio)
+        continue;
+      const level = event.messageType;
+      if (options.errorsOnly && level !== "error")
+        continue;
+      if (options.warnings && level !== "error" && level !== "warning")
+        continue;
+      const url = event.location.url;
+      const filename = url ? url.substring(url.lastIndexOf("/") + 1) : "<anonymous>";
+      items.push({
+        type: "browser",
+        level,
+        text: event.text,
+        location: `${filename}:${event.location.lineNumber}`,
+        timestamp: event.time
+      });
+    }
+    if (event.type === "event" && event.method === "pageError") {
+      if (options.stdio)
+        continue;
+      const error = event.params.error;
+      items.push({
+        type: "browser",
+        level: "error",
+        text: error?.error?.message || String(error?.value || ""),
+        timestamp: event.time
+      });
+    }
+  }
+  for (const event of model.stdio) {
+    if (options.browser)
+      continue;
+    if (options.errorsOnly && event.type !== "stderr")
+      continue;
+    if (options.warnings && event.type !== "stderr")
+      continue;
+    let text = "";
+    if (event.text)
+      text = event.text.trim();
+    if (event.base64)
+      text = Buffer.from(event.base64, "base64").toString("utf-8").trim();
+    if (!text)
+      continue;
+    items.push({
+      type: event.type,
+      level: event.type === "stderr" ? "error" : "info",
+      text,
+      timestamp: event.timestamp
+    });
+  }
+  items.sort((a, b) => a.timestamp - b.timestamp);
+  if (!items.length) {
+    console.log("  No console entries");
+    return;
+  }
+  for (const item of items) {
+    const ts = (0, import_traceUtils.formatTimestamp)(item.timestamp, model.startTime);
+    const source = item.type === "browser" ? "[browser]" : `[${item.type}]`;
+    const level = item.level.padEnd(8);
+    const location = item.location ? `  ${item.location}` : "";
+    console.log(`  ${ts}  ${source.padEnd(10)} ${level} ${item.text}${location}`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  traceConsole
+});

package/lib/tools/trace/traceErrors.js

@@ -0,0 +1,55 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var traceErrors_exports = {};
+__export(traceErrors_exports, {
+  traceErrors: () => traceErrors
+});
+module.exports = __toCommonJS(traceErrors_exports);
+var import_traceUtils = require("./traceUtils");
+async function traceErrors() {
+  const trace = await (0, import_traceUtils.loadTrace)();
+  const model = trace.model;
+  if (!model.errorDescriptors.length) {
+    console.log("  No errors");
+    return;
+  }
+  for (const error of model.errorDescriptors) {
+    if (error.action) {
+      const title = (0, import_traceUtils.actionTitle)(error.action);
+      console.log(`
+  \u2717 ${title}`);
+    } else {
+      console.log(`
+  \u2717 Error`);
+    }
+    if (error.stack?.length) {
+      const frame = error.stack[0];
+      const file = frame.file.replace(/.*[/\\](.*)/, "$1");
+      console.log(`    at ${file}:${frame.line}:${frame.column}`);
+    }
+    console.log("");
+    const indented = error.message.split("\n").map((l) => `    ${l}`).join("\n");
+    console.log(indented);
+  }
+  console.log("");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  traceErrors
+});

package/lib/tools/trace/traceOpen.js

@@ -0,0 +1,69 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var traceOpen_exports = {};
+__export(traceOpen_exports, {
+  traceOpen: () => traceOpen
+});
+module.exports = __toCommonJS(traceOpen_exports);
+var import_traceUtils = require("./traceUtils");
+var import_formatUtils = require("../../utils/isomorphic/formatUtils");
+async function traceOpen(traceFile) {
+  await (0, import_traceUtils.openTrace)(traceFile);
+  await traceInfo();
+}
+async function traceInfo() {
+  const trace = await (0, import_traceUtils.loadTrace)();
+  const model = trace.model;
+  const info = {
+    browser: model.browserName || "unknown",
+    platform: model.platform || "unknown",
+    playwrightVersion: model.playwrightVersion || "unknown",
+    title: model.title || "",
+    duration: (0, import_formatUtils.msToString)(model.endTime - model.startTime),
+    durationMs: model.endTime - model.startTime,
+    startTime: model.wallTime ? new Date(model.wallTime).toISOString() : "unknown",
+    viewport: model.options.viewport ? `${model.options.viewport.width}x${model.options.viewport.height}` : "default",
+    actions: model.actions.length,
+    pages: model.pages.length,
+    network: model.resources.length,
+    errors: model.errorDescriptors.length,
+    attachments: model.attachments.length,
+    consoleMessages: model.events.filter((e) => e.type === "console").length
+  };
+  console.log("");
+  console.log(`  Browser:      ${info.browser}`);
+  console.log(`  Platform:     ${info.platform}`);
+  console.log(`  Playwright:   ${info.playwrightVersion}`);
+  if (info.title)
+    console.log(`  Title:        ${info.title}`);
+  console.log(`  Duration:     ${info.duration}`);
+  console.log(`  Start time:   ${info.startTime}`);
+  console.log(`  Viewport:     ${info.viewport}`);
+  console.log(`  Actions:      ${info.actions}`);
+  console.log(`  Pages:        ${info.pages}`);
+  console.log(`  Network:      ${info.network} requests`);
+  console.log(`  Errors:       ${info.errors}`);
+  console.log(`  Attachments:  ${info.attachments}`);
+  console.log(`  Console:      ${info.consoleMessages} messages`);
+  console.log("");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  traceOpen
+});

package/lib/tools/trace/traceParser.js

@@ -0,0 +1,96 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var traceParser_exports = {};
+__export(traceParser_exports, {
+  DirTraceLoaderBackend: () => DirTraceLoaderBackend,
+  extractTrace: () => extractTrace
+});
+module.exports = __toCommonJS(traceParser_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_zipFile = require("../../server/utils/zipFile");
+class DirTraceLoaderBackend {
+  constructor(dir) {
+    this._dir = dir;
+  }
+  isLive() {
+    return false;
+  }
+  async entryNames() {
+    const entries = [];
+    const walk = async (dir, prefix) => {
+      const items = await import_fs.default.promises.readdir(dir, { withFileTypes: true });
+      for (const item of items) {
+        if (item.isDirectory())
+          await walk(import_path.default.join(dir, item.name), prefix ? `${prefix}/${item.name}` : item.name);
+        else
+          entries.push(prefix ? `${prefix}/${item.name}` : item.name);
+      }
+    };
+    await walk(this._dir, "");
+    return entries;
+  }
+  async hasEntry(entryName) {
+    try {
+      await import_fs.default.promises.access(import_path.default.join(this._dir, entryName));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async readText(entryName) {
+    try {
+      return await import_fs.default.promises.readFile(import_path.default.join(this._dir, entryName), "utf-8");
+    } catch {
+    }
+  }
+  async readBlob(entryName) {
+    try {
+      const buffer = await import_fs.default.promises.readFile(import_path.default.join(this._dir, entryName));
+      return new Blob([new Uint8Array(buffer)]);
+    } catch {
+    }
+  }
+}
+async function extractTrace(traceFile, outDir) {
+  const zipFile = new import_zipFile.ZipFile(traceFile);
+  const entries = await zipFile.entries();
+  for (const entry of entries) {
+    const outPath = import_path.default.join(outDir, entry);
+    await import_fs.default.promises.mkdir(import_path.default.dirname(outPath), { recursive: true });
+    const buffer = await zipFile.read(entry);
+    await import_fs.default.promises.writeFile(outPath, buffer);
+  }
+  zipFile.close();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DirTraceLoaderBackend,
+  extractTrace
+});

package/lib/tools/trace/traceRequests.js

@@ -0,0 +1,158 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var traceRequests_exports = {};
+__export(traceRequests_exports, {
+  traceRequest: () => traceRequest,
+  traceRequests: () => traceRequests
+});
+module.exports = __toCommonJS(traceRequests_exports);
+var import_traceUtils = require("./traceUtils");
+var import_formatUtils = require("../../utils/isomorphic/formatUtils");
+async function traceRequests(options) {
+  const trace = await (0, import_traceUtils.loadTrace)();
+  const model = trace.model;
+  let indexed = model.resources.map((r, i) => ({ resource: r, ordinal: i + 1 }));
+  if (options.grep) {
+    const pattern = new RegExp(options.grep, "i");
+    indexed = indexed.filter(({ resource: r }) => pattern.test(r.request.url));
+  }
+  if (options.method)
+    indexed = indexed.filter(({ resource: r }) => r.request.method.toLowerCase() === options.method.toLowerCase());
+  if (options.status) {
+    const code = parseInt(options.status, 10);
+    indexed = indexed.filter(({ resource: r }) => r.response.status === code);
+  }
+  if (options.failed)
+    indexed = indexed.filter(({ resource: r }) => r.response.status >= 400 || r.response.status === -1);
+  if (!indexed.length) {
+    console.log("  No network requests");
+    return;
+  }
+  console.log(`  ${"#".padStart(4)} ${"Method".padEnd(8)} ${"Status".padEnd(8)} ${"Name".padEnd(45)} ${"Duration".padStart(10)} ${"Size".padStart(8)} ${"Route".padEnd(10)}`);
+  console.log(`  ${"\u2500".repeat(4)} ${"\u2500".repeat(8)} ${"\u2500".repeat(8)} ${"\u2500".repeat(45)} ${"\u2500".repeat(10)} ${"\u2500".repeat(8)} ${"\u2500".repeat(10)}`);
+  for (const { resource: r, ordinal } of indexed) {
+    let name;
+    try {
+      const url = new URL(r.request.url);
+      name = url.pathname.substring(url.pathname.lastIndexOf("/") + 1);
+      if (!name)
+        name = url.host;
+      if (url.search)
+        name += url.search;
+    } catch {
+      name = r.request.url;
+    }
+    if (name.length > 45)
+      name = name.substring(0, 42) + "...";
+    const status = r.response.status > 0 ? String(r.response.status) : "ERR";
+    const size = r.response._transferSize > 0 ? r.response._transferSize : r.response.bodySize;
+    const route = formatRouteStatus(r);
+    console.log(`  ${(ordinal + ".").padStart(4)} ${r.request.method.padEnd(8)} ${status.padEnd(8)} ${name.padEnd(45)} ${(0, import_formatUtils.msToString)(r.time).padStart(10)} ${bytesToString(size).padStart(8)} ${route.padEnd(10)}`);
+  }
+}
+async function traceRequest(requestId) {
+  const trace = await (0, import_traceUtils.loadTrace)();
+  const model = trace.model;
+  const ordinal = parseInt(requestId, 10);
+  const resource = !isNaN(ordinal) && ordinal >= 1 && ordinal <= model.resources.length ? model.resources[ordinal - 1] : void 0;
+  if (!resource) {
+    console.error(`Request '${requestId}' not found. Use 'trace requests' to see available request IDs.`);
+    process.exitCode = 1;
+    return;
+  }
+  const r = resource;
+  const status = r.response.status > 0 ? `${r.response.status} ${r.response.statusText}` : "ERR";
+  const size = r.response._transferSize > 0 ? r.response._transferSize : r.response.bodySize;
+  console.log(`
+  ${r.request.method} ${r.request.url}
+`);
+  console.log("  General");
+  console.log(`    status:    ${status}`);
+  console.log(`    duration:  ${(0, import_formatUtils.msToString)(r.time)}`);
+  console.log(`    size:      ${bytesToString(size)}`);
+  if (r.response.content.mimeType)
+    console.log(`    type:      ${r.response.content.mimeType}`);
+  const route = formatRouteStatus(r);
+  if (route)
+    console.log(`    route:     ${route}`);
+  if (r.serverIPAddress)
+    console.log(`    server:    ${r.serverIPAddress}${r._serverPort ? ":" + r._serverPort : ""}`);
+  if (r.response._failureText)
+    console.log(`    error:     ${r.response._failureText}`);
+  if (r.request.headers.length) {
+    console.log("\n  Request headers");
+    for (const h of r.request.headers)
+      console.log(`    ${h.name}: ${h.value}`);
+  }
+  if (r.request.postData) {
+    console.log("\n  Request body");
+    console.log(`    type: ${r.request.postData.mimeType}`);
+    if (r.request.postData.text) {
+      const text = r.request.postData.text.length > 2e3 ? r.request.postData.text.substring(0, 2e3) + "..." : r.request.postData.text;
+      console.log(`    ${text}`);
+    }
+  }
+  if (r.response.headers.length) {
+    console.log("\n  Response headers");
+    for (const h of r.response.headers)
+      console.log(`    ${h.name}: ${h.value}`);
+  }
+  if (r._securityDetails) {
+    console.log("\n  Security");
+    if (r._securityDetails.protocol)
+      console.log(`    protocol:  ${r._securityDetails.protocol}`);
+    if (r._securityDetails.subjectName)
+      console.log(`    subject:   ${r._securityDetails.subjectName}`);
+    if (r._securityDetails.issuer)
+      console.log(`    issuer:    ${r._securityDetails.issuer}`);
+  }
+  console.log("");
+}
+function bytesToString(bytes) {
+  if (bytes < 0 || !isFinite(bytes))
+    return "-";
+  if (bytes === 0)
+    return "0";
+  if (bytes < 1e3)
+    return bytes.toFixed(0);
+  const kb = bytes / 1024;
+  if (kb < 1e3)
+    return kb.toFixed(1) + "K";
+  const mb = kb / 1024;
+  if (mb < 1e3)
+    return mb.toFixed(1) + "M";
+  const gb = mb / 1024;
+  return gb.toFixed(1) + "G";
+}
+function formatRouteStatus(r) {
+  if (r._wasAborted)
+    return "aborted";
+  if (r._wasContinued)
+    return "continued";
+  if (r._wasFulfilled)
+    return "fulfilled";
+  if (r._apiRequest)
+    return "api";
+  return "";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  traceRequest,
+  traceRequests
+});