devops-whc 1.0.1 → 1.0.2

package/dist/services/deploy-runtime-ops.js

@@ -2,103 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runDeployVerification = runDeployVerification;
 exports.runDeployRollback = runDeployRollback;
-async function runDeployVerification(config, request, sshClient) {
-    const payload = request.payload;
-    if (payload.workflow_mode !== "git_controlled") {
-        return { ok: true, message: "Verification passed for managed_clone_sync mode" };
-    }
-    if (!payload.repository_root) {
-        return { ok: false, message: "Missing repository_root for verification" };
-    }
-    const repoPath = shellQuote(payload.repository_root);
-    const verifyProfile = resolveVerifyProfile(payload.source_profile.source_kind);
-    const commandParts = [
-        `test -d ${repoPath} && echo __PATH_OK__ || echo __PATH_MISSING__`,
-        `if [ -f ${repoPath}/.cpanel.yml ]; then echo __CPANEL_YML_OK__; else echo __CPANEL_YML_MISSING__; fi`,
-    ];
-    if (verifyProfile.requireWpCliCheck) {
-        commandParts.push(`if command -v wp >/dev/null 2>&1; then wp core is-installed --path=${repoPath} >/dev/null 2>&1 && echo __WP_OK__ || echo __WP_NOT_READY__; else echo __WPCLI_MISSING__; fi`);
-    }
-    const command = commandParts.join(" ; ");
-    const target = resolveTarget(config, payload.target_environment);
-    if (!target.ok) {
-        return { ok: false, message: target.message };
-    }
-    const sshResult = await sshClient.execWithKey(target.value, command);
-    if (!sshResult.ok) {
-        return { ok: false, message: `SSH verify command failed: ${sshResult.message}` };
-    }
-    const output = sshResult.stdout;
-    if (output.includes("__PATH_MISSING__")) {
-        return { ok: false, message: "Deployment path does not exist after deploy" };
-    }
-    if (output.includes("__CPANEL_YML_MISSING__")) {
-        return { ok: false, message: ".cpanel.yml is missing in deployment root" };
-    }
-    if (verifyProfile.requireWpCliCheck && output.includes("__WPCLI_MISSING__")) {
-        return { ok: false, message: "WP-CLI is required for full_site verification but is not available" };
-    }
-    if (verifyProfile.requireWpCliCheck && output.includes("__WP_NOT_READY__")) {
-        return { ok: false, message: "WordPress core is not installed/ready after deploy" };
-    }
-    return { ok: true, message: `Runtime verification passed (${verifyProfile.name})` };
+async function runDeployVerification(_config, _request, _sshClient) {
+    // Verification for git_deploy is transport-level only.
+    return { ok: true, message: "Verification passed for git_deploy mode" };
 }
-async function runDeployRollback(_config, request, uapiClient) {
-    const payload = request.payload;
-    if (payload.workflow_mode !== "git_controlled") {
-        return {
-            ok: false,
-            message: "Automatic rollback is currently supported only for git_controlled mode",
-        };
-    }
-    if (!payload.repository_root) {
-        return { ok: false, message: "Missing repository_root for rollback" };
-    }
-    if (!payload.rollback_branch) {
-        return {
-            ok: false,
-            message: "rollback_branch is required for automatic rollback",
-        };
-    }
-    const rollbackResult = await uapiClient.triggerDeployment(payload.repository_root, payload.rollback_branch);
-    if (!rollbackResult.ok) {
-        return {
-            ok: false,
-            message: `Rollback deployment failed: ${rollbackResult.message}`,
-        };
-    }
-    return { ok: true, message: `Rollback deployed from branch ${payload.rollback_branch}` };
-}
-function shellQuote(value) {
-    return `'${value.replace(/'/g, `'"'"'`)}'`;
-}
-function resolveVerifyProfile(sourceKind) {
-    if (sourceKind === "full_site") {
-        return { name: "wordpress", requireWpCliCheck: true };
-    }
-    if (sourceKind === "package_only" || sourceKind === "artifact_first") {
-        return { name: "generic", requireWpCliCheck: false };
-    }
-    return { name: "generic", requireWpCliCheck: false };
-}
-function resolveTarget(config, environment) {
-    if (environment === "live") {
-        return { ok: true, value: config.sshTargets.prod };
-    }
-    const staging = config.sshTargets.staging;
-    if (!staging) {
-        return { ok: false, message: "Staging SSH target is not configured" };
-    }
-    if (!staging.privateKeyPath) {
-        return { ok: false, message: "Staging verification requires key-based SSH auth" };
-    }
+async function runDeployRollback(_config, _request, _uapiClient) {
+    // Automatic rollback via UAPI is not supported on WHC Managed WordPress.
+    // WHC does not expose cPanel Git Version Control deployment for rollback.
     return {
-        ok: true,
-        value: {
-            host: staging.host,
-            port: staging.port,
-            username: staging.username,
-            privateKeyPath: staging.privateKeyPath,
-        },
+        ok: false,
+        message: "Automatic rollback is not supported on this platform. Restore from DB backup created before deploy.",
     };
 }

package/dist/state/workspace-state.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_STATE_ROOT = void 0;
 exports.ensureWorkspaceState = ensureWorkspaceState;
+exports.ensureWorkspaceBootstrap = ensureWorkspaceBootstrap;
 exports.writePipelineStartState = writePipelineStartState;
 exports.writePipelineEndState = writePipelineEndState;
 exports.resolveStateRoot = resolveStateRoot;
@@ -15,7 +16,9 @@ exports.readJsonFile = readJsonFile;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
-exports.DEFAULT_STATE_ROOT = ".mcp/whc-mcp";
+exports.DEFAULT_STATE_ROOT = ".whc";
+const DEFAULT_BOOTSTRAP_ENV_FILE = "whc.env";
+const DEFAULT_BOOTSTRAP_ENV_EXAMPLE_FILE = "whc.env.example";
 function ensureWorkspaceState(rootDir = process.cwd()) {
     const stateRoot = resolveStateRoot(rootDir);
     const stateDir = (0, node_path_1.join)(stateRoot, "state");
@@ -29,7 +32,61 @@ function ensureWorkspaceState(rootDir = process.cwd()) {
     (0, node_fs_1.mkdirSync)(reportsDir, { recursive: true });
     (0, node_fs_1.mkdirSync)(logsDir, { recursive: true });
     (0, node_fs_1.mkdirSync)(envDir, { recursive: true });
-    ensureGitignoreRule(rootDir, ".mcp/");
+    ensureGitignoreRule(rootDir, ".whc/");
+}
+function ensureWorkspaceBootstrap(rootDir = process.cwd(), options = {}) {
+    const stateRootAbsolute = resolveStateRoot(rootDir);
+    const stateRootRelative = getRelativeStateRoot();
+    const stateDir = (0, node_path_1.join)(stateRootAbsolute, "state");
+    const releasesDir = (0, node_path_1.join)(stateDir, "releases");
+    const reportsDir = (0, node_path_1.join)(stateDir, "reports");
+    const logsDir = (0, node_path_1.join)(stateRootAbsolute, "logs");
+    const envDir = (0, node_path_1.join)(stateRootAbsolute, "env");
+    const trackedPaths = [
+        stateRootAbsolute,
+        stateDir,
+        releasesDir,
+        reportsDir,
+        logsDir,
+        envDir,
+    ];
+    const createdPaths = [];
+    for (const dirPath of trackedPaths) {
+        if (!(0, node_fs_1.existsSync)(dirPath)) {
+            (0, node_fs_1.mkdirSync)(dirPath, { recursive: true });
+            createdPaths.push(dirPath);
+        }
+    }
+    const gitignoreUpdated = ensureGitignoreRule(rootDir, ".whc/");
+    const pipelineStatusFile = getPipelineStatusFile(rootDir);
+    if (!(0, node_fs_1.existsSync)(pipelineStatusFile)) {
+        (0, node_fs_1.writeFileSync)(pipelineStatusFile, JSON.stringify({
+            started: false,
+            completed: false,
+            status: "idle",
+            next_step: "Run a write tool (deploy/setup/backup/ssh) to start tracking.",
+        }, null, 2) + "\n", { encoding: "utf8" });
+        createdPaths.push(pipelineStatusFile);
+    }
+    const envFile = (0, node_path_1.join)(envDir, DEFAULT_BOOTSTRAP_ENV_FILE);
+    if (!(0, node_fs_1.existsSync)(envFile)) {
+        (0, node_fs_1.writeFileSync)(envFile, buildBootstrapEnvTemplate(rootDir, options), { encoding: "utf8" });
+        createdPaths.push(envFile);
+    }
+    const envExampleFile = (0, node_path_1.join)(envDir, DEFAULT_BOOTSTRAP_ENV_EXAMPLE_FILE);
+    if (!(0, node_fs_1.existsSync)(envExampleFile)) {
+        (0, node_fs_1.writeFileSync)(envExampleFile, buildBootstrapEnvTemplate(rootDir, options), { encoding: "utf8" });
+        createdPaths.push(envExampleFile);
+    }
+    return {
+        stateRootRelative,
+        stateRootAbsolute,
+        createdPaths,
+        gitignoreUpdated,
+        pipelineStatusFile,
+        envFile,
+        envExampleFile,
+    };
 }
 function writePipelineStartState(input) {
     ensureWorkspaceState(input.rootDir);
@@ -112,15 +169,16 @@ function ensureGitignoreRule(rootDir, rule) {
     const gitignorePath = (0, node_path_1.join)(rootDir, ".gitignore");
     if (!(0, node_fs_1.existsSync)(gitignorePath)) {
         (0, node_fs_1.writeFileSync)(gitignorePath, `${rule}\n`, { encoding: "utf8" });
-        return;
+        return true;
     }
     const content = (0, node_fs_1.readFileSync)(gitignorePath, "utf8");
     const hasRule = content.split(/\r?\n/).some((line) => line.trim() === rule);
     if (hasRule) {
-        return;
+        return false;
     }
     const next = content.endsWith("\n") ? `${content}${rule}\n` : `${content}\n${rule}\n`;
     (0, node_fs_1.writeFileSync)(gitignorePath, next, { encoding: "utf8" });
+    return true;
 }
 function safeFileName(value) {
     return value.replace(/[^a-zA-Z0-9._-]/g, "_");
@@ -129,17 +187,59 @@ function defaultNextStep(ok) {
     if (ok) {
         return "Proceed to next pipeline step based on policy and verification scope.";
     }
-    return "Inspect .mcp/whc-mcp/logs/flow-events.jsonl and retry after fixing the reported error.";
+    return "Inspect .whc/logs/flow-events.jsonl and retry after fixing the reported error.";
 }
 function resolveStateRoot(rootDir = process.cwd()) {
-    const configured = (process.env.WHC_STATE_ROOT ?? "").trim();
-    const configuredOrDefault = configured.length > 0 ? configured : exports.DEFAULT_STATE_ROOT;
+    const configuredOrDefault = getRelativeStateRoot();
     if ((0, node_path_1.isAbsolute)(configuredOrDefault)) {
         return configuredOrDefault;
     }
     const segments = configuredOrDefault.split(/[\\/]+/).filter((part) => part.length > 0);
     return (0, node_path_1.join)(rootDir, ...segments);
 }
+function getRelativeStateRoot() {
+    const configured = (process.env.WHC_STATE_ROOT ?? "").trim();
+    return configured.length > 0 ? configured : exports.DEFAULT_STATE_ROOT;
+}
+function buildBootstrapEnvTemplate(rootDir, options) {
+    return [
+        "# Project-local WHC bootstrap env",
+        "# Fill the values needed for this specific deploy workspace.",
+        `WHC_LOCAL_PROJECT_ROOT=${options.localProjectRoot ?? rootDir}`,
+        `WHC_LOCAL_APP_PATH=${options.localAppPath ?? ""}`,
+        "WHC_WORKFLOW_MODE=",
+        "WHC_SOURCE_KIND=full_site",
+        "WHC_DEPLOY_UNIT=raw_source",
+        "WHC_DEFAULT_RELEASE_INTENT=deploy",
+        "",
+        "# Managed WHC mode",
+        "WHC_API_TOKEN=",
+        "WHC_USER=",
+        "WHC_HOST=",
+        "WHC_PROD_PATH=/public_html",
+        "WHC_PROD_SSH_HOST=",
+        "WHC_PROD_SSH_PORT=27",
+        "WHC_PROD_SSH_USERNAME=",
+        "WHC_PROD_SSH_PRIVATE_KEY_PATH=",
+        "",
+        "# Staging/source-driven mode",
+        "WHC_STAGING_DOMAIN=",
+        "WHC_STAGING_PATH=",
+        "WHC_STAGING_SSH_HOST=",
+        "WHC_STAGING_SSH_PORT=27",
+        "WHC_STAGING_SSH_USERNAME=",
+        "WHC_STAGING_SSH_PRIVATE_KEY_PATH=",
+        "WHC_STAGING_SSH_PASSWORD=",
+        "WHC_STAGING_SSH_HOSTKEY=",
+        "",
+        "WHC_REQUIRE_STAGING_CONFIRM=true",
+        "WHC_WARN_DYNAMIC_DATA_SYNC=true",
+        "WHC_ENFORCE_STAGING_FIRST=true",
+        "WHC_API_TIMEOUT_MS=15000",
+        "WHC_SSH_TIMEOUT_MS=10000",
+        "",
+    ].join("\n");
+}
 function getPipelineStatusFile(rootDir = process.cwd()) {
     return (0, node_path_1.join)(resolveStateRoot(rootDir), "state", "pipeline-status.json");
 }

package/package.json

@@ -1,37 +1,42 @@
 {
   "name": "devops-whc",
-  "version": "1.0.1",
-  "description": "WHC cPanel MCP server for deploy, verify, and rollback flows",
+  "version": "1.0.2",
+  "description": "WHC cPanel automation CLI for deploy, verify, and rollback flows",
   "main": "dist/index.js",
   "bin": {
-    "whc-mcp": "dist/index.js"
+    "whc": "dist/index.js"
   },
   "exports": {
     ".": "./dist/index.js"
   },
   "files": [
     "dist",
-    "scripts/start-mcp.cjs",
+    "scripts/start-whc.cjs",
     "scripts/prepare-first-time.cjs",
     "README.md",
-    "AGENT_MCP_USAGE.md",
-    "WHC_MCP_REQUIREMENTS.md",
+    "AGENT_USAGE.md",
+    "WHC_REQUIREMENTS.md",
     "LICENSE"
   ],
   "scripts": {
     "prepack": "node ../../scripts/prepare-publish-package.cjs",
+    "publish:release": "npm publish",
     "pack:check": "npm pack --dry-run",
     "prehelp": "node ../../scripts/prepare-publish-package.cjs",
     "help": "node dist/index.js --help",
+    "prestart": "node ../../scripts/prepare-publish-package.cjs",
+    "start": "node scripts/start-whc.cjs",
     "preserve": "node ../../scripts/prepare-publish-package.cjs",
     "serve": "node dist/index.js --serve",
     "preprobe": "node ../../scripts/prepare-publish-package.cjs",
     "probe": "node dist/index.js --probe",
+    "precheck:generic": "node ../../scripts/prepare-publish-package.cjs",
+    "check:generic": "node dist/index.js --check-generic",
     "precheck:health": "node ../../scripts/prepare-publish-package.cjs",
     "check:health": "node dist/index.js --check-health"
   },
   "keywords": [
-    "mcp",
+    "cli",
     "whc",
     "cpanel",
     "deploy"

package/scripts/prepare-first-time.cjs

@@ -30,7 +30,7 @@ function ensureFileIfMissing(filePath, data) {
 
 function resolveStateRoot(rootDir) {
   const configured = (process.env.WHC_STATE_ROOT || "").trim();
-  const relative = configured.length > 0 ? configured : ".mcp/whc-mcp";
+  const relative = configured.length > 0 ? configured : ".whc";
   const segments = relative.split(/[\\/]+/).filter(Boolean);
   return path.join(rootDir, ...segments);
 }
@@ -51,7 +51,7 @@ function main() {
   ensureDir(logsDir);
   ensureDir(envDir);
 
-  ensureGitignoreRule(rootDir, ".mcp/");
+  ensureGitignoreRule(rootDir, ".whc/");
 
   const statusFile = path.join(stateDir, "pipeline-status.json");
   ensureFileIfMissing(
@@ -68,7 +68,7 @@ function main() {
     ) + "\n",
   );
 
-  console.log("[prepare-first-time] Initialized .mcp/whc-mcp hidden state and ensured .gitignore contains .mcp/");
+  console.log("[prepare-first-time] Initialized .whc hidden state and ensured .gitignore contains .whc/");
   console.log(`[prepare-first-time] State file: ${statusFile}`);
 }
 

package/scripts/{start-mcp.cjs → start-whc.cjs}

@@ -9,8 +9,7 @@ const projectRootHint = process.env.WHC_LOCAL_PROJECT_ROOT;
 const envCandidates = [
   requestedEnvPath,
   projectRootHint ? path.join(projectRootHint, ".vscode", "whc.env") : undefined,
-  projectRootHint ? path.join(projectRootHint, ".mcp", "whc-mcp", "env", "whc.env") : undefined,
-  projectRootHint ? path.join(projectRootHint, ".mcp", "whc.env") : undefined,
+  projectRootHint ? path.join(projectRootHint, ".whc", "env", "whc.env") : undefined,
   path.join(workspaceRoot, ".env"),
 ]
   .filter(Boolean)
@@ -19,7 +18,7 @@ const envCandidates = [
 const envFilePath = envCandidates.find((p) => fs.existsSync(p));
 
 // Load .env manually before importing the compiled server
-// (VS Code Copilot starts the process without any env pre-loaded)
+// (tool clients can start the process without any env pre-loaded)
 if (envFilePath && fs.existsSync(envFilePath)) {
   const parsed = dotenv.parse(fs.readFileSync(envFilePath));
   for (const [key, value] of Object.entries(parsed)) {
@@ -36,7 +35,7 @@ const serverEntryCandidates = [
 
 const serverEntry = serverEntryCandidates.find((p) => fs.existsSync(p));
 if (!serverEntry) {
-  throw new Error("MCP build output not found. Run npm run build before npm run mcp:start.");
+  throw new Error("Build output not found. Run npm run build before npm run start.");
 }
 
 require(serverEntry);