devops-whc 1.0.1

package/dist/state/workspace-state.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_STATE_ROOT = void 0;
+exports.ensureWorkspaceState = ensureWorkspaceState;
+exports.writePipelineStartState = writePipelineStartState;
+exports.writePipelineEndState = writePipelineEndState;
+exports.resolveStateRoot = resolveStateRoot;
+exports.getPipelineStatusFile = getPipelineStatusFile;
+exports.getReleaseManifestFile = getReleaseManifestFile;
+exports.readPipelineStatus = readPipelineStatus;
+exports.readReleaseManifest = readReleaseManifest;
+exports.getVerifyReportFile = getVerifyReportFile;
+exports.findLatestVerifyReportFile = findLatestVerifyReportFile;
+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";
+function ensureWorkspaceState(rootDir = process.cwd()) {
+    const stateRoot = resolveStateRoot(rootDir);
+    const stateDir = (0, node_path_1.join)(stateRoot, "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)(stateRoot, "logs");
+    const envDir = (0, node_path_1.join)(stateRoot, "env");
+    (0, node_fs_1.mkdirSync)(stateRoot, { recursive: true });
+    (0, node_fs_1.mkdirSync)(stateDir, { recursive: true });
+    (0, node_fs_1.mkdirSync)(releasesDir, { recursive: true });
+    (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/");
+}
+function writePipelineStartState(input) {
+    ensureWorkspaceState(input.rootDir);
+    const stateFile = getPipelineStatusFile(input.rootDir);
+    const payload = {
+        started: true,
+        completed: false,
+        status: "in_progress",
+        tool: input.toolName,
+        request_id: input.requestId,
+        target_environment: input.targetEnvironment,
+        pipeline_id: input.pipelineId,
+        release_intent: input.releaseIntent,
+        started_at: input.startedAtIso,
+        next_step: "Wait for tool execution result.",
+    };
+    (0, node_fs_1.writeFileSync)(stateFile, JSON.stringify(payload, null, 2), { encoding: "utf8" });
+}
+function writePipelineEndState(input, result) {
+    ensureWorkspaceState(input.rootDir);
+    const stateFile = getPipelineStatusFile(input.rootDir);
+    const completedAtIso = new Date().toISOString();
+    const payload = {
+        started: true,
+        completed: true,
+        status: result.ok ? "success" : "failure",
+        tool: input.toolName,
+        request_id: input.requestId,
+        action_id: result.actionId,
+        target_environment: input.targetEnvironment,
+        pipeline_id: input.pipelineId,
+        release_intent: input.releaseIntent,
+        started_at: input.startedAtIso,
+        completed_at: completedAtIso,
+        next_step: result.nextStep ?? defaultNextStep(result.ok),
+        error: result.ok
+            ? null
+            : {
+                code: result.errorCode ?? "UNKNOWN",
+                message: result.errorMessage ?? "Unknown error",
+            },
+    };
+    (0, node_fs_1.writeFileSync)(stateFile, JSON.stringify(payload, null, 2), { encoding: "utf8" });
+    writeAutoManifest(input, completedAtIso, result.ok);
+}
+function writeAutoManifest(input, completedAtIso, ok) {
+    const releaseFile = getReleaseManifestFile(input.rootDir, input.requestId);
+    const changedFiles = collectGitChangedFiles(input.rootDir);
+    const payload = {
+        request_id: input.requestId,
+        tool: input.toolName,
+        target_environment: input.targetEnvironment,
+        pipeline_id: input.pipelineId,
+        release_intent: input.releaseIntent,
+        started_at: input.startedAtIso,
+        completed_at: completedAtIso,
+        status: ok ? "success" : "failure",
+        changed_files: changedFiles,
+    };
+    (0, node_fs_1.writeFileSync)(releaseFile, JSON.stringify(payload, null, 2), { encoding: "utf8" });
+}
+function collectGitChangedFiles(rootDir) {
+    try {
+        const output = (0, node_child_process_1.execSync)("git status --porcelain", { cwd: rootDir, stdio: ["ignore", "pipe", "ignore"] })
+            .toString("utf8")
+            .trim();
+        if (!output) {
+            return [];
+        }
+        return output
+            .split(/\r?\n/)
+            .map((line) => line.slice(3).trim())
+            .filter((path) => path.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+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;
+    }
+    const content = (0, node_fs_1.readFileSync)(gitignorePath, "utf8");
+    const hasRule = content.split(/\r?\n/).some((line) => line.trim() === rule);
+    if (hasRule) {
+        return;
+    }
+    const next = content.endsWith("\n") ? `${content}${rule}\n` : `${content}\n${rule}\n`;
+    (0, node_fs_1.writeFileSync)(gitignorePath, next, { encoding: "utf8" });
+}
+function safeFileName(value) {
+    return value.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+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.";
+}
+function resolveStateRoot(rootDir = process.cwd()) {
+    const configured = (process.env.WHC_STATE_ROOT ?? "").trim();
+    const configuredOrDefault = configured.length > 0 ? configured : exports.DEFAULT_STATE_ROOT;
+    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 getPipelineStatusFile(rootDir = process.cwd()) {
+    return (0, node_path_1.join)(resolveStateRoot(rootDir), "state", "pipeline-status.json");
+}
+function getReleaseManifestFile(rootDir, requestId) {
+    return (0, node_path_1.join)(resolveStateRoot(rootDir), "state", "releases", `${safeFileName(requestId)}.auto-manifest.json`);
+}
+function readPipelineStatus(rootDir = process.cwd()) {
+    const statusFile = getPipelineStatusFile(rootDir);
+    if (!(0, node_fs_1.existsSync)(statusFile)) {
+        return null;
+    }
+    try {
+        const raw = (0, node_fs_1.readFileSync)(statusFile, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function readReleaseManifest(rootDir, requestId) {
+    const file = getReleaseManifestFile(rootDir, requestId);
+    if (!(0, node_fs_1.existsSync)(file)) {
+        return null;
+    }
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function getVerifyReportFile(rootDir, releaseId) {
+    return (0, node_path_1.join)(resolveStateRoot(rootDir), "state", "reports", `${safeFileName(releaseId)}.verify-report.json`);
+}
+function findLatestVerifyReportFile(rootDir = process.cwd()) {
+    const reportsDir = (0, node_path_1.join)(resolveStateRoot(rootDir), "state", "reports");
+    if (!(0, node_fs_1.existsSync)(reportsDir)) {
+        return null;
+    }
+    const files = (0, node_fs_1.readdirSync)(reportsDir)
+        .filter((name) => name.endsWith(".verify-report.json"))
+        .map((name) => {
+        const fullPath = (0, node_path_1.join)(reportsDir, name);
+        return { fullPath, mtime: (0, node_fs_1.statSync)(fullPath).mtimeMs };
+    })
+        .sort((a, b) => b.mtime - a.mtime);
+    return files[0]?.fullPath ?? null;
+}
+function readJsonFile(filePath) {
+    if (!(0, node_fs_1.existsSync)(filePath)) {
+        return null;
+    }
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(filePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "devops-whc",
+  "version": "1.0.1",
+  "description": "WHC cPanel MCP server for deploy, verify, and rollback flows",
+  "main": "dist/index.js",
+  "bin": {
+    "whc-mcp": "dist/index.js"
+  },
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "scripts/start-mcp.cjs",
+    "scripts/prepare-first-time.cjs",
+    "README.md",
+    "AGENT_MCP_USAGE.md",
+    "WHC_MCP_REQUIREMENTS.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "prepack": "node ../../scripts/prepare-publish-package.cjs",
+    "pack:check": "npm pack --dry-run",
+    "prehelp": "node ../../scripts/prepare-publish-package.cjs",
+    "help": "node dist/index.js --help",
+    "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:health": "node ../../scripts/prepare-publish-package.cjs",
+    "check:health": "node dist/index.js --check-health"
+  },
+  "keywords": [
+    "mcp",
+    "whc",
+    "cpanel",
+    "deploy"
+  ],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "dotenv": "^17.4.2",
+    "ssh2": "^1.17.0",
+    "zod": "^4.4.3"
+  }
+}

package/scripts/prepare-first-time.cjs

@@ -0,0 +1,75 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+function ensureDir(p) {
+  fs.mkdirSync(p, { recursive: true });
+}
+
+function ensureGitignoreRule(rootDir, rule) {
+  const gitignorePath = path.join(rootDir, ".gitignore");
+  if (!fs.existsSync(gitignorePath)) {
+    fs.writeFileSync(gitignorePath, `${rule}\n`, "utf8");
+    return;
+  }
+
+  const content = fs.readFileSync(gitignorePath, "utf8");
+  const hasRule = content.split(/\r?\n/).some((line) => line.trim() === rule);
+  if (hasRule) {
+    return;
+  }
+
+  const next = content.endsWith("\n") ? `${content}${rule}\n` : `${content}\n${rule}\n`;
+  fs.writeFileSync(gitignorePath, next, "utf8");
+}
+
+function ensureFileIfMissing(filePath, data) {
+  if (!fs.existsSync(filePath)) {
+    fs.writeFileSync(filePath, data, "utf8");
+  }
+}
+
+function resolveStateRoot(rootDir) {
+  const configured = (process.env.WHC_STATE_ROOT || "").trim();
+  const relative = configured.length > 0 ? configured : ".mcp/whc-mcp";
+  const segments = relative.split(/[\\/]+/).filter(Boolean);
+  return path.join(rootDir, ...segments);
+}
+
+function main() {
+  const rootDir = path.resolve(__dirname, "..");
+  const stateRoot = resolveStateRoot(rootDir);
+  const stateDir = path.join(stateRoot, "state");
+  const releasesDir = path.join(stateDir, "releases");
+  const reportsDir = path.join(stateDir, "reports");
+  const logsDir = path.join(stateRoot, "logs");
+  const envDir = path.join(stateRoot, "env");
+
+  ensureDir(stateRoot);
+  ensureDir(stateDir);
+  ensureDir(releasesDir);
+  ensureDir(reportsDir);
+  ensureDir(logsDir);
+  ensureDir(envDir);
+
+  ensureGitignoreRule(rootDir, ".mcp/");
+
+  const statusFile = path.join(stateDir, "pipeline-status.json");
+  ensureFileIfMissing(
+    statusFile,
+    JSON.stringify(
+      {
+        started: false,
+        completed: false,
+        status: "idle",
+        next_step: "Run a write tool (deploy/setup/backup/ssh) to start tracking.",
+      },
+      null,
+      2,
+    ) + "\n",
+  );
+
+  console.log("[prepare-first-time] Initialized .mcp/whc-mcp hidden state and ensured .gitignore contains .mcp/");
+  console.log(`[prepare-first-time] State file: ${statusFile}`);
+}
+
+main();

package/scripts/start-mcp.cjs

@@ -0,0 +1,42 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const dotenv = require("dotenv");
+
+const workspaceRoot = path.resolve(__dirname, "..");
+const requestedEnvPath = process.env.WHC_ENV_FILE;
+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,
+  path.join(workspaceRoot, ".env"),
+]
+  .filter(Boolean)
+  .map((p) => path.resolve(p));
+
+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)
+if (envFilePath && fs.existsSync(envFilePath)) {
+  const parsed = dotenv.parse(fs.readFileSync(envFilePath));
+  for (const [key, value] of Object.entries(parsed)) {
+    if (!process.env[key]) {
+      process.env[key] = value;
+    }
+  }
+}
+
+const serverEntryCandidates = [
+  path.join(workspaceRoot, "dist", "server-entry.js"),
+  path.join(workspaceRoot, "dist", "src", "server-entry.js"),
+];
+
+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.");
+}
+
+require(serverEntry);