@aifabrix/builder 2.44.1 → 2.44.2

package/.npmrc.token

@@ -1 +1 @@
-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
+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

package/lib/core/secrets.js

@@ -224,6 +224,52 @@ async function loadMergedConfigAndUserSecrets() {
   }
 }
 
+/**
+ * @returns {string[]}
+ */
+function collectBuilderSecretsYamlPaths() {
+  const projectRoot = pathsUtil.getProjectRoot();
+  const candidates = [];
+  if (projectRoot) {
+    candidates.push(path.join(projectRoot, 'builder', 'secrets.local.yaml'));
+  }
+  try {
+    const alt = path.join(pathsUtil.getBuilderRoot(), 'secrets.local.yaml');
+    if (!candidates.length || path.resolve(candidates[0]) !== path.resolve(alt)) {
+      candidates.push(alt);
+    }
+  } catch {
+    /* ignore */
+  }
+  return candidates;
+}
+
+/**
+ * Merge `builder/secrets.local.yaml` from project root and from {@link pathsUtil.getBuilderRoot} when distinct.
+ * @param {Object|null|undefined} merged
+ * @returns {Object|null|undefined}
+ */
+function mergeBuilderSecretsLocalFiles(merged) {
+  try {
+    const seen = new Set();
+    let out = merged;
+    for (const builderPath of collectBuilderSecretsYamlPaths()) {
+      if (!builderPath || seen.has(path.resolve(builderPath))) {
+        continue;
+      }
+      seen.add(path.resolve(builderPath));
+      if (fs.existsSync(builderPath)) {
+        ensureSecureFilePermissions(builderPath);
+        const builderSecrets = mergeUserWithConfigFile(out || {}, builderPath);
+        if (builderSecrets) out = builderSecrets;
+      }
+    }
+    return out;
+  } catch {
+    return merged;
+  }
+}
+
 /**
  * Loads merged secrets using config/user cascade, builder file merge, and default fallback.
  * @async
@@ -238,19 +284,7 @@ async function loadSecretsWithFallbacks() {
     }
     merged = await applyCanonicalSecretsOverride(merged);
   }
-  try {
-    const projectRoot = pathsUtil.getProjectRoot();
-    if (projectRoot) {
-      const builderPath = path.join(projectRoot, 'builder', 'secrets.local.yaml');
-      if (fs.existsSync(builderPath)) {
-        ensureSecureFilePermissions(builderPath);
-        const builderSecrets = mergeUserWithConfigFile(merged || {}, builderPath);
-        if (builderSecrets) merged = builderSecrets;
-      }
-    }
-  } catch {
-    // Ignore (e.g. no project root or read error)
-  }
+  merged = mergeBuilderSecretsLocalFiles(merged);
   if (Object.keys(merged).length === 0) {
     merged = loadDefaultSecrets();
   }

package/lib/datasource/log-viewer.js

@@ -278,6 +278,34 @@ function formatLogContent(parsed, logType, fileName) {
   }
 }
 
+/**
+ * Parse saved debug log JSON (strict). Always throws an Error whose message starts with
+ * "Invalid JSON" so CLI/tests get a stable contract.
+ * @param {string} content
+ * @param {string} logPath
+ * @returns {Object}
+ */
+function parseDatasourceLogJson(content, logPath) {
+  if (content === undefined || content === null) {
+    throw new Error(`Invalid JSON in ${logPath}: empty content`);
+  }
+  const text = String(content).replace(/^\uFEFF/, '').trim();
+  if (!text) {
+    throw new Error(`Invalid JSON in ${logPath}: empty file`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new Error(`Invalid JSON in ${logPath}: ${detail}`);
+  }
+  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error(`Invalid JSON in ${logPath}: expected a JSON object at the root`);
+  }
+  return parsed;
+}
+
 /**
  * Run log viewer: resolve log file, read, parse, format and print
  * @async
@@ -322,12 +350,7 @@ async function runLogViewer(datasourceKey, options) {
     fileName = path.basename(logPath);
   }
   const content = await fsp.readFile(logPath, 'utf8');
-  let parsed;
-  try {
-    parsed = JSON.parse(content);
-  } catch (err) {
-    throw new Error(`Invalid JSON in ${logPath}: ${err.message}`);
-  }
+  const parsed = parseDatasourceLogJson(content, logPath);
   formatLogContent(parsed, logType, fileName);
 }
 
@@ -339,5 +362,6 @@ module.exports = {
   formatE2ELog,
   formatIntegrationLog,
   formatStructuralTestLog,
+  parseDatasourceLogJson,
   runLogViewer
 };

package/lib/utils/app-service-env-from-builder.js

@@ -12,8 +12,21 @@
 const path = require('path');
 const yaml = require('js-yaml');
 const fsRealSync = require('../internal/fs-real-sync');
+const pathsUtil = require('./paths');
 const { localHostPort } = require('./declarative-url-ports');
 
+/**
+ * @param {string} p
+ * @returns {boolean}
+ */
+function isExistingDirSync(p) {
+  try {
+    return Boolean(p && fsRealSync.existsSync(p) && fsRealSync.statSync(p).isDirectory());
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Maps application.yaml `app.key` to env var prefix (MISO_HOST, DATAPLANE_PORT, …).
  * Generic keys not listed are skipped (no guessed PREFIX).
@@ -110,12 +123,11 @@ function mergeDocIntoOverlay(overlayDocker, overlayLocal, doc, folderName) {
 }
 
 /**
- * @param {string} projectRoot
+ * @param {string} builderDir
  * @returns {Array<{ doc: object, folderName: string }>}
  */
-function listBuilderApplicationDocs(projectRoot) {
-  const builderDir = path.join(projectRoot, 'builder');
-  if (!fsRealSync.existsSync(builderDir) || !fsRealSync.statSync(builderDir).isDirectory()) {
+function listBuilderApplicationDocsInDir(builderDir) {
+  if (!isExistingDirSync(builderDir)) {
     return [];
   }
   const out = [];
@@ -140,6 +152,33 @@ function listBuilderApplicationDocs(projectRoot) {
   return out;
 }
 
+/**
+ * Prefer projectRoot/builder when present (unit tests, in-repo runs). When missing but projectRoot
+ * is the detected CLI package root (global npm install omits builder/), fall back to
+ * {@link pathsUtil.getBuilderRoot}.
+ *
+ * @param {string} projectRoot
+ * @returns {string[]}
+ */
+function collectBuilderScanDirs(projectRoot) {
+  const legacy = path.join(projectRoot, 'builder');
+  if (isExistingDirSync(legacy)) {
+    return [legacy];
+  }
+  try {
+    const detected = pathsUtil.getProjectRoot();
+    if (detected && path.resolve(projectRoot) === path.resolve(detected)) {
+      const br = pathsUtil.getBuilderRoot();
+      if (isExistingDirSync(br)) {
+        return [br];
+      }
+    }
+  } catch {
+    /* ignore */
+  }
+  return [];
+}
+
 /**
  * @param {string|null|undefined} projectRoot
  * @returns {{ docker: Record<string, unknown>, local: Record<string, unknown> }}
@@ -150,8 +189,10 @@ function buildAppServiceEnvOverlay(projectRoot) {
   if (!projectRoot || !fsRealSync.existsSync(projectRoot)) {
     return { docker: overlayDocker, local: overlayLocal };
   }
-  for (const { doc, folderName } of listBuilderApplicationDocs(projectRoot)) {
-    mergeDocIntoOverlay(overlayDocker, overlayLocal, doc, folderName);
+  for (const builderDir of collectBuilderScanDirs(projectRoot)) {
+    for (const { doc, folderName } of listBuilderApplicationDocsInDir(builderDir)) {
+      mergeDocIntoOverlay(overlayDocker, overlayLocal, doc, folderName);
+    }
   }
   return { docker: overlayDocker, local: overlayLocal };
 }

package/lib/utils/config-paths.js

@@ -216,6 +216,10 @@ function createEnvConfigPathFunctions(getConfigFn, saveConfigFn) {
       if (fromProject) {
         return fromProject;
       }
+      const fromEffective = tryDir(pathsMod.getBuilderRoot());
+      if (fromEffective) {
+        return fromEffective;
+      }
       const work = pathsMod.getAifabrixWork();
       return tryDir(work);
     }

package/lib/utils/url-declarative-resolve-load-doc.js

@@ -8,10 +8,50 @@ const path = require('path');
 const yaml = require('js-yaml');
 const fsRealSync = require('../internal/fs-real-sync');
 
+/**
+ * @param {string} cfgPath
+ * @returns {object|null}
+ */
+function tryReadApplicationYamlAt(cfgPath) {
+  try {
+    if (!fsRealSync.existsSync(cfgPath)) {
+      return null;
+    }
+    const raw = fsRealSync.readFileSync(cfgPath, 'utf8');
+    const doc = yaml.load(raw);
+    return doc && typeof doc === 'object' ? doc : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Prefer projectRoot/builder (fixtures, tests); then {@link pathsUtil.getBuilderPath} (global npm).
+ * @param {string} appKey
+ * @param {object} pathsUtil
+ * @returns {string[]}
+ */
+function collectApplicationYamlPathsForUrlResolve(appKey, pathsUtil) {
+  const list = [];
+  const root = pathsUtil.getProjectRoot();
+  if (root) {
+    list.push(path.resolve(path.join(root, 'builder', appKey, 'application.yaml')));
+  }
+  try {
+    const viaBuilder = path.resolve(path.join(pathsUtil.getBuilderPath(appKey), 'application.yaml'));
+    if (!list.length || path.resolve(list[0]) !== viaBuilder) {
+      list.push(viaBuilder);
+    }
+  } catch {
+    /* ignore getBuilderPath errors */
+  }
+  return list;
+}
+
 /**
  * @param {string} appKey
  * @param {Object} ctx
- * @param {object} pathsUtil - paths module (getProjectRoot)
+ * @param {object} pathsUtil - paths module (getProjectRoot, getBuilderPath)
  * @returns {object|null}
  */
 function loadApplicationYamlDocForUrlResolve(appKey, ctx, pathsUtil) {
@@ -19,28 +59,18 @@ function loadApplicationYamlDocForUrlResolve(appKey, ctx, pathsUtil) {
     const current = ctx.currentAppKey || '';
     if (appKey === current && ctx.variablesPath) {
       const vp = path.resolve(String(ctx.variablesPath));
-      try {
-        const raw = fsRealSync.readFileSync(vp, 'utf8');
-        const doc = yaml.load(raw);
-        if (doc && typeof doc === 'object') {
-          return doc;
-        }
-      } catch {
-        // Fall through to builder-relative resolution
+      const fromVars = tryReadApplicationYamlAt(vp);
+      if (fromVars) {
+        return fromVars;
       }
     }
-    const root = pathsUtil.getProjectRoot();
-    if (!root) {
-      return null;
-    }
-    const cfgPath = path.resolve(path.join(root, 'builder', appKey, 'application.yaml'));
-    try {
-      const raw = fsRealSync.readFileSync(cfgPath, 'utf8');
-      const doc = yaml.load(raw);
-      return doc && typeof doc === 'object' ? doc : null;
-    } catch {
-      return null;
+    for (const cfgPath of collectApplicationYamlPathsForUrlResolve(appKey, pathsUtil)) {
+      const doc = tryReadApplicationYamlAt(cfgPath);
+      if (doc) {
+        return doc;
+      }
     }
+    return null;
   } catch {
     return null;
   }

package/lib/utils/urls-local-registry.js

@@ -156,19 +156,12 @@ function mergeDocIntoRegistry(merged, doc, folderName) {
 }
 
 /**
- * Merge scan results into registry (does not remove stale keys).
- * @param {string|null} projectRoot - getProjectRoot() or null
- * @returns {Object} Updated registry
+ * @param {Object} merged
+ * @param {string} builderDir
  */
-function refreshUrlsLocalRegistryFromBuilder(projectRoot) {
-  const root = projectRoot || pathsUtil.getProjectRoot();
-  const merged = { ...readUrlsLocalRegistrySync() };
-  if (!root) {
-    return writeMergedRegistry(merged);
-  }
-  const builderDir = path.join(root, 'builder');
-  if (!fsRealSync.existsSync(builderDir) || !fsRealSync.statSync(builderDir).isDirectory()) {
-    return writeMergedRegistry(merged);
+function mergeBuilderDirIntoRegistry(merged, builderDir) {
+  if (!builderDir || !fsRealSync.existsSync(builderDir) || !fsRealSync.statSync(builderDir).isDirectory()) {
+    return;
   }
   for (const ent of fsRealSync.readdirSync(builderDir, { withFileTypes: true })) {
     if (!ent.isDirectory()) {
@@ -180,6 +173,37 @@ function refreshUrlsLocalRegistryFromBuilder(projectRoot) {
     }
     mergeDocIntoRegistry(merged, doc, ent.name);
   }
+}
+
+/**
+ * Merge scan results into registry (does not remove stale keys).
+ * @param {string|null} projectRoot - getProjectRoot() or null (same semantics as projectRoot || getProjectRoot())
+ * @returns {Object} Updated registry
+ */
+function refreshUrlsLocalRegistryFromBuilder(projectRoot) {
+  const root = projectRoot || pathsUtil.getProjectRoot();
+  const merged = { ...readUrlsLocalRegistrySync() };
+  if (!root) {
+    return writeMergedRegistry(merged);
+  }
+  // Published npm tarball omits builder/ under the package root (.npmignore). Global installs must
+  // still refresh from the real builder tree (AIFABRIX_BUILDER_DIR or integration base + builder).
+  const legacyBuilderDir = path.join(root, 'builder');
+  const effectiveBuilderDir = pathsUtil.getBuilderRoot();
+  const builderDirs = [legacyBuilderDir];
+  try {
+    if (
+      effectiveBuilderDir &&
+      path.resolve(effectiveBuilderDir) !== path.resolve(legacyBuilderDir)
+    ) {
+      builderDirs.push(effectiveBuilderDir);
+    }
+  } catch {
+    /* ignore path resolution errors */
+  }
+  for (const builderDir of builderDirs) {
+    mergeBuilderDirIntoRegistry(merged, builderDir);
+  }
   return writeMergedRegistry(merged);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aifabrix/builder",
-  "version": "2.44.1",
+  "version": "2.44.2",
   "description": "AI Fabrix Local Fabric & Deployment SDK",
   "main": "lib/index.js",
   "bin": {