@bluealba/platform-cli 1.0.0 → 1.0.2

package/dist/index.js

@@ -213,7 +213,7 @@ import { join as join2, dirname as dirname2 } from "path";
 
 // src/utils/template-engine.ts
 import { readdir, readFile, writeFile, mkdir, copyFile, stat, chmod } from "fs/promises";
-import { join, dirname, extname } from "path";
+import { join, dirname, extname, basename } from "path";
 var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".pem",
   ".crt",
@@ -239,6 +239,13 @@ function applyVariables(text, variables) {
   }
   return result;
 }
+function transformFilename(relativePath) {
+  const base = basename(relativePath);
+  if (base === "gitignore") {
+    return join(dirname(relativePath), ".gitignore");
+  }
+  return relativePath;
+}
 function isBinary(filePath) {
   return BINARY_EXTENSIONS.has(extname(filePath).toLowerCase());
 }
@@ -263,7 +270,7 @@ async function applyTemplate(config, onProgress) {
     const relativePath = srcPath.slice(templateDir4.length + 1);
     if (relativePath.endsWith(".gitkeep")) continue;
     if (exclude.includes(relativePath)) continue;
-    const transformedRelative = applyVariables(relativePath, variables);
+    const transformedRelative = transformFilename(applyVariables(relativePath, variables));
     const destPath = join(outputDir, transformedRelative);
     await mkdir(dirname(destPath), { recursive: true });
     if (isBinary(srcPath)) {
@@ -1302,6 +1309,7 @@ async function createUiModule(params, logger) {
 import { spawn as spawn3 } from "child_process";
 import { access as access7 } from "fs/promises";
 import { join as join24, resolve as resolve5 } from "path";
+import { fetch as undiciFetch2, Agent as Agent2 } from "undici";
 
 // src/commands/local-scripts/docker-compose-orchestrator.ts
 import { spawn } from "child_process";
@@ -2015,6 +2023,40 @@ async function checkContainersPerApp(layout, manifest, allContainers) {
   }
   return groups;
 }
+async function checkIdpProviders(layout) {
+  const envPath = join24(layout.localDir, ".env");
+  let env;
+  try {
+    env = await readEnvFile(envPath);
+  } catch {
+    return { configured: false, providers: [], error: "could not read core/local/.env" };
+  }
+  const gatewayUrl = env.get("PAE_GATEWAY_HOST_URL");
+  const accessSecret = env.get("PAE_GATEWAY_SERVICE_ACCESS_SECRET");
+  if (!gatewayUrl || !accessSecret) {
+    return { configured: false, providers: [], error: "PAE_GATEWAY_HOST_URL or PAE_GATEWAY_SERVICE_ACCESS_SECRET not set" };
+  }
+  const agent = new Agent2({ connect: { rejectUnauthorized: false } });
+  let response;
+  try {
+    response = await undiciFetch2(`${gatewayUrl}/_/providers`, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${accessSecret}`
+      },
+      dispatcher: agent
+    });
+  } catch {
+    return { configured: false, providers: [], error: "gateway unreachable" };
+  }
+  if (!response.ok) {
+    return { configured: false, providers: [], error: `gateway responded with ${response.status}` };
+  }
+  const data = await response.json();
+  const providers2 = data.map((p) => ({ name: p.name, type: p.type, active: p.active }));
+  return { configured: providers2.length > 0, providers: providers2 };
+}
 async function gatherStatus() {
   const layout = await findPlatformLayout();
   const [nodeCheck, dockerCheck] = await Promise.all([checkNodeVersion(), checkDocker()]);
@@ -2033,7 +2075,8 @@ async function gatherStatus() {
       },
       containers: [],
       containersByApp: [],
-      coreDirName: null
+      coreDirName: null,
+      idp: null
     };
   }
   let manifest;
@@ -2053,7 +2096,8 @@ async function gatherStatus() {
       },
       containers: [],
       containersByApp: [],
-      coreDirName: layout.coreDirName
+      coreDirName: layout.coreDirName,
+      idp: null
     };
   }
   const [installedDetails, builtDetails, containers] = await Promise.all([
@@ -2062,6 +2106,8 @@ async function gatherStatus() {
     checkContainers(layout, manifest)
   ]);
   const containersByApp = await checkContainersPerApp(layout, manifest, containers);
+  const running = containers.length > 0 && containers.every((c) => c.state === "running");
+  const idp = running ? await checkIdpProviders(layout) : null;
   const projectInfo = {
     productName: manifest.product.name,
     displayName: manifest.product.displayName,
@@ -2079,11 +2125,12 @@ async function gatherStatus() {
       installedDetails,
       built: builtDetails.every((d) => d.exists),
       builtDetails,
-      running: containers.length > 0 && containers.every((c) => c.state === "running")
+      running
     },
     containers,
     containersByApp,
-    coreDirName: layout.coreDirName
+    coreDirName: layout.coreDirName,
+    idp
   };
 }
 
@@ -2097,7 +2144,7 @@ var statusCommand = {
 
 // 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";
+import { fetch as undiciFetch3, Agent as Agent3 } from "undici";
 var MANAGE_PLATFORM_ADMINS_COMMAND_NAME = "manage-platform-admins";
 var managePlatformAdminsCommand = {
   name: MANAGE_PLATFORM_ADMINS_COMMAND_NAME,
@@ -2134,10 +2181,10 @@ async function listPlatformAdmins(logger) {
   const config = await getGatewayConfig(logger);
   if (!config) return [];
   const { gatewayUrl, accessSecret } = config;
-  const agent = new Agent2({ connect: { rejectUnauthorized: false } });
+  const agent = new Agent3({ connect: { rejectUnauthorized: false } });
   let response;
   try {
-    response = await undiciFetch2(`${gatewayUrl}/applications/platform/rules`, {
+    response = await undiciFetch3(`${gatewayUrl}/applications/platform/rules`, {
       method: "GET",
       headers: {
         Accept: "application/json",
@@ -2165,10 +2212,10 @@ 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 } });
+  const agent = new Agent3({ connect: { rejectUnauthorized: false } });
   let response;
   try {
-    response = await undiciFetch2(`${gatewayUrl}/applications/platform/rules`, {
+    response = await undiciFetch3(`${gatewayUrl}/applications/platform/rules`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -2204,10 +2251,10 @@ 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 } });
+  const agent = new Agent3({ connect: { rejectUnauthorized: false } });
   let response;
   try {
-    response = await undiciFetch2(`${gatewayUrl}/applications/platform/rules/${ruleId}`, {
+    response = await undiciFetch3(`${gatewayUrl}/applications/platform/rules/${ruleId}`, {
       method: "DELETE",
       headers: {
         Authorization: `Bearer ${accessSecret}`
@@ -2228,6 +2275,91 @@ async function removePlatformAdmin(ruleId, logger) {
   return true;
 }
 
+// src/commands/install-ai-plugin/plugins/ba-platform/index.ts
+var baPlatformPlugin = {
+  name: "ba-platform-plugin",
+  description: "Blue Alba Platform knowledge and CLI skills for AI assistants",
+  version: "1.0.0",
+  skills: [
+    {
+      name: "platform",
+      description: "Comprehensive Blue Alba Platform architecture and concepts knowledge",
+      type: "skill",
+      sourceFile: "skills/ba-platform/platform.skill.md"
+    },
+    {
+      name: "platform-cli",
+      description: "Blue Alba Platform CLI commands and usage knowledge",
+      type: "skill",
+      sourceFile: "skills/ba-platform/platform-cli.skill.md"
+    }
+  ]
+};
+
+// src/commands/install-ai-plugin/plugins/registry.ts
+var pluginCatalog = [baPlatformPlugin];
+function findPlugin(name) {
+  return pluginCatalog.find((p) => p.name === name);
+}
+
+// src/commands/install-ai-plugin/install-ai-plugin.command.ts
+var INSTALL_AI_PLUGIN_COMMAND_NAME = "install-ai-plugin";
+var installAiPluginCommand = {
+  name: INSTALL_AI_PLUGIN_COMMAND_NAME,
+  description: "Install AI assistant plugins (skills, MCPs, hooks) for your AI provider"
+};
+async function installAiPlugin(params, context) {
+  const { provider, docsSource, logger, confirmUpdate } = context;
+  for (const pluginName of params.plugins) {
+    const plugin = findPlugin(pluginName);
+    if (!plugin) {
+      logger.log(`Error: Plugin "${pluginName}" not found in catalog.`);
+      continue;
+    }
+    const manifest = await provider.readManifest(pluginName);
+    const diff = provider.calculateDiff(manifest, plugin);
+    const hasStructuralChanges = diff.versionChanged || diff.newSkills.length > 0 || diff.removedSkills.length > 0;
+    if (manifest && hasStructuralChanges) {
+      logger.log(
+        `Plugin "${pluginName}" is already installed (v${diff.currentVersion} \u2192 v${diff.targetVersion}).`
+      );
+      if (diff.newSkills.length > 0) {
+        logger.log(`  New skills: ${diff.newSkills.map((s) => s.name).join(", ")}`);
+      }
+      if (diff.removedSkills.length > 0) {
+        logger.log(`  Removed skills: ${diff.removedSkills.join(", ")}`);
+      }
+      if (diff.existingSkills.length > 0) {
+        logger.log(`  Updated skills: ${diff.existingSkills.map((s) => s.name).join(", ")}`);
+      }
+      if (!params.force && confirmUpdate) {
+        const proceed = await confirmUpdate(diff, plugin);
+        if (!proceed) {
+          logger.log(`Skipped "${pluginName}".`);
+          continue;
+        }
+      }
+      for (const skillName of diff.removedSkills) {
+        await provider.removeSkill(skillName, logger);
+      }
+    } else if (!manifest) {
+      logger.log(`Installing plugin "${pluginName}" v${plugin.version}...`);
+    }
+    for (const skill of plugin.skills) {
+      await provider.installSkill(skill, docsSource, logger);
+    }
+    await provider.writeManifest({
+      plugin: pluginName,
+      version: plugin.version,
+      provider: provider.name,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      skills: plugin.skills.map((s) => s.name)
+    });
+    await provider.updatePermissions(docsSource, logger);
+    logger.log(`Plugin "${pluginName}" v${plugin.version} installed successfully.`);
+  }
+}
+
 // src/commands/registry.ts
 var CommandRegistry = class {
   commands = /* @__PURE__ */ new Map();
@@ -2268,6 +2400,7 @@ for (const cmd of localScriptCommands) {
 }
 registry.register(statusCommand);
 registry.register(managePlatformAdminsCommand);
+registry.register(installAiPluginCommand);
 
 // src/app-state.ts
 var APP_STATE = {
@@ -2365,12 +2498,12 @@ async function configureIdpUiController(ctx) {
     ctx.log("Error: Cannot configure an IDP \u2014 no platform initialized in this directory.");
     return;
   }
-  const providers = getAllProviders();
+  const providers2 = getAllProviders();
   const providerType = await ctx.select(
     "Select IDP type:",
-    providers.map((p) => ({ label: p.displayName, value: p.type }))
+    providers2.map((p) => ({ label: p.displayName, value: p.type }))
   );
-  const provider = providers.find((p) => p.type === providerType);
+  const provider = providers2.find((p) => p.type === providerType);
   const name = await ctx.prompt("Provider name:");
   const issuer = await ctx.prompt("Issuer URL:");
   const clientId = await ctx.prompt("Client ID:");
@@ -2551,6 +2684,20 @@ function formatStatusLines(result) {
       lines.push(`  ${tick(ok)} ${c.name.padEnd(35)} ${stateStr}${ports}`);
     }
   }
+  if (result.idp !== null) {
+    lines.push("");
+    lines.push(theme.section("Identity Providers"));
+    if (result.idp.error) {
+      lines.push(`  ${CROSS} ${theme.warning(result.idp.error)}`);
+    } else if (result.idp.configured) {
+      for (const p of result.idp.providers) {
+        const activeStr = p.active ? theme.success("active") : theme.warning("inactive");
+        lines.push(`  ${CHECK} ${p.name} ${theme.label(`(${p.type})`)} \u2014 ${activeStr}`);
+      }
+    } else {
+      lines.push(`  ${CROSS} ${theme.warning("No identity providers configured")}`);
+    }
+  }
   return lines;
 }
 
@@ -2568,6 +2715,13 @@ async function statusUiController(ctx) {
     }
     const { step, appNames, allApps } = computeNextStepInfo(result);
     if (step === null) {
+      if (result.idp && !result.idp.configured && !result.idp.error) {
+        const shouldConfigure = await ctx.confirm("No IDP configured. Configure one now?", true);
+        if (shouldConfigure) {
+          await configureIdpUiController(ctx);
+          continue;
+        }
+      }
       ctx.log("");
       ctx.log("All checks passed!");
       return;
@@ -2758,6 +2912,153 @@ async function handleRemove(ctx) {
   ctx.log(`Successfully removed ${successCount} of ${selected.length} admin(s).`);
 }
 
+// src/services/install-ai-plugin.service.ts
+async function installAiPluginService(params, context) {
+  await installAiPlugin(params, context);
+}
+
+// src/commands/install-ai-plugin/providers/claude.provider.ts
+import { homedir as homedir2 } from "os";
+import { join as join26 } from "path";
+import { readFile as readFile10, writeFile as writeFile9, mkdir as mkdir3, rm } from "fs/promises";
+var ClaudeProvider = class {
+  name = "claude";
+  baseDir = join26(homedir2(), ".claude");
+  getInstallPath(skillName) {
+    return join26(this.baseDir, "skills", skillName, "SKILL.md");
+  }
+  manifestPath(pluginName) {
+    return join26(this.baseDir, `${pluginName}.manifest.json`);
+  }
+  async readManifest(pluginName) {
+    try {
+      const content = await readFile10(this.manifestPath(pluginName), "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  async writeManifest(manifest) {
+    await mkdir3(this.baseDir, { recursive: true });
+    await writeFile9(
+      this.manifestPath(manifest.plugin),
+      JSON.stringify(manifest, null, 2),
+      "utf-8"
+    );
+  }
+  calculateDiff(manifest, plugin) {
+    const installedSkills = manifest?.skills ?? [];
+    const targetSkillNames = plugin.skills.map((s) => s.name);
+    return {
+      newSkills: plugin.skills.filter((s) => !installedSkills.includes(s.name)),
+      removedSkills: installedSkills.filter((name) => !targetSkillNames.includes(name)),
+      existingSkills: plugin.skills.filter((s) => installedSkills.includes(s.name)),
+      versionChanged: manifest?.version !== plugin.version,
+      currentVersion: manifest?.version ?? null,
+      targetVersion: plugin.version
+    };
+  }
+  async installSkill(skill, docsSource, logger) {
+    const sourcePath = docsSource.resolve(skill.sourceFile);
+    let content = await readFile10(sourcePath, "utf-8");
+    const docsPath = docsSource.resolve("docs");
+    content = content.replaceAll("{{docsPath}}", docsPath);
+    const installPath = this.getInstallPath(skill.name);
+    await mkdir3(join26(installPath, ".."), { recursive: true });
+    await writeFile9(installPath, content, "utf-8");
+    logger.log(`  Installed skill: ${installPath}`);
+  }
+  async removeSkill(skillName, logger) {
+    const skillDir = join26(this.baseDir, "skills", skillName);
+    try {
+      await rm(skillDir, { recursive: true, force: true });
+      logger.log(`  Removed skill: ${skillDir}`);
+    } catch {
+    }
+  }
+  async updatePermissions(docsSource, logger) {
+    const settingsPath = join26(this.baseDir, "settings.json");
+    const docsPath = docsSource.resolve("docs");
+    let settings = {};
+    try {
+      const content = await readFile10(settingsPath, "utf-8");
+      settings = JSON.parse(content);
+    } catch {
+    }
+    const permissions = settings.permissions ?? {};
+    const additionalDirectories = permissions.additionalDirectories ?? [];
+    if (additionalDirectories.includes(docsPath)) {
+      return;
+    }
+    permissions.additionalDirectories = [...additionalDirectories, docsPath];
+    settings.permissions = permissions;
+    await mkdir3(this.baseDir, { recursive: true });
+    await writeFile9(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+    logger.log(`  Granted read access to docs: ${docsPath}`);
+  }
+};
+
+// src/commands/install-ai-plugin/providers/index.ts
+var providers = {
+  claude: () => new ClaudeProvider()
+};
+var providerNames = Object.keys(providers);
+function getProvider(name) {
+  const factory = providers[name];
+  if (!factory) {
+    throw new Error(`Unknown AI provider: "${name}". Available: ${providerNames.join(", ")}`);
+  }
+  return factory();
+}
+
+// src/commands/install-ai-plugin/docs-source/local.docs-source.ts
+import { fileURLToPath as fileURLToPath10 } from "url";
+import { join as join27, dirname as dirname12 } from "path";
+var packageRoot = join27(dirname12(fileURLToPath10(import.meta.url)), "..");
+var LocalDocsSource = class {
+  resolve(relativePath) {
+    return join27(packageRoot, relativePath);
+  }
+};
+
+// src/controllers/ui/install-ai-plugin.ui-controller.ts
+async function installAiPluginUiController(ctx) {
+  const providerName = await ctx.select(
+    "Select AI provider:",
+    providerNames.map((name) => ({
+      label: name.charAt(0).toUpperCase() + name.slice(1),
+      value: name
+    }))
+  );
+  const selectedPlugins = await ctx.multiselect(
+    "Select plugins to install:",
+    pluginCatalog.map((p) => ({
+      label: `${p.name} \u2014 ${p.description}`,
+      value: p.name
+    }))
+  );
+  if (selectedPlugins.length === 0) {
+    ctx.log("No plugins selected.");
+    return;
+  }
+  const provider = getProvider(providerName);
+  const docsSource = new LocalDocsSource();
+  await installAiPluginService(
+    { provider: providerName, plugins: selectedPlugins },
+    {
+      provider,
+      docsSource,
+      logger: ctx,
+      confirmUpdate: async (diff, plugin) => {
+        return ctx.confirm(
+          `Update "${plugin.name}" from v${diff.currentVersion} to v${diff.targetVersion}?`,
+          true
+        );
+      }
+    }
+  );
+}
+
 // src/controllers/ui/registry.ts
 var uiControllers = /* @__PURE__ */ new Map([
   [CREATE_APPLICATION_COMMAND_NAME, createApplicationUiController],
@@ -2771,7 +3072,8 @@ var uiControllers = /* @__PURE__ */ new Map([
   [START_COMMAND_NAME, createLocalScriptUiController(START_COMMAND_NAME)],
   [STOP_COMMAND_NAME, createLocalScriptUiController(STOP_COMMAND_NAME)],
   [DESTROY_COMMAND_NAME, createLocalScriptUiController(DESTROY_COMMAND_NAME)],
-  [MANAGE_PLATFORM_ADMINS_COMMAND_NAME, managePlatformAdminsUiController]
+  [MANAGE_PLATFORM_ADMINS_COMMAND_NAME, managePlatformAdminsUiController],
+  [INSTALL_AI_PLUGIN_COMMAND_NAME, installAiPluginUiController]
 ]);
 
 // src/hooks/use-command-runner.ts
@@ -3333,6 +3635,10 @@ var statusCliController = async (_args) => {
     }
     process.exit(1);
   }
+  if (result.idp && !result.idp.configured && !result.idp.error) {
+    console.log("");
+    console.log(`Hint: Run "platform configure-idp" to set up an identity provider.`);
+  }
 };
 
 // src/controllers/cli/manage-platform-admins.cli-controller.ts
@@ -3398,6 +3704,32 @@ async function managePlatformAdminsCliController(args2) {
   }
 }
 
+// src/controllers/cli/install-ai-plugin.cli-controller.ts
+async function installAiPluginCliController(args2) {
+  const { provider: providerName, plugins: pluginsArg, force } = args2;
+  if (!providerName) {
+    console.error('Error: "provider" argument is required (e.g., provider=claude).');
+    process.exit(1);
+  }
+  if (!pluginsArg) {
+    console.error(
+      'Error: "plugins" argument is required (e.g., plugins=ba-platform-plugin).'
+    );
+    process.exit(1);
+  }
+  const plugins = pluginsArg.split(",").map((s) => s.trim());
+  const provider = getProvider(providerName);
+  const docsSource = new LocalDocsSource();
+  await installAiPluginService(
+    { provider: providerName, plugins, force: force === "true" },
+    {
+      provider,
+      docsSource,
+      logger: { log: console.log }
+    }
+  );
+}
+
 // src/controllers/cli/registry.ts
 var cliControllers = /* @__PURE__ */ new Map([
   [CREATE_APPLICATION_COMMAND_NAME, createApplicationCliController],
@@ -3411,7 +3743,8 @@ var cliControllers = /* @__PURE__ */ new Map([
   [START_COMMAND_NAME, createLocalScriptCliController(START_COMMAND_NAME)],
   [STOP_COMMAND_NAME, createLocalScriptCliController(STOP_COMMAND_NAME)],
   [DESTROY_COMMAND_NAME, createLocalScriptCliController(DESTROY_COMMAND_NAME)],
-  [MANAGE_PLATFORM_ADMINS_COMMAND_NAME, managePlatformAdminsCliController]
+  [MANAGE_PLATFORM_ADMINS_COMMAND_NAME, managePlatformAdminsCliController],
+  [INSTALL_AI_PLUGIN_COMMAND_NAME, installAiPluginCliController]
 ]);
 
 // src/utils/parse-args.ts

package/docs/404.mdx

@@ -0,0 +1,5 @@
+---
+title: Page Not Found
+---
+
+Sorry, this page doesn't exist. Use the navigation to find what you're looking for.