@aifabrix/builder 2.49.1 → 2.50.0

package/lib/channels/approval-guides/index.js

@@ -0,0 +1,110 @@
+/**
+ * Channel approval / go-live guide registry (plan 152).
+ *
+ * @fileoverview Per-target admin steps for channel add TTY output
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const path = require('path');
+const { getArtifactOutputPath } = require('../channel-artifact-generator');
+const { getChannelTarget } = require('../channel-targets');
+const { buildSlackApprovalGuide } = require('./slack');
+const { buildTeamsBotApprovalGuide } = require('./teams-bot');
+const { buildMicrosoftCopilotApprovalGuide } = require('./microsoft-copilot');
+const { buildChatGptApprovalGuide } = require('./chatgpt');
+const { buildWebEmbedInstallGuide } = require('./web-embed');
+const { buildCredentialPortalUrl } = require('./credential-portal');
+
+/** @type {Record<string, (ctx: Object) => { portalUrl: string|null, steps: string[] }>} */
+const GUIDE_BUILDERS = {
+  slack: buildSlackApprovalGuide,
+  'teams-bot': buildTeamsBotApprovalGuide,
+  'microsoft-copilot': buildMicrosoftCopilotApprovalGuide,
+  chatgpt: buildChatGptApprovalGuide,
+  'web-embed': buildWebEmbedInstallGuide
+};
+
+/**
+ * @param {string} projectRoot
+ * @param {string} channelTarget
+ * @param {string} [artifactPath]
+ * @returns {string}
+ */
+function resolveArtifactPath(projectRoot, channelTarget, artifactPath) {
+  if (artifactPath && String(artifactPath).trim()) {
+    return path.resolve(artifactPath);
+  }
+  return getArtifactOutputPath(projectRoot, channelTarget);
+}
+
+/**
+ * @param {string} channelTarget
+ * @param {string} name
+ * @returns {string}
+ */
+function buildResumeCommand(channelTarget, name) {
+  return `aifabrix channel add ${channelTarget} --name "${name}"`;
+}
+
+/**
+ * @param {string} channelTarget
+ * @param {Object} [context]
+ * @returns {Object}
+ */
+function buildChannelApprovalGuide(channelTarget, context = {}) {
+  const target = getChannelTarget(channelTarget);
+  const builder = GUIDE_BUILDERS[channelTarget];
+  if (!builder) {
+    throw new Error(`No approval guide for channel target "${channelTarget}"`);
+  }
+
+  const projectRoot = context.projectRoot || process.cwd();
+  const name = context.name || '';
+  const artifactPath = resolveArtifactPath(projectRoot, channelTarget, context.artifactPath);
+  const installGuidePath = path.join(path.dirname(artifactPath), 'INSTALL.md');
+  const resumeCommand = buildResumeCommand(channelTarget, name);
+  const credentialPortalUrl = context.dataplaneBaseUrl
+    ? buildCredentialPortalUrl(context.dataplaneBaseUrl, channelTarget)
+    : null;
+  const baseCtx = {
+    channelTarget,
+    artifactPath,
+    resumeCommand,
+    credentialKey: target.credentialKey,
+    credentialPortalUrl
+  };
+
+  const guide = builder(baseCtx);
+
+  return {
+    channelTarget,
+    portalUrl: guide.portalUrl,
+    artifactPath,
+    installGuidePath,
+    resumeCommand,
+    credentialKey: target.credentialKey,
+    credentialPortalUrl,
+    steps: guide.steps,
+    approvalRequired: target.approvalRequired === true
+  };
+}
+
+/**
+ * @param {string} channelTarget
+ * @param {Object} [context]
+ * @returns {string|null}
+ */
+function resolveApprovalPortalUrl(channelTarget, context = {}) {
+  return buildChannelApprovalGuide(channelTarget, context).portalUrl;
+}
+
+module.exports = {
+  GUIDE_BUILDERS,
+  buildChannelApprovalGuide,
+  resolveApprovalPortalUrl,
+  resolveArtifactPath,
+  buildResumeCommand
+};

package/lib/channels/approval-guides/microsoft-copilot.js

@@ -0,0 +1,34 @@
+/**
+ * Microsoft Copilot channel admin approval steps (plan 152).
+ *
+ * @fileoverview Copilot Studio / M365 admin connector guide
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { formatCredentialPortalStep } = require('./credential-portal');
+
+/**
+ * @param {Object} ctx
+ * @returns {{ portalUrl: string, steps: string[] }}
+ */
+function buildMicrosoftCopilotApprovalGuide(ctx) {
+  return {
+    portalUrl: 'https://admin.cloud.microsoft.com/',
+    steps: [
+      'Sign in to Microsoft 365 admin (https://admin.cloud.microsoft.com/) or Copilot Studio as a tenant admin.',
+      'Create or open a Copilot extensibility project (declarative agent or API plugin).',
+      'Import or configure using the generated manifest artifact (path shown below).',
+      'Point the OpenAPI / action endpoints to the URLs in INSTALL.md (dataplane Copilot routes).',
+      'Register OAuth client credentials for the API provider connection if the platform prompts for them.',
+      formatCredentialPortalStep(ctx, 'the OAuth client ID and client secret'),
+      'Submit for M365 admin approval and publish to your organization when review completes.',
+      `After Copilot shows the extension as available, re-run: ${ctx.resumeCommand}`,
+      'Optional: add --probe when dataplane Copilot runtime routes are live on your environment.'
+    ]
+  };
+}
+
+module.exports = { buildMicrosoftCopilotApprovalGuide };

package/lib/channels/approval-guides/slack.js

@@ -0,0 +1,34 @@
+/**
+ * Slack channel admin approval steps (plan 152).
+ *
+ * @fileoverview Slack app manifest install guide
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { formatCredentialPortalStep } = require('./credential-portal');
+
+/**
+ * @param {Object} ctx
+ * @returns {{ portalUrl: string, steps: string[] }}
+ */
+function buildSlackApprovalGuide(ctx) {
+  return {
+    portalUrl: 'https://api.slack.com/apps',
+    steps: [
+      'Open https://api.slack.com/apps and sign in as a Slack workspace admin.',
+      'Click Create New App → From an app manifest.',
+      'Select your workspace, then paste or upload the Slack app manifest (path shown below).',
+      'Review callback URLs and OAuth scopes (pre-filled from AI Fabrix), then create the app.',
+      'Open Install App → Install to Workspace and approve the installation.',
+      'Copy the Bot User OAuth Token and Signing Secret from the Slack app settings.',
+      formatCredentialPortalStep(ctx, 'the Bot User OAuth Token and Signing Secret'),
+      `When Slack shows the app as installed, re-run: ${ctx.resumeCommand}`,
+      'Optional: add --probe to verify callbacks and the assistant catalog.'
+    ]
+  };
+}
+
+module.exports = { buildSlackApprovalGuide };

package/lib/channels/approval-guides/teams-bot.js

@@ -0,0 +1,35 @@
+/**
+ * Microsoft Teams bot channel admin approval steps (plan 152).
+ *
+ * @fileoverview Teams Developer Portal + Azure Bot registration guide
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { formatCredentialPortalStep } = require('./credential-portal');
+
+/**
+ * @param {Object} ctx
+ * @returns {{ portalUrl: string, steps: string[] }}
+ */
+function buildTeamsBotApprovalGuide(ctx) {
+  return {
+    portalUrl: 'https://dev.teams.microsoft.com/',
+    steps: [
+      'Open the Teams Developer Portal (https://dev.teams.microsoft.com/) as a Teams tenant admin.',
+      'Create a new app or import the Bot Framework manifest JSON (path shown below).',
+      'Set the bot messaging endpoint to the Bot messages URL in INSTALL.md (your dataplane /messages route).',
+      'In Azure Portal, register or link the Azure Bot resource and copy the Microsoft App ID.',
+      'Create a client secret (or upload certificate) for the bot app registration in Microsoft Entra.',
+      'Enable the Microsoft Teams channel on the Azure Bot resource.',
+      formatCredentialPortalStep(ctx, 'the Microsoft App ID and client secret'),
+      'Publish the app to your org (or sideload for lab) and complete tenant admin approval if prompted.',
+      `After the bot is live in Teams, re-run: ${ctx.resumeCommand}`,
+      'Optional: add --probe to verify inbound JWT validation and the assistant catalog.'
+    ]
+  };
+}
+
+module.exports = { buildTeamsBotApprovalGuide };

package/lib/channels/approval-guides/web-embed.js

@@ -0,0 +1,32 @@
+/**
+ * Web embed channel go-live steps (plan 152) — no platform admin approval.
+ *
+ * @fileoverview Customer-site embed configuration guide
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { formatCredentialPortalStep } = require('./credential-portal');
+
+/**
+ * @param {Object} ctx
+ * @returns {{ portalUrl: null, steps: string[] }}
+ */
+function buildWebEmbedInstallGuide(ctx) {
+  return {
+    portalUrl: null,
+    steps: [
+      'Review the generated embed configuration JSON (path shown below).',
+      'Confirm allowed origins and the embed config URL in INSTALL.md match your customer site.',
+      formatCredentialPortalStep(ctx, 'the embed API key'),
+      'Add the embed snippet or widget loader to your web application (see INSTALL.md).',
+      'No Slack/Teams-style admin approval is required — validate in your browser after deploy.',
+      `Re-run: ${ctx.resumeCommand}`,
+      'Optional: add --probe to verify the config endpoint and assistant catalog.'
+    ]
+  };
+}
+
+module.exports = { buildWebEmbedInstallGuide };

package/lib/channels/channel-approval-guide.js

@@ -0,0 +1,11 @@
+/**
+ * Re-export channel approval guides (plan 152).
+ *
+ * @fileoverview Back-compat shim — implementation in approval-guides/
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+module.exports = require('./approval-guides');

package/lib/channels/channel-artifact-generator.js

@@ -13,6 +13,7 @@ const fs = require('fs');
 const path = require('path');
 const Handlebars = require('handlebars');
 const { getChannelTarget } = require('./channel-targets');
+const { BUILDER_ROOT } = require('./channel-integration-template');
 
 const SECRET_PATTERNS = [/xoxb-/i, /xoxp-/i, /client_secret/i, /signing_secret/i, /Bearer\s+/i];
 
@@ -32,13 +33,23 @@ function assertNoSecretsInArtifact(content) {
 }
 
 /**
- * @param {string} projectRoot
+ * Handlebars templates ship with @aifabrix/builder (not the caller's cwd).
  * @param {string} channelTarget
  * @returns {string}
  */
-function getTemplatesDir(projectRoot, channelTarget) {
+function getChannelTemplatesDir(channelTarget) {
   const target = getChannelTarget(channelTarget);
-  return path.join(projectRoot, 'templates', 'channels', target.templateDir);
+  return path.join(BUILDER_ROOT, 'templates', 'channels', target.templateDir);
+}
+
+/**
+ * @param {string} _projectRoot
+ * @param {string} channelTarget
+ * @returns {string}
+ * @deprecated Use getChannelTemplatesDir — templates are package-rooted.
+ */
+function getTemplatesDir(_projectRoot, channelTarget) {
+  return getChannelTemplatesDir(channelTarget);
 }
 
 /**
@@ -102,7 +113,7 @@ function renderInstallGuideIfPresent(templatesDir, runtimeValues, outputDir, dry
  * @returns {{ outputPath: string, artifactHash: string, content: string, installPath?: string }}
  */
 function generateChannelArtifact(params) {
-  const templatesDir = getTemplatesDir(params.projectRoot, params.channelTarget);
+  const templatesDir = getChannelTemplatesDir(params.channelTarget);
   const manifestTemplate = path.join(templatesDir, 'manifest.template.json.hbs');
   const content = renderTemplateFile(manifestTemplate, params.runtimeValues);
   assertNoSecretsInArtifact(content);
@@ -133,6 +144,7 @@ function generateChannelArtifact(params) {
 
 module.exports = {
   assertNoSecretsInArtifact,
+  getChannelTemplatesDir,
   getTemplatesDir,
   getArtifactOutputPath,
   renderTemplateFile,

package/lib/channels/channel-audit.js

@@ -15,6 +15,9 @@ const logger = require('../utils/logger');
  * @param {Object} payload
  */
 function emitChannelAuditEvent(eventName, payload) {
+  if (process.env.AIFABRIX_CHANNEL_AUDIT !== '1') {
+    return;
+  }
   logger.log(
     JSON.stringify({
       event: eventName,

package/lib/channels/channel-auth-context.js

@@ -21,7 +21,7 @@ const { resolveDataplaneUrl } = require('../utils/dataplane-resolver');
  */
 async function resolveChannelAuthContext(channelTarget, opts = {}) {
   const controllerUrl = await resolveControllerUrl();
-  const environment = (await config.getEnvironment()) || 'dev';
+  const environment = (await config.resolveEnvironment()) || 'dev';
   const authConfig = await getDeploymentAuth(controllerUrl, environment, channelTarget);
   if (!authConfig) {
     throw new Error('Authentication required. Run "aifabrix login" first.');

package/lib/channels/channel-description.js

@@ -0,0 +1,59 @@
+/**
+ * Slack manifest description limits (plan 152).
+ *
+ * @fileoverview Enforce Slack display_information.description max length
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+/** Slack manifest `display_information.description` max (api.slack.com/reference/manifests). */
+const SLACK_APP_DESCRIPTION_MAX_LENGTH = 140;
+
+/**
+ * @param {string} description
+ * @returns {string}
+ */
+function normalizeSlackAppDescription(description) {
+  const text = String(description ?? '').trim();
+  if (!text || text.length <= SLACK_APP_DESCRIPTION_MAX_LENGTH) {
+    return text;
+  }
+  return `${text.slice(0, SLACK_APP_DESCRIPTION_MAX_LENGTH - 1)}…`;
+}
+
+/**
+ * @param {string} description
+ * @returns {string}
+ * @throws {Error}
+ */
+function assertSlackAppDescription(description) {
+  const text = String(description ?? '').trim();
+  if (text.length > SLACK_APP_DESCRIPTION_MAX_LENGTH) {
+    throw new Error(
+      `Slack app description must be at most ${SLACK_APP_DESCRIPTION_MAX_LENGTH} characters (got ${text.length}). Provide a shorter --description.`
+    );
+  }
+  return text;
+}
+
+/**
+ * @param {string} channelTarget
+ * @param {string} description
+ * @returns {string}
+ */
+function resolveAppDescription(channelTarget, description) {
+  const text = String(description ?? '').trim();
+  if (channelTarget === 'slack') {
+    return assertSlackAppDescription(text);
+  }
+  return text;
+}
+
+module.exports = {
+  SLACK_APP_DESCRIPTION_MAX_LENGTH,
+  normalizeSlackAppDescription,
+  assertSlackAppDescription,
+  resolveAppDescription
+};

package/lib/channels/channel-integration-generator.js

@@ -1,9 +1,11 @@
 /**
- * Generate integration/<channelTarget>/ for communication external systems (plan 152).
+ * Scaffold integration/<channelTarget>/ from published templates (plan 152).
+ * Manifest SSOT: dataplane integration/ (slack via make sync-json) → templates/channels/{target}/integration/.
+ * Builder generates only *-deploy.json at scaffold time.
  *
- * @fileoverview Builder generator for channel deploy step 1 scaffolds
+ * @fileoverview Channel integration scaffold — template copy + deploy JSON
  * @author AI Fabrix Team
- * @version 1.0.0
+ * @version 2.0.0
  */
 
 'use strict';
@@ -12,201 +14,8 @@ const fs = require('fs');
 const path = require('path');
 const { getChannelTarget } = require('./channel-targets');
 const { getIntegrationPath } = require('../utils/paths');
-
-/** @type {Record<string, Object>} */
-const AUTH_BLOCKS = {
-  slack: {
-    authType: 'credential',
-    credential: {
-      credentialKey: 'slack-app',
-      displayName: 'Slack assistant channel',
-      method: 'hmac',
-      variables: {},
-      security: {
-        signingSecret: 'kv://slack/signingSecret',
-        clientId: 'kv://slack/clientId',
-        clientSecret: 'kv://slack/clientSecret'
-      },
-      writeOnce: true
-    }
-  },
-  'teams-bot': {
-    authType: 'credential',
-    credential: {
-      credentialKey: 'teams-bot',
-      displayName: 'Microsoft Teams assistant bot',
-      method: 'oidc',
-      variables: {
-        openIdConfigUrl: 'https://login.botframework.com/v1/.well-known/openid_configuration',
-        clientId: 'kv://teams-bot/botAppId',
-        expectedIssuer: 'https://api.botframework.com'
-      },
-      security: {},
-      writeOnce: true
-    }
-  },
-  'microsoft-copilot': {
-    authType: 'credential',
-    credential: {
-      credentialKey: 'microsoft-copilot-channel',
-      displayName: 'Microsoft Copilot assistant channel',
-      method: 'oauth2',
-      variables: {
-        tokenUrl: 'https://login.microsoftonline.com/common/oauth2/v2.0/token',
-        grantType: 'client_credentials'
-      },
-      security: {
-        clientId: 'kv://microsoft-copilot/clientId',
-        clientSecret: 'kv://microsoft-copilot/clientSecret'
-      },
-      writeOnce: true
-    }
-  },
-  chatgpt: {
-    authType: 'credential',
-    credential: {
-      credentialKey: 'chatgpt-channel',
-      displayName: 'ChatGPT assistant channel',
-      method: 'apikey',
-      variables: {},
-      security: {
-        apiKey: 'kv://chatgpt/apiKey'
-      },
-      writeOnce: true
-    }
-  },
-  'web-embed': {
-    authType: 'credential',
-    credential: {
-      credentialKey: 'web-embed-channel',
-      displayName: 'Web embed assistant channel',
-      method: 'apikey',
-      variables: {},
-      security: {
-        apiKey: 'kv://web-embed/apiKey'
-      },
-      writeOnce: true
-    }
-  }
-};
-
-/**
- * @param {string} channelTarget
- * @param {typeof import('./channel-targets').CHANNEL_TARGETS[string]} target
- * @returns {Object}
- */
-function buildAuthenticationBlock(channelTarget, target) {
-  const block = AUTH_BLOCKS[channelTarget];
-  if (!block) {
-    throw new Error(`No authentication block for channel target "${channelTarget}"`);
-  }
-  const auth = JSON.parse(JSON.stringify(block));
-  auth.credential.credentialKey = target.credentialKey;
-  return auth;
-}
-
-/**
- * @param {string} channelTarget
- * @returns {Object}
- */
-function buildSystemJson(channelTarget) {
-  const target = getChannelTarget(channelTarget);
-  const system = {
-    key: channelTarget,
-    displayName: 'Microsoft Teams assistant bot',
-    description: 'Bot Framework assistant channel (not full Teams / Graph integration)',
-    type: 'custom',
-    systemKind: 'communication',
-    enabled: true,
-    authentication: buildAuthenticationBlock(channelTarget, target),
-    configuration: [],
-    dataSources: []
-  };
-
-  if (channelTarget === 'teams-bot') {
-    system.displayName = 'Microsoft Teams assistant bot';
-    system.endpoints = [
-      {
-        type: 'messages',
-        path: '/messages',
-        router: 'teams_bot_router',
-        description: 'Bot Framework messaging endpoint',
-        active: true
-      },
-      {
-        type: 'notifications',
-        path: '/notifications',
-        router: 'teams_notifications_router',
-        description: 'Proactive notification endpoint',
-        active: true
-      },
-      {
-        type: 'config',
-        path: '/bot-config',
-        router: 'teams_config_router',
-        description: 'Bot configuration endpoint',
-        active: true
-      }
-    ];
-    system.endpointsActive = true;
-  } else {
-    system.displayName = `${target.key} assistant channel`;
-    system.description = 'Communication external system for assistant channel install (plan 152)';
-  }
-
-  return system;
-}
-
-/**
- * @param {string} channelTarget
- * @returns {Object}
- */
-function buildApplicationJson(channelTarget) {
-  const target = getChannelTarget(channelTarget);
-  const systemFile = `${channelTarget}-system.json`;
-  return {
-    app: {
-      key: channelTarget,
-      displayName: `${target.key} assistant channel`,
-      description: 'Assistant communication channel — deploy then app add-channel',
-      type: 'external'
-    },
-    externalIntegration: {
-      schemaBasePath: './',
-      systems: [systemFile],
-      dataSources: [],
-      autopublish: true,
-      version: '1.0.0'
-    }
-  };
-}
-
-/**
- * @param {string} channelTarget
- * @returns {string}
- */
-function buildEnvTemplate(channelTarget) {
-  const kvPrefix = channelTarget === 'web-embed' ? 'web-embed' : channelTarget;
-  const lines = [
-    `# ${channelTarget} assistant channel — resolve secrets before deploy/add-channel`,
-    '# kv:// paths are pushed via aifabrix credential push or add-channel secret sync',
-    ''
-  ];
-  if (channelTarget === 'slack') {
-    lines.push('KV_SLACK_SIGNINGSECRET=kv://slack/signingSecret');
-    lines.push('KV_SLACK_CLIENTID=kv://slack/clientId');
-    lines.push('KV_SLACK_CLIENTSECRET=kv://slack/clientSecret');
-  } else if (channelTarget === 'teams-bot') {
-    lines.push('KV_TEAMS_BOT_BOTAPPID=kv://teams-bot/botAppId');
-  } else if (channelTarget === 'microsoft-copilot') {
-    lines.push('KV_MICROSOFT_COPILOT_CLIENTID=kv://microsoft-copilot/clientId');
-    lines.push('KV_MICROSOFT_COPILOT_CLIENTSECRET=kv://microsoft-copilot/clientSecret');
-  } else {
-    lines.push(`KV_${kvPrefix.toUpperCase().replace(/-/g, '_')}_APIKEY=kv://${kvPrefix}/apiKey`);
-  }
-  lines.push('');
-  return lines.join('\n');
-}
+const { copyChannelIntegrationTemplate } = require('./channel-integration-template');
+const { generateDeployJson } = require('../generator/index');
 
 /**
  * @param {string} channelTarget
@@ -214,9 +23,9 @@ function buildEnvTemplate(channelTarget) {
  * @param {boolean} [options.force]
  * @param {boolean} [options.allowExperimental]
  * @param {string} [options.projectRoot]
- * @returns {{ integrationDir: string, files: string[] }}
+ * @returns {Promise<{ integrationDir: string, files: string[] }>}
  */
-function scaffoldChannelIntegration(channelTarget, options = {}) {
+async function scaffoldChannelIntegration(channelTarget, options = {}) {
   const target = getChannelTarget(channelTarget);
   if (target.experimental && !options.allowExperimental) {
     throw new Error(
@@ -233,42 +42,16 @@ function scaffoldChannelIntegration(channelTarget, options = {}) {
     );
   }
 
-  fs.mkdirSync(integrationDir, { recursive: true });
-  const systemPath = path.join(integrationDir, `${channelTarget}-system.json`);
-  const appPath = path.join(integrationDir, 'application.json');
-  const envPath = path.join(integrationDir, 'env.template');
-  const readmePath = path.join(integrationDir, 'README.md');
-
-  fs.writeFileSync(systemPath, `${JSON.stringify(buildSystemJson(channelTarget), null, 2)}\n`, 'utf8');
-  fs.writeFileSync(appPath, `${JSON.stringify(buildApplicationJson(channelTarget), null, 2)}\n`, 'utf8');
-  fs.writeFileSync(envPath, buildEnvTemplate(channelTarget), 'utf8');
-  fs.writeFileSync(
-    readmePath,
-    [
-      `# ${channelTarget} assistant channel`,
-      '',
-      '## Two-step install',
-      '',
-      '```bash',
-      `aifabrix deploy ${channelTarget}`,
-      `aifabrix app add-channel ${channelTarget} --name "Your Assistant"`,
-      '```',
-      '',
-      'Generated by `aifabrix channel scaffold`. Secrets belong in kv:// env.template only.',
-      ''
-    ].join('\n'),
-    'utf8'
-  );
+  const copied = copyChannelIntegrationTemplate(channelTarget, integrationDir);
+  const deployPath = await generateDeployJson(channelTarget, { appPath: integrationDir });
+  const files = [...copied, deployPath];
 
   return {
     integrationDir,
-    files: [systemPath, appPath, envPath, readmePath]
+    files
   };
 }
 
 module.exports = {
-  buildSystemJson,
-  buildApplicationJson,
-  buildEnvTemplate,
   scaffoldChannelIntegration
 };