zcatalyst-cli 1.21.0 → 1.22.0

package/lib/throbber/index.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ISpinnerOptions, VALID_STATUSES } from './utils';
+import { TTYPassThrough } from '../util_modules/logger';
+interface IThrobbers {
+    [name: string]: ISpinnerOptions;
+}
+declare class Throbber {
+    options: ISpinnerOptions;
+    spinners: IThrobbers;
+    isCursorHidden: boolean;
+    currentInterval: null | NodeJS.Timeout;
+    stream: NodeJS.WriteStream | TTYPassThrough;
+    lineCount: number;
+    currentFrameIndex: number;
+    spin: boolean;
+    private constructor();
+    static instance?: Throbber | undefined;
+    static getInstance(options?: ISpinnerOptions): Throbber;
+    pick(name: string): ISpinnerOptions;
+    add(name: string, options?: ISpinnerOptions): ISpinnerOptions;
+    update(name: string, options?: ISpinnerOptions): ISpinnerOptions;
+    succeed(name: string, options?: ISpinnerOptions): ISpinnerOptions;
+    fail(name: string, options?: ISpinnerOptions): ISpinnerOptions;
+    remove(name: string): ISpinnerOptions;
+    stopAll(newStatus?: string): IThrobbers;
+    hasActiveSpinners(): boolean;
+    setSpinnerProperties(name: string, options: ISpinnerOptions, status?: VALID_STATUSES): void;
+    updateSpinnerState(): void;
+    loopStream(): NodeJS.Timeout;
+    setStreamOutput(frame?: string): void;
+    setRawStreamOutput(): void;
+    checkIfActiveSpinners(): void;
+    bindSigint(): void;
+}
+export default Throbber;

package/lib/throbber/index.js

@@ -7,22 +7,26 @@ const ansi_colors_1 = __importDefault(require("ansi-colors"));
 const cli_cursor_1 = __importDefault(require("cli-cursor"));
 const readline_1 = require("readline");
 const strip_ansi_1 = __importDefault(require("strip-ansi"));
-const error_js_1 = __importDefault(require("../error.js"));
-const char_js_1 = require("../util_modules/char.js");
+const index_1 = __importDefault(require("../error/index"));
+const utils_js_1 = require("../util_modules/logger/utils.js");
 const shell_js_1 = require("../util_modules/shell.js");
 const spinners_json_1 = require("./spinners.json");
 const utils_1 = require("./utils");
+const logger_1 = require("../util_modules/logger");
+const env_1 = require("../util_modules/env");
 class Throbber {
     constructor(options) {
         this.options = options;
         this.spinners = {};
         this.isCursorHidden = false;
         this.currentInterval = null;
-        this.stream = process.stderr;
+        this.stream = env_1.isVsCode ? logger_1.LogStreamFactory.getStream() : process.stderr;
         this.lineCount = 0;
         this.currentFrameIndex = 0;
         this.spin =
-            !this.options.disableSpins && !process.env.CI && process.stderr && process.stderr.isTTY;
+            !this.options.disableSpins &&
+                !process.env.CI &&
+                ((process.stderr && process.stderr.isTTY) || env_1.isVsCode);
         this.bindSigint();
         Throbber.instance = this;
     }
@@ -30,7 +34,7 @@ class Throbber {
         if (Throbber.instance !== undefined) {
             return Throbber.instance;
         }
-        const instance = new Throbber(Object.assign({ spinnerColor: 'cyanBright', spinner: (0, shell_js_1.supportsUnicode)() ? spinners_json_1.dots : spinners_json_1.dashes, disableSpins: false, status: 'spinning', succeedPrefix: char_js_1.CHAR.success, failPrefix: char_js_1.CHAR.error }, options));
+        const instance = new Throbber(Object.assign({ spinnerColor: 'cyanBright', spinner: (0, shell_js_1.supportsUnicode)() ? spinners_json_1.dots : spinners_json_1.dashes, disableSpins: false, status: 'spinning', succeedPrefix: utils_js_1.CHAR.success, failPrefix: utils_js_1.CHAR.error }, options));
         Throbber.instance = instance;
         return instance;
     }
@@ -100,7 +104,7 @@ class Throbber {
             return;
         }
         if (!this.spinners[name]) {
-            throw new error_js_1.default(`No spinner initialized with name ${name}`);
+            throw new index_1.default(`No spinner initialized with name ${name}`);
         }
         status = status || 'spinning';
         this.spinners[name] = Object.assign(Object.assign(Object.assign({}, this.spinners[name]), options), { status });
@@ -123,7 +127,7 @@ class Throbber {
     }
     loopStream() {
         if (this.options.spinner === undefined) {
-            throw new error_js_1.default('LoopStream must be called only with valid spinner object', {
+            throw new index_1.default('LoopStream must be called only with valid spinner object', {
                 exit: 2
             });
         }

package/lib/throbber/utils.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+export type VALID_STATUSES = 'succeed' | 'fail' | 'spinning' | 'non-spinnable' | 'stopped';
+export type VALID_COLORS = 'black' | 'red' | 'green' | 'yellow' | 'blue' | 'magenta' | 'cyan' | 'white' | 'grey' | 'redBright' | 'greenBright' | 'yellowBright' | 'blueBright' | 'magentaBright' | 'cyanBright' | 'whiteBright';
+export interface ISpinnerOptions {
+    text?: string;
+    status?: VALID_STATUSES;
+    indent?: number;
+    spinner?: {
+        interval: number;
+        frames: Array<string>;
+    };
+    succeedPrefix?: string;
+    failPrefix?: string;
+    color?: VALID_COLORS;
+    succeedColor?: VALID_COLORS;
+    failColor?: VALID_COLORS;
+    spinnerColor?: VALID_COLORS;
+    disableSpins?: boolean;
+}
+export declare function breakText(text: string, prefixLength: number): string;
+export declare function getLinesLength(text: string, prefixLength: number): Array<number>;
+export declare function writeStream(stream: NodeJS.WritableStream, output: string, rawLines: Array<number>): void;
+export declare function cleanStream(stream: NodeJS.WritableStream, rawLines: Array<number>): void;

package/lib/track.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (event: string, message: string, duration: number) => Promise<void>;
+export default _default;

package/lib/track.js

@@ -14,30 +14,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
 const readline_1 = require("readline");
-const config_store_1 = __importDefault(require("./config-store"));
+const config_store_js_1 = __importDefault(require("./util_modules/config-store.js"));
 const endpoints_1 = require("./endpoints");
-const error_1 = __importDefault(require("./error"));
+const index_js_1 = __importDefault(require("./error/index.js"));
 const runtime_store_1 = __importDefault(require("./runtime-store"));
 const fs_1 = require("./util_modules/fs");
-const logger_1 = require("./util_modules/logger");
-const winston_1 = require("./winston");
+const index_1 = require("./util_modules/logger/index");
+const winston_js_1 = require("./util_modules/logger/winston.js");
 exports.default = (event, message, duration) => __awaiter(void 0, void 0, void 0, function* () {
-    (0, logger_1.debug)(`EXEC ENDED with event: ${event}, message: ${message}`);
-    (0, logger_1.debug)('TOTAL DURATION OF COMMAND EXEC : ' + duration);
+    (0, index_1.debug)(`EXEC ENDED with event: ${event}, message: ${message}`);
+    (0, index_1.debug)('TOTAL DURATION OF COMMAND EXEC : ' + duration);
     try {
-        const httpLog = winston_1.logger.transports.find((transport) => {
+        const httpLog = winston_js_1.logger.transports.find((transport) => {
             return (transport.filename ===
-                winston_1.transport.http_log.filename);
+                winston_js_1.transport.http_log.filename);
         });
         if (runtime_store_1.default.get('credential', false) &&
-            config_store_1.default.get('usage', false) &&
+            config_store_js_1.default.get('usage', false) &&
             httpLog !== undefined) {
             const httpLogger = yield (0, endpoints_1.logAPI)();
             if (httpLogger === undefined) {
-                (0, logger_1.debug)('Unable to initialise the log API');
+                (0, index_1.debug)('Unable to initialise the log API');
                 return;
             }
-            winston_1.logger.remove(httpLog);
+            winston_js_1.logger.remove(httpLog);
             const rl = (0, readline_1.createInterface)({
                 input: fs_1.SYNC.getReadStream((0, path_1.join)(httpLog.dirname, httpLog.filename)),
                 crlfDelay: Infinity
@@ -54,7 +54,7 @@ exports.default = (event, message, duration) => __awaiter(void 0, void 0, void 0
         }
     }
     catch (e) {
-        const err = error_1.default.getErrorInstance(e);
-        (0, logger_1.debug)('Unable to send debug log to server: ' + err.message);
+        const err = index_js_1.default.getErrorInstance(e);
+        (0, index_1.debug)('Unable to send debug log to server: ' + err.message);
     }
 });

package/lib/userConfig.d.ts

@@ -0,0 +1,22 @@
+export declare const CONFIG_KEYS: {
+    python39_bin: string;
+    java8_bin: string;
+    java11_bin: string;
+    java17_bin: string;
+    javac_disableWarnings: string;
+    serve_container: string;
+};
+declare class UserConfig {
+    private configFilePath;
+    private config;
+    private validKeys;
+    constructor();
+    set(key: string, value: string): Record<string, string>;
+    get(key: string): string;
+    delete(key: string): boolean;
+    list(): string;
+    has(key: string): boolean;
+    refresh(): void;
+}
+declare const _default: UserConfig;
+export default _default;

package/lib/userConfig.js

@@ -3,21 +3,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG_KEYS = void 0;
 const fs_1 = require("./util_modules/fs");
 const constants_1 = require("./util_modules/constants");
 const path_1 = __importDefault(require("path"));
 const error_1 = __importDefault(require("./error"));
+exports.CONFIG_KEYS = {
+    python39_bin: 'python3_9.bin',
+    java8_bin: 'java8.bin',
+    java11_bin: 'java11.bin',
+    java17_bin: 'java17.bin',
+    javac_disableWarnings: 'javac.disable_warnings',
+    serve_container: 'serve.container'
+};
 class UserConfig {
     constructor() {
-        this.validKeys = [
-            'python3_9.bin',
-            'java8.bin',
-            'java11.bin',
-            'java17.bin',
-            'javac.disable_warnings'
-        ];
         this.configFilePath = path_1.default.join(constants_1.ENVPATH.userConfig.config, '.zcconfig');
-        this.config = fs_1.SYNC.readJSONFile(this.configFilePath, { checkpath: true }) || {};
+        this.config = {};
+        this.validKeys = Object.values(exports.CONFIG_KEYS);
+        this.refresh();
     }
     set(key, value) {
         if (!this.validKeys.includes(key)) {
@@ -50,5 +54,11 @@ class UserConfig {
         });
         return result.trim();
     }
+    has(key) {
+        return key in this.config;
+    }
+    refresh() {
+        this.config = fs_1.SYNC.readJSONFile(this.configFilePath, { checkpath: true }) || {};
+    }
 }
 exports.default = new UserConfig();

package/lib/util_modules/config/index.d.ts

@@ -0,0 +1,6 @@
+import * as apigConfig from './lib/apig';
+import * as clientConfig from './lib/client';
+import * as functionsConfig from './lib/functions';
+import * as appSailConfig from './lib/appsail';
+import * as slateConfig from './lib/slate.js';
+export { clientConfig, functionsConfig, apigConfig, appSailConfig, slateConfig };

package/lib/util_modules/config/lib/apig.d.ts

@@ -0,0 +1,15 @@
+export interface IAPIGConfig {
+    rules?: string;
+    enabled?: boolean;
+    scripts?: {
+        [x: string]: string;
+    };
+}
+export declare function raw(throwError?: boolean): IAPIGConfig | undefined;
+export declare function rules(): string;
+export declare function enabled(): boolean;
+export declare function enabled<T>(fallback?: T): boolean | T;
+export declare function script<T>(name?: string, fallback?: T): T | {
+    [x: string]: string;
+} | string;
+export declare const source: typeof rules;

package/lib/util_modules/config/lib/apig.js

@@ -4,14 +4,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.source = exports.script = exports.enabled = exports.rules = exports.raw = void 0;
-const error_1 = __importDefault(require("../../../error"));
+const index_js_1 = __importDefault(require("../../../error/index.js"));
 const runtime_store_1 = __importDefault(require("../../../runtime-store"));
 const constants_1 = require("../../constants");
 function raw(throwError = false) {
     const config = runtime_store_1.default.get('config', null);
     if (config === null) {
         if (throwError) {
-            throw new error_1.default(constants_1.FILENAME.config + ' file is required', { exit: 2 });
+            throw new index_js_1.default(constants_1.FILENAME.config + ' file is required', { exit: 2 });
         }
         return;
     }
@@ -32,13 +32,13 @@ function script(name, fallback) {
     const apigConfig = raw();
     const rawScripts = apigConfig && (apigConfig === null || apigConfig === void 0 ? void 0 : apigConfig.scripts);
     if (rawScripts === undefined && fallback === undefined) {
-        throw new error_1.default('Scripts not found', { exit: 2 });
+        throw new index_js_1.default('Scripts not found', { exit: 2 });
     }
     if (name === undefined) {
         return rawScripts || fallback;
     }
     if (rawScripts && rawScripts[name] === undefined && fallback === undefined) {
-        throw new error_1.default('Scripts not found', { exit: 2 });
+        throw new index_js_1.default('Scripts not found', { exit: 2 });
     }
     return (rawScripts && rawScripts[name]) || fallback;
 }

package/lib/util_modules/config/lib/appsail.d.ts

@@ -0,0 +1,50 @@
+export interface IAppSailConfig {
+    source: string;
+    name: string;
+    command?: string;
+    memory?: number;
+    port?: {
+        http: number;
+        debug: number;
+    };
+}
+export interface IAppSailServerConfig extends Record<string, unknown> {
+    command?: string;
+    build_path?: string;
+    buildPath?: string;
+    ignore?: Array<string>;
+    scripts?: Record<'predeploy' | 'postdeploy' | 'preserve' | 'postserve', string>;
+    stack?: string;
+    env_variables?: Record<string, string>;
+    platform?: 'javase' | 'war';
+    memory?: number;
+    catalyst_auth?: boolean;
+    login_redirect?: string;
+    port?: {
+        http?: number;
+        debug?: number;
+    };
+    raw: {
+        source_path?: string;
+        build_path?: string;
+    };
+}
+export type TAppSailDetails = {
+    name: string;
+    source: string;
+    validity: {
+        valid: boolean;
+        reason?: string;
+    };
+    runtime?: 'custom' | 'catalyst';
+    url?: string;
+    config?: IAppSailServerConfig;
+};
+export declare const CONTAINER_IMAGE_PROTOCOLS: {
+    docker: string;
+    dockerArchive: string;
+};
+export declare function raw(throwError?: boolean): Array<TAppSailDetails> | undefined;
+export declare function getTargetDetails(name: string): Promise<TAppSailDetails | undefined>;
+export declare function getAllTargetDetails(throwErr?: boolean): Promise<Array<TAppSailDetails> | undefined>;
+export declare function unlinkAppSail(name: string): Promise<boolean>;

package/lib/util_modules/config/lib/appsail.js

@@ -12,13 +12,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAllTargetDetails = exports.getTargetDetails = exports.raw = void 0;
+exports.unlinkAppSail = exports.getAllTargetDetails = exports.getTargetDetails = exports.raw = exports.CONTAINER_IMAGE_PROTOCOLS = void 0;
 const path_1 = require("path");
 const error_1 = __importDefault(require("../../../error"));
 const runtime_store_1 = __importDefault(require("../../../runtime-store"));
 const constants_1 = require("../../constants");
 const fs_1 = require("../../fs");
 const project_1 = require("../../project");
+exports.CONTAINER_IMAGE_PROTOCOLS = {
+    docker: 'docker://',
+    dockerArchive: 'docker-archive://'
+};
 function validateConfig(source, configJson) {
     if (!configJson) {
         return {
@@ -26,20 +30,22 @@ function validateConfig(source, configJson) {
             reason: 'Config file is empty'
         };
     }
-    const sourcePath = (0, path_1.join)((0, project_1.getProjectRoot)(), source);
+    const sourcePath = (0, path_1.isAbsolute)(source) ? source : (0, path_1.join)((0, project_1.getProjectRoot)(), source);
     configJson.raw.source_path = sourcePath;
-    if (configJson.buildPath || configJson.build_path) {
-        const buildPath = configJson.build_path || configJson.buildPath;
-        if (!buildPath) {
-            return {
-                valid: false,
-                reason: 'Build Path not present'
-            };
-        }
-        const absolutePath = (0, path_1.isAbsolute)(buildPath) ? buildPath : (0, path_1.resolve)(sourcePath, buildPath);
-        configJson.build_path = absolutePath;
-        configJson.raw.build_path = buildPath;
+    let buildPath;
+    if ('build_path' in configJson)
+        buildPath = configJson.build_path;
+    if ('buildPath' in configJson)
+        buildPath = configJson.buildPath;
+    if (!buildPath) {
+        return {
+            valid: false,
+            reason: `Invalid Build Path: "${buildPath}"`
+        };
     }
+    const absolutePath = (0, path_1.isAbsolute)(buildPath) ? buildPath : (0, path_1.resolve)(sourcePath, buildPath);
+    configJson.build_path = absolutePath;
+    configJson.raw.build_path = buildPath;
     if (configJson.catalyst_auth === true) {
         if (configJson.login_redirect === undefined) {
             return {
@@ -76,9 +82,46 @@ function raw(throwError = false) {
         return;
     }
     const appsailConfig = config.get('appsail');
+    const normalizeArchivePath = (path) => {
+        const tarPath = path.replace(exports.CONTAINER_IMAGE_PROTOCOLS.dockerArchive, '');
+        const normalized = (0, path_1.normalize)((0, path_1.join)((0, project_1.getProjectRoot)(), tarPath));
+        return `${exports.CONTAINER_IMAGE_PROTOCOLS.dockerArchive}${normalized}`;
+    };
     return appsailConfig === null || appsailConfig === void 0 ? void 0 : appsailConfig.map((_conf) => {
+        if (Object.values(exports.CONTAINER_IMAGE_PROTOCOLS)
+            .flat()
+            .find((proto) => _conf.source.startsWith(proto))) {
+            return {
+                name: _conf.name,
+                source: _conf.source.startsWith(exports.CONTAINER_IMAGE_PROTOCOLS.dockerArchive)
+                    ? normalizeArchivePath(_conf.source)
+                    : _conf.source,
+                runtime: 'custom',
+                validity: {
+                    valid: true
+                },
+                config: {
+                    command: _conf.command,
+                    memory: _conf.memory || 256,
+                    port: _conf.port,
+                    catalyst_auth: true,
+                    login_redirect: '/',
+                    build_path: '',
+                    env_variables: {},
+                    raw: {},
+                    stack: ''
+                }
+            };
+        }
         _conf.source = (0, path_1.isAbsolute)(_conf.source) ? _conf.source : (0, path_1.normalize)(_conf.source);
-        return _conf;
+        return {
+            name: _conf.name,
+            source: _conf.source,
+            runtime: 'catalyst',
+            validity: {
+                valid: true
+            }
+        };
     });
 }
 exports.raw = raw;
@@ -92,11 +135,13 @@ function getTargetDetails(name) {
         const appConfigPth = (0, project_1.resolveProjectPath)(target.source, constants_1.FILENAME.app_config);
         const isPath = yield fs_1.ASYNC.fileExists(appConfigPth);
         if (!isPath) {
-            return Object.assign({ validity: { valid: false, reason: 'Config file not present' } }, target);
+            target.validity = { valid: false, reason: 'Config file not present' };
+            return target;
         }
         const appConfigJson = yield fs_1.ASYNC.readJSONFile(appConfigPth);
         if (!appConfigJson) {
-            return Object.assign({ validity: { valid: false, reason: 'Config file is empty' } }, target);
+            target.validity = { valid: false, reason: 'Config file is empty' };
+            return target;
         }
         return Object.assign(Object.assign(Object.assign({}, target), appConfigJson), { validity: { valid: true } });
     });
@@ -112,28 +157,35 @@ function getAllTargetDetails(throwErr = true) {
             return;
         }
         return Promise.all(rawTargets.reduce((resArr, target) => {
+            if (target.runtime === 'custom') {
+                resArr.push(Promise.resolve(target));
+                return resArr;
+            }
             const catalystConfigPth = (0, project_1.resolveProjectPath)(target.source, constants_1.FILENAME.app_config);
             const isPath = fs_1.SYNC.fileExists(catalystConfigPth);
             if (!isPath) {
-                resArr.push(Promise.resolve(Object.assign({ validity: {
-                        valid: false,
-                        reason: 'Config file not present'
-                    } }, target)));
+                target.validity = {
+                    valid: false,
+                    reason: 'Config file not present'
+                };
+                resArr.push(Promise.resolve(target));
                 return resArr;
             }
             resArr.push(new Promise((res) => __awaiter(this, void 0, void 0, function* () {
                 try {
                     const configJson = yield fs_1.ASYNC.readJSONFile(catalystConfigPth);
                     configJson && (configJson.raw = {});
-                    const validity = validateConfig(target.source, configJson);
-                    return res(Object.assign({ config: configJson, validity }, target));
+                    target.validity = validateConfig(target.source, configJson);
+                    target.config = configJson;
+                    return res(target);
                 }
                 catch (er) {
                     const configErr = error_1.default.getErrorInstance(er, { skipHelp: true });
-                    res(Object.assign({ validity: {
-                            valid: false,
-                            reason: configErr.message
-                        } }, target));
+                    target.validity = {
+                        valid: false,
+                        reason: configErr.message
+                    };
+                    res(target);
                 }
             })));
             return resArr;
@@ -141,3 +193,21 @@ function getAllTargetDetails(throwErr = true) {
     });
 }
 exports.getAllTargetDetails = getAllTargetDetails;
+function unlinkAppSail(name) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const _raw = raw();
+        const idx = _raw === null || _raw === void 0 ? void 0 : _raw.findIndex((val) => val.name === name);
+        if (!idx) {
+            throw new error_1.default(`The provided AppSail name ${name} is not linked to the current project directory`, { exit: 1 });
+        }
+        const config = runtime_store_1.default.get('config', null);
+        if (!config) {
+            throw new error_1.default('Unable to retrieve config', { exit: 2 });
+        }
+        const deleted = _raw === null || _raw === void 0 ? void 0 : _raw.splice(idx, 1);
+        config.set('appsail', _raw);
+        yield config.save();
+        return !!deleted;
+    });
+}
+exports.unlinkAppSail = unlinkAppSail;

package/lib/util_modules/config/lib/client.d.ts

@@ -0,0 +1,20 @@
+export interface IClientConfig {
+    source?: string;
+    ignore?: Array<string>;
+    scripts?: {
+        [x: string]: string;
+    };
+    plugin?: {
+        [x: string]: string;
+    } | string;
+}
+export declare function raw(throwError?: boolean): IClientConfig | undefined;
+export declare function source(fallback?: "client"): string;
+export declare function plugin(): {
+    [x: string]: string;
+} | undefined;
+export declare function plugin(name: string): string | undefined;
+export declare function ignore(sourcePath: string): Array<string>;
+export declare function script<T>(name?: string, fallback?: T): T | {
+    [x: string]: string;
+} | string;

package/lib/util_modules/config/lib/client.js

@@ -5,25 +5,38 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.script = exports.ignore = exports.plugin = exports.source = exports.raw = void 0;
 const path_1 = require("path");
-const error_js_1 = __importDefault(require("../../../error.js"));
+const index_js_1 = __importDefault(require("../../../error/index.js"));
 const runtime_store_js_1 = __importDefault(require("../../../runtime-store.js"));
 const file_names_js_1 = __importDefault(require("../../constants/lib/file-names.js"));
 const folder_names_js_1 = __importDefault(require("../../constants/lib/folder-names.js"));
 const js_js_1 = require("../../js.js");
+const project_js_1 = require("../../project.js");
 function raw(throwError = false) {
     const config = runtime_store_js_1.default.get('config', null);
     if (config === null) {
         if (throwError) {
-            throw new error_js_1.default(file_names_js_1.default.config + ' file is required', { exit: 2 });
+            throw new index_js_1.default(file_names_js_1.default.config + ' file is required', { exit: 2 });
         }
         return;
     }
     return config.get('client');
 }
 exports.raw = raw;
-function source() {
+function source(fallback = folder_names_js_1.default.client) {
     const clientConfig = raw();
-    return (clientConfig && clientConfig.source) || folder_names_js_1.default.client;
+    const pth = (clientConfig === null || clientConfig === void 0 ? void 0 : clientConfig.source) || fallback;
+    const resolvedSource = (0, project_js_1.resolveProjectPath)(pth);
+    if (!resolvedSource.startsWith((0, project_js_1.getProjectRoot)())) {
+        throw new index_js_1.default('Invalid source path for functions. Source path outside project root', {
+            exit: 1,
+            context: {
+                projectRoot: (0, project_js_1.getProjectRoot)(),
+                sourcePath: pth,
+                resolvedSource
+            }
+        });
+    }
+    return resolvedSource;
 }
 exports.source = source;
 function plugin(name) {
@@ -70,13 +83,13 @@ function script(name, fallback) {
     const clientConfig = raw();
     const rawScripts = clientConfig && (clientConfig === null || clientConfig === void 0 ? void 0 : clientConfig.scripts);
     if (rawScripts === undefined && fallback === undefined) {
-        throw new error_js_1.default('Scripts not found', { exit: 2 });
+        throw new index_js_1.default('Scripts not found', { exit: 2 });
     }
     if (name === undefined) {
         return rawScripts || fallback;
     }
     if (rawScripts && rawScripts[name] === undefined && fallback === undefined) {
-        throw new error_js_1.default('Scripts not found', { exit: 2 });
+        throw new index_js_1.default('Scripts not found', { exit: 2 });
     }
     return (rawScripts && rawScripts[name]) || fallback;
 }