devops-whc 1.0.1 → 1.0.2-next

package/dist/index.js

@@ -1,7 +1,13 @@
 #!/usr/bin/env node
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const dotenv_1 = __importDefault(require("dotenv"));
 const env_1 = require("./config/env");
 const tool_dispatcher_1 = require("./dispatcher/tool-dispatcher");
 const whc_check_health_1 = require("./handlers/whc-check-health");
@@ -11,14 +17,16 @@ const tool_registry_1 = require("./registry/tool-registry");
 const store_1 = require("./idempotency/store");
 const audit_logger_1 = require("./audit/audit-logger");
 const server_1 = require("./server");
-const packageJson = require("../package.json");
-const APP_VERSION = packageJson.version;
+const source_compatibility_1 = require("./probes/source-compatibility");
+const workspace_state_1 = require("./state/workspace-state");
+const APP_VERSION = process.env.npm_package_version ?? "0.0.0";
 const HELP_TEXT = [
-    `WHC MCP CLI Help v${APP_VERSION}`,
+    `WHC CLI Help v${APP_VERSION}`,
     "",
     "Modes:",
-    "  --serve         Start MCP stdio server (registers all tools)",
+    "  --serve         Start stdio tool server (registers all tools)",
     "  --probe         Run connectivity probe (UAPI, SSH, WP-CLI)",
+    "  --check-generic Run one-shot deploy readiness check for a specific project folder",
     "  --check-health  Execute whc_check_health once and print JSON",
     "  --version       Print CLI version",
     "  --help          Show this help",
@@ -26,12 +34,13 @@ const HELP_TEXT = [
     "Quick start:",
     "  1) npm install",
     "  2) copy .env.example to .env and fill secrets",
-    "  3) npm run mcp:prepare",
+    "  3) npm run prepare",
     "  4) npm run serve",
     "",
     "Published package use:",
     "  npx -y devops-whc --serve",
     "  npx -y devops-whc --probe",
+    "  npx -y devops-whc --check-generic --project-root D:/Source/mytho/source/wordpress --workflow-mode ssh_scp_wpcli",
     "  npx -y devops-whc --check-health",
     "",
     "Safe release flow:",
@@ -42,13 +51,17 @@ const HELP_TEXT = [
     "  5) smoke gate",
     "  6) promote live only when smoke is green",
     "",
-    "Managed clone/sync payload reminders:",
-    "  - direction is required: live_to_staging or staging_to_live",
-    "  - sync_scope is required for clear safety intent",
-    "  - staging_to_live + database/everything needs backup policy",
+    "Git deploy payload reminders:",
+    "  - repository_root is required",
+    "  - branch is optional; omitted means deploy current configured HEAD",
+    "  - run whc_setup_remote + local git push before whc_deploy",
+    "",
+    "ssh_scp_wpcli reminders:",
+    "  - check-generic validates mytho/source-style doctor prerequisites",
+    "  - whc_deploy currently returns guidance/dry-run only for this mode",
     "",
     "Flow log:",
-    "  - default: .mcp/whc-mcp/logs/flow-events.jsonl",
+    "  - default: .whc/logs/flow-events.jsonl",
     "  - override: set WHC_FLOW_LOG_PATH",
     "",
     "Secrets safety:",
@@ -56,7 +69,7 @@ const HELP_TEXT = [
     "  - npm tarball excludes local env files by design",
     "",
     "Reference:",
-    "  - AGENT_MCP_USAGE.md",
+    "  - AGENT_USAGE.md",
 ].join("\n");
 async function main() {
     if (process.argv.includes("--help")) {
@@ -67,13 +80,13 @@ async function main() {
         console.log(APP_VERSION);
         return;
     }
-    // MCP stdio server mode — all 6 tools registered, reads from stdin/stdout
+    // Stdio server mode — all tools registered, reads from stdin/stdout
     if (process.argv.includes("--serve")) {
-        await (0, server_1.startMcpServer)();
+        await (0, server_1.startWhcToolServer)();
         return;
     }
-    const config = (0, env_1.loadConfig)();
     if (process.argv.includes("--probe")) {
+        const config = (0, env_1.loadConfig)();
         const report = await (0, connectivity_1.runConnectivityProbe)(config);
         const stagingWpCliOk = report.wpcli.staging.reachable;
         console.log(JSON.stringify({
@@ -84,7 +97,187 @@ async function main() {
         }, null, 2));
         return;
     }
+    if (process.argv.includes("--check-generic")) {
+        const projectRootArg = readCliOption("--project-root");
+        if (!projectRootArg) {
+            console.log(JSON.stringify({
+                ok: false,
+                ready_for_deploy: false,
+                status: "blocked",
+                next_actions: [
+                    "Re-run with --project-root <folder> so WHC can bootstrap hidden state for that specific project.",
+                ],
+                action_id: (0, node_crypto_1.randomUUID)(),
+                tool: "whc_source_compatibility_check",
+                data: {
+                    ok: false,
+                    ready_for_deploy: false,
+                    status: "blocked",
+                    blockers: ["Missing required CLI argument: --project-root"],
+                    warnings: [],
+                    next_actions: [
+                        "Use --project-root <folder> to tell WHC which deploy workspace to initialize and check.",
+                    ],
+                    checks: [
+                        {
+                            id: "project-root-argument",
+                            status: "fail",
+                            message: "Project root folder was not provided.",
+                            hint: "Example: npx -y devops-whc --check-generic --project-root D:/Source/mytho/source/wordpress --workflow-mode ssh_scp_wpcli",
+                        },
+                    ],
+                },
+            }, null, 2));
+            return;
+        }
+        const projectRoot = node_path_1.default.resolve(projectRootArg);
+        const appPathArg = readCliOption("--app-path");
+        const effectiveAppPath = appPathArg ?? ".";
+        const appRoot = node_path_1.default.resolve(projectRoot, effectiveAppPath);
+        if (!(0, node_fs_1.existsSync)(appRoot)) {
+            console.log(JSON.stringify({
+                ok: false,
+                ready_for_deploy: false,
+                status: "blocked",
+                next_actions: [
+                    "Fix --app-path so it points to an existing application directory, then rerun check-generic.",
+                ],
+                action_id: (0, node_crypto_1.randomUUID)(),
+                tool: "whc_source_compatibility_check",
+                data: {
+                    ok: false,
+                    ready_for_deploy: false,
+                    status: "blocked",
+                    paths: {
+                        local_project_root: projectRoot,
+                        app_root: appRoot,
+                        wp_content_path: node_path_1.default.resolve(appRoot, "wp-content"),
+                    },
+                    blockers: [`Application path does not exist: ${appRoot}`],
+                    warnings: [],
+                    next_actions: [
+                        "Fix --app-path so it points to an existing application directory, then rerun check-generic.",
+                    ],
+                    checks: [
+                        {
+                            id: "app-root",
+                            status: "fail",
+                            message: "Application root path is missing.",
+                            details: appRoot,
+                            hint: "User must point WHC at the correct project-root/app-path. Hidden WHC files are not initialized until the effective app root is valid.",
+                        },
+                    ],
+                },
+            }, null, 2));
+            return;
+        }
+        const bootstrap = (0, workspace_state_1.ensureWorkspaceBootstrap)(appRoot, {
+            localProjectRoot: projectRoot,
+            localAppPath: appPathArg,
+        });
+        const projectEnv = readProjectEnv(bootstrap.envFile);
+        const mergedEnv = {
+            ...withoutWhcEnv(process.env),
+            ...projectEnv,
+            WHC_LOCAL_PROJECT_ROOT: projectRoot,
+        };
+        if (appPathArg) {
+            mergedEnv.WHC_LOCAL_APP_PATH = appPathArg;
+        }
+        else {
+            mergedEnv.WHC_LOCAL_APP_PATH = "";
+        }
+        const workflowModeArg = readCliOption("--workflow-mode");
+        if (workflowModeArg) {
+            mergedEnv.WHC_WORKFLOW_MODE = workflowModeArg;
+        }
+        let config;
+        try {
+            config = (0, env_1.loadConfig)(mergedEnv);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown config error";
+            const missingKeys = extractMissingEnvKeys(message);
+            console.log(JSON.stringify({
+                ok: false,
+                ready_for_deploy: false,
+                status: "blocked",
+                next_actions: [
+                    `Fill the missing credentials in ${bootstrap.envFile}.`,
+                    "Re-run check-generic after updating the project-local WHC env file.",
+                ],
+                action_id: (0, node_crypto_1.randomUUID)(),
+                tool: "whc_source_compatibility_check",
+                data: {
+                    ok: false,
+                    ready_for_deploy: false,
+                    status: "blocked",
+                    paths: {
+                        local_project_root: projectRoot,
+                        app_root: appRoot,
+                        wp_content_path: node_path_1.default.resolve(appRoot, "wp-content"),
+                    },
+                    bootstrap: {
+                        state_root: bootstrap.stateRootRelative,
+                        created_paths: bootstrap.createdPaths,
+                        pipeline_status_file: bootstrap.pipelineStatusFile,
+                        env_file: bootstrap.envFile,
+                        env_example_file: bootstrap.envExampleFile,
+                        gitignore_updated: bootstrap.gitignoreUpdated,
+                    },
+                    summary: {
+                        pass: 1,
+                        warn: 0,
+                        fail: missingKeys.length,
+                    },
+                    blockers: missingKeys.map((key) => `Set ${key} in ${bootstrap.envFile}`),
+                    warnings: [],
+                    next_actions: [
+                        `Fill the missing credentials in ${bootstrap.envFile}.`,
+                        "Re-run check-generic after updating the project-local WHC env file.",
+                    ],
+                    checks: [
+                        {
+                            id: "workspace-bootstrap",
+                            status: "pass",
+                            message: "App-specific WHC hidden files are initialized.",
+                            details: bootstrap.stateRootAbsolute,
+                        },
+                        ...missingKeys.map((key) => ({
+                            id: `env:${key}`,
+                            status: "fail",
+                            message: `${key} is missing for this project workspace.`,
+                            hint: `Fill ${key} in ${bootstrap.envFile}`,
+                        })),
+                    ],
+                },
+            }, null, 2));
+            return;
+        }
+        const report = await (0, source_compatibility_1.runSourceCompatibilityCheck)(config);
+        console.log(JSON.stringify({
+            ok: report.ok,
+            ready_for_deploy: report.ready_for_deploy,
+            status: report.status,
+            next_actions: report.next_actions,
+            action_id: (0, node_crypto_1.randomUUID)(),
+            tool: "whc_source_compatibility_check",
+            data: {
+                ...report,
+                bootstrap: {
+                    state_root: bootstrap.stateRootRelative,
+                    created_paths: bootstrap.createdPaths,
+                    pipeline_status_file: bootstrap.pipelineStatusFile,
+                    env_file: bootstrap.envFile,
+                    env_example_file: bootstrap.envExampleFile,
+                    gitignore_updated: bootstrap.gitignoreUpdated,
+                },
+            },
+        }, null, 2));
+        return;
+    }
     if (process.argv.includes("--check-health")) {
+        const config = (0, env_1.loadConfig)();
         const request = (0, whc_check_health_1.buildDefaultWhcCheckHealthRequest)(config);
         const toolDef = tool_registry_1.TOOL_REGISTRY["whc_check_health"];
         const result = await (0, tool_dispatcher_1.dispatch)({
@@ -102,6 +295,57 @@ async function main() {
     }
     console.log(HELP_TEXT);
 }
+function readCliOption(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1 || index + 1 >= process.argv.length) {
+        const normalized = flag.replace(/^--/, "").replace(/-/g, "_");
+        const npmConfigValue = process.env[`npm_config_${normalized}`];
+        if (npmConfigValue && npmConfigValue.length > 0) {
+            return npmConfigValue;
+        }
+        return readCheckGenericPositional(flag);
+    }
+    return process.argv[index + 1];
+}
+function readProjectEnv(filePath) {
+    if (!(0, node_fs_1.existsSync)(filePath)) {
+        return {};
+    }
+    const parsed = dotenv_1.default.parse((0, node_fs_1.readFileSync)(filePath, "utf8"));
+    return parsed;
+}
+function extractMissingEnvKeys(message) {
+    const prefix = "VALIDATION_ERROR: Missing or invalid env vars:";
+    if (!message.startsWith(prefix)) {
+        return ["project-specific WHC env values"];
+    }
+    return message
+        .slice(prefix.length)
+        .split(",")
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+}
+function withoutWhcEnv(env) {
+    return Object.fromEntries(Object.entries(env).filter(([key]) => !key.startsWith("WHC_")));
+}
+function readCheckGenericPositional(flag) {
+    const checkIndex = process.argv.indexOf("--check-generic");
+    if (checkIndex === -1) {
+        return undefined;
+    }
+    const trailing = process.argv.slice(checkIndex + 1);
+    const positionalMap = {
+        "--project-root": 0,
+        "--app-path": 1,
+        "--workflow-mode": 2,
+    };
+    const position = positionalMap[flag];
+    if (position === undefined) {
+        return undefined;
+    }
+    const value = trailing[position];
+    return value && !value.startsWith("--") ? value : undefined;
+}
 main().catch((error) => {
     const message = error instanceof Error ? error.message : "Unknown startup error";
     console.error(message);