@learnpack/learnpack 5.0.344 → 5.0.346

package/lib/commands/publish.d.ts

@@ -1,8 +1,14 @@
 import SessionCommand from "../utils/SessionCommand";
+type ExistingAssetInfo = {
+    lang: string;
+    slug: string;
+    exists: boolean;
+    academyId?: number;
+};
 export declare const handleAssetCreation: (sessionPayload: {
     token: string;
     rigobotToken: string;
-}, learnJson: any, selectedLang: string, learnpackDeployUrl: string, b64IndexReadme: string, academyId: number | undefined, all_translations?: string[]) => Promise<any>;
+}, learnJson: any, selectedLang: string, learnpackDeployUrl: string, b64IndexReadme: string, academyId: number | undefined, preflightInfo?: ExistingAssetInfo, all_translations?: string[]) => Promise<any>;
 declare class BuildCommand extends SessionCommand {
     static description: string;
     static flags: {

package/lib/commands/publish.js

@@ -45,7 +45,33 @@ const getLocalizedValue = (translations, lang, fallbackLangs = ["en", "us"]) =>
     const first = firstKey ? translations[firstKey] : "";
     return typeof first === "string" ? first : "";
 };
-const handleAssetCreation = async (sessionPayload, learnJson, selectedLang, learnpackDeployUrl, b64IndexReadme, academyId, all_translations = []) => {
+const getExistingAssetsInfo = async (token, learnJson) => {
+    const availableLangs = getAvailableLangs(learnJson);
+    const results = [];
+    for (const lang of availableLangs) {
+        const assetTitle = getLocalizedValue(learnJson === null || learnJson === void 0 ? void 0 : learnJson.title, lang);
+        if (!assetTitle)
+            continue;
+        let slug = (0, creatorUtilities_1.slugify)(assetTitle).slice(0, 47);
+        slug = `${slug}-${lang}`;
+        // eslint-disable-next-line no-await-in-loop
+        const { exists, academyId } = await api_1.default.doesAssetExists(token, slug);
+        results.push({ lang, slug, exists, academyId });
+    }
+    return results;
+};
+const determinePublishAcademyMode = (existingAssets) => {
+    const academyIds = existingAssets
+        .filter((a) => a.exists && a.academyId !== undefined)
+        .map((a) => a.academyId);
+    const unique = [...new Set(academyIds)];
+    if (unique.length === 0)
+        return { type: "select" };
+    if (unique.length === 1)
+        return { type: "locked", academyId: unique[0] };
+    return { type: "conflict", academies: unique };
+};
+const handleAssetCreation = async (sessionPayload, learnJson, selectedLang, learnpackDeployUrl, b64IndexReadme, academyId, preflightInfo, all_translations = []) => {
     const category = "uncategorized";
     try {
         const user = await api_1.default.validateToken(sessionPayload.token);
@@ -56,15 +82,8 @@ const handleAssetCreation = async (sessionPayload, learnJson, selectedLang, lear
         }
         let slug = (0, creatorUtilities_1.slugify)(assetTitle).slice(0, 47);
         slug = `${slug}-${selectedLang}`;
-        const { exists, academyId: existingAcademyId } = await api_1.default.doesAssetExists(sessionPayload.token, slug);
-        // Compare academy IDs if asset exists and academyId is provided
-        if (exists &&
-            existingAcademyId !== undefined &&
-            academyId !== undefined &&
-            existingAcademyId !== academyId) {
-            console_1.default.warning(`Asset exists in academy ${existingAcademyId}, but attempting to publish to academy ${academyId}. ` +
-                `The asset will be updated in its current academy (${existingAcademyId}).`);
-        }
+        // Use pre-flight info when available to avoid an extra GET request
+        const { exists, academyId: existingAcademyId } = preflightInfo !== null && preflightInfo !== void 0 ? preflightInfo : (await api_1.default.doesAssetExists(sessionPayload.token, slug));
         // const technologies: unknown[] = Array.isArray(learnJson?.technologies) ?
         //   learnJson.technologies :
         //   []
@@ -105,14 +124,19 @@ const handleAssetCreation = async (sessionPayload, learnJson, selectedLang, lear
             return asset;
         }
         console_1.default.info("Asset exists, updating it");
-        const asset = await api_1.default.updateAsset(sessionPayload.token, slug, {
+        const updatePayload = {
             graded: true,
             learnpack_deploy_url: learnpackDeployUrl,
             title: assetTitle,
             category: category,
             description: assetDescription,
             all_translations,
-        });
+        };
+        // Only set academy when the asset has none yet and the user selected one
+        if (existingAcademyId === undefined && academyId !== undefined) {
+            updatePayload.academy_id = academyId;
+        }
+        const asset = await api_1.default.updateAsset(sessionPayload.token, slug, updatePayload);
         try {
             await api_1.default.updateRigoPackage(sessionPayload.rigobotToken.trim(), learnJson.slug, {
                 asset_id: asset.id,
@@ -130,7 +154,7 @@ const handleAssetCreation = async (sessionPayload, learnJson, selectedLang, lear
     }
 };
 exports.handleAssetCreation = handleAssetCreation;
-const createMultiLangAssetFromDisk = async (sessionPayload, learnJson, deployUrl) => {
+const createMultiLangAssetFromDisk = async (sessionPayload, learnJson, deployUrl, selectedAcademyId, existingAssetsInfo = []) => {
     const availableLangs = getAvailableLangs(learnJson);
     if (availableLangs.length === 0) {
         console_1.default.error("No languages found in learn.json.title. Add at least one language (e.g. title.en).");
@@ -150,9 +174,10 @@ const createMultiLangAssetFromDisk = async (sessionPayload, learnJson, deployUrl
             indexReadmeString = "";
         }
         const b64IndexReadme = Buffer.from(indexReadmeString).toString("base64");
+        const preflightInfo = existingAssetsInfo.find((a) => a.lang === lang);
         try {
             // eslint-disable-next-line no-await-in-loop
-            const asset = await (0, exports.handleAssetCreation)(sessionPayload, learnJson, lang, deployUrl, b64IndexReadme, undefined, all_translations);
+            const asset = await (0, exports.handleAssetCreation)(sessionPayload, learnJson, lang, deployUrl, b64IndexReadme, selectedAcademyId, preflightInfo, all_translations);
             if (!asset) {
                 console_1.default.debug("Could not create/update asset for lang", lang);
                 continue;
@@ -230,7 +255,7 @@ class BuildCommand extends SessionCommand_1.default {
         await this.initSession(flags);
     }
     async run() {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         const buildDir = path.join(process.cwd(), "build");
         const { flags } = this.parse(BuildCommand);
         const strict = flags.strict;
@@ -269,17 +294,35 @@ class BuildCommand extends SessionCommand_1.default {
             console_1.default.debug("Building exercises");
             (_c = this.configManager) === null || _c === void 0 ? void 0 : _c.buildIndex();
         }
+        const learnJsonPath = path.join(process.cwd(), "learn.json");
+        if (!fs.existsSync(learnJsonPath)) {
+            this.error("learn.json not found");
+        }
+        const learnJson = JSON.parse(fs.readFileSync(learnJsonPath, "utf-8"));
         const academies = await api_1.default.listUserAcademies(sessionPayload.token);
         if (academies.length === 0) {
             console_1.default.error("It seems you cannot publish tutorials. Make sure you creator subscription is up to date here: https://4geeks.com/profile/subscriptions. If you believe there is an issue you can always contact support@4geeks.com");
             process.exit(1);
         }
-        const { academy, category } = await selectAcademy(academies, sessionPayload.token);
-        const learnJsonPath = path.join(process.cwd(), "learn.json");
-        if (!fs.existsSync(learnJsonPath)) {
-            this.error("learn.json not found");
+        console_1.default.info("Checking existing assets...");
+        const existingAssetsInfo = await getExistingAssetsInfo(sessionPayload.token, learnJson);
+        const academyMode = determinePublishAcademyMode(existingAssetsInfo);
+        let selectedAcademyId;
+        if (academyMode.type === "conflict") {
+            console_1.default.warning(`Some of your assets are associated with different academies ` +
+                `(${academyMode.academies.join(", ")}). ` +
+                `Academy assignment will be skipped to avoid conflicts.`);
+        }
+        else if (academyMode.type === "locked") {
+            const lockedAcademy = academies.find((a) => a.id === academyMode.academyId);
+            console_1.default.info(`This package is associated with academy: ${(_d = lockedAcademy === null || lockedAcademy === void 0 ? void 0 : lockedAcademy.name) !== null && _d !== void 0 ? _d : academyMode.academyId}. Academy cannot be changed.`);
+            selectedAcademyId = academyMode.academyId;
+        }
+        else {
+            // mode === "select": all existing assets have no academy, user picks one
+            const { academy } = await selectAcademy(academies, sessionPayload.token);
+            selectedAcademyId = academy === null || academy === void 0 ? void 0 : academy.id;
         }
-        const learnJson = JSON.parse(fs.readFileSync(learnJsonPath, "utf-8"));
         const zipFilePath = path.join(process.cwd(), `${learnJson.slug}.zip`);
         // Ensure build directory exists
         if (!fs.existsSync(buildDir)) {
@@ -405,7 +448,7 @@ class BuildCommand extends SessionCommand_1.default {
                 console.log(res.data);
                 fs.unlinkSync(zipFilePath);
                 this.removeDirectory(buildDir);
-                await createMultiLangAssetFromDisk({ token: sessionPayload.token, rigobotToken: rigoToken }, learnJson, res.data.url);
+                await createMultiLangAssetFromDisk({ token: sessionPayload.token, rigobotToken: rigoToken }, learnJson, res.data.url, selectedAcademyId, existingAssetsInfo);
             }
             catch (error) {
                 if (axios_1.default.isAxiosError(error)) {

package/lib/commands/serve.js

@@ -39,6 +39,7 @@ const redis_1 = require("redis");
 const historyManager_1 = require("../managers/historyManager");
 const readmeHistoryService_1 = require("../managers/readmeHistoryService");
 const readmeSanitizer_1 = require("../utils/readmeSanitizer");
+// eslint-disable-next-line
 const frontMatter = require("front-matter");
 if (process.env.NEW_RELIC_ENABLED === "true") {
     require("newrelic");
@@ -387,7 +388,7 @@ const createMultiLangAsset = async (bucket, rigoToken, bcToken, courseSlug, cour
         const b64IndexReadme = buffer_1.Buffer.from(indexReadmeString).toString("base64");
         try {
             // eslint-disable-next-line no-await-in-loop
-            const asset = await (0, publish_1.handleAssetCreation)({ token: bcToken, rigobotToken: rigoToken.trim() }, courseJson, lang, deployUrl, b64IndexReadme, academyId, all_translations);
+            const asset = await (0, publish_1.handleAssetCreation)({ token: bcToken, rigobotToken: rigoToken.trim() }, courseJson, lang, deployUrl, b64IndexReadme, academyId, undefined, all_translations);
             if (!asset) {
                 errors.push({
                     lang,
@@ -3780,26 +3781,48 @@ class ServeCommand extends SessionCommand_1.default {
                 const configJson = JSON.parse(configContent.toString());
                 const { config } = configJson;
                 const availableLangs = Object.keys(config.title || {});
-                let academyId = null;
                 let isPublished = false;
-                for (const lang of availableLangs) {
+                // Collect academy ids from all existing assets
+                const foundAcademyIds = [];
+                const slugsToCheck = availableLangs
+                    .map(lang => {
                     const assetTitle = getLocalizedValue(config.title, lang);
                     if (!assetTitle)
-                        continue;
-                    let assetSlug = (0, creatorUtilities_2.slugify)(assetTitle).slice(0, 47);
-                    assetSlug = `${assetSlug}-${lang}`;
-                    const { exists, academyId: existingAcademyId } = 
-                    // eslint-disable-next-line no-await-in-loop
-                    await (0, api_1.doesAssetExists)(bcToken, assetSlug);
+                        return null;
+                    const assetSlug = (0, creatorUtilities_2.slugify)(assetTitle).slice(0, 47);
+                    return `${assetSlug}-${lang}`;
+                })
+                    .filter((slug) => slug !== null);
+                const assetChecks = await Promise.all(slugsToCheck.map(slug => (0, api_1.doesAssetExists)(bcToken, slug)));
+                for (const { exists, academyId: existingAcademyId } of assetChecks) {
                     if (exists) {
                         isPublished = true;
                         if (existingAcademyId !== undefined) {
-                            academyId = existingAcademyId;
-                            break;
+                            foundAcademyIds.push(existingAcademyId);
                         }
                     }
                 }
-                return res.json({ academyId, isPublished });
+                const uniqueAcademies = [...new Set(foundAcademyIds)];
+                let mode;
+                let lockedAcademyId;
+                let conflictAcademies;
+                if (uniqueAcademies.length === 0) {
+                    mode = "select";
+                }
+                else if (uniqueAcademies.length === 1) {
+                    mode = "locked";
+                    lockedAcademyId = uniqueAcademies[0];
+                }
+                else {
+                    mode = "conflict";
+                    conflictAcademies = uniqueAcademies;
+                }
+                return res.json({
+                    isPublished,
+                    mode,
+                    lockedAcademyId,
+                    conflictAcademies,
+                });
             }
             catch (error) {
                 console.error("Error fetching package academy:", error);

package/lib/utils/api.js

@@ -278,36 +278,48 @@ const getConsumable = async (token, consumableSlug = "ai-generation") => {
     }
 };
 exports.getConsumable = getConsumable;
-const neededPermissions = [
-    "add_asset",
-    "change_asset",
-    "view_asset",
-    "delete_asset",
-];
+const CRUD_ASSET_CAPABILITY_URL = `${HOST}/v1/auth/user/me/capability/crud_asset`;
 const listUserAcademies = async (breathecodeToken) => {
-    const url = "https://breathecode.herokuapp.com/v1/auth/user/me";
+    const meUrl = `${HOST}/v1/auth/user/me`;
     try {
-        const response = await axios_1.default.get(url, {
+        const response = await axios_1.default.get(meUrl, {
             headers: {
                 Authorization: `Token ${breathecodeToken}`,
             },
         });
         const data = response.data;
         const academiesMap = new Map();
+        if (!Array.isArray(data.roles)) {
+            return [];
+        }
         for (const role of data.roles) {
             const academy = role.academy;
+            if (!academy)
+                continue;
             if (!academiesMap.has(academy.id)) {
                 academiesMap.set(academy.id, academy);
             }
         }
-        const permissions = new Set(data.permissions.map((p) => p.codename));
-        // Validate if the user has ALL the needed permissions
-        const hasAllPermissions = neededPermissions.every(permission => permissions.has(permission));
-        if (!hasAllPermissions) {
-            // The user does not have all the needed permissions
-            return [];
-        }
-        return [...academiesMap.values()];
+        const academies = [...academiesMap.values()];
+        const allowed = await Promise.all(academies.map(async (academy) => {
+            const capResponse = await axios_1.default.get(CRUD_ASSET_CAPABILITY_URL, {
+                headers: {
+                    Authorization: `Token ${breathecodeToken}`,
+                    Academy: academy.id,
+                },
+                validateStatus: () => true,
+            });
+            if (capResponse.status === 200) {
+                return academy;
+            }
+            if (capResponse.status !== 403) {
+                console.warn(`listUserAcademies: unexpected status ${capResponse.status} for academy ${academy.id}`);
+            }
+            return null;
+        }));
+        const filtered = allowed.filter((a) => a !== null);
+        filtered.sort((a, b) => a.name.localeCompare(b.name));
+        return filtered;
     }
     catch (error) {
         console.error("Failed to fetch user academies:", error);
@@ -330,6 +342,7 @@ const validateToken = async (token) => {
 };
 exports.validateToken = validateToken;
 const createAsset = async (token, asset) => {
+    var _a;
     const body = {
         slug: asset.slug,
         title: asset.title,
@@ -367,6 +380,7 @@ const createAsset = async (token, asset) => {
         url = `https://breathecode.herokuapp.com/v1/registry/academy/asset`;
         headers.Academy = String(asset.academy_id);
     }
+    console.log("[BC] POST", url, "| academy_id:", (_a = asset.academy_id) !== null && _a !== void 0 ? _a : "none", "| slug:", asset.slug);
     try {
         const response = await axios_1.default.post(url, body, { headers });
         return response.data;
@@ -398,10 +412,12 @@ const doesAssetExists = async (token, assetSlug) => {
 };
 exports.doesAssetExists = doesAssetExists;
 const updateAsset = async (token, assetSlug, asset) => {
+    var _a;
     const url = `https://breathecode.herokuapp.com/v1/registry/asset/me/${assetSlug}`;
     const headers = {
         Authorization: `Token ${token}`,
     };
+    console.log("[BC] PUT", url, "| academy_id:", (_a = asset.academy_id) !== null && _a !== void 0 ? _a : "none");
     try {
         const response = await axios_1.default.put(url, asset, { headers });
         return response.data;
@@ -460,7 +476,11 @@ const createRigoPackage = async (token, slug, config) => {
     }
 };
 let technologiesCache = [];
-/** Strip .env comments (e.g. "token # comment") so the token is sent without spaces. */
+/**
+ * Strip .env comments (e.g. "token # comment") so the token is sent without spaces.
+ * @param token - Raw token value from env, possibly with trailing comment.
+ * @returns Trimmed token with inline `#` comments removed, or empty string if missing.
+ */
 function sanitizeToken(token) {
     if (!token)
         return "";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@learnpack/learnpack",
   "description": "Seamlessly build, sell and/or take interactive & auto-graded tutorials, start learning now or build a new tutorial to your audience.",
-  "version": "5.0.344",
+  "version": "5.0.346",
   "author": "Alejandro Sanchez @alesanchezr",
   "contributors": [
     {

package/src/commands/publish.ts

@@ -54,6 +54,54 @@ const getLocalizedValue = (
   return typeof first === "string" ? first : ""
 }
 
+type ExistingAssetInfo = {
+  lang: string;
+  slug: string;
+  exists: boolean;
+  academyId?: number;
+};
+
+type AcademyMode =
+  | { type: "select" }
+  | { type: "locked"; academyId: number }
+  | { type: "conflict"; academies: number[] };
+
+const getExistingAssetsInfo = async (
+  token: string,
+  learnJson: any
+): Promise<ExistingAssetInfo[]> => {
+  const availableLangs = getAvailableLangs(learnJson)
+  const results: ExistingAssetInfo[] = []
+
+  for (const lang of availableLangs) {
+    const assetTitle = getLocalizedValue(learnJson?.title, lang)
+    if (!assetTitle) continue
+
+    let slug = slugify(assetTitle).slice(0, 47)
+    slug = `${slug}-${lang}`
+
+    // eslint-disable-next-line no-await-in-loop
+    const { exists, academyId } = await api.doesAssetExists(token, slug)
+    results.push({ lang, slug, exists, academyId })
+  }
+
+  return results
+}
+
+const determinePublishAcademyMode = (
+  existingAssets: ExistingAssetInfo[]
+): AcademyMode => {
+  const academyIds = existingAssets
+    .filter((a) => a.exists && a.academyId !== undefined)
+    .map((a) => a.academyId as number)
+
+  const unique = [...new Set(academyIds)]
+
+  if (unique.length === 0) return { type: "select" }
+  if (unique.length === 1) return { type: "locked", academyId: unique[0] }
+  return { type: "conflict", academies: unique }
+}
+
 export const handleAssetCreation = async (
   sessionPayload: { token: string; rigobotToken: string },
   learnJson: any,
@@ -61,6 +109,7 @@ export const handleAssetCreation = async (
   learnpackDeployUrl: string,
   b64IndexReadme: string,
   academyId: number | undefined,
+  preflightInfo?: ExistingAssetInfo,
   all_translations: string[] = []
 ) => {
   const category = "uncategorized"
@@ -83,23 +132,9 @@ export const handleAssetCreation = async (
     let slug = slugify(assetTitle).slice(0, 47)
     slug = `${slug}-${selectedLang}`
 
-    const { exists, academyId: existingAcademyId } = await api.doesAssetExists(
-      sessionPayload.token,
-      slug
-    )
-
-    // Compare academy IDs if asset exists and academyId is provided
-    if (
-      exists &&
-      existingAcademyId !== undefined &&
-      academyId !== undefined &&
-      existingAcademyId !== academyId
-    ) {
-      Console.warning(
-        `Asset exists in academy ${existingAcademyId}, but attempting to publish to academy ${academyId}. ` +
-          `The asset will be updated in its current academy (${existingAcademyId}).`
-      )
-    }
+    // Use pre-flight info when available to avoid an extra GET request
+    const { exists, academyId: existingAcademyId } =
+      preflightInfo ?? (await api.doesAssetExists(sessionPayload.token, slug))
 
     // const technologies: unknown[] = Array.isArray(learnJson?.technologies) ?
     //   learnJson.technologies :
@@ -148,14 +183,24 @@ export const handleAssetCreation = async (
     }
 
     Console.info("Asset exists, updating it")
-    const asset = await api.updateAsset(sessionPayload.token, slug, {
+    const updatePayload: any = {
       graded: true,
       learnpack_deploy_url: learnpackDeployUrl,
       title: assetTitle,
       category: category,
       description: assetDescription,
       all_translations,
-    })
+    }
+    // Only set academy when the asset has none yet and the user selected one
+    if (existingAcademyId === undefined && academyId !== undefined) {
+      updatePayload.academy_id = academyId
+    }
+
+    const asset = await api.updateAsset(
+      sessionPayload.token,
+      slug,
+      updatePayload
+    )
     try {
       await api.updateRigoPackage(
         sessionPayload.rigobotToken.trim(),
@@ -179,7 +224,9 @@ export const handleAssetCreation = async (
 const createMultiLangAssetFromDisk = async (
   sessionPayload: { token: string; rigobotToken: string },
   learnJson: any,
-  deployUrl: string
+  deployUrl: string,
+  selectedAcademyId?: number,
+  existingAssetsInfo: ExistingAssetInfo[] = []
 ) => {
   const availableLangs = getAvailableLangs(learnJson)
 
@@ -208,6 +255,7 @@ const createMultiLangAssetFromDisk = async (
     }
 
     const b64IndexReadme = Buffer.from(indexReadmeString).toString("base64")
+    const preflightInfo = existingAssetsInfo.find((a) => a.lang === lang)
 
     try {
       // eslint-disable-next-line no-await-in-loop
@@ -217,7 +265,8 @@ const createMultiLangAssetFromDisk = async (
         lang,
         deployUrl,
         b64IndexReadme,
-        undefined,
+        selectedAcademyId,
+        preflightInfo,
         all_translations
       )
 
@@ -406,6 +455,13 @@ class BuildCommand extends SessionCommand {
       this.configManager?.buildIndex()
     }
 
+    const learnJsonPath = path.join(process.cwd(), "learn.json")
+    if (!fs.existsSync(learnJsonPath)) {
+      this.error("learn.json not found")
+    }
+
+    const learnJson = JSON.parse(fs.readFileSync(learnJsonPath, "utf-8"))
+
     const academies = await api.listUserAcademies(sessionPayload.token)
 
     if (academies.length === 0) {
@@ -415,17 +471,36 @@ class BuildCommand extends SessionCommand {
       process.exit(1)
     }
 
-    const { academy, category } = await selectAcademy(
-      academies,
-      sessionPayload.token
+    Console.info("Checking existing assets...")
+    const existingAssetsInfo = await getExistingAssetsInfo(
+      sessionPayload.token,
+      learnJson
     )
+    const academyMode = determinePublishAcademyMode(existingAssetsInfo)
 
-    const learnJsonPath = path.join(process.cwd(), "learn.json")
-    if (!fs.existsSync(learnJsonPath)) {
-      this.error("learn.json not found")
-    }
+    let selectedAcademyId: number | undefined
 
-    const learnJson = JSON.parse(fs.readFileSync(learnJsonPath, "utf-8"))
+    if (academyMode.type === "conflict") {
+      Console.warning(
+        `Some of your assets are associated with different academies ` +
+          `(${academyMode.academies.join(", ")}). ` +
+          `Academy assignment will be skipped to avoid conflicts.`
+      )
+    } else if (academyMode.type === "locked") {
+      const lockedAcademy = academies.find(
+        (a) => a.id === academyMode.academyId
+      )
+      Console.info(
+        `This package is associated with academy: ${
+          lockedAcademy?.name ?? academyMode.academyId
+        }. Academy cannot be changed.`
+      )
+      selectedAcademyId = academyMode.academyId
+    } else {
+      // mode === "select": all existing assets have no academy, user picks one
+      const { academy } = await selectAcademy(academies, sessionPayload.token)
+      selectedAcademyId = academy?.id
+    }
 
     const zipFilePath = path.join(process.cwd(), `${learnJson.slug}.zip`)
 
@@ -595,7 +670,9 @@ class BuildCommand extends SessionCommand {
         await createMultiLangAssetFromDisk(
           { token: sessionPayload.token, rigobotToken: rigoToken },
           learnJson,
-          res.data.url
+          res.data.url,
+          selectedAcademyId,
+          existingAssetsInfo
         )
       } catch (error) {
         if (axios.isAxiosError(error)) {

package/src/commands/serve.ts

@@ -87,7 +87,8 @@ import { HistoryManager } from "../managers/historyManager"
 import { ReadmeHistoryService } from "../managers/readmeHistoryService"
 import { sanitizeReadmeNewlines } from "../utils/readmeSanitizer"
 
-const frontMatter = require("front-matter")
+// eslint-disable-next-line
+const frontMatter = require("front-matter");
 
 if (process.env.NEW_RELIC_ENABLED === "true") {
   require("newrelic")
@@ -624,6 +625,7 @@ const createMultiLangAsset = async (
         deployUrl,
         b64IndexReadme,
         academyId,
+        undefined,
         all_translations
       )
 
@@ -5451,30 +5453,56 @@ class ServeCommand extends SessionCommand {
         const { config } = configJson
 
         const availableLangs = Object.keys(config.title || {})
-        let academyId: number | null = null
         let isPublished = false
 
-        for (const lang of availableLangs) {
-          const assetTitle = getLocalizedValue(config.title, lang)
-          if (!assetTitle) continue
+        // Collect academy ids from all existing assets
+        const foundAcademyIds: number[] = []
 
-          let assetSlug = slugify(assetTitle).slice(0, 47)
-          assetSlug = `${assetSlug}-${lang}`
+        const slugsToCheck = availableLangs
+          .map(lang => {
+            const assetTitle = getLocalizedValue(config.title, lang)
+            if (!assetTitle) return null
+            const assetSlug = slugify(assetTitle).slice(0, 47)
+            return `${assetSlug}-${lang}`
+          })
+          .filter((slug): slug is string => slug !== null)
 
-          const { exists, academyId: existingAcademyId } =
-            // eslint-disable-next-line no-await-in-loop
-            await doesAssetExists(bcToken, assetSlug)
+        const assetChecks = await Promise.all(
+          slugsToCheck.map(slug => doesAssetExists(bcToken, slug))
+        )
 
+        for (const { exists, academyId: existingAcademyId } of assetChecks) {
           if (exists) {
             isPublished = true
             if (existingAcademyId !== undefined) {
-              academyId = existingAcademyId
-              break
+              foundAcademyIds.push(existingAcademyId)
             }
           }
         }
 
-        return res.json({ academyId, isPublished })
+        const uniqueAcademies = [...new Set(foundAcademyIds)]
+
+        type AcademyMode = "select" | "locked" | "conflict";
+        let mode: AcademyMode
+        let lockedAcademyId: number | undefined
+        let conflictAcademies: number[] | undefined
+
+        if (uniqueAcademies.length === 0) {
+          mode = "select"
+        } else if (uniqueAcademies.length === 1) {
+          mode = "locked"
+          lockedAcademyId = uniqueAcademies[0]
+        } else {
+          mode = "conflict"
+          conflictAcademies = uniqueAcademies
+        }
+
+        return res.json({
+          isPublished,
+          mode,
+          lockedAcademyId,
+          conflictAcademies,
+        })
       } catch (error) {
         console.error("Error fetching package academy:", error)
         return res.status(500).json({ error: (error as Error).message })