@pptb/types 1.2.3 → 1.2.4-beta.1

package/bin/pptb-validate.js

@@ -1,244 +1,2 @@
 #!/usr/bin/env node
-// @ts-check
-"use strict";
-
-/**
- * pptb-validate - CLI tool for validating Power Platform ToolBox tool packages
- *
- * Usage:
- *   pptb-validate [options] [path/to/package.json]
- *
- * Options:
- *   --skip-url-checks   Skip URL accessibility checks (faster, offline-friendly)
- *   --json              Output results as JSON
- *   --help, -h          Show help information
- */
-
-const fs = require("fs");
-const path = require("path");
-const { validatePackageJson, validatePPTBConfig, KNOWN_CAPABILITY_TAGS } = require("../lib/validate");
-
-// ANSI colour helpers – gracefully degrade when colours are unsupported
-const NO_COLOR = !process.stdout.isTTY || process.env.NO_COLOR;
-const c = {
-    red: (s) => (NO_COLOR ? s : `\x1b[31m${s}\x1b[0m`),
-    yellow: (s) => (NO_COLOR ? s : `\x1b[33m${s}\x1b[0m`),
-    green: (s) => (NO_COLOR ? s : `\x1b[32m${s}\x1b[0m`),
-    cyan: (s) => (NO_COLOR ? s : `\x1b[36m${s}\x1b[0m`),
-    bold: (s) => (NO_COLOR ? s : `\x1b[1m${s}\x1b[0m`),
-    dim: (s) => (NO_COLOR ? s : `\x1b[2m${s}\x1b[0m`),
-};
-
-function printHelp() {
-    console.log(`
-${c.bold("pptb-validate")} – Power Platform ToolBox tool validator
-
-${c.bold("USAGE")}
-  pptb-validate [options] [path/to/package.json]
-
-  When no path is given the tool looks for ${c.cyan("package.json")} in the current
-  working directory. If a ${c.cyan("pptb.config.json")} file exists in the same directory
-  it is automatically validated as well.
-
-${c.bold("OPTIONS")}
-  ${c.cyan("--skip-url-checks")}   Skip URL reachability checks (faster, works offline)
-  ${c.cyan("--json")}              Print results as a JSON object instead of human-readable text
-  ${c.cyan("--help")}, ${c.cyan("-h")}          Show this help message
-
-${c.bold("ADD TO YOUR TOOL'S package.json")}
-  ${c.dim(`"scripts": {
-    "validate": "pptb-validate"
-  }`)}
-
-  Then run: ${c.cyan("npm run validate")}
-
-${c.bold("EXAMPLES")}
-  npm run validate
-  npm run validate ./my-tool/package.json
-  npm run validate --skip-url-checks
-  npm run validate --json
-`);
-}
-
-async function main() {
-    const args = process.argv.slice(2);
-
-    if (args.includes("--help") || args.includes("-h")) {
-        printHelp();
-        process.exit(0);
-    }
-
-    const skipUrlChecks = args.includes("--skip-url-checks");
-    const jsonOutput = args.includes("--json");
-
-    // Find the package.json path from positional args (skip flags)
-    const positional = args.filter((a) => !a.startsWith("-"));
-    let packageJsonPath = positional[0] || path.join(process.cwd(), "package.json");
-
-    // Resolve to absolute path
-    if (!path.isAbsolute(packageJsonPath)) {
-        packageJsonPath = path.resolve(process.cwd(), packageJsonPath);
-    }
-
-    // Derive pptb.config.json path from the same directory as package.json
-    const toolDir = path.dirname(packageJsonPath);
-    const pptbConfigPath = path.join(toolDir, "pptb.config.json");
-
-    // --- Load package.json ---
-    if (!fs.existsSync(packageJsonPath)) {
-        if (jsonOutput) {
-            console.log(JSON.stringify({ valid: false, errors: [`package.json not found at: ${packageJsonPath}`], warnings: [] }, null, 2));
-        } else {
-            console.error(c.red(`✖ package.json not found at: ${packageJsonPath}`));
-        }
-        process.exit(1);
-    }
-
-    let packageJson;
-    try {
-        packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-    } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        if (jsonOutput) {
-            console.log(JSON.stringify({ valid: false, errors: [`Failed to parse package.json: ${message}`], warnings: [] }, null, 2));
-        } else {
-            console.error(c.red(`✖ Failed to parse package.json: ${message}`));
-        }
-        process.exit(1);
-    }
-
-    // --- Load pptb.config.json (optional) ---
-    let pptbConfig = null;
-    let pptbConfigParseError = null;
-    if (fs.existsSync(pptbConfigPath)) {
-        try {
-            pptbConfig = JSON.parse(fs.readFileSync(pptbConfigPath, "utf8"));
-        } catch (err) {
-            pptbConfigParseError = err instanceof Error ? err.message : String(err);
-        }
-    }
-
-    // --- Run validation ---
-    if (!jsonOutput) {
-        console.log();
-        console.log(c.bold("Power Platform ToolBox – Tool Validator"));
-        console.log(c.dim("─".repeat(45)));
-        console.log(c.dim(`File: ${packageJsonPath}`));
-        if (pptbConfig !== null) {
-            console.log(c.dim(`Config: ${pptbConfigPath}`));
-        }
-        if (skipUrlChecks) {
-            console.log(c.yellow("⚠  URL reachability checks are skipped"));
-        }
-        console.log();
-    }
-
-    let packageResult;
-    try {
-        packageResult = await validatePackageJson(packageJson, { skipUrlChecks });
-    } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        if (jsonOutput) {
-            console.log(JSON.stringify({ valid: false, errors: [`Unexpected validation error: ${message}`], warnings: [] }, null, 2));
-        } else {
-            console.error(c.red(`✖ Unexpected validation error: ${message}`));
-        }
-        process.exit(1);
-    }
-
-    // --- Validate pptb.config.json if present ---
-    let configResult = null;
-    if (pptbConfigParseError !== null) {
-        configResult = { valid: false, errors: [`Failed to parse pptb.config.json: ${pptbConfigParseError}`], warnings: [] };
-    } else if (pptbConfig !== null) {
-        configResult = validatePPTBConfig(pptbConfig);
-    }
-
-    // Merge results for overall pass/fail
-    const allErrors = [...packageResult.errors, ...(configResult ? configResult.errors : [])];
-    const allWarnings = [...packageResult.warnings, ...(configResult ? configResult.warnings : [])];
-    const overallValid = packageResult.valid && (configResult === null || configResult.valid);
-
-    // --- Output results ---
-    if (jsonOutput) {
-        const output = {
-            valid: overallValid,
-            errors: allErrors,
-            warnings: allWarnings,
-            packageInfo: packageResult.packageInfo,
-            configInfo: configResult ? configResult.packageInfo : undefined,
-        };
-        console.log(JSON.stringify(output, null, 2));
-        process.exit(overallValid ? 0 : 1);
-    }
-
-    // Human-readable output – package.json section
-    if (packageResult.errors.length > 0) {
-        console.log(c.bold(c.red(`package.json Errors (${packageResult.errors.length})`)));
-        packageResult.errors.forEach((e) => console.log(`  ${c.red("✖")} ${e}`));
-        console.log();
-    }
-
-    if (packageResult.warnings.length > 0) {
-        console.log(c.bold(c.yellow(`package.json Warnings (${packageResult.warnings.length})`)));
-        packageResult.warnings.forEach((w) => console.log(`  ${c.yellow("⚠")} ${w}`));
-        console.log();
-    }
-
-    // Human-readable output – pptb.config.json section
-    if (configResult !== null) {
-        if (configResult.errors.length > 0) {
-            console.log(c.bold(c.red(`pptb.config.json Errors (${configResult.errors.length})`)));
-            configResult.errors.forEach((e) => console.log(`  ${c.red("✖")} ${e}`));
-            console.log();
-        }
-
-        if (configResult.warnings.length > 0) {
-            console.log(c.bold(c.yellow(`pptb.config.json Warnings (${configResult.warnings.length})`)));
-            configResult.warnings.forEach((w) => console.log(`  ${c.yellow("⚠")} ${w}`));
-            console.log();
-        }
-    }
-
-    if (overallValid) {
-        const info = packageResult.packageInfo;
-        console.log(c.green(c.bold("✔ Validation passed")));
-        console.log();
-        console.log(c.bold("Package summary"));
-        console.log(c.dim("─".repeat(45)));
-        console.log(`  Name        : ${info.name}`);
-        console.log(`  Version     : ${info.version}`);
-        console.log(`  Display name: ${info.displayName}`);
-        console.log(`  Description : ${info.description}`);
-        console.log(`  License     : ${info.license}`);
-        console.log(`  Contributors: ${info.contributors.map((contributor) => contributor.name).join(", ")}`);
-        if (info.icon) {
-            console.log(`  Icon        : ${info.icon}`);
-        }
-        if (info.features) {
-            console.log(`  Features    : multiConnection=${info.features.multiConnection}${info.features.minAPI ? `, minAPI=${info.features.minAPI}` : ""}`);
-        }
-        if (configResult !== null && configResult.packageInfo && configResult.packageInfo.invocation) {
-            const inv = configResult.packageInfo.invocation;
-            console.log(`  Invocation  : version=${inv.version}`);
-            if (Array.isArray(inv.capabilities) && inv.capabilities.length > 0) {
-                console.log(`  Capabilities: ${inv.capabilities.join(", ")}`);
-            }
-        }
-        console.log();
-        console.log(c.dim(`Known capability tags: ${KNOWN_CAPABILITY_TAGS.join(", ")}`));
-        console.log();
-    } else {
-        console.log(c.red(c.bold("✖ Validation failed")));
-        console.log();
-        console.log(c.dim("Fix the errors listed above and re-run pptb-validate before publishing."));
-        console.log();
-    }
-
-    process.exit(overallValid ? 0 : 1);
-}
-
-main().catch((err) => {
-    console.error(c.red(`✖ Fatal error: ${err instanceof Error ? err.message : String(err)}`));
-    process.exit(1);
-});
+require("@pptb/validate/cli");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pptb/types",
-  "version": "1.2.3",
+  "version": "1.2.4-beta.1",
   "description": "Type definitions for Power Platform ToolBox APIs and validity checks for tool packages",
   "main": "index.d.ts",
   "types": "index.d.ts",
@@ -22,6 +22,9 @@
   "bin": {
     "pptb-validate": "./bin/pptb-validate.js"
   },
+  "dependencies": {
+    "@pptb/validate": "^0.0.1"
+  },
   "files": [
     "index.d.ts",
     "toolboxAPI.d.ts",

package/lib/validate.js

@@ -1,486 +0,0 @@
-// @ts-check
-"use strict";
-
-/**
- * Tool validation logic for Power Platform ToolBox tools.
- * Mirrors the validation rules used during the official review process.
- */
-
-/** @typedef {{ name: string; url?: string }} Contributor */
-/** @typedef {{ "connect-src"?: string[]; "script-src"?: string[]; "style-src"?: string[]; "img-src"?: string[]; "font-src"?: string[]; "frame-src"?: string[]; "media-src"?: string[] }} CspExceptions */
-/** @typedef {{ repository?: string; website?: string; funding?: string; readmeUrl?: string }} Configurations */
-/** @typedef {{ multiConnection?: "required" | "optional" | "none"; minAPI?: string }} Features */
-/**
- * @typedef {{
- *   name: string;
- *   version: string;
- *   displayName?: string;
- *   description?: string;
- *   contributors?: Contributor[];
- *   cspExceptions?: CspExceptions;
- *   license?: string;
- *   icon?: string;
- *   configurations?: Configurations;
- *   features?: Features;
- * }} ToolPackageJson
- */
-/**
- * @typedef {{
- *   valid: boolean;
- *   errors: string[];
- *   warnings: string[];
- *   packageInfo?: object;
- * }} ValidationResult
- */
-
-/**
- * @typedef {{ type?: string; enum?: string[]; items?: object }} JsonSchemaProperty
- * @typedef {{ properties?: Record<string, JsonSchemaProperty> }} JsonSchemaObject
- * @typedef {{
- *   version: string;
- *   prefill?: JsonSchemaObject;
- *   returnTopic?: JsonSchemaObject;
- * }} InvocationConfig
- * @typedef {{
- *   invocation?: InvocationConfig;
- * }} PPTBConfig
- */
-
-// List of approved open source licenses
-const APPROVED_LICENSES = ["MIT", "Apache-2.0", "BSD-2-Clause", "BSD-3-Clause", "GPL-2.0", "GPL-3.0", "LGPL-3.0", "ISC", "AGPL-3.0-only"];
-
-// Valid multiConnection values
-const VALID_MULTI_CONNECTION_VALUES = ["required", "optional", "none"];
-
-// Semver regex for minAPI validation
-const SEMVER_REGEX = /^\d+\.\d+\.\d+(-[0-9a-zA-Z-]+(\.[0-9a-zA-Z-]+)*)?(\+[0-9a-zA-Z-]+(\.[0-9a-zA-Z-]+)*)?$/;
-
-/**
- * Built-in list of well-known capability tags.
- * Mirrors the entries in the Supabase `capability_tags` table.
- * New tags are added to Supabase first (configurable without a deploy) and are
- * then reflected here in the next package release so offline validation stays current.
- *
- * When a tool declares a tag that is not in this list the validator emits a warning
- * (not an error) so existing tools are not broken by registry updates.
- *
- * **Keep in sync with `BUILT_IN_CAPABILITY_TAGS` in
- * `src/main/managers/toolRegistryManager.ts`.**  Because this file is a standalone
- * Node.js module that cannot import from the Electron/TypeScript source tree, both
- * lists must be updated together whenever a new tag is added.
- */
-const KNOWN_CAPABILITY_TAGS = [
-    "fetchxml",
-    "entity-picker",
-    "record-selector",
-    "solution-selector",
-    "webresource-editor",
-    "plugin-inspector",
-    "pcf-control-builder",
-];
-
-/**
- * Checks if a string is a valid URL.
- * @param {string} url
- * @returns {boolean}
- */
-function isValidUrl(url) {
-    try {
-        new URL(url);
-        return true;
-    } catch {
-        return false;
-    }
-}
-
-/**
- * Checks if a URL hostname is a GitHub domain.
- * @param {string} url
- * @returns {boolean}
- */
-function isGithubDomain(url) {
-    try {
-        const hostname = new URL(url).hostname.toLowerCase();
-        return hostname === "github.com" || hostname.endsWith(".github.com");
-    } catch {
-        return false;
-    }
-}
-
-/**
- * Validates an icon path string.
- * @param {string} fieldName
- * @param {string} iconPath
- * @param {string[]} errors
- */
-function validateIconPath(fieldName, iconPath, errors) {
-    if (iconPath.startsWith("http://") || iconPath.startsWith("https://")) {
-        errors.push(`${fieldName} cannot be an HTTP(S) URL - icons must be bundled under dist`);
-        return;
-    }
-    if (iconPath.startsWith("/")) {
-        errors.push(`${fieldName} must be a relative path (e.g., 'icon.svg' or 'icons/icon.svg')`);
-        return;
-    }
-    // Reject Windows absolute paths like "C:\..." or "C:/"
-    if (/^[a-zA-Z]:/.test(iconPath)) {
-        errors.push(`${fieldName} must be a relative path (e.g., 'icon.svg' or 'icons/icon.svg')`);
-        return;
-    }
-    // Reject backslashes — icon paths must use forward slashes
-    if (iconPath.includes("\\")) {
-        errors.push(`${fieldName} must use forward slashes, not backslashes (e.g., 'icons/icon.svg')`);
-        return;
-    }
-    if (iconPath.includes("..")) {
-        errors.push(`${fieldName} cannot contain '..' (path traversal not allowed)`);
-        return;
-    }
-    if (!iconPath.toLowerCase().endsWith(".svg")) {
-        errors.push(`${fieldName} must be an SVG file with .svg extension`);
-    }
-}
-
-/**
- * Checks if a URL is accessible by making a HEAD request.
- * @param {string} url
- * @returns {Promise<boolean>}
- */
-async function isUrlAccessible(url) {
-    try {
-        const response = await fetch(url, { method: "HEAD", redirect: "follow" });
-        return response.ok;
-    } catch {
-        return false;
-    }
-}
-
-/**
- * Validates a tool's package.json against the official review criteria.
- *
- * @param {ToolPackageJson} packageJson - The parsed package.json object.
- * @param {{ skipUrlChecks?: boolean }} [options] - Validation options.
- * @returns {Promise<ValidationResult>}
- */
-async function validatePackageJson(packageJson, options = {}) {
-    const { skipUrlChecks = false } = options;
-    const errors = /** @type {string[]} */ ([]);
-    const warnings = /** @type {string[]} */ ([]);
-
-    // Required fields
-    if (!packageJson.name || typeof packageJson.name !== "string") {
-        errors.push("Package name is required and must be a string");
-    }
-
-    if (!packageJson.version || typeof packageJson.version !== "string") {
-        errors.push("Package version is required and must be a string");
-    }
-
-    if (!packageJson.displayName || typeof packageJson.displayName !== "string") {
-        errors.push("displayName is required and must be a string");
-    }
-
-    if (!packageJson.description || typeof packageJson.description !== "string") {
-        errors.push("description is required and must be a string");
-    }
-
-    // License validation
-    if (!packageJson.license) {
-        errors.push("license is required");
-    } else if (!APPROVED_LICENSES.includes(packageJson.license)) {
-        errors.push(`License "${packageJson.license}" is not in the approved list. Approved licenses: ${APPROVED_LICENSES.join(", ")}`);
-    }
-
-    // Icon validation (optional, but must be a relative SVG path if provided)
-    if (packageJson.icon === undefined || packageJson.icon === null) {
-        warnings.push("icon is not set; consider adding a bundled SVG icon so your tool displays properly in the marketplace");
-    } else if (typeof packageJson.icon !== "string") {
-        errors.push("icon must be a string (relative path to bundled SVG under dist)");
-    } else {
-        validateIconPath("icon", packageJson.icon, errors);
-    }
-
-    // Contributors validation
-    if (!packageJson.contributors || !Array.isArray(packageJson.contributors)) {
-        errors.push("contributors is required and must be an array");
-    } else if (packageJson.contributors.length === 0) {
-        errors.push("At least one contributor is required");
-    } else {
-        packageJson.contributors.forEach((contributor, index) => {
-            if (!contributor.name || typeof contributor.name !== "string") {
-                errors.push(`Contributor at index ${index} must have a name`);
-            }
-            if (contributor.url && !isValidUrl(contributor.url)) {
-                warnings.push(`Contributor "${contributor.name}" has an invalid URL`);
-            }
-        });
-    }
-
-    // Configurations validation
-    if (!packageJson.configurations || typeof packageJson.configurations !== "object") {
-        errors.push("configurations is required and must include repository and readmeUrl");
-    } else {
-        const configs = packageJson.configurations;
-
-        // configurations.iconUrl is no longer supported
-        if (/** @type {Record<string, unknown>} */ (configs).iconUrl !== undefined) {
-            errors.push("configurations.iconUrl is no longer supported; use top-level 'icon' for bundled SVG path");
-        }
-
-        // Repository validation
-        if (!configs.repository || typeof configs.repository !== "string") {
-            errors.push("configurations.repository is required and must be a URL");
-        } else if (!isValidUrl(configs.repository)) {
-            errors.push("configurations.repository has an invalid URL format");
-        } else if (!skipUrlChecks) {
-            const accessible = await isUrlAccessible(configs.repository);
-            if (!accessible) {
-                errors.push("configurations.repository URL is not accessible");
-            }
-        }
-
-        // Website validation (optional but recommended)
-        if (!configs.website) {
-            warnings.push("configurations.website is not set; consider adding a URL where users can learn more about your tool");
-        } else if (!isValidUrl(configs.website)) {
-            warnings.push("configurations.website has an invalid URL format");
-        } else if (!skipUrlChecks) {
-            const accessible = await isUrlAccessible(configs.website);
-            if (!accessible) {
-                warnings.push("configurations.website URL is not accessible");
-            }
-        }
-
-        // Funding validation (optional but recommended)
-        if (configs.funding) {
-            if (!isValidUrl(configs.funding)) {
-                warnings.push("configurations.funding has an invalid URL format");
-            } else if (!skipUrlChecks) {
-                const accessible = await isUrlAccessible(configs.funding);
-                if (!accessible) {
-                    warnings.push("configurations.funding URL is not accessible");
-                }
-            }
-        }
-
-        // ReadmeUrl validation
-        if (!configs.readmeUrl || typeof configs.readmeUrl !== "string") {
-            errors.push("configurations.readmeUrl is required and must be a URL");
-        } else if (!isValidUrl(configs.readmeUrl)) {
-            errors.push("configurations.readmeUrl has an invalid URL format");
-        } else if (isGithubDomain(configs.readmeUrl)) {
-            errors.push("configurations.readmeUrl cannot be hosted on github.com; use raw.githubusercontent.com or another domain");
-        } else if (!skipUrlChecks) {
-            const accessible = await isUrlAccessible(configs.readmeUrl);
-            if (!accessible) {
-                errors.push("configurations.readmeUrl is not accessible");
-            }
-        }
-    }
-
-    // CSP Exceptions validation (optional, but validated if present)
-    if (packageJson.cspExceptions) {
-        const cspExceptions = packageJson.cspExceptions;
-
-        if (typeof cspExceptions !== "object" || cspExceptions === null || Array.isArray(cspExceptions)) {
-            errors.push("cspExceptions must be an object mapping CSP directives to arrays of strings");
-        } else {
-            const validCspDirectives = ["connect-src", "script-src", "style-src", "img-src", "font-src", "frame-src", "media-src"];
-
-            const hasAnyDirectives = Object.keys(cspExceptions).length > 0;
-            if (!hasAnyDirectives) {
-                errors.push("cspExceptions cannot be empty. If CSP exceptions are not needed, remove the cspExceptions field");
-            }
-
-            Object.keys(cspExceptions).forEach((directive) => {
-                if (!validCspDirectives.includes(directive)) {
-                    warnings.push(`Unknown CSP directive: ${directive}`);
-                }
-                const values = cspExceptions[/** @type {keyof CspExceptions} */ (directive)];
-                if (values && !Array.isArray(values)) {
-                    errors.push(`CSP directive "${directive}" must be an array of strings`);
-                } else if (values && values.length === 0) {
-                    errors.push(`CSP directive "${directive}" cannot be an empty array`);
-                }
-            });
-        }
-    }
-
-    // Features validation (optional, but validated if present)
-    if (packageJson.features !== undefined) {
-        const features = packageJson.features;
-
-        if (features === null || typeof features !== "object" || Array.isArray(features)) {
-            errors.push("features must be a non-array object with optional 'multiConnection' and 'minAPI' properties");
-        } else {
-            const VALID_FEATURE_KEYS = ["multiConnection", "minAPI"];
-            const featureKeys = Object.keys(features);
-            const invalidKeys = featureKeys.filter((key) => !VALID_FEATURE_KEYS.includes(key));
-
-            if (invalidKeys.length > 0) {
-                errors.push(`features can only contain ${VALID_FEATURE_KEYS.map((k) => `'${k}'`).join(", ")} properties. Invalid properties: ${invalidKeys.join(", ")}`);
-            }
-
-            if (features.multiConnection === undefined) {
-                errors.push("features.multiConnection is required when features object is provided");
-            } else if (!VALID_MULTI_CONNECTION_VALUES.includes(features.multiConnection)) {
-                errors.push(`features.multiConnection must be one of: ${VALID_MULTI_CONNECTION_VALUES.join(", ")}`);
-            }
-
-            if (features.minAPI !== undefined) {
-                if (typeof features.minAPI !== "string" || !SEMVER_REGEX.test(features.minAPI)) {
-                    errors.push("features.minAPI must be a valid semantic version string (e.g., '1.0.0')");
-                }
-            }
-        }
-    }
-
-    const valid = errors.length === 0;
-
-    return {
-        valid,
-        errors,
-        warnings,
-        packageInfo: valid
-            ? {
-                  name: packageJson.name,
-                  version: packageJson.version,
-                  displayName: packageJson.displayName,
-                  description: packageJson.description,
-                  license: packageJson.license,
-                  contributors: packageJson.contributors,
-                  cspExceptions: packageJson.cspExceptions,
-                  icon: packageJson.icon,
-                  configurations: packageJson.configurations,
-                  features: packageJson.features,
-              }
-            : undefined,
-    };
-}
-
-module.exports = { validatePackageJson, validatePPTBConfig, isValidUrl, APPROVED_LICENSES, KNOWN_CAPABILITY_TAGS };
-
-/**
- * Validates a tool's pptb.config.json against the official review criteria.
- *
- * @param {PPTBConfig} config - The parsed pptb.config.json object.
- * @returns {ValidationResult}
- */
-function validatePPTBConfig(config) {
-    const errors = /** @type {string[]} */ ([]);
-    const warnings = /** @type {string[]} */ ([]);
-
-    if (config === null || typeof config !== "object" || Array.isArray(config)) {
-        errors.push("pptb.config.json must be a JSON object");
-        return { valid: false, errors, warnings };
-    }
-
-    const VALID_ROOT_KEYS = ["invocation"];
-    const unknownRootKeys = Object.keys(config).filter((k) => !VALID_ROOT_KEYS.includes(k));
-    if (unknownRootKeys.length > 0) {
-        warnings.push(`pptb.config.json contains unrecognised root keys: ${unknownRootKeys.join(", ")}`);
-    }
-
-    // Invocation section
-    if (config.invocation !== undefined) {
-        const inv = config.invocation;
-
-        if (inv === null || typeof inv !== "object" || Array.isArray(inv)) {
-            errors.push("invocation must be a non-array object");
-        } else {
-            // invocation.version – required, must be a valid semver string
-            if (inv.version === undefined || inv.version === null) {
-                errors.push("invocation.version is required");
-            } else if (typeof inv.version !== "string") {
-                errors.push("invocation.version must be a string");
-            } else if (!SEMVER_REGEX.test(inv.version)) {
-                errors.push(`invocation.version "${inv.version}" is not a valid semantic version string (e.g. "1.0.0")`);
-            }
-
-            // invocation.prefill – optional JSON-schema-like object
-            if (inv.prefill !== undefined) {
-                if (inv.prefill === null || typeof inv.prefill !== "object" || Array.isArray(inv.prefill)) {
-                    errors.push("invocation.prefill must be a non-array object");
-                } else if (inv.prefill.properties !== undefined) {
-                    validateJsonSchemaProperties("invocation.prefill", inv.prefill.properties, errors);
-                }
-            }
-
-            // invocation.returnTopic – optional JSON-schema-like object
-            if (inv.returnTopic !== undefined) {
-                if (inv.returnTopic === null || typeof inv.returnTopic !== "object" || Array.isArray(inv.returnTopic)) {
-                    errors.push("invocation.returnTopic must be a non-array object");
-                } else if (inv.returnTopic.properties !== undefined) {
-                    validateJsonSchemaProperties("invocation.returnTopic", inv.returnTopic.properties, errors);
-                }
-            }
-
-            // invocation.capabilities – optional array of non-empty strings
-            if (inv.capabilities !== undefined) {
-                if (!Array.isArray(inv.capabilities)) {
-                    errors.push("invocation.capabilities must be an array");
-                } else {
-                    inv.capabilities.forEach((cap, idx) => {
-                        if (typeof cap !== "string" || cap.trim().length === 0) {
-                            errors.push(`invocation.capabilities[${idx}] must be a non-empty string`);
-                        } else if (!KNOWN_CAPABILITY_TAGS.includes(cap.trim())) {
-                            warnings.push(
-                                `invocation.capabilities[${idx}] "${cap}" is not a recognised capability tag. ` +
-                                    `Known tags: ${KNOWN_CAPABILITY_TAGS.join(", ")}. ` +
-                                    "If this is a new tag, ensure it has been added to the capability registry.",
-                            );
-                        }
-                    });
-                }
-            }
-        }
-    }
-
-    const valid = errors.length === 0;
-
-    return {
-        valid,
-        errors,
-        warnings,
-        packageInfo: valid
-            ? {
-                  invocation: config.invocation,
-              }
-            : undefined,
-    };
-}
-
-/**
- * Validates a JSON-schema-style `properties` map used inside invocation sections.
- * Only performs basic structural validation; full JSON Schema validation is not required.
- *
- * @param {string} fieldName
- * @param {unknown} properties
- * @param {string[]} errors
- */
-function validateJsonSchemaProperties(fieldName, properties, errors) {
-    if (properties === null || typeof properties !== "object" || Array.isArray(properties)) {
-        errors.push(`${fieldName}.properties must be a non-array object`);
-        return;
-    }
-
-    const propsRecord = /** @type {Record<string, unknown>} */ (properties);
-
-    for (const [key, value] of Object.entries(propsRecord)) {
-        if (value === null || typeof value !== "object" || Array.isArray(value)) {
-            errors.push(`${fieldName}.properties.${key} must be an object`);
-            continue;
-        }
-        const prop = /** @type {Record<string, unknown>} */ (value);
-        if (prop.type !== undefined && typeof prop.type !== "string") {
-            errors.push(`${fieldName}.properties.${key}.type must be a string`);
-        }
-        if (prop.enum !== undefined) {
-            if (!Array.isArray(prop.enum)) {
-                errors.push(`${fieldName}.properties.${key}.enum must be an array`);
-            } else if (prop.enum.length === 0) {
-                errors.push(`${fieldName}.properties.${key}.enum must not be empty`);
-            }
-        }
-    }
-}