@asyncapi/cli 4.0.1 → 4.1.1

package/LICENSE

@@ -198,4 +198,4 @@
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
-   limitations under the License.
+   limitations under the License.

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/domains/services/config.service.d.ts

@@ -0,0 +1,42 @@
+export interface AuthEntry {
+    pattern: string;
+    token: string;
+    authType?: string;
+    headers?: Record<string, string>;
+}
+export interface AuthResult {
+    token: string;
+    authType: string;
+    headers: Record<string, string>;
+}
+interface Config {
+    auth?: AuthEntry[];
+}
+export declare class ConfigService {
+    /**
+     * Load config file (~/.asyncapi/config.json)
+     */
+    static loadConfig(): Promise<Config>;
+    /**
+     * Save config back to file
+     */
+    static saveConfig(config: Config): Promise<void>;
+    /**
+     * Add a new auth entry
+     */
+    static addAuthEntry(entry: AuthEntry): Promise<void>;
+    /**
+     * Reads auth config from ~/.asyncapi/config.json and
+     * returns auth info matching the given URL, or null if no match.
+     *
+     * @param url - URL to match against auth patterns
+     * @returns Auth info or null if no match found
+     */
+    static getAuthForUrl(url: string): Promise<AuthResult | null>;
+    /**
+     * Convert wildcard pattern (*, **) to RegExp matching start of string
+     * @param pattern - wildcard pattern
+     */
+    private static wildcardToRegex;
+}
+export {};

package/lib/domains/services/config.service.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigService = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const os_1 = tslib_1.__importDefault(require("os"));
+const fs_1 = require("fs");
+const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.asyncapi');
+const CONFIG_FILE = path_1.default.join(CONFIG_DIR, 'config.json');
+class ConfigService {
+    /**
+     * Load config file (~/.asyncapi/config.json)
+     */
+    static loadConfig() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const content = yield fs_1.promises.readFile(CONFIG_FILE, 'utf8');
+                return JSON.parse(content);
+            }
+            catch (err) {
+                if (err.code === 'ENOENT') {
+                    return {}; // no config yet
+                }
+                throw new Error(`Error reading config file: ${err.message}`);
+            }
+        });
+    }
+    /**
+     * Save config back to file
+     */
+    static saveConfig(config) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield fs_1.promises.mkdir(CONFIG_DIR, { recursive: true });
+            yield fs_1.promises.writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf8');
+        });
+    }
+    /**
+     * Add a new auth entry
+     */
+    static addAuthEntry(entry) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const config = yield this.loadConfig();
+            if (!config.auth) {
+                config.auth = [];
+            }
+            config.auth.push(entry);
+            yield this.saveConfig(config);
+        });
+    }
+    /**
+     * Reads auth config from ~/.asyncapi/config.json and
+     * returns auth info matching the given URL, or null if no match.
+     *
+     * @param url - URL to match against auth patterns
+     * @returns Auth info or null if no match found
+     */
+    static getAuthForUrl(url) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const config = yield this.loadConfig();
+            if (!config.auth || !Array.isArray(config.auth)) {
+                console.warn('⚠️ No valid "auth" array found in config');
+                return null;
+            }
+            for (const entry of config.auth) {
+                try {
+                    const regex = this.wildcardToRegex(entry.pattern);
+                    if (regex.test(url)) {
+                        return {
+                            token: entry.token,
+                            authType: entry.authType || 'Bearer',
+                            headers: entry.headers || {}
+                        };
+                    }
+                }
+                catch (err) {
+                    console.warn(`⚠️ Invalid pattern "${entry.pattern}": ${err.message}`);
+                }
+            }
+            return null;
+        });
+    }
+    /**
+     * Convert wildcard pattern (*, **) to RegExp matching start of string
+     * @param pattern - wildcard pattern
+     */
+    static wildcardToRegex(pattern) {
+        const escaped = pattern.replace(/[-/\\^$+?.()|[\]{}]/g, '\\$&');
+        const regexStr = escaped
+            .replace(/\*\*/g, '.*')
+            .replace(/\*/g, '[^/]*');
+        // eslint-disable-next-line security/detect-non-literal-regexp
+        return new RegExp(`^${regexStr}`);
+    }
+}
+exports.ConfigService = ConfigService;

package/lib/domains/services/validation.service.js

@@ -14,6 +14,89 @@ const chalk_1 = require("chalk");
 const fs_1 = require("fs");
 const path_1 = tslib_1.__importDefault(require("path"));
 const scoreCalculator_1 = require("../../utils/scoreCalculator");
+const config_service_1 = require("./config.service");
+/**
+ * Helper function to validate if a URL is a GitHub blob URL
+ */
+const isValidGitHubBlobUrl = (url) => {
+    try {
+        const parsedUrl = new URL(url);
+        return (parsedUrl.hostname === 'github.com' &&
+            parsedUrl.pathname.split('/')[3] === 'blob');
+    }
+    catch (error) {
+        return false;
+    }
+};
+/**
+ * Convert GitHub web URL to API URL
+ */
+const convertGitHubWebUrl = (url) => {
+    // Remove fragment from URL before processing
+    const urlWithoutFragment = url.split('#')[0];
+    // Handle GitHub web URLs like: https://github.com/owner/repo/blob/branch/path
+    // eslint-disable-next-line no-useless-escape
+    const githubWebPattern = /^https:\/\/github\.com\/([^\/]+)\/([^\/]+)\/blob\/([^\/]+)\/(.+)$/;
+    const match = urlWithoutFragment.match(githubWebPattern);
+    if (match) {
+        const [, owner, repo, branch, filePath] = match;
+        return `https://api.github.com/repos/${owner}/${repo}/contents/${filePath}?ref=${branch}`;
+    }
+    return url;
+};
+/**
+ * Custom resolver for private repositories
+ */
+const createHttpWithAuthResolver = () => ({
+    schema: 'https',
+    order: 1,
+    read: (uri) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        let url = uri.toString();
+        // Default headers
+        const headers = {
+            'User-Agent': 'AsyncAPI-CLI',
+        };
+        const authInfo = yield config_service_1.ConfigService.getAuthForUrl(url);
+        if (isValidGitHubBlobUrl(url)) {
+            url = convertGitHubWebUrl(url);
+        }
+        if (authInfo) {
+            headers['Authorization'] = `${authInfo.authType} ${authInfo.token}`;
+            Object.assign(headers, authInfo.headers); // merge custom headers
+        }
+        if (url.includes('api.github.com')) {
+            headers['Accept'] = 'application/vnd.github.v3+json';
+            const res = yield fetch(url, { headers });
+            if (!res.ok) {
+                throw new Error(`Failed to fetch GitHub API URL: ${url} - ${res.statusText}`);
+            }
+            const fileInfo = (yield res.json());
+            if (fileInfo.download_url) {
+                const contentRes = yield fetch(fileInfo.download_url, { headers });
+                if (!contentRes.ok) {
+                    throw new Error(`Failed to fetch content from download URL: ${fileInfo.download_url} - ${contentRes.statusText}`);
+                }
+                return yield contentRes.text();
+            }
+            throw new Error(`No download URL found in GitHub API response for: ${url}`);
+        }
+        else if (url.includes('raw.githubusercontent.com')) {
+            headers['Accept'] = 'application/vnd.github.v3.raw';
+            const res = yield fetch(url, { headers });
+            if (!res.ok) {
+                throw new Error(`Failed to fetch GitHub URL: ${url} - ${res.statusText}`);
+            }
+            return yield res.text();
+        }
+        else {
+            const res = yield fetch(url, { headers });
+            if (!res.ok) {
+                throw new Error(`Failed to fetch URL: ${url} - ${res.statusText}`);
+            }
+            return yield res.text();
+        }
+    }),
+});
 const { writeFile } = fs_1.promises;
 var ValidationStatus;
 (function (ValidationStatus) {
@@ -40,11 +123,17 @@ const validFormats = [
 ];
 class ValidationService extends base_service_1.BaseService {
     constructor(parserOptions = {}) {
-        var _a;
+        var _a, _b, _c;
         super();
-        this.parser = new cjs_1.Parser(Object.assign(Object.assign({}, parserOptions), { __unstable: Object.assign({ resolver: {
+        // Create parser with custom GitHub resolver
+        const customParserOptions = Object.assign(Object.assign({}, parserOptions), { __unstable: Object.assign({ resolver: {
                     cache: false,
-                } }, (_a = parserOptions.__unstable) === null || _a === void 0 ? void 0 : _a.resolver) }));
+                    resolvers: [
+                        createHttpWithAuthResolver(),
+                        ...(((_b = (_a = parserOptions.__unstable) === null || _a === void 0 ? void 0 : _a.resolver) === null || _b === void 0 ? void 0 : _b.resolvers) || [])
+                    ],
+                } }, (_c = parserOptions.__unstable) === null || _c === void 0 ? void 0 : _c.resolver) });
+        this.parser = new cjs_1.Parser(customParserOptions);
         this.parser.registerSchemaParser((0, openapi_schema_parser_1.OpenAPISchemaParser)());
         this.parser.registerSchemaParser((0, raml_dt_schema_parser_1.RamlDTSchemaParser)());
         this.parser.registerSchemaParser((0, avro_schema_parser_1.AvroSchemaParser)());
@@ -130,6 +219,7 @@ class ValidationService extends base_service_1.BaseService {
                 __unstable: {
                     resolver: {
                         cache: false,
+                        resolvers: [createHttpWithAuthResolver()],
                     },
                 },
             });

package/oclif.manifest.json

@@ -1798,6 +1798,57 @@
         "studio.js"
       ]
     },
+    "config:auth:add": {
+      "aliases": [],
+      "args": {
+        "pattern": {
+          "description": "Glob pattern for matching protected URLs (e.g. github.com/org/repo/**/*.*)",
+          "name": "pattern",
+          "required": true
+        },
+        "token": {
+          "description": "Authentication token or environment variable reference (prefix with $, e.g. $GITHUB_TOKEN)",
+          "name": "token",
+          "required": true
+        }
+      },
+      "description": "Add an authentication config for resolving $ref files requiring HTTP Authorization.",
+      "flags": {
+        "auth-type": {
+          "char": "a",
+          "description": "Authentication type (default is \"Bearer\")",
+          "name": "auth-type",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "header": {
+          "char": "h",
+          "description": "Additional header in key=value format; can be used multiple times",
+          "name": "header",
+          "hasDynamicHelp": false,
+          "multiple": true,
+          "type": "option"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "config:auth:add",
+      "pluginAlias": "@asyncapi/cli",
+      "pluginName": "@asyncapi/cli",
+      "pluginType": "core",
+      "strict": true,
+      "isESM": false,
+      "relativePath": [
+        "lib",
+        "apps",
+        "cli",
+        "commands",
+        "config",
+        "auth",
+        "add.js"
+      ]
+    },
     "config:context:add": {
       "aliases": [],
       "args": {
@@ -2088,5 +2139,5 @@
       ]
     }
   },
-  "version": "4.0.1"
+  "version": "4.1.1"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@asyncapi/cli",
   "description": "All in one CLI for all AsyncAPI tools",
-  "version": "4.0.1",
+  "version": "4.1.1",
   "author": "@asyncapi",
   "bin": {
     "asyncapi": "./bin/run_bin"