@jshookmcp/jshook 0.2.3 → 0.2.5

package/dist/src/modules/emulator/AIEnvironmentAnalyzer.js

@@ -1,48 +1,9 @@
-import { logger } from '../../utils/logger.js';
-import { generateBrowserEnvAnalysisMessages, generateAntiCrawlAnalysisMessages, generateAPIImplementationMessages, generateEnvironmentSuggestionsMessages, } from '../../services/prompts/environment.js';
 export class AIEnvironmentAnalyzer {
-    llm;
-    constructor(llm) {
-        this.llm = llm;
+    constructor(legacyDependency) {
+        void legacyDependency;
     }
-    async analyze(code, detected, missing, browserType = 'chrome') {
-        if (!this.llm) {
-            logger.warn('LLM service unavailable, skipping AI environment analysis');
-            return this.getEmptyResult();
-        }
-        try {
-            logger.info(' AI...');
-            const response = await this.llm.chat(generateBrowserEnvAnalysisMessages(code, detected, missing, browserType));
-            const result = this.parseAIResponse(response.content);
-            logger.info(`AI environment analysis complete, confidence: ${(result.confidence * 100).toFixed(1)}%`);
-            return result;
-        }
-        catch (error) {
-            logger.error('AI', error);
-            return this.getEmptyResult();
-        }
-    }
-    parseAIResponse(response) {
-        try {
-            const jsonMatch = response.match(/```json\s*([\s\S]*?)\s*```/) || response.match(/\{[\s\S]*\}/);
-            if (!jsonMatch) {
-                logger.warn('AIJSON');
-                return this.getEmptyResult();
-            }
-            const jsonStr = jsonMatch[1] || jsonMatch[0];
-            const parsed = JSON.parse(jsonStr);
-            return {
-                recommendedVariables: parsed.recommendedVariables || {},
-                recommendedAPIs: parsed.recommendedAPIs || [],
-                antiCrawlFeatures: parsed.antiCrawlFeatures || [],
-                suggestions: parsed.suggestions || [],
-                confidence: parsed.confidence || 0.5,
-            };
-        }
-        catch (error) {
-            logger.error('AI', error);
-            return this.getEmptyResult();
-        }
+    async analyze(_code, _detected, _missing, _browserType = 'chrome') {
+        return this.getEmptyResult();
     }
     getEmptyResult() {
         return {
@@ -53,67 +14,14 @@ export class AIEnvironmentAnalyzer {
             confidence: 0,
         };
     }
-    async analyzeAntiCrawl(code) {
-        if (!this.llm) {
-            return [];
-        }
-        try {
-            const response = await this.llm.chat(generateAntiCrawlAnalysisMessages(code));
-            const jsonMatch = response.content.match(/```json\s*([\s\S]*?)\s*```/) ||
-                response.content.match(/\[[\s\S]*\]/);
-            if (jsonMatch) {
-                const jsonStr = jsonMatch[1] || jsonMatch[0];
-                return JSON.parse(jsonStr);
-            }
-            return [];
-        }
-        catch (error) {
-            logger.error('', error);
-            return [];
-        }
+    async analyzeAntiCrawl(_code) {
+        return [];
     }
-    async inferAPIImplementation(apiPath, context) {
-        if (!this.llm) {
-            return null;
-        }
-        try {
-            const response = await this.llm.chat(generateAPIImplementationMessages(apiPath, context));
-            const codeMatch = response.content.match(/```(?:javascript|js)?\s*([\s\S]*?)\s*```/);
-            if (codeMatch?.[1]) {
-                return codeMatch[1].trim();
-            }
-            const trimmed = response.content.trim();
-            if (trimmed.includes('function') || trimmed.includes('const') || trimmed.includes('var')) {
-                return trimmed;
-            }
-            return null;
-        }
-        catch (error) {
-            logger.error('API', error);
-            return null;
-        }
+    async inferAPIImplementation(_apiPath, _context) {
+        return null;
     }
-    async generateSuggestions(detected, missing, browserType) {
-        if (!this.llm) {
-            return this.getDefaultSuggestions(detected, missing);
-        }
-        try {
-            const response = await this.llm.chat(generateEnvironmentSuggestionsMessages(detected, missing, browserType));
-            const jsonMatch = response.content.match(/```json\s*([\s\S]*?)\s*```/) ||
-                response.content.match(/\[[\s\S]*\]/);
-            if (jsonMatch) {
-                const jsonStr = jsonMatch[1] || jsonMatch[0];
-                const suggestions = JSON.parse(jsonStr);
-                if (Array.isArray(suggestions) && suggestions.every((s) => typeof s === 'string')) {
-                    return suggestions;
-                }
-            }
-            return this.getDefaultSuggestions(detected, missing);
-        }
-        catch (error) {
-            logger.error('', error);
-            return this.getDefaultSuggestions(detected, missing);
-        }
+    async generateSuggestions(detected, missing, _browserType) {
+        return this.getDefaultSuggestions(detected, missing);
     }
     getDefaultSuggestions(detected, missing) {
         const suggestions = [];

package/dist/src/modules/emulator/EnvironmentEmulator.d.ts

@@ -1,9 +1,7 @@
 import type { EnvironmentEmulatorOptions, EnvironmentEmulatorResult } from '../../types/index.js';
-import type { LLMService } from '../../services/LLMService.js';
 export declare class EnvironmentEmulator {
     private browser?;
-    private llm?;
-    constructor(llm?: LLMService);
+    constructor(legacyDependency?: unknown);
     analyze(options: EnvironmentEmulatorOptions): Promise<EnvironmentEmulatorResult>;
     private detectEnvironmentVariables;
     private getMemberExpressionPath;
@@ -14,8 +12,6 @@ export declare class EnvironmentEmulator {
     private resolveExecutablePath;
     private identifyMissingAPIs;
     private getSuggestionForMissingAPI;
-    private generateMissingAPIImplementationsWithAI;
-    private inferMissingVariablesWithAI;
     cleanup(): Promise<void>;
     private isRecord;
     private isIdentifierNode;

package/dist/src/modules/emulator/EnvironmentEmulator.js

@@ -3,18 +3,13 @@ import traverse from '@babel/traverse';
 import { existsSync } from 'fs';
 import { logger } from '../../utils/logger.js';
 import { chromeEnvironmentTemplate } from '../emulator/templates/chrome-env.js';
-import { generateMissingAPIImplementationsMessages, generateMissingVariablesMessages, } from '../../services/prompts/environment.js';
 import { generateEmulationCode, generateRecommendations } from '../emulator/EmulatorCodeGen.js';
 import { findBrowserExecutable } from '../../utils/browserExecutable.js';
 import { fetchRealEnvironmentData } from '../emulator/EnvironmentEmulatorFetch.js';
 export class EnvironmentEmulator {
     browser;
-    llm;
-    constructor(llm) {
-        this.llm = llm;
-        if (!llm) {
-            logger.debug('LLM service unavailable, skipping AI environment analysis');
-        }
+    constructor(legacyDependency) {
+        void legacyDependency;
     }
     async analyze(options) {
         const startTime = Date.now();
@@ -31,16 +26,7 @@ export class EnvironmentEmulator {
             else {
                 variableManifest = this.buildManifestFromTemplate(detectedVariables, browserType);
             }
-            if (this.llm) {
-                logger.info(' AI...');
-                const aiInferredVars = await this.inferMissingVariablesWithAI(code, detectedVariables, variableManifest, browserType);
-                Object.assign(variableManifest, { ...aiInferredVars, ...variableManifest });
-            }
             const missingAPIs = this.identifyMissingAPIs(detectedVariables, variableManifest);
-            if (this.llm && missingAPIs.length > 0) {
-                logger.info(` AI ${missingAPIs.length} API...`);
-                await this.generateMissingAPIImplementationsWithAI(missingAPIs, code, variableManifest);
-            }
             logger.info(' ...');
             const emulationCode = generateEmulationCode(variableManifest, targetRuntime, includeComments);
             const recommendations = generateRecommendations(detectedVariables, missingAPIs);
@@ -84,15 +70,14 @@ export class EnvironmentEmulator {
                 sourceType: 'unambiguous',
                 plugins: ['jsx', 'typescript'],
             });
-            const self = this;
             traverse(ast, {
-                MemberExpression(path) {
-                    const fullPath = self.getMemberExpressionPath(path.node);
+                MemberExpression: (path) => {
+                    const fullPath = this.getMemberExpressionPath(path.node);
                     if (fullPath) {
                         accessedPaths.add(fullPath);
                     }
                 },
-                Identifier(path) {
+                Identifier: (path) => {
                     const name = path.node.name;
                     if ([
                         'window',
@@ -132,7 +117,7 @@ export class EnvironmentEmulator {
                 }
             }
             for (const key of Object.keys(detected)) {
-                detected[key] = Array.from(new Set(detected[key])).sort();
+                detected[key] = Array.from(new Set(detected[key])).toSorted();
             }
         }
         catch (error) {
@@ -182,7 +167,7 @@ export class EnvironmentEmulator {
             detected[category].push(...matches);
         }
         for (const key of Object.keys(detected)) {
-            detected[key] = Array.from(new Set(detected[key])).sort();
+            detected[key] = Array.from(new Set(detected[key])).toSorted();
         }
     }
     buildManifestFromTemplate(detected, _browserType) {
@@ -307,75 +292,6 @@ export class EnvironmentEmulator {
             return `null: ${path} = null`;
         }
     }
-    async generateMissingAPIImplementationsWithAI(missingAPIs, code, manifest) {
-        if (!this.llm || missingAPIs.length === 0) {
-            return;
-        }
-        try {
-            const apisToGenerate = missingAPIs.slice(0, 10);
-            const response = await this.llm.chat(generateMissingAPIImplementationsMessages(apisToGenerate, code));
-            const jsonMatch = response.content.match(/```json\s*([\s\S]*?)\s*```/) ||
-                response.content.match(/\{[\s\S]*\}/);
-            if (jsonMatch) {
-                const jsonStr = jsonMatch[1] || jsonMatch[0];
-                const implementations = JSON.parse(jsonStr);
-                if (!this.isRecord(implementations)) {
-                    return;
-                }
-                let addedCount = 0;
-                for (const [path, impl] of Object.entries(implementations)) {
-                    if (typeof impl === 'string' && impl.trim()) {
-                        manifest[path] = impl;
-                        addedCount++;
-                    }
-                }
-                logger.info(` AI ${addedCount} API`);
-            }
-        }
-        catch (error) {
-            logger.error('AIAPI', error);
-        }
-    }
-    async inferMissingVariablesWithAI(code, detected, existingManifest, browserType) {
-        if (!this.llm) {
-            return {};
-        }
-        try {
-            const allDetectedPaths = [
-                ...detected.window,
-                ...detected.document,
-                ...detected.navigator,
-                ...detected.location,
-                ...detected.screen,
-                ...detected.other,
-            ];
-            const missingPaths = allDetectedPaths.filter((path) => !(path in existingManifest));
-            if (missingPaths.length === 0) {
-                logger.info('Environment analysis complete, AI suggestions applied');
-                return {};
-            }
-            logger.info(` AI ${missingPaths.length} ...`);
-            const response = await this.llm.chat(generateMissingVariablesMessages(browserType, missingPaths, code, existingManifest));
-            const jsonMatch = response.content.match(/```json\s*([\s\S]*?)\s*```/) ||
-                response.content.match(/\{[\s\S]*\}/);
-            if (jsonMatch) {
-                const jsonStr = jsonMatch[1] || jsonMatch[0];
-                const inferredVars = JSON.parse(jsonStr);
-                if (!this.isRecord(inferredVars)) {
-                    logger.warn('AIJSON');
-                    return {};
-                }
-                logger.info(` AI ${Object.keys(inferredVars).length} `);
-                return inferredVars;
-            }
-            logger.warn('AIJSON');
-            return {};
-        }
-        catch (error) {
-            logger.error('AI', error);
-            return {};
-        }
-    }
     async cleanup() {
         if (this.browser) {
             await this.browser.close();

package/dist/src/modules/emulator/EnvironmentEmulatorFetch.js

@@ -1,5 +1,6 @@
 import puppeteer from 'rebrowser-puppeteer-core';
 import { logger } from '../../utils/logger.js';
+const launchBrowser = Reflect.get(puppeteer, 'launch');
 export async function fetchRealEnvironmentData(params) {
     const { url, detected, depth, resolveExecutablePath, buildManifestFromTemplate } = params;
     const manifest = {};
@@ -26,67 +27,64 @@ export async function fetchRealEnvironmentData(params) {
             if (executablePath) {
                 launchOptions.executablePath = executablePath;
             }
-            browser = await puppeteer.launch(launchOptions);
+            browser = await launchBrowser(launchOptions);
         }
         page = await browser.newPage();
         await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36');
         await page.evaluateOnNewDocument(() => {
             const typedWindow = window;
-            const setChromeObject = (target) => {
-                target.chrome = {
-                    runtime: {
-                        connect: () => { },
-                        sendMessage: () => { },
-                        onMessage: {
-                            addListener: () => { },
-                            removeListener: () => { },
-                        },
-                    },
-                    loadTimes: function () {
-                        return {
-                            commitLoadTime: Date.now() / 1000 - Math.random() * 10,
-                            connectionInfo: 'http/1.1',
-                            finishDocumentLoadTime: Date.now() / 1000 - Math.random() * 5,
-                            finishLoadTime: Date.now() / 1000 - Math.random() * 3,
-                            firstPaintAfterLoadTime: 0,
-                            firstPaintTime: Date.now() / 1000 - Math.random() * 8,
-                            navigationType: 'Other',
-                            npnNegotiatedProtocol: 'http/1.1',
-                            requestTime: Date.now() / 1000 - Math.random() * 15,
-                            startLoadTime: Date.now() / 1000 - Math.random() * 12,
-                            wasAlternateProtocolAvailable: false,
-                            wasFetchedViaSpdy: false,
-                            wasNpnNegotiated: true,
-                        };
-                    },
-                    csi: function () {
-                        return {
-                            onloadT: Date.now(),
-                            pageT: Math.random() * 1000,
-                            startE: Date.now() - Math.random() * 5000,
-                            tran: 15,
-                        };
-                    },
-                    app: {
-                        isInstalled: false,
-                        InstallState: {
-                            DISABLED: 'disabled',
-                            INSTALLED: 'installed',
-                            NOT_INSTALLED: 'not_installed',
-                        },
-                        RunningState: {
-                            CANNOT_RUN: 'cannot_run',
-                            READY_TO_RUN: 'ready_to_run',
-                            RUNNING: 'running',
-                        },
-                    },
-                };
-            };
             Object.defineProperty(navigator, 'webdriver', {
                 get: () => undefined,
                 configurable: true,
             });
-            setChromeObject(typedWindow);
+            typedWindow.chrome = {
+                runtime: {
+                    connect: () => { },
+                    sendMessage: () => { },
+                    onMessage: {
+                        addListener: () => { },
+                        removeListener: () => { },
+                    },
+                },
+                loadTimes: function () {
+                    return {
+                        commitLoadTime: Date.now() / 1000 - Math.random() * 10,
+                        connectionInfo: 'http/1.1',
+                        finishDocumentLoadTime: Date.now() / 1000 - Math.random() * 5,
+                        finishLoadTime: Date.now() / 1000 - Math.random() * 3,
+                        firstPaintAfterLoadTime: 0,
+                        firstPaintTime: Date.now() / 1000 - Math.random() * 8,
+                        navigationType: 'Other',
+                        npnNegotiatedProtocol: 'http/1.1',
+                        requestTime: Date.now() / 1000 - Math.random() * 15,
+                        startLoadTime: Date.now() / 1000 - Math.random() * 12,
+                        wasAlternateProtocolAvailable: false,
+                        wasFetchedViaSpdy: false,
+                        wasNpnNegotiated: true,
+                    };
+                },
+                csi: function () {
+                    return {
+                        onloadT: Date.now(),
+                        pageT: Math.random() * 1000,
+                        startE: Date.now() - Math.random() * 5000,
+                        tran: 15,
+                    };
+                },
+                app: {
+                    isInstalled: false,
+                    InstallState: {
+                        DISABLED: 'disabled',
+                        INSTALLED: 'installed',
+                        NOT_INSTALLED: 'not_installed',
+                    },
+                    RunningState: {
+                        CANNOT_RUN: 'cannot_run',
+                        READY_TO_RUN: 'ready_to_run',
+                        RUNNING: 'running',
+                    },
+                },
+            };
             Object.defineProperty(navigator, 'plugins', {
                 get: () => {
                     const pluginArray = [
@@ -170,13 +168,12 @@ export async function fetchRealEnvironmentData(params) {
         const extractedValues = await page.evaluate((paths, maxDepth) => {
             const result = {};
             const seen = new WeakSet();
-            const isObjectLike = (value) => typeof value === 'object' && value !== null;
             function extractValue(path) {
                 try {
                     const parts = path.split('.');
                     let current = window;
                     for (const part of parts) {
-                        if (isObjectLike(current) && part in current) {
+                        if (typeof current === 'object' && current !== null && part in current) {
                             current = current[part];
                         }
                         else {
@@ -189,8 +186,8 @@ export async function fetchRealEnvironmentData(params) {
                     return `[Error: ${error.message}]`;
                 }
             }
-            function serializeValue(value, depth, seenObjects) {
-                if (depth <= 0)
+            function serializeValue(value, recurseDepth, seenObjects) {
+                if (recurseDepth <= 0)
                     return '[Max Depth]';
                 if (value === null)
                     return null;
@@ -213,20 +210,20 @@ export async function fetchRealEnvironmentData(params) {
                         return '[Function]';
                     }
                 }
-                if (isObjectLike(value) && seenObjects.has(value)) {
+                if (typeof value === 'object' && value !== null && seenObjects.has(value)) {
                     return '[Circular Reference]';
                 }
                 if (Array.isArray(value)) {
                     seenObjects.add(value);
                     const arr = value
                         .slice(0, 20)
-                        .map((item) => serializeValue(item, depth - 1, seenObjects));
+                        .map((item) => serializeValue(item, recurseDepth - 1, seenObjects));
                     if (value.length > 20) {
                         arr.push(`[... ${value.length - 20} more items]`);
                     }
                     return arr;
                 }
-                if (isObjectLike(value)) {
+                if (typeof value === 'object' && value !== null) {
                     seenObjects.add(value);
                     const serialized = {};
                     const allKeys = Object.getOwnPropertyNames(value);
@@ -237,14 +234,14 @@ export async function fetchRealEnvironmentData(params) {
                             if (descriptor) {
                                 if (descriptor.get) {
                                     try {
-                                        serialized[key] = serializeValue(value[key], depth - 1, seenObjects);
+                                        serialized[key] = serializeValue(value[key], recurseDepth - 1, seenObjects);
                                     }
                                     catch {
                                         serialized[key] = '[Getter Error]';
                                     }
                                 }
                                 else if (descriptor.value !== undefined) {
-                                    serialized[key] = serializeValue(descriptor.value, depth - 1, seenObjects);
+                                    serialized[key] = serializeValue(descriptor.value, recurseDepth - 1, seenObjects);
                                 }
                             }
                         }

package/dist/src/modules/emulator/templates/chrome-env.d.ts

@@ -162,17 +162,21 @@ export declare const chromeEnvironmentTemplate: {
             };
         };
         WebSocket: {
-            new (_url: string): {
+            new (): {
                 send(): void;
                 close(): void;
                 addEventListener(): void;
             };
         };
         Blob: {
-            new (_parts: unknown[], _options?: unknown): {};
+            new (): {
+                size: number;
+                type: string;
+            };
         };
         File: {
-            new (parts: BlobPart[], _name: string, options?: BlobPropertyBag): {
+            new (parts: BlobPart[], name: string, options?: BlobPropertyBag): {
+                name: string;
                 readonly size: number;
                 readonly type: string;
                 arrayBuffer(): Promise<ArrayBuffer>;
@@ -202,16 +206,22 @@ export declare const chromeEnvironmentTemplate: {
             };
         };
         Request: {
-            new (_input: unknown, _init?: unknown): {};
+            new (): {
+                clone(): any;
+            };
         };
         Response: {
-            new (_body?: unknown, _init?: unknown): {};
+            new (): {
+                clone(): any;
+            };
         };
         URL: {
-            new (_url: string, _base?: string): {};
+            new (): {
+                toString(): string;
+            };
         };
         URLSearchParams: {
-            new (_init?: unknown): {
+            new (): {
                 append(): void;
                 delete(): void;
                 get(): void;

package/dist/src/modules/emulator/templates/chrome-env.js

@@ -161,17 +161,19 @@ export const chromeEnvironmentTemplate = {
             addEventListener() { }
         },
         WebSocket: class WebSocket {
-            constructor(_url) { }
             send() { }
             close() { }
             addEventListener() { }
         },
         Blob: class Blob {
-            constructor(_parts, _options) { }
+            size = 0;
+            type = '';
         },
         File: class File extends Blob {
-            constructor(parts, _name, options) {
+            name = '';
+            constructor(parts, name, options) {
                 super(parts, options);
+                this.name = name;
             }
         },
         FormData: class FormData {
@@ -190,16 +192,21 @@ export const chromeEnvironmentTemplate = {
             set() { }
         },
         Request: class Request {
-            constructor(_input, _init) { }
+            clone() {
+                return this;
+            }
         },
         Response: class Response {
-            constructor(_body, _init) { }
+            clone() {
+                return this;
+            }
         },
         URL: class URL {
-            constructor(_url, _base) { }
+            toString() {
+                return '';
+            }
         },
         URLSearchParams: class URLSearchParams {
-            constructor(_init) { }
             append() { }
             delete() { }
             get() { }

package/dist/src/modules/external/ExternalToolRunner.js

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { resolve, relative, sep } from 'node:path';
+import { resolve, relative, sep, isAbsolute } from 'node:path';
 import { getProjectRoot } from '../../utils/outputPaths.js';
 import { logger } from '../../utils/logger.js';
 import { ioLimit } from '../../utils/concurrency.js';
@@ -37,9 +37,16 @@ export class ExternalToolRunner {
         const args = [...(spec.defaultArgs || []), ...request.args];
         const env = { PATH: process.env.PATH || '' };
         if (process.platform === 'win32') {
-            env.SYSTEMROOT = process.env.SYSTEMROOT || 'C:\\Windows';
-            env.TEMP = process.env.TEMP || '';
-            env.TMP = process.env.TMP || '';
+            const systemRoot = process.env.SYSTEMROOT || process.env.SystemRoot || process.env.WINDIR;
+            if (systemRoot) {
+                env.SYSTEMROOT = systemRoot;
+            }
+            if (process.env.TEMP) {
+                env.TEMP = process.env.TEMP;
+            }
+            if (process.env.TMP) {
+                env.TMP = process.env.TMP;
+            }
         }
         if (spec.envAllowlist) {
             for (const key of spec.envAllowlist) {
@@ -66,13 +73,23 @@ export class ExternalToolRunner {
             let stdoutTruncated = false;
             let stderrTruncated = false;
             let settled = false;
-            let timeoutHandle;
+            const timeoutHandle = setTimeout(() => {
+                if (!settled) {
+                    child.kill('SIGTERM');
+                    setTimeout(() => {
+                        if (!settled) {
+                            child.kill('SIGKILL');
+                            finish(null, 'SIGKILL');
+                        }
+                    }, EXTERNAL_TOOL_FORCE_KILL_GRACE_MS);
+                    request.onProgress?.({ phase: 'timeout', ts: Date.now() });
+                }
+            }, timeoutMs);
             const finish = (exitCode, signal) => {
                 if (settled)
                     return;
                 settled = true;
-                if (timeoutHandle)
-                    clearTimeout(timeoutHandle);
+                clearTimeout(timeoutHandle);
                 const durationMs = Date.now() - startTime;
                 const result = {
                     ok: exitCode === 0,
@@ -91,18 +108,6 @@ export class ExternalToolRunner {
                 }
                 resolvePromise(result);
             };
-            timeoutHandle = setTimeout(() => {
-                if (!settled) {
-                    child.kill('SIGTERM');
-                    setTimeout(() => {
-                        if (!settled) {
-                            child.kill('SIGKILL');
-                            finish(null, 'SIGKILL');
-                        }
-                    }, EXTERNAL_TOOL_FORCE_KILL_GRACE_MS);
-                    request.onProgress?.({ phase: 'timeout', ts: Date.now() });
-                }
-            }, timeoutMs);
             if (request.stdin) {
                 child.stdin.write(request.stdin);
                 child.stdin.end();
@@ -153,13 +158,11 @@ export class ExternalToolRunner {
         const resolved = resolve(requestedCwd);
         const projectRoot = getProjectRoot();
         const rel = relative(projectRoot, resolved);
-        if (rel && !rel.startsWith('..') && !resolve(rel).startsWith(sep)) {
+        if (rel && !rel.startsWith('..') && !isAbsolute(rel) && !resolve(rel).startsWith(sep)) {
             return resolved;
         }
         const tmpDirs = [process.env.TEMP, process.env.TMP, '/tmp', '/var/tmp'].filter(Boolean);
         for (const tmp of tmpDirs) {
-            if (!tmp)
-                continue;
             const resolvedTmp = resolve(tmp);
             if (resolved === resolvedTmp || resolved.startsWith(resolvedTmp + sep)) {
                 return resolved;