@asyncapi-actions-test/trusted-publishing-test_asyncapi-cli 4.1.3

package/lib/apps/api/exceptions/problem.exception.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProblemException = void 0;
+const problem_1 = require("@asyncapi/problem");
+const typePrefix = 'https://api.asyncapi.com/problem';
+class ProblemException extends (0, problem_1.ProblemMixin)({
+    typePrefix,
+}) {
+}
+exports.ProblemException = ProblemException;

package/lib/apps/api/index.d.ts

@@ -0,0 +1,10 @@
+import { ValidateController } from './controllers/validate.controller';
+import { ParseController } from './controllers/parse.controller';
+import { GenerateController } from './controllers/generate.controller';
+import { ConvertController } from './controllers/convert.controller';
+import { BundleController } from './controllers/bundle.controller';
+import { DiffController } from './controllers/diff.controller';
+import { DocsController } from './controllers/docs.controller';
+import { HelpController } from './controllers/help.controller';
+import { VersionController } from './controllers/version.controller';
+export declare const CONTROLLERS: (ValidateController | ParseController | GenerateController | ConvertController | BundleController | DiffController | DocsController | HelpController | VersionController)[];

package/lib/apps/api/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTROLLERS = void 0;
+const validate_controller_1 = require("./controllers/validate.controller");
+const parse_controller_1 = require("./controllers/parse.controller");
+const generate_controller_1 = require("./controllers/generate.controller");
+const convert_controller_1 = require("./controllers/convert.controller");
+const bundle_controller_1 = require("./controllers/bundle.controller");
+const diff_controller_1 = require("./controllers/diff.controller");
+const docs_controller_1 = require("./controllers/docs.controller");
+const help_controller_1 = require("./controllers/help.controller");
+const version_controller_1 = require("./controllers/version.controller");
+exports.CONTROLLERS = [
+    new validate_controller_1.ValidateController(),
+    new parse_controller_1.ParseController(),
+    new generate_controller_1.GenerateController(),
+    new convert_controller_1.ConvertController(),
+    new bundle_controller_1.BundleController(),
+    new diff_controller_1.DiffController(),
+    new docs_controller_1.DocsController(),
+    new help_controller_1.HelpController(),
+    new version_controller_1.VersionController(),
+];

package/lib/apps/api/middlewares/logger.middleware.d.ts

@@ -0,0 +1,2 @@
+import { NextFunction, Request, Response } from 'express';
+export declare function loggerMiddleware(req: Request, res: Response, next: NextFunction): void;

package/lib/apps/api/middlewares/logger.middleware.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loggerMiddleware = loggerMiddleware;
+const logger_1 = require("../../../utils/logger");
+function loggerMiddleware(req, res, next) {
+    const start = Date.now();
+    res.on('finish', () => {
+        const duration = Date.now() - start;
+        logger_1.logger.info(`[${req.method}] ${req.originalUrl} ${res.statusCode} - ${duration}ms`);
+    });
+    next();
+}

package/lib/apps/api/middlewares/problem.middleware.d.ts

@@ -0,0 +1,6 @@
+import { NextFunction, Request, Response } from 'express';
+import { ProblemException } from '../exceptions/problem.exception';
+/**
+ * Catch problem exception, log it and serialize error to human readable form.
+ */
+export declare function problemMiddleware(error: ProblemException, req: Request, res: Response, next: NextFunction): void;

package/lib/apps/api/middlewares/problem.middleware.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.problemMiddleware = problemMiddleware;
+const logger_1 = require("../../../utils/logger");
+/**
+ * Catch problem exception, log it and serialize error to human readable form.
+ */
+function problemMiddleware(error, req, res, next) {
+    if (res.headersSent) {
+        return next(error);
+    }
+    try {
+        const problemShape = error.get();
+        const status = (problemShape.status = problemShape.status || 500);
+        problemShape.title = problemShape.title || 'Internal server error';
+        logger_1.logger.error(`[${req.method}] ${req.path} >> Status:: ${status}, Type:: ${problemShape.type.replace('https://api.asyncapi.com/problem/', '')}, Title:: ${problemShape.title}, Detail:: ${problemShape.detail}`);
+        const isError = status >= 500;
+        const problem = error.toObject({
+            includeStack: isError,
+            includeCause: isError,
+        });
+        res.status(status).json(problem);
+    }
+    catch (err) {
+        next(err);
+    }
+}

package/lib/apps/api/middlewares/validation.middleware.d.ts

@@ -0,0 +1,12 @@
+import { Request, Response, NextFunction } from 'express';
+export interface ValidationMiddlewareOptions {
+    path: string;
+    method: 'all' | 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head';
+    documents?: Array<string>;
+    version?: 'v1';
+    condition?: (req: Request) => boolean;
+}
+/**
+ * Validate RequestBody and sent AsyncAPI document(s) for given path and method based on the OpenAPI Document.
+ */
+export declare function validationMiddleware(options: ValidationMiddlewareOptions): Promise<(req: Request, res: Response, next: NextFunction) => Promise<void>>;

package/lib/apps/api/middlewares/validation.middleware.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validationMiddleware = validationMiddleware;
+const tslib_1 = require("tslib");
+const problem_exception_1 = require("../exceptions/problem.exception");
+const ajv_1 = require("../../../utils/ajv");
+const app_openapi_1 = require("../../../utils/app-openapi");
+const validation_service_1 = require("../../../domains/services/validation.service");
+const SpecificationFile_1 = require("../../../domains/models/SpecificationFile");
+const ajvInstance = (0, ajv_1.createAjvInstance)();
+/**
+ * Create AJV's validator function for given path in the OpenAPI document.
+ */
+function compileAjv(options) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const appOpenAPI = yield (0, app_openapi_1.getAppOpenAPI)();
+        const paths = appOpenAPI.paths || {};
+        const pathName = options.path;
+        const path = paths[String(pathName)];
+        if (!path) {
+            throw new Error(`Path "${pathName}" doesn't exist in the OpenAPI document.`);
+        }
+        const methodName = options.method;
+        const method = path[String(methodName)];
+        if (!method) {
+            throw new Error(`Method "${methodName}" for "${pathName}" path doesn't exist in the OpenAPI document.`);
+        }
+        const requestBody = method.requestBody;
+        if (!requestBody) {
+            return;
+        }
+        let schema = requestBody.content['application/json'].schema;
+        if (!schema) {
+            return;
+        }
+        schema = Object.assign({}, schema);
+        schema['$schema'] = 'http://json-schema.org/draft-07/schema';
+        if (options.documents && schema.properties) {
+            schema.properties = Object.assign({}, schema.properties);
+            for (const field of options.documents) {
+                if (schema.properties[String(field)].items) {
+                    schema.properties[String(field)] = Object.assign({}, schema.properties[String(field)]);
+                    schema.properties[String(field)].items = true;
+                }
+                else {
+                    schema.properties[String(field)] = true;
+                }
+            }
+        }
+        return ajvInstance.compile(schema);
+    });
+}
+function validateRequestBody(validate, body) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const valid = validate(body);
+        const errors = validate.errors && [...validate.errors];
+        if (valid === false) {
+            throw new problem_exception_1.ProblemException({
+                type: 'invalid-request-body',
+                title: 'Invalid Request Body',
+                status: 422,
+                validationErrors: errors,
+            });
+        }
+    });
+}
+function validateSingleDocument(asyncapi, path, validationService) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (typeof asyncapi === 'object') {
+            asyncapi = JSON.stringify(asyncapi);
+        }
+        const specFile = new SpecificationFile_1.Specification(asyncapi, { fileURL: path });
+        return validationService
+            .validateDocument(specFile, {
+            'fail-severity': 'error',
+            suppressAllWarnings: false,
+        })
+            .then((result) => {
+            var _a, _b;
+            if (!result.success || ((_a = result.data) === null || _a === void 0 ? void 0 : _a.status) !== 'valid') {
+                throw new problem_exception_1.ProblemException({
+                    type: 'invalid-asyncapi-document',
+                    title: 'Invalid AsyncAPI Document',
+                    status: 422,
+                    detail: result.error || 'The provided AsyncAPI document is invalid.',
+                    diagnostics: result.diagnostics || ((_b = result.data) === null || _b === void 0 ? void 0 : _b.diagnostics),
+                });
+            }
+            return result.data;
+        });
+    });
+}
+function validateListDocuments(asyncapis, path, validationService) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const validationResults = [];
+        for (const asyncapi of asyncapis) {
+            const parsed = yield validateSingleDocument(asyncapi, path, validationService);
+            if (parsed) {
+                validationResults.push(parsed);
+            }
+            else {
+                throw new problem_exception_1.ProblemException({
+                    type: 'invalid-asyncapi-document',
+                    title: 'Invalid AsyncAPI Document',
+                    status: 422,
+                    detail: 'One or more provided AsyncAPI documents are invalid.',
+                });
+            }
+        }
+        return validationResults;
+    });
+}
+/**
+ * Validate RequestBody and sent AsyncAPI document(s) for given path and method based on the OpenAPI Document.
+ */
+function validationMiddleware(options) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        options.version = options.version || 'v1';
+        const validate = yield compileAjv(options);
+        const documents = options.documents || [];
+        return (req, res, next) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // Check if the condition is met
+            if (options.condition && !options.condition(req)) {
+                return next();
+            }
+            try {
+                if (!validate) {
+                    throw new problem_exception_1.ProblemException({
+                        type: 'invalid-request-body',
+                        title: 'Invalid Request Body',
+                        status: 422,
+                        detail: `Request body validation is not supported for "${options.path}" path with "${options.method}" method.`,
+                    });
+                }
+                yield validateRequestBody(validate, req.body);
+            }
+            catch (error) {
+                if (error instanceof problem_exception_1.ProblemException) {
+                    return next(error);
+                }
+                // Handle unexpected errors
+                return next(new problem_exception_1.ProblemException({
+                    type: 'internal-server-error',
+                    title: 'Internal Server Error',
+                    status: 500,
+                    detail: `An unexpected error occurred during request validation: ${(_a = error.message) !== null && _a !== void 0 ? _a : 'Unknown error'}`,
+                }));
+            }
+            const parserConfig = {
+                __unstable: {
+                    resolver: {
+                        resolvers: [
+                        // @TODO: Add Cookie Based Resolvers after migration and understanding some
+                        // details about how to use them in the new parser-js version.
+                        ],
+                    },
+                },
+            };
+            const validationService = new validation_service_1.ValidationService(parserConfig);
+            const resolveURL = req.header('x-asyncapi-resolve-url') ||
+                req.header('referer') ||
+                req.header('origin') ||
+                '';
+            try {
+                req.asyncapi = req.asyncapi || {};
+                for (const field of documents) {
+                    const body = req.body[String(field)];
+                    if (Array.isArray(body)) {
+                        const results = yield validateListDocuments(body, resolveURL, validationService);
+                        const parsedDocuments = results.map((result) => result.document);
+                        if (!parsedDocuments.every(doc => doc !== undefined)) {
+                            throw new problem_exception_1.ProblemException({
+                                type: 'invalid-asyncapi-document-parse',
+                                title: 'Invalid AsyncAPI Document (Parse Error)',
+                                status: 422,
+                                detail: 'One or more provided AsyncAPI documents are invalid.',
+                                diagnostics: results.flatMap(result => result.diagnostics || []),
+                            });
+                        }
+                        req.asyncapi.parsedDocuments = parsedDocuments;
+                        req.asyncapi.validationResults = results;
+                    }
+                    else {
+                        const result = yield validateSingleDocument(body, resolveURL, validationService);
+                        req.asyncapi.parsedDocument = result === null || result === void 0 ? void 0 : result.document;
+                        req.asyncapi.validationResult = result;
+                    }
+                }
+                next();
+            }
+            catch (err) {
+                return next(err);
+            }
+        });
+    });
+}
+const TYPES_400 = [
+    'null-or-falsey-document',
+    'impossible-to-convert-to-json',
+    'invalid-document-type',
+    'invalid-json',
+    'invalid-yaml',
+];
+/**
+ * Some error types have to be treated as 400 HTTP Status Code, another as 422.
+ */
+function retrieveStatusCode(type) {
+    if (TYPES_400.includes(type)) {
+        return 400;
+    }
+    return 422;
+}
+/**
+ * Merges fields from ParserError to ProblemException.
+ */
+function mergeParserError(error, parserError) {
+    if (parserError.detail) {
+        error.set('detail', parserError.detail);
+    }
+    if (parserError.validationErrors) {
+        error.set('validationErrors', parserError.validationErrors);
+    }
+    if (parserError.parsedJSON) {
+        error.set('parsedJSON', parserError.parsedJSON);
+    }
+    if (parserError.location) {
+        error.set('location', parserError.location);
+    }
+    if (parserError.refs) {
+        error.set('refs', parserError.refs);
+    }
+    return error;
+}
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function tryConvertToProblemException(err) {
+    const typeName = err.type.replace('https://github.com/asyncapi/parser-js/', '');
+    const error = new problem_exception_1.ProblemException({
+        type: typeName,
+        title: err.title,
+        status: retrieveStatusCode(typeName),
+    });
+    mergeParserError(error, err);
+    return error;
+}

package/lib/apps/api/server.d.ts

@@ -0,0 +1,3 @@
+import './configs/production.json';
+import './configs/development.json';
+import './configs/test.json';

package/lib/apps/api/server.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+// include configs in the `dist` folder
+require("./configs/production.json");
+require("./configs/development.json");
+require("./configs/test.json");
+// for `config` module
+process.env['NODE_CONFIG_DIR'] = `${__dirname}/configs`;
+const app_1 = require("./app");
+const _1 = require(".");
+function main() {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const app = new app_1.App(_1.CONTROLLERS);
+        yield app.init();
+        app.listen();
+    });
+}
+main();

package/lib/apps/cli/commands/bundle.d.ts

@@ -0,0 +1,15 @@
+import Command from '../internal/base';
+export default class Bundle extends Command {
+    static readonly description = "Bundle one or multiple AsyncAPI Documents and their references together.";
+    static strict: boolean;
+    static examples: string[];
+    static flags: {
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        base: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        baseDir: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        xOrigin: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private collectMetricsData;
+}

package/lib/apps/cli/commands/bundle.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const base_1 = tslib_1.__importDefault(require("../internal/base"));
+const bundler_1 = tslib_1.__importDefault(require("@asyncapi/bundler"));
+const fs_1 = require("fs");
+const path_1 = tslib_1.__importDefault(require("path"));
+const SpecificationFile_1 = require("../../../domains/models/SpecificationFile");
+const bundle_flags_1 = require("../internal/flags/bundle.flags");
+const { writeFile } = fs_1.promises;
+class Bundle extends base_1.default {
+    run() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { argv, flags } = yield this.parse(Bundle);
+            const output = flags.output;
+            const outputFormat = path_1.default.extname(argv[0]);
+            const AsyncAPIFiles = argv;
+            this.metricsMetadata.files = AsyncAPIFiles.length;
+            const document = yield (0, bundler_1.default)(AsyncAPIFiles, {
+                base: flags.base,
+                baseDir: flags.baseDir,
+                xOrigin: flags.xOrigin,
+            });
+            yield this.collectMetricsData(document);
+            if (!output) {
+                if (outputFormat === '.yaml' || outputFormat === '.yml') {
+                    this.log(document.yml());
+                }
+                else {
+                    this.log(JSON.stringify(document.json()));
+                }
+            }
+            else {
+                const format = path_1.default.extname(output);
+                if (format === '.yml' || format === '.yaml') {
+                    yield writeFile(path_1.default.resolve(process.cwd(), output), document.yml() || '', {
+                        encoding: 'utf-8',
+                    });
+                }
+                if (format === '.json') {
+                    yield writeFile(path_1.default.resolve(process.cwd(), output), document.string() || '', {
+                        encoding: 'utf-8',
+                    });
+                }
+                this.log(`Check out your shiny new bundled files at ${output}`);
+            }
+        });
+    }
+    collectMetricsData(document) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                // We collect the metadata from the final output so it contains all the files
+                this.specFile = new SpecificationFile_1.Specification((_a = document.string()) !== null && _a !== void 0 ? _a : '');
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    this.log(`Skipping submitting anonymous metrics due to the following error: ${e.name}: ${e.message}`);
+                }
+            }
+        });
+    }
+}
+Bundle.description = 'Bundle one or multiple AsyncAPI Documents and their references together.';
+Bundle.strict = false;
+Bundle.examples = [
+    'asyncapi bundle ./asyncapi.yaml > final-asyncapi.yaml',
+    'asyncapi bundle ./asyncapi.yaml --output final-asyncapi.yaml',
+    'asyncapi bundle ./asyncapi.yaml ./features.yaml',
+    'asyncapi bundle ./asyncapi.yaml ./features.yaml --base ./main.yaml',
+    'asyncapi bundle ./asyncapi.yaml ./features.yaml --base ./main.yaml --xOrigin',
+    'asyncapi bundle ./asyncapi.yaml -o final-asyncapi.yaml --base ../public-api/main.yaml --baseDir ./social-media/comments-service',
+];
+Bundle.flags = (0, bundle_flags_1.bundleFlags)();
+exports.default = Bundle;

package/lib/apps/cli/commands/config/analytics.d.ts

@@ -0,0 +1,11 @@
+import Command from '../../internal/base';
+export default class Analytics extends Command {
+    static readonly description = "Enable or disable analytics for metrics collection";
+    static readonly flags: {
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        disable: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        enable: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        status: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/apps/cli/commands/config/analytics.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path_1 = require("path");
+const base_1 = tslib_1.__importDefault(require("../../internal/base"));
+const fs_1 = require("fs");
+const os_1 = require("os");
+const analytics_flags_1 = require("../../internal/flags/config/analytics.flags");
+const picocolors_1 = require("picocolors");
+const { readFile, writeFile } = fs_1.promises;
+class Analytics extends base_1.default {
+    run() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { flags } = yield this.parse(Analytics);
+            const analyticsConfigFile = process.env.ASYNCAPI_METRICS_CONFIG_PATH ||
+                (0, path_1.join)((0, os_1.homedir)(), '.asyncapi-analytics');
+            try {
+                const analyticsConfigFileContent = JSON.parse(yield readFile((0, path_1.resolve)(analyticsConfigFile), { encoding: 'utf8' }));
+                if (flags.disable) {
+                    analyticsConfigFileContent.analyticsEnabled = 'false';
+                    this.log('\nAnalytics disabled.\n');
+                    this.metricsMetadata.analytics_disabled = flags.disable;
+                }
+                else if (flags.enable) {
+                    analyticsConfigFileContent.analyticsEnabled = 'true';
+                    this.log('\nAnalytics enabled.\n');
+                    this.metricsMetadata.analytics_enabled = flags.enable;
+                }
+                else if (!flags.status) {
+                    this.log(`\nPlease append the ${(0, picocolors_1.blueBright)('--disable')} flag to the command if you prefer to disable analytics, or use the ${(0, picocolors_1.blueBright)('--enable')} flag if you want to enable analytics again. To check the current analytics status, use the ${(0, picocolors_1.blueBright)('--status')} flag.\n`);
+                    return;
+                }
+                yield writeFile(analyticsConfigFile, JSON.stringify(analyticsConfigFileContent), { encoding: 'utf8' });
+                if (flags.status) {
+                    if (analyticsConfigFileContent.analyticsEnabled === 'true') {
+                        this.log('\nAnalytics are enabled.\n');
+                    }
+                    else {
+                        this.log(`\n${(0, picocolors_1.redBright)('Analytics are disabled.')} To enable analytics, use the ${(0, picocolors_1.blueBright)('--enable')} flag.\n`);
+                    }
+                    this.metricsMetadata.analytics_status_checked = flags.status;
+                }
+            }
+            catch (e) {
+                switch (e.code) {
+                    case 'ENOENT':
+                        this.error(`Unable to access the analytics configuration file. We tried to access the ${(0, picocolors_1.blueBright)('.asyncapi-analytics')} file in the path "${(0, picocolors_1.blueBright)(analyticsConfigFile)}" but the file could not be found.`);
+                        break;
+                    case 'EEXIST':
+                        this.error(`Unable to update the analytics configuration file. We tried to update your ".asyncapi-analytics" file in the path "${(0, picocolors_1.blueBright)(analyticsConfigFile)}" but the file does not exist.`);
+                        break;
+                    default:
+                        this.error(`Unable to change your analytics configuration. Please check the following message for further info about the error:\n\n${(0, picocolors_1.redBright)(e)}`);
+                }
+            }
+        });
+    }
+}
+Analytics.description = 'Enable or disable analytics for metrics collection';
+Analytics.flags = (0, analytics_flags_1.analyticsFlags)();
+exports.default = Analytics;

package/lib/apps/cli/commands/config/auth/add.d.ts

@@ -0,0 +1,13 @@
+import Command from '../../../internal/base';
+export default class AuthAdd extends Command {
+    static description: string;
+    static args: {
+        pattern: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        token: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        'auth-type': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        header: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/apps/cli/commands/config/auth/add.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const base_1 = tslib_1.__importDefault(require("../../../internal/base"));
+const picocolors_1 = require("picocolors");
+const config_service_1 = require("../../../../../domains/services/config.service");
+class AuthAdd extends base_1.default {
+    run() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { args, flags } = yield this.parse(AuthAdd);
+            const isEnvVar = args.token.startsWith('$');
+            const tokenValue = isEnvVar ? args.token.slice(1) : args.token;
+            // Parse headers into an object
+            const headers = {};
+            if (flags.header) {
+                for (const headerEntry of flags.header) {
+                    const [key, value] = headerEntry.split('=');
+                    if (key && value) {
+                        headers[key.trim()] = value.trim();
+                    }
+                    else {
+                        this.warn(`⚠️ Ignored invalid header format: ${headerEntry}`);
+                    }
+                }
+            }
+            const entry = {
+                pattern: args.pattern,
+                token: tokenValue,
+                authType: flags['auth-type'] || 'Bearer',
+                headers: Object.keys(headers).length ? headers : undefined,
+            };
+            try {
+                yield config_service_1.ConfigService.addAuthEntry(entry);
+                this.log(`✅ Auth config added for ${(0, picocolors_1.blueBright)(args.pattern)} using ${isEnvVar ? `env var (${tokenValue})` : 'raw token'} with auth type ${(0, picocolors_1.blueBright)(entry.authType || 'Bearer')}`);
+                if (entry.headers) {
+                    this.log(`Headers: ${JSON.stringify(entry.headers, null, 2)}`);
+                }
+            }
+            catch (err) {
+                this.error(`❌ Failed to add auth config: ${err.message}`);
+            }
+        });
+    }
+}
+AuthAdd.description = 'Add an authentication config for resolving $ref files requiring HTTP Authorization.';
+AuthAdd.args = {
+    pattern: core_1.Args.string({
+        required: true,
+        description: 'Glob pattern for matching protected URLs (e.g. github.com/org/repo/**/*.*)',
+    }),
+    token: core_1.Args.string({
+        required: true,
+        description: 'Authentication token or environment variable reference (prefix with $, e.g. $GITHUB_TOKEN)',
+    }),
+};
+AuthAdd.flags = {
+    'auth-type': core_1.Flags.string({
+        char: 'a',
+        description: 'Authentication type (default is "Bearer")',
+    }),
+    header: core_1.Flags.string({
+        char: 'h',
+        description: 'Additional header in key=value format; can be used multiple times',
+        multiple: true,
+    }),
+};
+exports.default = AuthAdd;

package/lib/apps/cli/commands/config/context/add.d.ts

@@ -0,0 +1,13 @@
+import Command from '../../../internal/base';
+export default class ContextAdd extends Command {
+    static description: string;
+    static flags: {
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        'set-current': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        'context-name': import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        'spec-file-path': import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}