@js-recon/js-recon 1.4.3 → 2.0.1-alpha.1

package/build/proxy/genReq.js

@@ -11,79 +11,371 @@ import { APIGatewayClient, CreateResourceCommand, GetResourcesCommand, PutMethod
 //   CreateDeploymentCommand,
 //   CreateStageCommand,
 PutIntegrationResponseCommand, PutMethodResponseCommand, TestInvokeMethodCommand, DeleteResourceCommand, } from "@aws-sdk/client-api-gateway";
-import md5 from "md5";
 import chalk from "chalk";
+import { createHash, randomUUID } from "node:crypto";
+import fs from "node:fs";
 import * as globals from "../utility/globals.js";
+import { progressError } from "../utility/progressLog.js";
 import { readAwsGatewayMap } from "./awsConfig.js";
+const AWS_CLEANUP_TIMEOUT_MS = 5000;
+const AWS_CLEANUP_MAX_ATTEMPTS = 3;
+const AWS_CLEANUP_RETRY_DELAY_MS = 100;
+const AWS_CLEANUP_ABSENCE_GRACE_MS = 30000;
+const AWS_CLEANUP_MAX_PAGES = 100;
+const AWS_CLEANUP_LEASE_MS = 5 * 60000;
+const AWS_OPERATION_TIMEOUT_MS = 4 * 60000;
+const AWS_CLEANUP_RETRY_BASE_MS = 30000;
+const AWS_CLEANUP_RETRY_MAX_MS = 15 * 60000;
+const cleanupReplayLocks = new Map();
+const isCleanupRecord = (value) => {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const candidate = value;
+    return (candidate.version === 1 &&
+        typeof candidate.recordId === "string" &&
+        /^[0-9a-f-]{36}$/i.test(candidate.recordId) &&
+        typeof candidate.recordedAt === "string" &&
+        Number.isFinite(Date.parse(candidate.recordedAt)) &&
+        typeof candidate.leaseExpiresAt === "string" &&
+        Number.isFinite(Date.parse(candidate.leaseExpiresAt)) &&
+        typeof candidate.nextRetryAt === "string" &&
+        Number.isFinite(Date.parse(candidate.nextRetryAt)) &&
+        typeof candidate.retryCount === "number" &&
+        Number.isSafeInteger(candidate.retryCount) &&
+        candidate.retryCount >= 0 &&
+        typeof candidate.gatewayId === "string" &&
+        typeof candidate.region === "string" &&
+        typeof candidate.resourcePathPart === "string" &&
+        /^[0-9a-f]{32}$/i.test(candidate.resourcePathPart) &&
+        (candidate.resourceId === undefined ||
+            (typeof candidate.resourceId === "string" && /^[A-Za-z0-9_-]{1,256}$/.test(candidate.resourceId))));
+};
+const withCleanupReplaySingleFlight = (key, work) => __awaiter(void 0, void 0, void 0, function* () {
+    const existing = cleanupReplayLocks.get(key);
+    if (existing)
+        return existing;
+    const current = work();
+    cleanupReplayLocks.set(key, current);
+    try {
+        yield current;
+    }
+    finally {
+        if (cleanupReplayLocks.get(key) === current)
+            cleanupReplayLocks.delete(key);
+    }
+});
 /**
  * Utility function to pause execution for a specified duration.
  *
  * @param ms - Number of milliseconds to sleep
  * @returns Promise that resolves after the specified delay
  */
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const sleep = (ms, signal) => new Promise((resolve, reject) => {
+    if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+        reject(signal.reason);
+        return;
+    }
+    const finish = () => {
+        clearTimeout(timeout);
+        signal === null || signal === void 0 ? void 0 : signal.removeEventListener("abort", cancel);
+        resolve();
+    };
+    const cancel = () => {
+        clearTimeout(timeout);
+        reject(signal === null || signal === void 0 ? void 0 : signal.reason);
+    };
+    const timeout = setTimeout(finish, ms);
+    signal === null || signal === void 0 ? void 0 : signal.addEventListener("abort", cancel, { once: true });
+});
 /**
- * Given a URL, generates a new API Gateway for it and returns the response of the URL.
+ * Given a URL, generates a new API Gateway for it and returns the response of the URL,
+ * along with the real HTTP status/headers so callers can corroborate WAF/CDN block detection.
  * @param {string} url The URL to generate an API Gateway for.
  * @param {object} [headers] The headers to include in the request.
- * @returns {Promise<string>} The response of the URL.
+ * @param {AbortSignal} [signal] Cancels pending AWS operations and retry delays.
+ * @returns {Promise<AwsGatewayResponse>} The response of the URL, with status/headers.
  */
-const get = (url_1, ...args_1) => __awaiter(void 0, [url_1, ...args_1], void 0, function* (url, headers = {}) {
+const getWithMetadata = (url_1, ...args_1) => __awaiter(void 0, [url_1, ...args_1], void 0, function* (url, headers = {}, signal) {
+    var _a, _b, _c, _d, _e;
+    if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+        throw signal.reason;
     // read the aws gateway map from the proxy config file
-    let config;
-    try {
-        config = readAwsGatewayMap(globals.getProxyConfigFile());
-    }
-    catch (error) {
-        throw new Error(`Failed to read or parse proxy config file: ${error.message}`);
+    const config = (() => {
+        try {
+            return readAwsGatewayMap(globals.getProxyConfigFile());
+        }
+        catch (error) {
+            throw new Error(`Failed to read or parse proxy config file: ${error.message}`);
+        }
+    })();
+    const gatewayNames = Object.keys(config);
+    if (gatewayNames.length === 0) {
+        throw new Error("No AWS API Gateway configuration is available");
     }
-    // select a random api gateway
-    let apiGateway = Object.keys(config)[Math.floor(Math.random() * Object.keys(config).length)];
+    const apiGateway = gatewayNames[Math.floor(Math.random() * gatewayNames.length)];
+    const gateway = config[apiGateway];
     const client = new APIGatewayClient({
-        region: config[apiGateway].region,
+        region: gateway.region,
         credentials: {
-            accessKeyId: config[apiGateway].access_key,
-            secretAccessKey: config[apiGateway].secret_key,
+            accessKeyId: gateway.access_key,
+            secretAccessKey: gateway.secret_key,
         },
     });
-    // get the root resource id
-    const getResourceCommand = new GetResourcesCommand({
-        restApiId: config[apiGateway].id,
-        limit: 999999999,
-    });
-    const getResourceResponse = yield client.send(getResourceCommand);
-    yield sleep(200);
-    // before creating a resource, check if the resource already exists
-    const resourceExists = getResourceResponse.items.find(
-    // file deepcode ignore InsecureHash: False positive
-    (item) => item.pathPart === md5(url));
-    let newResourceResponse;
-    if (resourceExists) {
-        // console.error(chalk.yellow("[!] Resource already exists"));
-        newResourceResponse = {
-            id: resourceExists.id,
-        };
-    }
-    else {
-        // create a new resource
-        let rootId;
-        if (getResourceResponse.items.find((item) => item.path === "/")) {
-            rootId = getResourceResponse.items.find((item) => item.path === "/").id;
-        }
-        else {
-            rootId = getResourceResponse.items[0].parentId;
-        }
-        const newResourceCommand = new CreateResourceCommand({
-            restApiId: config[apiGateway].id,
-            parentId: rootId,
-            pathPart: md5(url), // md5 of the url
+    const operationController = new AbortController();
+    const operationTimeout = setTimeout(() => operationController.abort(new DOMException("AWS API Gateway operation exceeded its ownership lease budget", "TimeoutError")), AWS_OPERATION_TIMEOUT_MS);
+    (_a = operationTimeout.unref) === null || _a === void 0 ? void 0 : _a.call(operationTimeout);
+    const operationSignal = signal ? AbortSignal.any([signal, operationController.signal]) : operationController.signal;
+    const sendOptions = { abortSignal: operationSignal };
+    const operationId = randomUUID();
+    // Derived from the URL alone (not operationId) so repeat requests to the same
+    // URL resolve to the same pathPart, letting the existing-resource lookup below
+    // reuse an already-provisioned resource instead of creating a new one every call.
+    const resourcePathPart = createHash("sha256").update(url).digest("hex").slice(0, 32);
+    const cleanupOptions = () => ({ abortSignal: AbortSignal.timeout(AWS_CLEANUP_TIMEOUT_MS) });
+    const cleanupDirectory = `${globals.getProxyConfigFile()}.cleanup`;
+    const cleanupRecordPath = (recordId) => `${cleanupDirectory}/${recordId}.json`;
+    const persistCleanupRecord = (record) => {
+        const recordPath = cleanupRecordPath(record.recordId);
+        const temporaryPath = `${recordPath}.${process.pid}.${randomUUID()}.tmp`;
+        try {
+            fs.mkdirSync(cleanupDirectory, { recursive: true, mode: 0o700 });
+            fs.writeFileSync(temporaryPath, JSON.stringify(record), { encoding: "utf8", mode: 0o600, flag: "wx" });
+            fs.renameSync(temporaryPath, recordPath);
+            return true;
+        }
+        catch (err) {
+            progressError(chalk.red(`[!] Failed to record pending AWS API Gateway cleanup: ${err}`));
+            return false;
+        }
+        finally {
+            try {
+                if (fs.existsSync(temporaryPath))
+                    fs.unlinkSync(temporaryPath);
+            }
+            catch (_a) {
+                // A stale temporary file has no ownership authority and can be ignored.
+            }
+        }
+    };
+    const retireCleanupRecord = (record) => {
+        try {
+            fs.unlinkSync(cleanupRecordPath(record.recordId));
+        }
+        catch (err) {
+            const code = typeof err === "object" && err !== null ? Reflect.get(err, "code") : undefined;
+            if (code !== "ENOENT") {
+                progressError(chalk.red(`[!] Failed to retire completed AWS API Gateway cleanup record: ${err}`));
+            }
+        }
+    };
+    const beginCleanupOwnership = () => {
+        const recordedAt = new Date();
+        const record = Object.freeze({
+            version: 1,
+            recordId: operationId,
+            recordedAt: recordedAt.toISOString(),
+            leaseExpiresAt: new Date(recordedAt.getTime() + AWS_CLEANUP_LEASE_MS).toISOString(),
+            nextRetryAt: new Date(recordedAt.getTime() + AWS_CLEANUP_LEASE_MS).toISOString(),
+            retryCount: 0,
+            gatewayId: gateway.id,
+            region: gateway.region,
+            resourcePathPart,
         });
-        newResourceResponse = yield client.send(newResourceCommand);
-        yield sleep(200);
-        // add a new method
-        const newMethodCommand = new PutMethodCommand({
-            restApiId: config[apiGateway].id,
-            resourceId: newResourceResponse.id,
+        if (!persistCleanupRecord(record)) {
+            throw new Error("Refusing to create a temporary AWS API Gateway resource without a cleanup record");
+        }
+        return record;
+    };
+    const loadCleanupRecords = () => {
+        if (!fs.existsSync(cleanupDirectory))
+            return [];
+        try {
+            return Object.freeze(fs
+                .readdirSync(cleanupDirectory, { withFileTypes: true })
+                .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+                .flatMap((entry) => {
+                try {
+                    const parsed = JSON.parse(fs.readFileSync(`${cleanupDirectory}/${entry.name}`, "utf8"));
+                    return isCleanupRecord(parsed) ? [Object.freeze(Object.assign({}, parsed))] : [];
+                }
+                catch (_a) {
+                    return [];
+                }
+            }));
+        }
+        catch (err) {
+            progressError(chalk.red(`[!] Failed to read pending AWS API Gateway cleanup records: ${err}`));
+            return [];
+        }
+    };
+    const deferCleanupRecord = (record) => {
+        const retryDelay = Math.min(AWS_CLEANUP_RETRY_BASE_MS * Math.pow(2, Math.min(record.retryCount, 10)), AWS_CLEANUP_RETRY_MAX_MS);
+        persistCleanupRecord(Object.freeze(Object.assign(Object.assign({}, record), { retryCount: record.retryCount + 1, nextRetryAt: new Date(Date.now() + retryDelay).toISOString() })));
+    };
+    const isNotFoundError = (err) => {
+        var _a;
+        if (typeof err !== "object" || err === null)
+            return false;
+        const candidate = err;
+        return candidate.name === "NotFoundException" || ((_a = candidate.$metadata) === null || _a === void 0 ? void 0 : _a.httpStatusCode) === 404;
+    };
+    const deleteResource = (resourceId_1, ...args_2) => __awaiter(void 0, [resourceId_1, ...args_2], void 0, function* (resourceId, cleanupClient = client, restApiId = gateway.id) {
+        const deleteResourceCommand = new DeleteResourceCommand({
+            restApiId,
+            resourceId,
+        });
+        let lastError;
+        for (let attempt = 1; attempt <= AWS_CLEANUP_MAX_ATTEMPTS; attempt++) {
+            try {
+                // Cleanup deliberately gets its own request rather than the cancelled
+                // discovery signal so an aborted run does not leak temporary resources.
+                yield cleanupClient.send(deleteResourceCommand, cleanupOptions());
+                return true;
+            }
+            catch (err) {
+                if (isNotFoundError(err))
+                    return true;
+                lastError = err;
+                if (attempt < AWS_CLEANUP_MAX_ATTEMPTS) {
+                    yield sleep(AWS_CLEANUP_RETRY_DELAY_MS * attempt);
+                }
+            }
+        }
+        progressError(chalk.red(`[!] Error when deleting temporary AWS API Gateway resource: ${lastError}`));
+        return false;
+    });
+    const listCleanupResources = (...args_2) => __awaiter(void 0, [...args_2], void 0, function* (cleanupClient = client, restApiId = gateway.id) {
+        var _a;
+        const items = [];
+        const seenPositions = new Set();
+        let position;
+        for (let page = 0; page < AWS_CLEANUP_MAX_PAGES; page++) {
+            const resources = yield cleanupClient.send(new GetResourcesCommand(Object.assign({ restApiId, limit: 500 }, (position ? { position } : {}))), cleanupOptions());
+            items.push(...((_a = resources.items) !== null && _a !== void 0 ? _a : []));
+            if (!resources.position)
+                return Object.freeze(items);
+            if (seenPositions.has(resources.position)) {
+                throw new Error("AWS API Gateway returned a repeated cleanup pagination cursor");
+            }
+            seenPositions.add(resources.position);
+            position = resources.position;
+        }
+        throw new Error(`AWS API Gateway cleanup exceeded ${AWS_CLEANUP_MAX_PAGES} resource pages`);
+    });
+    const reconcileResource = (expectedPathPart, expectedResourceId) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        let lastError;
+        let observedCompleteListing = false;
+        for (let attempt = 1; attempt <= AWS_CLEANUP_MAX_ATTEMPTS; attempt++) {
+            try {
+                const resources = yield listCleanupResources();
+                observedCompleteListing = true;
+                const resourceId = (_a = resources.find((item) => item.pathPart === expectedPathPart &&
+                    (expectedResourceId === undefined || item.id === expectedResourceId))) === null || _a === void 0 ? void 0 : _a.id;
+                if (resourceId) {
+                    return (yield deleteResource(resourceId)) ? "deleted" : "unresolved";
+                }
+            }
+            catch (err) {
+                lastError = err;
+            }
+            if (attempt < AWS_CLEANUP_MAX_ATTEMPTS) {
+                yield sleep(AWS_CLEANUP_RETRY_DELAY_MS * attempt);
+            }
+        }
+        if (!observedCompleteListing && lastError !== undefined) {
+            progressError(chalk.red(`[!] Error when reconciling temporary AWS API Gateway resource: ${lastError}`));
+            return "unresolved";
+        }
+        return "absent";
+    });
+    const replayGatewayRecords = (records, replayGateway, replayClient) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        let resources = null;
+        let lastError;
+        for (let attempt = 1; attempt <= AWS_CLEANUP_MAX_ATTEMPTS; attempt++) {
+            try {
+                resources = yield listCleanupResources(replayClient, replayGateway.id);
+                break;
+            }
+            catch (err) {
+                lastError = err;
+                if (attempt < AWS_CLEANUP_MAX_ATTEMPTS) {
+                    yield sleep(AWS_CLEANUP_RETRY_DELAY_MS * attempt);
+                }
+            }
+        }
+        if (!resources) {
+            progressError(chalk.red(`[!] Error when replaying pending AWS API Gateway cleanup for ${replayGateway.id}: ${lastError}`));
+            for (const record of records)
+                deferCleanupRecord(record);
+            return;
+        }
+        for (const record of records) {
+            const resourceId = (_a = resources.find((item) => item.pathPart === record.resourcePathPart &&
+                (record.resourceId === undefined || item.id === record.resourceId))) === null || _a === void 0 ? void 0 : _a.id;
+            if (resourceId) {
+                if (yield deleteResource(resourceId, replayClient, replayGateway.id)) {
+                    retireCleanupRecord(record);
+                }
+                else {
+                    deferCleanupRecord(record);
+                }
+                continue;
+            }
+            const oldEnoughToConfirmAbsence = Date.now() - Date.parse(record.recordedAt) >= AWS_CLEANUP_ABSENCE_GRACE_MS;
+            if (oldEnoughToConfirmAbsence)
+                retireCleanupRecord(record);
+        }
+    });
+    const replayCleanupRecords = () => __awaiter(void 0, void 0, void 0, function* () {
+        return withCleanupReplaySingleFlight(cleanupDirectory, () => __awaiter(void 0, void 0, void 0, function* () {
+            const now = Date.now();
+            const expiredRecords = loadCleanupRecords().filter((record) => Date.parse(record.leaseExpiresAt) <= now && Date.parse(record.nextRetryAt) <= now);
+            if (expiredRecords.length === 0)
+                return;
+            const replayedGateways = new Set();
+            for (const replayGateway of Object.values(config)) {
+                const gatewayKey = `${replayGateway.region}\0${replayGateway.id}`;
+                if (replayedGateways.has(gatewayKey))
+                    continue;
+                replayedGateways.add(gatewayKey);
+                const records = expiredRecords.filter((record) => record.gatewayId === replayGateway.id && record.region === replayGateway.region);
+                if (records.length === 0)
+                    continue;
+                const useCurrentClient = replayGateway === gateway;
+                const replayClient = useCurrentClient
+                    ? client
+                    : new APIGatewayClient({
+                        region: replayGateway.region,
+                        credentials: {
+                            accessKeyId: replayGateway.access_key,
+                            secretAccessKey: replayGateway.secret_key,
+                        },
+                    });
+                try {
+                    yield replayGatewayRecords(records, replayGateway, replayClient);
+                }
+                finally {
+                    if (!useCurrentClient)
+                        replayClient.destroy();
+                }
+            }
+        }));
+    });
+    const reconcileAmbiguousResource = (record) => __awaiter(void 0, void 0, void 0, function* () {
+        const outcome = yield reconcileResource(record.resourcePathPart);
+        if (outcome === "deleted") {
+            retireCleanupRecord(record);
+        }
+        else if (outcome === "unresolved") {
+            progressError(chalk.red(`[!] Temporary AWS API Gateway ownership remains pending in ${cleanupRecordPath(record.recordId)}`));
+        }
+    });
+    const configureResource = (resourceId) => __awaiter(void 0, void 0, void 0, function* () {
+        yield client.send(new PutMethodCommand({
+            restApiId: gateway.id,
+            resourceId,
             httpMethod: "GET",
             authorizationType: "NONE",
             requestParameters: {
@@ -105,93 +397,108 @@ const get = (url_1, ...args_1) => __awaiter(void 0, [url_1, ...args_1], void 0,
                 "method.request.header.Sec-Fetch-Mode": false,
                 "method.request.header.Sec-Fetch-Dest": false,
             },
-        });
-        const newMethodResponse = yield client.send(newMethodCommand);
-        yield sleep(100);
-        // create new integration
-        const newIntegrationCommand = new PutIntegrationCommand({
-            restApiId: config[apiGateway].id,
-            resourceId: newResourceResponse.id,
+        }), sendOptions);
+        yield sleep(100, operationSignal);
+        yield client.send(new PutIntegrationCommand({
+            restApiId: gateway.id,
+            resourceId,
             httpMethod: "GET",
             integrationHttpMethod: "GET",
             type: "HTTP",
             timeoutInMillis: 29000,
             uri: url,
-        });
-        const newIntegrationResponse = yield client.send(newIntegrationCommand);
-        yield sleep(100);
-        // create a new method response
-        const newMethodResponseCommand = new PutMethodResponseCommand({
+        }), sendOptions);
+        yield sleep(100, operationSignal);
+        yield client.send(new PutMethodResponseCommand({
             httpMethod: "GET",
-            resourceId: newResourceResponse.id,
-            restApiId: config[apiGateway].id,
+            resourceId,
+            restApiId: gateway.id,
             statusCode: "200",
-        });
-        const newMethodResponseResponse = yield client.send(newMethodResponseCommand);
-        yield sleep(100);
-        // put integration response
-        const putIntegrationResponseCommand = new PutIntegrationResponseCommand({
+        }), sendOptions);
+        yield sleep(100, operationSignal);
+        yield client.send(new PutIntegrationResponseCommand({
             httpMethod: "GET",
-            resourceId: newResourceResponse.id,
-            restApiId: config[apiGateway].id,
+            resourceId,
+            restApiId: gateway.id,
             statusCode: "200",
-        });
-        const putIntegrationResponseResponse = yield client.send(putIntegrationResponseCommand);
-        yield sleep(100);
-    }
-    // Generate dynamic stage name
-    //   const dynamicStageName = `prod-${Date.now()}-${Math.random().toString(36).substring(2, 7)}`;
-    //   console.log(chalk.blue(`[*] Using dynamic stage name: ${dynamicStageName}`));
-    // Create a deployment
-    //   const createDeploymentCommand = new CreateDeploymentCommand({
-    //     restApiId: config[apiGateway].id,
-    //     stageName: dynamicStageName,
-    //     description: `Deployment for ${url} at ${new Date().toISOString()} to stage ${dynamicStageName}`,
-    //   });
-    //   const deploymentResponse = await client.send(createDeploymentCommand);
-    //   console.log(chalk.green("[+] Deployment created:"), deploymentResponse.id);
-    //   await sleep(100);
-    const testInvokeMethodQuery = new TestInvokeMethodCommand({
-        httpMethod: "GET",
-        resourceId: newResourceResponse.id,
-        restApiId: config[apiGateway].id,
-        headers: headers || {},
+        }), sendOptions);
+        yield sleep(100, operationSignal);
     });
-    const testInvokeMethodResponse = yield client.send(testInvokeMethodQuery);
-    yield sleep(100);
-    const body = yield testInvokeMethodResponse.body;
-    // delete the resource
-    const deleteResourceCommand = new DeleteResourceCommand({
-        restApiId: config[apiGateway].id,
-        resourceId: newResourceResponse.id,
+    const createResource = (parentId) => __awaiter(void 0, void 0, void 0, function* () {
+        const initialCleanupRecord = beginCleanupOwnership();
+        let resourceId;
+        try {
+            const created = yield client.send(new CreateResourceCommand({
+                restApiId: gateway.id,
+                parentId,
+                pathPart: resourcePathPart,
+            }), sendOptions);
+            if (!created.id)
+                throw new Error("AWS API Gateway did not return a resource ID");
+            resourceId = created.id;
+        }
+        catch (error) {
+            // CreateResource can commit remotely even when cancellation or a
+            // transport failure loses its response. Reconcile by deterministic
+            // pathPart before returning the original failure.
+            yield reconcileAmbiguousResource(initialCleanupRecord);
+            throw error;
+        }
+        const cleanupRecord = Object.freeze(Object.assign(Object.assign({}, initialCleanupRecord), { resourceId }));
+        // The original pathPart-only record remains sufficient for replay if
+        // this best-effort enrichment cannot be persisted.
+        persistCleanupRecord(cleanupRecord);
+        try {
+            yield sleep(200, operationSignal);
+            yield configureResource(resourceId);
+            return Object.freeze({ id: resourceId, cleanupRecord });
+        }
+        catch (error) {
+            if (yield deleteResource(resourceId))
+                retireCleanupRecord(cleanupRecord);
+            throw error;
+        }
     });
     try {
-        yield client.send(deleteResourceCommand);
+        yield replayCleanupRecords();
+        const resources = yield listCleanupResources();
+        yield sleep(200, operationSignal);
+        const existingResource = resources.find((item) => item.pathPart === resourcePathPart);
+        const rootId = (_c = (_b = resources.find((item) => item.path === "/")) === null || _b === void 0 ? void 0 : _b.id) !== null && _c !== void 0 ? _c : (_d = resources[0]) === null || _d === void 0 ? void 0 : _d.parentId;
+        if (!(existingResource === null || existingResource === void 0 ? void 0 : existingResource.id) && !rootId) {
+            throw new Error("AWS API Gateway did not return a root resource ID");
+        }
+        const resource = (existingResource === null || existingResource === void 0 ? void 0 : existingResource.id)
+            ? { id: existingResource.id, cleanupRecord: null }
+            : yield createResource(rootId);
+        try {
+            const invoked = yield client.send(new TestInvokeMethodCommand({
+                httpMethod: "GET",
+                resourceId: resource.id,
+                restApiId: gateway.id,
+                headers,
+            }), sendOptions);
+            yield sleep(100, operationSignal);
+            return { body: (_e = invoked.body) !== null && _e !== void 0 ? _e : "", status: invoked.status, headers: invoked.headers };
+        }
+        finally {
+            if (resource.cleanupRecord && (yield deleteResource(resource.id))) {
+                retireCleanupRecord(resource.cleanupRecord);
+            }
+        }
     }
-    catch (err) {
-        console.error(chalk.red(`[!] Error when sending delete resource command to AWS: ${err}`));
+    finally {
+        clearTimeout(operationTimeout);
+        client.destroy();
     }
-    return body;
-    // create a new stage
-    //   dynamicStageName = `prod-${Date.now()}-${Math.random().toString(36).substring(2, 7)}`;
-    //   const newStageCommand = new CreateStageCommand({
-    //     restApiId: config[apiGateway].id,
-    //     stageName: dynamicStageName, // Use dynamic stage name
-    //     deploymentId: deploymentResponse.id, // Use the ID from the deployment
-    //     cacheClusterEnabled: false,
-    //     // cacheClusterSize: "0", // Removed as cacheClusterEnabled is false
-    //     methodSettings: [
-    //       {
-    //         httpMethod: "*",
-    //         // resourceId: "*", // This might need to be more specific if you don't want it for all resources
-    //         throttlingBurstLimit: 5,
-    //         throttlingRateLimit: 10,
-    //       },
-    //     ],
-    //   });
-    //   const newStageResponse = await client.send(newStageCommand);
-    //   await sleep(100);
-    //   console.log(newStageResponse);
 });
-export { get };
+/**
+ * Given a URL, generates a new API Gateway for it and returns the response body as text.
+ * @param {string} url The URL to generate an API Gateway for.
+ * @param {object} [headers] The headers to include in the request.
+ * @param {AbortSignal} [signal] Cancels pending AWS operations and retry delays.
+ * @returns {Promise<string>} The response body of the URL.
+ */
+const get = (url_1, ...args_1) => __awaiter(void 0, [url_1, ...args_1], void 0, function* (url, headers = {}, signal) { return (yield getWithMetadata(url, headers, signal)).body; });
+export { get, getWithMetadata };
 //# sourceMappingURL=genReq.js.map