devops-whc 1.0.1 → 1.0.2-next

package/dist/handlers/whc-deploy.js

@@ -7,15 +7,7 @@ const whc_uapi_client_1 = require("../clients/whc-uapi-client");
 const deployment_locks_1 = require("../services/deployment-locks");
 const ssh_client_1 = require("../clients/ssh-client");
 const deploy_runtime_ops_1 = require("../services/deploy-runtime-ops");
-/**
- * Resolves the effective safety level for this deploy operation.
- * staging_to_live + database or everything → Level D.
- * All other writes remain at Level C.
- */
-function resolveDeploySafetyLevel(direction, syncScope) {
-    if (direction === "staging_to_live" && (syncScope === "database" || syncScope === "everything")) {
-        return "D";
-    }
+function resolveDeploySafetyLevel() {
     return "C";
 }
 async function executeWhcDeploy(config, request, deps = {}) {
@@ -26,90 +18,78 @@ async function executeWhcDeploy(config, request, deps = {}) {
     const lockService = deps.lockService ?? new deployment_locks_1.InMemoryDeploymentLockService();
     const verifyRunner = deps.verifyRunner ?? ((cfg, req) => (0, deploy_runtime_ops_1.runDeployVerification)(cfg, req, sshClient));
     const rollbackRunner = deps.rollbackRunner ?? ((cfg, req) => (0, deploy_runtime_ops_1.runDeployRollback)(cfg, req, uapiClient));
-    const { workflow_mode, target_environment, release_intent, pipeline_id, source_profile, direction, sync_scope, repository_root, branch, rollback_branch, backup_reference, allow_emergency_without_backup, verify_after_deploy, auto_rollback_on_verify_failure, lock_key, } = request.payload;
-    const effectiveSafetyLevel = resolveDeploySafetyLevel(direction, sync_scope);
-    const needsBackupGate = direction === "staging_to_live" && (sync_scope === "database" || sync_scope === "everything");
+    const { workflow_mode, target_environment, release_intent, pipeline_id, source_profile, repository_root, branch, direction, sync_scope, backup_reference, verify_after_deploy, auto_rollback_on_verify_failure, lock_key, } = request.payload;
+    const effectiveSafetyLevel = resolveDeploySafetyLevel();
     const shouldVerify = verify_after_deploy ?? false;
-    const deployLockKey = lock_key ?? buildDefaultLockKey(target_environment, workflow_mode, repository_root);
+    const deployLockKey = lock_key ?? `whc_deploy:${target_environment}:${workflow_mode}:${repository_root ?? "unset"}`;
     const lockOwner = request.request_id;
     const warnings = [];
-    if ((config.safety.enforceStagingFirst ?? true) && target_environment === "live") {
-        const isManagedPromoteFlow = workflow_mode === "managed_clone_sync" &&
-            direction === "staging_to_live" &&
-            release_intent === "promote";
-        if (!isManagedPromoteFlow) {
-            return buildErrorResponse(actionIdFactory(), startedAt, effectiveSafetyLevel, "BUSINESS_POLICY_BLOCKED", [
-                "Staging-first policy: direct live deploy is blocked.",
-                "Only promote flow from staging to live is allowed.",
-                "Required payload shape for live target:",
-                JSON.stringify({
-                    workflow_mode: "managed_clone_sync",
-                    target_environment: "live",
-                    release_intent: "promote",
-                    direction: "staging_to_live",
-                }, null, 2),
-            ].join("\n"));
-        }
-    }
-    if (target_environment === "staging" &&
-        config.workflowMode === "managed_clone_sync" &&
-        workflow_mode === "git_controlled" &&
-        !config.safety.allowStagingGitControlled) {
+    if ((config.safety.enforceStagingFirst ?? true) && workflow_mode === "git_deploy" && target_environment === "live" && release_intent !== "promote") {
         return buildErrorResponse(actionIdFactory(), startedAt, effectiveSafetyLevel, "BUSINESS_POLICY_BLOCKED", [
-            "Server mode lock: staging is configured as managed_clone_sync only (WHC_WORKFLOW_MODE=managed_clone_sync).",
-            "Request used workflow_mode='git_controlled' and was blocked to prevent cross-account deadlock loops.",
-            "Use this payload instead:",
-            JSON.stringify(buildStagingAlternativePayload(request), null, 2),
+            "Staging-first policy: direct live git deployment is blocked.",
+            "Only release_intent='promote' is allowed when target_environment='live'.",
         ].join("\n"));
     }
-    if (config.safety.warnDynamicDataSync && sync_scope === "database") {
-        warnings.push("DATABASE sync detected — existing data on target will be overwritten. Ensure a backup exists before proceeding.");
-    }
-    if (config.safety.warnDynamicDataSync && sync_scope === "everything") {
-        warnings.push("FULL sync (files + database) detected — all data on target will be replaced. This is irreversible without a backup.");
-    }
-    if (workflow_mode === "managed_clone_sync" && release_intent === "deploy" && direction === "live_to_staging") {
-        return buildErrorResponse(actionIdFactory(), startedAt, effectiveSafetyLevel, "BUSINESS_POLICY_BLOCKED", "Invalid deploy mindset: managed live_to_staging is an environment refresh, not a release deploy. Use release_intent='refresh' for live_to_staging, or deploy a release candidate to staging via git_controlled workflow.");
-    }
-    if (workflow_mode === "git_controlled" && repository_root) {
-        if (target_environment === "staging" && config.paths.staging && repository_root !== config.paths.staging) {
-            return buildErrorResponse(actionIdFactory(), startedAt, effectiveSafetyLevel, "BUSINESS_POLICY_BLOCKED", [
-                `Invalid staging target for git_controlled deploy: repository_root='${repository_root}' does not match WHC_STAGING_PATH='${config.paths.staging}'.`,
-                "This prevents accidental deploys to a live path while target_environment is staging.",
-                "Use the configured staging path, or switch to managed_clone_sync refresh for cross-account WHC staging.",
-                "Copy-ready payload using configured staging path:",
-                JSON.stringify(buildSuggestedStagingGitControlledPayload(request, config.paths.staging), null, 2),
-            ].join("\n"));
-        }
-        const pathOwner = extractHomeOwner(repository_root);
-        if (pathOwner && pathOwner !== config.user) {
-            const lines = [
-                `Path owner mismatch: repository_root belongs to '${pathOwner}' but WHC_USER is '${config.user}'.`,
-            ];
-            if (target_environment === "staging") {
-                lines.push("git_controlled via UAPI cannot deploy to a separate-account staging environment.", "WHC managed staging uses a different cPanel account and is not reachable via these credentials.", "Use managed_clone_sync + release_intent='refresh' + direction='live_to_staging' to sync the environment,", "then deploy your release candidate over SSH using whc_ssh_exec, or configure separate staging credentials.", "Suggested alternative payload (managed_clone_sync refresh):", JSON.stringify(buildStagingAlternativePayload(request), null, 2));
-            }
-            else {
-                const suggestedPayload = buildSuggestedDeployPayload(request, config.user);
-                lines.push(`Use /home/${config.user}/... for git_controlled deploy or switch credentials.`, "Copy-ready payload using current WHC_USER:", JSON.stringify(suggestedPayload, null, 2));
-            }
-            return buildErrorResponse(actionIdFactory(), startedAt, effectiveSafetyLevel, "BUSINESS_POLICY_BLOCKED", lines.join("\n"));
+    if (workflow_mode === "ssh_scp_wpcli") {
+        const sourceScriptHint = [
+            "ssh_scp_wpcli execution is not implemented in whc_deploy yet.",
+            "This workflow is modeled after mytho/source where deploy is:",
+            "1. doctor",
+            "2. backup",
+            "3. scp code sync",
+            "4. wp-cli runtime bootstrap",
+            "5. wp eval-file seed/bootstrap",
+            "6. HTTP/API smoke",
+            "Use the project-local pipeline script for real execution until source-specific deploy integration lands.",
+        ].join("\n");
+        if (request.dry_run) {
+            const phaseCoverage = buildPhaseCoverage({
+                workflowMode: workflow_mode,
+                verifyStatus: "skipped",
+                dryRun: true,
+            });
+            return {
+                ok: true,
+                action_id: actionIdFactory(),
+                tool: "whc_deploy",
+                data: {
+                    outcome: "dry_run_preview",
+                    workflow_mode,
+                    target_environment,
+                    direction,
+                    sync_scope,
+                    lock_key: deployLockKey,
+                    backup_reference,
+                    pipeline_status: derivePipelineStatus(phaseCoverage),
+                    phase_coverage: phaseCoverage,
+                    warnings: [...warnings, sourceScriptHint],
+                },
+                error: null,
+                meta: {
+                    latency_ms: Date.now() - startedAt,
+                    safety_level: effectiveSafetyLevel,
+                    workflow_mode,
+                    pipeline_id,
+                    release_intent,
+                    source_profile,
+                    delivery_mechanism: "file_transfer",
+                },
+            };
         }
+        return buildErrorResponse(actionIdFactory(), startedAt, effectiveSafetyLevel, "BUSINESS_POLICY_BLOCKED", sourceScriptHint);
     }
-    if (direction === "live_to_staging" && sync_scope !== "files") {
-        warnings.push("Refreshing staging from live with database/everything scope — any staging-only changes will be lost.");
+    if (direction || sync_scope) {
+        warnings.push("direction/sync_scope are legacy managed-sync fields and are ignored by git_deploy.");
     }
-    if (needsBackupGate && !backup_reference && !allow_emergency_without_backup) {
-        return buildErrorResponse(actionIdFactory(), startedAt, effectiveSafetyLevel, "BUSINESS_POLICY_BLOCKED", "Backup reference is required for staging_to_live database/everything sync. Provide payload.backup_reference or set allow_emergency_without_backup=true.");
+    if (!repository_root) {
+        return buildErrorResponse(actionIdFactory(), startedAt, effectiveSafetyLevel, "VALIDATION_ERROR", "git_deploy requires payload.repository_root so WHC knows which cPanel-managed repository to deploy.");
     }
-    if (needsBackupGate && !backup_reference && allow_emergency_without_backup) {
-        warnings.push("Emergency override enabled without backup_reference. Data loss recovery is not guaranteed.");
+    if (!branch) {
+        warnings.push("No branch was supplied; cPanel will deploy the repository's current configured HEAD.");
     }
-    // Dry run: return preview without making changes
     if (request.dry_run) {
         const phaseCoverage = buildPhaseCoverage({
             workflowMode: workflow_mode,
-            syncScope: sync_scope,
             verifyStatus: "skipped",
             dryRun: true,
         });
@@ -121,11 +101,10 @@ async function executeWhcDeploy(config, request, deps = {}) {
                 outcome: "dry_run_preview",
                 workflow_mode,
                 target_environment,
-                direction,
-                sync_scope,
                 repository_root,
                 branch,
-                rollback_branch,
+                direction,
+                sync_scope,
                 lock_key: deployLockKey,
                 backup_reference,
                 pipeline_status: derivePipelineStatus(phaseCoverage),
@@ -140,7 +119,7 @@ async function executeWhcDeploy(config, request, deps = {}) {
                 pipeline_id,
                 release_intent,
                 source_profile,
-                delivery_mechanism: workflow_mode === "git_controlled" ? "git_deploy" : "managed_sync",
+                delivery_mechanism: "git_deploy",
             },
         };
     }
@@ -149,78 +128,9 @@ async function executeWhcDeploy(config, request, deps = {}) {
         return buildErrorResponse(actionIdFactory(), startedAt, effectiveSafetyLevel, "BUSINESS_POLICY_BLOCKED", `Concurrent deployment blocked: ${lockAcquired.reason}`);
     }
     try {
-        // managed_clone_sync mode: use WHC staging sync
-        if (workflow_mode === "managed_clone_sync") {
-            if (!direction) {
-                return buildErrorResponse(actionIdFactory(), startedAt, effectiveSafetyLevel, "VALIDATION_ERROR", "managed_clone_sync mode requires 'direction' field.");
-            }
-            // WHC managed sync is represented with guarded intent + recovery contract.
-            const outcome = direction === "live_to_staging" ? "synced_live_to_staging" : "synced_staging_to_live";
-            let verifyStatus = "skipped";
-            let rollbackStatus = "not_needed";
-            if (shouldVerify) {
-                const verifyResult = await verifyRunner(config, request);
-                if (!verifyResult.ok) {
-                    verifyStatus = "failed";
-                    if (auto_rollback_on_verify_failure) {
-                        rollbackStatus = "attempted";
-                        const rollbackResult = await rollbackRunner(config, request);
-                        rollbackStatus = rollbackResult.ok ? "succeeded" : "failed";
-                    }
-                    return buildErrorResponse(actionIdFactory(), startedAt, effectiveSafetyLevel, "TEMPORARY_UPSTREAM_ERROR", `Post-deploy verification failed: ${verifyResult.message}`);
-                }
-                verifyStatus = "passed";
-            }
-            const phaseCoverage = buildPhaseCoverage({
-                workflowMode: workflow_mode,
-                syncScope: sync_scope,
-                verifyStatus,
-                dryRun: false,
-            });
-            return {
-                ok: true,
-                action_id: actionIdFactory(),
-                tool: "whc_deploy",
-                data: {
-                    outcome,
-                    workflow_mode,
-                    target_environment,
-                    direction,
-                    sync_scope,
-                    verify_status: verifyStatus,
-                    rollback_status: rollbackStatus,
-                    lock_key: deployLockKey,
-                    backup_reference,
-                    pipeline_status: derivePipelineStatus(phaseCoverage),
-                    phase_coverage: phaseCoverage,
-                    warnings,
-                },
-                error: null,
-                meta: {
-                    latency_ms: Date.now() - startedAt,
-                    safety_level: effectiveSafetyLevel,
-                    workflow_mode,
-                    pipeline_id,
-                    release_intent,
-                    source_profile,
-                    delivery_mechanism: "managed_sync",
-                },
-            };
-        }
-        // git_controlled mode: trigger UAPI VersionControl::deployment
-        if (!repository_root) {
-            return buildErrorResponse(actionIdFactory(), startedAt, effectiveSafetyLevel, "VALIDATION_ERROR", "git_controlled mode requires 'repository_root' field.");
-        }
-        let deployResult;
-        try {
-            deployResult = await uapiClient.triggerDeployment(repository_root, branch);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : "UAPI deployment trigger failed";
-            return buildErrorResponse(actionIdFactory(), startedAt, effectiveSafetyLevel, "AUTH_ERROR", message);
-        }
+        const deployResult = await uapiClient.triggerDeployment(repository_root, branch);
         if (!deployResult.ok) {
-            return buildErrorResponse(actionIdFactory(), startedAt, effectiveSafetyLevel, "TEMPORARY_UPSTREAM_ERROR", deployResult.message);
+            return buildErrorResponse(actionIdFactory(), startedAt, effectiveSafetyLevel, "TEMPORARY_UPSTREAM_ERROR", `Git deployment trigger failed: ${deployResult.message}`);
         }
         let verifyStatus = "skipped";
         let rollbackStatus = "not_needed";
@@ -239,7 +149,6 @@ async function executeWhcDeploy(config, request, deps = {}) {
         }
         const phaseCoverage = buildPhaseCoverage({
             workflowMode: workflow_mode,
-            syncScope: sync_scope,
             verifyStatus,
             dryRun: false,
         });
@@ -248,12 +157,13 @@ async function executeWhcDeploy(config, request, deps = {}) {
             action_id: actionIdFactory(),
             tool: "whc_deploy",
             data: {
-                outcome: "deployed",
+                outcome: "deployment_triggered",
                 workflow_mode,
                 target_environment,
                 repository_root,
                 branch,
-                rollback_branch,
+                direction,
+                sync_scope,
                 deployment_id: deployResult.deployment_id,
                 verify_status: verifyStatus,
                 rollback_status: rollbackStatus,
@@ -289,83 +199,29 @@ function buildErrorResponse(actionId, startedAt, safetyLevel, code, message) {
         meta: { latency_ms: Date.now() - startedAt, safety_level: safetyLevel },
     };
 }
-function buildDefaultLockKey(targetEnvironment, workflowMode, repositoryRoot) {
-    return `whc_deploy:${targetEnvironment}:${workflowMode}:${repositoryRoot ?? "-"}`;
-}
-function extractHomeOwner(pathValue) {
-    const match = pathValue.match(/^\/home\/([^\/]+)\//);
-    return match?.[1];
-}
-function buildSuggestedDeployPayload(request, currentUser) {
-    return {
-        request_id: request.request_id,
-        actor: request.actor,
-        dry_run: request.dry_run,
-        confirmed: request.confirmed,
-        idempotency_key: request.idempotency_key,
-        payload: {
-            ...request.payload,
-            target_environment: "live",
-            repository_root: `/home/${currentUser}/public_html`,
-        },
-    };
-}
-function buildStagingAlternativePayload(request) {
-    return {
-        workflow_mode: "managed_clone_sync",
-        target_environment: "staging",
-        release_intent: "refresh",
-        pipeline_id: request.payload.pipeline_id,
-        source_profile: request.payload.source_profile,
-        direction: "live_to_staging",
-        sync_scope: "files",
-        verify_after_deploy: request.payload.verify_after_deploy,
-        auto_rollback_on_verify_failure: request.payload.auto_rollback_on_verify_failure,
-    };
-}
-function buildSuggestedStagingGitControlledPayload(request, stagingPath) {
-    return {
-        request_id: request.request_id,
-        actor: request.actor,
-        dry_run: request.dry_run,
-        confirmed: request.confirmed,
-        idempotency_key: request.idempotency_key,
-        payload: {
-            ...request.payload,
-            target_environment: "staging",
-            repository_root: stagingPath,
-        },
-    };
-}
 function buildPhaseCoverage(input) {
     const notes = [];
-    let codeState = "excluded";
-    let runtimeState = "excluded";
-    let dataState = "excluded";
+    const codeState = input.dryRun ? "excluded" : "included";
     const deploymentState = input.dryRun ? "excluded" : "included";
-    if (input.workflowMode === "git_controlled") {
-        codeState = input.dryRun ? "excluded" : "included";
-        runtimeState = input.verifyStatus === "passed" ? "included" : "excluded";
-        dataState = "excluded";
-        notes.push("git_controlled deploy covers code transport/deployment state; data/content bootstrap is out of scope.");
+    if (input.workflowMode === "git_deploy") {
+        notes.push("git_deploy triggers a cPanel deployment task for repository-managed code delivery.", "git_deploy does not bootstrap WordPress runtime/data; use separate runtime checks or project-specific scripts for that layer.");
     }
-    if (input.workflowMode === "managed_clone_sync") {
-        if (input.syncScope === "files" || input.syncScope === "everything") {
-            codeState = input.dryRun ? "excluded" : "included";
-        }
-        if (input.syncScope === "database" || input.syncScope === "everything") {
-            dataState = input.dryRun ? "excluded" : "included";
-        }
-        runtimeState = "excluded";
-        notes.push("managed_clone_sync does not bootstrap app runtime configuration (plugin/theme activation, rewrite, Woo setup).", "Managed verification is transport-level unless additional runtime checks are run externally.");
+    else {
+        notes.push("ssh_scp_wpcli is expected to cover code sync, WP-CLI runtime bootstrap, seed/bootstrap, and smoke gating.", "whc_deploy does not execute that source-specific flow yet; use a project-local pipeline script for real runs today.");
+    }
+    if (input.verifyStatus === "passed") {
+        notes.push("Post-deploy verification passed.");
+    }
+    if (input.verifyStatus === "failed") {
+        notes.push("Post-deploy verification failed.");
     }
     if (input.dryRun) {
         notes.push("dry_run preview only; no target state has been changed.");
     }
     return {
         code_state: codeState,
-        runtime_state: runtimeState,
-        data_state: dataState,
+        runtime_state: "excluded",
+        data_state: "excluded",
         deployment_state: deploymentState,
         notes,
     };

package/dist/handlers/whc-pipeline-status.js

@@ -21,7 +21,7 @@ async function executeWhcPipelineStatus(config, request) {
                 next_step: "Run whc_prepare then a write tool to initialize pipeline state.",
                 artifacts: {
                     state_file: (0, workspace_state_1.getPipelineStatusFile)(rootDir),
-                    flow_log_file: config.flowLogPath ?? ".mcp/whc-mcp/logs/flow-events.jsonl",
+                    flow_log_file: config.flowLogPath ?? ".whc/logs/flow-events.jsonl",
                 },
             },
             error: null,
@@ -57,7 +57,7 @@ async function executeWhcPipelineStatus(config, request) {
             artifacts: {
                 state_file: (0, workspace_state_1.getPipelineStatusFile)(rootDir),
                 manifest_file: manifestFile,
-                flow_log_file: config.flowLogPath ?? ".mcp/whc-mcp/logs/flow-events.jsonl",
+                flow_log_file: config.flowLogPath ?? ".whc/logs/flow-events.jsonl",
             },
         },
         error: null,

package/dist/handlers/whc-prepare.js

@@ -49,7 +49,7 @@ async function executeWhcPrepare(_config, request) {
     }
     (0, workspace_state_1.ensureWorkspaceState)(rootDir);
     const gitignoreUpdated = request.payload.ensure_gitignore_rule !== false
-        ? ensureGitignoreRule(rootDir, ".mcp/")
+        ? ensureGitignoreRule(rootDir, ".whc/")
         : false;
     if (!(0, node_fs_1.existsSync)(pipelineStatusFile) || request.payload.force_reinitialize) {
         const payload = {

package/dist/handlers/whc-setup-remote.js

@@ -15,7 +15,7 @@ async function executeWhcSetupRemote(config, request, deps = {}) {
             `Path owner mismatch: deploy_target_path belongs to '${pathOwner}' but WHC_USER is '${config.user}'.`,
         ];
         if (isStaging) {
-            lines.push("WHC managed staging uses a separate cPanel account; git repo setup via this user's UAPI cannot target it.", "Use managed_clone_sync mode to sync staging from live, or configure dedicated staging credentials.");
+            lines.push("WHC managed staging uses a separate cPanel account; git repo setup via this user's UAPI cannot target it.", "Use git_deploy mode to drive repository-based staging refresh/deploy flows, or configure dedicated staging credentials.");
         }
         else {
             const suggestedPayload = buildSuggestedSetupRemotePayload(request, config.user);
@@ -183,7 +183,8 @@ async function executeWhcSetupRemote(config, request, deps = {}) {
     };
 }
 function buildSshRemoteHint(config, deployTargetPath) {
-    const { username, host } = config.sshTargets.prod;
+    const host = config.sshTargets.prod.host || config.host;
+    const username = config.sshTargets.prod.username || config.user;
     return `${username}@${host}:${deployTargetPath}`;
 }
 function inferBaselineKind(sourceKind) {
@@ -226,7 +227,7 @@ function buildSetupRemotePhaseCoverage(dryRun) {
     };
 }
 function extractHomeOwner(pathValue) {
-    const match = pathValue.match(/^\/home\/([^\/]+)\//);
+    const match = pathValue.match(/^\/home\/([^/]+)\//);
     return match?.[1];
 }
 function buildSuggestedSetupRemotePayload(request, currentUser) {