@hubspot/cli 7.10.0-beta.1 → 7.10.0-experimental.0

package/lib/projects/localDev/AppDevModeInterface.js

@@ -1,6 +1,6 @@
 import { fetchAppInstallationData } from '@hubspot/local-dev-lib/api/localDevAuth';
 import { fetchAppMetadataByUid, fetchPublicAppProductionInstallCounts, installStaticAuthAppOnTestAccount, } from '@hubspot/local-dev-lib/api/appsDev';
-import { getAccountConfig } from '@hubspot/local-dev-lib/config';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
 import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, APP_INSTALLATION_STATES, LOCAL_DEV_SERVER_MESSAGE_TYPES, } from '../../constants.js';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
 import { isAppIRNode } from '../../projects/structure.js';
@@ -67,7 +67,7 @@ class AppDevModeInterface {
         return (this.appNode?.config.auth.type.toLowerCase() === APP_AUTH_TYPES.OAUTH);
     }
     isAutomaticallyInstallable() {
-        const targetTestingAccount = getAccountConfig(this.localDevState.targetTestingAccountId);
+        const targetTestingAccount = getConfigAccountById(this.localDevState.targetTestingAccountId);
         if (!targetTestingAccount) {
             return false;
         }

package/lib/projects/localDev/DevServerManager_DEPRECATED.js

@@ -2,7 +2,7 @@ import { logger } from '@hubspot/local-dev-lib/logger';
 import { DevModeInterface as UIEDevModeInterface } from '@hubspot/ui-extensions-dev-server';
 import { startPortManagerServer, stopPortManagerServer, requestPorts, } from '@hubspot/local-dev-lib/portManager';
 import { getHubSpotApiOrigin, getHubSpotWebsiteOrigin, } from '@hubspot/local-dev-lib/urls';
-import { getAccountConfig } from '@hubspot/local-dev-lib/config';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
 import { ComponentTypes, } from '../../../types/Projects.js';
 import { lib } from '../../../lang/en.js';
 import { uiLogger } from '../../ui/logger.js';
@@ -58,7 +58,7 @@ class DevServerManager_DEPRECATED {
     async setup({ components, onUploadRequired, accountId, setActiveApp, }) {
         this.componentsByType = this.arrangeComponentsByType(components);
         let env;
-        const accountConfig = getAccountConfig(accountId);
+        const accountConfig = getConfigAccountById(accountId);
         if (accountConfig) {
             env = accountConfig.env;
         }

package/lib/projects/localDev/DevSessionManager.d.ts

@@ -0,0 +1,17 @@
+import LocalDevState from './LocalDevState.js';
+import LocalDevLogger from './LocalDevLogger.js';
+type DevSessionManagerConstructorOptions = {
+    localDevState: LocalDevState;
+    localDevLogger: LocalDevLogger;
+};
+declare class DevSessionManager {
+    localDevState: LocalDevState;
+    localDevLogger: LocalDevLogger;
+    private _devSessionId;
+    private _heartbeatInterval;
+    constructor(options: DevSessionManagerConstructorOptions);
+    registerDevSession(): Promise<boolean>;
+    private initializeHeartbeat;
+    deleteDevSession(): Promise<boolean>;
+}
+export default DevSessionManager;

package/lib/projects/localDev/DevSessionManager.js

@@ -0,0 +1,56 @@
+import { getActiveServers } from '@hubspot/local-dev-lib/portManager';
+import { devSessionHeartbeat, registerDevSession, deleteDevSession, } from './helpers/devSessionsApi.js';
+class DevSessionManager {
+    localDevState;
+    localDevLogger;
+    _devSessionId;
+    _heartbeatInterval;
+    constructor(options) {
+        this.localDevState = options.localDevState;
+        this.localDevLogger = options.localDevLogger;
+        this._devSessionId = undefined;
+        this._heartbeatInterval = undefined;
+    }
+    async registerDevSession() {
+        try {
+            const activeServers = await getActiveServers();
+            const portData = Object.entries(activeServers).map(([serverId, port]) => ({ serverId, port }));
+            const registerDevSessionResponse = await registerDevSession(this.localDevState.targetTestingAccountId, portData);
+            this._devSessionId = registerDevSessionResponse.data.sessionId;
+        }
+        catch (e) {
+            this.localDevLogger.devSessionRegistrationError(e);
+            return false;
+        }
+        this.initializeHeartbeat();
+        return true;
+    }
+    initializeHeartbeat() {
+        this._heartbeatInterval = setInterval(() => {
+            if (!this._devSessionId) {
+                return;
+            }
+            try {
+                devSessionHeartbeat(this.localDevState.targetTestingAccountId, this._devSessionId);
+            }
+            catch (e) {
+                // TODO: What do we do if the heartbeat fails?
+                this.localDevLogger.devSessionHeartbeatError(e);
+            }
+        }, 30000);
+    }
+    async deleteDevSession() {
+        if (this._devSessionId) {
+            clearInterval(this._heartbeatInterval);
+            try {
+                await deleteDevSession(this.localDevState.targetProjectAccountId, this._devSessionId);
+            }
+            catch (e) {
+                this.localDevLogger.devSessionDeletionError(e);
+                return false;
+            }
+        }
+        return true;
+    }
+}
+export default DevSessionManager;

package/lib/projects/localDev/LocalDevLogger.d.ts

@@ -12,6 +12,9 @@ declare class LocalDevLogger {
     devServerSetupError(e: unknown): void;
     devServerStartError(e: unknown): void;
     devServerCleanupError(e: unknown): void;
+    devSessionRegistrationError(e: unknown): void;
+    devSessionHeartbeatError(e: unknown): void;
+    devSessionDeletionError(e: unknown): void;
     resetSpinnies(): void;
     startupMessage(): void;
     cleanupStart(): void;

package/lib/projects/localDev/LocalDevLogger.js

@@ -1,5 +1,5 @@
-import { getAccountId, hasLocalStateFlag } from '@hubspot/local-dev-lib/config';
-import { getConfigDefaultAccount } from '@hubspot/local-dev-lib/config';
+import { hasLocalStateFlag } from '@hubspot/local-dev-lib/config';
+import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
 import { uiLogger } from '../../ui/logger.js';
 import { uiLine, uiAccountDescription, uiCommandReference, } from '../../ui/index.js';
 import { lib } from '../../../lang/en.js';
@@ -30,9 +30,9 @@ class LocalDevLogger {
         uiLogger.error(langFunction(e instanceof Error ? e.message : ''));
     }
     getUploadCommand() {
-        const currentDefaultAccount = getConfigDefaultAccount() || undefined;
+        const currentDefaultAccount = getConfigDefaultAccountIfExists();
         return this.state.targetProjectAccountId !==
-            getAccountId(currentDefaultAccount)
+            currentDefaultAccount?.accountId
             ? uiCommandReference(`hs project upload --account=${this.state.targetProjectAccountId}`)
             : uiCommandReference('hs project upload');
     }
@@ -67,6 +67,15 @@ class LocalDevLogger {
     devServerCleanupError(e) {
         this.handleError(e, lib.LocalDevManager.devServer.cleanupError);
     }
+    devSessionRegistrationError(e) {
+        this.handleError(e, lib.LocalDevManager.devSession.registrationError);
+    }
+    devSessionHeartbeatError(e) {
+        this.handleError(e, lib.LocalDevManager.devSession.heartbeatError);
+    }
+    devSessionDeletionError(e) {
+        this.handleError(e, lib.LocalDevManager.devSession.deletionError);
+    }
     resetSpinnies() {
         SpinniesManager.stopAll();
         SpinniesManager.init();

package/lib/projects/localDev/LocalDevManager_DEPRECATED.js

@@ -3,7 +3,7 @@ import chokidar from 'chokidar';
 import chalk from 'chalk';
 import { fetchAppInstallationData } from '@hubspot/local-dev-lib/api/localDevAuth';
 import { fetchPublicAppsForPortal, fetchPublicAppProductionInstallCounts, } from '@hubspot/local-dev-lib/api/appsDev';
-import { getAccountId, getConfigDefaultAccount, } from '@hubspot/local-dev-lib/config';
+import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
 import { PROJECT_CONFIG_FILE } from '../../constants.js';
 import SpinniesManager from '../../ui/SpinniesManager.js';
 import DevServerManager_DEPRECATED from './DevServerManager_DEPRECATED.js';
@@ -200,8 +200,8 @@ class LocalDevManager {
         });
     }
     getUploadCommand() {
-        const currentDefaultAccount = getConfigDefaultAccount() || undefined;
-        return this.targetProjectAccountId !== getAccountId(currentDefaultAccount)
+        const currentDefaultAccount = getConfigDefaultAccountIfExists();
+        return this.targetProjectAccountId !== currentDefaultAccount?.accountId
             ? uiCommandReference(`hs project upload --account=${this.targetProjectAccountId}`)
             : uiCommandReference('hs project upload');
     }

package/lib/projects/localDev/LocalDevProcess.d.ts

@@ -7,6 +7,7 @@ declare class LocalDevProcess {
     private state;
     private _logger;
     private devServerManager;
+    private devSessionManager;
     constructor(options: LocalDevStateConstructorOptions);
     get projectDir(): string;
     get projectData(): Project;

package/lib/projects/localDev/LocalDevProcess.js

@@ -6,6 +6,7 @@ import open from 'open';
 import LocalDevState from './LocalDevState.js';
 import LocalDevLogger from './LocalDevLogger.js';
 import DevServerManager from './DevServerManager.js';
+import DevSessionManager from './DevSessionManager.js';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
 import { getProjectConfig } from '../config.js';
 import { handleProjectUpload } from '../upload.js';
@@ -20,6 +21,7 @@ class LocalDevProcess {
     state;
     _logger;
     devServerManager;
+    devSessionManager;
     constructor(options) {
         this.state = new LocalDevState(options);
         this._logger = new LocalDevLogger(this.state);
@@ -27,6 +29,10 @@ class LocalDevProcess {
             localDevState: this.state,
             logger: this._logger,
         });
+        this.devSessionManager = new DevSessionManager({
+            localDevState: this.state,
+            localDevLogger: this._logger,
+        });
     }
     get projectDir() {
         return this.state.projectDir;
@@ -149,6 +155,10 @@ class LocalDevProcess {
             this.openLocalDevUi();
         }
         await this.startDevServers();
+        const devSessionRegistered = await this.devSessionManager.registerDevSession();
+        if (!devSessionRegistered) {
+            process.exit(EXIT_CODES.ERROR);
+        }
         this.state.devServersStarted = true;
         this.logger.monitorConsoleOutput();
     }
@@ -156,7 +166,8 @@ class LocalDevProcess {
         if (showProgress) {
             this.logger.cleanupStart();
         }
-        const cleanupSucceeded = await this.cleanupDevServers();
+        let cleanupSucceeded = await this.cleanupDevServers();
+        cleanupSucceeded = await this.devSessionManager.deleteDevSession();
         if (!cleanupSucceeded) {
             if (showProgress) {
                 this.logger.cleanupError();

package/lib/projects/localDev/LocalDevState.d.ts

@@ -20,6 +20,7 @@ declare class LocalDevState {
     private _devServerMessage;
     private _uploadWarnings;
     private _devServersStarted;
+    private _devSessionId;
     constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectData, debug, initialProjectNodes, initialProjectProfileData, profile, env, }: LocalDevStateConstructorOptions);
     private runListeners;
     get targetProjectAccountId(): number;
@@ -54,6 +55,8 @@ declare class LocalDevState {
     get uploadWarnings(): Set<string>;
     get devServersStarted(): boolean;
     set devServersStarted(started: boolean);
+    get devSessionId(): number | undefined;
+    set devSessionId(sessionId: number | undefined);
     addUploadWarning(warning: string): void;
     clearUploadWarnings(): void;
     addListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;

package/lib/projects/localDev/LocalDevState.js

@@ -16,6 +16,7 @@ class LocalDevState {
     _devServerMessage;
     _uploadWarnings;
     _devServersStarted;
+    _devSessionId;
     constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectData, debug, initialProjectNodes, initialProjectProfileData, profile, env, }) {
         this._targetProjectAccountId = targetProjectAccountId;
         this._targetTestingAccountId = targetTestingAccountId;
@@ -32,6 +33,7 @@ class LocalDevState {
         this._devServerMessage = LOCAL_DEV_SERVER_MESSAGE_TYPES.INITIAL;
         this._uploadWarnings = new Set();
         this._devServersStarted = false;
+        this._devSessionId = undefined;
         this._listeners = {};
     }
     runListeners(key) {
@@ -115,6 +117,13 @@ class LocalDevState {
         this._devServersStarted = started;
         this.runListeners('devServersStarted');
     }
+    get devSessionId() {
+        return this._devSessionId;
+    }
+    set devSessionId(sessionId) {
+        this._devSessionId = sessionId;
+        this.runListeners('devSessionId');
+    }
     addUploadWarning(warning) {
         this.uploadWarnings.add(warning);
         this.runListeners('uploadWarnings');

package/lib/projects/localDev/helpers/account.d.ts

@@ -1,14 +1,14 @@
-import { CLIAccount } from '@hubspot/local-dev-lib/types/Accounts';
+import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
 import { Environment } from '@hubspot/local-dev-lib/types/Config';
 import { DeveloperTestAccount } from '@hubspot/local-dev-lib/types/developerTestAccounts.js';
 import { ProjectDevTargetAccountPromptResponse } from '../../../prompts/projectDevTargetAccountPrompt.js';
-export declare function confirmDefaultAccountIsTarget(accountConfig: CLIAccount): Promise<void>;
-export declare function checkIfDefaultAccountIsSupported(accountConfig: CLIAccount, hasPublicApps: boolean): Promise<void>;
-export declare function checkIfParentAccountIsAuthed(accountConfig: CLIAccount): void;
-export declare function checkIfAccountFlagIsSupported(accountConfig: CLIAccount, hasPublicApps: boolean): void;
-export declare function suggestRecommendedNestedAccount(accounts: CLIAccount[], accountConfig: CLIAccount, hasPublicApps: boolean): Promise<ProjectDevTargetAccountPromptResponse>;
-export declare function createSandboxForLocalDev(accountId: number, accountConfig: CLIAccount, env: Environment): Promise<number>;
-export declare function createDeveloperTestAccountForLocalDev(accountId: number, accountConfig: CLIAccount, env: Environment, useV2?: boolean): Promise<number>;
+export declare function confirmDefaultAccountIsTarget(accountConfig: HubSpotConfigAccount): Promise<void>;
+export declare function checkIfDefaultAccountIsSupported(accountConfig: HubSpotConfigAccount, hasPublicApps: boolean): Promise<void>;
+export declare function checkIfParentAccountIsAuthed(accountConfig: HubSpotConfigAccount): void;
+export declare function checkIfAccountFlagIsSupported(accountConfig: HubSpotConfigAccount, hasPublicApps: boolean): void;
+export declare function suggestRecommendedNestedAccount(accounts: HubSpotConfigAccount[], accountConfig: HubSpotConfigAccount, hasPublicApps: boolean): Promise<ProjectDevTargetAccountPromptResponse>;
+export declare function createSandboxForLocalDev(accountId: number, accountConfig: HubSpotConfigAccount, env: Environment): Promise<number>;
+export declare function createDeveloperTestAccountForLocalDev(accountId: number, accountConfig: HubSpotConfigAccount, env: Environment, useV2?: boolean): Promise<number>;
 export declare function useExistingDevTestAccount(env: Environment, account: DeveloperTestAccount): Promise<void>;
-export declare function hasSandboxes(account: CLIAccount): Promise<boolean>;
-export declare function selectAccountTypePrompt(accountConfig: CLIAccount): Promise<string | null>;
+export declare function hasSandboxes(account: HubSpotConfigAccount): Promise<boolean>;
+export declare function selectAccountTypePrompt(accountConfig: HubSpotConfigAccount): Promise<string | null>;

package/lib/projects/localDev/helpers/account.js

@@ -1,6 +1,5 @@
 import { HUBSPOT_ACCOUNT_TYPE_STRINGS } from '@hubspot/local-dev-lib/constants/config';
-import { getAccountConfig } from '@hubspot/local-dev-lib/config';
-import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
+import { getConfigAccountById, getConfigAccountIfExists, } from '@hubspot/local-dev-lib/config';
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
 import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
 import { isMissingScopeError } from '@hubspot/local-dev-lib/errors/index';
@@ -60,8 +59,8 @@ export async function checkIfDefaultAccountIsSupported(accountConfig, hasPublicA
 }
 export function checkIfParentAccountIsAuthed(accountConfig) {
     if (!accountConfig.parentAccountId ||
-        !getAccountConfig(accountConfig.parentAccountId)) {
-        uiLogger.error(lib.localDevHelpers.account.checkIfParentAccountIsAuthed.notAuthedError(accountConfig.parentAccountId || '', uiAccountDescription(getAccountIdentifier(accountConfig))));
+        !getConfigAccountIfExists(accountConfig.parentAccountId)?.accountId) {
+        uiLogger.error(lib.localDevHelpers.account.checkIfParentAccountIsAuthed.notAuthedError(accountConfig.parentAccountId || '', uiAccountDescription(accountConfig.accountId)));
         process.exit(EXIT_CODES.SUCCESS);
     }
 }
@@ -122,11 +121,7 @@ export async function createSandboxForLocalDev(accountId, accountConfig, env) {
         trackCommandMetadataUsage('sandbox-create', { step: 'project-dev' }, accountId);
         const result = await buildSandbox(name, accountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, env);
         const targetAccountId = result.sandbox.sandboxHubId;
-        const sandboxAccountConfig = getAccountConfig(result.sandbox.sandboxHubId);
-        if (!sandboxAccountConfig) {
-            uiLogger.error(lib.sandbox.create.developer.failure.generic);
-            process.exit(EXIT_CODES.ERROR);
-        }
+        const sandboxAccountConfig = getConfigAccountById(result.sandbox.sandboxHubId);
         const syncTasks = await getAvailableSyncTypes(accountConfig, sandboxAccountConfig);
         // For v1 sandboxes, keep sync here. Once we migrate to v2, this will be handled by BE automatically
         await syncSandbox(sandboxAccountConfig, accountConfig, env, syncTasks, true);
@@ -190,7 +185,7 @@ export async function useExistingDevTestAccount(env, account) {
     uiLogger.success(lib.developerTestAccount.create.success.configFileUpdated(devTestAcctConfigName, PERSONAL_ACCESS_KEY_AUTH_METHOD.name));
 }
 export async function hasSandboxes(account) {
-    const accountId = getAccountIdentifier(account);
+    const accountId = account.accountId;
     if (!accountId) {
         return false;
     }
@@ -206,7 +201,7 @@ export async function hasSandboxes(account) {
 // Top level prompt to choose the type of account to test on
 export async function selectAccountTypePrompt(accountConfig) {
     const hasAccessToSandboxes = await hasSandboxes(accountConfig);
-    const accountId = getAccountIdentifier(accountConfig);
+    const accountId = accountConfig.accountId;
     const result = await listPrompt(lib.localDevHelpers.account.selectAccountTypePrompt.message, {
         choices: [
             {

package/lib/projects/localDev/helpers/devSessionsApi.d.ts

@@ -0,0 +1,9 @@
+import { HubSpotPromise } from '@hubspot/local-dev-lib/types/Http';
+export declare function registerDevSession(accountId: number, ports: {
+    serverId: string;
+    port: number;
+}[], force?: boolean): HubSpotPromise<{
+    sessionId: number;
+}>;
+export declare function devSessionHeartbeat(accountId: number, sessionId: number): HubSpotPromise<void>;
+export declare function deleteDevSession(accountId: number, sessionId: number): HubSpotPromise<void>;

package/lib/projects/localDev/helpers/devSessionsApi.js

@@ -0,0 +1,19 @@
+import { http } from '@hubspot/local-dev-lib/http';
+const DEV_SESSIONS_API_PATH = 'projects-localdev/2025-09/dev-sessions';
+export async function registerDevSession(accountId, ports, force) {
+    return http.post(accountId, {
+        url: `${DEV_SESSIONS_API_PATH}/register${force ? '?force=true' : ''}`,
+        data: { ports },
+    });
+}
+export async function devSessionHeartbeat(accountId, sessionId) {
+    return http.post(accountId, {
+        url: `${DEV_SESSIONS_API_PATH}/${sessionId}/heartbeat`,
+        data: {},
+    });
+}
+export async function deleteDevSession(accountId, sessionId) {
+    return http.delete(accountId, {
+        url: `${DEV_SESSIONS_API_PATH}/${sessionId}`,
+    });
+}

package/lib/projects/uieLinting.d.ts

@@ -0,0 +1,33 @@
+export declare const REQUIRED_PACKAGES_AND_MIN_VERSIONS: {
+    readonly eslint: "9.0.0";
+    readonly '@typescript-eslint/eslint-plugin': "8.46.4";
+    readonly '@typescript-eslint/parser': "8.46.4";
+    readonly 'typescript-eslint': "8.46.4";
+    readonly jiti: "2.6.1";
+};
+export declare function isEslintInstalled(directory: string): boolean;
+export declare function areAllLintPackagesInstalled(directory: string): boolean;
+export declare function getMissingLintPackages(directory: string): {
+    missingPackages: string[];
+};
+export declare function hasEslintConfig(directory: string): boolean;
+export declare function hasDeprecatedEslintConfig(directory: string): boolean;
+export declare function getDeprecatedEslintConfigFiles(directory: string): string[];
+export declare function createEslintConfig(directory: string): string;
+export declare function lintPackagesInDirectory(directory: string, projectDir?: string): Promise<{
+    success: boolean;
+    output: string;
+}>;
+export declare function lintPackages(lintLocations?: string[], projectDir?: string): Promise<{
+    success: boolean;
+    results: Array<{
+        location: string;
+        success: boolean;
+        output: string;
+    }>;
+}>;
+export declare function displayLintResults(results: Array<{
+    location: string;
+    success: boolean;
+    output: string;
+}>): void;

package/lib/projects/uieLinting.js

@@ -0,0 +1,222 @@
+import fs from 'fs';
+import path from 'path';
+import util from 'util';
+import semver from 'semver';
+import { exec as execAsync } from 'node:child_process';
+import { getProjectPackageJsonLocations, isPackageInstalled, } from '../dependencyManagement.js';
+import { commands } from '../../lang/en.js';
+import { uiLogger } from '../ui/logger.js';
+export const REQUIRED_PACKAGES_AND_MIN_VERSIONS = {
+    eslint: '9.0.0',
+    '@typescript-eslint/eslint-plugin': '8.46.4',
+    '@typescript-eslint/parser': '8.46.4',
+    'typescript-eslint': '8.46.4',
+    jiti: '2.6.1',
+};
+const ESLINT_CONFIG_FILES = [
+    'eslint.config.mts',
+    'eslint.config.ts',
+    'eslint.config.cts',
+    'eslint.config.js',
+    'eslint.config.mjs',
+    'eslint.config.cjs',
+];
+const DEPRECATED_ESLINT_CONFIG_FILES = [
+    '.eslintrc.js',
+    '.eslintrc.cjs',
+    '.eslintrc.yaml',
+    '.eslintrc.yml',
+    '.eslintrc.json',
+    '.eslintrc',
+];
+const ESLINT_CONFIG_TEMPLATE = `import { defineConfig } from "eslint/config";
+import tsParser from "@typescript-eslint/parser";
+
+export default defineConfig([
+  {
+    files: ["**/*.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"],
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        ecmaVersion: "latest",
+        sourceType: "module",
+        ecmaFeatures: {
+          jsx: true
+        }
+      }
+    },
+    rules: {
+      "no-console": ["warn", { allow: ["warn", "error"] }]
+    }
+  },
+]);
+`;
+function getPackageVersionFromPackageJson(directory, packageName) {
+    const packageJsonPath = path.join(directory, 'package.json');
+    try {
+        const packageJsonContent = fs.readFileSync(packageJsonPath, 'utf-8');
+        const packageJson = JSON.parse(packageJsonContent);
+        const version = packageJson.dependencies?.[packageName] ||
+            packageJson.devDependencies?.[packageName];
+        return version || null;
+    }
+    catch (error) {
+        return null;
+    }
+}
+function isPackageVersionValid(directory, packageName) {
+    const versionRange = getPackageVersionFromPackageJson(directory, packageName);
+    if (!versionRange) {
+        return false;
+    }
+    const minimumVersion = REQUIRED_PACKAGES_AND_MIN_VERSIONS[packageName];
+    if (!minimumVersion) {
+        // If no minimum version specified, any version is valid
+        return true;
+    }
+    try {
+        // Check if the version range satisfies the minimum version
+        // For ranges like ^9.0.0, ~8.5.0, >=9.0.0, etc.
+        const minVersionSatisfied = semver.satisfies(minimumVersion, versionRange, {
+            includePrerelease: true,
+        });
+        const coercedVersion = semver.minVersion(versionRange);
+        if (coercedVersion) {
+            return semver.gte(coercedVersion, minimumVersion);
+        }
+        return minVersionSatisfied;
+    }
+    catch (error) {
+        return false;
+    }
+}
+export function isEslintInstalled(directory) {
+    return isPackageInstalled(directory, 'eslint');
+}
+export function areAllLintPackagesInstalled(directory) {
+    return Object.keys(REQUIRED_PACKAGES_AND_MIN_VERSIONS).every(pkg => {
+        const installed = isPackageInstalled(directory, pkg);
+        const validVersion = isPackageVersionValid(directory, pkg);
+        return installed && validVersion;
+    });
+}
+export function getMissingLintPackages(directory) {
+    const missingPackages = [];
+    for (const packageName of Object.keys(REQUIRED_PACKAGES_AND_MIN_VERSIONS)) {
+        const isInstalled = isPackageInstalled(directory, packageName);
+        const isValidVersion = isPackageVersionValid(directory, packageName);
+        if (!isInstalled || !isValidVersion) {
+            missingPackages.push(packageName);
+        }
+    }
+    return { missingPackages };
+}
+export function hasEslintConfig(directory) {
+    return ESLINT_CONFIG_FILES.some(configFile => {
+        const configPath = path.join(directory, configFile);
+        return fs.existsSync(configPath);
+    });
+}
+export function hasDeprecatedEslintConfig(directory) {
+    return DEPRECATED_ESLINT_CONFIG_FILES.some(configFile => {
+        const configPath = path.join(directory, configFile);
+        return fs.existsSync(configPath);
+    });
+}
+export function getDeprecatedEslintConfigFiles(directory) {
+    return DEPRECATED_ESLINT_CONFIG_FILES.filter(configFile => {
+        const configPath = path.join(directory, configFile);
+        return fs.existsSync(configPath);
+    });
+}
+export function createEslintConfig(directory) {
+    const configPath = path.join(directory, 'eslint.config.mts');
+    try {
+        fs.writeFileSync(configPath, ESLINT_CONFIG_TEMPLATE, 'utf-8');
+        return path.relative(process.cwd(), configPath);
+    }
+    catch (error) {
+        uiLogger.error(commands.project.lint.failedToCreateEslintConfig(configPath));
+        throw error;
+    }
+}
+export async function lintPackagesInDirectory(directory, projectDir) {
+    const displayPath = projectDir
+        ? path.relative(projectDir, directory)
+        : directory;
+    const exec = util.promisify(execAsync);
+    const lintCommand = 'npx eslint . --color';
+    try {
+        const { stdout, stderr } = await exec(lintCommand, {
+            cwd: directory,
+            maxBuffer: 10 * 1024 * 1024, // 10MB buffer for large outputs
+        });
+        let output = `\n${displayPath}:\n`;
+        if (stdout && stdout.trim()) {
+            output += stdout;
+        }
+        else {
+            output += '  No linting issues found.\n';
+        }
+        if (stderr && stderr.trim()) {
+            output += stderr;
+        }
+        return { success: true, output };
+    }
+    catch (error) {
+        // ESLint returns exit code 1 when there are linting errors
+        // but still provides useful output in stdout/stderr
+        let output = `\n${displayPath}:\n`;
+        if (error && typeof error === 'object' && 'stdout' in error) {
+            const execError = error;
+            if (execError.stdout) {
+                output += execError.stdout;
+            }
+            if (execError.stderr) {
+                output += execError.stderr;
+            }
+        }
+        return { success: false, output };
+    }
+}
+export async function lintPackages(lintLocations, projectDir) {
+    const locations = lintLocations || (await getProjectPackageJsonLocations());
+    const results = [];
+    for (const location of locations) {
+        const result = await lintPackagesInDirectory(location, projectDir);
+        const displayPath = projectDir
+            ? path.relative(projectDir, location)
+            : location;
+        results.push({ location: displayPath, ...result });
+    }
+    const failedLocations = results.filter(r => !r.success);
+    return {
+        success: failedLocations.length === 0,
+        results,
+    };
+}
+export function displayLintResults(results) {
+    // Display all output
+    results.forEach(r => {
+        uiLogger.log(r.output);
+    });
+    // Summary
+    const failedLocations = results.filter(r => !r.success);
+    const passedLocations = results.filter(r => r.success);
+    uiLogger.log('\n' + '='.repeat(50));
+    if (passedLocations.length > 0) {
+        uiLogger.success(`Linting passed in ${passedLocations.length} ${passedLocations.length === 1 ? 'directory' : 'directories'}:`);
+        passedLocations.forEach(r => {
+            uiLogger.log(`  ✓ ${r.location}`);
+        });
+    }
+    if (failedLocations.length > 0) {
+        if (passedLocations.length > 0) {
+            uiLogger.log('');
+        }
+        uiLogger.error(`Linting failed in ${failedLocations.length} ${failedLocations.length === 1 ? 'directory' : 'directories'}:`);
+        failedLocations.forEach(r => {
+            uiLogger.log(`  ✗ ${r.location}`);
+        });
+    }
+}