nexarch 0.8.16 → 0.8.17

package/dist/commands/init-agent.js

@@ -8,7 +8,7 @@ import { fetchAgentRegistryOrThrow } from "../lib/agent-registry.js";
 import { callMcpTool, mcpInitialize, mcpListTools } from "../lib/mcp.js";
 import { buildVersionAttributes } from "../lib/version-normalization.js";
 import { requestTrustAttestation } from "../lib/trust.js";
-const CLI_VERSION = "0.8.16";
+const CLI_VERSION = "0.8.17";
 const AGENT_ENTITY_TYPE = "agent";
 const TECH_COMPONENT_ENTITY_TYPE = "technology_component";
 function parseFlag(args, flag) {
@@ -287,6 +287,29 @@ After running, confirm \`"ok": true\` in the JSON output. No further action is n
     writeFileSync(filePath, content, "utf8");
     return filePath;
 }
+function managedMarkers(key) {
+    return {
+        start: `<!-- nexarch:${key}:start -->`,
+        end: `<!-- nexarch:${key}:end -->`,
+    };
+}
+function wrapManagedSection(key, body) {
+    const markers = managedMarkers(key);
+    return `${markers.start}\n${body.trim()}\n${markers.end}`;
+}
+function replaceManagedSection(existing, key, body) {
+    const markers = managedMarkers(key);
+    const escapedStart = markers.start.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const escapedEnd = markers.end.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const managedRegex = new RegExp(`${escapedStart}[\\s\\S]*?${escapedEnd}`, "gm");
+    if (!managedRegex.test(existing))
+        return existing;
+    const canonicalBlock = wrapManagedSection(key, body);
+    let replaced = existing.replace(managedRegex, canonicalBlock);
+    // collapse accidental duplicates if multiple managed blocks exist
+    replaced = replaced.replace(new RegExp(`(${escapedStart}[\\s\\S]*?${escapedEnd})(?:\\s*${escapedStart}[\\s\\S]*?${escapedEnd})+`, "gm"), "$1");
+    return replaced.endsWith("\n") ? replaced : `${replaced}\n`;
+}
 function replaceInjectedSection(existing, sectionHeading, sectionBody) {
     const escapedHeading = sectionHeading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const blockRegex = new RegExp(`^${escapedHeading}[\\t ]*\\n[\\s\\S]*?(?=^##\\s|$)`, "gm");
@@ -315,33 +338,37 @@ function injectAgentConfigs(registry) {
         const sectionBody = template.body.trim();
         const sectionHeading = target.sectionHeading ?? "## Nexarch Agent Registration";
         const sectionMarker = target.sectionMarker ?? sectionHeading;
+        const managedBody = wrapManagedSection("agent-registration", sectionBody);
         if (target.insertionMode === "replace_section") {
-            let replaced = replaceInjectedSection(existing, sectionHeading, sectionBody);
+            let replaced = replaceManagedSection(existing, "agent-registration", sectionBody);
+            if (replaced === existing) {
+                replaced = replaceInjectedSection(existing, sectionHeading, managedBody);
+            }
             if (replaced === existing && existing.includes(sectionMarker)) {
                 const markerIndex = existing.indexOf(sectionMarker);
                 const before = existing.slice(0, markerIndex).replace(/\s*$/, "\n\n");
-                replaced = `${before}${sectionBody}\n`;
+                replaced = `${before}${managedBody}\n`;
             }
             if (replaced !== existing) {
                 writeFileSync(filePath, replaced, "utf8");
                 results.push({ path: filePath, status: "updated" });
             }
-            else if (existing.includes(sectionBody)) {
+            else if (existing.includes(managedBody) || existing.includes(sectionBody)) {
                 results.push({ path: filePath, status: "already_present" });
             }
             else {
                 const separator = existing.endsWith("\n") ? "" : "\n";
-                writeFileSync(filePath, existing + separator + sectionBody + "\n", "utf8");
+                writeFileSync(filePath, existing + separator + managedBody + "\n", "utf8");
                 results.push({ path: filePath, status: "injected" });
             }
             continue;
         }
-        if (existing.includes(sectionBody)) {
+        if (existing.includes(managedBody) || existing.includes(sectionBody)) {
             results.push({ path: filePath, status: "already_present" });
         }
         else {
             const separator = existing.endsWith("\n") ? "" : "\n";
-            const next = existing + separator + sectionBody + "\n";
+            const next = existing + separator + managedBody + "\n";
             writeFileSync(filePath, next, "utf8");
             results.push({ path: filePath, status: "injected" });
         }
@@ -370,8 +397,29 @@ function injectTrustAttestationBlock(path, attestation) {
         "",
     ].join("\n");
     const existing = existsSync(path) ? readFileSync(path, "utf8") : "";
-    const replaced = replaceInjectedSection(existing, "## Nexarch Trust Attestation", section.trim());
-    writeFileSync(path, replaced !== existing ? replaced : `${existing}${existing.endsWith("\n") ? "" : "\n"}${section}`, "utf8");
+    const managed = wrapManagedSection("trust-attestation", section.trim());
+    let replaced = replaceManagedSection(existing, "trust-attestation", section.trim());
+    if (replaced === existing) {
+        replaced = replaceInjectedSection(existing, "## Nexarch Trust Attestation", managed);
+    }
+    writeFileSync(path, replaced !== existing ? replaced : `${existing}${existing.endsWith("\n") ? "" : "\n"}${managed}\n`, "utf8");
+}
+function injectTrustAttestationUnavailableBlock(path, reason) {
+    const section = [
+        "## Nexarch Trust Attestation",
+        "",
+        "Trust attestation was requested but is currently unavailable.",
+        `status: unavailable (${reason})`,
+        "action: check MCP gateway TRUST_ATTESTATION_SECRET and restart gateway",
+        "",
+    ].join("\n");
+    const existing = existsSync(path) ? readFileSync(path, "utf8") : "";
+    const managed = wrapManagedSection("trust-attestation", section.trim());
+    let replaced = replaceManagedSection(existing, "trust-attestation", section.trim());
+    if (replaced === existing) {
+        replaced = replaceInjectedSection(existing, "## Nexarch Trust Attestation", managed);
+    }
+    writeFileSync(path, replaced !== existing ? replaced : `${existing}${existing.endsWith("\n") ? "" : "\n"}${managed}\n`, "utf8");
 }
 function injectGenericAgentConfig(registry) {
     const templateByCode = new Map(registry.instructionTemplates.map((t) => [t.code, t]));
@@ -385,20 +433,30 @@ function injectGenericAgentConfig(registry) {
         const filePath = join(process.cwd(), target.filePathPattern);
         const sectionBody = template.body.trim();
         const sectionHeading = target.sectionHeading ?? "## Nexarch Agent Registration";
+        const managedBody = wrapManagedSection("agent-registration", sectionBody);
         if (!existsSync(filePath)) {
-            writeFileSync(filePath, `${sectionBody}\n`, "utf8");
+            writeFileSync(filePath, `${managedBody}\n`, "utf8");
             return [{ path: filePath, status: "injected" }];
         }
         const existing = readFileSync(filePath, "utf8");
         if (target.insertionMode === "replace_section") {
-            const replaced = replaceInjectedSection(existing, sectionHeading, sectionBody);
+            let replaced = replaceManagedSection(existing, "agent-registration", sectionBody);
+            if (replaced === existing) {
+                replaced = replaceInjectedSection(existing, sectionHeading, managedBody);
+            }
             if (replaced !== existing) {
                 writeFileSync(filePath, replaced, "utf8");
                 return [{ path: filePath, status: "updated" }];
             }
+            if (existing.includes(managedBody) || existing.includes(sectionBody)) {
+                return [{ path: filePath, status: "already_present" }];
+            }
+        }
+        if (existing.includes(managedBody) || existing.includes(sectionBody)) {
+            return [{ path: filePath, status: "already_present" }];
         }
         const separator = existing.endsWith("\n") ? "" : "\n";
-        writeFileSync(filePath, existing + separator + sectionBody + "\n", "utf8");
+        writeFileSync(filePath, existing + separator + managedBody + "\n", "utf8");
         return [{ path: filePath, status: "injected" }];
     }
     const fallbackTemplate = templateByCode.get("nexarch_agent_registration_v1") ?? registry.instructionTemplates[0];
@@ -406,19 +464,26 @@ function injectGenericAgentConfig(registry) {
         return [];
     const fallbackPath = join(process.cwd(), "AGENTS.md");
     const sectionBody = fallbackTemplate.body.trim();
+    const managedBody = wrapManagedSection("agent-registration", sectionBody);
     if (!existsSync(fallbackPath)) {
-        writeFileSync(fallbackPath, `${sectionBody}\n`, "utf8");
+        writeFileSync(fallbackPath, `${managedBody}\n`, "utf8");
         return [{ path: fallbackPath, status: "injected" }];
     }
     const existing = readFileSync(fallbackPath, "utf8");
     const sectionHeading = "## Nexarch Agent Registration";
-    const replaced = replaceInjectedSection(existing, sectionHeading, sectionBody);
+    let replaced = replaceManagedSection(existing, "agent-registration", sectionBody);
+    if (replaced === existing) {
+        replaced = replaceInjectedSection(existing, sectionHeading, managedBody);
+    }
     if (replaced !== existing) {
         writeFileSync(fallbackPath, replaced, "utf8");
         return [{ path: fallbackPath, status: "updated" }];
     }
+    if (existing.includes(managedBody) || existing.includes(sectionBody)) {
+        return [{ path: fallbackPath, status: "already_present" }];
+    }
     const separator = existing.endsWith("\n") ? "" : "\n";
-    writeFileSync(fallbackPath, existing + separator + sectionBody + "\n", "utf8");
+    writeFileSync(fallbackPath, existing + separator + managedBody + "\n", "utf8");
     return [{ path: fallbackPath, status: "injected" }];
 }
 export async function initAgent(args) {
@@ -1008,15 +1073,18 @@ export async function initAgent(args) {
             if (agentConfigResults.length > 0) {
                 trustAttestationAttempted = true;
                 trustAttestation = await requestTrustAttestation(agentId);
-                if (trustAttestation.ok) {
-                    for (const r of agentConfigResults) {
-                        try {
+                for (const r of agentConfigResults) {
+                    try {
+                        if (trustAttestation.ok) {
                             injectTrustAttestationBlock(r.path, trustAttestation);
                         }
-                        catch {
-                            // non-fatal
+                        else {
+                            injectTrustAttestationUnavailableBlock(r.path, trustAttestation.reason ?? "unknown");
                         }
                     }
+                    catch {
+                        // non-fatal
+                    }
                 }
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexarch",
-  "version": "0.8.16",
+  "version": "0.8.17",
   "description": "Your architecture workspace for AI delivery.",
   "keywords": [
     "nexarch",