@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/server/domains/maintenance/handlers.extensions.js

@@ -1,510 +0,0 @@
-import { execFile } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { dirname, isAbsolute, relative, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { promisify } from 'node:util';
-import { logger } from '../../../utils/logger.js';
-import { EXTENSION_GIT_CLONE_TIMEOUT_MS, EXTENSION_GIT_CHECKOUT_TIMEOUT_MS } from '../../../constants.js';
-import { INSTALLED_EXTENSION_METADATA_FILENAME, } from '../../extensions/types.js';
-import { asJsonResponse, serializeError } from '../../domains/shared/response.js';
-const execFileAsync = promisify(execFile);
-function getJshookInstallRoot() {
-    return fileURLToPath(new URL('../../../../', import.meta.url));
-}
-function parseFirstRoot(raw) {
-    const value = raw?.trim();
-    if (!value)
-        return undefined;
-    return value
-        .split(',')
-        .map((item) => item.trim())
-        .find((item) => item.length > 0);
-}
-function resolveDefaultExtensionRoot(kind) {
-    const envKey = kind === 'workflow' ? 'MCP_WORKFLOW_ROOTS' : 'MCP_PLUGIN_ROOTS';
-    const configured = parseFirstRoot(process.env[envKey]);
-    if (configured) {
-        return resolve(configured);
-    }
-    const installRoot = getJshookInstallRoot();
-    return resolve(installRoot, kind === 'workflow' ? 'workflows' : 'plugins');
-}
-function getRegistryBaseUrl() {
-    const baseUrl = (process.env.EXTENSION_REGISTRY_BASE_URL ?? '').trim().replace(/\/+$/, '');
-    if (!baseUrl) {
-        throw new Error('EXTENSION_REGISTRY_BASE_URL is not configured. Set it in .env or environment before browsing or installing extensions.');
-    }
-    return baseUrl;
-}
-function normalizeInstallPathSegment(value, field) {
-    const normalized = value?.trim();
-    if (!normalized) {
-        if (field === 'subpath') {
-            return '.';
-        }
-        throw new Error(`Registry source.${field} must be a non-empty string`);
-    }
-    return normalized;
-}
-function ensurePathStaysWithin(baseDir, targetPath, field) {
-    const rel = relative(baseDir, targetPath).replace(/\\/g, '/');
-    if (rel === '..' || rel.startsWith('../') || isAbsolute(rel)) {
-        throw new Error(`Registry source.${field} must stay within ${baseDir}: ${targetPath}`);
-    }
-}
-function resolveExtensionProjectDir(installDir, subpath) {
-    const normalizedSubpath = normalizeInstallPathSegment(subpath, 'subpath');
-    const projectDir = resolve(installDir, normalizedSubpath);
-    ensurePathStaysWithin(installDir, projectDir, 'subpath');
-    return projectDir;
-}
-function resolveExtensionEntryFile(projectDir, entryPath) {
-    const normalizedEntry = normalizeInstallPathSegment(entryPath, 'entry');
-    const resolvedEntryFile = resolve(projectDir, normalizedEntry);
-    ensurePathStaysWithin(projectDir, resolvedEntryFile, 'entry');
-    return resolvedEntryFile;
-}
-async function writeInstalledExtensionMetadata(kind, entry, projectDir) {
-    const payload = {
-        version: 1,
-        kind,
-        slug: entry.slug,
-        id: entry.id,
-        source: {
-            type: entry.source.type,
-            repo: entry.source.repo,
-            ref: entry.source.ref,
-            commit: entry.source.commit,
-            subpath: normalizeInstallPathSegment(entry.source.subpath, 'subpath'),
-            entry: normalizeInstallPathSegment(entry.source.entry, 'entry'),
-        },
-    };
-    const metadataPath = resolve(projectDir, INSTALLED_EXTENSION_METADATA_FILENAME);
-    await writeFile(metadataPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
-    return metadataPath;
-}
-const LOCAL_EXTENSION_SDK_PACKAGE = '@jshookmcp/extension-sdk';
-const LOCAL_EXTENSION_SDK_ROOT = resolve(getJshookInstallRoot(), 'packages', 'extension-sdk');
-var RegistryLimit;
-(function (RegistryLimit) {
-    RegistryLimit[RegistryLimit["FETCH_TIMEOUT_MS"] = 10000] = "FETCH_TIMEOUT_MS";
-})(RegistryLimit || (RegistryLimit = {}));
-const REGISTRY_CACHE_DIR = resolve(homedir(), '.jshookmcp', 'cache');
-class RegistryFetchError extends Error {
-    code;
-    url;
-    cachePath;
-    status;
-    constructor(code, url, message, cachePath, status) {
-        super(message);
-        this.code = code;
-        this.url = url;
-        this.cachePath = cachePath;
-        this.status = status;
-        this.name = 'RegistryFetchError';
-    }
-}
-function resolvePackageManagerInvocation(packageManager, args) {
-    if (process.platform !== 'win32') {
-        return { command: packageManager, args };
-    }
-    return {
-        command: 'powershell.exe',
-        args: ['-NoProfile', '-NonInteractive', '-Command', `${packageManager} ${args.join(' ')}`],
-    };
-}
-async function execPackageManager(packageManager, args, options) {
-    const invocation = resolvePackageManagerInvocation(packageManager, args);
-    return execFileAsync(invocation.command, invocation.args, {
-        ...options,
-        env: {
-            ...process.env,
-            ...options?.env,
-            CI: 'true',
-        },
-    });
-}
-async function resolvePackageManager(installDir) {
-    const packageJsonPath = resolve(installDir, 'package.json');
-    const pnpmLockPath = resolve(installDir, 'pnpm-lock.yaml');
-    const npmLockPath = resolve(installDir, 'package-lock.json');
-    if (existsSync(packageJsonPath)) {
-        try {
-            const raw = await readFile(packageJsonPath, 'utf8');
-            const pkg = JSON.parse(raw);
-            const packageManager = pkg.packageManager?.trim().toLowerCase().split('@')[0];
-            if (packageManager === 'pnpm')
-                return 'pnpm';
-            if (packageManager === 'npm')
-                return 'npm';
-        }
-        catch {
-        }
-    }
-    if (existsSync(pnpmLockPath))
-        return 'pnpm';
-    if (existsSync(npmLockPath))
-        return 'npm';
-    return 'pnpm';
-}
-function getRegistryCachePath(kind) {
-    return resolve(REGISTRY_CACHE_DIR, `registry-${kind}.json`);
-}
-async function readRegistryCache(kind) {
-    const cachePath = getRegistryCachePath(kind);
-    try {
-        const raw = await readFile(cachePath, 'utf8');
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-}
-async function writeRegistryCache(kind, payload) {
-    const cachePath = getRegistryCachePath(kind);
-    await mkdir(dirname(cachePath), { recursive: true });
-    await writeFile(cachePath, JSON.stringify(payload, null, 2), 'utf8');
-}
-function classifyRegistryFetchError(url, error, cachePath) {
-    if (error instanceof RegistryFetchError) {
-        return error;
-    }
-    if (error instanceof DOMException && error.name === 'AbortError') {
-        return new RegistryFetchError('timeout', url, `Registry fetch timed out after ${RegistryLimit.FETCH_TIMEOUT_MS}ms: ${url}`, cachePath);
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    if (message.includes('ENOTFOUND') || message.includes('getaddrinfo')) {
-        return new RegistryFetchError('dns_failure', url, `DNS resolution failed for registry URL: ${url}`, cachePath);
-    }
-    if (message.includes('ECONNREFUSED')) {
-        return new RegistryFetchError('connection_refused', url, `Connection refused by registry server: ${url}`, cachePath);
-    }
-    if (message.includes('CERT_') || message.includes('certificate') || message.includes('SSL')) {
-        return new RegistryFetchError('tls_error', url, `TLS/certificate error when connecting to registry: ${url}`, cachePath);
-    }
-    const httpMatch = message.match(/HTTP\s+(\d+)/i);
-    if (httpMatch) {
-        const status = Number(httpMatch[1]);
-        return new RegistryFetchError('http_error', url, message, cachePath, status);
-    }
-    return new RegistryFetchError('fetch_failed', url, message, cachePath);
-}
-function serializeRegistryFetchError(error) {
-    return {
-        success: false,
-        error: error.code,
-        message: error.message,
-        url: error.url,
-        ...(typeof error.status === 'number' ? { status: error.status } : {}),
-        ...(error.cachePath ? { cachePath: error.cachePath } : {}),
-    };
-}
-async function fetchJson(url, options) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), RegistryLimit.FETCH_TIMEOUT_MS);
-    const cachePath = options?.cacheKey ? getRegistryCachePath(options.cacheKey) : undefined;
-    try {
-        const res = await fetch(url, { signal: controller.signal });
-        if (!res.ok) {
-            throw new RegistryFetchError('http_error', url, `HTTP ${res.status} ${res.statusText} from ${url}`, cachePath, res.status);
-        }
-        const data = (await res.json());
-        if (options?.cacheKey) {
-            try {
-                await writeRegistryCache(options.cacheKey, data);
-            }
-            catch (cacheError) {
-                logger.warn(`[extensions] Failed to persist ${options.cacheKey} registry cache for ${url}:`, cacheError);
-            }
-        }
-        return {
-            data,
-            stale: false,
-            source: 'network',
-            cachePath,
-        };
-    }
-    catch (error) {
-        const classified = classifyRegistryFetchError(url, error, cachePath);
-        if (options?.cacheKey) {
-            const cached = await readRegistryCache(options.cacheKey);
-            if (cached) {
-                logger.warn(`[extensions] Using stale ${options.cacheKey} registry cache after ${classified.code}: ${url}`);
-                return {
-                    data: cached,
-                    stale: true,
-                    source: 'cache',
-                    cachePath,
-                };
-            }
-        }
-        throw classified;
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
-async function rewriteLocalExtensionSdkDependency(installDir) {
-    const packageJsonPath = resolve(installDir, 'package.json');
-    try {
-        const raw = await readFile(packageJsonPath, 'utf8');
-        const pkg = JSON.parse(raw);
-        const sections = [
-            'dependencies',
-            'devDependencies',
-            'peerDependencies',
-            'optionalDependencies',
-        ];
-        const relativeSdkPath = relative(installDir, LOCAL_EXTENSION_SDK_ROOT).replace(/\\/g, '/');
-        const localSdkSpec = `file:${relativeSdkPath || '.'}`;
-        let changed = false;
-        for (const sectionName of sections) {
-            const section = pkg[sectionName];
-            if (!section || typeof section !== 'object') {
-                continue;
-            }
-            const dependencyMap = section;
-            const currentValue = dependencyMap[LOCAL_EXTENSION_SDK_PACKAGE];
-            if (typeof currentValue === 'string' && currentValue.startsWith('workspace:')) {
-                dependencyMap[LOCAL_EXTENSION_SDK_PACKAGE] = localSdkSpec;
-                changed = true;
-            }
-        }
-        if (!changed) {
-            return false;
-        }
-        await writeFile(packageJsonPath, `${JSON.stringify(pkg, null, 2)}\n`, 'utf8');
-        logger.info(`[extensions] Rewrote ${LOCAL_EXTENSION_SDK_PACKAGE} dependency to local file path for ${installDir}`);
-        return true;
-    }
-    catch (error) {
-        logger.warn(`[extensions] Failed to rewrite ${LOCAL_EXTENSION_SDK_PACKAGE} dependency for ${installDir}:`, error);
-        return false;
-    }
-}
-async function findRegistryEntryBySlug(registryBase, slug) {
-    const [workflowResult, pluginResult] = await Promise.allSettled([
-        fetchJson(`${registryBase}/workflows.index.json`, {
-            cacheKey: 'workflows',
-        }),
-        fetchJson(`${registryBase}/plugins.index.json`, {
-            cacheKey: 'plugins',
-        }),
-    ]);
-    if (workflowResult.status === 'fulfilled') {
-        const workflows = Array.isArray(workflowResult.value.data.workflows)
-            ? workflowResult.value.data.workflows
-            : [];
-        const workflowEntry = workflows.find((item) => item.slug === slug);
-        if (workflowEntry) {
-            return { entry: workflowEntry, kind: 'workflow' };
-        }
-    }
-    if (pluginResult.status === 'fulfilled') {
-        const plugins = Array.isArray(pluginResult.value.data.plugins)
-            ? pluginResult.value.data.plugins
-            : [];
-        const pluginEntry = plugins.find((item) => item.slug === slug);
-        if (pluginEntry) {
-            return { entry: pluginEntry, kind: 'plugin' };
-        }
-    }
-    const workflowFetchError = workflowResult.status === 'rejected'
-        ? workflowResult.reason instanceof Error
-            ? workflowResult.reason
-            : new Error(String(workflowResult.reason))
-        : undefined;
-    const pluginFetchError = pluginResult.status === 'rejected'
-        ? pluginResult.reason instanceof Error
-            ? pluginResult.reason
-            : new Error(String(pluginResult.reason))
-        : undefined;
-    if (workflowFetchError && pluginFetchError) {
-        throw new Error(`Failed to resolve extension slug "${slug}": workflow registry error: ${workflowFetchError.message}; plugin registry error: ${pluginFetchError.message}`);
-    }
-    if (pluginFetchError) {
-        throw new Error(`Extension "${slug}" was not found in workflow registry, and plugin registry lookup failed: ${pluginFetchError.message}`);
-    }
-    if (workflowFetchError) {
-        throw new Error(`Extension "${slug}" was not found in plugin registry, and workflow registry lookup failed: ${workflowFetchError.message}`);
-    }
-    throw new Error(`Extension "${slug}" not found in workflow or plugin registry`);
-}
-export class ExtensionManagementHandlers {
-    ctx;
-    constructor(ctx) {
-        this.ctx = ctx;
-    }
-    async handleListExtensions() {
-        try {
-            const result = this.ctx.listExtensions();
-            return asJsonResponse({ success: true, ...result });
-        }
-        catch (error) {
-            logger.error('Failed to list extensions:', error);
-            return asJsonResponse(serializeError(error));
-        }
-    }
-    async handleReloadExtensions() {
-        try {
-            const result = await this.ctx.reloadExtensions();
-            return asJsonResponse({ success: true, ...result });
-        }
-        catch (error) {
-            logger.error('Failed to reload extensions:', error);
-            return asJsonResponse(serializeError(error));
-        }
-    }
-    async handleBrowseExtensionRegistry(kind) {
-        try {
-            const registryBase = getRegistryBaseUrl();
-            const showPlugins = kind === 'all' || kind === 'plugin';
-            const showWorkflows = kind === 'all' || kind === 'workflow';
-            const result = { success: true };
-            let stale = false;
-            const pluginPromise = showPlugins
-                ? fetchJson(`${registryBase}/plugins.index.json`, {
-                    cacheKey: 'plugins',
-                })
-                : undefined;
-            const workflowPromise = showWorkflows
-                ? fetchJson(`${registryBase}/workflows.index.json`, {
-                    cacheKey: 'workflows',
-                })
-                : undefined;
-            const [pluginIndex, workflowIndex] = await Promise.all([
-                pluginPromise ?? Promise.resolve(undefined),
-                workflowPromise ?? Promise.resolve(undefined),
-            ]);
-            if (pluginIndex) {
-                const plugins = Array.isArray(pluginIndex.data.plugins) ? pluginIndex.data.plugins : [];
-                result.plugins = plugins.map((p) => ({
-                    slug: p.slug,
-                    id: p.id,
-                    name: p.meta.name,
-                    description: p.meta.description,
-                    author: p.meta.author,
-                    repo: p.source.repo,
-                    commit: p.source.commit,
-                    entry: p.source.entry,
-                }));
-                result.pluginCount = plugins.length;
-                result.pluginSource = pluginIndex.source;
-                stale = stale || pluginIndex.stale;
-            }
-            if (workflowIndex) {
-                const workflows = Array.isArray(workflowIndex.data.workflows)
-                    ? workflowIndex.data.workflows
-                    : [];
-                result.workflows = workflows.map((w) => ({
-                    slug: w.slug,
-                    id: w.id,
-                    name: w.meta.name,
-                    description: w.meta.description,
-                    author: w.meta.author,
-                    repo: w.source.repo,
-                    commit: w.source.commit,
-                    entry: w.source.entry,
-                }));
-                result.workflowCount = workflows.length;
-                result.workflowSource = workflowIndex.source;
-                stale = stale || workflowIndex.stale;
-            }
-            if (stale) {
-                result.stale = true;
-            }
-            return asJsonResponse(result);
-        }
-        catch (error) {
-            logger.error('Failed to browse extension registry:', error);
-            if (error instanceof RegistryFetchError) {
-                return asJsonResponse(serializeRegistryFetchError(error));
-            }
-            return asJsonResponse(serializeError(error));
-        }
-    }
-    async handleInstallExtension(slug, targetDir) {
-        try {
-            const registryBase = getRegistryBaseUrl();
-            const { entry, kind } = await findRegistryEntryBySlug(registryBase, slug);
-            const isWorkflow = kind === 'workflow';
-            const defaultRoot = resolveDefaultExtensionRoot(isWorkflow ? 'workflow' : 'plugin');
-            const installDir = targetDir ? resolve(targetDir) : resolve(defaultRoot, slug);
-            const projectDir = resolveExtensionProjectDir(installDir, entry.source.subpath);
-            const entryFile = resolveExtensionEntryFile(projectDir, entry.source.entry);
-            if (existsSync(installDir)) {
-                return asJsonResponse({
-                    success: false,
-                    error: `Target directory already exists: ${installDir}`,
-                    hint: 'Remove the existing directory first, or specify a different targetDir',
-                });
-            }
-            await mkdir(dirname(installDir), { recursive: true });
-            await execFileAsync('git', ['clone', entry.source.repo, installDir], {
-                timeout: EXTENSION_GIT_CLONE_TIMEOUT_MS,
-            });
-            await execFileAsync('git', ['-C', installDir, 'checkout', entry.source.commit], {
-                timeout: EXTENSION_GIT_CHECKOUT_TIMEOUT_MS,
-            });
-            const packageJsonPath = resolve(projectDir, 'package.json');
-            if (existsSync(packageJsonPath)) {
-                await rewriteLocalExtensionSdkDependency(projectDir);
-                const packageManager = await resolvePackageManager(projectDir);
-                const installArgs = packageManager === 'pnpm'
-                    ? ['--ignore-workspace', 'install', '--no-frozen-lockfile']
-                    : ['install'];
-                await execPackageManager(packageManager, installArgs, {
-                    cwd: projectDir,
-                    timeout: Math.max(EXTENSION_GIT_CLONE_TIMEOUT_MS, 120_000),
-                });
-                const buildArgs = packageManager === 'pnpm'
-                    ? ['--ignore-workspace', 'run', '--if-present', 'build']
-                    : ['run', 'build', '--if-present'];
-                await execPackageManager(packageManager, buildArgs, {
-                    cwd: projectDir,
-                    timeout: Math.max(EXTENSION_GIT_CLONE_TIMEOUT_MS, 120_000),
-                });
-            }
-            if (!existsSync(entryFile)) {
-                return asJsonResponse({
-                    success: false,
-                    error: `Installed extension entry not found: ${entry.source.entry}`,
-                    installDir,
-                    projectDir,
-                    expectedEntryFile: entryFile,
-                    hint: 'The registry source.entry must exist after clone/build before reloadExtensions can load it.',
-                });
-            }
-            const metadataPath = await writeInstalledExtensionMetadata(isWorkflow ? 'workflow' : 'plugin', entry, projectDir);
-            const reloadResult = await this.ctx.reloadExtensions();
-            return asJsonResponse({
-                success: true,
-                installed: {
-                    slug: entry.slug,
-                    id: entry.id,
-                    name: entry.meta.name,
-                    repo: entry.source.repo,
-                    commit: entry.source.commit,
-                    installDir,
-                    projectDir,
-                    entry: entry.source.entry,
-                    entryFile,
-                    metadataPath,
-                },
-                reload: {
-                    addedTools: reloadResult.addedTools,
-                    pluginCount: reloadResult.pluginCount,
-                    workflowCount: reloadResult.workflowCount,
-                    errors: reloadResult.errors,
-                    warnings: reloadResult.warnings,
-                },
-            });
-        }
-        catch (error) {
-            logger.error('Failed to install extension:', error);
-            return asJsonResponse(serializeError(error));
-        }
-    }
-}

package/dist/src/server/domains/maintenance/handlers.js

@@ -1,141 +0,0 @@
-import { logger } from '../../../utils/logger.js';
-import {} from '../../../utils/TokenBudgetManager.js';
-import {} from '../../../utils/UnifiedCacheManager.js';
-import { asJsonResponse, serializeError } from '../../domains/shared/response.js';
-import { cleanupArtifacts } from '../../../utils/artifactRetention.js';
-import { runEnvironmentDoctor } from '../../../utils/environmentDoctor.js';
-export class CoreMaintenanceHandlers {
-    tokenBudget;
-    unifiedCache;
-    artifactCleanup;
-    environmentDoctor;
-    constructor(deps) {
-        this.tokenBudget = deps.tokenBudget;
-        this.unifiedCache = deps.unifiedCache;
-        this.artifactCleanup = deps.artifactCleanup ?? cleanupArtifacts;
-        this.environmentDoctor = deps.environmentDoctor ?? runEnvironmentDoctor;
-    }
-    async handleGetTokenBudgetStats() {
-        try {
-            const stats = this.tokenBudget.getStats();
-            return asJsonResponse({
-                success: true,
-                ...stats,
-                sessionDuration: `${Math.round((Date.now() - stats.sessionStartTime) / 1000)}s`,
-            });
-        }
-        catch (error) {
-            logger.error('Failed to read token budget stats:', error);
-            return asJsonResponse(serializeError(error));
-        }
-    }
-    async handleManualTokenCleanup() {
-        try {
-            const beforeStats = this.tokenBudget.getStats();
-            this.tokenBudget.manualCleanup();
-            const afterStats = this.tokenBudget.getStats();
-            const freed = beforeStats.currentUsage - afterStats.currentUsage;
-            return asJsonResponse({
-                success: true,
-                message: 'Manual cleanup completed',
-                before: {
-                    usage: beforeStats.currentUsage,
-                    percentage: beforeStats.usagePercentage,
-                },
-                after: {
-                    usage: afterStats.currentUsage,
-                    percentage: afterStats.usagePercentage,
-                },
-                freed: {
-                    tokens: freed,
-                    percentage: Math.round((freed / beforeStats.maxTokens) * 100),
-                },
-            });
-        }
-        catch (error) {
-            logger.error('Failed to perform manual cleanup:', error);
-            return asJsonResponse(serializeError(error));
-        }
-    }
-    async handleResetTokenBudget() {
-        try {
-            this.tokenBudget.reset();
-            return asJsonResponse({
-                success: true,
-                message: 'Token budget reset successfully',
-                currentUsage: 0,
-                maxTokens: 200000,
-                usagePercentage: 0,
-            });
-        }
-        catch (error) {
-            logger.error('Failed to reset token budget:', error);
-            return asJsonResponse(serializeError(error));
-        }
-    }
-    async handleGetCacheStats() {
-        try {
-            const stats = await this.unifiedCache.getGlobalStats();
-            return asJsonResponse({
-                success: true,
-                ...stats,
-            });
-        }
-        catch (error) {
-            logger.error('Failed to get cache stats:', error);
-            return asJsonResponse(serializeError(error));
-        }
-    }
-    async handleSmartCacheCleanup(targetSize) {
-        try {
-            const result = await this.unifiedCache.smartCleanup(targetSize);
-            return asJsonResponse({
-                success: true,
-                ...result,
-            });
-        }
-        catch (error) {
-            logger.error('Failed to perform cache cleanup:', error);
-            return asJsonResponse(serializeError(error));
-        }
-    }
-    async handleClearAllCaches() {
-        try {
-            await this.unifiedCache.clearAll();
-            return asJsonResponse({
-                success: true,
-                message: 'All caches cleared',
-            });
-        }
-        catch (error) {
-            logger.error('Failed to clear caches:', error);
-            return asJsonResponse(serializeError(error));
-        }
-    }
-    async handleCleanupArtifacts(args) {
-        try {
-            const result = await this.artifactCleanup({
-                retentionDays: args.retentionDays,
-                maxTotalBytes: args.maxTotalBytes,
-                dryRun: args.dryRun,
-            });
-            return asJsonResponse(result);
-        }
-        catch (error) {
-            logger.error('Failed to cleanup artifacts:', error);
-            return asJsonResponse(serializeError(error));
-        }
-    }
-    async handleEnvironmentDoctor(args) {
-        try {
-            const report = await this.environmentDoctor({
-                includeBridgeHealth: args.includeBridgeHealth,
-            });
-            return asJsonResponse(report);
-        }
-        catch (error) {
-            logger.error('Failed to run environment doctor:', error);
-            return asJsonResponse(serializeError(error));
-        }
-    }
-}

package/dist/src/server/domains/maintenance/index.d.ts

@@ -1,3 +0,0 @@
-export { tokenBudgetTools, cacheTools, extensionTools, artifactTools, } from '../../domains/maintenance/definitions.js';
-export { CoreMaintenanceHandlers } from '../../domains/maintenance/handlers.js';
-export { ExtensionManagementHandlers } from '../../domains/maintenance/handlers.extensions.js';

package/dist/src/server/domains/maintenance/index.js

@@ -1,3 +0,0 @@
-export { tokenBudgetTools, cacheTools, extensionTools, artifactTools, } from '../../domains/maintenance/definitions.js';
-export { CoreMaintenanceHandlers } from '../../domains/maintenance/handlers.js';
-export { ExtensionManagementHandlers } from '../../domains/maintenance/handlers.extensions.js';