@pitcher/cli-scripts 1.1.0 → 2.0.1

package/README.md

@@ -2,30 +2,46 @@
 
 > Pitcher CLI Tools provide a suite of command-line utilities to streamline your workflow. For the best experience, we recommend installing the tools globally using `npm install -g @pitcher/cli-scripts`.
 
-
 ## Help
+
 ```bash
 p --help
 # or for specific command help:
 p command --help
 ```
 
-
-## To run the `copy-instance-files` command:
-
-```bash
-p copy-instance-files <fromInstance> <toInstance> --org pitcher --api-key myapikey
-```
-
 ## To run the `publish-app` command:
+
 ```bash
+# Basic usage
 p publish-app <folder> --url https://dev.my.pitcher.com --api-key myapikey
-# or for current folder and dev org
+
+# Publish to current folder and dev org
 p publish-app --api-key myapikey
-# or for dry run and incrementing app.json's version
+
+# Dry run with version increment
 p publish-app --api-key myapikey --dry-run --increment-version
 
+# Publish and install to specific instances
+p publish-app --api-key myapikey --increment-version --install-to "01HG0C5NS1BTQ2ZPE1XCGKSGDH, 01HG0C5NS1BTQ2ZPE1XCGKSGDA"
+
+# Publish and install to all instances with a specific environment name
+p publish-app --api-key myapikey --increment-version --install-to-env-name "Demo"
+
+# Combine both: install to specific instances AND all instances in an environment
+p publish-app --api-key myapikey --increment-version --install-to "01HG0C5NS1BTQ2ZPE1XCGKSGDH" --install-to-env-name "Demo"
+
 # Alternative: Set API key via environment variable
 export NG_API_KEY=myapikey
-p publish-app --increment-version
+p publish-app --increment-version --install-to-env-name "Production"
 ```
+
+### Options
+
+- `--api-key <apiKey>`: API Key for authentication (can also use `NG_API_KEY` env variable)
+- `--org <organization>`: Organization subdomain (default: "dev")
+- `--increment-version`: Increment version in app.json with timestamp
+- `--dry-run`: Perform a dry run without publishing
+- `--publish-url <url>`: Explicit publish URL
+- `--install-to <instanceIds>`: Comma-separated list of instance IDs to install the app to after publishing
+- `--install-to-env-name <envName>`: Environment name to filter instances and install the app to after publishing

package/dist/copyInstanceFiles.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createCopyInstanceFilesCommand(): Command;

package/dist/copyInstanceFiles.js

@@ -0,0 +1,17 @@
+import { Command } from "commander";
+export function createCopyInstanceFilesCommand() {
+    const program = new Command("copy-instance-files");
+    program
+        .arguments("<fromInstance> <toInstance>")
+        .requiredOption("--api-key <apiKey>", "API Key", process.env.PITCHER_API_KEY)
+        .requiredOption("--org <orgName>", "Organization Name", process.env.PITCHER_ORG)
+        .description('clone instance files into another one e.g. "p copy-instance-files <fromInstanceId> <toInstanceId> --org mondelez --api-key myapikey"')
+        .action((sourceInstanceId, destinationInstanceId, options) => {
+        console.log("clone instance files command called", {
+            sourceInstanceId,
+            destinationInstanceId,
+            options,
+        });
+    });
+    return program;
+}

package/dist/index.js

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 import { Command } from "commander";
-import { createCopyInstanceFilesCommand } from "./src/copyInstanceFiles.js";
 import { createPublishAppCommand } from "./src/publishApp.js";
 import { readFileSync } from "fs";
 import { fileURLToPath } from "url";
@@ -14,6 +13,5 @@ program
     .description("The Pitcher CLI for various tasks in its ecosystem.")
     .version(pkg.version);
 // Add subcommands
-program.addCommand(createCopyInstanceFilesCommand());
 program.addCommand(createPublishAppCommand());
 program.parse(process.argv);

package/dist/package.json

@@ -0,0 +1,40 @@
+{
+    "name": "@pitcher/cli-scripts",
+    "version": "1.0.6",
+    "description": "The Pitcher CLI for various tasks in its ecosystem.",
+    "author": "Pitcher AG",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/PitcherAG/ng-scripts.git"
+    },
+    "keywords": [
+        "pitcher",
+        "cli",
+        "ng-scripts"
+    ],
+    "type": "module",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "scripts": {
+        "build": "tsc",
+        "prepublishOnly": "npm run build"
+    },
+    "bin": {
+        "p": "node --no-warnings ./dist/index.js"
+    },
+    "files": [
+        "dist"
+    ],
+    "devDependencies": {
+        "@types/archiver": "^6.0.2",
+        "@types/node": "^20.0.0",
+        "typescript": "^5.4.5"
+    },
+    "dependencies": {
+        "archiver": "^7.0.1",
+        "axios": "^1.7.2",
+        "commander": "^12.1.0",
+        "form-data": "^4.0.0"
+    }
+}

package/dist/publishApp.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createPublishAppCommand(): Command;

package/dist/publishApp.js

@@ -0,0 +1,93 @@
+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';
+export function createPublishAppCommand() {
+    const program = new Command("publish-app");
+    program
+        .arguments("[folder]")
+        .requiredOption("--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")
+        .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) => {
+        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);
+                    }
+                    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;
+}

package/dist/src/publishApp.js

@@ -4,7 +4,113 @@ import axios from "axios";
 import fs from "fs";
 import path from "path";
 import FormData from "form-data";
-import { fileURLToPath } from 'url';
+import { fileURLToPath } from "url";
+async function fetchAllInstances(baseUrl, apiKey) {
+    const pageSize = 100;
+    const maxPages = 1000;
+    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) => instance.env_name === envName);
+    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((inst) => {
+        console.log(`  - ${inst.id}${inst.env_name ? ` (${inst.env_name})` : ""}${inst.name ? ` - ${inst.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
@@ -14,6 +120,8 @@ export function createPublishAppCommand() {
         .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;
@@ -21,6 +129,8 @@ export function createPublishAppCommand() {
             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);
@@ -53,7 +163,8 @@ export function createPublishAppCommand() {
                 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/`;
+                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);
@@ -73,6 +184,51 @@ export function createPublishAppCommand() {
                             },
                         });
                         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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pitcher/cli-scripts",
-  "version": "1.1.0",
+  "version": "2.0.1",
   "description": "The Pitcher CLI for various tasks in its ecosystem.",
   "author": "Pitcher AG",
   "license": "MIT",
@@ -24,12 +24,12 @@
   ],
   "devDependencies": {
     "@types/archiver": "^6.0.3",
-    "@types/node": "^22.13.4",
-    "typescript": "^5.7.3"
+    "@types/node": "^22.18.0",
+    "typescript": "^5.9.2"
   },
   "dependencies": {
     "archiver": "^7.0.1",
-    "axios": "^1.8.3",
+    "axios": "^1.12.0",
     "commander": "^13.1.0",
     "form-data": "^4.0.2"
   }