@pitcher/cli-scripts 2.1.2 → 2.2.1

package/dist/src/publishApp.js

@@ -1,257 +0,0 @@
-import { Command } from "commander";
-import archiver from "archiver";
-import axios from "axios";
-import fs from "fs";
-import path from "path";
-import FormData from "form-data";
-import { fileURLToPath } from "url";
-async function fetchAllInstances(baseUrl, apiKey) {
-    const pageSize = 100;
-    const maxPages = 50;
-    try {
-        console.log("Fetching instances page 1 to determine total count...");
-        const firstResponse = await axios.get(`${baseUrl}/api/v1/instances`, {
-            headers: {
-                accept: "application/json",
-                "x-api-key": apiKey,
-            },
-            params: {
-                page_size: pageSize,
-                page: 1,
-            },
-        });
-        const firstData = firstResponse.data;
-        const firstInstances = firstData.results || [];
-        if (firstInstances.length === 0) {
-            console.log("No instances found");
-            return [];
-        }
-        const totalCount = firstData.count || firstInstances.length;
-        const totalPages = Math.min(Math.ceil(totalCount / pageSize), maxPages);
-        console.log(`Found ${totalCount} instance(s) across ${totalPages} page(s)`);
-        if (totalPages === 1) {
-            console.log(`✓ Fetched ${firstInstances.length} total instance(s) from API`);
-            return firstInstances;
-        }
-        const remainingPageNumbers = Array.from({ length: totalPages - 1 }, (_, i) => i + 2);
-        console.log(`Fetching remaining ${totalPages - 1} pages in parallel...`);
-        const remainingPagePromises = remainingPageNumbers.map((page) => axios.get(`${baseUrl}/api/v1/instances`, {
-            headers: {
-                accept: "application/json",
-                "x-api-key": apiKey,
-            },
-            params: {
-                page_size: pageSize,
-                page: page,
-            },
-        }));
-        const remainingResponses = await Promise.all(remainingPagePromises);
-        const remainingInstances = remainingResponses.flatMap((response) => response.data.results || []);
-        const allInstances = [...firstInstances, ...remainingInstances];
-        if (totalPages >= maxPages) {
-            console.warn(`⚠ Warning: Reached maximum page limit (${maxPages}). There may be more instances.`);
-        }
-        console.log(`✓ Fetched ${allInstances.length} total instance(s) from API`);
-        return allInstances;
-    }
-    catch (error) {
-        const axiosError = error;
-        console.error("Error fetching instances:", axiosError?.response?.data?.detail ?? axiosError.message);
-        return [];
-    }
-}
-function filterInstancesByEnvName(instances, envName) {
-    const filtered = instances.filter((instance) => {
-        return instance.environment?.name.toLowerCase() === envName.toLowerCase();
-    });
-    if (filtered.length === 0) {
-        console.warn(`No instances found with environment name "${envName}"`);
-    }
-    else {
-        console.log(`Found ${filtered.length} instance(s) with environment name "${envName}"`);
-    }
-    return filtered;
-}
-function validateInstanceIds(instances, requestedIds) {
-    const instanceMap = new Map(instances.map((inst) => [inst.id, inst]));
-    const valid = [];
-    const invalid = [];
-    for (const id of requestedIds) {
-        const instance = instanceMap.get(id);
-        if (instance) {
-            valid.push(instance);
-        }
-        else {
-            invalid.push(id);
-        }
-    }
-    return { valid, invalid };
-}
-async function installAppToInstances(baseUrl, apiKey, appName, instances) {
-    if (instances.length === 0) {
-        console.log("No instances to install to.");
-        return;
-    }
-    const instanceIds = instances.map((inst) => inst.id);
-    console.log(`\nInstalling app "${appName}" to ${instances.length} instance(s):`);
-    instances.forEach((i) => {
-        console.log(`  - ${i.id}${i.environment?.name ? ` (${i.environment.name})` : ""}${i.name ? ` - ${i.name}` : ""}`);
-    });
-    try {
-        const response = await axios.post(`${baseUrl}/api/v1/apps/${appName}/install/`, { instance_ids: instanceIds }, {
-            headers: {
-                accept: "application/json",
-                "content-type": "application/json",
-                "x-api-key": apiKey,
-            },
-        });
-        console.log("\nInstallation response:", response.data);
-        console.log(`✓ Successfully installed app to ${instances.length} instance(s)`);
-    }
-    catch (error) {
-        const axiosError = error;
-        console.error("\n✗ Error installing app:", axiosError?.response?.data?.detail ?? axiosError.message);
-    }
-}
-export function createPublishAppCommand() {
-    const program = new Command("publish-app");
-    program
-        .arguments("[folder]")
-        .option("--api-key <apiKey>", "API Key for authentication")
-        .option("--org <organization>", "Organization subdomain", "dev")
-        .option("--increment-version", "Increment version in app.json")
-        .option("--dry-run", "Perform a dry run without publishing")
-        .option("--publish-url <url>", "Explicit publish URL")
-        .option("--install-to <instanceIds>", "Comma-separated list of instance IDs to install the app to after publishing")
-        .option("--install-to-env-name <envName>", "Environment name to filter instances and install the app to after publishing")
-        .description('zip the contents of a folder and publish as an app to a pitcher org URL. for current folder: "p publish-app --api-key myapikey"')
-        .action(async (folder = ".", options) => {
-        const apiKey = options.apiKey || process.env.NG_API_KEY;
-        if (!apiKey) {
-            console.error("Error: API key is required. Provide it via --api-key or set the NG_API_KEY environment variable.");
-            process.exit(1);
-        }
-        if (!options.publishUrl && !options.org)
-            options.org = "dev";
-        options.apiKey = apiKey;
-        try {
-            const folderPath = path.resolve(folder);
-            if (options.incrementVersion) {
-                const appJsonPath = path.join(folderPath, "app.json");
-                if (fs.existsSync(appJsonPath)) {
-                    const appJson = JSON.parse(fs.readFileSync(appJsonPath, "utf-8"));
-                    const now = new Date();
-                    const year = now.getFullYear();
-                    const month = String(now.getMonth() + 1).padStart(2, "0");
-                    const day = String(now.getDate()).padStart(2, "0");
-                    const timestamp = now.getTime();
-                    const version = `${year}.${month}.${day}.${timestamp}`;
-                    appJson.version = version;
-                    fs.writeFileSync(appJsonPath, JSON.stringify(appJson, null, 2));
-                    console.log(`Updated app.json version to ${version}`);
-                }
-                else {
-                    console.error("app.json not found in the specified folder.");
-                    return;
-                }
-            }
-            const currentDir = path.dirname(fileURLToPath(import.meta.url));
-            const zipFilePath = path.join(currentDir, "app.zip");
-            const output = fs.createWriteStream(zipFilePath);
-            const archive = archiver("zip", {
-                zlib: { level: 9 },
-            });
-            output.on("close", async () => {
-                console.log(`Zipped ${archive.pointer()} total bytes`);
-                const formData = new FormData();
-                formData.append("file", fs.createReadStream(zipFilePath));
-                const publishUrl = options.publishUrl ||
-                    `https://${options.org}.my.pitcher.com/api/v1/apps/publish/`;
-                if (options.dryRun) {
-                    console.log("Dry run mode enabled. The following data would be published:");
-                    console.log("Publish URL:", publishUrl);
-                    console.log("Headers:", {
-                        ...formData.getHeaders(),
-                        "x-api-key": options.apiKey,
-                    });
-                    console.log("app.json content:", fs.readFileSync(path.join(folderPath, "app.json"), "utf-8"));
-                    fs.unlinkSync(zipFilePath);
-                }
-                else {
-                    try {
-                        const response = await axios.post(publishUrl, formData, {
-                            headers: {
-                                ...formData.getHeaders(),
-                                "x-api-key": options.apiKey,
-                            },
-                        });
-                        console.log("Publish response:", response.data);
-                        const baseUrl = options.publishUrl
-                            ? new URL(options.publishUrl).origin
-                            : `https://${options.org}.my.pitcher.com`;
-                        const appName = response.data?.app?.name;
-                        if (!appName) {
-                            console.warn("Could not determine app name from publish response");
-                        }
-                        else if (options.installTo || options.installToEnvName) {
-                            console.log("\n--- Starting installation process ---");
-                            const allInstances = await fetchAllInstances(baseUrl, options.apiKey);
-                            if (allInstances.length === 0) {
-                                console.warn("Cannot proceed with installation: no instances available");
-                            }
-                            else {
-                                let targetInstances = [];
-                                if (options.installTo) {
-                                    const requestedIds = options.installTo
-                                        .split(",")
-                                        .map((id) => id.trim())
-                                        .filter(Boolean);
-                                    console.log(`\nValidating ${requestedIds.length} requested instance ID(s)...`);
-                                    const { valid, invalid } = validateInstanceIds(allInstances, requestedIds);
-                                    if (invalid.length > 0) {
-                                        console.warn(`⚠ Warning: ${invalid.length} invalid instance ID(s) will be skipped:`);
-                                        invalid.forEach((id) => console.warn(`  - ${id}`));
-                                    }
-                                    if (valid.length > 0) {
-                                        console.log(`✓ Found ${valid.length} valid instance(s)`);
-                                        targetInstances = [...targetInstances, ...valid];
-                                    }
-                                }
-                                if (options.installToEnvName) {
-                                    console.log(`\nFiltering instances by environment name: "${options.installToEnvName}"`);
-                                    const envInstances = filterInstancesByEnvName(allInstances, options.installToEnvName);
-                                    targetInstances = [...targetInstances, ...envInstances];
-                                }
-                                const uniqueInstances = Array.from(new Map(targetInstances.map((inst) => [inst.id, inst])).values());
-                                if (uniqueInstances.length > 0) {
-                                    await installAppToInstances(baseUrl, options.apiKey, appName, uniqueInstances);
-                                }
-                                else {
-                                    console.log("\nNo valid instances found to install to.");
-                                }
-                            }
-                        }
-                    }
-                    catch (e) {
-                        const error = e;
-                        const errData = error?.response?.data;
-                        console.error("Error publishing:", errData?.detail ?? errData);
-                    }
-                    finally {
-                        fs.unlinkSync(zipFilePath);
-                    }
-                }
-            });
-            archive.on("error", (err) => {
-                throw err;
-            });
-            archive.pipe(output);
-            archive.directory(folderPath, false);
-            await archive.finalize();
-        }
-        catch (error) {
-            console.error("Error zipping or publishing:", error);
-        }
-    });
-    return program;
-}