zephyr-agent/dist/lib/errors/zephyr-error.js

Zephyr plugin agent

"use strict";
var __webpack_require__ = {};
(()=>{
    __webpack_require__.d = (exports1, getters, values)=>{
        var define = (defs, kind)=>{
            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
                enumerable: true,
                [kind]: defs[key]
            });
        };
        define(getters, "get");
        define(values, "value");
    };
})();
(()=>{
    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
})();
(()=>{
    __webpack_require__.r = (exports1)=>{
        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
            value: 'Module'
        });
        Object.defineProperty(exports1, '__esModule', {
            value: true
        });
    };
})();
var __webpack_exports__ = {};
__webpack_require__.r(__webpack_exports__);
__webpack_require__.d(__webpack_exports__, {
    ZephyrError: ()=>ZephyrError,
    discordUrl: ()=>discordUrl,
    docsUrl: ()=>docsUrl
});
const external_node_fs_namespaceObject = require("node:fs");
const external_node_os_namespaceObject = require("node:os");
const external_node_path_namespaceObject = require("node:path");
const external_node_util_namespaceObject = require("node:util");
const external_zephyr_edge_contract_namespaceObject = require("zephyr-edge-contract");
const index_js_namespaceObject = require("../logging/index.js");
const picocolor_js_namespaceObject = require("../logging/picocolor.js");
const redaction_js_namespaceObject = require("../security/redaction.js");
const external_codes_js_namespaceObject = require("./codes.js");
const docsUrl = 'https://docs.zephyr-cloud.io/errors';
const discordUrl = 'https://zephyr-cloud.io/discord';
class ZephyrError extends Error {
    code;
    data;
    template;
    operation;
    reason;
    cause;
    constructor(type, opts){
        if (ZephyrError.is(opts?.cause)) {
            if ((0, external_codes_js_namespaceObject.isZeErrorEqual)(type, external_codes_js_namespaceObject.ZeErrors.ERR_UNKNOWN)) return opts.cause;
            if (!opts.data && opts.cause.data) {
                opts.data = opts.cause.data;
                opts.cause.data = void 0;
            }
        }
        let message = type.message;
        if (opts) message = (0, external_zephyr_edge_contract_namespaceObject.formatString)(type.message, opts);
        super(message.trim());
        this.code = ZephyrError.toZeCode(type);
        if (opts) {
            const { cause, data, operation, reason, ...template } = opts;
            this.template = template;
            this.data = data;
            this.cause = cause;
            this.operation = operation;
            this.reason = reason ?? (ZephyrError.is(cause) ? cause.reason ?? cause.code : this.code);
        }
        this.reason ??= this.code;
        if (process.env['VITE']) this._stack = this.stack;
    }
    static is(err, codeOrType) {
        if (!(err instanceof ZephyrError)) return false;
        if (!codeOrType) return true;
        return ZephyrError.toZeCode(codeOrType) === err.code;
    }
    static withContext(error, operation) {
        const zeError = ZephyrError.is(error) ? error : new ZephyrError(external_codes_js_namespaceObject.ZeErrors.ERR_UNKNOWN, {
            message: error?.message || String(error),
            cause: error
        });
        zeError.operation ??= operation;
        return zeError;
    }
    static toZeCode({ id, kind }) {
        const prefix = external_codes_js_namespaceObject.ZeErrorCategories[kind];
        const paddedId = id.toString().padStart(3, '0');
        const paddedPrefix = prefix.toString().padStart(2, '0');
        return `ZE${paddedPrefix}${paddedId}`;
    }
    static fromZeCode(code) {
        const prefix = code.slice(2, 4);
        const id = code.slice(4);
        let category;
        for (const errorCategory of Object.keys(external_codes_js_namespaceObject.ZeErrorCategories))if (external_codes_js_namespaceObject.ZeErrorCategories[errorCategory] === prefix) {
            category = errorCategory;
            break;
        }
        if (!category) return external_codes_js_namespaceObject.ZeErrors.ERR_UNKNOWN;
        for (const error of Object.values(external_codes_js_namespaceObject.ZeErrors))if (+error.id === +id && error.kind === category) return error;
        return external_codes_js_namespaceObject.ZeErrors.ERR_UNKNOWN;
    }
    static format(error) {
        const zeError = ZephyrError.is(error) ? error : new ZephyrError(external_codes_js_namespaceObject.ZeErrors.ERR_UNKNOWN, {
            message: error?.message || String(error),
            cause: error
        });
        const tmpFile = write_error_file(zeError);
        const sanitizedData = (0, redaction_js_namespaceObject.sanitizeForLogging)(zeError.data);
        const inspected = 'object' == typeof sanitizedData ? external_node_util_namespaceObject.inspect(sanitizedData, false, 5, true) : sanitizedData;
        const messages = [
            `${(0, picocolor_js_namespaceObject.bold)((0, picocolor_js_namespaceObject.underline)(zeError.code))}: ${(0, redaction_js_namespaceObject.redactString)(zeError.message)}`,
            formatDiagnosticContext(zeError),
            `

Visit ${(0, picocolor_js_namespaceObject.cyanBright)(`${docsUrl}/${zeError.code.toLowerCase()}`)} for more information
Or join our ${(0, picocolor_js_namespaceObject.blue)('Discord')} server at ${(0, picocolor_js_namespaceObject.cyanBright)(discordUrl)}

`.trim(),
            '{}' !== inspected && inspected,
            tmpFile && (0, picocolor_js_namespaceObject.blackBright)(`Complete error details available at ${(0, picocolor_js_namespaceObject.whiteBright)(tmpFile)}`)
        ];
        return (0, redaction_js_namespaceObject.redactString)(messages.filter((x)=>!!x).map((x)=>x.trim()).join('\n\n'));
    }
    toJSON() {
        return format_error(this);
    }
}
function write_error_file(zeError) {
    try {
        const errorString = (0, redaction_js_namespaceObject.safeStringifyForLogging)(format_error(zeError));
        const errorExt = 'json';
        index_js_namespaceObject.ze_log.misc(errorString);
        const tempPath = external_node_path_namespaceObject.join(external_node_os_namespaceObject.tmpdir(), `ze${Math.round(10e9 * Math.random())}.${errorExt}`);
        external_node_fs_namespaceObject.writeFileSync(tempPath, errorString, 'utf8');
        return tempPath;
    } catch (error) {
        index_js_namespaceObject.ze_log.error('Failed writing error to temp file:', error);
        return;
    }
}
function format_error(err) {
    if (!err) return;
    const error = err;
    return (0, redaction_js_namespaceObject.sanitizeForLogging)({
        name: error.name,
        code: error.code,
        operation: error.operation,
        reason: error.reason,
        template: void 0,
        ...error?.template,
        data: error?.data,
        message: error?.message,
        stack: split_stack(error.stack, error.message),
        cause: error.cause
    });
}
function formatDiagnosticContext(error) {
    if (!error.operation && error.reason === error.code) return;
    const cause = ZephyrError.is(error.cause) ? error.cause : void 0;
    const reasonMessage = cause && cause.code === error.reason ? (0, redaction_js_namespaceObject.redactString)(cause.message) : void 0;
    return [
        error.operation && `Operation: ${error.operation}`,
        error.reason && `Reason: ${error.reason}${reasonMessage ? `: ${reasonMessage}` : ''}`
    ].filter(Boolean).join('\n');
}
function split_stack(stack, message) {
    if (!stack) return;
    if (message) stack = stack.slice(`Error: ${message}\n`.length);
    return stack.split('\n').map((line)=>(0, external_zephyr_edge_contract_namespaceObject.stripAnsi)(line.trim()));
}
exports.ZephyrError = __webpack_exports__.ZephyrError;
exports.discordUrl = __webpack_exports__.discordUrl;
exports.docsUrl = __webpack_exports__.docsUrl;
for(var __rspack_i in __webpack_exports__)if (-1 === [
    "ZephyrError",
    "discordUrl",
    "docsUrl"
].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
Object.defineProperty(exports, '__esModule', {
    value: true
});

//# sourceMappingURL=zephyr-error.js.map