codeplay-common 4.4.7 → 4.4.9

package/files/buildCodeplay/codeplayBeforeBuild-6.2.js

@@ -1910,18 +1910,7 @@ async function fetchVersions() {
 
 }
 
-function readInstalledAgentInstructionsVersion() {
-  const versionFile = path.join(
-    process.cwd(),
-    AGENT_INSTRUCTIONS_DIR,
-    AGENT_INSTRUCTIONS_VERSION_FILE
-  );
-
-  if (!fs.existsSync(versionFile)) return "0";
-  return String(fs.readFileSync(versionFile, "utf8")).trim() || "0";
-}
-
-function validateAgentInstructionsZip(zip) {
+function getAgentInstructionsZipLayout(zip) {
   const entries = zip.getEntries().filter(entry => !entry.isDirectory);
 
   for (const entry of entries) {
@@ -1935,35 +1924,69 @@ function validateAgentInstructionsZip(zip) {
     }
   }
 
-  const hasAgentFile = entries.some(entry => entry.entryName.replace(/\\/g, "/") === AGENT_INSTRUCTIONS_FILE);
-  const hasAgentFolderFiles = entries.some(entry =>
-    entry.entryName.replace(/\\/g, "/").startsWith(`${AGENT_INSTRUCTIONS_DIR}/`)
+  const normalizedEntries = entries.map(entry => ({
+    entry,
+    name: entry.entryName.replace(/\\/g, "/")
+  }));
+  const agentFile = normalizedEntries.find(({ name }) =>
+    name.toLowerCase() === AGENT_INSTRUCTIONS_FILE.toLowerCase()
   );
+  const agentDirectoryPrefix = `${AGENT_INSTRUCTIONS_DIR.toLowerCase()}/`;
+  const nestedSupportFiles = normalizedEntries
+    .filter(({ name }) => name.toLowerCase().startsWith(agentDirectoryPrefix))
+    .map(({ entry, name }) => ({
+      entry,
+      relativePath: name.slice(name.indexOf("/") + 1)
+    }))
+    .filter(({ relativePath }) => relativePath && relativePath !== AGENT_INSTRUCTIONS_VERSION_FILE);
+  const flatSupportFiles = normalizedEntries
+    .filter(({ name }) =>
+      !name.includes("/") &&
+      name.toLowerCase() !== AGENT_INSTRUCTIONS_FILE.toLowerCase() &&
+      name.toLowerCase() !== AGENT_INSTRUCTIONS_VERSION_FILE.toLowerCase() &&
+      name.toLowerCase().endsWith(".md")
+    )
+    .map(({ entry, name }) => ({ entry, relativePath: name }));
+  const supportFiles = nestedSupportFiles.length ? nestedSupportFiles : flatSupportFiles;
 
-  if (!hasAgentFile || !hasAgentFolderFiles) {
+  if (!agentFile || !supportFiles.length) {
     throw new Error(
-      `Agent instructions ZIP must contain ${AGENT_INSTRUCTIONS_FILE} and files inside ${AGENT_INSTRUCTIONS_DIR}/ at its root.`
+      `Agent instructions ZIP must contain ${AGENT_INSTRUCTIONS_FILE} (case-insensitive) and either files inside ${AGENT_INSTRUCTIONS_DIR}/ or supporting Markdown files at the archive root.`
     );
   }
+
+  return { agentFile: agentFile.entry, supportFiles };
+}
+
+function readInstalledAgentInstructionsVersion(projectRoot) {
+  const versionFile = path.join(projectRoot, AGENT_INSTRUCTIONS_DIR, AGENT_INSTRUCTIONS_VERSION_FILE);
+  if (!fs.existsSync(versionFile)) return "0";
+
+  const installedVersion = String(fs.readFileSync(versionFile, "utf8")).trim();
+  return /^\d+(?:\.\d+)*$/.test(installedVersion) ? installedVersion : "0";
 }
 
 async function syncAgentInstructions() {
+  const projectRoot = process.cwd();
+  const targetAgentFile = path.join(projectRoot, AGENT_INSTRUCTIONS_FILE);
+  const targetAgentDir = path.join(projectRoot, AGENT_INSTRUCTIONS_DIR);
+  const hasAgentDirectoryFiles =
+    fs.existsSync(targetAgentDir) &&
+    fs.statSync(targetAgentDir).isDirectory() &&
+    fs.readdirSync(targetAgentDir).some(name => name !== AGENT_INSTRUCTIONS_VERSION_FILE);
+  const requiredFilesExist = fs.existsSync(targetAgentFile) && hasAgentDirectoryFiles;
+  const localVersion = readInstalledAgentInstructionsVersion(projectRoot);
+
   const versions = await fetchVersions();
   const remoteVersion = String(versions?.[AGENT_INSTRUCTIONS_VERSION_KEY] || "").trim();
 
   if (!/^\d+(?:\.\d+)*$/.test(remoteVersion)) {
-    console.log(`ℹ️ No valid "${AGENT_INSTRUCTIONS_VERSION_KEY}" version found on the server. Skipping agent instructions update.`);
-    return;
+    throw new Error(`Required agent instructions could not be resolved from the server.`);
   }
 
-  const projectRoot = process.cwd();
-  const targetAgentFile = path.join(projectRoot, AGENT_INSTRUCTIONS_FILE);
-  const targetAgentDir = path.join(projectRoot, AGENT_INSTRUCTIONS_DIR);
-  const localVersion = readInstalledAgentInstructionsVersion();
-  const filesAreMissing = !fs.existsSync(targetAgentFile) || !fs.existsSync(targetAgentDir);
-
-  if (!filesAreMissing && compareVersionStrings(remoteVersion, localVersion) <= 0) {
-    console.log(`✅ Agent instructions are up to date (version ${localVersion}).`);
+  const remoteIsNewer = compareVersionStrings(remoteVersion, localVersion) > 0;
+  if (requiredFilesExist && !remoteIsNewer) {
+    console.log(`✅ Agent instructions do not need an update (local ${localVersion}, online ${remoteVersion}).`);
     return;
   }
 
@@ -1976,18 +1999,25 @@ async function syncAgentInstructions() {
   try {
     console.log(`🔍 Checking latest agent instructions: ${zipName}`);
     if (!(await urlExists(url))) {
-      console.warn(`⚠️ Agent instructions archive not found: ${url}`);
-      return;
+      throw new Error(`Required agent instructions archive not found: ${url}`);
     }
 
     await downloadFile(url, zipPath);
+    console.log(`⬇️ Downloaded agent instructions archive: ${zipName}`);
     const zip = new AdmZip(zipPath);
-    validateAgentInstructionsZip(zip);
-    zip.extractAllTo(extractPath, true);
+    const archiveLayout = getAgentInstructionsZipLayout(zip);
 
     const stagedAgentFile = path.join(extractPath, AGENT_INSTRUCTIONS_FILE);
     const stagedAgentDir = path.join(extractPath, AGENT_INSTRUCTIONS_DIR);
+    fs.mkdirSync(stagedAgentDir, { recursive: true });
+    fs.writeFileSync(stagedAgentFile, archiveLayout.agentFile.getData());
+    archiveLayout.supportFiles.forEach(({ entry, relativePath }) => {
+      const stagedSupportFile = path.join(stagedAgentDir, relativePath);
+      fs.mkdirSync(path.dirname(stagedSupportFile), { recursive: true });
+      fs.writeFileSync(stagedSupportFile, entry.getData());
+    });
 
+    fs.rmSync(targetAgentDir, { recursive: true, force: true });
     fs.mkdirSync(targetAgentDir, { recursive: true });
     fs.copyFileSync(stagedAgentFile, targetAgentFile);
     fs.cpSync(stagedAgentDir, targetAgentDir, { recursive: true, force: true });
@@ -1998,9 +2028,9 @@ async function syncAgentInstructions() {
     );
 
     writeUpdateLine(`Agent instructions ${localVersion} -> ${remoteVersion}`);
-    console.log(`✅ Agent instructions updated directly in the project root → v${remoteVersion}`);
+    console.log(`✅ Agent instructions replaced in the project root → v${remoteVersion}.`);
   } catch (error) {
-    console.warn(`⚠️ Agent instructions update failed: ${error?.message || error}`);
+    throw new Error(`Required agent instructions installation failed: ${error?.message || error}`);
   } finally {
     fs.rmSync(tempRoot, { recursive: true, force: true });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeplay-common",
-  "version": "4.4.7",
+  "version": "4.4.9",
   "description": "Common build scripts and files",
   "scripts": {
 	"postinstall": "node scripts/sync-files.js",