@postman-cse/onboarding-repo-sync 2.1.1 → 2.1.3

package/dist/cli.cjs

@@ -125394,12 +125394,20 @@ async function retry(operation, options = {}) {
 }
 
 // src/lib/postman/postman-gateway-assets-client.ts
+var MAX_CREATE_FLIGHTS = 256;
+var createFlights = /* @__PURE__ */ new Map();
 var PostmanGatewayAssetsClient = class {
   gateway;
   workspaceId;
+  sleep;
+  reconcileAttempts;
+  reconcileDelayMs;
   constructor(options) {
     this.gateway = options.gateway;
     this.workspaceId = String(options.workspaceId || "").trim();
+    this.sleep = options.sleep ?? sleep;
+    this.reconcileAttempts = Math.max(1, options.reconcileAttempts ?? 3);
+    this.reconcileDelayMs = Math.max(0, options.reconcileDelayMs ?? 500);
   }
   asRecord(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) return null;
@@ -125429,8 +125437,64 @@ var PostmanGatewayAssetsClient = class {
     const parts = trimmed.split("-");
     return parts.length >= 6 ? parts.slice(1).join("-") : trimmed;
   }
-  isTransient(error) {
-    return error instanceof HttpError && (error.status === 429 || error.status >= 500);
+  isAmbiguousCreateOutcome(error) {
+    if (error instanceof HttpError) {
+      return error.status === 408 || error.status === 429 || error.status >= 500;
+    }
+    return error instanceof Error;
+  }
+  isRetryableIdempotentWriteOutcome(error) {
+    if (error instanceof HttpError) {
+      return error.status === 408 || error.status === 429 || error.status >= 500;
+    }
+    return error instanceof Error;
+  }
+  selectExactMatch(kind, identity, matches) {
+    if (matches.length > 1) {
+      const ids = matches.map((match) => match.uid).join(", ");
+      throw new Error(
+        `Multiple ${kind}s match ${identity}: ${ids}. Refusing to choose one; remove duplicates or pass an explicit asset ID.`
+      );
+    }
+    return matches[0] ?? null;
+  }
+  async singleFlight(key, fingerprint, kind, operation) {
+    const existing = createFlights.get(key);
+    if (existing) {
+      if (existing.fingerprint !== fingerprint) {
+        throw new Error(`Incompatible concurrent ${kind} create for ${key}`);
+      }
+      return existing.promise;
+    }
+    if (createFlights.size >= MAX_CREATE_FLIGHTS) {
+      throw new Error(`Too many concurrent Postman asset creates (limit ${MAX_CREATE_FLIGHTS})`);
+    }
+    const pending = operation().finally(() => {
+      if (createFlights.get(key)?.promise === pending) {
+        createFlights.delete(key);
+      }
+    });
+    createFlights.set(key, { fingerprint, promise: pending });
+    return pending;
+  }
+  async discoverAfterAmbiguousCreate(discover, error) {
+    if (!this.isAmbiguousCreateOutcome(error)) {
+      return null;
+    }
+    for (let attempt = 0; attempt < this.reconcileAttempts; attempt += 1) {
+      if (attempt > 0) {
+        await this.sleep(this.reconcileDelayMs);
+      }
+      const found = await discover();
+      if (found) {
+        return found;
+      }
+    }
+    return null;
+  }
+  publicEnvironmentUid(data, bareId) {
+    const owner = String(data?.owner ?? "").trim();
+    return owner && !bareId.startsWith(`${owner}-`) ? `${owner}-${bareId}` : bareId;
   }
   // --- environments (service: sync) ---
   //
@@ -125441,9 +125505,10 @@ var PostmanGatewayAssetsClient = class {
   /**
    * Create/upsert an environment through the sync service.
    * POST /environment/import?workspace=:ws { id:<uuid>, name, values } ->
-   * { data:{ id:<bare uuid>, owner } }. The id is generated once and reused
-   * across retries so the import is idempotent (a retry upserts the same
-   * environment instead of duplicating it).
+   * { data:{ id:<bare uuid>, owner } }. The id is generated once for the
+   * operation. Unsafe creates submit once (no blind retry); on an ambiguous
+   * response the client discovers by exact workspace-scoped name before
+   * failing.
    *
    * Returns the PUBLIC uid (`<owner>-<uuid>`), not the bare model id the sync
    * import echoes: mock/monitor create reference the environment by its public
@@ -125453,33 +125518,54 @@ var PostmanGatewayAssetsClient = class {
    */
   async createEnvironment(workspaceId, name, values) {
     const ws = workspaceId || this.workspaceId;
-    const id = crypto.randomUUID();
-    const body = {
-      id,
-      name,
-      values: values.map((v) => ({
-        key: v.key,
-        value: v.value,
-        type: v.type ?? "default",
-        enabled: v.enabled ?? true
-      }))
-    };
-    const response = await retry(
-      () => this.gateway.requestJson({
-        service: "sync",
-        method: "post",
-        path: `/environment/import?workspace=${ws}`,
-        body
-      }),
-      { maxAttempts: 5, delayMs: 2e3, backoffMultiplier: 2, maxDelayMs: 15e3, shouldRetry: (e) => this.isTransient(e) }
-    );
-    const data = this.dataOf(response);
-    const bareId = this.idOf(data);
-    if (!bareId) {
-      throw new Error("Environment import did not return a UID");
-    }
-    const owner = String(data?.owner ?? "").trim();
-    return owner && !bareId.startsWith(`${owner}-`) ? `${owner}-${bareId}` : bareId;
+    const envName = String(name ?? "").trim();
+    const flightKey = `environment:${ws}:${envName}`;
+    const normalizedValues = values.map((v) => ({
+      key: v.key,
+      value: v.value,
+      type: v.type ?? "default",
+      enabled: v.enabled ?? true
+    }));
+    return this.singleFlight(flightKey, JSON.stringify(normalizedValues), "environment", async () => {
+      const existing = await this.findEnvironmentByName(ws, envName);
+      if (existing?.uid) {
+        await this.updateEnvironment(existing.uid, envName, values);
+        return existing.uid;
+      }
+      const id = crypto.randomUUID();
+      const body = {
+        id,
+        name: envName,
+        values: normalizedValues
+      };
+      try {
+        const response = await this.gateway.requestJson(
+          {
+            service: "sync",
+            method: "post",
+            path: `/environment/import?workspace=${ws}`,
+            body
+          },
+          { retryTransient: false }
+        );
+        const data = this.dataOf(response);
+        const bareId = this.idOf(data);
+        if (!bareId) {
+          throw new Error("Environment import did not return a UID");
+        }
+        return this.publicEnvironmentUid(data, bareId);
+      } catch (error) {
+        const adopted = await this.discoverAfterAmbiguousCreate(async () => {
+          const match = await this.findEnvironmentByName(ws, envName);
+          return match?.uid ?? null;
+        }, error);
+        if (adopted) {
+          await this.updateEnvironment(adopted, envName, values);
+          return adopted;
+        }
+        throw error;
+      }
+    });
   }
   /**
    * Update an existing environment through the sync service.
@@ -125509,7 +125595,7 @@ var PostmanGatewayAssetsClient = class {
         path: `/environment/${id}`,
         body
       }),
-      { maxAttempts: 5, delayMs: 2e3, backoffMultiplier: 2, maxDelayMs: 15e3, shouldRetry: (e) => this.isTransient(e) }
+      { maxAttempts: 5, delayMs: 2e3, backoffMultiplier: 2, maxDelayMs: 15e3, shouldRetry: (e) => this.isRetryableIdempotentWriteOutcome(e) }
     );
   }
   /**
@@ -125533,13 +125619,37 @@ var PostmanGatewayAssetsClient = class {
    */
   async listEnvironments(workspaceId) {
     const ws = workspaceId || this.workspaceId;
-    const response = await this.gateway.requestJson({
-      service: "sync",
-      method: "post",
-      path: `/list/environment?workspace=${ws}`
-    });
+    const response = await this.gateway.requestJson(
+      {
+        service: "sync",
+        method: "post",
+        path: `/list/environment?workspace=${ws}`
+      },
+      { retryTransient: true }
+    );
     const items = Array.isArray(response?.data) ? response.data : [];
-    return items.map((raw) => this.asRecord(raw)).filter((e) => e !== null).map((e) => ({ name: String(e.name ?? ""), uid: this.idOf(e) }));
+    return items.map((raw) => this.asRecord(raw)).filter((e) => e !== null).map((e) => {
+      const bareOrPublic = this.idOf(e);
+      return {
+        name: String(e.name ?? ""),
+        uid: this.publicEnvironmentUid(e, bareOrPublic)
+      };
+    });
+  }
+  /** Exact name match within a workspace. Prefer tracked UIDs before calling. */
+  async findEnvironmentByName(workspaceId, name) {
+    const want = String(name ?? "").trim();
+    if (!want) {
+      return null;
+    }
+    const environments = await this.listEnvironments(workspaceId);
+    const matches = environments.filter((entry) => entry.name === want);
+    const match = this.selectExactMatch(
+      "environment",
+      `workspace ${workspaceId} and name "${want}"`,
+      matches
+    );
+    return match?.uid ? { uid: match.uid, name: match.name } : null;
   }
   // --- collection read (service: collection, v3 export) ---
   //
@@ -125569,32 +125679,51 @@ var PostmanGatewayAssetsClient = class {
   // --- mocks (service: mock) ---
   async createMock(workspaceId, name, collectionUid, environmentUid) {
     const ws = workspaceId || this.workspaceId;
+    const mockName = String(name ?? "").trim();
     const collection = String(collectionUid ?? "").trim();
     const environment = String(environmentUid ?? "").trim();
-    const body = {
-      name,
-      collection,
-      private: false,
-      ...environment ? { environment } : {}
-    };
-    const response = await retry(
-      () => this.gateway.requestJson({
-        service: "mock",
-        method: "post",
-        path: `/mocks?workspace=${ws}`,
-        body
-      }),
-      { maxAttempts: 5, delayMs: 2e3, backoffMultiplier: 2, maxDelayMs: 15e3, shouldRetry: (e) => this.isTransient(e) }
-    );
-    const record = this.dataOf(response);
-    const uid = this.idOf(record);
-    if (!uid) {
-      throw new Error("Mock create did not return a UID");
-    }
-    return {
-      uid,
-      url: String(record?.url ?? record?.mockUrl ?? "").trim()
-    };
+    const flightKey = `mock:${ws}:${collection}:${environment}:${mockName}`;
+    return this.singleFlight(flightKey, flightKey, "mock", async () => {
+      const existing = await this.findMockByCollection(collection, environment, mockName);
+      if (existing) {
+        return { uid: existing.uid, url: existing.mockUrl };
+      }
+      const body = {
+        name: mockName,
+        collection,
+        private: false,
+        ...environment ? { environment } : {}
+      };
+      try {
+        const response = await this.gateway.requestJson(
+          {
+            service: "mock",
+            method: "post",
+            path: `/mocks?workspace=${ws}`,
+            body
+          },
+          { retryTransient: false }
+        );
+        const record = this.dataOf(response);
+        const uid = this.idOf(record);
+        if (!uid) {
+          throw new Error("Mock create did not return a UID");
+        }
+        return {
+          uid,
+          url: String(record?.url ?? record?.mockUrl ?? "").trim()
+        };
+      } catch (error) {
+        const adopted = await this.discoverAfterAmbiguousCreate(
+          () => this.findMockByCollection(collection, environment, mockName),
+          error
+        );
+        if (adopted) {
+          return { uid: adopted.uid, url: adopted.mockUrl };
+        }
+        throw error;
+      }
+    });
   }
   async listMocks() {
     const response = await this.gateway.requestJson({
@@ -125623,10 +125752,19 @@ var PostmanGatewayAssetsClient = class {
       return false;
     }
   }
-  async findMockByCollection(collectionUid) {
+  async findMockByCollection(collectionUid, environmentUid, name) {
     const mocks = await this.listMocks();
     const want = String(collectionUid ?? "").trim();
-    const match = mocks.find((m) => m.collection === want);
+    const environment = String(environmentUid ?? "").trim();
+    const mockName = String(name ?? "").trim();
+    const matches = mocks.filter(
+      (mock) => mock.collection === want && mock.environment === environment && mock.name === mockName
+    );
+    const match = this.selectExactMatch(
+      "mock",
+      `workspace ${this.workspaceId}, name "${mockName}", collection ${want}, and environment ${environment || "(none)"}`,
+      matches
+    );
     return match ? { uid: match.uid, mockUrl: match.mockUrl } : null;
   }
   // --- monitors (service: monitors; collection-based = jobTemplates) ---
@@ -125643,32 +125781,51 @@ var PostmanGatewayAssetsClient = class {
   async createMonitor(workspaceId, name, collectionUid, environmentUid, cronSchedule) {
     const ws = workspaceId || this.workspaceId;
     const effectiveCron = cronSchedule && cronSchedule.trim() ? cronSchedule.trim() : "0 0 * * 0";
+    const monitorName = String(name ?? "").trim();
     const collection = String(collectionUid ?? "").trim();
     const environment = String(environmentUid ?? "").trim();
-    const body = {
-      name,
-      collection,
-      options: { strictSSL: false, followRedirects: true, requestTimeout: null, requestDelay: 0 },
-      notifications: { onFailure: [], onError: [] },
-      retry: {},
-      schedule: { cronPattern: effectiveCron, timeZone: "UTC" },
-      distribution: null,
-      ...environment ? { environment } : {}
-    };
-    const response = await retry(
-      () => this.gateway.requestJson({
-        service: "monitors",
-        method: "post",
-        path: `/jobTemplates?workspace=${ws}`,
-        body
-      }),
-      { maxAttempts: 5, delayMs: 2e3, backoffMultiplier: 2, maxDelayMs: 15e3, shouldRetry: (e) => this.isTransient(e) }
-    );
-    const uid = this.idOf(this.dataOf(response));
-    if (!uid) {
-      throw new Error("Monitor create did not return a UID");
-    }
-    return uid;
+    const flightKey = `monitor:${ws}:${collection}:${environment}:${monitorName}`;
+    return this.singleFlight(flightKey, effectiveCron, "monitor", async () => {
+      const existing = await this.findMonitorByCollection(collection, environment, monitorName);
+      if (existing?.uid) {
+        return existing.uid;
+      }
+      const body = {
+        name: monitorName,
+        collection,
+        options: { strictSSL: false, followRedirects: true, requestTimeout: null, requestDelay: 0 },
+        notifications: { onFailure: [], onError: [] },
+        retry: {},
+        schedule: { cronPattern: effectiveCron, timeZone: "UTC" },
+        distribution: null,
+        ...environment ? { environment } : {}
+      };
+      try {
+        const response = await this.gateway.requestJson(
+          {
+            service: "monitors",
+            method: "post",
+            path: `/jobTemplates?workspace=${ws}`,
+            body
+          },
+          { retryTransient: false }
+        );
+        const uid = this.idOf(this.dataOf(response));
+        if (!uid) {
+          throw new Error("Monitor create did not return a UID");
+        }
+        return uid;
+      } catch (error) {
+        const adopted = await this.discoverAfterAmbiguousCreate(
+          () => this.findMonitorByCollection(collection, environment, monitorName),
+          error
+        );
+        if (adopted?.uid) {
+          return adopted.uid;
+        }
+        throw error;
+      }
+    });
   }
   async listMonitors() {
     const response = await this.gateway.requestJson({
@@ -125691,24 +125848,30 @@ var PostmanGatewayAssetsClient = class {
       return false;
     }
   }
-  async findMonitorByCollection(collectionUid) {
+  async findMonitorByCollection(collectionUid, environmentUid, name) {
     const want = String(collectionUid ?? "").trim();
-    const response = await this.gateway.requestJson({
-      service: "monitors",
-      method: "get",
-      path: `/collections/${want}/jobTemplates?_etc=true`
-    });
-    const data = response?.data;
-    const monitors = this.mapJobTemplates(Array.isArray(data) ? data : []);
-    const match = monitors.find((m) => m.collectionUid === want) ?? monitors[0];
+    const environment = String(environmentUid ?? "").trim();
+    const monitorName = String(name ?? "").trim();
+    const monitors = await this.listMonitors();
+    const matches = monitors.filter(
+      (monitor) => monitor.collectionUid === want && monitor.environmentUid === environment && monitor.name === monitorName
+    );
+    const match = this.selectExactMatch(
+      "monitor",
+      `workspace ${this.workspaceId}, name "${monitorName}", collection ${want}, and environment ${environment || "(none)"}`,
+      matches
+    );
     return match?.uid ? { uid: match.uid, name: match.name } : null;
   }
   async runMonitor(uid) {
-    await this.gateway.requestJson({
-      service: "monitors",
-      method: "post",
-      path: `/jobTemplates/${uid}/jobs`
-    });
+    await this.gateway.requestJson(
+      {
+        service: "monitors",
+        method: "post",
+        path: `/jobTemplates/${uid}/jobs`
+      },
+      { retryTransient: false }
+    );
   }
 };
 
@@ -125874,12 +126037,8 @@ async function mintAccessTokenIfNeeded(inputs, log, setSecret2, fetchImpl = fetc
 function isExpiredAuthError(status, body) {
   return status === 401 || body.includes("UNAUTHENTICATED") || body.includes("authenticationError");
 }
-function isTransientGatewayError(status, body) {
-  if (status === 502 || status === 503 || status === 504) return true;
-  if (status >= 500 && (body.includes("ESOCKETTIMEDOUT") || body.includes("ETIMEDOUT") || body.includes("ECONNRESET") || body.includes("serverError") || body.includes("downstream"))) {
-    return true;
-  }
-  return false;
+function isRetryableSafeReadResponse(status) {
+  return status === 408 || status === 429 || status >= 500;
 }
 function defaultSleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
@@ -125938,14 +126097,28 @@ var AccessTokenGatewayClient = class {
   }
   /**
    * Send a gateway request, refreshing the token once on an auth failure and
-   * retrying transient downstream failures (5xx / Bifrost read timeouts) with
-   * exponential backoff. The auth-refresh-once path is independent of the
-   * transient-retry budget.
+   * optionally retrying transient downstream failures (5xx / Bifrost read
+   * timeouts) with exponential backoff. Safe reads keep transient retries;
+   * unsafe creates pass `{ retryTransient: false }` and reconcile after an
+   * ambiguous response instead of re-POSTing. Auth refresh remains independent
+   * of the transient-retry budget.
    */
-  async request(request) {
+  async request(request, options = {}) {
+    const retryTransient = options.retryTransient ?? request.method === "get";
     let attempt = 0;
     for (; ; ) {
-      let response = await this.send(request);
+      let response;
+      try {
+        response = await this.send(request);
+      } catch (error) {
+        if (retryTransient && attempt < this.maxRetries) {
+          const delay = this.retryBaseDelayMs * 2 ** attempt;
+          attempt += 1;
+          await this.sleepImpl(delay);
+          continue;
+        }
+        throw error;
+      }
       if (response.ok) {
         return response;
       }
@@ -125959,7 +126132,7 @@ var AccessTokenGatewayClient = class {
         const retryBody = await response.text().catch(() => "");
         throw this.toHttpError(request, response, retryBody);
       }
-      if (isTransientGatewayError(response.status, body) && attempt < this.maxRetries) {
+      if (retryTransient && isRetryableSafeReadResponse(response.status) && attempt < this.maxRetries) {
         const delay = this.retryBaseDelayMs * 2 ** attempt;
         attempt += 1;
         await this.sleepImpl(delay);
@@ -125969,8 +126142,8 @@ var AccessTokenGatewayClient = class {
     }
   }
   /** Send a gateway request and parse the JSON body, or null when empty. */
-  async requestJson(request) {
-    const response = await this.request(request);
+  async requestJson(request, options = {}) {
+    const response = await this.request(request, options);
     const text = await response.text().catch(() => "");
     if (!text.trim()) {
       return null;
@@ -126373,18 +126546,28 @@ async function upsertEnvironments(inputs, dependencies, resourcesState) {
   for (const envName of inputs.environments) {
     const runtimeUrl = String(inputs.envRuntimeUrls[envName] || "").trim();
     const values = buildEnvironmentValues(envName, runtimeUrl);
-    const existingUid = envUids[envName];
-    if (existingUid) {
-      await dependencies.postman.updateEnvironment(
-        existingUid,
-        `${inputs.projectName} - ${envName}`,
-        values
+    const displayName = `${inputs.projectName} - ${envName}`;
+    let existingUid = String(envUids[envName] || "").trim();
+    if (!existingUid) {
+      const discovered = await dependencies.postman.findEnvironmentByName(
+        inputs.workspaceId,
+        displayName
       );
+      if (discovered?.uid) {
+        existingUid = discovered.uid;
+        dependencies.core.info(
+          `Discovered existing environment for ${displayName}: ${existingUid}`
+        );
+      }
+    }
+    if (existingUid) {
+      await dependencies.postman.updateEnvironment(existingUid, displayName, values);
+      envUids[envName] = existingUid;
       continue;
     }
     envUids[envName] = await dependencies.postman.createEnvironment(
       inputs.workspaceId,
-      `${inputs.projectName} - ${envName}`,
+      displayName,
       values
     );
   }
@@ -126430,10 +126613,33 @@ function writeJsonFile(path5, content, normalize3 = false) {
   const data = normalize3 ? stripVolatileFields(content) : content;
   (0, import_node_fs3.writeFileSync)(path5, JSON.stringify(data, null, 2));
 }
-function buildResourcesManifest(workspaceId, collectionMap, envMap, artifactDir, localSpecRefs, mappedSpecRef, specId) {
-  const manifest = {
-    workspace: { id: workspaceId }
-  };
+function buildMappedSpecCloudKey(mappedSource, specSyncMode, releaseLabel) {
+  if (specSyncMode !== "version") {
+    return mappedSource;
+  }
+  const normalized = normalizeReleaseLabel(releaseLabel || "");
+  if (!normalized) {
+    return void 0;
+  }
+  return `${mappedSource}#release=${normalized}`;
+}
+function resolveDurableWorkspaceId(options) {
+  const { candidateId, priorId, workspaceLinkEnabled, workspaceLinkStatus } = options;
+  const candidate = candidateId.trim();
+  const prior = priorId?.trim() || void 0;
+  if (!workspaceLinkEnabled) {
+    return candidate || prior;
+  }
+  if (workspaceLinkStatus === "success") {
+    return candidate || void 0;
+  }
+  return prior === candidate ? prior : void 0;
+}
+function buildResourcesManifest(workspaceId, collectionMap, envMap, artifactDir, localSpecRefs, mappedSpecRef, specId, existingSpecs) {
+  const manifest = {};
+  if (workspaceId) {
+    manifest.workspace = { id: workspaceId };
+  }
   const localResources = {};
   const cloudResources = {};
   const collectionKeys = Object.keys(collectionMap);
@@ -126454,8 +126660,12 @@ function buildResourcesManifest(workspaceId, collectionMap, envMap, artifactDir,
   if (localSpecRefs.length > 0) {
     localResources.specs = localSpecRefs;
   }
+  const specs = { ...existingSpecs || {} };
   if (mappedSpecRef && specId) {
-    cloudResources.specs = { [mappedSpecRef]: specId };
+    specs[mappedSpecRef] = specId;
+  }
+  if (Object.keys(specs).length > 0) {
+    cloudResources.specs = specs;
   }
   if (Object.keys(localResources).length > 0) {
     manifest.localResources = localResources;
@@ -126522,7 +126732,7 @@ function assertPathWithinCwd(targetPath, fieldName) {
     throw new Error(`${fieldName} must stay within the repository root; received ${targetPath}`);
   }
 }
-async function exportArtifacts(inputs, dependencies, envUids, assetProjectName) {
+async function exportArtifacts(inputs, dependencies, envUids, assetProjectName, options) {
   if (!inputs.workspaceId) {
     return;
   }
@@ -126556,6 +126766,11 @@ async function exportArtifacts(inputs, dependencies, envUids, assetProjectName)
   const manifestCollections = {};
   const discoveredSpecs = scanLocalSpecReferences();
   const mappedSpec = resolveMappedSpecReference(inputs.specPath, discoveredSpecs);
+  const mappedSpecCloudKey = mappedSpec && inputs.specId ? buildMappedSpecCloudKey(
+    mappedSpec.configRelativePath,
+    inputs.specSyncMode,
+    options.releaseLabel
+  ) : void 0;
   if (inputs.baselineCollectionId) {
     const col = await dependencies.postman.getCollection(inputs.baselineCollectionId);
     const dirName = getCollectionDirectoryName("Baseline", assetProjectName);
@@ -126581,14 +126796,21 @@ async function exportArtifacts(inputs, dependencies, envUids, assetProjectName)
       true
     );
   }
+  const durableWorkspaceId = resolveDurableWorkspaceId({
+    candidateId: inputs.workspaceId,
+    priorId: options.priorWorkspaceId,
+    workspaceLinkEnabled: inputs.workspaceLinkEnabled,
+    workspaceLinkStatus: options.workspaceLinkStatus
+  });
   (0, import_node_fs3.writeFileSync)(".postman/resources.yaml", buildResourcesManifest(
-    inputs.workspaceId,
+    durableWorkspaceId,
     manifestCollections,
     envUids,
     inputs.artifactDir,
     discoveredSpecs.map((spec) => spec.configRelativePath),
-    mappedSpec?.configRelativePath,
-    inputs.specId || void 0
+    mappedSpecCloudKey,
+    inputs.specId || void 0,
+    options.existingSpecs
   ));
   if (mappedSpec && Object.keys(manifestCollections).length > 0) {
     (0, import_node_fs3.writeFileSync)(
@@ -126755,12 +126977,17 @@ async function runRepoSyncInner(inputs, dependencies) {
     const mockEnvUid = envUids.dev || envUids.prod || Object.values(envUids)[0];
     if (mockEnvUid) {
       let resolvedMockUrl = "";
+      const mockName = `${assetProjectName} Mock`;
       if (inputs.mockUrl) {
         resolvedMockUrl = inputs.mockUrl;
         dependencies.core.info(`Reusing mock from explicit input: ${resolvedMockUrl}`);
       }
       if (!resolvedMockUrl && inputs.baselineCollectionId) {
-        const discovered = await dependencies.postman.findMockByCollection(inputs.baselineCollectionId);
+        const discovered = await dependencies.postman.findMockByCollection(
+          inputs.baselineCollectionId,
+          mockEnvUid,
+          mockName
+        );
         if (discovered) {
           resolvedMockUrl = discovered.mockUrl;
           dependencies.core.info(`Discovered existing mock for collection ${inputs.baselineCollectionId}: ${resolvedMockUrl}`);
@@ -126769,7 +126996,7 @@ async function runRepoSyncInner(inputs, dependencies) {
       if (!resolvedMockUrl) {
         const mock = await dependencies.postman.createMock(
           inputs.workspaceId,
-          `${assetProjectName} Mock`,
+          mockName,
           inputs.baselineCollectionId,
           mockEnvUid
         );
@@ -126784,6 +127011,7 @@ async function runRepoSyncInner(inputs, dependencies) {
     const effectiveCron = inputs.monitorCron && inputs.monitorCron.trim() ? inputs.monitorCron.trim() : "";
     if (monitorEnvUid && inputs.monitorType !== "cli") {
       let resolvedMonitorId = "";
+      const monitorName = `${assetProjectName} - Smoke Monitor`;
       if (inputs.monitorId) {
         const valid = await dependencies.postman.monitorExists(inputs.monitorId);
         if (valid) {
@@ -126794,7 +127022,11 @@ async function runRepoSyncInner(inputs, dependencies) {
         }
       }
       if (!resolvedMonitorId && inputs.smokeCollectionId) {
-        const discovered = await dependencies.postman.findMonitorByCollection(inputs.smokeCollectionId);
+        const discovered = await dependencies.postman.findMonitorByCollection(
+          inputs.smokeCollectionId,
+          monitorEnvUid,
+          monitorName
+        );
         if (discovered) {
           resolvedMonitorId = discovered.uid;
           dependencies.core.info(`Discovered existing monitor for collection ${inputs.smokeCollectionId}: ${resolvedMonitorId}`);
@@ -126803,7 +127035,7 @@ async function runRepoSyncInner(inputs, dependencies) {
       if (!resolvedMonitorId) {
         resolvedMonitorId = await dependencies.postman.createMonitor(
           inputs.workspaceId,
-          `${assetProjectName} - Smoke Monitor`,
+          monitorName,
           inputs.smokeCollectionId,
           monitorEnvUid,
           effectiveCron || void 0
@@ -126837,7 +127069,12 @@ async function runRepoSyncInner(inputs, dependencies) {
       );
     }
   }
-  await exportArtifacts(inputs, dependencies, envUids, assetProjectName);
+  await exportArtifacts(inputs, dependencies, envUids, assetProjectName, {
+    workspaceLinkStatus: outputs["workspace-link-status"],
+    priorWorkspaceId: resourcesState?.workspace?.id,
+    existingSpecs: resourcesState?.cloudResources?.specs,
+    releaseLabel
+  });
   const commit = await commitAndPushGeneratedFiles(inputs, dependencies);
   outputs["commit-sha"] = commit.commitSha;
   if (commit.resolvedCurrentRef) {
@@ -127016,6 +127253,7 @@ function createRepoSyncDependencies(inputs, resolved, factories, options = {}) {
     createEnvironment: gatewayAssets.createEnvironment.bind(gatewayAssets),
     getEnvironment: gatewayAssets.getEnvironment.bind(gatewayAssets),
     updateEnvironment: gatewayAssets.updateEnvironment.bind(gatewayAssets),
+    findEnvironmentByName: gatewayAssets.findEnvironmentByName.bind(gatewayAssets),
     // Collection read via the v3 export endpoint — returns canonical v3 IR,
     // written to disk by `convertAndSplitAnyCollection`. PMAK is never used for
     // collection reads.