@plune-ai/cli 0.16.0 → 0.17.1

package/dist/reporter-core.d.cts

@@ -50,11 +50,17 @@ interface Attachment {
     url: string;
     contentType?: string;
 }
-/** A file the runner kept for an attempt, where it lies on this machine. */
+/**
+ * A file the runner kept for an attempt: where it lies on this machine, or — for a text a test attached as
+ * a `body`, which leaves no file — the bytes themselves. Playwright gives one of the two; were both here,
+ * the bytes are what is sent.
+ */
 interface ResultFile {
     name: string;
     contentType?: string;
-    path: string;
+    path?: string;
+    /** Only a JSON or a plain text — the types the platform keeps as a text; see `filesOf`. */
+    body?: Buffer;
 }
 /** One assertion's outcome, in the shape the platform already stores for its own runner. */
 interface AssertionRecord {
@@ -117,7 +123,8 @@ interface PendingResult {
     /**
      * The files the runner kept for this attempt, passed or not — built by `filesOf`. Never part of a
      * batch: the paths are this machine's. Once the platform has accepted the result, the core uploads
-     * the screenshots among them to it (platform ADR 0040).
+     * the screenshots and the text files among them to it (platform ADR 0040) — never a body to the
+     * fallback file either, which keeps a file by its path and leaves the bytes out.
      */
     files?: ResultFile[];
 }
@@ -137,8 +144,8 @@ interface FailureDetail {
         line: number;
         column?: number;
     };
-    /** The files the runner kept for the attempt, by name. The screenshots among them are uploaded to the
-     * result besides (`files`); the rest stay in the CI run. */
+    /** The files the runner kept for the attempt, by name. The screenshots and text files among them are
+     * uploaded to the result besides (`files`); the rest stay in the CI run. */
     artifacts?: {
         name: string;
         contentType?: string;
@@ -177,11 +184,13 @@ interface FailedAttempt {
     errors: AttemptError[];
     /** The declared steps, outermost first — as the JSON report keeps them. */
     steps: DeclaredStep[];
-    /** What the runner kept; `path` is what makes one a file. */
+    /** What the runner kept; `path` is what makes one a file, and a `body` — the bytes of a test's own
+     * attachment — is one to the platform only as a text. */
     attachments: {
         name: string;
         contentType?: string;
         path?: string;
+        body?: Buffer;
     }[];
     /** `metadata.ci.buildHref` of the run — the CI run that produced the report. */
     buildHref?: string;
@@ -268,6 +277,25 @@ interface RunStats extends SubmitCounts {
         skipped: number;
         failed: number;
     };
+    /**
+     * The same for the JSON and plain-text files of the accepted results (plune-ai/plune#928): counted
+     * apart from the screenshots because the two have limits of their own — 512 KiB and ten a result against
+     * 2 MB and twenty — and a person reading "3 skipped" has to know which kind it was.
+     */
+    textFiles: {
+        uploaded: number;
+        skipped: number;
+        failed: number;
+    };
+    /**
+     * Every other file (a trace, a video, a page): only a project's bucket takes them (plune-ai/plune#946), so
+     * without one they are counted as skipped. With one, the summary adds all three kinds up.
+     */
+    otherFiles: {
+        uploaded: number;
+        skipped: number;
+        failed: number;
+    };
 }
 /** Everything the core needs to talk to a deployment. */
 interface ReporterConfig {
@@ -479,6 +507,11 @@ declare function errorContextOf(attempt: FailedAttempt, home?: string): string;
  * The files the runner kept for one attempt, whatever its status: a screenshot of a test that passed
  * is how a person sees what it checked (plune-ai/plune#913). Which of them the platform takes, the
  * session decides as it uploads — once, for both roads.
+ *
+ * A file is what has a `path`. What a test attached as a `body` leaves none — Playwright hands the bytes
+ * over and keeps nothing — so a JSON or a text is kept with its bytes (plune-ai/plune#928), and nothing
+ * else is: an image, a trace or a page is not taken from memory, and a suite whose screenshots are
+ * bodies must not hold them all until a batch is sent.
  */
 declare function filesOf(attempt: FailedAttempt): ResultFile[];
 /**
@@ -508,6 +541,26 @@ type ClientOutcome<T> = {
     kind: ClientFailureKind;
     status: number | null;
     detail: string;
+    code?: string;
+};
+/** What a PUT to a bucket carries: a file on disk, streamed at a length known beforehand, or bytes in memory. */
+type PutSource = {
+    path: string;
+    size: number;
+} | {
+    body: Buffer;
+};
+/**
+ * How a PUT ended. Never a URL, never a message: the link is a write key to someone's bucket, and the
+ * errors of the transports (`getaddrinfo ENOTFOUND <host>`, `no answer from <origin>`) name the host. All
+ * that survives is a status and a short code.
+ */
+type PutOutcome = {
+    ok: true;
+} | {
+    ok: false;
+    status: number | null;
+    code: string;
 };
 interface ClientOptions {
     apiUrl: string;
@@ -530,6 +583,12 @@ interface PlatformClient {
      * a proxy error page that echoes the request would put a token in a CI log.
      */
     del<T>(path: string): Promise<ClientOutcome<T>>;
+    /**
+     * The bytes to a short-lived link of the customer's bucket (plune-ai/plune#946): exactly the headers the
+     * link came with, no token of ours. Network failures and 5xx wait and try again, up to three times; a 403
+     * (the link has expired) comes back at once, for the caller to ask for a new one.
+     */
+    put(url: string, headers: Record<string, string>, source: PutSource): Promise<PutOutcome>;
 }
 declare function createClient(opts: ClientOptions): PlatformClient;
 

package/dist/reporter-core.d.ts

@@ -50,11 +50,17 @@ interface Attachment {
     url: string;
     contentType?: string;
 }
-/** A file the runner kept for an attempt, where it lies on this machine. */
+/**
+ * A file the runner kept for an attempt: where it lies on this machine, or — for a text a test attached as
+ * a `body`, which leaves no file — the bytes themselves. Playwright gives one of the two; were both here,
+ * the bytes are what is sent.
+ */
 interface ResultFile {
     name: string;
     contentType?: string;
-    path: string;
+    path?: string;
+    /** Only a JSON or a plain text — the types the platform keeps as a text; see `filesOf`. */
+    body?: Buffer;
 }
 /** One assertion's outcome, in the shape the platform already stores for its own runner. */
 interface AssertionRecord {
@@ -117,7 +123,8 @@ interface PendingResult {
     /**
      * The files the runner kept for this attempt, passed or not — built by `filesOf`. Never part of a
      * batch: the paths are this machine's. Once the platform has accepted the result, the core uploads
-     * the screenshots among them to it (platform ADR 0040).
+     * the screenshots and the text files among them to it (platform ADR 0040) — never a body to the
+     * fallback file either, which keeps a file by its path and leaves the bytes out.
      */
     files?: ResultFile[];
 }
@@ -137,8 +144,8 @@ interface FailureDetail {
         line: number;
         column?: number;
     };
-    /** The files the runner kept for the attempt, by name. The screenshots among them are uploaded to the
-     * result besides (`files`); the rest stay in the CI run. */
+    /** The files the runner kept for the attempt, by name. The screenshots and text files among them are
+     * uploaded to the result besides (`files`); the rest stay in the CI run. */
     artifacts?: {
         name: string;
         contentType?: string;
@@ -177,11 +184,13 @@ interface FailedAttempt {
     errors: AttemptError[];
     /** The declared steps, outermost first — as the JSON report keeps them. */
     steps: DeclaredStep[];
-    /** What the runner kept; `path` is what makes one a file. */
+    /** What the runner kept; `path` is what makes one a file, and a `body` — the bytes of a test's own
+     * attachment — is one to the platform only as a text. */
     attachments: {
         name: string;
         contentType?: string;
         path?: string;
+        body?: Buffer;
     }[];
     /** `metadata.ci.buildHref` of the run — the CI run that produced the report. */
     buildHref?: string;
@@ -268,6 +277,25 @@ interface RunStats extends SubmitCounts {
         skipped: number;
         failed: number;
     };
+    /**
+     * The same for the JSON and plain-text files of the accepted results (plune-ai/plune#928): counted
+     * apart from the screenshots because the two have limits of their own — 512 KiB and ten a result against
+     * 2 MB and twenty — and a person reading "3 skipped" has to know which kind it was.
+     */
+    textFiles: {
+        uploaded: number;
+        skipped: number;
+        failed: number;
+    };
+    /**
+     * Every other file (a trace, a video, a page): only a project's bucket takes them (plune-ai/plune#946), so
+     * without one they are counted as skipped. With one, the summary adds all three kinds up.
+     */
+    otherFiles: {
+        uploaded: number;
+        skipped: number;
+        failed: number;
+    };
 }
 /** Everything the core needs to talk to a deployment. */
 interface ReporterConfig {
@@ -479,6 +507,11 @@ declare function errorContextOf(attempt: FailedAttempt, home?: string): string;
  * The files the runner kept for one attempt, whatever its status: a screenshot of a test that passed
  * is how a person sees what it checked (plune-ai/plune#913). Which of them the platform takes, the
  * session decides as it uploads — once, for both roads.
+ *
+ * A file is what has a `path`. What a test attached as a `body` leaves none — Playwright hands the bytes
+ * over and keeps nothing — so a JSON or a text is kept with its bytes (plune-ai/plune#928), and nothing
+ * else is: an image, a trace or a page is not taken from memory, and a suite whose screenshots are
+ * bodies must not hold them all until a batch is sent.
  */
 declare function filesOf(attempt: FailedAttempt): ResultFile[];
 /**
@@ -508,6 +541,26 @@ type ClientOutcome<T> = {
     kind: ClientFailureKind;
     status: number | null;
     detail: string;
+    code?: string;
+};
+/** What a PUT to a bucket carries: a file on disk, streamed at a length known beforehand, or bytes in memory. */
+type PutSource = {
+    path: string;
+    size: number;
+} | {
+    body: Buffer;
+};
+/**
+ * How a PUT ended. Never a URL, never a message: the link is a write key to someone's bucket, and the
+ * errors of the transports (`getaddrinfo ENOTFOUND <host>`, `no answer from <origin>`) name the host. All
+ * that survives is a status and a short code.
+ */
+type PutOutcome = {
+    ok: true;
+} | {
+    ok: false;
+    status: number | null;
+    code: string;
 };
 interface ClientOptions {
     apiUrl: string;
@@ -530,6 +583,12 @@ interface PlatformClient {
      * a proxy error page that echoes the request would put a token in a CI log.
      */
     del<T>(path: string): Promise<ClientOutcome<T>>;
+    /**
+     * The bytes to a short-lived link of the customer's bucket (plune-ai/plune#946): exactly the headers the
+     * link came with, no token of ours. Network failures and 5xx wait and try again, up to three times; a 403
+     * (the link has expired) comes back at once, for the caller to ask for a new one.
+     */
+    put(url: string, headers: Record<string, string>, source: PutSource): Promise<PutOutcome>;
 }
 declare function createClient(opts: ClientOptions): PlatformClient;