@hubspot/local-dev-lib 0.0.4 → 0.0.6

package/lib/path.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAbsoluteFilePath = exports.isAllowedExtension = exports.getExt = exports.getCwd = exports.splitHubSpotPath = exports.splitLocalPath = exports.convertToLocalFileSystemPath = exports.convertToUnixPath = void 0;
+exports.getAbsoluteFilePath = exports.isAllowedExtension = exports.getAllowedExtensions = exports.getExt = exports.getCwd = exports.splitHubSpotPath = exports.splitLocalPath = exports.convertToLocalFileSystemPath = exports.convertToUnixPath = void 0;
 const path_1 = __importDefault(require("path"));
 const unixify_1 = __importDefault(require("unixify"));
 const extensions_1 = require("../constants/extensions");
@@ -73,9 +73,14 @@ function getExt(filepath) {
     return ext[0] === '.' ? ext.slice(1) : ext;
 }
 exports.getExt = getExt;
-function isAllowedExtension(filepath) {
+function getAllowedExtensions(allowList = []) {
+    return new Set([...Array.from(extensions_1.ALLOWED_EXTENSIONS), ...allowList]);
+}
+exports.getAllowedExtensions = getAllowedExtensions;
+function isAllowedExtension(filepath, allowList = []) {
     const ext = getExt(filepath);
-    return extensions_1.ALLOWED_EXTENSIONS.has(ext);
+    const allowedExtensions = getAllowedExtensions(allowList);
+    return allowedExtensions.has(ext);
 }
 exports.isAllowedExtension = isAllowedExtension;
 function getAbsoluteFilePath(_path) {

package/lib/personalAccessKey.d.ts

@@ -0,0 +1,13 @@
+import { CLIAccount } from '../types/Accounts';
+import { Environment } from '../types/Config';
+type AccessToken = {
+    portalId: number;
+    accessToken: string;
+    expiresAt: string;
+    scopeGroups: Array<string>;
+    encodedOauthRefreshToken: string;
+};
+export declare function getAccessToken(personalAccessKey: string, env?: Environment, accountId?: number): Promise<AccessToken>;
+export declare function accessTokenForPersonalAccessKey(accountId: number): Promise<string | undefined>;
+export declare const updateConfigWithPersonalAccessKey: (personalAccessKey: string, name: string, env: Environment, makeDefault?: boolean) => Promise<CLIAccount | null>;
+export {};

package/lib/personalAccessKey.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateConfigWithPersonalAccessKey = exports.accessTokenForPersonalAccessKey = exports.getAccessToken = void 0;
+const moment_1 = __importDefault(require("moment"));
+const environments_1 = require("../constants/environments");
+const auth_1 = require("../constants/auth");
+const standardErrors_1 = require("../errors/standardErrors");
+const localDevAuth_1 = require("../api/localDevAuth");
+const sandboxHubs_1 = require("../api/sandboxHubs");
+const config_1 = require("../config");
+const refreshRequests = new Map();
+function getRefreshKey(personalAccessKey, expiration) {
+    return `${personalAccessKey}-${expiration || 'fresh'}`;
+}
+async function getAccessToken(personalAccessKey, env = environments_1.ENVIRONMENTS.PROD, accountId) {
+    let response;
+    try {
+        response = await (0, localDevAuth_1.fetchAccessToken)(personalAccessKey, env, accountId);
+    }
+    catch (e) {
+        const error = e;
+        if (error.response) {
+            (0, standardErrors_1.throwAuthErrorWithMessage)('personalAccessKey.invalidPersonalAccessKey', { errorMessage: error.response.body.message || '' }, error);
+        }
+        else {
+            (0, standardErrors_1.throwError)(e);
+        }
+    }
+    return {
+        portalId: response.hubId,
+        accessToken: response.oauthAccessToken,
+        expiresAt: (0, moment_1.default)(response.expiresAtMillis).toISOString(),
+        scopeGroups: response.scopeGroups,
+        encodedOauthRefreshToken: response.encodedOauthRefreshToken,
+    };
+}
+exports.getAccessToken = getAccessToken;
+async function refreshAccessToken(personalAccessKey, env = environments_1.ENVIRONMENTS.PROD, accountId) {
+    const { accessToken, expiresAt } = await getAccessToken(personalAccessKey, env, accountId);
+    const config = (0, config_1.getAccountConfig)(accountId);
+    (0, config_1.updateAccountConfig)({
+        env,
+        ...config,
+        accountId,
+        tokenInfo: {
+            accessToken,
+            expiresAt: expiresAt,
+        },
+    });
+    (0, config_1.writeConfig)();
+    return accessToken;
+}
+async function getNewAccessToken(accountId, personalAccessKey, expiresAt, env) {
+    const key = getRefreshKey(personalAccessKey, expiresAt);
+    if (refreshRequests.has(key)) {
+        return refreshRequests.get(key);
+    }
+    let accessToken;
+    try {
+        const refreshAccessPromise = refreshAccessToken(personalAccessKey, env, accountId);
+        if (key) {
+            refreshRequests.set(key, refreshAccessPromise);
+        }
+        accessToken = await refreshAccessPromise;
+    }
+    catch (e) {
+        if (key) {
+            refreshRequests.delete(key);
+        }
+        throw e;
+    }
+    return accessToken;
+}
+async function accessTokenForPersonalAccessKey(accountId) {
+    const account = (0, config_1.getAccountConfig)(accountId);
+    if (!account) {
+        (0, standardErrors_1.throwErrorWithMessage)('personalAccessKey.accountNotFound', { accountId });
+    }
+    const { auth, personalAccessKey, env } = account;
+    const authTokenInfo = auth && auth.tokenInfo;
+    const authDataExists = authTokenInfo && auth?.tokenInfo?.accessToken;
+    if (!authDataExists ||
+        (0, moment_1.default)().add(5, 'minutes').isAfter((0, moment_1.default)(authTokenInfo.expiresAt))) {
+        return getNewAccessToken(accountId, personalAccessKey, authTokenInfo && authTokenInfo.expiresAt, env);
+    }
+    return auth?.tokenInfo?.accessToken;
+}
+exports.accessTokenForPersonalAccessKey = accessTokenForPersonalAccessKey;
+// Adds a account to the config using authType: personalAccessKey
+const updateConfigWithPersonalAccessKey = async (personalAccessKey, name, env, makeDefault = false) => {
+    const accountEnv = env || (0, config_1.getEnv)(name);
+    let token;
+    try {
+        token = await getAccessToken(personalAccessKey, accountEnv);
+    }
+    catch (err) {
+        (0, standardErrors_1.throwError)(err);
+    }
+    const { portalId, accessToken, expiresAt } = token;
+    let hubInfo;
+    try {
+        hubInfo = await (0, sandboxHubs_1.fetchSandboxHubData)(accessToken, portalId, accountEnv);
+    }
+    catch (err) {
+        // Ignore error, returns 404 if account is not a sandbox
+    }
+    let sandboxAccountType = null;
+    let parentAccountId = null;
+    if (hubInfo) {
+        if (hubInfo.type !== undefined) {
+            sandboxAccountType = hubInfo.type === null ? 'STANDARD' : hubInfo.type;
+        }
+        if (hubInfo.parentHubId) {
+            parentAccountId = hubInfo.parentHubId;
+        }
+    }
+    const updatedConfig = (0, config_1.updateAccountConfig)({
+        accountId: portalId,
+        personalAccessKey,
+        name,
+        authType: auth_1.PERSONAL_ACCESS_KEY_AUTH_METHOD.value,
+        tokenInfo: { accessToken, expiresAt },
+        sandboxAccountType,
+        parentAccountId,
+    });
+    (0, config_1.writeConfig)();
+    if (makeDefault) {
+        (0, config_1.updateDefaultAccount)(name);
+    }
+    return updatedConfig;
+};
+exports.updateConfigWithPersonalAccessKey = updateConfigWithPersonalAccessKey;

package/lib/sandboxes.d.ts

@@ -0,0 +1,14 @@
+import { InitiateSyncResponse, Sandbox, SandboxType, SyncTask, Task, Usage } from '../types/Sandbox';
+export declare function createSandbox(accountId: number, name: string, type: string): Promise<{
+    name: string;
+    sandbox: Sandbox;
+    personalAccessKey: string;
+}>;
+export declare function deleteSandbox(parentAccountId: number, sandboxAccountId: number): Promise<{
+    parentAccountId: number;
+    sandboxAccountId: number;
+}>;
+export declare function getSandboxUsageLimits(parentAccountId: number): Promise<Usage | void>;
+export declare function initiateSync(fromHubId: number, toHubId: number, tasks: Array<SyncTask>, sandboxHubId: number): Promise<InitiateSyncResponse>;
+export declare function fetchTaskStatus(accountId: number, taskId: number): Promise<Task>;
+export declare function fetchTypes(accountId: number, toHubId: number): Promise<Array<SandboxType> | void>;

package/lib/sandboxes.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTypes = exports.fetchTaskStatus = exports.initiateSync = exports.getSandboxUsageLimits = exports.deleteSandbox = exports.createSandbox = void 0;
+const sandboxHubs_1 = require("../api/sandboxHubs");
+const sandboxSync_1 = require("../api/sandboxSync");
+const standardErrors_1 = require("../errors/standardErrors");
+const i18nKey = 'sandboxes';
+async function createSandbox(accountId, name, type) {
+    try {
+        const resp = await (0, sandboxHubs_1.createSandbox)(accountId, name, type);
+        return {
+            name,
+            ...resp,
+        };
+    }
+    catch (err) {
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.createSandbox`, {}, err);
+    }
+}
+exports.createSandbox = createSandbox;
+async function deleteSandbox(parentAccountId, sandboxAccountId) {
+    try {
+        await (0, sandboxHubs_1.deleteSandbox)(parentAccountId, sandboxAccountId);
+    }
+    catch (err) {
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.deleteSandbox`, {}, err);
+    }
+    return {
+        parentAccountId,
+        sandboxAccountId,
+    };
+}
+exports.deleteSandbox = deleteSandbox;
+async function getSandboxUsageLimits(parentAccountId) {
+    try {
+        const resp = await (0, sandboxHubs_1.getSandboxUsageLimits)(parentAccountId);
+        return resp && resp.usage;
+    }
+    catch (err) {
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.getSandboxUsageLimits`, {}, err);
+    }
+}
+exports.getSandboxUsageLimits = getSandboxUsageLimits;
+async function initiateSync(fromHubId, toHubId, tasks, sandboxHubId) {
+    try {
+        return await (0, sandboxSync_1.initiateSync)(fromHubId, toHubId, tasks, sandboxHubId);
+    }
+    catch (err) {
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.initiateSync`, {}, err);
+    }
+}
+exports.initiateSync = initiateSync;
+async function fetchTaskStatus(accountId, taskId) {
+    try {
+        return await (0, sandboxSync_1.fetchTaskStatus)(accountId, taskId);
+    }
+    catch (err) {
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.fetchTaskStatus`, {}, err);
+    }
+}
+exports.fetchTaskStatus = fetchTaskStatus;
+async function fetchTypes(accountId, toHubId) {
+    try {
+        const resp = await (0, sandboxSync_1.fetchTypes)(accountId, toHubId);
+        return resp && resp.results;
+    }
+    catch (err) {
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.fetchTypes`, {}, err);
+    }
+}
+exports.fetchTypes = fetchTypes;

package/lib/trackUsage.d.ts

@@ -0,0 +1 @@
+export declare function trackUsage(eventName: string, eventClass: string, meta: {} | undefined, accountId: number): Promise<void>;

package/lib/trackUsage.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackUsage = void 0;
+const logger_1 = require("../utils/logger");
+const http_1 = __importDefault(require("../http"));
+const config_1 = require("../config");
+const fileMapper_1 = require("../api/fileMapper");
+async function trackUsage(eventName, eventClass, meta = {}, accountId) {
+    const i18nKey = 'api.filemapper.trackUsage';
+    const usageEvent = {
+        accountId,
+        eventName,
+        eventClass,
+        meta,
+    };
+    const EVENT_TYPES = {
+        VSCODE_EXTENSION_INTERACTION: 'vscode-extension-interaction',
+        CLI_INTERACTION: 'cli-interaction',
+    };
+    let analyticsEndpoint;
+    switch (eventName) {
+        case EVENT_TYPES.CLI_INTERACTION:
+            analyticsEndpoint = 'cms-cli-usage';
+            break;
+        case EVENT_TYPES.VSCODE_EXTENSION_INTERACTION:
+            analyticsEndpoint = 'vscode-extension-usage';
+            break;
+        default:
+            (0, logger_1.debug)(`${i18nKey}.invalidEvent`, { eventName });
+    }
+    const path = `${fileMapper_1.FILE_MAPPER_API_PATH}/${analyticsEndpoint}`;
+    const accountConfig = accountId && (0, config_1.getAccountConfig)(accountId);
+    if (accountConfig && accountConfig.authType === 'personalaccesskey') {
+        (0, logger_1.debug)(`${i18nKey}.sendingEventAuthenticated`);
+        return http_1.default.post(accountId, {
+            url: `${path}/authenticated`,
+            body: usageEvent,
+            resolveWithFullResponse: true,
+        });
+    }
+    const env = (0, config_1.getEnv)(accountId);
+    (0, logger_1.debug)(`${i18nKey}.sendingEventUnauthenticated`);
+    http_1.default.post(accountId, {
+        env,
+        url: path,
+        body: usageEvent,
+        resolveWithFullResponse: true,
+    });
+}
+exports.trackUsage = trackUsage;

package/lib/validate.d.ts

@@ -0,0 +1,2 @@
+import { LintResult } from '../types/HublValidation';
+export declare function lint(accountId: number, filepath: string, callback?: (lintResult: LintResult) => number): Promise<Array<Partial<LintResult>> | void>;

package/lib/validate.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lint = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const extensions_1 = require("../constants/extensions");
+const validateHubl_1 = require("../api/validateHubl");
+const fs_1 = require("../lib/fs");
+const path_1 = require("../lib/path");
+async function lint(accountId, filepath, callback) {
+    const stats = await fs_extra_1.default.stat(filepath);
+    const files = stats.isDirectory() ? await (0, fs_1.walk)(filepath) : [filepath];
+    if (!(files && files.length)) {
+        return [];
+    }
+    return Promise.all(files
+        .filter(file => extensions_1.HUBL_EXTENSIONS.has((0, path_1.getExt)(file)))
+        .map(async (file) => {
+        const source = await fs_extra_1.default.readFile(file, { encoding: 'utf8' });
+        if (!(source && source.trim())) {
+            const result = { file, validation: null };
+            if (callback) {
+                callback(result);
+            }
+            return result;
+        }
+        const validation = await (0, validateHubl_1.validateHubl)(accountId, source);
+        const result = {
+            file,
+            validation,
+        };
+        if (callback) {
+            callback(result);
+        }
+        return result;
+    }));
+}
+exports.lint = lint;

package/models/OAuth2Manager.d.ts

@@ -0,0 +1,34 @@
+import { FlatAccountFields, OAuthAccount, TokenInfo } from '../types/Accounts';
+type WriteTokenInfoFunction = (tokenInfo: TokenInfo) => void;
+type RefreshTokenResponse = {
+    refresh_token: string;
+    access_token: string;
+    expires_in: string;
+};
+type ExchangeProof = {
+    grant_type: string;
+    client_id?: string;
+    client_secret?: string;
+    refresh_token?: string;
+};
+declare class OAuth2Manager {
+    account: OAuthAccount;
+    writeTokenInfo: WriteTokenInfoFunction;
+    refreshTokenRequest: Promise<RefreshTokenResponse> | null;
+    constructor(account: OAuthAccount, writeTokenInfo: WriteTokenInfoFunction);
+    accessToken(): Promise<string | undefined>;
+    fetchAccessToken(exchangeProof: ExchangeProof): Promise<void>;
+    exchangeForTokens(exchangeProof: ExchangeProof): Promise<void>;
+    refreshAccessToken(): Promise<void>;
+    toObj(): {
+        environment: "prod" | "qa";
+        clientSecret: string | undefined;
+        clientId: string | undefined;
+        scopes: string[] | undefined;
+        tokenInfo: TokenInfo | undefined;
+        name: string | undefined;
+        accountId: number;
+    };
+    static fromConfig(accountConfig: FlatAccountFields, writeTokenInfo: WriteTokenInfoFunction): OAuth2Manager;
+}
+export default OAuth2Manager;

package/models/OAuth2Manager.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const moment_1 = __importDefault(require("moment"));
+const environments_1 = require("../constants/environments");
+const urls_1 = require("../lib/urls");
+const environment_1 = require("../lib/environment");
+const logger_1 = require("../utils/logger");
+const getAccountIdentifier_1 = require("../utils/getAccountIdentifier");
+const auth_1 = require("../constants/auth");
+const standardErrors_1 = require("../errors/standardErrors");
+const i18nKey = 'models.OAuth2Manager';
+class OAuth2Manager {
+    account;
+    writeTokenInfo;
+    refreshTokenRequest;
+    constructor(account, writeTokenInfo) {
+        this.account = account;
+        this.writeTokenInfo = writeTokenInfo;
+        this.refreshTokenRequest = null;
+    }
+    async accessToken() {
+        if (!this.account.auth.tokenInfo?.refreshToken) {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.missingRefreshToken`, {
+                accountId: (0, getAccountIdentifier_1.getAccountIdentifier)(this.account),
+            });
+        }
+        if (!this.account.auth.tokenInfo?.accessToken ||
+            (0, moment_1.default)()
+                .add(5, 'minutes')
+                .isAfter((0, moment_1.default)(this.account.auth?.tokenInfo.expiresAt))) {
+            await this.refreshAccessToken();
+        }
+        return this.account.auth?.tokenInfo.accessToken;
+    }
+    async fetchAccessToken(exchangeProof) {
+        (0, logger_1.debug)(`${i18nKey}.fetchingAccessToken`, {
+            accountId: (0, getAccountIdentifier_1.getAccountIdentifier)(this.account),
+            clientId: this.account.auth.clientId || '',
+        });
+        try {
+            const { data } = await axios_1.default.post(`${(0, urls_1.getHubSpotApiOrigin)((0, environment_1.getValidEnv)(this.account.env))}/oauth/v1/token`, {
+                form: exchangeProof,
+                json: true,
+            });
+            this.refreshTokenRequest = data;
+            const { refresh_token: refreshToken, access_token: accessToken, expires_in: expiresIn, } = data;
+            if (!this.account.auth.tokenInfo) {
+                this.account.auth.tokenInfo = {};
+            }
+            this.account.auth.tokenInfo.refreshToken = refreshToken;
+            this.account.auth.tokenInfo.accessToken = accessToken;
+            this.account.auth.tokenInfo.expiresAt = (0, moment_1.default)()
+                .add(Math.round(parseInt(expiresIn) * 0.75), 'seconds')
+                .toString();
+            if (this.writeTokenInfo) {
+                (0, logger_1.debug)(`${i18nKey}.updatingTokenInfo`, {
+                    accountId: (0, getAccountIdentifier_1.getAccountIdentifier)(this.account),
+                    clientId: this.account.auth.clientId || '',
+                });
+                this.writeTokenInfo(this.account.auth.tokenInfo);
+            }
+            this.refreshTokenRequest = null;
+        }
+        catch (e) {
+            this.refreshTokenRequest = null;
+            (0, standardErrors_1.throwError)(e);
+        }
+    }
+    async exchangeForTokens(exchangeProof) {
+        try {
+            if (this.refreshTokenRequest) {
+                (0, logger_1.debug)(`${i18nKey}.refreshingAccessToken`, {
+                    accountId: (0, getAccountIdentifier_1.getAccountIdentifier)(this.account),
+                    clientId: this.account.auth.clientId || '',
+                });
+                await this.refreshTokenRequest;
+            }
+            else {
+                await this.fetchAccessToken(exchangeProof);
+            }
+        }
+        catch (e) {
+            const error = e;
+            if (error.response) {
+                (0, standardErrors_1.throwAuthErrorWithMessage)(`${i18nKey}.auth`, {
+                    token: error.response.body.message || '',
+                }, error);
+            }
+            else {
+                (0, standardErrors_1.throwError)(error);
+            }
+        }
+    }
+    async refreshAccessToken() {
+        const refreshTokenProof = {
+            grant_type: 'refresh_token',
+            client_id: this.account.auth.clientId,
+            client_secret: this.account.auth.clientSecret,
+            refresh_token: this.account.auth.tokenInfo?.refreshToken,
+        };
+        await this.exchangeForTokens(refreshTokenProof);
+    }
+    toObj() {
+        return {
+            environment: this.account.env ? environments_1.ENVIRONMENTS.QA : environments_1.ENVIRONMENTS.PROD,
+            clientSecret: this.account.auth.clientSecret,
+            clientId: this.account.auth.clientId,
+            scopes: this.account.auth.scopes,
+            tokenInfo: this.account.auth.tokenInfo,
+            name: this.account.name,
+            accountId: (0, getAccountIdentifier_1.getAccountIdentifier)(this.account),
+        };
+    }
+    static fromConfig(accountConfig, writeTokenInfo) {
+        return new OAuth2Manager({
+            ...accountConfig,
+            authType: auth_1.AUTH_METHODS.oauth.value,
+            auth: accountConfig.auth || {},
+        }, writeTokenInfo);
+    }
+}
+exports.default = OAuth2Manager;

package/package.json

@@ -1,8 +1,8 @@
 {
     "name": "@hubspot/local-dev-lib",
-    "version": "0.0.4",
+    "version": "0.0.6",
     "description": "Provides library functionality for HubSpot local development tooling, including the HubSpot CLI",
-    "main": "dist/index.js",
+    "main": "lib/index.js",
     "repository": {
         "type": "git",
         "url": "https://github.com/HubSpot/hubspot-local-dev-lib"
@@ -12,28 +12,32 @@
         "access": "public"
     },
     "scripts": {
-        "build": "tsc --rootDir . --outdir dist",
+        "build": "rm -rf ./dist/ && tsc --rootDir . --outdir dist && yarn copy-files",
         "check-main": "branch=$(git rev-parse --abbrev-ref HEAD) && [ $branch = main ] || (echo 'Error: New release can only be published on main branch' && exit 1)",
+        "copy-files": "cp -r lang dist/lang",
         "lint": "eslint --max-warnings=0 . && prettier --check ./**/*.ts",
         "local-dev": "yarn build && cd dist && yarn link && cd .. && tsc --watch --rootDir . --outdir dist",
-        "_postinstall": "husky install",
+        "postinstall": "husky install",
         "prepack": "pinst --disable",
         "postpack": "pinst --enable",
-        "prettier:write": "prettier --write ./**/*.{js,json}",
+        "prettier:write": "prettier --write ./**/*.{ts,js,json}",
         "pub": "cd dist && npm publish --tag latest && cd ..",
         "push": "git push --atomic origin main v$npm_package_version",
         "release:major": "yarn check-main && yarn version --major && yarn build && yarn pub && yarn push",
         "release:minor": "yarn check-main && yarn version --minor && yarn build && yarn pub && yarn push",
         "release:patch": "yarn check-main && yarn version --patch && yarn build && yarn pub && yarn push",
-        "test": "jest"
+        "test": "jest --silent"
     },
     "license": "Apache-2.0",
     "devDependencies": {
+        "@types/content-disposition": "^0.5.5",
+        "@types/debounce": "^1.2.1",
         "@types/findup-sync": "^4.0.2",
         "@types/fs-extra": "^11.0.1",
         "@types/jest": "^29.5.0",
         "@types/js-yaml": "^4.0.5",
         "@types/node": "^18.14.2",
+        "@types/prettier": "^3.0.0",
         "@types/unixify": "^1.0.0",
         "@typescript-eslint/eslint-plugin": "^5.54.0",
         "@typescript-eslint/parser": "^5.59.7",
@@ -41,27 +45,35 @@
         "husky": "^8.0.0",
         "jest": "^29.5.0",
         "pinst": "^3.0.0",
-        "prettier": "^2.8.4",
         "ts-jest": "^29.0.5",
         "typescript": "^4.9.5"
     },
     "exports": {
-        ".": "./lib/index.js",
-        "./cms": "./lib/cms",
-        "./constants": "./constants",
-        "./github": "./lib/github.js",
-        "./path": "./lib/path.js"
+        "./*": "./lib/*.js",
+        "./api/*": "./api/*.js",
+        "./errors/*": "./errors/*.js",
+        "./http": "./http/index.js",
+        "./config": "./config/index.js",
+        "./constants/*": "./constants/*.js",
+        "./logger": "./lib/logging/logger.js"
     },
     "dependencies": {
         "axios": "^1.3.5",
+        "chokidar": "^3.5.3",
+        "content-disposition": "^0.5.4",
         "extract-zip": "^2.0.1",
         "findup-sync": "^5.0.0",
         "fs-extra": "^11.1.0",
+        "ignore": "^5.1.4",
         "js-yaml": "^4.1.0",
         "moment": "^2.29.4",
+        "p-queue": "^6.0.2",
+        "prettier": "^3.0.3",
+        "semver": "^6.3.0",
+        "table": "^6.8.1",
         "unixify": "^1.0.0"
     },
     "engines": {
-        "node": ">=18.0.0"
+        "node": ">=16.20.0"
     }
 }