@bluealba/platform-cli 0.3.1-feature-platform-cli-229 → 0.3.1-feature-platform-cli-231

package/dist/index.js

@@ -2095,6 +2095,139 @@ var statusCommand = {
   hidden: (ctx) => !ctx.platformInitialized
 };
 
+// src/commands/manage-platform-admins/manage-platform-admins.command.ts
+import { join as join25 } from "path";
+import { fetch as undiciFetch2, Agent as Agent2 } from "undici";
+var MANAGE_PLATFORM_ADMINS_COMMAND_NAME = "manage-platform-admins";
+var managePlatformAdminsCommand = {
+  name: MANAGE_PLATFORM_ADMINS_COMMAND_NAME,
+  description: "Manage platform administrators (list, add, remove)",
+  hidden: (ctx) => !ctx.platformInitialized
+};
+async function getGatewayConfig(logger) {
+  const layout = await findPlatformLayout();
+  if (!layout) {
+    logger.log("Error: Cannot manage platform admins \u2014 no platform initialized in this directory.");
+    return null;
+  }
+  const envPath = join25(layout.localDir, ".env");
+  let env;
+  try {
+    env = await readEnvFile(envPath);
+  } catch (error) {
+    logger.log(`Error: ${error.message}`);
+    return null;
+  }
+  const gatewayUrl = env.get("PAE_GATEWAY_HOST_URL");
+  const accessSecret = env.get("PAE_GATEWAY_SERVICE_ACCESS_SECRET");
+  if (!gatewayUrl) {
+    logger.log("Error: PAE_GATEWAY_HOST_URL is not set in core/local/.env");
+    return null;
+  }
+  if (!accessSecret) {
+    logger.log("Error: PAE_GATEWAY_SERVICE_ACCESS_SECRET is not set in core/local/.env");
+    return null;
+  }
+  return { gatewayUrl, accessSecret };
+}
+async function listPlatformAdmins(logger) {
+  const config = await getGatewayConfig(logger);
+  if (!config) return [];
+  const { gatewayUrl, accessSecret } = config;
+  const agent = new Agent2({ connect: { rejectUnauthorized: false } });
+  let response;
+  try {
+    response = await undiciFetch2(`${gatewayUrl}/applications/platform/rules`, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${accessSecret}`
+      },
+      dispatcher: agent
+    });
+  } catch (error) {
+    const err = error;
+    const cause = err.cause instanceof Error ? ` (cause: ${err.cause.message})` : err.cause ? ` (cause: ${String(err.cause)})` : "";
+    logger.log(`Error: Failed to reach gateway \u2014 ${err.message}${cause}`);
+    return [];
+  }
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    logger.log(`Error: Server responded with ${response.status}${body ? ` \u2014 ${body}` : ""}`);
+    return [];
+  }
+  const rules = await response.json();
+  return rules.filter(
+    (r) => r.subjectType === "user" && r.resourceType === "role" && r.resourceName === "admin"
+  ).map((r) => ({ username: r.subject, ruleId: String(r.id) }));
+}
+async function addPlatformAdmin(username, logger) {
+  const config = await getGatewayConfig(logger);
+  if (!config) return false;
+  const { gatewayUrl, accessSecret } = config;
+  const agent = new Agent2({ connect: { rejectUnauthorized: false } });
+  let response;
+  try {
+    response = await undiciFetch2(`${gatewayUrl}/applications/platform/rules`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        Authorization: `Bearer ${accessSecret}`
+      },
+      body: JSON.stringify({
+        subject: username,
+        subjectType: "user",
+        resourceType: "role",
+        resource: "admin"
+      }),
+      dispatcher: agent
+    });
+  } catch (error) {
+    const err = error;
+    const cause = err.cause instanceof Error ? ` (cause: ${err.cause.message})` : err.cause ? ` (cause: ${String(err.cause)})` : "";
+    logger.log(`Error: Failed to reach gateway \u2014 ${err.message}${cause}`);
+    return false;
+  }
+  if (response.status === 409) {
+    logger.log(`'${username}' is already a platform admin.`);
+    return false;
+  }
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    logger.log(`Error: Server responded with ${response.status}${body ? ` \u2014 ${body}` : ""}`);
+    return false;
+  }
+  return true;
+}
+async function removePlatformAdmin(ruleId, logger) {
+  const config = await getGatewayConfig(logger);
+  if (!config) return false;
+  const { gatewayUrl, accessSecret } = config;
+  const agent = new Agent2({ connect: { rejectUnauthorized: false } });
+  let response;
+  try {
+    response = await undiciFetch2(`${gatewayUrl}/applications/platform/rules/${ruleId}`, {
+      method: "DELETE",
+      headers: {
+        Authorization: `Bearer ${accessSecret}`
+      },
+      dispatcher: agent
+    });
+  } catch (error) {
+    const err = error;
+    const cause = err.cause instanceof Error ? ` (cause: ${err.cause.message})` : err.cause ? ` (cause: ${String(err.cause)})` : "";
+    logger.log(`Error: Failed to reach gateway \u2014 ${err.message}${cause}`);
+    return false;
+  }
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    logger.log(`Error: Server responded with ${response.status}${body ? ` \u2014 ${body}` : ""}`);
+    return false;
+  }
+  return true;
+}
+
 // src/commands/registry.ts
 var CommandRegistry = class {
   commands = /* @__PURE__ */ new Map();
@@ -2134,6 +2267,7 @@ for (const cmd of localScriptCommands) {
   registry.register(cmd);
 }
 registry.register(statusCommand);
+registry.register(managePlatformAdminsCommand);
 
 // src/app-state.ts
 var APP_STATE = {
@@ -2498,6 +2632,131 @@ function createLocalScriptUiController(scriptName) {
   };
 }
 
+// src/controllers/ui/manage-platform-admins.ui-controller.ts
+import { execSync } from "child_process";
+
+// src/services/manage-platform-admins.service.ts
+async function listAdminsService(logger) {
+  return listPlatformAdmins(logger);
+}
+async function addAdminService(username, logger) {
+  return addPlatformAdmin(username, logger);
+}
+async function removeAdminService(ruleId, logger) {
+  return removePlatformAdmin(ruleId, logger);
+}
+
+// src/controllers/ui/manage-platform-admins.ui-controller.ts
+function getDefaultUsername() {
+  try {
+    const email = execSync("git config user.email", { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    return email || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function managePlatformAdminsUiController(ctx) {
+  if (!await isPlatformInitialized()) {
+    ctx.log("Error: Cannot manage platform admins \u2014 no platform initialized in this directory.");
+    return;
+  }
+  while (true) {
+    const action = await ctx.select("What would you like to do?", [
+      { label: "List current admins", value: "list" },
+      { label: "Add admin(s)", value: "add" },
+      { label: "Remove admin(s)", value: "remove" },
+      { label: "Back to main menu", value: "back" }
+    ]);
+    if (action === "list") {
+      await handleList(ctx);
+    } else if (action === "add") {
+      await handleAdd(ctx);
+    } else if (action === "remove") {
+      await handleRemove(ctx);
+    } else if (action === "back") {
+      break;
+    }
+  }
+}
+async function handleList(ctx) {
+  const admins = await listAdminsService(ctx);
+  if (admins.length === 0) {
+    ctx.log("No platform admins found.");
+  } else {
+    ctx.log("Current platform admins:");
+    for (const admin of admins) {
+      ctx.log(`  - ${admin.username}`);
+    }
+  }
+}
+async function handleAdd(ctx) {
+  const currentAdmins = await listAdminsService(ctx);
+  const existingUsernames = new Set(currentAdmins.map((a) => a.username));
+  const pendingAdmins = [];
+  const suggestedUsername = getDefaultUsername();
+  let isFirstIteration = true;
+  while (true) {
+    const defaultValue = isFirstIteration ? suggestedUsername : void 0;
+    const username = (await ctx.prompt("Username to add as admin:", defaultValue)).trim();
+    isFirstIteration = false;
+    if (!username) {
+      ctx.log("Username cannot be empty, skipping.");
+    } else if (existingUsernames.has(username)) {
+      ctx.log(`'${username}' is already a platform admin.`);
+    } else if (pendingAdmins.includes(username)) {
+      ctx.log(`'${username}' is already in the pending list.`);
+    } else {
+      pendingAdmins.push(username);
+      ctx.log(`Admins to add: ${pendingAdmins.join(", ")}`);
+    }
+    const addAnother = await ctx.confirm("Add another admin?", false);
+    if (!addAnother) break;
+  }
+  if (pendingAdmins.length === 0) {
+    ctx.log("No admins to add.");
+    return;
+  }
+  let successCount = 0;
+  for (const username of pendingAdmins) {
+    const ok = await addAdminService(username, ctx);
+    if (ok) {
+      ctx.log(`'${username}' granted platform admin access.`);
+      successCount++;
+    }
+  }
+  ctx.log(`Successfully added ${successCount} of ${pendingAdmins.length} admin(s).`);
+}
+async function handleRemove(ctx) {
+  const admins = await listAdminsService(ctx);
+  if (admins.length === 0) {
+    ctx.log("No platform admins to remove.");
+    return;
+  }
+  const selected = await ctx.multiselect(
+    "Select admins to remove:",
+    admins.map((a) => ({ label: a.username, value: a.ruleId }))
+  );
+  if (selected.length === 0) {
+    ctx.log("No admins selected.");
+    return;
+  }
+  const confirmed = await ctx.confirm(`Remove ${selected.length} admin(s)?`, false);
+  if (!confirmed) {
+    ctx.log("Cancelled.");
+    return;
+  }
+  let successCount = 0;
+  for (const ruleId of selected) {
+    const admin = admins.find((a) => a.ruleId === ruleId);
+    const ok = await removeAdminService(ruleId, ctx);
+    if (ok) {
+      ctx.log(`'${admin?.username ?? ruleId}' removed from platform admins.`);
+      successCount++;
+    }
+  }
+  ctx.log(`Successfully removed ${successCount} of ${selected.length} admin(s).`);
+}
+
 // src/controllers/ui/registry.ts
 var uiControllers = /* @__PURE__ */ new Map([
   [CREATE_APPLICATION_COMMAND_NAME, createApplicationUiController],
@@ -2510,7 +2769,8 @@ var uiControllers = /* @__PURE__ */ new Map([
   [BUILD_COMMAND_NAME, createLocalScriptUiController(BUILD_COMMAND_NAME)],
   [START_COMMAND_NAME, createLocalScriptUiController(START_COMMAND_NAME)],
   [STOP_COMMAND_NAME, createLocalScriptUiController(STOP_COMMAND_NAME)],
-  [DESTROY_COMMAND_NAME, createLocalScriptUiController(DESTROY_COMMAND_NAME)]
+  [DESTROY_COMMAND_NAME, createLocalScriptUiController(DESTROY_COMMAND_NAME)],
+  [MANAGE_PLATFORM_ADMINS_COMMAND_NAME, managePlatformAdminsUiController]
 ]);
 
 // src/hooks/use-command-runner.ts
@@ -3074,6 +3334,69 @@ var statusCliController = async (_args) => {
   }
 };
 
+// src/controllers/cli/manage-platform-admins.cli-controller.ts
+async function managePlatformAdminsCliController(args2) {
+  const logger = { log: console.log };
+  if (!await isPlatformInitialized()) {
+    console.error("Error: Cannot manage platform admins \u2014 no platform initialized in this directory.");
+    process.exit(1);
+  }
+  const { action } = args2;
+  if (!action || !["list", "add", "remove"].includes(action)) {
+    logger.log("Error: Missing or invalid 'action' argument. Valid values: list, add, remove");
+    logger.log("Usage:");
+    logger.log("  platform manage-platform-admins action=list");
+    logger.log("  platform manage-platform-admins action=add usernames=alice,bob");
+    logger.log("  platform manage-platform-admins action=remove usernames=alice");
+    process.exit(1);
+  }
+  if (action === "list") {
+    const admins = await listAdminsService(logger);
+    if (admins.length === 0) {
+      logger.log("No platform admins found.");
+    } else {
+      logger.log("Current platform admins:");
+      for (const admin of admins) {
+        logger.log(`  - ${admin.username}`);
+      }
+    }
+    return;
+  }
+  const { usernames } = args2;
+  if (!usernames) {
+    logger.log(`Error: Missing required argument 'usernames' for action '${action}'`);
+    process.exit(1);
+  }
+  const usernameList = usernames.split(",").map((u) => u.trim()).filter(Boolean);
+  if (usernameList.length === 0) {
+    logger.log("Error: 'usernames' argument is empty.");
+    process.exit(1);
+  }
+  if (action === "add") {
+    for (const username of usernameList) {
+      const ok = await addAdminService(username, logger);
+      if (ok) {
+        logger.log(`'${username}' granted platform admin access.`);
+      }
+    }
+    return;
+  }
+  if (action === "remove") {
+    const admins = await listAdminsService(logger);
+    for (const username of usernameList) {
+      const admin = admins.find((a) => a.username === username);
+      if (!admin) {
+        logger.log(`'${username}' is not currently a platform admin.`);
+        continue;
+      }
+      const ok = await removeAdminService(admin.ruleId, logger);
+      if (ok) {
+        logger.log(`'${username}' removed from platform admins.`);
+      }
+    }
+  }
+}
+
 // src/controllers/cli/registry.ts
 var cliControllers = /* @__PURE__ */ new Map([
   [CREATE_APPLICATION_COMMAND_NAME, createApplicationCliController],
@@ -3086,7 +3409,8 @@ var cliControllers = /* @__PURE__ */ new Map([
   [BUILD_COMMAND_NAME, createLocalScriptCliController(BUILD_COMMAND_NAME)],
   [START_COMMAND_NAME, createLocalScriptCliController(START_COMMAND_NAME)],
   [STOP_COMMAND_NAME, createLocalScriptCliController(STOP_COMMAND_NAME)],
-  [DESTROY_COMMAND_NAME, createLocalScriptCliController(DESTROY_COMMAND_NAME)]
+  [DESTROY_COMMAND_NAME, createLocalScriptCliController(DESTROY_COMMAND_NAME)],
+  [MANAGE_PLATFORM_ADMINS_COMMAND_NAME, managePlatformAdminsCliController]
 ]);
 
 // src/utils/parse-args.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bluealba/platform-cli",
-  "version": "0.3.1-feature-platform-cli-229",
+  "version": "0.3.1-feature-platform-cli-231",
   "description": "Blue Alba Platform CLI",
   "license": "PolyForm-Noncommercial-1.0.0",
   "type": "module",

package/templates/bootstrap-service-template/package.json

@@ -13,8 +13,8 @@
     "lint:fix": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix"
   },
   "dependencies": {
-    "@bluealba/pae-bootstrap-lib": "3.0.0",
-    "@bluealba/pae-core": "5.2.0",
+    "@bluealba/pae-bootstrap-lib": "3.1.1",
+    "@bluealba/pae-core": "5.4.0",
     "copyfiles": "^2.4.1",
     "express": "^4.21.2"
   },

package/templates/customization-ui-module-template/package.json

@@ -47,7 +47,7 @@
     "webpack-merge": "^5.8.0"
   },
   "dependencies": {
-    "@bluealba/pae-ui-react-core": "4.3.0",
+    "@bluealba/pae-ui-react-core": "4.5.0",
     "css-loader": "^7.1.2",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",

package/templates/platform-init-template/{{platformName}}-core/local/platform-docker-compose.yml

@@ -26,7 +26,7 @@ services:
       retries: 20
 
   pae-nestjs-gateway-service:
-    image: bluealba-ba-docker-virtual.jfrog.io/bluealba-pae-nestjs-gateway-service:3.6.1
+    image: bluealba-ba-docker-virtual.jfrog.io/bluealba-pae-nestjs-gateway-service:3.8.0
     ports:
       - 9080:80
       - 9443:443
@@ -50,22 +50,22 @@ services:
         condition: service_healthy
 
   pae-shell-ui:
-    image: bluealba-ba-docker-virtual.jfrog.io/bluealba-pae-shell-ui:3.3.0
+    image: bluealba-ba-docker-virtual.jfrog.io/bluealba-pae-shell-ui:3.3.2
     ports:
       - 9004:80
 
   pae-admin-ui:
-    image: bluealba-ba-docker-virtual.jfrog.io/bluealba-pae-admin-ui:4.4.0
+    image: bluealba-ba-docker-virtual.jfrog.io/bluealba-pae-admin-ui:4.6.0
     ports:
       - 9005:80
 
   pae-documentation-ui:
-    image: bluealba-ba-docker-virtual.jfrog.io/bluealba-pae-documentation-ui:1.0.7
+    image: bluealba-ba-docker-virtual.jfrog.io/bluealba-pae-documentation-ui:1.0.9
     ports:
       - 9006:80
 
   pae-documentation:
-    image: bluealba-ba-docker-virtual.jfrog.io/bluealba-pae-documentation:1.0.7
+    image: bluealba-ba-docker-virtual.jfrog.io/bluealba-pae-documentation:1.0.9
     ports:
       - 8585:80
 

package/templates/react-ui-module-template/package.json

@@ -10,7 +10,7 @@
     "lint:fix": "pae-ui-sdk lint --fix"
   },
   "devDependencies": {
-    "@bluealba/pae-ui-react-core": "4.4.0",
+    "@bluealba/pae-ui-react-core": "4.5.0",
     "@bluealba/pae-ui-react-sdk": "1.0.2",
     "@types/react": "18.3.3",
     "@types/react-dom": "18.3.0",