scene-capability-engine 3.6.53 → 3.6.55

package/lib/app/collection-store.js

@@ -0,0 +1,127 @@
+const path = require('path');
+const fs = require('fs-extra');
+
+function normalizeString(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value.trim();
+}
+
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const seen = new Set();
+  const items = [];
+  for (const entry of value) {
+    const normalized = normalizeString(entry);
+    if (!normalized || seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    items.push(normalized);
+  }
+  return items;
+}
+
+function normalizeBoolean(value, fallback = false) {
+  if (typeof value === 'boolean') {
+    return value;
+  }
+  return fallback;
+}
+
+function normalizeCollectionItem(item = {}) {
+  return {
+    app_id: normalizeString(item.app_id || item.appId) || null,
+    app_key: normalizeString(item.app_key || item.appKey) || null,
+    required: normalizeBoolean(item.required, false),
+    allow_local_remove: normalizeBoolean(item.allow_local_remove ?? item.allowLocalRemove, true),
+    priority: Number.isFinite(Number(item.priority)) ? Number(item.priority) : null,
+    default_entry: normalizeString(item.default_entry || item.defaultEntry) || null,
+    capability_tags: normalizeStringArray(item.capability_tags || item.capabilityTags),
+    metadata: item.metadata && typeof item.metadata === 'object' ? item.metadata : {}
+  };
+}
+
+function normalizeAppCollection(raw = {}, filePath = '') {
+  const fileName = normalizeString(path.basename(filePath, path.extname(filePath)));
+  const collectionId = normalizeString(raw.collection_id || raw.collectionId || raw.id) || fileName;
+  if (!collectionId) {
+    throw new Error(`invalid app collection file: missing collection_id (${filePath})`);
+  }
+  const items = Array.isArray(raw.items)
+    ? raw.items
+      .filter((item) => item && typeof item === 'object')
+      .map((item) => normalizeCollectionItem(item))
+      .filter((item) => item.app_id || item.app_key)
+    : [];
+
+  return {
+    collection_id: collectionId,
+    name: normalizeString(raw.name) || collectionId,
+    description: normalizeString(raw.description) || null,
+    status: normalizeString(raw.status) || 'active',
+    tags: normalizeStringArray(raw.tags),
+    item_count: items.length,
+    items,
+    metadata: raw.metadata && typeof raw.metadata === 'object' ? raw.metadata : {},
+    source_file: filePath
+  };
+}
+
+async function listAppCollections(projectPath = process.cwd(), options = {}) {
+  const fileSystem = options.fileSystem || fs;
+  const collectionsDir = path.join(projectPath, '.sce', 'app', 'collections');
+  if (!await fileSystem.pathExists(collectionsDir)) {
+    return [];
+  }
+
+  const entries = await fileSystem.readdir(collectionsDir);
+  const query = normalizeString(options.query).toLowerCase();
+  const status = normalizeString(options.status);
+  const normalized = [];
+
+  for (const entry of entries) {
+    if (!entry.toLowerCase().endsWith('.json')) {
+      continue;
+    }
+    const absolutePath = path.join(collectionsDir, entry);
+    const raw = await fileSystem.readJson(absolutePath);
+    const collection = normalizeAppCollection(raw, absolutePath);
+    if (status && collection.status !== status) {
+      continue;
+    }
+    if (query) {
+      const haystack = [
+        collection.collection_id,
+        collection.name,
+        collection.description,
+        ...collection.tags
+      ].join(' ').toLowerCase();
+      if (!haystack.includes(query)) {
+        continue;
+      }
+    }
+    normalized.push(collection);
+  }
+
+  normalized.sort((left, right) => left.collection_id.localeCompare(right.collection_id));
+  return normalized;
+}
+
+async function getAppCollection(projectPath = process.cwd(), collectionRef = '', options = {}) {
+  const normalizedRef = normalizeString(collectionRef);
+  if (!normalizedRef) {
+    return null;
+  }
+  const collections = await listAppCollections(projectPath, options);
+  return collections.find((item) => item.collection_id === normalizedRef || path.basename(item.source_file, '.json') === normalizedRef) || null;
+}
+
+module.exports = {
+  normalizeAppCollection,
+  listAppCollections,
+  getAppCollection
+};

package/lib/app/install-apply-runner.js

@@ -0,0 +1,192 @@
+function normalizeString(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value.trim();
+}
+
+function resolveAppRef(action = {}) {
+  return normalizeString(action.app_key) || normalizeString(action.app_id);
+}
+
+function getBlockingReasons(plan = {}) {
+  const reasons = [];
+  const unresolvedCollections = Array.isArray(plan.unresolved_collections) ? plan.unresolved_collections : [];
+  if (unresolvedCollections.length > 0) {
+    reasons.push('unresolved-collections');
+  }
+  const skipActions = Array.isArray(plan.actions)
+    ? plan.actions.filter((item) => normalizeString(item.decision) === 'skip')
+    : [];
+  if (skipActions.some((item) => normalizeString(item.reason) === 'app-bundle-not-found')) {
+    reasons.push('unresolved-app-bundles');
+  }
+  if (skipActions.some((item) => normalizeString(item.reason) === 'active-release-protected')) {
+    reasons.push('active-release-protected');
+  }
+  return reasons;
+}
+
+async function verifyInstallCandidates(plan = {}, store) {
+  const failures = [];
+  const actions = Array.isArray(plan.actions) ? plan.actions : [];
+  for (const action of actions) {
+    if (normalizeString(action.decision) !== 'install') {
+      continue;
+    }
+    const appRef = resolveAppRef(action);
+    const graph = appRef ? await store.getAppBundleGraph(appRef) : null;
+    const metadata = graph && graph.bundle && graph.bundle.metadata && typeof graph.bundle.metadata === 'object'
+      ? graph.bundle.metadata
+      : {};
+    const serviceCatalog = metadata.service_catalog && typeof metadata.service_catalog === 'object'
+      ? metadata.service_catalog
+      : {};
+    const releases = Array.isArray(serviceCatalog.releases) ? serviceCatalog.releases : [];
+    if (!graph || releases.length === 0) {
+      failures.push({
+        app_ref: appRef,
+        reason: 'no-installable-runtime-release'
+      });
+    }
+  }
+  return failures;
+}
+
+async function verifyActivateCandidates(plan = {}, store) {
+  const failures = [];
+  const actions = Array.isArray(plan.actions) ? plan.actions : [];
+  for (const action of actions) {
+    if (normalizeString(action.decision) !== 'activate') {
+      continue;
+    }
+    const appRef = resolveAppRef(action);
+    const graph = appRef ? await store.getAppBundleGraph(appRef) : null;
+    const metadata = graph && graph.bundle && graph.bundle.metadata && typeof graph.bundle.metadata === 'object'
+      ? graph.bundle.metadata
+      : {};
+    const serviceCatalog = metadata.service_catalog && typeof metadata.service_catalog === 'object'
+      ? metadata.service_catalog
+      : {};
+    const releases = Array.isArray(serviceCatalog.releases) ? serviceCatalog.releases : [];
+    const installedReleaseId = normalizeString(action.installed_release_id);
+    if (!graph || !installedReleaseId || !releases.some((item) => normalizeString(item && item.release_id) === installedReleaseId)) {
+      failures.push({
+        app_ref: appRef,
+        reason: 'no-activatable-installed-release'
+      });
+    }
+  }
+  return failures;
+}
+
+function sortExecutableActions(actions = []) {
+  const install = [];
+  const activate = [];
+  const uninstall = [];
+  for (const action of actions) {
+    const decision = normalizeString(action.decision);
+    if (decision === 'install') {
+      install.push(action);
+    } else if (decision === 'activate') {
+      activate.push(action);
+    } else if (decision === 'uninstall') {
+      uninstall.push(action);
+    }
+  }
+  return [...install, ...activate, ...uninstall];
+}
+
+async function executeInstallPlan(plan = {}, options = {}) {
+  const store = options.store;
+  const executeInstall = options.executeInstall;
+  const executeActivate = options.executeActivate;
+  const executeUninstall = options.executeUninstall;
+  const dependencies = options.dependencies || {};
+  const commandOptions = options.commandOptions || {};
+
+  const blockingReasons = getBlockingReasons(plan);
+  if (blockingReasons.length > 0) {
+    return {
+      execute_supported: true,
+      executed: false,
+      blocked_reason: blockingReasons.join(','),
+      results: []
+    };
+  }
+
+  const installPreflightFailures = await verifyInstallCandidates(plan, store);
+  const activatePreflightFailures = await verifyActivateCandidates(plan, store);
+  const preflightFailures = [...installPreflightFailures, ...activatePreflightFailures];
+  if (preflightFailures.length > 0) {
+    return {
+      execute_supported: true,
+      executed: false,
+      blocked_reason: 'install-preflight-failed',
+      preflight_failures: preflightFailures,
+      results: []
+    };
+  }
+
+  const results = [];
+  const actions = sortExecutableActions(Array.isArray(plan.actions) ? plan.actions : []);
+  for (const action of actions) {
+    const decision = normalizeString(action.decision);
+    const appRef = resolveAppRef(action);
+    if (!appRef) {
+      return {
+        execute_supported: true,
+        executed: false,
+        blocked_reason: 'invalid-plan-action',
+        results
+      };
+    }
+    const nestedOptions = {
+      app: appRef,
+      authLease: commandOptions.authLease,
+      authPassword: commandOptions.authPassword,
+      actor: commandOptions.actor,
+      json: true,
+      silent: true
+    };
+    if (decision === 'install') {
+      const payload = await executeInstall(nestedOptions, dependencies);
+      results.push({
+        app_ref: appRef,
+        decision,
+        success: true,
+        summary: payload.summary || null
+      });
+    } else if (decision === 'activate') {
+      const payload = await executeActivate({
+        ...nestedOptions,
+        release: normalizeString(action.installed_release_id)
+      }, dependencies);
+      results.push({
+        app_ref: appRef,
+        decision,
+        success: true,
+        summary: payload.summary || null
+      });
+    } else if (decision === 'uninstall') {
+      const payload = await executeUninstall(nestedOptions, dependencies);
+      results.push({
+        app_ref: appRef,
+        decision,
+        success: true,
+        summary: payload.summary || null
+      });
+    }
+  }
+
+  return {
+    execute_supported: true,
+    executed: true,
+    blocked_reason: null,
+    results
+  };
+}
+
+module.exports = {
+  executeInstallPlan
+};