openxiangda 1.0.241 → 1.0.243

package/lib/cli.js

@@ -3698,6 +3698,29 @@ function deploymentQueueDetails(error) {
   return value;
 }
 
+function deploymentQueueWaitDecision(statusInput) {
+  const status = String(statusInput || '').trim().toLowerCase();
+  return {
+    status,
+    wait: status === 'running',
+    evidencePending: status === 'deployed',
+  };
+}
+
+function deploymentEvidencePendingError(deployment = {}) {
+  const deploymentId = String(deployment.deploymentId || deployment.id || '').trim();
+  const error = new Error(
+    `APP_DEPLOYMENT_EVIDENCE_PENDING: 目标环境部署 ${deploymentId || '-'} 已完成激活，当前为 deployed，待提交测试证据；请先执行 openxiangda release test --deployment ${deploymentId || '<id>'} --evidence-json <JSON|file>`
+  );
+  error.code = 'APP_DEPLOYMENT_EVIDENCE_PENDING';
+  error.data = {
+    deploymentId: deploymentId || null,
+    status: 'deployed',
+    nextAction: 'release test',
+  };
+  return error;
+}
+
 async function createApplicationDeploymentWhenAvailable(
   config,
   target,
@@ -3718,9 +3741,17 @@ async function createApplicationDeploymentWhenAvailable(
       );
     } catch (error) {
       const queue = deploymentQueueDetails(error);
-      if (!queue || Date.now() >= deadline || waitSeconds === 0) throw error;
+      if (!queue) throw error;
       const deploymentId = String(queue.deploymentId || '').trim();
       if (!deploymentId) throw error;
+      const queuedState = deploymentQueueWaitDecision(queue.status);
+      if (queuedState.evidencePending) {
+        throw deploymentEvidencePendingError({
+          ...queue,
+          deploymentId,
+        });
+      }
+      if (Date.now() >= deadline || waitSeconds === 0) throw error;
       const delaySeconds = Math.min(
         Math.max(Number(queue.retryAfterSeconds || 5), 1),
         30
@@ -3742,7 +3773,14 @@ async function createApplicationDeploymentWhenAvailable(
         } catch {
           break;
         }
-        if (!['running', 'deployed'].includes(active?.status)) break;
+        const activeState = deploymentQueueWaitDecision(active?.status);
+        if (activeState.evidencePending) {
+          throw deploymentEvidencePendingError({
+            ...active,
+            deploymentId,
+          });
+        }
+        if (!activeState.wait) break;
       }
       if (Date.now() >= deadline) {
         fail(
@@ -3990,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,
@@ -4004,11 +4317,40 @@ async function completeManagedDeployment(
       evidence: deployment.evidenceSummary || evidenceInput || null,
     };
   }
-  if (deployment.status !== 'deployed') {
+  if (!['deployed', 'failed'].includes(deployment.status)) {
     fail(
       `DEPLOYMENT_NOT_READY_FOR_COMPLETION: deployment ${deployment.id} 当前状态为 ${deployment.status}`
     );
   }
+  const reconciled = await requestWithAuth(
+    config,
+    target.profileName,
+    applicationDeploymentApiPath(
+      logicalAppCode,
+      deployment.id,
+      'reconcile'
+    ),
+    {
+      method: 'POST',
+      body: {
+        reason: 'bind final active AppRelease lineage before test evidence',
+      },
+    }
+  );
+  if (reconciled.status === 'succeeded') {
+    rememberTargetDeployment(target, reconciled);
+    return {
+      deployment: reconciled,
+      evidence: reconciled.evidenceSummary || evidenceInput || null,
+    };
+  }
+  if (reconciled.status !== 'deployed') {
+    fail(
+      `DEPLOYMENT_RECONCILIATION_NOT_CONFIRMED: deployment ${deployment.id} 恢复后状态为 ${reconciled.status}`
+    );
+  }
+  deployment = reconciled;
+  rememberTargetDeployment(target, deployment);
   const evidence = buildBoundDeploymentEvidence(
     evidenceInput,
     target,
@@ -4273,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}`
     );
   }
 
@@ -4360,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,
@@ -4627,26 +4982,14 @@ async function runApplicationEnvironmentReleaseCommand(
     const candidate = deployment.candidateId
       ? readCandidate(deployment.candidateId)
       : null;
-    const evidence = buildBoundDeploymentEvidence(
-      readJsonInput(flags['evidence-json'], 'evidence-json'),
+    return await completeManagedDeployment(
+      config,
       target,
+      logicalApp.code,
       deployment,
-      candidate
-    );
-    const completed = await requestWithAuth(
-      config,
-      target.profileName,
-      applicationDeploymentApiPath(logicalApp.code, deploymentId, 'complete'),
-      {
-        method: 'POST',
-        body: {
-          evidenceSummary: evidence,
-          evidenceHash: sha256Canonical(evidence),
-        },
-      }
+      candidate,
+      readJsonInput(flags['evidence-json'], 'evidence-json')
     );
-    rememberTargetDeployment(target, completed);
-    return { deployment: completed, evidence };
   }
 
   if (subcommand === 'rollback') {
@@ -30089,8 +30432,13 @@ function buildWorkspacePublishEnv(
 module.exports = {
   buildResourceManifestSddTargets,
   buildScopeGrantSourceSyncDecision,
+  deploymentEvidencePendingError,
+  deploymentQueueWaitDecision,
+  inspectSucceededPreproductionDeployment,
   main,
+  recoveredPreproductionShipPatch,
   resolveReleaseCommandScopedFiles,
+  selectSucceededPreproductionDeployment,
   resolveDeliveryV2BackendManifestReplacementIntent,
   resolveDataViewSourceFormCodes,
   satisfiedFormCodesFromContext,

package/package.json

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