vibesane 0.0.0-stage → 0.1.0

package/dist/scanner/port-detector.d.ts

@@ -0,0 +1,48 @@
+export declare const DEFAULT_PORTS: readonly [3000, 3001, 5173, 5174, 8080, 8000, 4321];
+export declare const DEFAULT_TCP_TIMEOUT_MS = 300;
+export declare const DEFAULT_HTTP_TIMEOUT_MS = 2000;
+export declare const DEFAULT_BODY_READ_TIMEOUT_MS = 500;
+export declare const MAX_BODY_BYTES: number;
+export type LoopbackHost = '127.0.0.1' | '::1';
+export type DetectionFailureReason = 'no_server' | 'non_http' | 'http_timeout';
+export interface PortDetectorOptions {
+    port?: number;
+    ports?: readonly number[];
+    tcpTimeoutMs?: number;
+    httpTimeoutMs?: number;
+}
+export interface TcpProbeResult {
+    port: number;
+    open: boolean;
+    host?: LoopbackHost;
+    elapsedMs: number;
+}
+export interface RootHttpSnapshot {
+    path: string;
+    statusCode: number;
+    contentType: string;
+    location?: string;
+    body: string;
+    headersElapsedMs: number;
+    truncated: boolean;
+}
+export interface PortDetectionResult {
+    ok: boolean;
+    port: number | null;
+    host?: LoopbackHost;
+    url?: string;
+    statusCode?: number;
+    elapsedMs: number;
+    alsoActivePorts: number[];
+    checkedPorts: number[];
+    reason?: DetectionFailureReason;
+    rootResponse?: RootHttpSnapshot;
+}
+export declare function assertValidPort(port: number): void;
+export declare function assertValidTimeout(ms: number, name?: string): void;
+export declare function readBoundedTextBody(res: Response, maxBytes?: number, bodyTimeoutMs?: number): Promise<{
+    body: string;
+    truncated: boolean;
+}>;
+export declare function probeTcpPort(port: number, tcpTimeoutMs?: number, signal?: AbortSignal): Promise<TcpProbeResult>;
+export declare function detectServer(options?: PortDetectorOptions): Promise<PortDetectionResult>;

package/dist/scanner/port-detector.js

@@ -0,0 +1,335 @@
+import net from 'node:net';
+import { performance } from 'node:perf_hooks';
+export const DEFAULT_PORTS = [3000, 3001, 5173, 5174, 8080, 8000, 4321];
+export const DEFAULT_TCP_TIMEOUT_MS = 300;
+export const DEFAULT_HTTP_TIMEOUT_MS = 2000;
+export const DEFAULT_BODY_READ_TIMEOUT_MS = 500;
+export const MAX_BODY_BYTES = 1024 * 1024;
+export function assertValidPort(port) {
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new RangeError(`Invalid port "${port}": expected integer between 1 and 65535`);
+    }
+}
+export function assertValidTimeout(ms, name = 'timeout') {
+    if (typeof ms !== 'number' || !Number.isFinite(ms) || ms <= 0) {
+        throw new RangeError(`Invalid ${name} "${ms}": expected positive finite number`);
+    }
+}
+function isTextLikeContentType(contentType) {
+    const lower = contentType.toLowerCase();
+    if (lower === '') {
+        return true;
+    }
+    return (lower.includes('text/') ||
+        lower.includes('html') ||
+        lower.includes('json') ||
+        lower.includes('javascript') ||
+        lower.includes('ecmascript') ||
+        lower.includes('xml'));
+}
+export async function readBoundedTextBody(res, maxBytes = MAX_BODY_BYTES, bodyTimeoutMs = DEFAULT_BODY_READ_TIMEOUT_MS) {
+    const contentType = (res.headers.get('content-type') ?? '').toLowerCase();
+    if (!isTextLikeContentType(contentType)) {
+        await res.body?.cancel().catch(() => { });
+        return { body: '', truncated: false };
+    }
+    if (!res.body) {
+        return { body: '', truncated: false };
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder('utf-8');
+    const parts = [];
+    let totalBytes = 0;
+    let truncated = false;
+    let timedOut = false;
+    let timer = null;
+    const timeoutPromise = new Promise((resolve) => {
+        timer = setTimeout(() => {
+            timedOut = true;
+            truncated = true;
+            void reader.cancel().catch(() => { });
+            resolve({ kind: 'timeout' });
+        }, bodyTimeoutMs);
+    });
+    try {
+        while (!timedOut) {
+            const readPromise = reader.read().then((result) => ({ kind: 'chunk', result }), () => ({ kind: 'error' }));
+            const outcome = await Promise.race([readPromise, timeoutPromise]);
+            if (outcome.kind === 'timeout') {
+                truncated = true;
+                break;
+            }
+            if (outcome.kind === 'error') {
+                truncated = true;
+                await reader.cancel().catch(() => { });
+                break;
+            }
+            const { done, value: chunk } = outcome.result;
+            if (done) {
+                break;
+            }
+            if (!chunk || chunk.byteLength === 0) {
+                continue;
+            }
+            const remaining = maxBytes - totalBytes;
+            if (chunk.byteLength >= remaining) {
+                const slice = chunk.subarray(0, remaining);
+                if (slice.byteLength > 0) {
+                    parts.push(decoder.decode(slice, { stream: true }));
+                    totalBytes += slice.byteLength;
+                }
+                truncated = true;
+                await reader.cancel().catch(() => { });
+                break;
+            }
+            parts.push(decoder.decode(chunk, { stream: true }));
+            totalBytes += chunk.byteLength;
+        }
+    }
+    catch {
+        truncated = true;
+        await reader.cancel().catch(() => { });
+    }
+    finally {
+        if (timer !== null) {
+            clearTimeout(timer);
+        }
+    }
+    parts.push(decoder.decode());
+    return { body: parts.join(''), truncated };
+}
+export function probeTcpPort(port, tcpTimeoutMs = DEFAULT_TCP_TIMEOUT_MS, signal) {
+    assertValidPort(port);
+    assertValidTimeout(tcpTimeoutMs, 'tcpTimeoutMs');
+    const startedAt = performance.now();
+    return new Promise((resolve) => {
+        if (signal?.aborted) {
+            resolve({
+                port,
+                open: false,
+                elapsedMs: Math.max(0, Math.round(performance.now() - startedAt)),
+            });
+            return;
+        }
+        let settled = false;
+        let failedCount = 0;
+        const hosts = ['127.0.0.1', '::1'];
+        const sockets = [];
+        const onAbort = () => {
+            finish(false);
+        };
+        const timer = setTimeout(() => {
+            finish(false);
+        }, tcpTimeoutMs);
+        const cleanup = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', onAbort);
+            for (const socket of sockets) {
+                socket.removeAllListeners();
+                socket.destroy();
+            }
+        };
+        const finish = (open, winningHost) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            const elapsedMs = Math.max(0, Math.round(performance.now() - startedAt));
+            if (open && winningHost) {
+                resolve({ port, open: true, host: winningHost, elapsedMs });
+            }
+            else {
+                resolve({ port, open: false, elapsedMs });
+            }
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+        for (const host of hosts) {
+            const socket = net.createConnection({ host, port });
+            sockets.push(socket);
+            socket.once('connect', () => {
+                finish(true, host);
+            });
+            socket.once('error', () => {
+                failedCount += 1;
+                if (failedCount >= hosts.length) {
+                    finish(false);
+                }
+            });
+        }
+    });
+}
+export async function detectServer(options = {}) {
+    const startedAt = performance.now();
+    const tcpTimeoutMs = options.tcpTimeoutMs ?? DEFAULT_TCP_TIMEOUT_MS;
+    const httpTimeoutMs = options.httpTimeoutMs ?? DEFAULT_HTTP_TIMEOUT_MS;
+    assertValidTimeout(tcpTimeoutMs, 'tcpTimeoutMs');
+    assertValidTimeout(httpTimeoutMs, 'httpTimeoutMs');
+    let checkedPorts;
+    if (options.port !== undefined) {
+        assertValidPort(options.port);
+        checkedPorts = [options.port];
+    }
+    else if (options.ports !== undefined) {
+        if (options.ports.length === 0) {
+            throw new RangeError('ports list cannot be empty');
+        }
+        for (const p of options.ports) {
+            assertValidPort(p);
+        }
+        checkedPorts = [...new Set(options.ports)];
+    }
+    else {
+        checkedPorts = [...DEFAULT_PORTS];
+    }
+    const controllers = checkedPorts.map(() => new AbortController());
+    const results = new Array(checkedPorts.length).fill(null);
+    let winnerIndex = -1;
+    let resolveStage1;
+    const stage1Done = new Promise((resolve) => {
+        resolveStage1 = resolve;
+    });
+    let graceStarted = false;
+    let graceTimer = null;
+    let settledStage1 = false;
+    const finishStage1 = () => {
+        if (settledStage1) {
+            return;
+        }
+        settledStage1 = true;
+        if (graceTimer !== null) {
+            clearTimeout(graceTimer);
+            graceTimer = null;
+        }
+        if (winnerIndex !== -1) {
+            for (let k = winnerIndex + 1; k < checkedPorts.length; k++) {
+                if (results[k] === null) {
+                    controllers[k].abort();
+                }
+            }
+        }
+        resolveStage1();
+    };
+    const evaluateProgress = () => {
+        if (settledStage1) {
+            return;
+        }
+        if (winnerIndex === -1) {
+            let candidate = -1;
+            for (let i = 0; i < checkedPorts.length; i++) {
+                const res = results[i];
+                if (res === null) {
+                    break;
+                }
+                if (res.open) {
+                    candidate = i;
+                    break;
+                }
+            }
+            if (candidate !== -1) {
+                winnerIndex = candidate;
+            }
+            else {
+                const allFinished = results.every((r) => r !== null);
+                if (allFinished) {
+                    finishStage1();
+                }
+                return;
+            }
+        }
+        const anyLowerPriorityPending = results
+            .slice(winnerIndex + 1)
+            .some((r) => r === null);
+        if (!anyLowerPriorityPending) {
+            finishStage1();
+            return;
+        }
+        if (!graceStarted) {
+            graceStarted = true;
+            const graceMs = Math.min(15, Math.floor(tcpTimeoutMs / 5));
+            if (graceMs <= 0) {
+                finishStage1();
+            }
+            else {
+                graceTimer = setTimeout(() => {
+                    finishStage1();
+                }, graceMs);
+            }
+        }
+    };
+    const probePromises = checkedPorts.map((port, index) => probeTcpPort(port, tcpTimeoutMs, controllers[index].signal).then((res) => {
+        results[index] = res;
+        evaluateProgress();
+        return res;
+    }));
+    await stage1Done;
+    await Promise.all(probePromises);
+    if (winnerIndex === -1) {
+        return {
+            ok: false,
+            port: null,
+            elapsedMs: Math.max(0, Math.round(performance.now() - startedAt)),
+            alsoActivePorts: [],
+            checkedPorts,
+            reason: 'no_server',
+        };
+    }
+    const winner = results[winnerIndex];
+    const winnerPort = winner.port;
+    const winnerHost = winner.host ?? '127.0.0.1';
+    const alsoActivePorts = [];
+    for (let k = winnerIndex + 1; k < checkedPorts.length; k++) {
+        const res = results[k];
+        if (res?.open) {
+            alsoActivePorts.push(checkedPorts[k]);
+        }
+    }
+    const fetchHost = winnerHost === '::1' ? '[::1]' : '127.0.0.1';
+    const targetUrl = `http://${fetchHost}:${winnerPort}/`;
+    const displayUrl = `http://localhost:${winnerPort}`;
+    try {
+        const fetchStart = performance.now();
+        const res = await fetch(targetUrl, {
+            method: 'GET',
+            redirect: 'manual',
+            signal: AbortSignal.timeout(httpTimeoutMs),
+        });
+        const headersElapsedMs = Math.max(0, Math.round(performance.now() - fetchStart));
+        const contentType = res.headers.get('content-type') ?? '';
+        const location = res.headers.get('location') ?? undefined;
+        const { body, truncated } = await readBoundedTextBody(res, MAX_BODY_BYTES, DEFAULT_BODY_READ_TIMEOUT_MS);
+        return {
+            ok: true,
+            port: winnerPort,
+            host: winnerHost,
+            url: displayUrl,
+            statusCode: res.status,
+            elapsedMs: Math.max(0, Math.round(performance.now() - startedAt)),
+            alsoActivePorts,
+            checkedPorts,
+            rootResponse: {
+                path: '/',
+                statusCode: res.status,
+                contentType,
+                location,
+                body,
+                headersElapsedMs,
+                truncated,
+            },
+        };
+    }
+    catch (err) {
+        const isTimeout = err instanceof Error &&
+            (err.name === 'TimeoutError' || err.name === 'AbortError');
+        return {
+            ok: false,
+            port: winnerPort,
+            host: winnerHost,
+            url: displayUrl,
+            elapsedMs: Math.max(0, Math.round(performance.now() - startedAt)),
+            alsoActivePorts,
+            checkedPorts,
+            reason: isTimeout ? 'http_timeout' : 'non_http',
+        };
+    }
+}

package/dist/scanner/route-crawler.d.ts

@@ -0,0 +1,39 @@
+import { type LoopbackHost, type RootHttpSnapshot } from './port-detector.js';
+import { type SanityIssue } from './security-scan.js';
+export declare const DEFAULT_SCAN_BUDGET_MS = 2500;
+export declare const DEFAULT_ROUTE_TIMEOUT_MS = 2000;
+export declare const DEFAULT_SLOW_ROUTE_MS = 1500;
+export declare const DEFAULT_MAX_ROUTES = 10;
+export declare const DEFAULT_MAX_SCRIPTS = 5;
+export declare const DEFAULT_MAX_CONCURRENCY = 4;
+export declare const MAX_REDIRECTS = 3;
+export interface RouteScanItem {
+    path: string;
+    statusCode?: number;
+    contentType?: string;
+    headersElapsedMs?: number;
+    truncated?: boolean;
+    skipped?: boolean;
+}
+export interface SanityScanOptions {
+    scanBudgetMs?: number;
+    routeTimeoutMs?: number;
+    slowRouteMs?: number;
+    maxRoutes?: number;
+    maxScripts?: number;
+    maxConcurrency?: number;
+}
+export interface SanityScanSummary {
+    routes: RouteScanItem[];
+    scannedScripts: string[];
+    skippedRoutes: string[];
+    issues: SanityIssue[];
+}
+export declare function isExcludedFrameworkScript(pathOrUrl: string): boolean;
+export declare function getScriptPriority(pathOrUrl: string): 1 | 2;
+export declare function extractInternalLinks(html: string, baseOrigin: string, maxSubRoutes: number): string[];
+export declare function extractCandidateScripts(html: string, baseOrigin: string, maxScripts: number): string[];
+export declare function selectScriptsToFetch(input: string | readonly string[], baseOriginOrMaxScripts?: string | number, maxScripts?: number): string[];
+export declare function extractModuleImports(jsContent: string, scriptPath: string, baseOrigin: string): string[];
+export declare function fetchSameOriginHop(baseUrl: string, initialPath: string, signal: AbortSignal, routeTimeoutMs: number, followRedirects?: boolean): Promise<RootHttpSnapshot>;
+export declare function runSanityScan(host: LoopbackHost, port: number, rootResponse: RootHttpSnapshot, options?: SanityScanOptions): Promise<SanityScanSummary>;