openxiangda 1.0.242 → 1.0.243

package/lib/cli.js

@@ -4028,6 +4028,281 @@ async function readManagedDeployment(
   return deployment;
 }
 
+function inspectSucceededPreproductionDeployment(
+  deployment,
+  context,
+  now = Date.now()
+) {
+  const candidate = context?.candidate || {};
+  const target = context?.target || {};
+  const currentAppReleaseId = String(
+    context?.currentAppReleaseId || ''
+  ).trim();
+  const evidence = deployment?.evidenceSummary;
+  const reasons = [];
+  if (deployment?.status !== 'succeeded') {
+    reasons.push('status_not_succeeded');
+  }
+  if (deployment?.kind !== 'deploy') {
+    reasons.push('kind_not_preproduction_deploy');
+  }
+  if (deployment?.candidateId !== candidate.id) {
+    reasons.push('candidate_mismatch');
+  }
+  if (deployment?.targetEnvironmentId !== target.environmentId) {
+    reasons.push('target_environment_mismatch');
+  }
+  if (!currentAppReleaseId) reasons.push('current_app_release_missing');
+  if (deployment?.targetAppReleaseId !== currentAppReleaseId) {
+    reasons.push('active_app_release_mismatch');
+  }
+  if (!deployment?.evidenceHash) reasons.push('evidence_hash_missing');
+  if (!evidence || typeof evidence !== 'object' || Array.isArray(evidence)) {
+    reasons.push('evidence_summary_missing');
+  } else {
+    if (sha256Canonical(evidence) !== deployment.evidenceHash) {
+      reasons.push('evidence_hash_mismatch');
+    }
+    if (evidence.outcome !== 'passed') reasons.push('evidence_not_passed');
+    if (evidence.deploymentId !== deployment.id) {
+      reasons.push('evidence_deployment_mismatch');
+    }
+    if (evidence.candidateId !== candidate.id) {
+      reasons.push('evidence_candidate_mismatch');
+    }
+    if (evidence.candidateHash !== candidate.candidateHash) {
+      reasons.push('evidence_candidate_hash_mismatch');
+    }
+    if ((evidence.testPlanHash || null) !== (candidate.testPlanHash || null)) {
+      reasons.push('evidence_test_plan_hash_mismatch');
+    }
+    if (evidence.environmentId !== target.environmentId) {
+      reasons.push('evidence_environment_mismatch');
+    }
+    if (evidence.environmentKind !== 'preproduction') {
+      reasons.push('evidence_environment_kind_mismatch');
+    }
+    if (evidence.appType !== target.appType) {
+      reasons.push('evidence_app_type_mismatch');
+    }
+    if (evidence.appReleaseId !== deployment.targetAppReleaseId) {
+      reasons.push('evidence_app_release_mismatch');
+    }
+    const validUntil = Date.parse(evidence.validUntil || '');
+    if (!Number.isFinite(validUntil) || validUntil <= now) {
+      reasons.push('evidence_expired');
+    }
+  }
+  return { accepted: reasons.length === 0, reasons };
+}
+
+function selectSucceededPreproductionDeployment(
+  deployments,
+  context,
+  now = Date.now()
+) {
+  const ordered = [...(deployments || [])].sort((left, right) => {
+    const rightCreated =
+      Date.parse(right?.createdAt || right?.finishedAt || '') || 0;
+    const leftCreated =
+      Date.parse(left?.createdAt || left?.finishedAt || '') || 0;
+    return rightCreated - leftCreated;
+  });
+  for (const deployment of ordered) {
+    const validation = inspectSucceededPreproductionDeployment(
+      deployment,
+      context,
+      now
+    );
+    if (validation.accepted) return deployment;
+  }
+  return null;
+}
+
+function managedPreproductionEvidenceLineage(
+  deployment,
+  candidate,
+  target
+) {
+  return {
+    deploymentId: deployment.id,
+    candidateId: candidate.id,
+    candidateHash: candidate.candidateHash,
+    testPlanHash: candidate.testPlanHash || null,
+    environmentId: target.environmentId,
+    environmentKind: target.environmentKind,
+    appType: target.appType,
+    appReleaseId: deployment.targetAppReleaseId,
+    evidenceHash: deployment.evidenceHash || null,
+  };
+}
+
+function recoveredPreproductionShipPatch(
+  resolution,
+  candidate,
+  target,
+  recoveredAt = new Date().toISOString()
+) {
+  const deployment = resolution.deployment;
+  return {
+    status: 'awaiting_production_confirmation',
+    preproductionDeploymentId: deployment.id,
+    preproductionAppReleaseId: deployment.targetAppReleaseId,
+    preproductionStatus: deployment.status,
+    preproductionEvidenceHash: deployment.evidenceHash,
+    preproductionEvidenceLineage: managedPreproductionEvidenceLineage(
+      deployment,
+      candidate,
+      target
+    ),
+    preproductionRecovery: {
+      status: 'recovered_from_candidate_history',
+      replacedDeploymentId: resolution.replacedDeploymentId,
+      replacedDeploymentStatus: resolution.replacedDeploymentStatus,
+      selectedDeploymentId: deployment.id,
+      recoveredAt,
+    },
+    failure: null,
+  };
+}
+
+async function resolvePreproductionDeploymentForAcceptance(
+  config,
+  target,
+  logicalAppCode,
+  originalDeploymentId,
+  candidate
+) {
+  await assertRemoteCandidateMatches(
+    config,
+    target,
+    logicalAppCode,
+    candidate
+  );
+  const status = await requestWithAuth(
+    config,
+    target.profileName,
+    environmentSetApiPath(logicalAppCode, '/status')
+  );
+  const targetStatus = (status?.environments || []).find(
+    environment =>
+      environment?.id === target.environmentId &&
+      environment?.kind === 'preproduction' &&
+      environment?.appType === target.appType
+  );
+  const currentAppReleaseId = String(
+    targetStatus?.heads?.appReleaseId || ''
+  ).trim();
+  if (!targetStatus || !currentAppReleaseId) {
+    fail(
+      `PREPRODUCTION_ACTIVE_HEAD_REQUIRED: 预发环境 ${target.environmentId} 缺少可验证的当前 AppRelease head`
+    );
+  }
+
+  let originalDeployment = null;
+  let originalReadError = null;
+  try {
+    originalDeployment = await readManagedDeployment(
+      config,
+      target,
+      logicalAppCode,
+      originalDeploymentId,
+      { full: true }
+    );
+  } catch (error) {
+    originalReadError = error;
+  }
+  const context = { candidate, target, currentAppReleaseId };
+  if (originalDeployment?.status === 'deployed') {
+    const identityMatches =
+      originalDeployment.kind === 'deploy' &&
+      originalDeployment.candidateId === candidate.id &&
+      originalDeployment.targetEnvironmentId === target.environmentId &&
+      originalDeployment.targetAppReleaseId === currentAppReleaseId;
+    if (identityMatches) {
+      return {
+        deployment: originalDeployment,
+        recovered: false,
+        currentAppReleaseId,
+      };
+    }
+  }
+  if (originalDeployment?.status === 'succeeded') {
+    const validation = inspectSucceededPreproductionDeployment(
+      originalDeployment,
+      context
+    );
+    if (validation.accepted) {
+      return {
+        deployment: originalDeployment,
+        recovered: false,
+        currentAppReleaseId,
+      };
+    }
+  }
+
+  const history = await requestWithAuth(
+    config,
+    target.profileName,
+    `${applicationDeploymentApiPath(logicalAppCode)}?limit=200`
+  );
+  const summaries = (Array.isArray(history) ? history : [])
+    .filter(
+      deployment =>
+        deployment?.id !== originalDeploymentId &&
+        deployment?.status === 'succeeded' &&
+        deployment?.kind === 'deploy' &&
+        deployment?.candidateId === candidate.id &&
+        deployment?.targetEnvironmentId === target.environmentId &&
+        deployment?.targetAppReleaseId === currentAppReleaseId
+    )
+    .sort((left, right) => {
+      const rightCreated = Date.parse(right?.createdAt || '') || 0;
+      const leftCreated = Date.parse(left?.createdAt || '') || 0;
+      return rightCreated - leftCreated;
+    });
+  const details = [];
+  for (const summary of summaries) {
+    const detail = await requestWithAuth(
+      config,
+      target.profileName,
+      `${applicationDeploymentApiPath(
+        logicalAppCode,
+        summary.id
+      )}?full=true`
+    );
+    details.push(detail);
+  }
+  const replacement = selectSucceededPreproductionDeployment(
+    details,
+    context
+  );
+  if (!replacement) {
+    const originalStatus = originalDeployment?.status || 'unreadable';
+    const error = new Error(
+      `PREPRODUCTION_NOT_READY_FOR_ACCEPTANCE: 预发 deployment ${originalDeploymentId} 当前状态为 ${originalStatus}，且未找到同 candidate、同环境、当前 AppRelease 和有效测试证据完全一致的 succeeded replacement`
+    );
+    error.code = 'PREPRODUCTION_NOT_READY_FOR_ACCEPTANCE';
+    error.data = {
+      originalDeploymentId,
+      originalStatus,
+      originalReadErrorCode: originalReadError?.code || null,
+      candidateId: candidate.id,
+      targetEnvironmentId: target.environmentId,
+      currentAppReleaseId,
+    };
+    throw error;
+  }
+  rememberTargetDeployment(target, replacement);
+  return {
+    deployment: replacement,
+    recovered: true,
+    replacedDeploymentId: originalDeploymentId,
+    replacedDeploymentStatus: originalDeployment?.status || 'unreadable',
+    currentAppReleaseId,
+  };
+}
+
 async function completeManagedDeployment(
   config,
   target,
@@ -4340,21 +4615,25 @@ async function runApplicationShipCommand(
   );
   const candidate = readCandidate(existingShip.candidateId);
   assertLocalCandidate(candidate);
-  let preproductionDeployment = await readManagedDeployment(
+  const preproductionResolution = await resolvePreproductionDeploymentForAcceptance(
     config,
     preproduction,
     logicalApp.code,
     existingShip.preproductionDeploymentId,
-    { full: true }
+    candidate
   );
-  if (
-    !['deployed', 'succeeded'].includes(
-      preproductionDeployment.status
-    ) ||
-    !preproductionDeployment.targetAppReleaseId
-  ) {
-    fail(
-      `PREPRODUCTION_NOT_READY_FOR_ACCEPTANCE: 预发 deployment ${preproductionDeployment.id} 当前状态为 ${preproductionDeployment.status}`
+  let preproductionDeployment = preproductionResolution.deployment;
+  if (preproductionResolution.recovered) {
+    writeManagedShip(
+      changeId,
+      recoveredPreproductionShipPatch(
+        preproductionResolution,
+        candidate,
+        preproduction
+      )
+    );
+    warn(
+      `预发验收已从同 candidate 的成功部署恢复: ${preproductionResolution.replacedDeploymentId} -> ${preproductionDeployment.id}`
     );
   }
 
@@ -4427,6 +4706,15 @@ async function runApplicationShipCommand(
   const promotionStartedAt = new Date().toISOString();
   writeManagedShip(changeId, {
     status: 'confirmed_for_production',
+    preproductionDeploymentId: preproductionDeployment.id,
+    preproductionAppReleaseId: preproductionDeployment.targetAppReleaseId,
+    preproductionStatus: preproductionDeployment.status,
+    preproductionEvidenceHash: preproductionDeployment.evidenceHash,
+    preproductionEvidenceLineage: managedPreproductionEvidenceLineage(
+      preproductionDeployment,
+      candidate,
+      preproduction
+    ),
     productionConfirmation: {
       status: 'confirmed',
       confirmedAt,
@@ -30146,8 +30434,11 @@ module.exports = {
   buildScopeGrantSourceSyncDecision,
   deploymentEvidencePendingError,
   deploymentQueueWaitDecision,
+  inspectSucceededPreproductionDeployment,
   main,
+  recoveredPreproductionShipPatch,
   resolveReleaseCommandScopedFiles,
+  selectSucceededPreproductionDeployment,
   resolveDeliveryV2BackendManifestReplacementIntent,
   resolveDataViewSourceFormCodes,
   satisfiedFormCodesFromContext,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openxiangda",
-  "version": "1.0.242",
+  "version": "1.0.243",
   "description": "OpenXiangda CLI, workspace build tools, runtime SDK, and form components.",
   "private": false,
   "bin": {