@podosoft/podokit 0.16.4 → 0.17.1

package/dist/deploy-dispatch.d.ts

@@ -0,0 +1,33 @@
+import type { CommandRunner } from "./dev";
+import { type DeploymentDoctorFinding, type DeploymentPlan, type DeploymentStatus, type VerificationResult } from "./deploy";
+import { type ComposeDoctorFinding, type ComposePlan, type ComposeStatus, type ComposeVerificationResult } from "./deploy-compose";
+import { type DeployDriver } from "./deploy-driver";
+/**
+ * Driver-agnostic entry points.
+ *
+ * A caller that already knows which driver it wants can reach for that driver's
+ * functions directly. Everything that works from a profile name — the CLI's shared
+ * paths, the MCP server — comes through here instead, so adding a driver does not
+ * mean adding a parallel tool for every read-only operation.
+ */
+export declare function doctorAnyDeployment(projectRoot: string, profileName: string, runner?: CommandRunner): {
+    driver: DeployDriver;
+    findings: (DeploymentDoctorFinding | ComposeDoctorFinding)[];
+};
+export declare function planAnyDeployment(projectRoot: string, profileName: string, release: string, runner?: CommandRunner): {
+    driver: DeployDriver;
+    plan: DeploymentPlan | ComposePlan;
+};
+export declare function getAnyDeploymentStatus(projectRoot: string, profileName: string, runner?: CommandRunner): {
+    driver: DeployDriver;
+    status: DeploymentStatus | ComposeStatus;
+};
+export declare function verifyAnyDeployment(projectRoot: string, profileName: string, fetcher?: typeof fetch): Promise<{
+    driver: DeployDriver;
+    verification: VerificationResult | ComposeVerificationResult;
+}>;
+/** A one-line, secret-free description of where a profile points. */
+export declare function describeDeploymentTarget(profile: {
+    driver: DeployDriver;
+    target: Record<string, unknown>;
+}): string;

package/dist/deploy-dispatch.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doctorAnyDeployment = doctorAnyDeployment;
+exports.planAnyDeployment = planAnyDeployment;
+exports.getAnyDeploymentStatus = getAnyDeploymentStatus;
+exports.verifyAnyDeployment = verifyAnyDeployment;
+exports.describeDeploymentTarget = describeDeploymentTarget;
+const deploy_1 = require("./deploy");
+const deploy_compose_1 = require("./deploy-compose");
+const deploy_driver_1 = require("./deploy-driver");
+/**
+ * Driver-agnostic entry points.
+ *
+ * A caller that already knows which driver it wants can reach for that driver's
+ * functions directly. Everything that works from a profile name — the CLI's shared
+ * paths, the MCP server — comes through here instead, so adding a driver does not
+ * mean adding a parallel tool for every read-only operation.
+ */
+function doctorAnyDeployment(projectRoot, profileName, runner) {
+    const driver = (0, deploy_driver_1.readDeploymentDriver)(projectRoot, profileName);
+    const findings = driver === "docker-compose"
+        ? (0, deploy_compose_1.doctorComposeDeployment)(projectRoot, profileName, runner)
+        : (0, deploy_1.doctorDeployment)(projectRoot, profileName, runner);
+    return { driver, findings };
+}
+function planAnyDeployment(projectRoot, profileName, release, runner) {
+    const driver = (0, deploy_driver_1.readDeploymentDriver)(projectRoot, profileName);
+    return {
+        driver,
+        plan: driver === "docker-compose"
+            ? (0, deploy_compose_1.planComposeDeployment)(projectRoot, profileName, release, runner)
+            : (0, deploy_1.planDeployment)(projectRoot, profileName, release, runner),
+    };
+}
+function getAnyDeploymentStatus(projectRoot, profileName, runner) {
+    const driver = (0, deploy_driver_1.readDeploymentDriver)(projectRoot, profileName);
+    return {
+        driver,
+        status: driver === "docker-compose"
+            ? (0, deploy_compose_1.getComposeStatus)(projectRoot, profileName, runner)
+            : (0, deploy_1.getDeploymentStatus)(projectRoot, profileName, runner),
+    };
+}
+async function verifyAnyDeployment(projectRoot, profileName, fetcher) {
+    const driver = (0, deploy_driver_1.readDeploymentDriver)(projectRoot, profileName);
+    return {
+        driver,
+        verification: driver === "docker-compose"
+            ? await (0, deploy_compose_1.verifyComposeDeployment)(projectRoot, profileName, fetcher)
+            : await (0, deploy_1.verifyDeployment)(projectRoot, profileName, fetcher),
+    };
+}
+/** A one-line, secret-free description of where a profile points. */
+function describeDeploymentTarget(profile) {
+    return profile.driver === "docker-compose"
+        ? `driver=docker-compose, context=${String(profile.target.context)}, project=${String(profile.target.project)}`
+        : `driver=kubernetes-helm, context=${String(profile.target.context)}, namespace=${String(profile.target.namespace)}, release=${String(profile.target.release)}`;
+}

package/dist/deploy-driver.d.ts

@@ -0,0 +1,25 @@
+import { DeployProfileV1 } from "./deploy-profile";
+import { DockerComposeProfileV1 } from "./deploy-compose-profile";
+/**
+ * Driver dispatch.
+ *
+ * A profile names its own driver, so reading one is a two-step: look at `driver`,
+ * then hand the document to that driver's parser. Everything downstream narrows on
+ * the same discriminant.
+ */
+export type AnyDeployProfile = DeployProfileV1 | DockerComposeProfileV1;
+export type DeployDriver = AnyDeployProfile["driver"];
+export declare const DEPLOY_DRIVERS: DeployDriver[];
+export interface AnyDeploymentProfileSummary {
+    name: string;
+    path: string;
+    profile: AnyDeployProfile;
+}
+/** The declared driver, read without validating the rest of the document. */
+export declare function readDeploymentDriver(projectRoot: string, name: string): DeployDriver;
+export declare function loadAnyDeploymentProfile(projectRoot: string, name: string): AnyDeployProfile;
+export declare function loadComposeProfile(projectRoot: string, name: string): DockerComposeProfileV1;
+export declare function loadKubernetesProfile(projectRoot: string, name: string): DeployProfileV1;
+export declare function listAnyDeploymentProfiles(projectRoot: string): AnyDeploymentProfileSummary[];
+/** The release tag gate, which both drivers enforce identically. */
+export declare function assertAnyReleaseTag(profile: AnyDeployProfile, release: string): void;

package/dist/deploy-driver.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEPLOY_DRIVERS = void 0;
+exports.readDeploymentDriver = readDeploymentDriver;
+exports.loadAnyDeploymentProfile = loadAnyDeploymentProfile;
+exports.loadComposeProfile = loadComposeProfile;
+exports.loadKubernetesProfile = loadKubernetesProfile;
+exports.listAnyDeploymentProfiles = listAnyDeploymentProfiles;
+exports.assertAnyReleaseTag = assertAnyReleaseTag;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const deploy_profile_1 = require("./deploy-profile");
+const deploy_compose_profile_1 = require("./deploy-compose-profile");
+const deploy_schema_1 = require("./deploy-schema");
+exports.DEPLOY_DRIVERS = ["kubernetes-helm", "docker-compose"];
+function readProfileDocument(projectRoot, name) {
+    const path = (0, deploy_schema_1.profilePath)(projectRoot, name);
+    if (!(0, node_fs_1.existsSync)(path))
+        throw new Error(`Deployment profile "${name}" does not exist at ${path}.`);
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(path, "utf8"));
+    }
+    catch (error) {
+        throw new Error(`Cannot read deployment profile "${name}": ${error.message}`);
+    }
+}
+/** The declared driver, read without validating the rest of the document. */
+function readDeploymentDriver(projectRoot, name) {
+    const document = readProfileDocument(projectRoot, name);
+    if (!(0, deploy_schema_1.isRecord)(document))
+        throw new Error("Deployment profile must be a JSON object.");
+    const driver = document.driver;
+    if (driver !== "kubernetes-helm" && driver !== "docker-compose") {
+        throw new Error(`Unsupported deployment driver: ${String(driver)}. Supported drivers: ${exports.DEPLOY_DRIVERS.join(", ")}.`);
+    }
+    return driver;
+}
+function loadAnyDeploymentProfile(projectRoot, name) {
+    return readDeploymentDriver(projectRoot, name) === "docker-compose"
+        ? (0, deploy_compose_profile_1.parseComposeProfile)(readProfileDocument(projectRoot, name))
+        : (0, deploy_profile_1.loadDeploymentProfile)(projectRoot, name);
+}
+function loadComposeProfile(projectRoot, name) {
+    const profile = loadAnyDeploymentProfile(projectRoot, name);
+    if (profile.driver !== "docker-compose") {
+        throw new Error(`Deployment profile "${name}" uses the ${profile.driver} driver; this command needs docker-compose.`);
+    }
+    return profile;
+}
+function loadKubernetesProfile(projectRoot, name) {
+    const profile = loadAnyDeploymentProfile(projectRoot, name);
+    if (profile.driver !== "kubernetes-helm") {
+        throw new Error(`Deployment profile "${name}" uses the ${profile.driver} driver; this command needs kubernetes-helm.`);
+    }
+    return profile;
+}
+function listAnyDeploymentProfiles(projectRoot) {
+    const directory = (0, deploy_schema_1.profileDirectory)(projectRoot);
+    if (!(0, node_fs_1.existsSync)(directory))
+        return [];
+    return (0, node_fs_1.readdirSync)(directory)
+        .filter((entry) => entry.endsWith(".json"))
+        .sort()
+        .map((entry) => {
+        const name = entry.slice(0, -5);
+        return {
+            name,
+            path: (0, node_path_1.join)(directory, entry),
+            profile: loadAnyDeploymentProfile(projectRoot, name),
+        };
+    });
+}
+/** The release tag gate, which both drivers enforce identically. */
+function assertAnyReleaseTag(profile, release) {
+    if (release === "latest" || !new RegExp(profile.release.tagPattern).test(release)) {
+        throw new Error(`Release "${release}" does not match deployment tag pattern ${profile.release.tagPattern}.`);
+    }
+}

package/dist/deploy-profile.d.ts

@@ -1,3 +1,6 @@
+import { MigrationProfile, VerificationCheckProfile } from "./deploy-schema";
+export { profileDirectory, profilePath } from "./deploy-schema";
+export type { MigrationProfile, VerificationCheckProfile } from "./deploy-schema";
 export type DependencyMode = "inCluster" | "external" | "disabled";
 export interface ResourceProfile {
     cpuRequest: string;
@@ -25,14 +28,6 @@ export interface NamedSecretProfile {
     name: string;
     requiredKeys: string[];
 }
-export interface VerificationCheckProfile {
-    path: string;
-    expectedStatus: number;
-    expectedJson?: Record<string, string | number | boolean | null>;
-}
-export interface MigrationProfile {
-    command: string[];
-}
 export interface DeployProfileV1 {
     schemaVersion: 1;
     driver: "kubernetes-helm";
@@ -82,8 +77,6 @@ export interface DeploymentProfileSummary {
     path: string;
     profile: DeployProfileV1;
 }
-export declare function profileDirectory(projectRoot: string): string;
-export declare function profilePath(projectRoot: string, name: string): string;
 export declare function loadDeploymentProfile(projectRoot: string, name: string): DeployProfileV1;
 export declare function listDeploymentProfiles(projectRoot: string): DeploymentProfileSummary[];
 export interface InitializeDeploymentProfileOptions {