@aifabrix/builder 2.44.3 → 2.44.4

package/lib/utils/datasource-test-run-tty-meta-lines.js

@@ -0,0 +1,123 @@
+/**
+ * @fileoverview TTY meta header lines for DatasourceTestRun (extracted for max-lines).
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const { headerKeyValue } = require('./cli-test-layout-chalk');
+const { pushCapacityOperationsSummaryLines } = require('./datasource-test-run-capacity-operations');
+
+/** @type {number} */
+const DEFAULT_MAX_REF_CHARS = 200;
+
+// UI-only: round float seconds tokens like "1.1713749s" -> "1.171s".
+function formatSecondsText(text) {
+  const txt = String(text);
+  return txt.replace(/(\d+\.\d+)(?=s\b)/g, m => {
+    const n = Number(m);
+    if (!Number.isFinite(n)) return m;
+    return n.toFixed(3);
+  });
+}
+
+/**
+ * @param {string} str
+ * @param {number} maxChars
+ * @returns {string}
+ */
+function truncateRefLine(str, maxChars) {
+  const s = String(str);
+  if (s.length <= maxChars) return s;
+  return `${s.slice(0, Math.max(0, maxChars - 24))}… [+${s.length - maxChars + 24} chars]`;
+}
+
+/**
+ * @param {string[]} lines
+ * @param {Object} envelope
+ */
+function pushTtyMetaRunWallLine(lines, envelope) {
+  if (envelope.cliWallSeconds === undefined || envelope.cliWallSeconds === null) return;
+  const n = Number(envelope.cliWallSeconds);
+  if (Number.isFinite(n) && n >= 0) {
+    lines.push(`${chalk.gray('Run wall:')} ${chalk.white(`~${n}s`)}`);
+  }
+}
+
+/**
+ * @param {string[]} lines
+ * @param {Object} envelope
+ */
+function pushTtyMetaCapabilitiesPreviewLine(lines, envelope) {
+  const caps = Array.isArray(envelope.capabilities) ? envelope.capabilities : [];
+  if (caps.length === 0) return;
+  const keys = caps
+    .map(c => (c && c.key !== undefined && c.key !== null ? String(c.key) : ''))
+    .filter(Boolean);
+  if (keys.length === 0) return;
+  const preview = keys.slice(0, 10).join(', ');
+  const more = keys.length > 10 ? ', …' : '';
+  lines.push(`${chalk.gray('Capabilities tested:')} ${chalk.white(`${preview}${more}`)}`);
+}
+
+/**
+ * @param {string[]} lines
+ * @param {Object} envelope
+ */
+function pushTtyMetaDebugExecutionSummaryLine(lines, envelope) {
+  if (!envelope.debug || typeof envelope.debug !== 'object' || !envelope.debug.executionSummary) return;
+  lines.push(
+    `${chalk.blue.bold('debug.executionSummary:')} ${chalk.white(
+      truncateRefLine(formatSecondsText(envelope.debug.executionSummary), DEFAULT_MAX_REF_CHARS)
+    )}`
+  );
+}
+
+/**
+ * @param {string[]} lines
+ * @param {Object} envelope
+ */
+function pushTtyMetaRunIdLine(lines, envelope) {
+  const rid = envelope.runId || envelope.testRunId;
+  if (rid) lines.push(`${chalk.gray('Run ID:')} ${chalk.cyan(String(rid))}`);
+}
+
+/**
+ * @param {string[]} lines
+ * @param {Object} envelope
+ */
+function pushTtyMetaReportCompletenessLine(lines, envelope) {
+  if (!envelope.reportCompleteness || envelope.reportCompleteness === 'full') return;
+  lines.push(`${chalk.gray('Report:')} ${chalk.yellow(String(envelope.reportCompleteness))}`);
+}
+
+/**
+ * @param {Object} envelope
+ * @param {(e: Object) => string} formatEnvelopeStatusLine
+ * @param {{ includeDebugExecutionSummary?: boolean }} [options]
+ * @returns {string[]}
+ */
+function buildTtyMetaLines(envelope, formatEnvelopeStatusLine, options = {}) {
+  const includeDebugExecutionSummary = options.includeDebugExecutionSummary === true;
+  const lines = [];
+  lines.push(
+    headerKeyValue('Datasource:', `${envelope.datasourceKey} (${envelope.systemKey})`)
+  );
+  lines.push(headerKeyValue('Run:', String(envelope.runType)));
+  pushTtyMetaRunWallLine(lines, envelope);
+  pushTtyMetaCapabilitiesPreviewLine(lines, envelope);
+  lines.push(formatEnvelopeStatusLine(envelope));
+  pushCapacityOperationsSummaryLines(lines, envelope);
+  if (includeDebugExecutionSummary) {
+    pushTtyMetaDebugExecutionSummaryLine(lines, envelope);
+  }
+  pushTtyMetaRunIdLine(lines, envelope);
+  pushTtyMetaReportCompletenessLine(lines, envelope);
+  return lines;
+}
+
+module.exports = {
+  buildTtyMetaLines
+};

package/lib/utils/error-formatter.js

@@ -265,13 +265,38 @@ function formatSingleError(error, options) {
   return message || `${field}: ${error.message || 'Validation error'}`;
 }
 
+/**
+ * Removes exact duplicate lines while preserving first-seen order (AJV composite schemas often repeat the same message).
+ * @param {string[]} strings
+ * @returns {string[]}
+ */
+function dedupeFormattedMessagesPreserveOrder(strings) {
+  if (!Array.isArray(strings)) {
+    return strings;
+  }
+  const seen = new Set();
+  const out = [];
+  for (const s of strings) {
+    if (typeof s !== 'string') {
+      continue;
+    }
+    if (seen.has(s)) {
+      continue;
+    }
+    seen.add(s);
+    out.push(s);
+  }
+  return out;
+}
+
 /**
  * Formats validation errors into developer-friendly messages
  * Converts technical schema errors into actionable advice
  *
  * @function formatValidationErrors
  * @param {Array} errors - Raw validation errors from Ajv
- * @param {Object} [options] - Optional; pass `{ deploymentManifest }` or `{ rootData }` for RBAC/pattern detail
+ * @param {Object} [options] - Optional; pass `{ deploymentManifest }` or `{ rootData }` for RBAC/pattern detail.
+ *   Pass `{ dedupe: true }` to remove exact duplicate lines (AJV `allOf`/`if-then` often repeats the same message).
  * @returns {Array} Formatted error messages
  *
  * @example
@@ -283,7 +308,11 @@ function formatValidationErrors(errors, options) {
     return ['Unknown validation error'];
   }
 
-  return errors.map((e) => formatSingleError(e, options));
+  const messages = errors.map(e => formatSingleError(e, options));
+  if (options && options.dedupe === true) {
+    return dedupeFormattedMessagesPreserveOrder(messages);
+  }
+  return messages;
 }
 
 /**
@@ -308,6 +337,7 @@ function formatMissingDbPasswordError(appKey, opts = {}) {
 module.exports = {
   formatSingleError,
   formatValidationErrors,
+  dedupeFormattedMessagesPreserveOrder,
   formatMissingDbPasswordError,
   getPatternDescription,
   getValueAtInstancePath,

package/lib/utils/external-system-readiness-core.js

@@ -214,6 +214,40 @@ function datasourceTestRunToLegacyRow(run) {
   };
 }
 
+/**
+ * Map dataplane **datasourceSummaries** item into legacy probe row shape.
+ * @param {Object} summary
+ * @returns {Object}
+ */
+function datasourceSummaryToLegacyRow(summary) {
+  const key = summary.datasourceKey || summary.datasource_key || 'unknown';
+  const root = String(summary.status || '').toLowerCase();
+  const vStat = String(summary.validationStatus || '').toLowerCase();
+  const issues = Array.isArray(summary.issues) ? summary.issues : [];
+  const { errors, warnings } = partitionDatasourceTestRunIssues(issues);
+  if (vStat === 'warn' && warnings.length === 0) {
+    warnings.push('validation warnings');
+  }
+  const isValid = vStat !== 'fail' && errors.length === 0;
+  const cert = String(summary.certificateStatus || '').toLowerCase();
+  if (cert === 'not_passed' && isValid) {
+    warnings.push('certification not passed');
+  }
+  return {
+    sourceKey: key,
+    key,
+    success: root !== 'fail',
+    skipped: root === 'skipped',
+    validationResults: { isValid, errors, warnings },
+    endpointTestResults: {
+      success: true,
+      endpointReachable: true,
+      message: null,
+      warning: false
+    }
+  };
+}
+
 /**
  * Normalize runtime probe body for Tier B display.
  *
@@ -225,6 +259,7 @@ function datasourceTestRunToLegacyRow(run) {
  * - **Runtime probe (--probe)** uses validation run and returns either:
  *   - legacy `{ results: ExternalDataSourceTestResponse[] }`, or
  *   - canonical **DatasourceTestRun** envelope (single success shape) which we coerce into a legacy row
+ *   - optional **datasourceSummaries** on the envelope for multi-datasource system runs
  *
  * This helper intentionally accepts multiple shapes so the CLI output stays truthful across dataplane versions.
  *
@@ -234,6 +269,10 @@ function datasourceTestRunToLegacyRow(run) {
 function coerceProbeRunToResultRows(probeRaw) {
   if (!probeRaw || typeof probeRaw !== 'object') return [];
   if (Array.isArray(probeRaw.results) && probeRaw.results.length > 0) return probeRaw.results;
+  const summaries = probeRaw.datasourceSummaries;
+  if (Array.isArray(summaries) && summaries.length > 0) {
+    return summaries.map(datasourceSummaryToLegacyRow);
+  }
   if (isDatasourceTestRunEnvelope(probeRaw)) return [datasourceTestRunToLegacyRow(probeRaw)];
   return [];
 }

package/lib/utils/external-system-readiness-deploy-display.js

@@ -54,7 +54,7 @@ function logDeployProbeDatasourceSection(probeData) {
   const results = coerceProbeRunToResultRows(probeData);
   const probeSummary = summarizeProbeResults(results);
   logSectionTitle('Runtime Readiness:');
-  logDatasourceTable(probeSummary.rows, probeSummary);
+  logDatasourceTable(probeSummary.rows, probeSummary, 'Per datasource:');
   if (probeSummary.issues.length > 0) {
     logSeparator();
     logSectionTitle('Key Issues:');
@@ -253,10 +253,9 @@ function logDeployReadinessSummary(ctx) {
   logDeployConfigDeploymentRuntime(systemCfg, deploymentOk, probeData, summary, deploymentDetail || null);
 
   logSeparator();
+  logDatasourceTable(summary.rows, summary, probeData ? 'Configured datasources:' : undefined);
   if (probeData) {
     logDeployProbeDatasourceSection(probeData);
-  } else {
-    logDatasourceTable(summary.rows, summary);
   }
 
   logDeployIdentityAndCredentialBlocks(systemCfg, !!probeData);

package/lib/utils/external-system-readiness-display-internals.js

@@ -50,9 +50,10 @@ function verdictLine(v) {
 /**
  * @param {Array<{ key: string, tier: string }>} rows
  * @param {{ ready: number, partial: number, failed: number }} counts
+ * @param {string} [title]
  */
-function logDatasourceTable(rows, counts) {
-  logSectionTitle('Datasources:');
+function logDatasourceTable(rows, counts, title) {
+  logSectionTitle(title && String(title).trim() ? String(title).trim() : 'Datasources:');
   for (const r of rows) {
     const statusLabel = r.tier === 'ready' ? 'Ready' : r.tier === 'failed' ? 'Failed' : 'Partial';
     logger.log(

package/lib/utils/external-system-system-test-tty.js

@@ -133,8 +133,8 @@ function countByStatus(rows) {
   return counts;
 }
 
-function pickBlockingDatasourceKey(rows) {
-  const keys = rows
+function rollupRowsWithKeys(rows) {
+  return rows
     .map(r => {
       const env = r && r.datasourceTestRun;
       const st = rollupRowStatus(r);
@@ -146,15 +146,37 @@ function pickBlockingDatasourceKey(rows) {
             : '';
       return { key, st };
     })
-    .filter(x => x.key);
-  keys.sort((a, b) => {
-    const d = statusRank(a.st) - statusRank(b.st);
-    if (d !== 0) return d;
-    return a.key.localeCompare(b.key);
-  });
+    .filter(x => x.key)
+    .sort((a, b) => {
+      const d = statusRank(a.st) - statusRank(b.st);
+      if (d !== 0) return d;
+      return a.key.localeCompare(b.key);
+    });
+}
+
+/**
+ * Worst-first datasource key for suggested CLI drill-down (always returned when any row exists).
+ * @param {Array} rows
+ * @returns {string|null}
+ */
+function pickDrillDownDatasourceKey(rows) {
+  const keys = rollupRowsWithKeys(rows);
   return keys.length ? keys[0].key : null;
 }
 
+/**
+ * Datasource key to label as "blocking" only when at least one row is not fully OK (fail/warn/skipped).
+ * When every row is OK, returns null so we do not imply a blocker when the system is all-green.
+ * @param {Array} rows
+ * @returns {string|null}
+ */
+function pickBlockingDatasourceKey(rows) {
+  const keys = rollupRowsWithKeys(rows);
+  if (keys.length === 0) return null;
+  if (keys.every(x => x.st === 'ok')) return null;
+  return keys[0].key;
+}
+
 function issueKey(issue) {
   const code = issue && issue.code ? String(issue.code) : '';
   const msg = issue && issue.message ? String(issue.message) : '';
@@ -390,6 +412,7 @@ function displaySystemAggregateDatasourceTestRuns(results, opts) {
   const systemStatus = deriveSystemStatus(rows);
   const counts = countByStatus(rows);
   const blocking = pickBlockingDatasourceKey(rows);
+  const drillDownKey = pickDrillDownDatasourceKey(rows);
   logSystemHeader(results, runType, systemStatus);
   logVerdictAndSummary(runType, systemStatus, systemCertStatus(rows), counts);
   logDataQualityAndReadiness(rows);
@@ -400,7 +423,7 @@ function displaySystemAggregateDatasourceTestRuns(results, opts) {
   logCapabilitiesOverviewSection(rows, ttyIo);
   logIntegrationHealthSectionBlock(rows, runType, ttyIo);
   logCertificationSection(rows);
-  logUseAndFooter(results, runType, systemStatus, blocking);
+  logUseAndFooter(results, runType, systemStatus, drillDownKey);
 }
 
 module.exports = {
@@ -410,6 +433,7 @@ module.exports = {
   deriveSystemReadiness,
   rollupRowStatus,
   pickBlockingDatasourceKey,
+  pickDrillDownDatasourceKey,
   collectKeyIssues,
   systemCertStatus,
   drillDownCommand

package/lib/utils/external-system-validators.js

@@ -39,7 +39,21 @@ function validateFieldMappingExpression(expression) {
 
   // Validate transformations (optional)
   const transformations = expression.split('|').slice(1).map(t => t.trim());
-  const validTransformations = ['toUpper', 'toLower', 'trim', 'default', 'toNumber', 'toString'];
+  // Keep in sync with dataplane field-mapping function registry (pipe DSL after {{path}})
+  const validTransformations = [
+    'toUpper',
+    'toLower',
+    'trim',
+    'default',
+    'toNumber',
+    'toString',
+    'coalesce',
+    'substring',
+    'replace',
+    'join',
+    'split',
+    'normalizeWhitespace'
+  ];
   for (const trans of transformations) {
     const transName = trans.split('(')[0].trim();
     if (!validTransformations.includes(transName)) {
@@ -67,6 +81,40 @@ function validateFieldMappingExpression(expression) {
  * @param {Object} payloadTemplate - Payload template
  * @param {Object} results - Results object to update
  */
+/**
+ * Root object used to verify {{...}} paths exist in the test payload.
+ * HubSpot-style configs map from `{{raw.id}}` while `payloadTemplate` often holds the
+ * API record at the top level; wrap virtually so path checks match CIP input shape
+ * without duplicating the record under `raw` in JSON (metadataSchema validation still
+ * uses the unwrapped `payloadTemplate`).
+ * @param {Object} payloadTemplate - testPayload.payloadTemplate
+ * @param {Object} attributes - fieldMappings.attributes
+ * @returns {Object}
+ */
+function fieldMappingPathRoot(payloadTemplate, attributes) {
+  if (!payloadTemplate || typeof payloadTemplate !== 'object') {
+    return payloadTemplate;
+  }
+  if ('raw' in payloadTemplate) {
+    return payloadTemplate;
+  }
+  const usesRawPrefix =
+    attributes &&
+    typeof attributes === 'object' &&
+    !Array.isArray(attributes) &&
+    Object.values(attributes).some(
+      cfg =>
+        cfg &&
+        typeof cfg === 'object' &&
+        typeof cfg.expression === 'string' &&
+        /\{\{\s*raw\./.test(cfg.expression)
+    );
+  if (usesRawPrefix) {
+    return { raw: payloadTemplate };
+  }
+  return payloadTemplate;
+}
+
 function validateSingleFieldMapping(fieldName, fieldConfig, payloadTemplate, results) {
   if (!fieldConfig.expression) {
     results.errors.push(`Field '${fieldName}' missing expression`);
@@ -124,8 +172,13 @@ function checkPathExistsInPayload(fieldPath, payloadTemplate) {
  * @returns {Object} Map suitable for validateDimensions
  */
 function getDimensionsMapForValidation(datasource) {
-  const root = datasource?.dimensions;
-  if (!root || typeof root !== 'object' || Array.isArray(root)) return {};
+  if (!datasource || !Object.prototype.hasOwnProperty.call(datasource, 'dimensions')) {
+    return undefined;
+  }
+  const root = datasource.dimensions;
+  if (!root || typeof root !== 'object' || Array.isArray(root)) {
+    return {};
+  }
   const out = {};
   for (const [dimKey, binding] of Object.entries(root)) {
     if (binding && typeof binding === 'object' && typeof binding.field === 'string') {
@@ -238,7 +291,10 @@ function validateFieldMappings(datasource, testPayload) {
     return results;
   }
 
-  validateDimensions(getDimensionsMapForValidation(datasource), results);
+  const dimensionsForValidation = getDimensionsMapForValidation(datasource);
+  if (dimensionsForValidation !== undefined) {
+    validateDimensions(dimensionsForValidation, results);
+  }
 
   // Validate attributes structure (required in new schema)
   const attributes = validateAttributesStructure(datasource.fieldMappings.attributes, results);
@@ -248,8 +304,9 @@ function validateFieldMappings(datasource, testPayload) {
 
   // Validate each attribute
   const payloadTemplate = testPayload.payloadTemplate || testPayload;
+  const pathCheckRoot = fieldMappingPathRoot(payloadTemplate, attributes);
   for (const [attributeName, attributeConfig] of Object.entries(attributes)) {
-    validateSingleAttribute(attributeName, attributeConfig, payloadTemplate, results);
+    validateSingleAttribute(attributeName, attributeConfig, pathCheckRoot, results);
   }
 
   return results;

package/lib/utils/load-cip-capacity-display-config.js

@@ -0,0 +1,130 @@
+/**
+ * @fileoverview Resolve CIP standard operation order for CLI display from the
+ * same source as `external-datasource.schema.json` ($defs.cipDefinition.properties.operations.properties).
+ * Falls back to `lib/schema/cip-capacity-display.fallback.json` when the schema file is unavailable.
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * @param {object|null} schema - Parsed external-datasource.schema.json
+ * @returns {string[]|null}
+ */
+function extractStandardOperationOrderFromSchema(schema) {
+  const props =
+    schema &&
+    schema.$defs &&
+    schema.$defs.cipDefinition &&
+    schema.$defs.cipDefinition.properties &&
+    schema.$defs.cipDefinition.properties.operations &&
+    schema.$defs.cipDefinition.properties.operations.properties;
+  if (!props || typeof props !== 'object') return null;
+  return Object.keys(props);
+}
+
+/**
+ * @param {string} p
+ * @returns {object|null}
+ */
+function tryReadJsonFile(p) {
+  try {
+    if (!p || !fs.existsSync(p)) return null;
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolve path to dataplane external-datasource.schema.json (monorepo / env).
+ * Set `AIFABRIX_EXTERNAL_DATASOURCE_SCHEMA` to override.
+ * @returns {string|null}
+ */
+function resolveExternalDatasourceSchemaPath() {
+  if (process.env.AIFABRIX_EXTERNAL_DATASOURCE_SCHEMA) {
+    const envPath = String(process.env.AIFABRIX_EXTERNAL_DATASOURCE_SCHEMA).trim();
+    if (envPath && fs.existsSync(envPath)) return envPath;
+  }
+  const candidates = [
+    path.join(process.cwd(), 'app/schemas/json/external-datasource.schema.json'),
+    path.join(process.cwd(), 'aifabrix-dataplane/app/schemas/json/external-datasource.schema.json'),
+    path.join(process.cwd(), '..', 'aifabrix-dataplane', 'app/schemas/json/external-datasource.schema.json'),
+    path.join(__dirname, '../../../aifabrix-dataplane/app/schemas/json/external-datasource.schema.json')
+  ];
+  for (const c of candidates) {
+    if (c && fs.existsSync(c)) return c;
+  }
+  return null;
+}
+
+const FALLBACK_PATH = path.join(__dirname, '../schema/cip-capacity-display.fallback.json');
+
+/** @type {{ standardOrder: string[], aliases: Record<string, string> }|null} */
+let _cache = null;
+
+/**
+ * @returns {{ standardOrder: string[], aliases: Record<string, string> }}
+ */
+function getCipCapacityDisplayConfig() {
+  if (_cache) return _cache;
+  const schemaPath = resolveExternalDatasourceSchemaPath();
+  const schema = schemaPath ? tryReadJsonFile(schemaPath) : null;
+  const fromSchema = extractStandardOperationOrderFromSchema(schema);
+  const fallback = tryReadJsonFile(FALLBACK_PATH) || {};
+  const fbOrder = Array.isArray(fallback.standardOperationOrder)
+    ? fallback.standardOperationOrder
+    : [];
+  const standardOrder = fromSchema && fromSchema.length ? fromSchema : fbOrder;
+  const aliases =
+    fallback.displayAliases && typeof fallback.displayAliases === 'object'
+      ? fallback.displayAliases
+      : { create: 'insert (create)' };
+  _cache = { standardOrder, aliases };
+  return _cache;
+}
+
+/**
+ * @param {string[]} standardOrder - from schema `cipDefinition.operations.properties` keys
+ * @param {string} op
+ * @returns {number}
+ */
+function standardOperationRank(standardOrder, op) {
+  const idx = standardOrder.indexOf(op);
+  if (idx >= 0) return idx;
+  return 500;
+}
+
+/**
+ * @param {string} capacityKey e.g. capacity:myOp#3 or capacity:update#1
+ * @returns {{ op: string, index: number }|null}
+ */
+function parseCapacityDetailKey(capacityKey) {
+  const s = String(capacityKey);
+  const m = s.match(/^capacity:([^#]+)#(\d+)$/i);
+  if (m) {
+    return { op: String(m[1]).toLowerCase(), index: parseInt(m[2], 10) };
+  }
+  const m2 = s.match(/^capacity:([^#]+)$/i);
+  if (m2) {
+    return { op: String(m2[1]).toLowerCase(), index: 0 };
+  }
+  return null;
+}
+
+function clearCipCapacityDisplayConfigCacheForTests() {
+  _cache = null;
+}
+
+module.exports = {
+  extractStandardOperationOrderFromSchema,
+  resolveExternalDatasourceSchemaPath,
+  getCipCapacityDisplayConfig,
+  standardOperationRank,
+  parseCapacityDetailKey,
+  clearCipCapacityDisplayConfigCacheForTests
+};

package/lib/utils/paths.js

@@ -615,8 +615,10 @@ async function detectAppType(appName, _options = {}) {
 }
 
 /**
- * Resolve-specific app path: prefer integration + env.template only (env-only mode).
- * If integration/<systemKey>/env.template exists, use that directory without requiring application.yaml.
+ * Resolve-specific app path: integration + env.template without application config → env-only mode.
+ * If integration/<systemKey>/env.template exists but there is no application.yaml, application.json,
+ * application.yml, or variables.yaml, use that directory with envOnly true (kv resolve only).
+ * When any application config file exists in that folder, use full resolve (envOnly false).
  * Otherwise fall back to detectAppType (integration or builder with full config).
  *
  * @param {string} appName - Application name
@@ -630,7 +632,12 @@ async function getResolveAppPath(appName) {
   const integrationPath = getIntegrationPath(appName);
   const envTemplatePath = path.join(integrationPath, 'env.template');
   if (fs.existsSync(integrationPath) && fs.existsSync(envTemplatePath)) {
-    return { appPath: integrationPath, envOnly: true };
+    try {
+      resolveApplicationConfigPath(integrationPath);
+      return { appPath: integrationPath, envOnly: false };
+    } catch {
+      return { appPath: integrationPath, envOnly: true };
+    }
   }
   const result = await detectAppType(appName);
   return { appPath: result.appPath, envOnly: false };