@poetora/cli 0.0.1 → 0.1.2

package/bin/commands/dev.command.js

@@ -0,0 +1,40 @@
+import { dev } from '@poetora/previewing';
+import { InvalidEnvironmentError } from '../errors/index.js';
+import { BaseCommand } from './base.command.js';
+export class DevCommand extends BaseCommand {
+    versionService;
+    portService;
+    name = 'dev';
+    description = 'initialize a local preview environment';
+    constructor(logger, versionService, portService, packageName = 'poet') {
+        super(logger, packageName);
+        this.versionService = versionService;
+        this.portService = portService;
+    }
+    async validate(_options) {
+        const versionResult = this.versionService.checkNodeVersion();
+        if (!versionResult.isValid) {
+            throw new InvalidEnvironmentError(versionResult.message ?? 'Unsupported Node.js version');
+        }
+        if (versionResult.hasWarning && versionResult.message) {
+            this.logger.warn(versionResult.message);
+        }
+    }
+    async execute(options) {
+        const port = await this.portService.findAvailablePort(options.port);
+        const cliVersion = this.versionService.getCliVersion();
+        const devArgs = {
+            _: [],
+            $0: this.packageName,
+            port,
+            open: options.open ?? true,
+            localSchema: options.localSchema ?? false,
+            clientVersion: options.clientVersion,
+            groups: options.groups,
+            disableOpenapi: options.disableOpenapi ?? false,
+            packageName: this.packageName,
+            cliVersion,
+        };
+        await dev(devArgs);
+    }
+}

package/bin/commands/index.d.ts

@@ -0,0 +1,6 @@
+export * from './base.command.js';
+export * from './check.command.js';
+export * from './dev.command.js';
+export * from './init.command.js';
+export * from './link.command.js';
+export * from './update.command.js';

package/bin/commands/index.js

@@ -0,0 +1,6 @@
+export * from './base.command.js';
+export * from './check.command.js';
+export * from './dev.command.js';
+export * from './init.command.js';
+export * from './link.command.js';
+export * from './update.command.js';

package/bin/commands/init.command.d.ts

@@ -0,0 +1,16 @@
+import type { TemplateService } from '../services/template.service.js';
+import type { InitOptions } from '../types/index.js';
+import type { ILogger } from '../utils/index.js';
+import { BaseCommand } from './base.command.js';
+export declare class InitCommand extends BaseCommand {
+    private readonly templateService;
+    readonly name = "init";
+    readonly description = "Create a new Poetora documentation site";
+    constructor(logger: ILogger, templateService: TemplateService, packageName?: string);
+    protected execute(options: InitOptions): Promise<void>;
+    private promptDirectoryChoice;
+    private promptSubdirectoryName;
+    private promptProjectName;
+    private promptTheme;
+    private showOnboardingMessage;
+}

package/bin/commands/init.command.js

@@ -0,0 +1,88 @@
+import { input, select } from '@inquirer/prompts';
+import { ValidationError } from '../errors/index.js';
+import { BaseCommand } from './base.command.js';
+export class InitCommand extends BaseCommand {
+    templateService;
+    name = 'init';
+    description = 'Create a new Poetora documentation site';
+    constructor(logger, templateService, packageName = 'poet') {
+        super(logger, packageName);
+        this.templateService = templateService;
+    }
+    async execute(options) {
+        let installDir = options.directory;
+        const dirStatus = await this.templateService.checkDirectory(installDir);
+        if (dirStatus.exists && dirStatus.hasContents) {
+            const choice = await this.promptDirectoryChoice(installDir);
+            if (choice === 'cancel') {
+                this.logger.info('Installation cancelled');
+                return;
+            }
+            if (choice === 'subdir') {
+                const subdir = await this.promptSubdirectoryName();
+                installDir = installDir === '.' ? subdir : `${installDir}/${subdir}`;
+            }
+        }
+        const projectName = await this.promptProjectName(installDir);
+        const theme = await this.promptTheme();
+        this.logger.info('Setting up documentation project...');
+        await this.templateService.installTemplate({
+            directory: installDir,
+            projectName,
+            theme,
+        });
+        this.showOnboardingMessage(installDir);
+    }
+    async promptDirectoryChoice(directory) {
+        const choice = await select({
+            message: `Directory ${directory} is not empty. What would you like to do?`,
+            choices: [
+                { name: 'Create in a subdirectory', value: 'subdir' },
+                { name: 'Overwrite current directory (may lose contents)', value: 'overwrite' },
+                { name: 'Cancel', value: 'cancel' },
+            ],
+        });
+        return choice;
+    }
+    async promptSubdirectoryName() {
+        const subdir = await input({
+            message: 'Subdirectory name:',
+            default: 'docs',
+        });
+        if (!subdir || subdir.trim() === '') {
+            throw new ValidationError('Subdirectory name cannot be empty');
+        }
+        return subdir.trim();
+    }
+    async promptProjectName(installDir) {
+        const defaultProject = installDir === '.' ? 'Poetora' : installDir;
+        const projectName = await input({
+            message: 'Project Name',
+            default: defaultProject,
+        });
+        return projectName || defaultProject;
+    }
+    async promptTheme() {
+        const themes = this.templateService.getAvailableThemes();
+        const theme = await select({
+            message: 'Theme',
+            choices: themes.map((t) => ({
+                name: t,
+                value: t,
+            })),
+        });
+        return theme;
+    }
+    showOnboardingMessage(installDir) {
+        this.logger.log('');
+        this.logger.success('Documentation Setup!');
+        this.logger.log('');
+        this.logger.log('To see your docs run:');
+        this.logger.log('');
+        if (installDir !== '.') {
+            this.logger.log(`  cd ${installDir}`);
+        }
+        this.logger.log(`  ${this.packageName} dev`);
+        this.logger.log('');
+    }
+}

package/bin/commands/link.command.d.ts

@@ -0,0 +1,13 @@
+import type { LinkService } from '../services/index.js';
+import type { RenameOptions } from '../types/index.js';
+import type { ILogger } from '../utils/index.js';
+import { BaseCommand } from './base.command.js';
+export declare class LinkCommand extends BaseCommand {
+    private readonly linkService;
+    readonly name = "link";
+    readonly description = "manage documentation links";
+    constructor(logger: ILogger, linkService: LinkService, packageName?: string);
+    checkBrokenLinks(): Promise<Record<string, string[]>>;
+    renameFile(options: RenameOptions): Promise<void>;
+    protected execute(): Promise<void>;
+}

package/bin/commands/link.command.js

@@ -0,0 +1,19 @@
+import { BaseCommand } from './base.command.js';
+export class LinkCommand extends BaseCommand {
+    linkService;
+    name = 'link';
+    description = 'manage documentation links';
+    constructor(logger, linkService, packageName = 'poet') {
+        super(logger, packageName);
+        this.linkService = linkService;
+    }
+    async checkBrokenLinks() {
+        return await this.linkService.checkBrokenLinks();
+    }
+    async renameFile(options) {
+        await this.linkService.renameFile(options.from, options.to, options.force);
+    }
+    async execute() {
+        await this.linkService.checkBrokenLinks();
+    }
+}

package/bin/commands/update.command.d.ts

@@ -0,0 +1,10 @@
+import type { UpdateService } from '../services/index.js';
+import type { ILogger } from '../utils/index.js';
+import { BaseCommand } from './base.command.js';
+export declare class UpdateCommand extends BaseCommand {
+    private readonly updateService;
+    readonly name = "update";
+    readonly description = "update the CLI to the latest version";
+    constructor(logger: ILogger, updateService: UpdateService, packageName?: string);
+    protected execute(): Promise<void>;
+}

package/bin/commands/update.command.js

@@ -0,0 +1,13 @@
+import { BaseCommand } from './base.command.js';
+export class UpdateCommand extends BaseCommand {
+    updateService;
+    name = 'update';
+    description = 'update the CLI to the latest version';
+    constructor(logger, updateService, packageName = 'poet') {
+        super(logger, packageName);
+        this.updateService = updateService;
+    }
+    async execute() {
+        await this.updateService.update();
+    }
+}

package/bin/constants.js

@@ -1,3 +1,3 @@
-import os from 'os';
+import os from 'node:os';
 export const HOME_DIR = os.homedir();
 export const CMD_EXEC_PATH = process.cwd();

package/bin/errors/cli-error.d.ts

@@ -0,0 +1,26 @@
+export declare class CliError extends Error {
+    readonly code: string;
+    readonly exitCode: number;
+    constructor(message: string, code: string, exitCode?: number);
+}
+export declare class InvalidEnvironmentError extends CliError {
+    constructor(message: string);
+}
+export declare class NoAvailablePortError extends CliError {
+    constructor(message: string);
+}
+export declare class ConfigNotFoundError extends CliError {
+    constructor(message: string);
+}
+export declare class ValidationError extends CliError {
+    readonly field?: string | undefined;
+    constructor(message: string, field?: string | undefined);
+}
+export declare class FileSystemError extends CliError {
+    readonly filePath?: string | undefined;
+    constructor(message: string, filePath?: string | undefined);
+}
+export declare class ExternalServiceError extends CliError {
+    readonly service?: string | undefined;
+    constructor(message: string, service?: string | undefined);
+}

package/bin/errors/cli-error.js

@@ -0,0 +1,53 @@
+export class CliError extends Error {
+    code;
+    exitCode;
+    constructor(message, code, exitCode = 1) {
+        super(message);
+        this.code = code;
+        this.exitCode = exitCode;
+        this.name = 'CliError';
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+export class InvalidEnvironmentError extends CliError {
+    constructor(message) {
+        super(message, 'INVALID_ENVIRONMENT', 1);
+        this.name = 'InvalidEnvironmentError';
+    }
+}
+export class NoAvailablePortError extends CliError {
+    constructor(message) {
+        super(message, 'NO_AVAILABLE_PORT', 1);
+        this.name = 'NoAvailablePortError';
+    }
+}
+export class ConfigNotFoundError extends CliError {
+    constructor(message) {
+        super(message, 'CONFIG_NOT_FOUND', 1);
+        this.name = 'ConfigNotFoundError';
+    }
+}
+export class ValidationError extends CliError {
+    field;
+    constructor(message, field) {
+        super(message, 'VALIDATION_ERROR', 1);
+        this.field = field;
+        this.name = 'ValidationError';
+    }
+}
+export class FileSystemError extends CliError {
+    filePath;
+    constructor(message, filePath) {
+        super(message, 'FILE_SYSTEM_ERROR', 1);
+        this.filePath = filePath;
+        this.name = 'FileSystemError';
+    }
+}
+export class ExternalServiceError extends CliError {
+    service;
+    constructor(message, service) {
+        super(message, 'EXTERNAL_SERVICE_ERROR', 1);
+        this.service = service;
+        this.name = 'ExternalServiceError';
+    }
+}

package/bin/errors/index.d.ts

@@ -0,0 +1 @@
+export * from './cli-error.js';

package/bin/errors/index.js

@@ -0,0 +1 @@
+export * from './cli-error.js';

package/bin/index.d.ts

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-import { type ChildProcess } from 'child_process';
+import { type ChildProcess } from 'node:child_process';
 declare let cli: ChildProcess | null;
 export { cli };

package/bin/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-import { spawn } from 'child_process';
-import path from 'path';
-import { fileURLToPath } from 'url';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const packageName = path.basename(process.argv[1] ?? '') === 'index'
@@ -24,13 +24,13 @@ const cleanup = async () => {
                     }
                     resolve();
                 }, 5000);
-                cli.once('exit', () => {
+                cli?.once('exit', () => {
                     clearTimeout(timeout);
                     resolve();
                 });
             });
         }
-        catch (error) {
+        catch (_error) {
         }
     }
 };
@@ -85,7 +85,7 @@ process.on('exit', () => {
         try {
             cli.kill('SIGKILL');
         }
-        catch (error) {
+        catch (_error) {
         }
     }
 });

package/bin/mdxAccessibility.js

@@ -1,7 +1,7 @@
+import fs from 'node:fs';
+import path from 'node:path';
 import { categorizeFilePaths, getPoetIgnore } from '@poetora/prebuild';
 import { coreRemark } from '@poetora/shared';
-import fs from 'fs';
-import path from 'path';
 import { visit } from 'unist-util-visit';
 const checkAltAttributes = (filePath, content) => {
     const issues = [];

package/bin/services/accessibility-check.service.d.ts

@@ -0,0 +1,10 @@
+import type { ILogger } from '../utils/logger.interface.js';
+export declare class AccessibilityCheckService {
+    private readonly logger;
+    constructor(logger?: ILogger);
+    private displayContrastResult;
+    private colorize;
+    private checkColorAccessibility;
+    private checkMdxAccessibility;
+    checkAccessibility(): Promise<number>;
+}

package/bin/services/accessibility-check.service.js

@@ -0,0 +1,144 @@
+import path from 'node:path';
+import { getConfigObj, getConfigPath } from '@poetora/prebuild';
+import { getBackgroundColors } from '@poetora/shared';
+import { checkDocsColors, } from '../accessibility.js';
+import { CMD_EXEC_PATH } from '../constants.js';
+import { checkMdxAccessibility } from '../mdxAccessibility.js';
+import { ConsoleLogger } from '../utils/console-logger.js';
+export class AccessibilityCheckService {
+    logger;
+    constructor(logger = new ConsoleLogger()) {
+        this.logger = logger;
+    }
+    displayContrastResult(result, label, prefix = '') {
+        if (!result)
+            return;
+        const { recommendation } = result;
+        let statusText;
+        let detailMessage;
+        if (recommendation === 'pass') {
+            if (result.meetsAAA) {
+                statusText = '✓ Excellent';
+                detailMessage = `ratio ${result.ratio.toFixed(2)}:1 (AAA standard)`;
+            }
+            else {
+                statusText = '✓ Good';
+                detailMessage = `ratio ${result.ratio.toFixed(2)}:1 (AA standard)`;
+            }
+        }
+        else if (recommendation === 'warning') {
+            statusText = '⚠ Acceptable';
+            detailMessage = `ratio ${result.ratio.toFixed(2)}:1 (consider improving)`;
+        }
+        else {
+            statusText = '✗ Poor';
+            detailMessage = `ratio ${result.ratio.toFixed(2)}:1 (below AA standard)`;
+        }
+        const labelText = `${prefix}${label}:`;
+        const statusColor = recommendation === 'pass' ? 'green' : recommendation === 'warning' ? 'yellow' : 'red';
+        this.logger.log(`${labelText} ${this.colorize(statusText, statusColor)} ${detailMessage}`);
+    }
+    colorize(text, color) {
+        const chalk = (text, color) => {
+            const colors = {
+                green: '\x1b[32m',
+                yellow: '\x1b[33m',
+                red: '\x1b[31m',
+                reset: '\x1b[0m',
+            };
+            return `${colors[color]}${text}${colors.reset}`;
+        };
+        return chalk(text, color);
+    }
+    async checkColorAccessibility() {
+        try {
+            const docsConfigPath = await getConfigPath(CMD_EXEC_PATH);
+            if (!docsConfigPath) {
+                this.logger.error('No configuration file found. Please run this command from a directory with a docs.json file.');
+                return 1;
+            }
+            const config = await getConfigObj(CMD_EXEC_PATH);
+            if (!config?.colors) {
+                this.logger.warn('No colors section found in configuration file');
+                return 0;
+            }
+            const { colors, navigation } = config;
+            const { lightHex, darkHex } = getBackgroundColors(config);
+            const results = checkDocsColors(colors, { lightHex, darkHex }, navigation);
+            this.logger.log('Checking color accessibility...');
+            this.displayContrastResult(results.primaryContrast, `Primary Color (${colors.primary}) vs Light Background`);
+            this.displayContrastResult(results.lightContrast, `Light Color (${colors.light}) vs Dark Background`);
+            this.displayContrastResult(results.darkContrast, `Dark Color (${colors.dark}) vs Dark Background`);
+            this.displayContrastResult(results.darkOnLightContrast, `Dark Color (${colors.dark}) vs Light Background`);
+            const anchorsWithResults = results.anchorResults.filter((anchor) => anchor.lightContrast || anchor.darkContrast);
+            if (anchorsWithResults.length > 0) {
+                for (const anchor of anchorsWithResults) {
+                    this.displayContrastResult(anchor.lightContrast, `${anchor.name} vs Light Background`);
+                    this.displayContrastResult(anchor.darkContrast, `${anchor.name} vs Dark Background`);
+                }
+            }
+            let overallDisplay;
+            if (results.overallScore === 'fail') {
+                overallDisplay =
+                    this.colorize('✗ Action needed:', 'red') +
+                        ' Update colors to meet accessibility standards';
+            }
+            else if (results.overallScore === 'warning') {
+                overallDisplay = `${this.colorize('⚠ Room for improvement:', 'yellow')} Consider enhancing color contrast`;
+            }
+            else {
+                overallDisplay = `${this.colorize('✓ All good:', 'green')} Colors meet accessibility guidelines`;
+            }
+            this.logger.logNewLine();
+            this.logger.log(overallDisplay);
+            return results.overallScore === 'fail' ? 1 : 0;
+        }
+        catch (error) {
+            this.logger.error(`Failed to check color accessibility: ${error}`);
+            return 1;
+        }
+    }
+    async checkMdxAccessibility() {
+        try {
+            this.logger.log('Checking mdx files for accessibility issues...');
+            const results = await checkMdxAccessibility();
+            if (results.missingAltAttributes.length === 0) {
+                this.logger.success('no accessibility issues found');
+                this.logger.info(`Checked ${results.totalFiles} MDX files - all images and videos have alt attributes.`);
+                return 0;
+            }
+            const issuesByFile = {};
+            results.missingAltAttributes.forEach((issue) => {
+                if (!issuesByFile[issue.filePath]) {
+                    issuesByFile[issue.filePath] = [];
+                }
+                issuesByFile[issue.filePath]?.push(issue);
+            });
+            this.logger.log(`Found ${this.logger.highlight?.(results.missingAltAttributes.length.toString()) ?? results.missingAltAttributes.length} accessibility issue${results.missingAltAttributes.length === 1 ? '' : 's'} in ${this.logger.highlight?.(results.filesWithIssues.toString()) ?? results.filesWithIssues} file${results.filesWithIssues === 1 ? '' : 's'}:`);
+            for (const [filePath, issues] of Object.entries(issuesByFile)) {
+                const relativePath = path.relative(process.cwd(), filePath);
+                this.logger.log(`${relativePath}:`);
+                for (const issue of issues) {
+                    const location = issue.line && issue.column ? ` (line ${issue.line}, col ${issue.column})` : '';
+                    if (issue.element === 'a') {
+                        this.logger.logColor(` ✗ Missing text attribute ${issue.tagName} element${location}`, 'red');
+                    }
+                    else {
+                        this.logger.logColor(` ✗ Missing alt attribute on ${issue.tagName} element${location}`, 'red');
+                    }
+                }
+            }
+            this.logger.warn('Recommendation: Add alt attributes to all images and videos for better accessibility.');
+            return 1;
+        }
+        catch (error) {
+            this.logger.error(`Failed to check MDX accessibility: ${error}`);
+            return 1;
+        }
+    }
+    async checkAccessibility() {
+        const colorCheckCode = await this.checkColorAccessibility();
+        const mdxCheckCode = await this.checkMdxAccessibility();
+        return colorCheckCode || mdxCheckCode;
+    }
+}

package/bin/services/index.d.ts

@@ -0,0 +1,7 @@
+export * from './accessibility-check.service.js';
+export * from './link.service.js';
+export * from './openapi-check.service.js';
+export * from './port.service.js';
+export * from './template.service.js';
+export * from './update.service.js';
+export * from './version.service.js';

package/bin/services/index.js

@@ -0,0 +1,7 @@
+export * from './accessibility-check.service.js';
+export * from './link.service.js';
+export * from './openapi-check.service.js';
+export * from './port.service.js';
+export * from './template.service.js';
+export * from './update.service.js';
+export * from './version.service.js';

package/bin/services/link.service.d.ts

@@ -0,0 +1,7 @@
+import type { ILogger } from '../utils/index.js';
+export declare class LinkService {
+    private readonly logger;
+    constructor(logger: ILogger);
+    checkBrokenLinks(): Promise<Record<string, string[]>>;
+    renameFile(from: string, to: string, force?: boolean): Promise<void>;
+}

package/bin/services/link.service.js

@@ -0,0 +1,40 @@
+import * as path from 'node:path';
+import { getBrokenInternalLinks, renameFilesAndUpdateLinksInContent, } from '@poetora/link-rot';
+export class LinkService {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    async checkBrokenLinks() {
+        const brokenLinks = await getBrokenInternalLinks();
+        if (brokenLinks.length === 0) {
+            this.logger.success('no broken links found');
+            return {};
+        }
+        const brokenLinksByFile = {};
+        brokenLinks.forEach((mdxPath) => {
+            const filename = path.join(mdxPath.relativeDir, mdxPath.filename);
+            const brokenLinksForFile = brokenLinksByFile[filename];
+            if (brokenLinksForFile) {
+                brokenLinksForFile.push(mdxPath.originalPath);
+            }
+            else {
+                brokenLinksByFile[filename] = [mdxPath.originalPath];
+            }
+        });
+        const fileCount = Object.keys(brokenLinksByFile).length;
+        this.logger.log(`found ${this.logger.highlight?.(brokenLinks.length.toString()) ?? brokenLinks.length} broken link${brokenLinks.length === 1 ? '' : 's'} in ${this.logger.highlight?.(fileCount.toString()) ?? fileCount} file${fileCount === 1 ? '' : 's'}`);
+        this.logger.logNewLine();
+        for (const [filename, links] of Object.entries(brokenLinksByFile)) {
+            console.log(`\x1b[4m${filename}\x1b[0m`);
+            links.forEach((link) => {
+                this.logger.logColor(` ⎿  ${link}`, 'gray');
+            });
+            this.logger.logNewLine();
+        }
+        return brokenLinksByFile;
+    }
+    async renameFile(from, to, force = false) {
+        await renameFilesAndUpdateLinksInContent(from, to, force);
+    }
+}

package/bin/services/openapi-check.service.d.ts

@@ -0,0 +1,7 @@
+import type { ILogger } from '../utils/index.js';
+export declare class OpenApiCheckService {
+    private readonly logger;
+    constructor(logger: ILogger);
+    validateSpec(filename: string, localSchema?: boolean): Promise<void>;
+    private readLocalOpenApiFile;
+}

package/bin/services/openapi-check.service.js

@@ -0,0 +1,43 @@
+import * as fs from 'node:fs';
+import { getOpenApiDocumentFromUrl, isAllowedLocalSchemaUrl, validate } from '@poetora/shared';
+import * as yaml from 'js-yaml';
+import { FileSystemError, ValidationError } from '../errors/index.js';
+export class OpenApiCheckService {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    async validateSpec(filename, localSchema = false) {
+        if (isAllowedLocalSchemaUrl(filename, localSchema)) {
+            await getOpenApiDocumentFromUrl(filename);
+            this.logger.success('OpenAPI definition is valid.');
+            return;
+        }
+        if (filename.startsWith('http://') && !localSchema) {
+            this.logger.warn('include the --local-schema flag to check locally hosted OpenAPI files');
+            this.logger.warn('only https protocol is supported in production');
+            return;
+        }
+        const document = await this.readLocalOpenApiFile(filename);
+        if (!document) {
+            throw new ValidationError('failed to parse OpenAPI spec: could not parse file correctly, please check for any syntax errors.');
+        }
+        await validate(document);
+        this.logger.success('OpenAPI definition is valid.');
+    }
+    async readLocalOpenApiFile(filename) {
+        try {
+            const fileContents = await fs.promises.readFile(filename, 'utf-8');
+            if (filename.endsWith('.json')) {
+                return JSON.parse(fileContents);
+            }
+            return yaml.load(fileContents);
+        }
+        catch (error) {
+            if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+                throw new FileSystemError(`file not found, please check the path provided: ${filename}`);
+            }
+            throw new ValidationError(`Failed to parse OpenAPI spec: ${error instanceof Error ? error.message : 'unknown error'}`);
+        }
+    }
+}

package/bin/services/port.service.d.ts

@@ -0,0 +1,7 @@
+import type { ILogger } from '../utils/index.js';
+export declare class PortService {
+    private readonly logger?;
+    constructor(logger?: ILogger | undefined);
+    findAvailablePort(preferredPort?: number): Promise<number>;
+    private isPortAvailable;
+}