8bitsapps-gcp-utils 1.0.0

package/GCPUtilities/Network.js

@@ -0,0 +1,104 @@
+const { JWT } = require("google-auth-library");
+const axios = require("axios");
+const compute = require("@google-cloud/compute");
+const fs = require("fs/promises");
+const { getConfigPath, getCredentialsPath } = require("../utils/paths.js");
+
+class Network {
+  constructor(configName) {
+    this.configurationName = configName;
+    this.configuration = null;
+    this.credentials = null;
+    this.authClient = null;
+    this.computeClient = null;
+  }
+
+  async loadConfiguration() {
+    if (this.configuration) {
+      return; // Already loaded
+    }
+    if (!this.configurationName)
+      throw new Error("Missing configuration name.");
+    //
+    try {
+      const configFileName = getConfigPath(this.configurationName);
+      console.log(`Loading configuration: ${configFileName}.`);
+      this.configuration = JSON.parse(await fs.readFile(configFileName, "utf8"));
+      //
+      const credentialsFileName = getCredentialsPath(this.configuration.credentialsFile);
+      console.log(`Loading credentials: ${credentialsFileName}.`);
+      this.credentials = JSON.parse(await fs.readFile(credentialsFileName, "utf8"));
+      //
+      this.authClient = new JWT({
+        email: this.credentials?.client_email,
+        key: this.credentials?.private_key,
+        scopes: ["https://www.googleapis.com/auth/cloud-platform"],
+      });
+      this.computeClient = new compute.FirewallsClient({ auth: this.authClient });
+    } 
+    catch (ex) {
+      console.error(`Error while reading the config file: ${ex}.`);
+      throw ex;
+    }
+  }
+
+  unloadConfiguration() {
+    this.configuration = null;
+    this.credentials = null;
+    this.authClient = null;
+    this.computeClient = null;
+  }
+
+  async getPublicIP() {
+    try {
+      const res = await axios.get("https://api.ipify.org?format=json");
+      return res.data.ip;
+    } catch (error) {
+      console.error("Error getting public IP:", error);
+      throw error;
+    }
+  }
+
+  async updateFirewall(options) {
+    await this.loadConfiguration();
+    //
+    const projectId = options?.projectId ?? this.configuration?.defaultProjectId;
+    const firewallRule = options?.firewallRule ?? this.configuration?.defaultFirewallRule;
+    const fixedIPAddresses = options?.fixedIPAddresses ?? this.configuration?.defaultFixedIPAddresses;
+    //
+    if (!projectId || !firewallRule) {
+      throw new Error("Both projectId and firewallRule must be specified either in options or in the configuration file.");
+    }
+    //
+    const ip = await this.getPublicIP();
+    const ipCidr = `${ip}/32`;
+    //
+    try {
+      const [rule] = await this.computeClient.get({
+        project: projectId,
+        firewall: firewallRule,
+      });
+      //
+      const updatedRule = {
+        ...rule,
+        sourceRanges: [...(fixedIPAddresses || []), ipCidr],
+      };
+      //
+      const [operation] = await this.computeClient.patch({
+        project: projectId,
+        firewall: firewallRule,
+        firewallResource: updatedRule,
+      });
+      //
+      console.log("Firewall updated. Operation:", operation.name);
+    } catch (err) {
+      if (err.code === 404) {
+        console.log("Rule not found!");
+      } else {
+        console.error("Error:", err);
+      }
+    }
+  }
+}
+
+module.exports = Network;

package/GCPUtilities/Storage.js

@@ -0,0 +1,185 @@
+const fs = require("fs/promises");
+const { Storage: GoogleCloudStorage } = require("@google-cloud/storage");
+const { getConfigPath, getCredentialsPath } = require("../utils/paths.js");
+
+class Storage {
+  constructor(configName) {
+    this.configurationName = configName;
+    this.configuration = null;
+    this.credentials = null;
+    this.storage = null;
+  }
+
+  async loadConfiguration() {
+    if (this.configuration) {
+      return; // Already loaded.
+    }
+    if (!this.configurationName)
+      throw new Error("Missing configuration name.");
+    //
+    try {
+      const configFileName = getConfigPath(this.configurationName);
+      console.log(`Loading configuration: ${configFileName}.`);
+      this.configuration = JSON.parse(await fs.readFile(configFileName, "utf8"));
+      //
+      const credentialsFileName = getCredentialsPath(this.configuration.credentialsFile);
+      console.log(`Loading credentials: ${credentialsFileName}.`);
+      this.credentials = JSON.parse(await fs.readFile(credentialsFileName, "utf8"));
+      //
+      this.storage = new GoogleCloudStorage({
+        credentials: this.credentials,
+        projectId: this.configuration.defaultProjectId
+      });
+    }
+    catch (ex) {
+      console.error(`Error while reading the config file: ${ex}.`);
+      throw ex;
+    }
+  }
+
+  unloadConfiguration() {
+    this.configuration = null;
+    this.credentials = null;
+    this.storage = null;
+  }
+
+  resolvePath(path) {
+    if (path[0] !== "/") {
+      return `${process.cwd()}/${path}`;
+    }
+    return path;
+  }
+
+  generateUniquePath(path) {
+    const uid = new Date().valueOf();
+    const lastDotPos = path.lastIndexOf(".");
+    if (lastDotPos < 0) {
+      return `${path}-${uid}`;
+    }
+    return `${path.substring(0, lastDotPos)}-${uid}${path.substring(lastDotPos)}`;
+  }
+
+  async upload(pathFile, pathCloud, options) {
+    await this.loadConfiguration();
+    //
+    if (!pathFile || !pathCloud) {
+      throw new Error("Must specify both the path of the local file and the cloud path on the bucket.");
+    }
+    //
+    const bucket = options?.bucket ?? this.configuration?.defaultBucket;
+    if (!bucket) {
+      throw new Error("Bucket must be specified either in options or in the configuration file.");
+    }
+    //
+    const resolvedPathFile = this.resolvePath(pathFile);
+    const uniquePathCloud = this.generateUniquePath(pathCloud);
+    //
+    try {
+      await this.storage.bucket(bucket).upload(resolvedPathFile, {
+        destination: uniquePathCloud,
+        resumable: false,
+      });
+      console.log(`File uploaded to ${bucket}/${uniquePathCloud}.`);
+    } catch (err) {
+      throw new Error(`Error uploading file ${resolvedPathFile} to GCloud ${uniquePathCloud}: ${err}`);
+    }
+  }
+  //
+  /**
+   * Returns the list of configured buckets.
+   * @returns {Array<{name: string, displayName: string}>} List of buckets.
+   */
+  async getBuckets() {
+    await this.loadConfiguration();
+    //
+    if (this.configuration.buckets && this.configuration.buckets.length > 0) {
+      // Normalize buckets to objects with name and displayName.
+      return this.configuration.buckets.map(b => {
+        if (typeof b === "string") {
+          return { name: b, displayName: b };
+        }
+        return b;
+      });
+    }
+    //
+    // Fallback to defaultBucket if buckets array is not defined.
+    if (this.configuration.defaultBucket) {
+      return [{ name: this.configuration.defaultBucket, displayName: this.configuration.defaultBucket }];
+    }
+    //
+    return [];
+  }
+  //
+  /**
+   * Lists objects in a bucket at the given prefix.
+   * @param {string} bucketName - The bucket name.
+   * @param {string} prefix - The folder prefix (empty for root).
+   * @returns {Promise<{folders: string[], files: Array<{name: string, size: number}>}>} Folders and files.
+   */
+  async listObjects(bucketName, prefix = "") {
+    await this.loadConfiguration();
+    //
+    const bucket = this.storage.bucket(bucketName);
+    const [files] = await bucket.getFiles({
+      prefix: prefix,
+      delimiter: "/",
+      autoPaginate: false
+    });
+    //
+    // Get folder prefixes from API response.
+    const [, , apiResponse] = await bucket.getFiles({
+      prefix: prefix,
+      delimiter: "/"
+    });
+    //
+    const folders = apiResponse?.prefixes || [];
+    //
+    // Filter out the prefix itself and get only direct files.
+    const directFiles = files
+      .filter(file => {
+        const relativePath = file.name.slice(prefix.length);
+        return relativePath && !relativePath.includes("/");
+      })
+      .map(file => ({
+        name: file.name,
+        size: parseInt(file.metadata.size, 10) || 0
+      }));
+    //
+    return { folders, files: directFiles };
+  }
+  //
+  /**
+   * Downloads a file from the bucket to a local path.
+   * @param {string} bucketName - The bucket name.
+   * @param {string} remotePath - The remote file path.
+   * @param {string} localPath - The local destination path.
+   */
+  async downloadFile(bucketName, remotePath, localPath) {
+    await this.loadConfiguration();
+    //
+    const bucket = this.storage.bucket(bucketName);
+    const file = bucket.file(remotePath);
+    //
+    await file.download({ destination: localPath });
+  }
+  //
+  /**
+   * Uploads a file to the bucket.
+   * @param {string} bucketName - The bucket name.
+   * @param {string} localPath - The local file path.
+   * @param {string} remotePath - The remote destination path.
+   */
+  async uploadFile(bucketName, localPath, remotePath) {
+    await this.loadConfiguration();
+    //
+    const resolvedPath = this.resolvePath(localPath);
+    const bucket = this.storage.bucket(bucketName);
+    //
+    await bucket.upload(resolvedPath, {
+      destination: remotePath,
+      resumable: false
+    });
+  }
+}
+
+module.exports = Storage;

package/GCPUtilities/index.js

@@ -0,0 +1,9 @@
+const Network = require("./Network.js");
+const GCPUStorage = require("./Storage.js");
+
+const GCPUtils = {
+  Network: Network,
+  Storage: GCPUStorage
+};
+
+module.exports = GCPUtils;

package/README.md

@@ -0,0 +1,126 @@
+# GCP Utils
+
+Interactive CLI tool for managing Google Cloud Platform (GCP) services, including firewall and storage operations.
+
+## Features
+
+### Update Firewall with current IP
+
+Automatically updates a GCP firewall rule with your current public IP address. Useful for development environments with dynamic IPs that need access to firewall-protected resources.
+
+- Automatically detects current public IP.
+- Preserves configured fixed IP addresses.
+- Adds current IP to the firewall rule's sourceRanges.
+
+### Browse and manage GCS storage
+
+Interactive navigator for Google Cloud Storage:
+
+- Browse buckets and folders.
+- View files with size information.
+- Download files to current directory.
+- Upload local files to GCS.
+- Support for multiple buckets per configuration.
+
+### Initialize configuration
+
+Sets up the global configuration directory (`~/.8bitsapps-gcp-utils/`) with the required structure.
+
+## Requirements
+
+- **Node.js**: >= 18.0.0 (Node.js 22 LTS recommended)
+
+## Installation
+
+### Global installation (recommended)
+
+```bash
+npm install -g 8bitsapps-gcp-utils
+```
+
+After installation, the `gcpUtils` command will be available globally.
+
+### Install from source
+
+```bash
+git clone https://github.com/giuseppelanzi-8bitsapps-gcp-utils.git
+cd 8bitsapps-gcp-utils
+npm install
+npm link
+```
+
+The `npm link` command makes `gcpUtils` available globally. To remove:
+
+```bash
+npm unlink
+```
+
+## Configuration
+
+### First run
+
+On first run, the tool will prompt you to initialize:
+
+```bash
+gcpUtils
+```
+
+This creates the following structure:
+
+```
+~/.8bitsapps-gcp-utils/
+├── configurations/
+└── credentials/
+```
+
+### Configuration file
+
+Create a JSON file in `~/.8bitsapps-gcp-utils/configurations/` (e.g., `gcp-options-myproject.json`):
+
+```json
+{
+  "credentialsFile": "my-service-account.json",
+  "defaultProjectId": "my-gcp-project-id",
+  "defaultFirewallRule": "allow-my-ip",
+  "defaultFixedIPAddresses": ["203.0.113.10/32"],
+  "buckets": [
+    { "name": "my-bucket-prod", "displayName": "Production" },
+    { "name": "my-bucket-dev", "displayName": "Development" }
+  ],
+  "defaultBucket": "my-bucket-dev"
+}
+```
+
+| Field | Description |
+|-------|-------------|
+| `credentialsFile` | GCP service account JSON filename (stored in `credentials/`). |
+| `defaultProjectId` | GCP project ID. |
+| `defaultFirewallRule` | Firewall rule name to update. |
+| `defaultFixedIPAddresses` | Array of fixed IPs to always keep in the rule. |
+| `buckets` | Array of available buckets (optional). |
+| `defaultBucket` | Default bucket for storage operations. |
+
+### GCP Credentials
+
+Download your service account JSON from GCP Console and save it in `~/.8bitsapps-gcp-utils/credentials/`.
+
+Required roles:
+
+- **Firewall**: `Compute Security Admin` or `Compute Network Admin`
+- **Storage**: `Storage Object Admin`
+
+## Usage
+
+```bash
+gcpUtils
+```
+
+Navigate menus with arrow keys. Press `ESC` to go back or exit.
+
+## License
+
+ISC
+
+## Author
+
+**8BitsApps** - https://8bitsapps.com

package/commands/index.js

@@ -0,0 +1,14 @@
+const updateFirewall = require("./updateFirewall.js");
+const storageNavigator = require("./storageNavigator.js");
+const init = require("./init.js");
+//
+/**
+ * Registry of available commands.
+ */
+const commands = [
+  updateFirewall,
+  storageNavigator,
+  init
+];
+//
+module.exports = commands;

package/commands/init.js

@@ -0,0 +1,50 @@
+const fs = require("fs/promises");
+const path = require("path");
+const chalk = require("chalk");
+const { getGlobalConfigDir } = require("../utils/paths.js");
+//
+/**
+ * Init command - initializes the global configuration directory.
+ */
+const command = {
+  name: "init",
+  description: "Initialize global configuration directory",
+  async execute() {
+    const configDir = getGlobalConfigDir();
+    const configurationsDir = path.join(configDir, "configurations");
+    const credentialsDir = path.join(configDir, "credentials");
+    //
+    console.log(chalk.cyan("Initializing gcp-utils configuration..."));
+    console.log(`Config directory: ${configDir}`);
+    //
+    // Create directories if they don't exist.
+    await fs.mkdir(configurationsDir, { recursive: true });
+    await fs.mkdir(credentialsDir, { recursive: true });
+    //
+    // Create example configuration file.
+    const exampleConfig = {
+      credentialsFile: "gcp-credentials-example.json",
+      defaultProjectId: "YOUR_PROJECT_ID",
+      defaultFirewallRule: "YOUR_FIREWALL_RULE_NAME",
+      defaultFixedIPAddresses: ["8.8.8.8/32"],
+      defaultBucket: "YOUR_BUCKET_NAME"
+    };
+    const exampleConfigPath = path.join(configurationsDir, "gcp-options-example.json");
+    //
+    try {
+      await fs.access(exampleConfigPath);
+      console.log(chalk.yellow("Example config already exists."));
+    } catch {
+      await fs.writeFile(exampleConfigPath, JSON.stringify(exampleConfig, null, 2));
+      console.log(chalk.green(`Created: ${exampleConfigPath}`));
+    }
+    //
+    console.log(chalk.cyan("\nSetup complete!"));
+    console.log("\nNext steps:");
+    console.log(`1. Add your GCP credentials JSON to: ${credentialsDir}/`);
+    console.log(`2. Edit configuration files in: ${configurationsDir}/`);
+    console.log("3. Run: gcpUtils");
+  }
+};
+//
+module.exports = command;

package/commands/storageNavigator.js

@@ -0,0 +1,282 @@
+const path = require("path");
+const inquirer = require("inquirer");
+const chalk = require("chalk");
+const Storage = require("../GCPUtilities/Storage.js");
+const ListWithEscapePrompt = require("../utils/prompts/listWithEscape.js");
+const { getSettings } = require("../utils/settings.js");
+//
+// Register custom prompt.
+inquirer.registerPrompt("listWithEscape", ListWithEscapePrompt);
+//
+/**
+ * Formats file size in human readable format.
+ * @param {number} bytes - Size in bytes.
+ * @returns {string} Formatted size.
+ */
+function formatSize(bytes) {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  return `${(bytes / Math.pow(1024, i)).toFixed(1)} ${units[i]}`;
+}
+//
+/**
+ * Extracts the display name from a full path.
+ * @param {string} fullPath - The full path.
+ * @param {string} prefix - The current prefix.
+ * @returns {string} The display name.
+ */
+function getDisplayName(fullPath, prefix) {
+  return fullPath.slice(prefix.length);
+}
+//
+/**
+ * Shows bucket selection menu.
+ * @param {Array<{name: string, displayName: string}>} buckets - List of buckets.
+ * @returns {Promise<string|null>} Selected bucket name or null if ESC pressed.
+ */
+async function selectBucket(buckets) {
+  if (buckets.length === 1) {
+    return buckets[0].name;
+  }
+  //
+  const choices = buckets.map((b, i) => ({
+    name: `${i + 1}. ${b.displayName} (${b.name})`,
+    value: b.name
+  }));
+  //
+  const { selected } = await inquirer.prompt([{
+    type: "listWithEscape",
+    name: "selected",
+    message: "Select bucket (ESC exit):",
+    choices,
+    enableBack: false
+  }]);
+  //
+  return selected;
+}
+//
+/**
+ * Shows folder/file navigation menu.
+ * @param {string} bucketName - Current bucket.
+ * @param {string} currentPath - Current path prefix.
+ * @param {{folders: string[], files: Array<{name: string, size: number}>}} contents - Folder contents.
+ * @param {{maxItems: number, backEnabled: boolean}} options - Menu options.
+ * @returns {Promise<{action: string, value: string}|null>} Selected action or null if ESC pressed.
+ */
+async function showNavigationMenu(bucketName, currentPath, contents, options) {
+  const { maxItems, backEnabled } = options;
+  const displayPath = currentPath || "/";
+  const choices = [];
+  let itemCount = 0;
+  let truncated = false;
+  //
+  // Add folders (limited by maxItems).
+  for (const folder of contents.folders) {
+    if (itemCount >= maxItems) {
+      truncated = true;
+      break;
+    }
+    const displayName = getDisplayName(folder, currentPath);
+    choices.push({
+      name: chalk.blue(`[D] ${displayName}`),
+      value: { action: "folder", value: folder }
+    });
+    itemCount++;
+  }
+  //
+  // Add files (limited by maxItems).
+  for (const file of contents.files) {
+    if (itemCount >= maxItems) {
+      truncated = true;
+      break;
+    }
+    const displayName = getDisplayName(file.name, currentPath);
+    const sizeStr = formatSize(file.size);
+    choices.push({
+      name: `[F] ${displayName} (${sizeStr})`,
+      value: { action: "file", value: file.name }
+    });
+    itemCount++;
+  }
+  //
+  // Add separator and upload option.
+  if (choices.length > 0) {
+    choices.push(new inquirer.Separator("─────────────"));
+  }
+  if (truncated) {
+    choices.push(new inquirer.Separator(chalk.yellow(`(showing first ${maxItems} items)`)));
+  }
+  choices.push({
+    name: chalk.green("Upload file here"),
+    value: { action: "upload", value: currentPath }
+  });
+  //
+  const message = backEnabled
+    ? `${bucketName}:${displayPath} (← back, ESC exit)`
+    : `${bucketName}:${displayPath} (ESC exit)`;
+  //
+  const { selected } = await inquirer.prompt([{
+    type: "listWithEscape",
+    name: "selected",
+    message,
+    choices,
+    enableBack: backEnabled
+  }]);
+  //
+  return selected;
+}
+//
+/**
+ * Prompts for local file path to upload.
+ * @returns {Promise<string|null>} Local file path or null if cancelled.
+ */
+async function promptUploadPath() {
+  const { filePath } = await inquirer.prompt([{
+    type: "input",
+    name: "filePath",
+    message: "Enter local file path to upload (or leave empty to cancel):"
+  }]);
+  //
+  return filePath || null;
+}
+//
+/**
+ * Shows the operation log section.
+ * @param {Array<{type: string, message: string}>} logs - Array of log entries.
+ */
+function showOperationLog(logs) {
+  if (logs.length === 0) return;
+  //
+  console.log(chalk.gray("════════════════════════════════════════"));
+  console.log(chalk.gray(" OPERATION LOG"));
+  console.log(chalk.gray("════════════════════════════════════════"));
+  for (const log of logs) {
+    if (log.type === "success") {
+      console.log(chalk.green(` ✓ ${log.message}`));
+    } else if (log.type === "error") {
+      console.log(chalk.red(` ✗ ${log.message}`));
+    } else {
+      console.log(chalk.gray(` · ${log.message}`));
+    }
+  }
+  console.log(chalk.gray("════════════════════════════════════════\n"));
+}
+//
+/**
+ * Storage Navigator command.
+ */
+const command = {
+  name: "storageNavigator",
+  description: "Browse and manage GCS storage",
+  //
+  async execute(configName) {
+    const storage = new Storage(configName);
+    const settings = getSettings();
+    const maxItems = settings.storage.maxItems;
+    //
+    // Get available buckets.
+    const buckets = await storage.getBuckets();
+    if (buckets.length === 0) {
+      console.log(chalk.red("No buckets configured. Add 'buckets' array or 'defaultBucket' to your configuration."));
+      return;
+    }
+    //
+    // Select bucket.
+    const bucketName = await selectBucket(buckets);
+    if (bucketName === null || bucketName?.action === "back") {
+      return; // ESC or back arrow pressed.
+    }
+    //
+    // Navigation loop.
+    const pathHistory = [""];
+    const operationLogs = [];
+    //
+    while (true) {
+      showOperationLog(operationLogs);
+      const currentPath = pathHistory[pathHistory.length - 1];
+      //
+      // List objects at current path.
+      process.stdout.write(chalk.yellow(`\n⏳ Listing ${currentPath || "/"}...`));
+      let contents;
+      try {
+        contents = await storage.listObjects(bucketName, currentPath);
+        // Clear the "Listing..." line (current line, no move up).
+        process.stdout.write("\x1b[2K\x1b[G");
+      } catch (err) {
+        process.stdout.write("\n");
+        console.log(chalk.red(`Error listing objects: ${err.message}`));
+        return;
+      }
+      //
+      // Show navigation menu.
+      const backEnabled = pathHistory.length > 1;
+      const result = await showNavigationMenu(bucketName, currentPath, contents, { maxItems, backEnabled });
+      //
+      if (result === null) {
+        // ESC pressed - exit storage navigator completely.
+        const exitDisplayPath = currentPath || "/";
+        const exitHint = backEnabled ? "(← back, ESC exit)" : "(ESC exit)";
+        process.stdout.write(`\x1b[1A\x1b[2K\x1b[G? ${bucketName}:${exitDisplayPath} ${exitHint} ${chalk.red("<- exit")}`);
+        console.log();
+        return;
+      }
+      //
+      if (result.action === "back") {
+        // Left arrow pressed - go back one level (only possible when backEnabled is true).
+        const backDisplayPath = currentPath || "/";
+        process.stdout.write(`\x1b[1A\x1b[2K\x1b[G? ${bucketName}:${backDisplayPath} (← back, ESC exit) ${chalk.cyan("<- back")}`);
+        pathHistory.pop();
+        continue;
+      }
+      //
+      switch (result.action) {
+      case "folder": {
+        // Force newline, then go back up and overwrite inquirer's colored line.
+        const folderDisplayName = getDisplayName(result.value, currentPath);
+        const folderDisplayPath = currentPath || "/";
+        process.stdout.write("\x1b[1A\x1b[2K\x1b[G");
+        process.stdout.write(`? ${bucketName}:${folderDisplayPath} (← back, ESC exit) ${chalk.cyan(`[D] ${folderDisplayName}`)}`);
+        // Enter folder.
+        pathHistory.push(result.value);
+        break;
+      }
+      //
+      case "file": {
+        // Download file.
+        const fileName = path.basename(result.value);
+        const localPath = path.join(process.cwd(), fileName);
+        //
+        console.log(chalk.yellow(`\n⏳ Downloading ${fileName}...`));
+        try {
+          await storage.downloadFile(bucketName, result.value, localPath);
+          operationLogs.push({ type: "success", message: `Downloaded: ${fileName} → ${localPath}` });
+        } catch (err) {
+          operationLogs.push({ type: "error", message: `Download failed: ${fileName} - ${err.message}` });
+        }
+        break;
+      }
+      //
+      case "upload": {
+        // Upload file.
+        const uploadPath = await promptUploadPath();
+        if (uploadPath) {
+          const uploadFileName = path.basename(uploadPath);
+          const remotePath = currentPath + uploadFileName;
+          //
+          console.log(chalk.yellow(`\n⏳ Uploading ${uploadFileName}...`));
+          try {
+            await storage.uploadFile(bucketName, uploadPath, remotePath);
+            operationLogs.push({ type: "success", message: `Uploaded: ${uploadFileName} → ${bucketName}/${remotePath}` });
+          } catch (err) {
+            operationLogs.push({ type: "error", message: `Upload failed: ${uploadFileName} - ${err.message}` });
+          }
+        }
+        break;
+      }
+      }
+    }
+  }
+};
+//
+module.exports = command;

package/commands/updateFirewall.js

@@ -0,0 +1,16 @@
+const GCPUtils = require("../GCPUtilities");
+//
+/**
+ * Executes the firewall update command.
+ * @param {string} configName - Configuration name.
+ */
+async function execute(configName) {
+  const networkManager = new GCPUtils.Network(configName);
+  await networkManager.updateFirewall();
+}
+//
+module.exports = {
+  name: "updateFirewall",
+  description: "Update Firewall with current IP",
+  execute
+};

package/gcpUtils.js

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+const fs = require("fs/promises");
+const inquirer = require("inquirer");
+const chalk = require("chalk");
+const { isLocalMode, getConfigurationsDir } = require("./utils/paths.js");
+const { listConfigurations } = require("./utils/configLoader.js");
+const commands = require("./commands/index.js");
+const ListWithEscapePrompt = require("./utils/prompts/listWithEscape.js");
+//
+// Register custom prompt with ESC support.
+inquirer.registerPrompt("listWithEscape", ListWithEscapePrompt);
+//
+/**
+ * Shows the main menu to select a command.
+ * @returns {Promise<string>} Selected command name.
+ */
+async function showMainMenu() {
+  // Filter out init command from numbered list.
+  const regularCommands = commands.filter(cmd => cmd.name !== "init");
+  const choices = regularCommands.map((cmd, i) => ({
+    name: `${i + 1}. ${cmd.description}`,
+    value: cmd.name
+  }));
+  // Add init option with "." prefix.
+  choices.push({ name: ".. Initialize repository", value: "init" });
+  //
+  const { selected } = await inquirer.prompt([{
+    type: "listWithEscape",
+    name: "selected",
+    message: "Select command (ESC to exit):",
+    choices,
+    enableBack: false
+  }]);
+  //
+  return selected;
+}
+//
+/**
+ * Shows the configuration selection menu.
+ * @returns {Promise<string>} Selected configuration name.
+ */
+async function showConfigMenu() {
+  const configs = await listConfigurations();
+  //
+  if (configs.length === 0) {
+    console.error(`No configuration found in ${getConfigurationsDir()}/.`);
+    return null;
+  }
+  //
+  const choices = configs.map((cfg, i) => ({
+    name: `${i + 1}. ${cfg}`,
+    value: cfg
+  }));
+  //
+  const { selected } = await inquirer.prompt([{
+    type: "listWithEscape",
+    name: "selected",
+    message: "Select configuration (ESC to go back):",
+    choices,
+    enableBack: false
+  }]);
+  //
+  return selected;
+}
+//
+/**
+ * Checks if the configuration directory is initialized.
+ * @returns {Promise<boolean>} True if initialized with at least one config.
+ */
+async function isInitialized() {
+  try {
+    await fs.access(getConfigurationsDir());
+    const configs = await listConfigurations();
+    return configs.length > 0;
+  } catch {
+    return false;
+  }
+}
+//
+/**
+ * Waits for user to press ENTER or ESC to continue.
+ */
+async function waitForKeypress() {
+  return new Promise((resolve) => {
+    const readline = require("readline");
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    //
+    console.log(chalk.gray("Press ENTER or ESC to continue..."));
+    //
+    process.stdin.once("keypress", (_str, _key) => {
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      process.stdin.pause();
+      resolve();
+    });
+  });
+}
+//
+/**
+ * Shows the application banner.
+ */
+function showBanner() {
+  const mode = isLocalMode() ? "local" : "global";
+  console.log(
+    `=================================================
+${chalk.hex("#FFFFFF")("   █     █    ")} |
+${chalk.hex("#ffff00")("    █   █     ")} |
+${chalk.hex("#fffF00")("   ███████    ")} |    ${chalk.hex("#F77B00").bold("GCP Utils")}
+${chalk.hex("#FFCE00")(" ███  █  ███  ")} |    by ${chalk.whiteBright.bold("8BitsApps")}
+${chalk.hex("#FFCE00")("█████████████ ")} |
+${chalk.hex("#F77B00")("█  ███████  █ ")} |    ${chalk.bgHex("#FFCE00").hex("#000000")("We made app for fun! (ツ)")}
+${chalk.hex("#F77B00")("█  ███████  █ ")} |    ${chalk.hex("#FFCE00")("https://8bitsapps.com")}
+${chalk.hex("#E73100")("    █   █     ")} |
+${chalk.hex("#E73100")("   ██   ██    ")} |    ${chalk.gray(`Mode:${mode}`)}
+_________________________________________________
+`);
+}
+//
+/**
+ * Main entry point.
+ */
+async function main() {
+  console.clear();
+  // Check if initialized.
+  if (!(await isInitialized())) {
+    console.log(chalk.yellow("Configuration not found."));
+    console.log(`Run ${chalk.cyan("gcpUtils")} after initialization to use the tool.\n`);
+    //
+    const { shouldInit } = await inquirer.prompt([{
+      type: "confirm",
+      name: "shouldInit",
+      message: "Would you like to initialize now?",
+      default: true
+    }]);
+    //
+    if (shouldInit) {
+      const initCmd = commands.find(c => c.name === "init");
+      await initCmd.execute();
+    }
+    return;
+  }
+  //
+  while (true) {
+    console.clear();
+    showBanner();
+    const cmdName = await showMainMenu();
+    //
+    // ESC pressed in main menu - exit.
+    if (cmdName === null) {
+      console.log("Goodbye!");
+      return;
+    }
+    //
+    if (cmdName === "init") {
+      const initCmd = commands.find(c => c.name === "init");
+      await initCmd.execute();
+      console.log("\n");
+      await waitForKeypress();
+      continue;
+    }
+    //
+    const cmd = commands.find(c => c.name === cmdName);
+    if (!cmd) {
+      console.error(`Command not found: ${cmdName}`);
+      continue;
+    }
+    //
+    const configName = await showConfigMenu();
+    //
+    // ESC pressed in config menu - go back to main menu.
+    if (configName === null) {
+      continue;
+    }
+    //
+    console.log(`\nRunning: ${cmd.description} with config: ${configName}\n`);
+    //
+    try {
+      await cmd.execute(configName);
+      console.log("\nCompleted.\n");
+    } catch (err) {
+      console.error(`\nError: ${err.message}\n`);
+    }
+    await waitForKeypress();
+  }
+}
+//
+main();

package/myIpToFirewallRule.js

@@ -0,0 +1,44 @@
+const inquirer = require("inquirer");
+const GCPUtils = require("./GCPUtilities");
+const { listConfigurations } = require("./utils/configLoader.js");
+const { getConfigurationsDir } = require("./utils/paths.js");
+//
+/**
+ * Shows configuration selection menu.
+ * @returns {Promise<string>} Selected configuration name.
+ */
+async function selectConfiguration() {
+  const configs = await listConfigurations();
+  //
+  if (configs.length === 0) {
+    throw new Error(`No configuration found in ${getConfigurationsDir()}/. Run 'gcpUtils' to initialize.`);
+  }
+  //
+  const choices = configs.map((cfg, i) => ({
+    name: `${i + 1}. ${cfg}`,
+    value: cfg
+  }));
+  //
+  const { selected } = await inquirer.prompt([{
+    type: "list",
+    name: "selected",
+    message: "Select configuration:",
+    choices
+  }]);
+  //
+  return selected;
+}
+//
+(async () => {
+  let configName = process.argv[2];
+  //
+  // If no argument provided, show interactive menu.
+  if (!configName) {
+    console.log("=== Update Firewall ===\n");
+    configName = await selectConfiguration();
+    console.log();
+  }
+  //
+  const networkManager = new GCPUtils.Network(configName);
+  await networkManager.updateFirewall();
+})();

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "8bitsapps-gcp-utils",
+  "version": "1.0.0",
+  "description": "GCP Utility CLI for firewall and storage operations",
+  "main": "gcpUtils.js",
+  "bin": {
+    "gcpUtils": "./gcpUtils.js"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "gcpUtils.js",
+    "myIpToFirewallRule.js",
+    "commands/",
+    "utils/",
+    "GCPUtilities/"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/giuseppelanzi/8bitsapps-gcp-utils.git"
+  },
+  "keywords": [
+    "gcp",
+    "google-cloud",
+    "firewall",
+    "cli",
+    "utility"
+  ],
+  "author": "Giuseppe Lanzi",
+  "license": "ISC",
+  "scripts": {
+    "test": "eslint .",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
+  },
+  "devDependencies": {
+    "eslint": "^9.18.0",
+    "@eslint/js": "^9.18.0",
+    "globals": "^15.14.0"
+  },
+  "dependencies": {
+    "@google-cloud/compute": "^5.2.0",
+    "@google-cloud/storage": "^7.16.0",
+    "axios": "^1.10.0",
+    "chalk": "^4.1.2",
+    "inquirer": "^8.2.6"
+  }
+}

package/utils/configLoader.js

@@ -0,0 +1,24 @@
+const fs = require("fs/promises");
+const { getConfigurationsDir } = require("./paths.js");
+//
+const CONFIG_PREFIX = "gcp-options-";
+const CONFIG_SUFFIX = ".json";
+//
+/**
+ * Reads configuration names dynamically from the user config directory.
+ * @returns {Promise<string[]>} Array of configuration names.
+ */
+async function listConfigurations() {
+  const configDir = getConfigurationsDir();
+  try {
+    const files = await fs.readdir(configDir);
+    return files
+      .filter(f => f.startsWith(CONFIG_PREFIX) && f.endsWith(CONFIG_SUFFIX))
+      .map(f => f.slice(CONFIG_PREFIX.length, -CONFIG_SUFFIX.length))
+      .sort();
+  } catch {
+    return [];
+  }
+}
+//
+module.exports = { listConfigurations };

package/utils/paths.js

@@ -0,0 +1,77 @@
+const os = require("os");
+const path = require("path");
+const fs = require("fs");
+//
+const APP_NAME = "gcp-utils";
+const LOCAL_CONFIG_DIR = "Configurations";
+const LOCAL_CREDS_DIR = "Credentials";
+//
+/**
+ * Determines if local mode should be used.
+ * @returns {boolean} True if local Configurations/ folder exists.
+ */
+function isLocalMode() {
+  const localConfigPath = path.join(process.cwd(), LOCAL_CONFIG_DIR);
+  return fs.existsSync(localConfigPath);
+}
+//
+/**
+ * Returns the global configuration directory path.
+ * @returns {string} Absolute path to global config directory.
+ */
+function getGlobalConfigDir() {
+  const homeDir = os.homedir();
+  if (process.platform === "win32") {
+    return path.join(process.env.APPDATA || path.join(homeDir, "AppData", "Roaming"), APP_NAME);
+  }
+  return path.join(homeDir, `.${APP_NAME}`);
+}
+//
+/**
+ * Returns the configurations directory path.
+ * @returns {string} Absolute path to configurations directory.
+ */
+function getConfigurationsDir() {
+  if (isLocalMode()) {
+    return path.join(process.cwd(), LOCAL_CONFIG_DIR);
+  }
+  return path.join(getGlobalConfigDir(), "configurations");
+}
+//
+/**
+ * Returns the credentials directory path.
+ * @returns {string} Absolute path to credentials directory.
+ */
+function getCredentialsDir() {
+  if (isLocalMode()) {
+    return path.join(process.cwd(), LOCAL_CREDS_DIR);
+  }
+  return path.join(getGlobalConfigDir(), "credentials");
+}
+//
+/**
+ * Returns the full path to a configuration file.
+ * @param {string} configName - Configuration name.
+ * @returns {string} Absolute path to configuration file.
+ */
+function getConfigPath(configName) {
+  return path.join(getConfigurationsDir(), `gcp-options-${configName}.json`);
+}
+//
+/**
+ * Returns the full path to a credentials file.
+ * @param {string} credentialsFile - Credentials file name.
+ * @returns {string} Absolute path to credentials file.
+ */
+function getCredentialsPath(credentialsFile) {
+  return path.join(getCredentialsDir(), credentialsFile);
+}
+//
+module.exports = {
+  isLocalMode,
+  getGlobalConfigDir,
+  getConfigurationsDir,
+  getCredentialsDir,
+  getConfigPath,
+  getCredentialsPath
+};

package/utils/prompts/listWithEscape.js

@@ -0,0 +1,50 @@
+const ListPrompt = require("inquirer/lib/prompts/list");
+const observe = require("inquirer/lib/utils/events");
+const { takeUntil, filter } = require("rxjs/operators");
+//
+/**
+ * Custom list prompt with ESC and left arrow support.
+ * Returns null when ESC is pressed (exit completely).
+ * Returns { action: "back" } when left arrow is pressed (go back one level).
+ */
+class ListWithEscapePrompt extends ListPrompt {
+  _run(cb) {
+    this.done = cb;
+    const events = observe(this.rl);
+    const enableBack = this.opt.enableBack !== false;
+    //
+    // Handle ESC key - exit completely (always enabled).
+    events.keypress
+      .pipe(
+        takeUntil(events.line),
+        filter(({ key }) => key && key.name === "escape")
+      )
+      .forEach(() => {
+        const height = this.screen.height || 1;
+        const moveUp = Math.max(1, height - 1);
+        process.stdout.write(`\x1b[${moveUp}A\x1b[J\x1b[G`);
+        this.screen.done();
+        this.done(null);
+      });
+    //
+    // Handle left arrow - go back one level (only if enabled).
+    if (enableBack) {
+      events.keypress
+        .pipe(
+          takeUntil(events.line),
+          filter(({ key }) => key && key.name === "left")
+        )
+        .forEach(() => {
+          const height = this.screen.height || 1;
+          const moveUp = Math.max(1, height - 1);
+          process.stdout.write(`\x1b[${moveUp}A\x1b[J\x1b[G`);
+          this.screen.done();
+          this.done({ action: "back" });
+        });
+    }
+    //
+    return super._run(cb);
+  }
+}
+//
+module.exports = ListWithEscapePrompt;

package/utils/settings.js

@@ -0,0 +1,53 @@
+const fs = require("fs");
+const path = require("path");
+const { getGlobalConfigDir } = require("./paths.js");
+//
+const SETTINGS_FILE = "settings.json";
+//
+/**
+ * Default settings.
+ */
+const defaultSettings = {
+  storage: {
+    maxItems: 30
+  }
+};
+//
+/**
+ * Loads and returns the application settings.
+ * Looks for settings.json in local directory first, then global.
+ * @returns {object} Settings object with defaults merged.
+ */
+function getSettings() {
+  let userSettings = {};
+  //
+  // Try local settings first.
+  const localPath = path.join(process.cwd(), SETTINGS_FILE);
+  if (fs.existsSync(localPath)) {
+    try {
+      userSettings = JSON.parse(fs.readFileSync(localPath, "utf8"));
+    } catch {
+      // Ignore parse errors.
+    }
+  } else {
+    // Try global settings.
+    const globalPath = path.join(getGlobalConfigDir(), SETTINGS_FILE);
+    if (fs.existsSync(globalPath)) {
+      try {
+        userSettings = JSON.parse(fs.readFileSync(globalPath, "utf8"));
+      } catch {
+        // Ignore parse errors.
+      }
+    }
+  }
+  //
+  // Merge with defaults.
+  return {
+    storage: {
+      ...defaultSettings.storage,
+      ...userSettings.storage
+    }
+  };
+}
+//
+module.exports = { getSettings };