FM / lib

/opt/canhelp/node_modules/next/dist/esm/server/lib/

/opt/canhelp/node_modules/next/dist/esm/server/lib

Name	Size	Mode	Actions
cache-handlers/	-	0755	rm
experimental/	-	0755	rm
incremental-cache/	-	0755	rm
module-loader/	-	0755	rm
router-utils/	-	0755	rm
server-ipc/	-	0755	rm
trace/	-	0755	rm
app-dir-module.js	1164	0644	edit dl rm
app-dir-module.js.map	2598	0644	edit dl rm
app-info-log.js	2723	0644	edit dl rm
app-info-log.js.map	5827	0644	edit dl rm
async-callback-set.js	519	0644	edit dl rm
async-callback-set.js.map	1097	0644	edit dl rm
cache-control.js	583	0644	edit dl rm
cache-control.js.map	1622	0644	edit dl rm
chrome-devtools-workspace.js	2297	0644	edit dl rm
chrome-devtools-workspace.js.map	4145	0644	edit dl rm
clone-response.js	2883	0644	edit dl rm
clone-response.js.map	4441	0644	edit dl rm
cpu-profile.js	1020	0644	edit dl rm
cpu-profile.js.map	2061	0644	edit dl rm
decode-query-path-parameter.js	458	0644	edit dl rm
decode-query-path-parameter.js.map	740	0644	edit dl rm
dedupe-fetch.js	5085	0644	edit dl rm
dedupe-fetch.js.map	7374	0644	edit dl rm
dev-bundler-service.js	3110	0644	edit dl rm
dev-bundler-service.js.map	5838	0644	edit dl rm
disk-lru-cache.external.js	1857	0644	edit dl rm
disk-lru-cache.external.js.map	3149	0644	edit dl rm
etag.js	1148	0644	edit dl rm
etag.js.map	2165	0644	edit dl rm
find-page-file.js	5445	0644	edit dl rm
find-page-file.js.map	9480	0644	edit dl rm
fix-mojibake.js	523	0644	edit dl rm
fix-mojibake.js.map	1026	0644	edit dl rm
format-hostname.js	332	0644	edit dl rm
format-hostname.js.map	616	0644	edit dl rm
i18n-provider.js	5531	0644	edit dl rm
i18n-provider.js.map	9041	0644	edit dl rm
implicit-tags.js	2450	0644	edit dl rm
implicit-tags.js.map	5238	0644	edit dl rm
is-ipv6.js	2090	0644	edit dl rm
is-ipv6.js.map	3388	0644	edit dl rm
lazy-result.js	939	0644	edit dl rm
lazy-result.js.map	1869	0644	edit dl rm
lru-cache.js	7148	0644	edit dl rm
lru-cache.js.map	11374	0644	edit dl rm
match-next-data-pathname.js	312	0644	edit dl rm
match-next-data-pathname.js.map	629	0644	edit dl rm
mock-request.js	13753	0644	edit dl rm
mock-request.js.map	21224	0644	edit dl rm
node-fs-methods.js	364	0644	edit dl rm
node-fs-methods.js.map	946	0644	edit dl rm
parse-stack.js	1561	0644	edit dl rm
parse-stack.js.map	2983	0644	edit dl rm
patch-fetch.js	44939	0644	edit dl rm
patch-fetch.js.map	64721	0644	edit dl rm
patch-set-header.js	1368	0644	edit dl rm
patch-set-header.js.map	2471	0644	edit dl rm
render-server.js	2988	0644	edit dl rm
render-server.js.map	6276	0644	edit dl rm
router-server.js	30029	0644	edit dl rm
router-server.js.map	46752	0644	edit dl rm
server-action-request-meta.js	1530	0644	edit dl rm
server-action-request-meta.js.map	3030	0644	edit dl rm
source-maps.js	8172	0644	edit dl rm
source-maps.js.map	14812	0644	edit dl rm
start-server.js	16797	0644	edit dl rm
start-server.js.map	27727	0644	edit dl rm
streaming-metadata.js	762	0644	edit dl rm
streaming-metadata.js.map	1582	0644	edit dl rm
to-route.js	582	0644	edit dl rm
to-route.js.map	848	0644	edit dl rm
types.js	46	0644	edit dl rm
types.js.map	451	0644	edit dl rm
utils.js	8516	0644	edit dl rm
utils.js.map	13627	0644	edit dl rm
worker-utils.js	755	0644	edit dl rm
worker-utils.js.map	1120	0644	edit dl rm

Edit: /opt/canhelp/node_modules/next/dist/esm/server/lib/start-server.js (16797B)

// Start CPU profile if it wasn't already started.
import './cpu-profile';
import { getNetworkHost } from '../../lib/get-network-host';
if (performance.getEntriesByName('next-start').length === 0) {
    performance.mark('next-start');
}
import '../next';
import '../require-hook';
import fs from 'fs';
import v8 from 'v8';
import path from 'path';
import http from 'http';
import https from 'https';
import os from 'os';
import { exec } from 'child_process';
import Watchpack from 'next/dist/compiled/watchpack';
import * as Log from '../../build/output/log';
import setupDebug from 'next/dist/compiled/debug';
import { RESTART_EXIT_CODE, getFormattedDebugAddress, getNodeDebugType } from './utils';
import { formatHostname } from './format-hostname';
import { initialize } from './router-server';
import { CONFIG_FILES } from '../../shared/lib/constants';
import { getStartServerInfo, logStartInfo } from './app-info-log';
import { validateTurboNextConfig } from '../../lib/turbopack-warning';
import { trace, flushAllTraces } from '../../trace';
import { isIPv6 } from './is-ipv6';
import { AsyncCallbackSet } from './async-callback-set';
const debug = setupDebug('next:start-server');
let startServerSpan;
/**
 * Get the process ID (PID) of the process using the specified port
 */ async function getProcessIdUsingPort(port) {
    const timeoutMs = 250;
    const processLookupController = new AbortController();
    const pidPromise = new Promise((resolve)=>{
        const handleError = (error)=>{
            debug('Failed to get process ID for port', port, error);
            resolve(null);
        };
        try {
            // Use lsof on Unix-like systems (macOS, Linux)
            if (process.platform !== 'win32') {
                exec(`lsof -ti:${port} -sTCP:LISTEN`, {
                    signal: processLookupController.signal
                }, (error, stdout)=>{
                    if (error) {
                        handleError(error);
                        return;
                    }
                    // `-sTCP` will ensure there's only one port, clean up output
                    const pid = stdout.trim();
                    resolve(pid || null);
                });
            } else {
                // Use netstat on Windows
                exec(`netstat -ano | findstr /C:":${port} " | findstr LISTENING`, {
                    signal: processLookupController.signal
                }, (error, stdout)=>{
                    if (error) {
                        handleError(error);
                        return;
                    }
                    // Clean up output and extract PID
                    const cleanOutput = stdout.replace(/\s+/g, ' ').trim();
                    if (cleanOutput) {
                        const lines = cleanOutput.split('\n');
                        const firstLine = lines[0].trim();
                        if (firstLine) {
                            const parts = firstLine.split(' ');
                            const pid = parts[parts.length - 1];
                            resolve(pid || null);
                        } else {
                            resolve(null);
                        }
                    } else {
                        resolve(null);
                    }
                });
            }
        } catch (cause) {
            handleError(Object.defineProperty(new Error('Unexpected error during process lookup', {
                cause
            }), "__NEXT_ERROR_CODE", {
                value: "E713",
                enumerable: false,
                configurable: true
            }));
        }
    });
    const timeoutId = setTimeout(()=>{
        processLookupController.abort(`PID detection timed out after ${timeoutMs}ms for port ${port}.`);
    }, timeoutMs);
    pidPromise.finally(()=>clearTimeout(timeoutId));
    return pidPromise;
}
export async function getRequestHandlers({ dir, port, isDev, onDevServerCleanup, server, hostname, minimalMode, keepAliveTimeout, experimentalHttpsServer, quiet }) {
    return initialize({
        dir,
        port,
        hostname,
        onDevServerCleanup,
        dev: isDev,
        minimalMode,
        server,
        keepAliveTimeout,
        experimentalHttpsServer,
        startServerSpan,
        quiet
    });
}
export async function startServer(serverOptions) {
    const { dir, isDev, hostname, minimalMode, allowRetry, keepAliveTimeout, selfSignedCertificate } = serverOptions;
    let { port } = serverOptions;
    process.title = `next-server (v${"15.5.14"})`;
    let handlersReady = ()=>{};
    let handlersError = ()=>{};
    let handlersPromise = new Promise((resolve, reject)=>{
        handlersReady = resolve;
        handlersError = reject;
    });
    let requestHandler = async (req, res)=>{
        if (handlersPromise) {
            await handlersPromise;
            return requestHandler(req, res);
        }
        throw Object.defineProperty(new Error('Invariant request handler was not setup'), "__NEXT_ERROR_CODE", {
            value: "E287",
            enumerable: false,
            configurable: true
        });
    };
    let upgradeHandler = async (req, socket, head)=>{
        if (handlersPromise) {
            await handlersPromise;
            return upgradeHandler(req, socket, head);
        }
        throw Object.defineProperty(new Error('Invariant upgrade handler was not setup'), "__NEXT_ERROR_CODE", {
            value: "E290",
            enumerable: false,
            configurable: true
        });
    };
    let nextServer;
    // setup server listener as fast as possible
    if (selfSignedCertificate && !isDev) {
        throw Object.defineProperty(new Error('Using a self signed certificate is only supported with `next dev`.'), "__NEXT_ERROR_CODE", {
            value: "E128",
            enumerable: false,
            configurable: true
        });
    }
    async function requestListener(req, res) {
        try {
            if (handlersPromise) {
                await handlersPromise;
                handlersPromise = undefined;
            }
            await requestHandler(req, res);
        } catch (err) {
            res.statusCode = 500;
            res.end('Internal Server Error');
            Log.error(`Failed to handle request for ${req.url}`);
            console.error(err);
        } finally{
            if (isDev) {
                if (v8.getHeapStatistics().used_heap_size > 0.8 * v8.getHeapStatistics().heap_size_limit) {
                    Log.warn(`Server is approaching the used memory threshold, restarting...`);
                    trace('server-restart-close-to-memory-threshold', undefined, {
                        'memory.heapSizeLimit': String(v8.getHeapStatistics().heap_size_limit),
                        'memory.heapUsed': String(v8.getHeapStatistics().used_heap_size)
                    }).stop();
                    await flushAllTraces();
                    process.exit(RESTART_EXIT_CODE);
                }
            }
        }
    }
    const server = selfSignedCertificate ? https.createServer({
        key: fs.readFileSync(selfSignedCertificate.key),
        cert: fs.readFileSync(selfSignedCertificate.cert)
    }, requestListener) : http.createServer(requestListener);
    if (keepAliveTimeout) {
        server.keepAliveTimeout = keepAliveTimeout;
    }
    server.on('upgrade', async (req, socket, head)=>{
        try {
            await upgradeHandler(req, socket, head);
        } catch (err) {
            socket.destroy();
            Log.error(`Failed to handle request for ${req.url}`);
            console.error(err);
        }
    });
    let portRetryCount = 0;
    const originalPort = port;
    server.on('error', (err)=>{
        if (allowRetry && port && isDev && err.code === 'EADDRINUSE' && portRetryCount < 10) {
            port += 1;
            portRetryCount += 1;
            server.listen(port, hostname);
        } else {
            Log.error(`Failed to start server`);
            console.error(err);
            process.exit(1);
        }
    });
    let cleanupListeners = isDev ? new AsyncCallbackSet() : undefined;
    await new Promise((resolve)=>{
        server.on('listening', async ()=>{
            const nodeDebugType = getNodeDebugType();
            const addr = server.address();
            const actualHostname = formatHostname(typeof addr === 'object' ? (addr == null ? void 0 : addr.address) || hostname || 'localhost' : addr);
            const formattedHostname = !hostname || actualHostname === '0.0.0.0' ? 'localhost' : actualHostname === '[::]' ? '[::1]' : formatHostname(hostname);
            port = typeof addr === 'object' ? (addr == null ? void 0 : addr.port) || port : port;
            if (portRetryCount) {
                const pid = await getProcessIdUsingPort(originalPort);
                if (pid) {
                    Log.warn(`Port ${originalPort} is in use by process ${pid}, using available port ${port} instead.`);
                } else {
                    Log.warn(`Port ${originalPort} is in use by an unknown process, using available port ${port} instead.`);
                }
            }
            const networkHostname = hostname ?? getNetworkHost(isIPv6(actualHostname) ? 'IPv6' : 'IPv4');
            const protocol = selfSignedCertificate ? 'https' : 'http';
            const networkUrl = networkHostname ? `${protocol}://${formatHostname(networkHostname)}:${port}` : null;
            const appUrl = `${protocol}://${formattedHostname}:${port}`;
            if (nodeDebugType) {
                const formattedDebugAddress = getFormattedDebugAddress();
                Log.info(`the --${nodeDebugType} option was detected, the Next.js router server should be inspected at ${formattedDebugAddress}.`);
            }
            // Store the selected port to:
            // - expose it to render workers
            // - re-use it for automatic dev server restarts with a randomly selected port
            process.env.PORT = port + '';
            process.env.__NEXT_PRIVATE_ORIGIN = appUrl;
            // Set experimental HTTPS flag for metadata resolution
            if (selfSignedCertificate) {
                process.env.__NEXT_EXPERIMENTAL_HTTPS = '1';
            }
            // Only load env and config in dev to for logging purposes
            let envInfo;
            let experimentalFeatures;
            if (isDev) {
                const startServerInfo = await getStartServerInfo({
                    dir,
                    dev: isDev
                });
                envInfo = startServerInfo.envInfo;
                experimentalFeatures = startServerInfo.experimentalFeatures;
            }
            logStartInfo({
                networkUrl,
                appUrl,
                envInfo,
                experimentalFeatures,
                maxExperimentalFeatures: 3
            });
            Log.event(`Starting...`);
            try {
                let cleanupStarted = false;
                let closeUpgraded = null;
                const cleanup = ()=>{
                    if (cleanupStarted) {
                        // We can get duplicate signals, e.g. when `ctrl+c` is used in an
                        // interactive shell (i.e. bash, zsh), the shell will recursively
                        // send SIGINT to children. The parent `next-dev` process will also
                        // send us SIGINT.
                        return;
                    }
                    cleanupStarted = true;
                    (async ()=>{
                        debug('start-server process cleanup');
                        // first, stop accepting new connections and finish pending requests,
                        // because they might affect `nextServer.close()` (e.g. by scheduling an `after`)
                        await new Promise((res)=>{
                            server.close((err)=>{
                                if (err) console.error(err);
                                res();
                            });
                            if (isDev) {
                                server.closeAllConnections();
                                closeUpgraded == null ? void 0 : closeUpgraded();
                            }
                        });
                        // now that no new requests can come in, clean up the rest
                        await Promise.all([
                            nextServer == null ? void 0 : nextServer.close().catch(console.error),
                            cleanupListeners == null ? void 0 : cleanupListeners.runAll().catch(console.error)
                        ]);
                        debug('start-server process cleanup finished');
                        process.exit(0);
                    })();
                };
                // Make sure commands gracefully respect termination signals (e.g. from Docker)
                // Allow the graceful termination to be manually configurable
                if (!process.env.NEXT_MANUAL_SIG_HANDLE) {
                    process.on('SIGINT', cleanup);
                    process.on('SIGTERM', cleanup);
                }
                const initResult = await getRequestHandlers({
                    dir,
                    port,
                    isDev,
                    onDevServerCleanup: cleanupListeners ? cleanupListeners.add.bind(cleanupListeners) : undefined,
                    server,
                    hostname,
                    minimalMode,
                    keepAliveTimeout,
                    experimentalHttpsServer: !!selfSignedCertificate
                });
                requestHandler = initResult.requestHandler;
                upgradeHandler = initResult.upgradeHandler;
                nextServer = initResult.server;
                closeUpgraded = initResult.closeUpgraded;
                const startServerProcessDuration = performance.mark('next-start-end') && performance.measure('next-start-duration', 'next-start', 'next-start-end').duration;
                handlersReady();
                const formatDurationText = startServerProcessDuration > 2000 ? `${Math.round(startServerProcessDuration / 100) / 10}s` : `${Math.round(startServerProcessDuration)}ms`;
                Log.event(`Ready in ${formatDurationText}`);
                if (process.env.TURBOPACK) {
                    await validateTurboNextConfig({
                        dir: serverOptions.dir,
                        isDev: true
                    });
                }
            } catch (err) {
                // fatal error if we can't setup
                handlersError();
                console.error(err);
                process.exit(1);
            }
            resolve();
        });
        server.listen(port, hostname);
    });
    if (isDev) {
        function watchConfigFiles(dirToWatch, onChange) {
            const wp = new Watchpack();
            wp.watch({
                files: CONFIG_FILES.map((file)=>path.join(dirToWatch, file))
            });
            wp.on('change', onChange);
        }
        watchConfigFiles(dir, async (filename)=>{
            if (process.env.__NEXT_DISABLE_MEMORY_WATCHER) {
                Log.info(`Detected change, manual restart required due to '__NEXT_DISABLE_MEMORY_WATCHER' usage`);
                return;
            }
            Log.warn(`Found a change in ${path.basename(filename)}. Restarting the server to apply the changes...`);
            process.exit(RESTART_EXIT_CODE);
        });
    }
}
if (process.env.NEXT_PRIVATE_WORKER && process.send) {
    process.addListener('message', async (msg)=>{
        if (msg && typeof msg === 'object' && msg.nextWorkerOptions && process.send) {
            startServerSpan = trace('start-dev-server', undefined, {
                cpus: String(os.cpus().length),
                platform: os.platform(),
                'memory.freeMem': String(os.freemem()),
                'memory.totalMem': String(os.totalmem()),
                'memory.heapSizeLimit': String(v8.getHeapStatistics().heap_size_limit)
            });
            await startServerSpan.traceAsyncFn(()=>startServer(msg.nextWorkerOptions));
            const memoryUsage = process.memoryUsage();
            startServerSpan.setAttribute('memory.rss', String(memoryUsage.rss));
            startServerSpan.setAttribute('memory.heapTotal', String(memoryUsage.heapTotal));
            startServerSpan.setAttribute('memory.heapUsed', String(memoryUsage.heapUsed));
            process.send({
                nextServerReady: true,
                port: process.env.PORT
            });
        }
    });
    process.send({
        nextWorkerReady: true
    });
}

//# sourceMappingURL=start-server.js.map

cmd: