@aifabrix/builder 2.51.0 → 2.52.0

package/lib/channels/channel-targets.js

@@ -8,6 +8,11 @@
 
 'use strict';
 
+const {
+  CHATGPT_RUNTIME_SYSTEM_KEY,
+  COPILOT_RUNTIME_SYSTEM_KEY
+} = require('./chatgpt-runtime-contract');
+
 /** @typedef {'teams-bot'|'slack'|'microsoft-copilot'|'chatgpt'|'web-embed'} ChannelTargetKey */
 
 const DEFAULT_CAPABILITIES = ['chat', 'notify', 'documentApproval'];
@@ -44,6 +49,7 @@ const CHANNEL_TARGETS = {
     artifactFileName: 'channel-microsoft-copilot.json',
     artifactFormat: 'json',
     credentialKey: 'microsoft-copilot-channel',
+    routeSystemKey: COPILOT_RUNTIME_SYSTEM_KEY,
     capabilities: [...DEFAULT_CAPABILITIES, 'enterpriseActions'],
     approvalRequired: true,
     experimental: false
@@ -55,6 +61,7 @@ const CHANNEL_TARGETS = {
     artifactFileName: 'channel-chatgpt.json',
     artifactFormat: 'json',
     credentialKey: 'chatgpt-channel',
+    routeSystemKey: CHATGPT_RUNTIME_SYSTEM_KEY,
     capabilities: ['chat', 'enterpriseActions'],
     approvalRequired: true,
     experimental: false
@@ -106,10 +113,27 @@ function getDefaultChannelDescription() {
   );
 }
 
+/**
+ * Human-readable supported channel list for CLI help and error hints.
+ * @returns {string}
+ */
+function formatSupportedChannelTargetsHelp() {
+  const stable = CHANNEL_TARGET_KEYS.filter((key) => !CHANNEL_TARGETS[key].experimental);
+  const experimental = CHANNEL_TARGET_KEYS.filter((key) => CHANNEL_TARGETS[key].experimental);
+  const lines = ['Supported channels:', `  ${stable.join(', ')}`];
+  if (experimental.length > 0) {
+    lines.push(
+      `  ${experimental.join(', ')} (experimental — scaffold with --allow-experimental)`
+    );
+  }
+  return lines.join('\n');
+}
+
 module.exports = {
   CHANNEL_TARGETS,
   CHANNEL_TARGET_KEYS,
   isChannelTargetKey,
   getChannelTarget,
-  getDefaultChannelDescription
+  getDefaultChannelDescription,
+  formatSupportedChannelTargetsHelp
 };

package/lib/channels/chatgpt-runtime-contract.js

@@ -0,0 +1,29 @@
+/**
+ * ChatGPT custom MCP app runtime contract constants (plan 163).
+ *
+ * @fileoverview Runtime-orchestration MCP contract fields used by chatgpt channel templates and probes
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const RUNTIME_ORCHESTRATION_SYSTEM_KEY = 'runtime-orchestration';
+
+const CHATGPT_RUNTIME_SYSTEM_KEY = RUNTIME_ORCHESTRATION_SYSTEM_KEY;
+const CHATGPT_RUNTIME_TRANSPORT = 'streamable-http';
+const CHATGPT_RUNTIME_AUTH_MODE = 'oauth21-authorization-code-pkce-s256';
+
+const COPILOT_RUNTIME_SYSTEM_KEY = RUNTIME_ORCHESTRATION_SYSTEM_KEY;
+const COPILOT_RUNTIME_TRANSPORT = 'streamable-http';
+const COPILOT_RUNTIME_AUTH_MODE = 'microsoft-entra-sso-or-oauth';
+
+module.exports = {
+  RUNTIME_ORCHESTRATION_SYSTEM_KEY,
+  CHATGPT_RUNTIME_SYSTEM_KEY,
+  CHATGPT_RUNTIME_TRANSPORT,
+  CHATGPT_RUNTIME_AUTH_MODE,
+  COPILOT_RUNTIME_SYSTEM_KEY,
+  COPILOT_RUNTIME_TRANSPORT,
+  COPILOT_RUNTIME_AUTH_MODE
+};

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

@@ -0,0 +1,280 @@
+/**
+ * Microsoft Copilot package artifact generation (plan 164).
+ *
+ * @fileoverview Build source files, package ZIP, and lifecycle summary for microsoft-copilot channel
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const AdmZip = require('adm-zip');
+
+const PLACEHOLDER_ICON_BASE64 =
+  'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO2s9WQAAAAASUVORK5CYII=';
+
+/**
+ * @param {string} outputPath
+ * @param {Object} runtimeValues
+ * @returns {Object}
+ */
+function buildCopilotOutputPaths(outputPath, runtimeValues) {
+  const rootDir = path.dirname(outputPath);
+  const sourceDir = path.join(rootDir, 'source');
+  const buildDir = path.join(rootDir, 'build');
+  const installDir = path.join(rootDir, 'install');
+  const environment = String(runtimeValues.environment || 'dev').trim() || 'dev';
+  const zipFileName = `appPackage.${environment}.zip`;
+  return {
+    rootDir,
+    sourceDir,
+    buildDir,
+    installDir,
+    summaryPath: outputPath,
+    zipFileName,
+    zipPath: path.join(buildDir, zipFileName),
+    validationPath: path.join(installDir, 'validation.json'),
+    installPath: path.join(installDir, 'README.md')
+  };
+}
+
+/**
+ * @returns {{ color: Buffer, outline: Buffer }}
+ */
+function getPlaceholderIcons() {
+  const icon = Buffer.from(PLACEHOLDER_ICON_BASE64, 'base64');
+  return { color: icon, outline: icon };
+}
+
+/**
+ * @param {Object} runtimeValues
+ * @param {(templatePath: string, context: Object) => string} renderTemplateFile
+ * @param {string} templatesDir
+ * @returns {{ sourceFiles: Record<string, string>, installText: string }}
+ */
+function renderCopilotTemplates(runtimeValues, renderTemplateFile, templatesDir) {
+  const sourceFiles = {
+    'manifest.json': renderTemplateFile(path.join(templatesDir, 'manifest.template.json.hbs'), runtimeValues),
+    'declarativeAgent.json': renderTemplateFile(
+      path.join(templatesDir, 'declarative-agent.template.json.hbs'),
+      runtimeValues
+    ),
+    'ai-plugin.json': renderTemplateFile(
+      path.join(templatesDir, 'ai-plugin.template.json.hbs'),
+      runtimeValues
+    )
+  };
+  const installText = renderTemplateFile(path.join(templatesDir, 'install.template.md.hbs'), runtimeValues);
+  return { sourceFiles, installText };
+}
+
+/**
+ * @param {Record<string, string>} sourceFiles
+ * @param {(content: string) => void} assertNoSecretsInArtifact
+ */
+function assertNoSecretsInSourceFiles(sourceFiles, assertNoSecretsInArtifact) {
+  for (const content of Object.values(sourceFiles)) {
+    assertNoSecretsInArtifact(content);
+  }
+}
+
+/**
+ * @param {Record<string, string>} sourceFiles
+ * @param {{ color: Buffer, outline: Buffer }} icons
+ * @returns {Buffer}
+ */
+function buildCopilotZipBuffer(sourceFiles, icons) {
+  const zip = new AdmZip();
+  zip.addFile('manifest.json', Buffer.from(sourceFiles['manifest.json'], 'utf8'));
+  zip.addFile('declarativeAgent.json', Buffer.from(sourceFiles['declarativeAgent.json'], 'utf8'));
+  zip.addFile('ai-plugin.json', Buffer.from(sourceFiles['ai-plugin.json'], 'utf8'));
+  zip.addFile('color.png', icons.color);
+  zip.addFile('outline.png', icons.outline);
+  return zip.toBuffer();
+}
+
+/**
+ * @param {Object} runtimeValues
+ * @param {Object} paths
+ * @param {string[]} sourceFileNames
+ * @returns {Object}
+ */
+function buildCopilotValidation(runtimeValues, paths, sourceFileNames) {
+  return {
+    tier: 'builderValidated',
+    environment: runtimeValues.environment,
+    sourceFiles: sourceFileNames,
+    zipFile: paths.zipFileName,
+    runtimeSystemKey: runtimeValues.runtimeSystemKey,
+    runtimeMcpUrl: runtimeValues.mcpUrl,
+    runtimeTransport: runtimeValues.runtimeTransport,
+    expectedLayerBToolNames: runtimeValues.layerBToolNames || [],
+    boundaries: {
+      onePackagePerEnvironment: true,
+      topLevelVendorToolsExposed: false,
+      roleAssistantResolution: 'dynamic-runtime'
+    },
+    requiresMicrosoftAdmin: [
+      'upload-package',
+      'tenant-approval',
+      'assignment-and-consent',
+      'first-copilot-invoke'
+    ]
+  };
+}
+
+/**
+ * @param {Array<string|Buffer>} parts
+ * @returns {string}
+ */
+function computeCopilotArtifactHash(parts) {
+  const hash = crypto.createHash('sha256');
+  for (const part of parts) {
+    if (Buffer.isBuffer(part)) {
+      hash.update(part);
+      continue;
+    }
+    hash.update(String(part), 'utf8');
+  }
+  return hash.digest('hex');
+}
+
+/**
+ * @param {Object} runtimeValues
+ * @param {Object} paths
+ * @param {Object} validation
+ * @param {string} artifactHash
+ * @returns {Object}
+ */
+function buildCopilotSummary(runtimeValues, paths, validation, artifactHash) {
+  return {
+    channelTarget: runtimeValues.channelTarget,
+    name: runtimeValues.appName,
+    baseName: runtimeValues.baseName,
+    description: runtimeValues.appDescription,
+    environment: runtimeValues.environment,
+    runtime: {
+      runtimeSystemKey: runtimeValues.runtimeSystemKey,
+      remoteMcpUrl: runtimeValues.mcpUrl,
+      transport: runtimeValues.runtimeTransport,
+      assistantCatalogUrl: runtimeValues.assistantCatalogUrl,
+      roleAssistantResolution: 'dynamic-runtime',
+      layerBToolNames: runtimeValues.layerBToolNames || []
+    },
+    authentication: {
+      mode: runtimeValues.runtimeAuthMode,
+      credentialKey: runtimeValues.credentialKey,
+      credentialPortalUrl: runtimeValues.credentialPortalUrl,
+      scopes: runtimeValues.scopes || []
+    },
+    package: {
+      appId: runtimeValues.packageAppId,
+      version: runtimeValues.packageVersion,
+      sourceFiles: ['manifest.json', 'declarativeAgent.json', 'ai-plugin.json', 'color.png', 'outline.png'],
+      zipFileName: paths.zipFileName,
+      installGuide: path.relative(paths.rootDir, paths.installPath),
+      validationFile: path.relative(paths.rootDir, paths.validationPath)
+    },
+    probeTiers: {
+      builderValidated: true,
+      runtimeValidated: false,
+      requiresMicrosoftAdmin: true
+    },
+    artifact: {
+      format: 'microsoft-365-copilot-package',
+      hash: artifactHash,
+      generatedAt: new Date().toISOString()
+    },
+    validation
+  };
+}
+
+/**
+ * @param {Object} params
+ */
+function writeCopilotArtifacts(params) {
+  const { paths, sourceFiles, icons, zipBuffer, installText, validationText, summaryText } = params;
+  fs.mkdirSync(paths.sourceDir, { recursive: true });
+  fs.mkdirSync(paths.buildDir, { recursive: true });
+  fs.mkdirSync(paths.installDir, { recursive: true });
+  fs.writeFileSync(path.join(paths.sourceDir, 'manifest.json'), sourceFiles['manifest.json'], 'utf8');
+  fs.writeFileSync(
+    path.join(paths.sourceDir, 'declarativeAgent.json'),
+    sourceFiles['declarativeAgent.json'],
+    'utf8'
+  );
+  fs.writeFileSync(path.join(paths.sourceDir, 'ai-plugin.json'), sourceFiles['ai-plugin.json'], 'utf8');
+  fs.writeFileSync(path.join(paths.sourceDir, 'color.png'), icons.color);
+  fs.writeFileSync(path.join(paths.sourceDir, 'outline.png'), icons.outline);
+  fs.writeFileSync(paths.zipPath, zipBuffer);
+  fs.writeFileSync(paths.installPath, installText, 'utf8');
+  fs.writeFileSync(paths.validationPath, validationText, 'utf8');
+  fs.writeFileSync(paths.summaryPath, summaryText, 'utf8');
+}
+
+/**
+ * @param {Object} params
+ * @param {Object} params.runtimeValues
+ * @param {string} params.templatesDir
+ * @param {string} params.outputPath
+ * @param {boolean} [params.dryRun]
+ * @param {(content: string) => void} params.assertNoSecretsInArtifact
+ * @param {(templatePath: string, context: Object) => string} params.renderTemplateFile
+ * @returns {{ outputPath: string, artifactHash: string, content: string, installPath: string }}
+ */
+function generateMicrosoftCopilotPackage(params) {
+  const runtimeValues = params.runtimeValues || {};
+  const paths = buildCopilotOutputPaths(params.outputPath, runtimeValues);
+  const icons = getPlaceholderIcons();
+  const { sourceFiles, installText } = renderCopilotTemplates(
+    runtimeValues,
+    params.renderTemplateFile,
+    params.templatesDir
+  );
+  assertNoSecretsInSourceFiles(sourceFiles, params.assertNoSecretsInArtifact);
+  params.assertNoSecretsInArtifact(installText);
+  const zipBuffer = buildCopilotZipBuffer(sourceFiles, icons);
+  const validation = buildCopilotValidation(runtimeValues, paths, Object.keys(sourceFiles));
+  const validationText = JSON.stringify(validation, null, 2);
+  const artifactHash = computeCopilotArtifactHash([
+    sourceFiles['manifest.json'],
+    sourceFiles['declarativeAgent.json'],
+    sourceFiles['ai-plugin.json'],
+    installText,
+    validationText,
+    zipBuffer
+  ]);
+  const summary = buildCopilotSummary(runtimeValues, paths, validation, artifactHash);
+  const summaryText = JSON.stringify(summary, null, 2);
+  params.assertNoSecretsInArtifact(summaryText);
+  if (!params.dryRun) {
+    writeCopilotArtifacts({
+      paths,
+      sourceFiles,
+      icons,
+      zipBuffer,
+      installText,
+      validationText,
+      summaryText
+    });
+  }
+  return {
+    outputPath: paths.summaryPath,
+    artifactHash,
+    content: summaryText,
+    installPath: paths.installPath
+  };
+}
+
+module.exports = {
+  generateMicrosoftCopilotPackage,
+  buildCopilotOutputPaths,
+  renderCopilotTemplates,
+  buildCopilotZipBuffer,
+  buildCopilotValidation,
+  buildCopilotSummary,
+  computeCopilotArtifactHash
+};

package/lib/channels/runtime-tool-catalog.js

@@ -0,0 +1,165 @@
+/**
+ * Resolve Runtime Layer B tool names from Dataplane.
+ *
+ * @fileoverview Runtime-orchestration MCP tool discovery for channel artifacts and probes
+ * @author AI Fabrix Team
+ * @version 1.1.0
+ */
+
+'use strict';
+
+const { createDataplaneApiClient } = require('../api/index');
+const { getChannelTarget } = require('./channel-targets');
+
+/**
+ * Prefer the first-party MCP gateway catalog, then MCP OpenAPI, then legacy paths.
+ */
+const TOOL_CATALOG_BUILDERS = Object.freeze([
+  (systemKey) =>
+    `/api/v1/mcp/servers/tools?filter=${encodeURIComponent(`systemKey:eq:${systemKey}`)}&pageSize=100`,
+  (systemKey) => `/api/v1/mcp/${systemKey}/docs/mcp-openapi.json`,
+  (systemKey) => `/api/v1/external/systems/${systemKey}/mcp/tools`,
+  (systemKey) => `/api/v1/external/systems/${systemKey}/mcp/tools/list`,
+  (systemKey) => `/api/v1/external/systems/${systemKey}/mcp/catalog`,
+  (systemKey) => `/api/v1/external/systems/${systemKey}/tools`
+]);
+
+/**
+ * @param {unknown} value
+ * @returns {string[]}
+ */
+function extractToolNames(value) {
+  if (Array.isArray(value)) {
+    return value
+      .map((item) => {
+        if (typeof item === 'string') return item.trim();
+        if (!item || typeof item !== 'object') return '';
+        return String(item.name || item.toolName || item.key || '').trim();
+      })
+      .filter(Boolean);
+  }
+  if (!value || typeof value !== 'object') {
+    return [];
+  }
+  const body = /** @type {Record<string, unknown>} */ (value);
+  if (body.paths && typeof body.paths === 'object') {
+    return extractToolNamesFromOpenApiPaths(body.paths);
+  }
+  const candidates = [body.tools, body.items, body.data, body.result];
+  for (const candidate of candidates) {
+    const names = extractToolNames(candidate);
+    if (names.length > 0) {
+      return names;
+    }
+  }
+  return [];
+}
+
+/**
+ * @param {Record<string, unknown>} paths
+ * @returns {string[]}
+ */
+function extractToolNamesFromOpenApiPaths(paths) {
+  const names = [];
+  for (const pathKey of Object.keys(paths || {})) {
+    const match = String(pathKey).match(/\/tools\/([^/]+)\/execute$/);
+    if (match && match[1] && match[1] !== 'execute') {
+      names.push(match[1]);
+    }
+  }
+  return [...new Set(names)];
+}
+
+/**
+ * @param {string} routeSystemKey
+ * @returns {string[]}
+ */
+function buildToolCatalogEndpoints(routeSystemKey) {
+  return TOOL_CATALOG_BUILDERS.map((build) => build(routeSystemKey));
+}
+
+/**
+ * @param {Object} response
+ * @returns {string[]}
+ */
+function extractToolNamesFromClientResponse(response) {
+  const direct = extractToolNames(response);
+  if (direct.length > 0) return preferLayerBToolNames(direct);
+  return preferLayerBToolNames(extractToolNames(response?.data ?? response));
+}
+
+/**
+ * Prefer MCP Layer B names (`work.start`) over REST-ish operation ids.
+ *
+ * @param {string[]} names
+ * @returns {string[]}
+ */
+function preferLayerBToolNames(names) {
+  const list = Array.isArray(names) ? names : [];
+  const dotted = list.filter((name) => /^[a-z][a-z0-9]*\.[a-z][a-z0-9.]*$/i.test(name));
+  return dotted.length > 0 ? dotted : list;
+}
+
+/**
+ * @param {string} dataplaneUrl
+ * @param {Object} authConfig
+ * @param {string} channelTarget
+ * @returns {Promise<string[]>}
+ */
+async function fetchRuntimeLayerBToolNames(dataplaneUrl, authConfig, channelTarget) {
+  const target = getChannelTarget(channelTarget);
+  const routeSystemKey = target.routeSystemKey || target.key;
+  const client = createDataplaneApiClient(dataplaneUrl, authConfig);
+  const endpoints = buildToolCatalogEndpoints(routeSystemKey);
+  for (const endpoint of endpoints) {
+    try {
+      const response = await client.get(endpoint, { timeoutMs: 10000 });
+      const names = extractToolNamesFromClientResponse(response);
+      if (Array.isArray(names) && names.length > 0) {
+        return [...new Set(names)].sort();
+      }
+    } catch {
+      // Try the next endpoint candidate.
+    }
+  }
+  return [];
+}
+
+/**
+ * True when Runtime MCP gateway docs or tool catalog is reachable.
+ *
+ * @async
+ * @param {string} dataplaneUrl
+ * @param {Object} authConfig
+ * @param {string} routeSystemKey
+ * @returns {Promise<boolean>}
+ */
+async function isRuntimeMcpGatewayReachable(dataplaneUrl, authConfig, routeSystemKey) {
+  if (!dataplaneUrl || !routeSystemKey) return false;
+  const client = createDataplaneApiClient(dataplaneUrl, authConfig);
+  const candidates = [
+    `/api/v1/mcp/${routeSystemKey}/docs/mcp-openapi.json`,
+    `/api/v1/mcp/servers/tools?filter=${encodeURIComponent(`systemKey:eq:${routeSystemKey}`)}&pageSize=1`
+  ];
+  for (const endpoint of candidates) {
+    try {
+      const response = await client.get(endpoint, { timeoutMs: 8000 });
+      if (response && response.success !== false) {
+        return true;
+      }
+    } catch {
+      // try next
+    }
+  }
+  return false;
+}
+
+module.exports = {
+  TOOL_CATALOG_BUILDERS,
+  extractToolNames,
+  extractToolNamesFromOpenApiPaths,
+  preferLayerBToolNames,
+  buildToolCatalogEndpoints,
+  fetchRuntimeLayerBToolNames,
+  isRuntimeMcpGatewayReachable
+};

package/lib/cli/index.js

@@ -24,6 +24,7 @@ const { setupDatasourceCommands } = require('../commands/datasource');
 const { setupDimensionCommands } = require('../commands/dimension');
 const { setupResourceTypeCommands } = require('../commands/resource-type');
 const { setupRoleCommands } = require('../commands/role');
+const { setupRoleAssistantCommands } = require('../commands/role-assistant');
 const { setupEvidenceKindCommands } = require('../commands/evidence-kind');
 const { setupEnterpriseKnowledgeCommands } = require('../commands/enterprise-knowledge');
 const { setupIdentityCommands } = require('../commands/identity');
@@ -76,6 +77,7 @@ function setupExtendedCliCommands(program) {
   setupDimensionCommands(program);
   setupResourceTypeCommands(program);
   setupRoleCommands(program);
+  setupRoleAssistantCommands(program);
   setupEvidenceKindCommands(program);
   setupEnterpriseKnowledgeCommands(program);
   setupIdentityCommands(program);

package/lib/cli/infra-guided-footers.js

@@ -95,7 +95,7 @@ function logPlatformSetupDurationHint(scope = 'platform') {
   const line =
     scope === 'dataplane'
       ? 'Installation may take a few minutes. Authenticating and starting Dataplane — please wait.'
-      : 'Installation may take a few minutes. Keycloak, Miso Controller, and Dataplane are starting — please wait.';
+      : 'Installation may take a few minutes. Keycloak, Miso Controller, Dataplane, and Builder API are starting — please wait.';
   logger.log(chalk.yellow(`⚠ ${line}`));
 }
 

package/lib/cli/infra-guided-public-url-warn.js

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview Consolidate deferred public-URL health warnings for guided install UX.
+ */
+
+'use strict';
+
+const logger = require('../utils/logger');
+const { formatWarningLine } = require('../utils/cli-test-layout-chalk');
+
+/**
+ * @param {string} message
+ * @returns {{ kind: 'dns'|'localhost', url: string }|null}
+ */
+function extractPublicUrlFromWarning(message) {
+  const text = String(message || '');
+  const dnsMatch = text.match(/Public URL was not verified \(DNS\):\s*(\S+)/);
+  if (dnsMatch) {
+    return { kind: 'dns', url: dnsMatch[1].replace(/\.$/, '') };
+  }
+  const match = text.match(/Public URL was not verified:\s*(\S+)/);
+  if (match) {
+    return { kind: 'localhost', url: match[1].replace(/\.$/, '') };
+  }
+  return null;
+}
+
+/**
+ * Print one consolidated public-URL warning (avoid N near-duplicate lines).
+ * @param {string[]} messages
+ */
+function flushDeferredPublicUrlWarnings(messages) {
+  const list = (messages || []).filter(Boolean);
+  if (list.length === 0) {
+    return;
+  }
+  const parsed = list.map(extractPublicUrlFromWarning).filter(Boolean);
+  if (parsed.length === 0) {
+    for (const message of list) {
+      logger.log(formatWarningLine(message));
+    }
+    return;
+  }
+  const urls = [...new Set(parsed.map((row) => row.url))];
+  const hasDns = parsed.some((row) => row.kind === 'dns');
+  const urlPart = urls.length === 1 ? urls[0] : urls.join(', ');
+  const detail = hasDns
+    ? 'Hostname DNS and/or Traefik routing/TLS could not be verified; health succeeded via localhost only.'
+    : 'Health checks succeeded via localhost only. Validate Traefik routing, TLS, and DNS.';
+  logger.log(formatWarningLine(`Public URL was not verified: ${urlPart}. ${detail}`));
+}
+
+module.exports = {
+  extractPublicUrlFromWarning,
+  flushDeferredPublicUrlWarnings
+};