scene-capability-engine 3.6.53 → 3.6.55

package/lib/commands/app.js

@@ -3,6 +3,11 @@ const chalk = require('chalk');
 const fs = require('fs-extra');
 const { ensureWriteAuthorization } = require('../security/write-authorization');
 const { getSceStateStore } = require('../state/sce-state-store');
+const { listAppCollections, getAppCollection } = require('../app/collection-store');
+const { buildCollectionApplyPlan } = require('../app/install-plan-service');
+const { executeInstallPlan } = require('../app/install-apply-runner');
+const { getCurrentDeviceProfile } = require('../device/current-device');
+const { loadDeviceOverride } = require('../device/device-override-store');
 const { loadAppRegistryConfig, saveAppRegistryConfig } = require('../app/registry-config');
 const { syncBundleRegistry, syncServiceCatalog } = require('../app/registry-sync-service');
 
@@ -49,6 +54,9 @@ function createStore(dependencies = {}) {
 }
 
 function printPayload(payload, options = {}, title = 'App Bundle') {
+  if (options.silent === true) {
+    return;
+  }
   if (options.json) {
     console.log(JSON.stringify(payload, null, 2));
     return;
@@ -175,6 +183,36 @@ function buildRuntimeSummary(graph = {}) {
   };
 }
 
+function buildAppInstallStateItem(bundle = {}, currentDevice = null) {
+  const state = getRuntimeProjectionState({ bundle });
+  const installation = state.installation && typeof state.installation === 'object'
+    ? state.installation
+    : {};
+  const installationMachineId = normalizeString(installation.machine_id) || null;
+  let machineScope = 'unspecified';
+
+  if (installationMachineId && currentDevice && currentDevice.device_id) {
+    machineScope = installationMachineId === currentDevice.device_id ? 'current-device' : 'other-device';
+  }
+
+  return {
+    app_id: bundle.app_id || null,
+    app_key: bundle.app_key || null,
+    app_name: bundle.app_name || null,
+    environment: bundle.environment || null,
+    bundle_status: bundle.status || null,
+    install_status: state.installStatus,
+    installed_release_id: state.installedReleaseId,
+    active_release_id: state.activeReleaseId,
+    install_root: installation.install_root || null,
+    machine_id: installationMachineId,
+    device_hostname: normalizeString(installation.hostname) || null,
+    machine_scope: machineScope,
+    release_count: state.releases.length,
+    status: state.installStatus
+  };
+}
+
 function buildEngineeringSummary(graph = {}) {
   const bundle = graph.bundle || {};
   const engineeringProject = graph.engineering_project || {};
@@ -381,6 +419,141 @@ async function runAppBundleRegisterCommand(options = {}, dependencies = {}) {
   return payload;
 }
 
+async function runAppCollectionListCommand(options = {}, dependencies = {}) {
+  const projectPath = dependencies.projectPath || process.cwd();
+  const fileSystem = dependencies.fileSystem || fs;
+  const collections = await listAppCollections(projectPath, {
+    fileSystem,
+    query: options.query,
+    status: options.status
+  });
+  const limit = normalizePositiveInteger(options.limit, 100, 1000);
+  const items = collections.slice(0, limit).map((item) => ({
+    collection_id: item.collection_id,
+    name: item.name,
+    description: item.description,
+    status: item.status,
+    item_count: item.item_count,
+    tags: item.tags,
+    source_file: item.source_file
+  }));
+
+  const payload = {
+    mode: 'app-collection-list',
+    generated_at: new Date().toISOString(),
+    query: {
+      limit,
+      status: normalizeString(options.status) || null,
+      query: normalizeString(options.query) || null
+    },
+    summary: {
+      total: items.length
+    },
+    items,
+    view_model: {
+      type: 'table',
+      columns: ['collection_id', 'name', 'status', 'item_count', 'source_file']
+    }
+  };
+  printPayload(payload, options, 'App Collection List');
+  return payload;
+}
+
+async function runAppCollectionShowCommand(options = {}, dependencies = {}) {
+  const collectionRef = normalizeString(options.collection);
+  if (!collectionRef) {
+    throw new Error('--collection is required');
+  }
+  const projectPath = dependencies.projectPath || process.cwd();
+  const fileSystem = dependencies.fileSystem || fs;
+  const collection = await getAppCollection(projectPath, collectionRef, {
+    fileSystem
+  });
+  if (!collection) {
+    throw new Error(`app collection not found: ${collectionRef}`);
+  }
+
+  const payload = {
+    mode: 'app-collection-show',
+    generated_at: new Date().toISOString(),
+    query: {
+      collection: collectionRef
+    },
+    summary: {
+      collection_id: collection.collection_id,
+      name: collection.name,
+      status: collection.status,
+      item_count: collection.item_count
+    },
+    collection
+  };
+  printPayload(payload, options, 'App Collection Show');
+  return payload;
+}
+
+async function runAppCollectionApplyCommand(options = {}, dependencies = {}) {
+  const collectionRef = normalizeString(options.collection);
+  if (!collectionRef) {
+    throw new Error('--collection is required');
+  }
+  const projectPath = dependencies.projectPath || process.cwd();
+  const fileSystem = dependencies.fileSystem || fs;
+  const store = createStore(dependencies);
+  const currentDevice = await getCurrentDeviceProfile(projectPath, {
+    fileSystem,
+    persistIfMissing: false
+  });
+  const deviceOverride = await loadDeviceOverride(projectPath, { fileSystem });
+  const plan = await buildCollectionApplyPlan(projectPath, {
+    fileSystem,
+    store,
+    collectionRef,
+    currentDevice,
+    deviceOverride
+  });
+  const execution = options.execute
+    ? await executeInstallPlan(plan, {
+      store,
+      executeInstall: runAppRuntimeInstallCommand,
+      executeActivate: runAppRuntimeActivateCommand,
+      executeUninstall: runAppRuntimeUninstallCommand,
+      dependencies,
+      commandOptions: options
+    })
+    : {
+      execute_supported: true,
+      executed: false,
+      blocked_reason: null,
+      results: []
+    };
+  const payload = {
+    mode: 'app-collection-apply',
+    generated_at: new Date().toISOString(),
+    execute_supported: execution.execute_supported,
+    executed: execution.executed,
+    execution_blocked_reason: execution.blocked_reason,
+    execution: {
+      results: execution.results,
+      preflight_failures: execution.preflight_failures || []
+    },
+    current_device: currentDevice,
+    device_override: deviceOverride,
+    summary: {
+      source_type: plan.source.type,
+      source_id: plan.source.id,
+      desired_app_count: plan.desired_apps.length,
+      install_count: plan.counts.install,
+      activate_count: plan.counts.activate,
+      uninstall_count: plan.counts.uninstall,
+      keep_count: plan.counts.keep,
+      skip_count: plan.counts.skip
+    },
+    plan
+  };
+  printPayload(payload, options, 'App Collection Apply');
+  return payload;
+}
+
 async function runAppEngineeringShowCommand(options = {}, dependencies = {}) {
   const appRef = normalizeString(options.app);
   if (!appRef) {
@@ -687,6 +860,10 @@ async function runAppRuntimeInstallCommand(options = {}, dependencies = {}) {
   await ensureAuthorized('app:runtime:install', options, dependencies);
   const projectPath = dependencies.projectPath || process.cwd();
   const fileSystem = dependencies.fileSystem || fs;
+  const currentDevice = await getCurrentDeviceProfile(projectPath, {
+    fileSystem,
+    persistIfMissing: true
+  });
   const { store, graph } = await requireAppGraph(appRef, dependencies);
   const nextPayload = graphToRegisterPayload(graph);
   const serviceCatalog = nextPayload.metadata && nextPayload.metadata.service_catalog && typeof nextPayload.metadata.service_catalog === 'object'
@@ -705,6 +882,8 @@ async function runAppRuntimeInstallCommand(options = {}, dependencies = {}) {
     status: 'installed',
     install_root: installRoot,
     release_id: releaseId,
+    machine_id: currentDevice.device_id,
+    hostname: currentDevice.hostname,
     installed_at: new Date().toISOString(),
     source: 'sce app runtime install'
   };
@@ -773,7 +952,12 @@ async function runAppRuntimeUninstallCommand(options = {}, dependencies = {}) {
     throw new Error('--app is required');
   }
   await ensureAuthorized('app:runtime:uninstall', options, dependencies);
+  const projectPath = dependencies.projectPath || process.cwd();
   const fileSystem = dependencies.fileSystem || fs;
+  const currentDevice = await getCurrentDeviceProfile(projectPath, {
+    fileSystem,
+    persistIfMissing: true
+  });
   const { store, graph } = await requireAppGraph(appRef, dependencies);
   const nextPayload = graphToRegisterPayload(graph);
   const state = getRuntimeProjectionState(graph);
@@ -800,6 +984,8 @@ async function runAppRuntimeUninstallCommand(options = {}, dependencies = {}) {
     status: 'not-installed',
     release_id: null,
     install_root: null,
+    machine_id: currentDevice.device_id,
+    hostname: currentDevice.hostname,
     uninstalled_at: new Date().toISOString(),
     source: 'sce app runtime uninstall',
     previous_release_id: targetReleaseId
@@ -819,6 +1005,53 @@ async function runAppRuntimeUninstallCommand(options = {}, dependencies = {}) {
   return payload;
 }
 
+async function runAppInstallStateListCommand(options = {}, dependencies = {}) {
+  const store = createStore(dependencies);
+  const currentDevice = await getCurrentDeviceProfile(dependencies.projectPath || process.cwd(), {
+    fileSystem: dependencies.fileSystem || fs,
+    persistIfMissing: false
+  });
+  const bundles = await store.listAppBundles({
+    limit: normalizePositiveInteger(options.limit, 100, 1000),
+    status: options.status,
+    environment: options.environment,
+    workspaceId: options.workspaceId,
+    query: options.query
+  });
+  const installStatusFilter = normalizeString(options.installStatus);
+  const items = (Array.isArray(bundles) ? bundles : [])
+    .map((bundle) => buildAppInstallStateItem(bundle, currentDevice))
+    .filter((item) => !installStatusFilter || item.install_status === installStatusFilter);
+
+  const payload = {
+    mode: 'app-install-state-list',
+    generated_at: new Date().toISOString(),
+    query: {
+      limit: normalizePositiveInteger(options.limit, 100, 1000),
+      status: normalizeString(options.status) || null,
+      environment: normalizeString(options.environment) || null,
+      workspace_id: normalizeString(options.workspaceId) || null,
+      query: normalizeString(options.query) || null,
+      install_status: installStatusFilter || null
+    },
+    current_device: currentDevice,
+    summary: {
+      total: items.length,
+      installed_count: items.filter((item) => item.install_status === 'installed').length,
+      not_installed_count: items.filter((item) => item.install_status !== 'installed').length,
+      active_count: items.filter((item) => Boolean(item.active_release_id)).length,
+      current_device_id: currentDevice.device_id
+    },
+    items,
+    view_model: {
+      type: 'table',
+      columns: ['app_id', 'app_key', 'app_name', 'install_status', 'installed_release_id', 'active_release_id', 'machine_scope', 'environment']
+    }
+  };
+  printPayload(payload, options, 'App Install State');
+  return payload;
+}
+
 function safeRun(handler, options = {}, context = 'app command') {
   Promise.resolve(handler(options))
     .catch((error) => {
@@ -868,6 +1101,34 @@ function registerAppCommands(program) {
     .option('--json', 'Print machine-readable JSON output')
     .action((options) => safeRun(runAppBundleRegisterCommand, options, 'app bundle register'));
 
+  const collection = app
+    .command('collection')
+    .description('Inspect file-backed app collection intent definitions');
+
+  collection
+    .command('list')
+    .description('List app collection definitions from .sce/app/collections')
+    .option('--limit <n>', 'Maximum rows', '100')
+    .option('--status <status>', 'Filter by collection status')
+    .option('--query <text>', 'Free-text query against id/name/description/tags')
+    .option('--json', 'Print machine-readable JSON output')
+    .action((options) => safeRun(runAppCollectionListCommand, options, 'app collection list'));
+
+  collection
+    .command('show')
+    .description('Show one app collection definition')
+    .requiredOption('--collection <id>', 'Collection id or file basename')
+    .option('--json', 'Print machine-readable JSON output')
+    .action((options) => safeRun(runAppCollectionShowCommand, options, 'app collection show'));
+
+  collection
+    .command('apply')
+    .description('Build a plan-first apply diff for one app collection')
+    .requiredOption('--collection <id>', 'Collection id or file basename')
+    .option('--execute', 'Reserved for future explicit execution; currently returns a blocked plan')
+    .option('--json', 'Print machine-readable JSON output')
+    .action((options) => safeRun(runAppCollectionApplyCommand, options, 'app collection apply'));
+
   const registry = app
     .command('registry')
     .description('Manage remote app bundle and service catalog registry configuration');
@@ -965,6 +1226,22 @@ function registerAppCommands(program) {
     .option('--json', 'Print machine-readable JSON output')
     .action((options) => safeRun(runAppRuntimeUninstallCommand, options, 'app runtime uninstall'));
 
+  const installState = app
+    .command('install-state')
+    .description('Inspect current device install state across app bundles');
+
+  installState
+    .command('list')
+    .description('List current device install state across app bundles')
+    .option('--limit <n>', 'Maximum rows', '100')
+    .option('--status <status>', 'Filter by app bundle status')
+    .option('--environment <env>', 'Filter by environment')
+    .option('--workspace-id <id>', 'Filter by workspace id')
+    .option('--query <text>', 'Free-text query against id/key/name')
+    .option('--install-status <status>', 'Filter by install status')
+    .option('--json', 'Print machine-readable JSON output')
+    .action((options) => safeRun(runAppInstallStateListCommand, options, 'app install-state list'));
+
   const engineering = app
     .command('engineering')
     .description('Manage engineering project projection for one app bundle');
@@ -1020,6 +1297,9 @@ module.exports = {
   runAppBundleListCommand,
   runAppBundleShowCommand,
   runAppBundleRegisterCommand,
+  runAppCollectionListCommand,
+  runAppCollectionShowCommand,
+  runAppCollectionApplyCommand,
   runAppRegistryStatusCommand,
   runAppRegistryConfigureCommand,
   runAppRegistrySyncBundlesCommand,
@@ -1030,6 +1310,7 @@ module.exports = {
   runAppRuntimeInstallCommand,
   runAppRuntimeActivateCommand,
   runAppRuntimeUninstallCommand,
+  runAppInstallStateListCommand,
   runAppEngineeringShowCommand,
   runAppEngineeringAttachCommand,
   runAppEngineeringHydrateCommand,

package/lib/commands/device.js

@@ -0,0 +1,194 @@
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const { ensureWriteAuthorization } = require('../security/write-authorization');
+const { getCurrentDeviceProfile } = require('../device/current-device');
+const { loadDeviceOverride, upsertDeviceOverride } = require('../device/device-override-store');
+
+function normalizeString(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value.trim();
+}
+
+function printDevicePayload(payload, options = {}) {
+  if (options.json) {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+
+  console.log(chalk.blue('Current Device'));
+  console.log(`  ID: ${payload.summary.device_id}`);
+  console.log(`  Label: ${payload.summary.label}`);
+  console.log(`  Hostname: ${payload.summary.hostname}`);
+  console.log(`  Platform: ${payload.summary.platform}`);
+  console.log(`  Arch: ${payload.summary.arch}`);
+  console.log(`  User: ${payload.summary.user}`);
+  console.log(`  Capability Tags: ${payload.summary.capability_tag_count}`);
+  console.log(`  Identity Source: ${payload.summary.identity_source}`);
+}
+
+function printDeviceOverridePayload(payload, options = {}) {
+  if (options.json) {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+
+  console.log(chalk.blue('Device Override'));
+  console.log(`  Source File: ${payload.summary.source_file || '(not created)'}`);
+  console.log(`  Removed Apps: ${payload.summary.removed_app_count}`);
+  console.log(`  Added Apps: ${payload.summary.added_app_count}`);
+}
+
+async function ensureAuthorized(action, options = {}, dependencies = {}) {
+  const projectPath = dependencies.projectPath || process.cwd();
+  const fileSystem = dependencies.fileSystem || fs;
+  const env = dependencies.env || process.env;
+  await ensureWriteAuthorization(action, {
+    authLease: options.authLease,
+    authPassword: options.authPassword,
+    actor: options.actor
+  }, {
+    projectPath,
+    fileSystem,
+    env
+  });
+}
+
+async function runDeviceCurrentCommand(options = {}, dependencies = {}) {
+  const projectPath = dependencies.projectPath || process.cwd();
+  const fileSystem = dependencies.fileSystem || fs;
+  const device = await getCurrentDeviceProfile(projectPath, {
+    fileSystem,
+    persistIfMissing: false
+  });
+
+  const payload = {
+    mode: 'device-current',
+    generated_at: new Date().toISOString(),
+    summary: {
+      device_id: device.device_id,
+      label: device.label,
+      hostname: device.hostname,
+      platform: device.platform,
+      arch: device.arch,
+      user: device.user,
+      capability_tag_count: Array.isArray(device.capability_tags) ? device.capability_tags.length : 0,
+      identity_source: device.identity_source
+    },
+    device
+  };
+  printDevicePayload(payload, options);
+  return payload;
+}
+
+async function runDeviceOverrideShowCommand(options = {}, dependencies = {}) {
+  const projectPath = dependencies.projectPath || process.cwd();
+  const fileSystem = dependencies.fileSystem || fs;
+  const override = await loadDeviceOverride(projectPath, { fileSystem });
+  const payload = {
+    mode: 'device-override-show',
+    generated_at: new Date().toISOString(),
+    summary: {
+      source_file: override.source_file,
+      removed_app_count: Array.isArray(override.removed_apps) ? override.removed_apps.length : 0,
+      added_app_count: Array.isArray(override.added_apps) ? override.added_apps.length : 0
+    },
+    override
+  };
+  printDeviceOverridePayload(payload, options);
+  return payload;
+}
+
+async function runDeviceOverrideUpsertCommand(options = {}, dependencies = {}) {
+  const inputFile = normalizeString(options.input);
+  if (!inputFile) {
+    throw new Error('--input is required');
+  }
+
+  await ensureAuthorized('device:override:upsert', options, dependencies);
+  const projectPath = dependencies.projectPath || process.cwd();
+  const fileSystem = dependencies.fileSystem || fs;
+  const resolvedInput = path.isAbsolute(inputFile)
+    ? inputFile
+    : path.join(projectPath, inputFile);
+  const patch = await fileSystem.readJson(resolvedInput);
+  const override = await upsertDeviceOverride(projectPath, patch, { fileSystem });
+  const payload = {
+    mode: 'device-override-upsert',
+    success: true,
+    generated_at: new Date().toISOString(),
+    input_file: resolvedInput,
+    summary: {
+      source_file: override.source_file,
+      removed_app_count: Array.isArray(override.removed_apps) ? override.removed_apps.length : 0,
+      added_app_count: Array.isArray(override.added_apps) ? override.added_apps.length : 0
+    },
+    override
+  };
+  printDeviceOverridePayload(payload, options);
+  return payload;
+}
+
+function safeRun(handler, options = {}, context = 'device command') {
+  Promise.resolve(handler(options))
+    .catch((error) => {
+      if (options.json) {
+        console.log(JSON.stringify({ success: false, error: error.message }, null, 2));
+      } else {
+        console.error(chalk.red(`${context} failed:`), error.message);
+      }
+      process.exitCode = 1;
+    });
+}
+
+function registerDeviceCommands(program) {
+  const device = program
+    .command('device')
+    .description('Inspect current device identity, capability tags, and local override state');
+
+  device
+    .command('current')
+    .description('Show current device identity and capability tags')
+    .option('--json', 'Print machine-readable JSON output')
+    .action(async (options) => {
+      try {
+        await runDeviceCurrentCommand(options);
+      } catch (error) {
+        if (options.json) {
+          console.log(JSON.stringify({ success: false, error: error.message }, null, 2));
+        } else {
+          console.error(chalk.red('device current failed:'), error.message);
+        }
+        process.exitCode = 1;
+      }
+    });
+
+  const override = device
+    .command('override')
+    .description('Inspect and update local device override policy');
+
+  override
+    .command('show')
+    .description('Show current local device override policy')
+    .option('--json', 'Print machine-readable JSON output')
+    .action((options) => safeRun(runDeviceOverrideShowCommand, options, 'device override show'));
+
+  override
+    .command('upsert')
+    .description('Merge local device override fields from JSON input')
+    .requiredOption('--input <path>', 'JSON file with override fields to upsert')
+    .option('--auth-lease <lease-id>', 'Write authorization lease id')
+    .option('--auth-password <password>', 'Inline auth password if policy allows')
+    .option('--actor <actor>', 'Audit actor override')
+    .option('--json', 'Print machine-readable JSON output')
+    .action((options) => safeRun(runDeviceOverrideUpsertCommand, options, 'device override upsert'));
+}
+
+module.exports = {
+  runDeviceCurrentCommand,
+  runDeviceOverrideShowCommand,
+  runDeviceOverrideUpsertCommand,
+  registerDeviceCommands
+};