@hubspot/cli 8.0.10-experimental.6 → 8.0.11-experimental.0

package/lib/npm/packageJson.d.ts

@@ -0,0 +1,24 @@
+import type { PackageJson } from '../../types/PackageJson.js';
+export interface PackageJsonWithMetadata {
+    packageJsonFilename: string;
+    packageRootDirectory: string;
+    packageJson: PackageJson;
+}
+/**
+ * Reads and parses a package.json file, with caching.
+ *
+ * @param packageJsonPath - Absolute path to the package.json file
+ * @returns The parsed PackageJson object, or null if the file doesn't exist or is invalid
+ */
+export declare const safeGetPackageJsonCached: (packageJsonPath: string) => PackageJson | null;
+/**
+ * Clears all cached package.json data and file paths.
+ * Use this when package.json files may have been modified externally.
+ */
+export declare const clearPackageJsonCache: () => void;
+/**
+ * Finds all package.json files in the project, with caching.
+ *
+ * @returns Array of absolute paths to package.json files in the project
+ */
+export declare function findAllPackageJsonFilesInProjectCached(): Promise<string[]>;

package/lib/npm/packageJson.js

@@ -0,0 +1,102 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { walk } from '@hubspot/local-dev-lib/fs';
+import { getProjectConfig } from '../projects/config.js';
+const packageJsonCache = new Map();
+const packageJsonFilesCache = new Map();
+const safeReadTextFile = (filePath) => {
+    try {
+        return fs.readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+};
+const safeReadJsonFile = (filePath) => {
+    const text = safeReadTextFile(filePath);
+    if (text === null) {
+        return null;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+};
+const safeReadPackageJsonWithMetadataUncached = (packageJsonPath) => {
+    const manifest = safeReadJsonFile(packageJsonPath);
+    if (!manifest) {
+        return null;
+    }
+    return {
+        packageJsonFilename: packageJsonPath,
+        packageRootDirectory: path.dirname(packageJsonPath),
+        packageJson: manifest,
+    };
+};
+const safeReadPackageJsonWithMetadataCached = (packageJsonPath) => {
+    const maybeCachedPackageJsonWithMetadata = packageJsonCache.get(packageJsonPath);
+    if (maybeCachedPackageJsonWithMetadata !== undefined) {
+        return maybeCachedPackageJsonWithMetadata;
+    }
+    // If not cached, read the package.json file and cache the result.
+    const packageJsonWithMetadata = safeReadPackageJsonWithMetadataUncached(packageJsonPath);
+    packageJsonCache.set(packageJsonPath, packageJsonWithMetadata);
+    return packageJsonWithMetadata;
+};
+/**
+ * Reads and parses a package.json file, with caching.
+ *
+ * @param packageJsonPath - Absolute path to the package.json file
+ * @returns The parsed PackageJson object, or null if the file doesn't exist or is invalid
+ */
+export const safeGetPackageJsonCached = (packageJsonPath) => {
+    const maybePackageJsonWithMetadata = safeReadPackageJsonWithMetadataCached(packageJsonPath);
+    return maybePackageJsonWithMetadata?.packageJson || null;
+};
+/**
+ * Clears all cached package.json data and file paths.
+ * Use this when package.json files may have been modified externally.
+ */
+export const clearPackageJsonCache = () => {
+    packageJsonCache.clear();
+    packageJsonFilesCache.clear();
+};
+const findAllPackageJsonFilesInDirectoryUncached = async (directory) => {
+    const packageJsonFiles = (await walk(directory)).filter(file => file.includes('package.json') &&
+        !file.includes('node_modules') &&
+        !file.includes('.vite'));
+    return packageJsonFiles;
+};
+/**
+ * Finds all package.json files in a directory recursively, with caching.
+ * Excludes files in node_modules and .vite directories.
+ *
+ * @param directory - Root directory to search from
+ * @returns Array of absolute paths to package.json files
+ */
+const findAllPackageJsonFilesInDirectoryCached = async (directory) => {
+    const maybeCachedPackageJsonFiles = packageJsonFilesCache.get(directory);
+    if (maybeCachedPackageJsonFiles) {
+        return maybeCachedPackageJsonFiles;
+    }
+    // If not cached, find all package.json files in the directory and cache the result.
+    const packageJsonFiles = await findAllPackageJsonFilesInDirectoryUncached(directory);
+    packageJsonFilesCache.set(directory, packageJsonFiles);
+    return packageJsonFiles;
+};
+/**
+ * Finds all package.json files in the project, with caching.
+ *
+ * @returns Array of absolute paths to package.json files in the project
+ */
+export async function findAllPackageJsonFilesInProjectCached() {
+    const projectConfig = await getProjectConfig();
+    const { projectDir } = projectConfig;
+    if (!projectDir) {
+        return [];
+    }
+    const packageJsonFiles = await findAllPackageJsonFilesInDirectoryCached(projectDir);
+    return packageJsonFiles;
+}

package/lib/npm/workspaces.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Finds the npm workspace root directory that contains the given package location, with caching.
+ *
+ * Searches through all package.json files in the project to find one that defines
+ * workspaces (via the "workspaces" field) and includes the specified directory
+ * within those workspace patterns.
+ *
+ * @param targetPackageDirectory - The absolute path to the package directory to find the workspace root for
+ * @returns The absolute path to the workspace root directory, or null if the package is not part of any workspace
+ *
+ */
+export declare const getNpmWorkspaceDirectoryForPackageAtLocationCached: (targetPackageDirectory: string) => Promise<string | null>;

package/lib/npm/workspaces.js

@@ -0,0 +1,48 @@
+import { minimatch } from 'minimatch';
+import path from 'path';
+import { safeGetPackageJsonCached, findAllPackageJsonFilesInProjectCached, } from './packageJson.js';
+/**
+ * Checks if a package directory matches any of the workspace glob patterns.
+ *
+ * @param directory - The absolute path to the package directory to check
+ * @param workspaceRoot - The absolute path to the workspace root directory
+ * @param workspaces - Array of glob patterns defining workspace locations (e.g., ['packages/*', 'apps/*'])
+ * @returns True if the directory matches any workspace pattern, false otherwise
+ */
+const isPackageLocationInWorkspaces = (directory, workspaceRoot, workspaces) => {
+    const relativePath = path.relative(workspaceRoot, directory);
+    return workspaces.some(workspace => minimatch(relativePath, workspace));
+};
+/**
+ * Finds the npm workspace root directory that contains the given package location, with caching.
+ *
+ * Searches through all package.json files in the project to find one that defines
+ * workspaces (via the "workspaces" field) and includes the specified directory
+ * within those workspace patterns.
+ *
+ * @param targetPackageDirectory - The absolute path to the package directory to find the workspace root for
+ * @returns The absolute path to the workspace root directory, or null if the package is not part of any workspace
+ *
+ */
+export const getNpmWorkspaceDirectoryForPackageAtLocationCached = async (targetPackageDirectory) => {
+    const allPackageJsonFilesInProject = await findAllPackageJsonFilesInProjectCached();
+    if (allPackageJsonFilesInProject.length === 0) {
+        return null;
+    }
+    for (const currentPackageJsonFile of allPackageJsonFilesInProject) {
+        const packageJson = safeGetPackageJsonCached(currentPackageJsonFile);
+        const workspaces = packageJson?.workspaces;
+        if (!Array.isArray(workspaces) || workspaces.length === 0) {
+            // If the package.json file does not define any workspaces, skip it, since
+            // it cannot be an npm workspace root.
+            continue;
+        }
+        // We found a package.json file that defines workspaces, so we can now check if the given
+        // directory is part of any of the workspace patterns.
+        const currentPackageDirectory = path.dirname(currentPackageJsonFile);
+        if (isPackageLocationInWorkspaces(targetPackageDirectory, currentPackageDirectory, workspaces)) {
+            return currentPackageDirectory;
+        }
+    }
+    return null;
+};

package/lib/oauth.d.ts

@@ -0,0 +1,2 @@
+import { OAuthConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
+export declare function authenticateWithOauth(accountConfig: OAuthConfigAccount): Promise<void>;

package/lib/oauth.js

@@ -0,0 +1,93 @@
+import express from 'express';
+import open from 'open';
+import { OAuth2Manager } from '@hubspot/local-dev-lib/models/OAuth2Manager';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
+import { addOauthToAccountConfig } from '@hubspot/local-dev-lib/oauth';
+import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
+import { uiLogger } from './ui/logger.js';
+import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
+import { DEFAULT_OAUTH_SCOPES } from '@hubspot/local-dev-lib/constants/auth';
+import { handleExit } from './process.js';
+import { lib } from '../lang/en.js';
+const PORT = 3000;
+const redirectUri = `http://localhost:${PORT}/oauth-callback`;
+function buildAuthUrl(oauthManager) {
+    const { env: accountEnv, auth } = oauthManager.account;
+    const env = accountEnv || ENVIRONMENTS.PROD;
+    const scopes = auth.scopes.length > 0 ? auth.scopes : DEFAULT_OAUTH_SCOPES;
+    if (!auth.clientId) {
+        throw new Error(lib.oauth.missingClientId);
+    }
+    return (`${getHubSpotWebsiteOrigin(env)}/oauth/${oauthManager.account.accountId}/authorize` +
+        `?client_id=${encodeURIComponent(auth.clientId)}` + // app's client ID
+        `&scope=${encodeURIComponent(scopes.join(' '))}` + // scopes being requested by the app
+        `&redirect_uri=${encodeURIComponent(redirectUri)}` // where to send the user after the consent page
+    );
+}
+function handleServerOnProcessEnd(server) {
+    const shutdownServerIfRunning = () => {
+        server?.close();
+    };
+    handleExit(shutdownServerIfRunning);
+}
+async function authorize(oauthManager) {
+    if (process.env.BROWSER !== 'none') {
+        open(buildAuthUrl(oauthManager), { url: true });
+    }
+    // eslint-disable-next-line no-async-promise-executor
+    return new Promise(async (resolve, reject) => {
+        let server;
+        const app = express();
+        app.get('/oauth-callback', async (req, res) => {
+            if (req.query.code) {
+                const authCodeProof = {
+                    grant_type: 'authorization_code',
+                    client_id: oauthManager.account.auth.clientId,
+                    client_secret: oauthManager.account.auth.clientSecret,
+                    redirect_uri: redirectUri,
+                    code: req.query.code,
+                };
+                try {
+                    await oauthManager.exchangeForTokens(authCodeProof);
+                    res.send(`
+          <body>
+            <h2>Authorization succeeded (you can close this page)</h2>
+          </body>
+          `);
+                }
+                catch (e) {
+                    res.send(`
+          <body>
+            <h2>Authorization failed (you can close this page)</h2>
+          </body>
+          `);
+                }
+            }
+            if (server) {
+                server.close();
+                server = null;
+            }
+            if (req.query.code) {
+                resolve();
+            }
+            else {
+                reject();
+            }
+        });
+        server = app.listen(PORT, () => uiLogger.log(`Waiting for authorization...`));
+        handleServerOnProcessEnd(server);
+    });
+}
+function setupOauth(accountConfig) {
+    const config = getConfigAccountById(accountConfig.accountId);
+    return new OAuth2Manager({
+        ...accountConfig,
+        env: accountConfig.env || config?.env || ENVIRONMENTS.PROD,
+    });
+}
+export async function authenticateWithOauth(accountConfig) {
+    const oauthManager = setupOauth(accountConfig);
+    uiLogger.log('Authorizing');
+    await authorize(oauthManager);
+    addOauthToAccountConfig(oauthManager);
+}

package/lib/parsing.d.ts

@@ -0,0 +1 @@
+export declare function parseStringToNumber(maybeNumber: string): number;

package/lib/parsing.js

@@ -0,0 +1,8 @@
+import { lib } from '../lang/en.js';
+export function parseStringToNumber(maybeNumber) {
+    const result = parseInt(maybeNumber, 10);
+    if (Number.isNaN(result) || !/^-?\d+$/.test(maybeNumber)) {
+        throw new Error(lib.parsing.unableToParseStringToNumber);
+    }
+    return result;
+}

package/lib/polling.d.ts

@@ -0,0 +1,21 @@
+import { HubSpotPromise } from '@hubspot/local-dev-lib/types/Http';
+export declare const DEFAULT_POLLING_STATES: {
+    readonly STARTED: "STARTED";
+    readonly SUCCESS: "SUCCESS";
+    readonly ERROR: "ERROR";
+    readonly REVERTED: "REVERTED";
+    readonly FAILURE: "FAILURE";
+};
+export declare const DEFAULT_POLLING_STATUS_LOOKUP: {
+    successStates: "SUCCESS"[];
+    errorStates: ("FAILURE" | "ERROR" | "REVERTED")[];
+};
+type GenericPollingResponse = {
+    status: string;
+};
+type PollingCallback<T extends GenericPollingResponse> = () => HubSpotPromise<T>;
+export declare function poll<T extends GenericPollingResponse>(callback: PollingCallback<T>, statusLookup?: {
+    successStates: string[];
+    errorStates: string[];
+}, timeoutMs?: number): Promise<T>;
+export {};

package/lib/polling.js

@@ -0,0 +1,48 @@
+import { DEFAULT_POLLING_DELAY } from './constants.js';
+import { lib } from '../lang/en.js';
+export const DEFAULT_POLLING_STATES = {
+    STARTED: 'STARTED',
+    SUCCESS: 'SUCCESS',
+    ERROR: 'ERROR',
+    REVERTED: 'REVERTED',
+    FAILURE: 'FAILURE',
+};
+export const DEFAULT_POLLING_STATUS_LOOKUP = {
+    successStates: [DEFAULT_POLLING_STATES.SUCCESS],
+    errorStates: [
+        DEFAULT_POLLING_STATES.ERROR,
+        DEFAULT_POLLING_STATES.REVERTED,
+        DEFAULT_POLLING_STATES.FAILURE,
+    ],
+};
+export function poll(callback, statusLookup = DEFAULT_POLLING_STATUS_LOOKUP, timeoutMs = 60000 // Default 60 second timeout
+) {
+    return new Promise((resolve, reject) => {
+        const pollInterval = setInterval(async () => {
+            try {
+                const { data: pollResp } = await callback();
+                const { status } = pollResp;
+                if (statusLookup.successStates.includes(status)) {
+                    clearInterval(pollInterval);
+                    clearTimeout(timeoutId);
+                    resolve(pollResp);
+                }
+                else if (statusLookup.errorStates.includes(status)) {
+                    clearInterval(pollInterval);
+                    clearTimeout(timeoutId);
+                    reject(pollResp);
+                }
+            }
+            catch (error) {
+                clearInterval(pollInterval);
+                clearTimeout(timeoutId);
+                reject(error);
+            }
+        }, DEFAULT_POLLING_DELAY);
+        // Set a timeout to stop polling after specified duration
+        const timeoutId = setTimeout(() => {
+            clearInterval(pollInterval);
+            reject(new Error(lib.polling.timeoutError(timeoutMs)));
+        }, timeoutMs);
+    });
+}

package/lib/process.d.ts

@@ -0,0 +1,13 @@
+interface KeyPress {
+    ctrl?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+    meta?: boolean;
+    name?: string;
+}
+export declare const TERMINATION_SIGNALS: string[];
+export declare function handleExit(callback: (onTerminate: {
+    isSIGHUP: boolean;
+}) => void): void;
+export declare function handleKeypress(callback: (onKeyPress: KeyPress) => void): void;
+export {};

package/lib/process.js

@@ -0,0 +1,56 @@
+import readline from 'readline';
+import { setLogLevel, LOG_LEVEL } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from './ui/logger.js';
+import { lib } from '../lang/en.js';
+import { logError } from './errorHandlers/index.js';
+const SIGHUP = 'SIGHUP';
+const uncaughtException = 'uncaughtException';
+export const TERMINATION_SIGNALS = [
+    'beforeExit',
+    'SIGINT', // Terminal trying to interrupt (Ctrl + C)
+    'SIGUSR1', // Start Debugger User-defined signal 1
+    'SIGUSR2', // User-defined signal 2
+    uncaughtException,
+    'SIGTERM', // Represents a graceful termination
+    SIGHUP, // Parent terminal has been closed
+];
+export function handleExit(callback) {
+    let exitInProgress = false;
+    TERMINATION_SIGNALS.forEach(signal => {
+        process.removeAllListeners(signal);
+        process.on(signal, async (...args) => {
+            // Prevent duplicate exit handling
+            if (!exitInProgress) {
+                exitInProgress = true;
+                const isSIGHUP = signal === SIGHUP;
+                // Prevent logs when terminal closes
+                if (isSIGHUP) {
+                    setLogLevel(LOG_LEVEL.NONE);
+                }
+                uiLogger.debug(lib.process.exitDebug(signal));
+                if (signal === uncaughtException && args && args.length > 0) {
+                    try {
+                        logError(args[0]);
+                    }
+                    catch (e) {
+                        uiLogger.error(String(args[0]));
+                    }
+                }
+                await callback({ isSIGHUP });
+            }
+        });
+    });
+}
+export function handleKeypress(callback) {
+    readline.createInterface(process.stdin, process.stdout);
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+    }
+    process.stdin.removeAllListeners('keypress');
+    process.stdin.on('keypress', (str, key) => {
+        if (key) {
+            callback(key);
+        }
+    });
+}

package/lib/projects/ProjectLogsManager.d.ts

@@ -0,0 +1,29 @@
+import { ProjectConfig } from '../../types/Projects.js';
+type FunctionInfo = {
+    componentName: string;
+    appId: number;
+    endpoint?: {
+        path: string;
+    };
+};
+declare class _ProjectLogsManager {
+    projectName: string | undefined;
+    projectConfig: ProjectConfig | undefined;
+    projectId: number | undefined;
+    accountId: number | undefined;
+    functions: FunctionInfo[];
+    selectedFunction: FunctionInfo | undefined;
+    functionName: string | undefined;
+    appId: number | undefined;
+    isPublicFunction: boolean | undefined;
+    endpointName: string | undefined;
+    reset(): void;
+    constructor();
+    init(accountId: number): Promise<void>;
+    fetchFunctionDetails(): Promise<void>;
+    fetchFunctionDetailsV2(deployedBuildId: number): Promise<void>;
+    getFunctionNames(): string[];
+    setFunction(functionName?: string): void;
+}
+export declare const ProjectLogsManager: _ProjectLogsManager;
+export {};

package/lib/projects/ProjectLogsManager.js

@@ -0,0 +1,155 @@
+import { getProjectConfig } from './config.js';
+import { ensureProjectExists } from './ensureProjectExists.js';
+import { fetchProjectComponentsMetadata } from '@hubspot/local-dev-lib/api/projects';
+import { fetchAppMetadataBySourceId } from '@hubspot/local-dev-lib/api/appsDev';
+import { uiLogger } from '../ui/logger.js';
+import { commands } from '../../lang/en.js';
+import { isV2Project } from './platformVersion.js';
+import { getDeployedProjectNodes } from './localDev/helpers/project.js';
+import { debugError } from '../errorHandlers/index.js';
+class _ProjectLogsManager {
+    projectName;
+    projectConfig;
+    projectId;
+    accountId;
+    functions;
+    selectedFunction;
+    functionName;
+    appId;
+    isPublicFunction;
+    endpointName;
+    reset() {
+        this.projectName = undefined;
+        this.projectConfig = undefined;
+        this.projectId = undefined;
+        this.accountId = undefined;
+        this.functions = [];
+        this.selectedFunction = undefined;
+        this.functionName = undefined;
+        this.appId = undefined;
+        this.isPublicFunction = undefined;
+        this.endpointName = undefined;
+    }
+    constructor() {
+        this.functions = [];
+    }
+    async init(accountId) {
+        const { projectConfig } = await getProjectConfig();
+        if (!projectConfig || !projectConfig.name) {
+            throw new Error(commands.project.logs.errors.noProjectConfig);
+        }
+        this.projectConfig = projectConfig;
+        this.projectName = projectConfig.name;
+        this.accountId = accountId;
+        this.functions = [];
+        const { project } = await ensureProjectExists(this.accountId, this.projectName, {
+            allowCreate: false,
+        });
+        if (!project ||
+            !project.deployedBuild ||
+            !project.deployedBuild.subbuildStatuses) {
+            throw new Error(commands.project.logs.errors.failedToFetchProjectDetails);
+        }
+        this.projectId = project.id;
+        if (isV2Project(projectConfig.platformVersion)) {
+            const deployedBuildId = project.deployedBuild.buildId;
+            if (!deployedBuildId) {
+                throw new Error(commands.project.logs.errors.noDeployedBuild);
+            }
+            await this.fetchFunctionDetailsV2(deployedBuildId);
+        }
+        else {
+            await this.fetchFunctionDetails();
+        }
+    }
+    async fetchFunctionDetails() {
+        if (!this.projectId) {
+            throw new Error(commands.project.logs.errors.noProjectConfig);
+        }
+        if (!this.accountId) {
+            uiLogger.debug(commands.project.logs.errors.projectLogsManagerNotInitialized);
+            throw new Error(commands.project.logs.errors.generic);
+        }
+        const { data: { topLevelComponentMetadata }, } = await fetchProjectComponentsMetadata(this.accountId, this.projectId);
+        const apps = topLevelComponentMetadata.filter(componentMetadata => {
+            const { type } = componentMetadata;
+            return type && type.name === 'PRIVATE_APP';
+        });
+        apps.forEach(app => {
+            const appFunctions = app.featureComponents.filter(component => component.type.name === 'APP_FUNCTION');
+            appFunctions.forEach(fn => {
+                if (fn.deployOutput) {
+                    this.functions.push({
+                        componentName: fn.componentName,
+                        appId: fn.deployOutput.appId,
+                        endpoint: fn.deployOutput.endpoint,
+                    });
+                }
+            });
+        });
+        if (this.functions.length === 0) {
+            throw new Error(commands.project.logs.errors.noFunctionsInProject);
+        }
+    }
+    async fetchFunctionDetailsV2(deployedBuildId) {
+        if (!this.projectId || !this.accountId || !this.projectConfig) {
+            uiLogger.debug(commands.project.logs.errors.projectLogsManagerNotInitialized);
+            throw new Error(commands.project.logs.errors.generic);
+        }
+        let deployedNodes;
+        try {
+            deployedNodes = await getDeployedProjectNodes(this.projectConfig, this.accountId, deployedBuildId);
+        }
+        catch (err) {
+            debugError(err);
+            throw new Error(commands.project.logs.errors.failedToFetchProjectDetails);
+        }
+        const appNode = Object.values(deployedNodes).find(node => node.componentType === 'APPLICATION');
+        if (!appNode) {
+            throw new Error(commands.project.logs.errors.noFunctionsInProject);
+        }
+        let appId;
+        try {
+            const { data: appMetadata } = await fetchAppMetadataBySourceId(this.projectId, appNode.uid, this.accountId);
+            appId = appMetadata.id;
+        }
+        catch (err) {
+            debugError(err);
+            throw new Error(commands.project.logs.errors.failedToFetchProjectDetails);
+        }
+        const functionNodes = Object.values(deployedNodes).filter(node => node.componentType === 'APP_FUNCTION');
+        for (const fnNode of functionNodes) {
+            const config = fnNode.config;
+            this.functions.push({
+                componentName: fnNode.uid,
+                appId,
+                endpoint: config.endpoint,
+            });
+        }
+        if (this.functions.length === 0) {
+            throw new Error(commands.project.logs.errors.noFunctionsInProject);
+        }
+    }
+    getFunctionNames() {
+        return this.functions.map(serverlessFunction => serverlessFunction.componentName);
+    }
+    setFunction(functionName) {
+        if (!functionName || this.functions.length === 0) {
+            throw new Error(commands.project.logs.errors.noFunctionsInProject);
+        }
+        this.selectedFunction = this.functions.find(serverlessFunction => serverlessFunction.componentName === functionName);
+        if (!this.selectedFunction) {
+            throw new Error(commands.project.logs.errors.noFunctionWithName(functionName));
+        }
+        this.functionName = functionName;
+        this.appId = this.selectedFunction.appId;
+        if (this.selectedFunction.endpoint) {
+            this.endpointName = this.selectedFunction.endpoint.path;
+            this.isPublicFunction = true;
+        }
+        else {
+            this.isPublicFunction = false;
+        }
+    }
+}
+export const ProjectLogsManager = new _ProjectLogsManager();

package/lib/projects/__tests__/AppDevModeInterface.test.d.ts

@@ -0,0 +1 @@
+export {};