@pitcher/cli-scripts 2.2.0 → 2.2.2

package/dist/src/commands/publishApp.d.ts

@@ -9,6 +9,7 @@ interface PublishResult {
     installed?: string[];
     dryRun?: boolean;
     publishUrl?: string;
+    skipped?: boolean;
 }
 interface PublishOptions {
     folder?: string;

package/dist/src/commands/publishApp.js

@@ -13,6 +13,25 @@ import { createCliError } from '../core/errors.js';
 import { emitEnvelope, log } from '../core/output.js';
 const PUBLISH_PATH = '/api/v1/apps/publish/';
 const INSTANCES_PATH = '/api/v1/instances';
+/**
+ * The publish endpoint rejects re-publishing an existing version with a 400
+ * (`non_field_errors: ["An app release version X already exists."]`). That is a
+ * no-op, not a failure — the app is already live at that version — so deploy
+ * pipelines that re-run the publish step (workflow re-runs) must not hard-fail
+ * on it. Detect it so we can degrade to an idempotent success-with-warning.
+ */
+function isVersionAlreadyExistsError(e) {
+    const err = e;
+    if (err?.response?.status !== 400)
+        return false;
+    // Only the version-release conflict — which the API reports in DRF
+    // `non_field_errors` — is a benign no-op. Don't scan the whole body: an
+    // unrelated 400 that merely mentions "already exists" (e.g. a field-level
+    // name/identifier conflict when creating a NEW app) is a real failure.
+    const nonField = err.response?.data?.non_field_errors;
+    const messages = Array.isArray(nonField) ? nonField : typeof nonField === 'string' ? [nonField] : [];
+    return messages.some((m) => typeof m === 'string' && /version .* already exists/i.test(m));
+}
 function buildVersion(now) {
     const year = now.getFullYear();
     const month = String(now.getMonth() + 1).padStart(2, '0');
@@ -112,11 +131,28 @@ export async function runPublishApp(opts, deps = {}) {
             await zipDirectoryToFile(folderPath, zipPath);
             const form = new FormData();
             form.append('file', fs.createReadStream(zipPath));
-            const res = await client.post(publishTarget, form, {
-                headers: form.getHeaders(),
-                maxBodyLength: Infinity,
-                maxContentLength: Infinity,
-            });
+            let res;
+            try {
+                res = await client.post(publishTarget, form, {
+                    headers: form.getHeaders(),
+                    maxBodyLength: Infinity,
+                    maxContentLength: Infinity,
+                });
+            }
+            catch (publishError) {
+                // Idempotent re-publish: an existing version is already live, so this is
+                // a no-op, not a failure. Return ok with a warning instead of failing the
+                // command — otherwise deploy re-runs (which re-publish the same built
+                // version) break. Genuine errors still propagate to the outer catch.
+                if (isVersionAlreadyExistsError(publishError)) {
+                    warnings.push(`Skipped publish: ${toCliError(publishError).message}`);
+                    return ok({
+                        app: existingAppJson ? { name: existingAppJson.name, version: nextVersion } : undefined,
+                        skipped: true,
+                    }, warnings);
+                }
+                throw publishError;
+            }
             const app = res.data?.app;
             const result = { app };
             if (!app?.name) {

package/dist/src/core/http.d.ts

@@ -1,4 +1,11 @@
 import { type AxiosInstance } from 'axios';
 import { type CliError } from './errors.js';
 export declare function makeClient(baseUrl: string, apiKey: string): AxiosInstance;
+/**
+ * Build a human-readable message from a server error body. Handles DRF shapes:
+ * a `detail`/`error` string, `non_field_errors`, and field-level error arrays
+ * (e.g. `{ version: ["already exists"] }`). Falls back to the raw body so the
+ * full server response is visible in logs instead of a bare status line.
+ */
+export declare function extractApiMessage(data: unknown, fallback: string): string;
 export declare function toCliError(e: unknown): CliError;

package/dist/src/core/http.js

@@ -9,12 +9,39 @@ export function makeClient(baseUrl, apiKey) {
         },
     });
 }
+/**
+ * Build a human-readable message from a server error body. Handles DRF shapes:
+ * a `detail`/`error` string, `non_field_errors`, and field-level error arrays
+ * (e.g. `{ version: ["already exists"] }`). Falls back to the raw body so the
+ * full server response is visible in logs instead of a bare status line.
+ */
+export function extractApiMessage(data, fallback) {
+    if (data == null)
+        return fallback;
+    if (typeof data === 'string')
+        return data.trim() || fallback;
+    if (typeof data !== 'object')
+        return String(data);
+    const obj = data;
+    if (typeof obj.detail === 'string' && obj.detail)
+        return obj.detail;
+    if (typeof obj.error === 'string' && obj.error)
+        return obj.error;
+    const parts = [];
+    for (const [key, val] of Object.entries(obj)) {
+        const text = Array.isArray(val) ? val.join('; ') : typeof val === 'string' ? val : JSON.stringify(val);
+        parts.push(key === 'non_field_errors' ? text : `${key}: ${text}`);
+    }
+    if (parts.length)
+        return parts.join(' | ');
+    return fallback;
+}
 export function toCliError(e) {
     if (isCliError(e))
         return e;
     const err = (e ?? {});
     const data = err.response?.data;
-    const apiMessage = data?.detail || data?.error || err.message || 'Request failed';
+    const apiMessage = extractApiMessage(data, err.message || 'Request failed');
     const status = err.response?.status;
     if (typeof status === 'number') {
         if (status === 401 || status === 403)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pitcher/cli-scripts",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "The Pitcher CLI for various tasks in its ecosystem.",
   "author": "Pitcher AG",
   "license": "MIT",