@speedkit/cli 4.23.3 → 4.24.0

package/dist/services/bundler/bundle-service.js

@@ -5,13 +5,23 @@ import { BundleResolveError } from "./error/bundle-resolve-error.js";
 import { BundleFetchError } from "./error/bundle-fetch-error.js";
 import { resolve } from "node:path";
 import { createRequire } from "node:module";
+const FALLBACK_NAMESPACE = "bundle-resolve-fallback";
+const RELATIVE_SPECIFIER = /^\.{1,2}\//;
 const importCache = {};
 export class BundleService {
     moduleDiscoveryDir;
-    constructor(moduleDiscoveryDir) {
+    additionalModulePaths;
+    /**
+     * @param moduleDiscoveryDir the directory bundled code resolves its own imports from
+     * @param additionalModulePaths extra `node_modules` directories to search, like `NODE_PATH`.
+     *   `sk` installs the packages a customer config declares under `dependencies` into its cache
+     *   rather than into the customer folder, so esbuild would otherwise never find them.
+     */
+    constructor(moduleDiscoveryDir, additionalModulePaths = []) {
         this.moduleDiscoveryDir = moduleDiscoveryDir;
+        this.additionalModulePaths = additionalModulePaths;
     }
-    async bundle({ entryPoints, basePaths, define, target = "es5", minify = true, logLevel = "silent", alias = {}, platform, }) {
+    async bundle({ entryPoints, basePaths, define, target = "es5", minify = true, logLevel = "silent", alias = {}, platform, resolveFallback, }) {
         const plugins = [];
         if (basePaths && Object.keys(basePaths).length > 0) {
             plugins.push(this.baqendPlugin(basePaths));
@@ -19,6 +29,9 @@ export class BundleService {
         if (entryPoints) {
             plugins.push(this.entryPointsPlugin(entryPoints));
         }
+        if (resolveFallback) {
+            plugins.push(this.resolveFallbackPlugin(resolveFallback));
+        }
         const result = await build({
             plugins: plugins,
             bundle: true,
@@ -30,6 +43,7 @@ export class BundleService {
             entryPoints: Object.keys(entryPoints),
             platform: platform || "neutral",
             logLevel,
+            nodePaths: this.additionalModulePaths,
             alias: this.resolveAliases(alias),
         });
         return result.outputFiles
@@ -54,14 +68,32 @@ export class BundleService {
         }
         // The filename never has to exist; only its directory decides where the lookup starts.
         const requireFrom = createRequire(resolve(this.moduleDiscoveryDir, "noop.js"));
-        return Object.fromEntries(Object.entries(alias).map(([from, to]) => {
+        return Object.fromEntries(Object.entries(alias).map(([from, to]) => [
+            from,
+            this.resolveAliasTarget(requireFrom, to) ?? to,
+        ]));
+    }
+    /**
+     * Looks the target up the way the bundled code would: the customer folder first, then the
+     * additional module paths. Returns `null` when it is installed nowhere, so the bare name reaches
+     * esbuild and is reported as before.
+     */
+    resolveAliasTarget(requireFrom, target) {
+        try {
+            return requireFrom.resolve(target);
+        }
+        catch {
+            // not in the customer folder — fall through to the additional module paths
+        }
+        for (const modulePath of this.additionalModulePaths) {
             try {
-                return [from, requireFrom.resolve(to)];
+                return createRequire(resolve(modulePath, "noop.js")).resolve(target);
             }
             catch {
-                return [from, to];
+                // keep looking
             }
-        }));
+        }
+        return null;
     }
     entryPointsPlugin(entryPoints) {
         // eslint-disable-next-line @typescript-eslint/no-this-alias
@@ -126,4 +158,47 @@ export class BundleService {
             },
         };
     }
+    /**
+     * Resolves relative imports that exist nowhere in the customer folder through `resolveFallback`.
+     *
+     * A document handler shares its source with the Baqend app it is deployed to, so it may
+     * `require("./someModule")` a module that only lives in the app. Disk always wins: the fallback
+     * is only consulted after esbuild's own resolution has failed, and only for relative specifiers —
+     * a bare name is an npm package, and a missing one stays esbuild's error to report.
+     */
+    resolveFallbackPlugin(resolveFallback) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const me = this;
+        return {
+            name: "resolveFallback",
+            setup(build) {
+                build.onResolve({ filter: RELATIVE_SPECIFIER }, async (arguments_) => {
+                    // build.resolve() re-enters this hook; the flag makes the second pass a no-op.
+                    if (arguments_.pluginData?.fallbackChecked) {
+                        return;
+                    }
+                    const onDisk = await build.resolve(arguments_.path, {
+                        importer: arguments_.importer,
+                        kind: arguments_.kind,
+                        resolveDir: arguments_.resolveDir,
+                        pluginData: { fallbackChecked: true },
+                    });
+                    if (onDisk.errors.length === 0) {
+                        return onDisk;
+                    }
+                    const contents = await resolveFallback(arguments_.path);
+                    if (contents === null) {
+                        return;
+                    }
+                    return { path: arguments_.path, namespace: FALLBACK_NAMESPACE };
+                });
+                build.onLoad({ filter: /.*/, namespace: FALLBACK_NAMESPACE }, async (arguments_) => ({
+                    contents: await resolveFallback(arguments_.path),
+                    loader: "js",
+                    // Lets a fallback module require npm packages the customer folder installed.
+                    resolveDir: resolve(me.moduleDiscoveryDir),
+                }));
+            },
+        };
+    }
 }

package/dist/services/bundler/bundle-service.spec.js

@@ -52,3 +52,127 @@ describe("BundleService alias resolution", () => {
         expect(String(error)).to.contain("not-installed-anywhere");
     });
 });
+/**
+ * A document handler is shared with the Baqend app it is deployed to, so it can require a module
+ * that only exists there. The bundler must reach for that copy only after the customer folder has
+ * had its chance, and only for the relative specifiers Baqend modules are required by.
+ */
+describe("BundleService resolve fallback", () => {
+    const bundleWithFallback = (source, fallback, moduleDiscoveryDir = process.cwd()) => new BundleService(moduleDiscoveryDir).bundle({
+        entryPoints: { "handler.js": source },
+        minify: false,
+        platform: "node",
+        logLevel: "silent",
+        resolveFallback: fallback,
+    });
+    it("bundles a relative module the customer folder does not have", async () => {
+        const bundle = await bundleWithFallback("module.exports = require('./checkS3Assets');", async () => 'module.exports = "from-the-app";');
+        expect(bundle).to.contain("from-the-app");
+    });
+    it("prefers a file on disk over the fallback", async () => {
+        const customerDirectory = mkdtempSync(join(tmpdir(), "sk-fallback-"));
+        writeFileSync(join(customerDirectory, "checkS3Assets.js"), 'module.exports = "from-the-customer-folder";');
+        let fallbackCalls = 0;
+        try {
+            const bundle = await bundleWithFallback("module.exports = require('./checkS3Assets');", async () => {
+                fallbackCalls++;
+                return 'module.exports = "from-the-app";';
+            }, customerDirectory);
+            expect(bundle).to.contain("from-the-customer-folder");
+            expect(bundle).to.not.contain("from-the-app");
+            expect(fallbackCalls).to.equal(0);
+        }
+        finally {
+            rmSync(customerDirectory, { recursive: true, force: true });
+        }
+    });
+    it("resolves a relative import made by a fallback module", async () => {
+        const modules = {
+            "./checkS3Assets": "module.exports = require('./s3Client');",
+            "./s3Client": 'module.exports = "nested-app-module";',
+        };
+        const bundle = await bundleWithFallback("module.exports = require('./checkS3Assets');", async (specifier) => modules[specifier] ?? null);
+        expect(bundle).to.contain("nested-app-module");
+    });
+    it("leaves a bare specifier to esbuild", async () => {
+        let fallbackCalls = 0;
+        const bundling = bundleWithFallback("module.exports = require('not-installed-anywhere');", async () => {
+            fallbackCalls++;
+            return 'module.exports = "from-the-app";';
+        });
+        const error = await bundling.then(() => undefined, (reason) => reason);
+        expect(String(error)).to.contain("not-installed-anywhere");
+        expect(fallbackCalls).to.equal(0);
+    });
+    it("reports esbuild's own error when the fallback has nothing", async () => {
+        const bundling = bundleWithFallback("module.exports = require('./checkS3Assets');", async () => null);
+        const error = await bundling.then(() => undefined, (reason) => reason);
+        expect(String(error)).to.contain("./checkS3Assets");
+    });
+});
+/**
+ * `sk` installs the packages a customer config declares under `dependencies` into its own cache,
+ * not into the customer folder, so the bundler needs that directory on its search path as well.
+ */
+describe("BundleService additional module paths", () => {
+    const MARKER = "fixture-additional-dependency";
+    let cacheDirectory;
+    let customerDirectory;
+    let additionalModulePath;
+    before(() => {
+        cacheDirectory = mkdtempSync(join(tmpdir(), "sk-cache-"));
+        customerDirectory = mkdtempSync(join(tmpdir(), "sk-customer-"));
+        additionalModulePath = join(cacheDirectory, "node_modules");
+        const packageDirectory = join(additionalModulePath, "additional-fixture");
+        mkdirSync(packageDirectory, { recursive: true });
+        writeFileSync(join(packageDirectory, "package.json"), JSON.stringify({
+            name: "additional-fixture",
+            version: "1.0.0",
+            main: "index.js",
+        }));
+        writeFileSync(join(packageDirectory, "index.js"), `module.exports = "${MARKER}";`);
+    });
+    after(() => {
+        rmSync(cacheDirectory, { recursive: true, force: true });
+        rmSync(customerDirectory, { recursive: true, force: true });
+    });
+    it("resolves a package installed outside the customer folder", async () => {
+        const bundle = await new BundleService(customerDirectory, [
+            additionalModulePath,
+        ]).bundle({
+            entryPoints: {
+                "handler.js": "module.exports = require('additional-fixture');",
+            },
+            minify: false,
+            platform: "node",
+            logLevel: "silent",
+        });
+        expect(bundle).to.contain(MARKER);
+    });
+    it("fails without the additional path, as it did before", async () => {
+        const bundling = new BundleService(customerDirectory).bundle({
+            entryPoints: {
+                "handler.js": "module.exports = require('additional-fixture');",
+            },
+            minify: false,
+            platform: "node",
+            logLevel: "silent",
+        });
+        const error = await bundling.then(() => undefined, (reason) => reason);
+        expect(String(error)).to.contain("additional-fixture");
+    });
+    it("resolves an alias target from an additional module path", async () => {
+        const bundle = await new BundleService(customerDirectory, [
+            additionalModulePath,
+        ]).bundle({
+            entryPoints: {
+                "handler.js": "module.exports = require('node-fetch');",
+            },
+            minify: false,
+            platform: "node",
+            logLevel: "silent",
+            alias: { "node-fetch": "additional-fixture" },
+        });
+        expect(bundle).to.contain(MARKER);
+    });
+});

package/dist/services/document-handler-runtime/document-handler-server.d.ts

@@ -8,13 +8,14 @@ export declare class DocumentHandlerServer {
     private files;
     private bundler;
     private cli;
-    private nodeModulesPath;
     private verboseLevel;
     private entityManager?;
     private documentHandlerCode;
     private documentHandlerConfigCode;
     private database;
-    constructor(customerConfig: CustomerConfig, files: FileListInterface, bundler: BundleService, cli: CliService, nodeModulesPath: string, verboseLevel?: boolean, entityManager?: EntityManager);
+    /** Sources of app modules already looked up; `null` marks a lookup that came back empty. */
+    private readonly appModules;
+    constructor(customerConfig: CustomerConfig, files: FileListInterface, bundler: BundleService, cli: CliService, verboseLevel?: boolean, entityManager?: EntityManager);
     transform(contentType: string, html: string, variation: string, url: string, headers: Record<string, string>): Promise<DocumentHandlerResponse>;
     private getTransformFunctionWrapper;
     buildDocumentHandler(): Promise<void>;
@@ -27,7 +28,12 @@ export declare class DocumentHandlerServer {
     private getContextVars;
     private createDataBaseMock;
     private createNodeVmContext;
-    private createRequireMock;
+    /**
+     * The `fetch` the customer's document handler calls.
+     *
+     * It stays on a direct connection, with no proxy and no fixed exit IP, because that is what the
+     * document handler gets in production.
+     */
     private createFetchMock;
     private createProcessPartial;
     /**
@@ -37,4 +43,18 @@ export declare class DocumentHandlerServer {
      */
     bundleDynamicFetcher(basePaths: Record<string, string>, dynamicFetcher: string): Promise<string>;
     bundleDocumentHandlerCode(name: string, code: string): Promise<string>;
+    /**
+     * Loads a module the customer folder does not contain from the app the config is deployed to.
+     *
+     * A document handler is shared with its Baqend app, so `require("./checkS3Assets")` may point at
+     * a module that only ever lived in the app. The bundler calls this after its own resolution
+     * failed, so a file on disk always wins.
+     */
+    private loadAppModule;
+    /**
+     * esbuild reports an unresolvable relative import without saying that the module may simply live
+     * in the app rather than in the customer folder — which is all the reader needs to know when the
+     * app lookup was skipped because there is no session.
+     */
+    private explainUnresolvedModules;
 }

package/dist/services/document-handler-runtime/document-handler-server.js

@@ -2,7 +2,6 @@ import { LATEST_DYNAMIC_FETCHER_URL, LOCAL_DOCUMENT_HANDLER, LOCAL_DOCUMENT_HAND
 import RequiredFileNotFoundError from "./error/required-file-not-found-error.js";
 import DatabaseMock from "./templates/database-mock.js";
 import * as vm from "node:vm";
-import path, { resolve } from "node:path";
 import { INTEGRATION_FILES } from "../../models/files.js";
 // documentHandlerDependencies
 import fetch from "node-fetch";
@@ -13,23 +12,24 @@ import { safe } from "../../helpers/safe.js";
 import { VmEmptyResponseError } from "../onboarding/error/vm-empty-response-error.js";
 import { DocumentHandlerTransformError } from "../onboarding/error/document-handler-transform-error.js";
 import { createRequire } from "node:module";
+import ApplicationError from "../error-handling/error/application-error.js";
 export class DocumentHandlerServer {
     customerConfig;
     files;
     bundler;
     cli;
-    nodeModulesPath;
     verboseLevel;
     entityManager;
     documentHandlerCode;
     documentHandlerConfigCode;
     database;
-    constructor(customerConfig, files, bundler, cli, nodeModulesPath, verboseLevel = false, entityManager) {
+    /** Sources of app modules already looked up; `null` marks a lookup that came back empty. */
+    appModules = new Map();
+    constructor(customerConfig, files, bundler, cli, verboseLevel = false, entityManager) {
         this.customerConfig = customerConfig;
         this.files = files;
         this.bundler = bundler;
         this.cli = cli;
-        this.nodeModulesPath = nodeModulesPath;
         this.verboseLevel = verboseLevel;
         this.entityManager = entityManager;
     }
@@ -192,43 +192,12 @@ export class DocumentHandlerServer {
         }
         return context;
     }
-    createRequireMock() {
-        return (module) => {
-            if (module === "baqend") {
-                return { baqend: { message: { RevalidateAssets: () => true } } };
-            }
-            if (module.toLowerCase().includes("fetch")) {
-                return this.createFetchMock();
-            }
-            const fileExtension = path.extname(module);
-            const moduleFileName = path.basename(module, fileExtension);
-            if (this.files.hasFile(moduleFileName)) {
-                const vmContext = {
-                    module: { exports: {} },
-                    exports: {},
-                    ...this.createNodeVmContext(),
-                };
-                vm.runInNewContext(this.files
-                    .getByName(moduleFileName)
-                    .getContent(), vmContext, { displayErrors: true });
-                return { ...vmContext.module.exports, ...vmContext.exports };
-            }
-            try {
-                return import(module);
-            }
-            catch {
-                // do nothing
-            }
-            try {
-                const additional = resolve(this.nodeModulesPath, "node_modules", module);
-                return import(additional);
-            }
-            catch {
-                // do nothing
-            }
-            this.cli.writeError(`[documentHandler] could not load module: ${module}`);
-        };
-    }
+    /**
+     * The `fetch` the customer's document handler calls.
+     *
+     * It stays on a direct connection, with no proxy and no fixed exit IP, because that is what the
+     * document handler gets in production.
+     */
     createFetchMock() {
         return async (url, options) => {
             if (this.verboseLevel) {
@@ -270,7 +239,7 @@ export class DocumentHandlerServer {
         });
     }
     async bundleDocumentHandlerCode(name, code) {
-        return this.bundler.bundle({
+        const bundling = await safe(this.bundler.bundle({
             entryPoints: {
                 [name]: code,
             },
@@ -279,6 +248,60 @@ export class DocumentHandlerServer {
             platform: "node",
             logLevel: "silent",
             alias: { "node-fetch": "node-fetch-native" },
-        });
+            resolveFallback: this.loadAppModule,
+        }));
+        if (bundling.success === true) {
+            return bundling.data;
+        }
+        throw this.explainUnresolvedModules(bundling.errorObj ?? new Error(bundling.error));
+    }
+    /**
+     * Loads a module the customer folder does not contain from the app the config is deployed to.
+     *
+     * A document handler is shared with its Baqend app, so `require("./checkS3Assets")` may point at
+     * a module that only ever lived in the app. The bundler calls this after its own resolution
+     * failed, so a file on disk always wins.
+     */
+    loadAppModule = async (specifier) => {
+        if (!this.entityManager) {
+            return null;
+        }
+        const moduleName = specifier
+            .replace(/^(?:\.{1,2}\/)+/, "")
+            .replace(/\.js$/, "");
+        if (!this.appModules.has(moduleName)) {
+            // esbuild resolves imports concurrently, so the action is keyed per module.
+            const action = `ONBOARDING:DOCUMENT_HANDLER:MODULE:${moduleName}`;
+            this.cli.startAction(action, this.cli.style.yellow(`[documentHandler.module]: load "${moduleName}" from app ${this.customerConfig.app}`));
+            const module = await safe(this.entityManager.code.loadCode(moduleName, "module"));
+            this.appModules.set(moduleName, module.success === true ? module.data : null);
+            if (module.success === true) {
+                this.cli.successAction(action);
+            }
+            else {
+                this.cli.failAction(action);
+            }
+        }
+        return this.appModules.get(moduleName);
+    };
+    /**
+     * esbuild reports an unresolvable relative import without saying that the module may simply live
+     * in the app rather than in the customer folder — which is all the reader needs to know when the
+     * app lookup was skipped because there is no session.
+     */
+    explainUnresolvedModules(error) {
+        const unresolved = [
+            ...error.message.matchAll(/Could not resolve "(\.{1,2}\/[^"]+)"/g),
+        ].map((match) => match[1]);
+        if (unresolved.length === 0) {
+            return error;
+        }
+        const suggestions = [
+            `${unresolved.join(", ")} was found neither in the customer folder nor in app "${this.customerConfig.app}".`,
+        ];
+        suggestions.push(this.entityManager
+            ? `Deploy the module to the app, or add it to the customer folder.`
+            : `You are not logged in to app "${this.customerConfig.app}", so modules that only exist in the app cannot be loaded. Run \`sk login ${this.customerConfig.app}\` and try again.`);
+        return new ApplicationError(error.message, suggestions);
     }
 }

package/dist/services/document-handler-runtime/factory/document-handler-runtime-service-factory.js

@@ -8,6 +8,7 @@ import { BundleServiceFactory } from "../../bundler/index.js";
 import { EntityManagerFactory } from "../../config-api/entity-manager-factory.js";
 import { safe } from "../../../helpers/safe.js";
 import { existsSync, mkdirSync } from "node:fs";
+import { resolve } from "node:path";
 export default class DocumentHandlerRuntimeServiceFactory {
     context;
     cliConfig;
@@ -33,11 +34,15 @@ export default class DocumentHandlerRuntimeServiceFactory {
                 .buildService()
                 .run());
         const customerConfig = this.getCustomerConfig(files);
-        const bundler = new BundleServiceFactory(this.context.customerPath).buildService();
         const cliService = new CliServiceFactory().getService();
         await this.installAdditionalDependencies(customerConfig, cliService);
+        // installAdditionalDependencies() installs into the cache, not into the customer folder, so
+        // the bundler has to search there too or a declared dependency resolves nowhere.
+        const bundler = new BundleServiceFactory(this.context.customerPath, [
+            resolve(this.cliConfig.nodeModulesPath, "node_modules"),
+        ]).buildService();
         const entityManagerResult = await safe(new EntityManagerFactory().getEntityManager(customerConfig.app));
-        return new DocumentHandlerServer(customerConfig, files, bundler, cliService, this.cliConfig.nodeModulesPath, this.context.verboseLevel, entityManagerResult.success ? entityManagerResult.data : null);
+        return new DocumentHandlerServer(customerConfig, files, bundler, cliService, this.context.verboseLevel, entityManagerResult.success ? entityManagerResult.data : null);
     }
     prepareIntegrationApi() {
         const integrationApiContext = new IntegrationApiContext(this.context.customerPath, this.context.configName, this.context.fileDependencies, [".git", ".idea", "node_modules"]);

package/dist/services/onboarding/dashboard/request-diff-service.js

@@ -1,8 +1,6 @@
 import { BaqendResponse } from "../browser/baqend-response.js";
 import { safe } from "../../../helpers/safe.js";
-import { Agent } from "node:https";
-import crypto from "node:crypto";
-import fetch from "node-fetch";
+import { originFetch } from "../../../helpers/origin-proxy.js";
 import { formatHtml } from "../../../helpers/html-format-helper.js";
 export class RequestDiffService {
     diffService;
@@ -61,17 +59,13 @@ export class RequestDiffService {
         return await this.diffService.executeDiff(parametersFilePath, pureFilePath);
     }
     async fetchHtml(url) {
-        const agent = new Agent({
-            rejectUnauthorized: false,
-            keepAlive: true,
-            secureOptions: crypto.constants.SSL_OP_LEGACY_SERVER_CONNECT,
-        });
-        const response = await safe(fetch(url, {
-            agent: agent,
+        const response = await safe(originFetch(url, {
             headers: {
                 "user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.79 Safari/537.36 SpeedKitCrawler/1.0",
             },
-        }));
+        }, 
+        // The dashboard diff has always accepted a broken origin handshake here.
+        { tolerateLegacyTls: true }));
         if (response.success !== true) {
             console.log(response.errorObj);
             throw response.errorObj;

package/dist/services/onboarding/onboarding-service-factory.d.ts

@@ -16,6 +16,4 @@ export declare class OnboardingServiceFactory {
     private getIntegrationFiles;
     private getUrlForTest;
     private ensureHttps;
-    private getCrawlerAgent;
-    private getCrawlerProxyConfig;
 }

package/dist/services/onboarding/onboarding-service-factory.js

@@ -39,8 +39,7 @@ import { StaticRecipe } from "../integration-api/virtual/static-recipe.js";
 import { DiffAgainstCurrentPage } from "./dashboard/diff-against-current-page.js";
 import { ExtensionDownloader } from "./browser/extension/extension-downloader.js";
 import { ExecutableValidator } from "./browser/executable/executable-validator.js";
-import { socksDispatcher } from "fetch-socks";
-import crypto from "node:crypto";
+import { applyOriginProxy, withOriginProxyFlag, } from "../../helpers/origin-proxy.js";
 import { QueryBuilderFactory } from "../query-builder/query-builder-factory.js";
 import { QueryTpe } from "../query-builder/query-builder-model.js";
 export class OnboardingServiceFactory {
@@ -54,6 +53,8 @@ export class OnboardingServiceFactory {
         const files = await this.getIntegrationFiles();
         const cli = new CliServiceFactory().getService();
         const customerConfig = files.getCustomerConfig().config;
+        // Before any origin request, so Chrome and the CLI agree on the route out.
+        applyOriginProxy(customerConfig.chromeFlags, cli);
         const domainToStart = await this.getUrlForTest(customerConfig, cli);
         const cache = new Cache(cli);
         const documentHandlerContext = {
@@ -73,7 +74,7 @@ export class OnboardingServiceFactory {
         this.cliConfig.chromeExtensionPaths = extensionPaths.join(",");
         const browserValidator = new ExecutableValidator(this.cliConfig, cli);
         const browserVersionString = await browserValidator.validateOrInstall();
-        const browserContext = new BrowserContext(domainToStart, browserVersionString, customerConfig.chromeFlags || [], this.cliConfig, undefined, this.context.debuggingPort, this.context.headless, this.context.debugPort);
+        const browserContext = new BrowserContext(domainToStart, browserVersionString, withOriginProxyFlag(customerConfig.chromeFlags), this.cliConfig, undefined, this.context.debuggingPort, this.context.headless, this.context.debugPort);
         if (this.context.debuggingPort || this.context.headless) {
             cli.writeWarning(`Chrome remote debugging enabled on port ${this.context.debugPort}.`);
         }
@@ -149,8 +150,7 @@ export class OnboardingServiceFactory {
     async getFetchEventHandler(files, customerConfig, documentHandler, cache, cli, browserContext, athenaClient, messageHandler, fileWatcher, speedKitServiceWorkerJs) {
         const configApi = this.getConfigApi(customerConfig.app);
         const serverConfig = await this.getSpeedKitServerConfig(configApi, cli);
-        const agent = this.getCrawlerAgent(customerConfig, cli);
-        const crawler = new Crawler(cli, agent, serverConfig);
+        const crawler = new Crawler(cli, serverConfig);
         const parameterQueryBuilder = await new QueryBuilderFactory({
             configName: this.context.configName,
             customerPath: this.context.customerPath,
@@ -251,42 +251,4 @@ export class OnboardingServiceFactory {
     ensureHttps(url = "") {
         return url.startsWith("https://") ? url : `https://${url}`;
     }
-    getCrawlerAgent(customerConfig, cli) {
-        const proxy = [];
-        const connect = {
-            keepAlive: true,
-        };
-        const agentOptions = {
-            rejectUnauthorized: false,
-            secureOptions: crypto.constants.SSL_OP_LEGACY_SERVER_CONNECT,
-        };
-        const crawlerProxyConfig = this.getCrawlerProxyConfig(customerConfig);
-        if (crawlerProxyConfig) {
-            cli.writeWarning(`use proxy from chromeFlags for local documenthandler`);
-            proxy.push(crawlerProxyConfig);
-        }
-        return socksDispatcher(proxy, { ...agentOptions, connect });
-    }
-    getCrawlerProxyConfig(customerConfig) {
-        if (!customerConfig.chromeFlags ||
-            customerConfig.chromeFlags.length === 0) {
-            return;
-        }
-        //"--proxy-server=socks5://ap-northeast-1.proxy.baqend.com:1080"
-        const selector = /--proxy-server=socks(4|5):(\/\/[^:]*):(\d+)/is;
-        for (const flag of customerConfig.chromeFlags) {
-            if (!flag.includes("--proxy-server=socks")) {
-                continue;
-            }
-            const [, type, host, port] = flag.match(selector) || [];
-            if (!type || !host || !port) {
-                continue;
-            }
-            return {
-                type: Number(type),
-                host,
-                port: Number(port),
-            };
-        }
-    }
 }

package/dist/services/onboarding/virtual-orestes-app/crawler.d.ts

@@ -1,13 +1,11 @@
 import { SpeedKitServerConfig } from "../onboarding-model.js";
 import { CliService } from "../../cli/index.js";
-import { Agent } from "undici";
 export declare class Crawler {
     private cli;
-    private agentConfig;
     private speedKitServerConfig?;
     /** Warnings already shown, so a per-fetch condition is reported once per session. */
     private readonly warned;
-    constructor(cli: CliService, agentConfig: Agent, speedKitServerConfig?: SpeedKitServerConfig);
+    constructor(cli: CliService, speedKitServerConfig?: SpeedKitServerConfig);
     private warnOnce;
     fetchRemote(originUrl: string, variation: string): Promise<{
         response: Response;