@gpzhang2001/sharpkit-proxy 0.2.1

package/lib/index.js

@@ -0,0 +1,1307 @@
+import z from "@deepseek-ai/schemastery";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { Buffer as Buffer$1 } from "node:buffer";
+//#region src/replay.ts
+/** strix clips replay response bodies at 8192 chars (caido_api.py:222). */
+const RESPONSE_BODY_MAX_CHARS = 8192;
+/** Framing headers that must never survive into a modified replay (strix :175). */
+const FRAMING_HEADERS = /* @__PURE__ */ new Set(["content-length", "transfer-encoding"]);
+/**
+* Parse a raw HTTP request text into components (strix `parse_raw_request`).
+* @param rawContent - the raw request text.
+* @returns the parsed components.
+* @throws when the request line is malformed.
+*/
+function parseRawRequest(rawContent) {
+	const lines = rawContent.split("\n");
+	const requestLine = (lines[0] ?? "").trim().split(" ");
+	if (requestLine.length < 2) throw new Error("Invalid request line format");
+	const headers = {};
+	let bodyStart = 0;
+	for (let index = 1; index < lines.length; index++) {
+		const line = lines[index] ?? "";
+		if (line.trim() === "") {
+			bodyStart = index + 1;
+			break;
+		}
+		const separator = line.indexOf(":");
+		if (separator !== -1) headers[line.slice(0, separator).trim()] = line.slice(separator + 1).trim();
+	}
+	const body = bodyStart < lines.length ? lines.slice(bodyStart).join("\n").trim() : "";
+	return {
+		method: requestLine[0] ?? "",
+		urlPath: requestLine[1] ?? "",
+		headers,
+		body
+	};
+}
+/**
+* Compose the full URL from the original request's connection facts, the
+* parsed components, and an optional explicit url override (strix
+* `full_url_from_components`).
+* @param original - the stored request's host/tls facts.
+* @param components - parsed raw request components.
+* @param modifications - the patch dict.
+* @returns the absolute target URL.
+*/
+function fullUrlFromComponents(original, components, modifications) {
+	const override = modifications["url"];
+	if (typeof override === "string" && override !== "") return override;
+	const hostHeader = components.headers["Host"] ?? original.host;
+	return `${original.tls ? "https" : "http"}://${hostHeader}${components.urlPath}`;
+}
+/** Parse a query string into a first-value map (Node parity of parse_qs). */
+function parseQuery(query) {
+	const params = {};
+	for (const pair of query.split("&")) {
+		if (pair === "") continue;
+		const eq = pair.indexOf("=");
+		const key = eq === -1 ? pair : pair.slice(0, eq);
+		const value = eq === -1 ? "" : pair.slice(eq + 1);
+		params[decodeURIComponent(key)] = decodeURIComponent(value);
+	}
+	return params;
+}
+/** Serialize a query map back to a string (Node parity of urlencode). */
+function encodeQuery(params) {
+	return Object.entries(params).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
+}
+/**
+* Overlay the patch dict onto parsed components (strix `apply_modifications`):
+* params merge into the query string, headers/cookies merge, body replaces.
+* @param components - parsed raw request components.
+* @param modifications - the patch dict (url/params/headers/body/cookies).
+* @param fullUrl - the composed final URL.
+* @returns the modified components keyed like strix.
+*/
+function applyModifications(components, modifications, fullUrl) {
+	const headers = { ...components.headers };
+	let body = components.body;
+	let finalUrl = fullUrl;
+	const params = modifications["params"];
+	if (params !== void 0 && params !== null && typeof params === "object") {
+		const question = finalUrl.indexOf("?");
+		const existing = question === -1 ? {} : parseQuery(finalUrl.slice(question + 1));
+		for (const [key, value] of Object.entries(params)) existing[key] = String(value);
+		finalUrl = `${question === -1 ? finalUrl : finalUrl.slice(0, question)}?${encodeQuery(existing)}`;
+	}
+	const headerPatch = modifications["headers"];
+	if (headerPatch !== void 0 && headerPatch !== null && typeof headerPatch === "object") for (const [key, value] of Object.entries(headerPatch)) headers[key] = String(value);
+	const bodyPatch = modifications["body"];
+	if (typeof bodyPatch === "string") body = bodyPatch;
+	const cookiePatch = modifications["cookies"];
+	if (cookiePatch !== void 0 && cookiePatch !== null && typeof cookiePatch === "object") {
+		const cookies = {};
+		const existingCookie = headers["Cookie"];
+		if (existingCookie !== void 0) for (const cookie of existingCookie.split(";")) {
+			const eq = cookie.indexOf("=");
+			if (eq !== -1) cookies[cookie.slice(0, eq).trim()] = cookie.slice(eq + 1).trim();
+		}
+		for (const [key, value] of Object.entries(cookiePatch)) cookies[key] = String(value);
+		headers["Cookie"] = Object.entries(cookies).map(([key, value]) => `${key}=${value}`).join("; ");
+	}
+	return {
+		method: components.method,
+		url: finalUrl,
+		headers,
+		body
+	};
+}
+/**
+* Rebuild a raw HTTP/1.1 request with connection facts (strix
+* `build_raw_request`): Host/UA defaults, framing headers dropped,
+* Content-Length recomputed from the actual body.
+* @param parts - method/url/headers/body of the replay.
+* @returns the connection target and encoded raw request bytes.
+*/
+function buildRawRequest(parts) {
+	let parsed;
+	try {
+		parsed = new URL(parts.url);
+	} catch {
+		throw new Error(`Invalid URL: ${parts.url}`);
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new Error(`Invalid URL: ${parts.url}`);
+	const tls = parsed.protocol === "https:";
+	const port = parsed.port !== "" ? Number(parsed.port) : tls ? 443 : 80;
+	const path = `${parsed.pathname}${parsed.search}`;
+	const headers = { ...parts.headers };
+	if (headers["Host"] === void 0) headers["Host"] = parsed.host;
+	if (headers["User-Agent"] === void 0) headers["User-Agent"] = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36";
+	for (const key of Object.keys(headers)) if (FRAMING_HEADERS.has(key.toLowerCase())) delete headers[key];
+	if (parts.body !== "") headers["Content-Length"] = String(Buffer.byteLength(parts.body, "utf8"));
+	const lines = [`${parts.method.toUpperCase()} ${path} HTTP/1.1`];
+	for (const [key, value] of Object.entries(headers)) lines.push(`${key}: ${value}`);
+	const raw = Buffer.from(`${lines.join("\r\n")}\r\n\r\n${parts.body}`, "utf8");
+	return {
+		connection: {
+			host: parsed.hostname,
+			port,
+			tls
+		},
+		raw
+	};
+}
+/**
+* Parse a raw HTTP response into the list_requests summary shape (strix
+* `parse_raw_response`); null when missing/unparseable. Body clipped at 8192
+* chars with a truncation flag.
+* @param rawBytes - the raw response bytes.
+* @returns the parsed parts, or null.
+*/
+function parseRawResponse(rawBytes) {
+	if (rawBytes === null || rawBytes === void 0 || rawBytes.byteLength === 0) return null;
+	const text = Buffer.from(rawBytes).toString("latin1");
+	const separator = text.indexOf("\r\n\r\n");
+	if (separator === -1) return null;
+	const lines = text.slice(0, separator).split("\r\n");
+	const statusParts = (lines[0] ?? "").split(" ");
+	if (statusParts.length < 2 || !/^\d+$/.test(statusParts[1] ?? "")) return null;
+	const headers = {};
+	for (const line of lines.slice(1)) {
+		const colon = line.indexOf(":");
+		if (colon === -1) continue;
+		headers[line.slice(0, colon).trim()] = line.slice(colon + 1).trim();
+	}
+	const bodyBytes = Buffer.from(text.slice(separator + 4), "latin1");
+	let body = bodyBytes.toString("utf8");
+	const truncated = body.length > RESPONSE_BODY_MAX_CHARS;
+	if (truncated) body = body.slice(0, RESPONSE_BODY_MAX_CHARS);
+	return {
+		statusCode: Number(statusParts[1]),
+		length: bodyBytes.byteLength,
+		headers,
+		body,
+		bodyTruncated: truncated
+	};
+}
+//#endregion
+//#region src/client.ts
+/**
+* Caido HTTP/GraphQL client — TS port of the CLIENT half of strix
+* tools/proxy/caido_api.py against the HOST-side published endpoint (global
+* fetch + Bearer token from the sandbox session's bootstrap). Documents are
+* trimmed, schema-valid subsets of the caido_sdk_client generated operations
+* (Requests/Request/ReplayEntry/StartReplayTask/sitemap trio). The replay
+* flow adapts the SDK's subscription wait into bounded polling of the entry
+* (finished when a response or an error appears; 30s strix dispatch budget).
+* @module @gpzhang2001/sharpkit-proxy/client
+*/
+/** strix `_REQ_FIELD_MAP` resolved to Caido's RequestResponseOrderBy enums. */
+const SORT_ENUMS = {
+	timestamp: "CREATED_AT",
+	host: "HOST",
+	method: "METHOD",
+	path: "PATH",
+	source: "SOURCE",
+	status_code: "RESP_STATUS_CODE",
+	response_time: "RESP_ROUNDTRIP_TIME",
+	response_size: "RESP_LENGTH"
+};
+/** Compact Requests query (subset of the SDK's generated document). */
+const REQUESTS_DOC = `query Requests($first: Int, $after: String, $filter: HTTPQLInput, $order: RequestResponseOrderInput, $scopeId: ID, $includeRequestRaw: Boolean!, $includeResponseRaw: Boolean!) {
+  requests(first: $first, after: $after, filter: $filter, order: $order, scopeId: $scopeId) {
+    edges { cursor node {
+      id host port method path query isTls createdAt
+      raw @include(if: $includeRequestRaw)
+      response { id statusCode roundtripTime length createdAt raw @include(if: $includeResponseRaw) }
+    } }
+    pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+  }
+}`;
+/** Compact Request query (both raws always requested — SDK parity note). */
+const REQUEST_DOC = `query Request($id: ID!, $includeRequestRaw: Boolean!, $includeResponseRaw: Boolean!) {
+  request(id: $id) {
+    id host port method path query isTls createdAt
+    raw @include(if: $includeRequestRaw)
+    response { id statusCode roundtripTime length createdAt raw @include(if: $includeResponseRaw) }
+  }
+}`;
+/** Empty replay session create (avoids the double history row the raw-create seeds). */
+const CREATE_REPLAY_SESSION_DOC = `mutation CreateReplaySession($input: CreateReplaySessionInput!) {
+  createReplaySession(input: $input) { session { id } error { __typename } }
+}`;
+/** Replay dispatch (strix `replay_send_raw` via the SDK's StartReplayTask). */
+const START_REPLAY_TASK_DOC = `mutation StartReplayTask($sessionId: ID!, $input: StartReplayTaskInput!) {
+  startReplayTask(sessionId: $sessionId, input: $input) { error { __typename } task { id replayEntry { id } } }
+}`;
+/** Replay entry poll — finished when request.response or error appears. */
+const REPLAY_ENTRY_DOC = `query ReplayEntry($id: ID!, $includeReplayRaw: Boolean!, $includeRequestRaw: Boolean!, $includeResponseRaw: Boolean!) {
+  replayEntry(id: $id) {
+    id error
+    request { id method path response { id statusCode length roundtripTime raw @include(if: $includeResponseRaw) } }
+  }
+}`;
+/** Scope management (strix caido_api.py scope_* via the SDK's ScopeFull set). */
+const SCOPES_DOC = `query Scopes { scopes { id name allowlist denylist indexed } }`;
+const SCOPE_DOC = `query Scope($id: ID!) { scope(id: $id) { id name allowlist denylist indexed } }`;
+const CREATE_SCOPE_DOC = `mutation CreateScope($input: CreateScopeInput!) { createScope(input: $input) { error { __typename } scope { id name allowlist denylist indexed } } }`;
+const UPDATE_SCOPE_DOC = `mutation UpdateScope($id: ID!, $input: UpdateScopeInput!) { updateScope(id: $id, input: $input) { error { __typename } scope { id name allowlist denylist indexed } } }`;
+const DELETE_SCOPE_DOC = `mutation DeleteScope($id: ID!) { deleteScope(id: $id) { deletedId } }`;
+/** Sitemap queries (verbatim field sets from strix caido_api.py:555-592). */
+const SITEMAP_ROOTS_DOC = `query GetSitemapRoots($scopeId: ID) {
+  sitemapRootEntries(scopeId: $scopeId) {
+    edges { node {
+      id kind label hasDescendants
+      metadata { ... on SitemapEntryMetadataDomain { isTls port } }
+      request { method path response { statusCode } }
+    } }
+    count { value }
+  }
+}`;
+const SITEMAP_DESCENDANTS_DOC = `query GetSitemapDescendants($parentId: ID!, $depth: SitemapDescendantsDepth!) {
+  sitemapDescendantEntries(parentId: $parentId, depth: $depth) {
+    edges { node {
+      id kind label hasDescendants
+      request { method path response { statusCode } }
+    } }
+    count { value }
+  }
+}`;
+const SITEMAP_ENTRY_DOC = `query GetSitemapEntry($id: ID!) {
+  sitemapEntry(id: $id) {
+    id kind label hasDescendants
+    metadata { ... on SitemapEntryMetadataDomain { isTls port } }
+    request { method path response { statusCode length roundtripTime } }
+    requests(first: 30, order: {by: CREATED_AT, ordering: DESC}) {
+      edges { node { method path response { statusCode length } } }
+      count { value }
+    }
+  }
+}`;
+/** Minimal GraphQL POST with bearer auth and error normalization. */
+async function graphql(options, doc, variables, signal) {
+	const response = await (options.fetchFn ?? fetch)(`${options.baseUrl}/graphql`, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${options.token}`
+		},
+		body: JSON.stringify({
+			query: doc,
+			variables
+		}),
+		signal
+	});
+	const text = await response.text();
+	if (response.status !== 200) throw new Error(`caido graphql HTTP ${response.status}: ${text.slice(0, 200)}`);
+	let payload;
+	try {
+		payload = JSON.parse(text);
+	} catch (error) {
+		throw new Error(`caido graphql unparseable response: ${String(error)}`);
+	}
+	const record = payload;
+	if (record.errors !== void 0 && record.errors !== null) throw new Error(`caido graphql errors: ${JSON.stringify(record.errors).slice(0, 300)}`);
+	if (typeof record.data !== "object" || record.data === null) throw new Error("caido graphql carried no data");
+	return record.data;
+}
+/** Project one raw requests-connection edge (strix list_requests mapping). */
+function projectEdge(edge) {
+	const node = edge.node;
+	const response = node.response;
+	return {
+		cursor: String(edge.cursor),
+		request: {
+			id: String(node.id),
+			host: String(node.host),
+			port: Number(node.port),
+			method: String(node.method),
+			path: String(node.path),
+			query: node.query === null || node.query === void 0 ? null : String(node.query),
+			tls: node.isTls === true,
+			createdAt: new Date(Number(node.createdAt)).toISOString()
+		},
+		response: response === null || response === void 0 ? null : {
+			id: String(response.id),
+			statusCode: response.statusCode === null || response.statusCode === void 0 ? null : Number(response.statusCode),
+			length: response.length === null || response.length === void 0 ? null : Number(response.length),
+			createdAt: response.createdAt === null || response.createdAt === void 0 ? null : new Date(Number(response.createdAt)).toISOString()
+		}
+	};
+}
+/**
+* The Caido client: five operations behind the five proxy tools. All methods
+* take an AbortSignal (tool exec.signal parity).
+*/
+var CaidoClient = class {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	/** List captured requests with HTTPQL filter/cursor/sort/scope (strix list_requests_with_client). */
+	async listRequests(options, signal) {
+		const data = await graphql(this.options, REQUESTS_DOC, {
+			first: options.first ?? 50,
+			...options.after !== void 0 && options.after !== "" ? { after: options.after } : {},
+			...options.httpqlFilter !== void 0 && options.httpqlFilter !== "" ? { filter: { code: options.httpqlFilter } } : {},
+			order: {
+				by: SORT_ENUMS[options.sortBy ?? "timestamp"],
+				ordering: (options.sortOrder ?? "desc") === "asc" ? "ASC" : "DESC"
+			},
+			...options.scopeId !== void 0 && options.scopeId !== "" ? { scopeId: options.scopeId } : {},
+			includeRequestRaw: false,
+			includeResponseRaw: false
+		}, signal);
+		return {
+			entries: data.requests.edges.map(projectEdge),
+			pageInfo: {
+				hasNextPage: data.requests.pageInfo.hasNextPage === true,
+				hasPreviousPage: data.requests.pageInfo.hasPreviousPage === true,
+				startCursor: data.requests.pageInfo.startCursor === null || data.requests.pageInfo.startCursor === void 0 ? null : String(data.requests.pageInfo.startCursor),
+				endCursor: data.requests.pageInfo.endCursor === null || data.requests.pageInfo.endCursor === void 0 ? null : String(data.requests.pageInfo.endCursor)
+			}
+		};
+	}
+	/** Fetch one request with both raw halves (strix get_request_with_client parity: always request both). */
+	async getRequest(requestId, signal) {
+		const request = (await graphql(this.options, REQUEST_DOC, {
+			id: requestId,
+			includeRequestRaw: true,
+			includeResponseRaw: true
+		}, signal)).request;
+		if (request === null || request === void 0) return null;
+		return {
+			id: String(request.id),
+			host: String(request.host),
+			port: Number(request.port),
+			method: String(request.method),
+			tls: request.isTls === true,
+			requestRaw: request.raw === null || request.raw === void 0 ? null : Buffer$1.from(String(request.raw), "base64").toString("utf8"),
+			responseRaw: request.response?.raw === null || request.response?.raw === void 0 ? null : Buffer$1.from(String(request.response.raw), "base64").toString("utf8")
+		};
+	}
+	/**
+	* Replay one stored request with optional field patches (strix
+	* `repeat_request` + `replay_send_raw`): fetch raw → parse → patch →
+	* rebuild → create empty session → startReplayTask → poll the entry.
+	* @param requestId - the stored request id.
+	* @param modifications - patch dict (url/params/headers/body/cookies).
+	* @param budget - total dispatch deadline (strix 30s) + poll interval.
+	*/
+	async replayRequest(requestId, modifications, signal, budget) {
+		const stored = await this.getRequest(requestId, signal);
+		if (stored === null || stored.requestRaw === null) return null;
+		const components = parseRawRequest(stored.requestRaw);
+		const fullUrl = fullUrlFromComponents({
+			host: stored.host,
+			tls: stored.tls
+		}, components, modifications ?? {});
+		const built = buildRawRequest(applyModifications(components, modifications ?? {}, fullUrl));
+		const createdSession = (await graphql(this.options, CREATE_REPLAY_SESSION_DOC, { input: {} }, signal)).createReplaySession.session;
+		if (createdSession === null || createdSession === void 0) throw new Error("createReplaySession returned no session");
+		const started = Date.now();
+		const start = await graphql(this.options, START_REPLAY_TASK_DOC, {
+			sessionId: createdSession.id,
+			input: {
+				connection: {
+					host: built.connection.host,
+					port: built.connection.port,
+					isTLS: built.connection.tls,
+					SNI: null
+				},
+				raw: Buffer$1.from(built.raw).toString("base64"),
+				settings: {
+					connectionClose: false,
+					updateContentLength: true,
+					placeholders: []
+				}
+			}
+		}, signal);
+		const task = start.startReplayTask.task;
+		if (start.startReplayTask.error !== null && start.startReplayTask.error !== void 0) throw new Error(`startReplayTask failed: ${JSON.stringify(start.startReplayTask.error).slice(0, 200)}`);
+		if (task === null || task === void 0 || task.replayEntry === null || task.replayEntry === void 0) throw new Error("startReplayTask returned no task/entry");
+		for (;;) {
+			const node = (await graphql(this.options, REPLAY_ENTRY_DOC, {
+				id: task.replayEntry.id,
+				includeReplayRaw: false,
+				includeRequestRaw: false,
+				includeResponseRaw: true
+			}, signal)).replayEntry;
+			if (node !== null && node !== void 0) {
+				const errorText = node.error === null || node.error === void 0 ? void 0 : String(node.error);
+				const responseNode = node.request?.response ?? null;
+				if (responseNode !== null && responseNode !== void 0) {
+					const rawBase64 = responseNode.raw;
+					const rawBytes = rawBase64 === null || rawBase64 === void 0 ? null : Buffer$1.from(String(rawBase64), "base64");
+					return {
+						sessionId: createdSession.id,
+						status: "DONE",
+						elapsedMs: Date.now() - started,
+						...errorText !== void 0 ? { error: errorText } : {},
+						response: parseRawResponse(rawBytes)
+					};
+				}
+				if (errorText !== void 0) return {
+					sessionId: createdSession.id,
+					status: "ERROR",
+					elapsedMs: Date.now() - started,
+					error: errorText,
+					response: null
+				};
+			}
+			if (Date.now() - started > budget.dispatchTimeoutMs) return {
+				sessionId: createdSession.id,
+				status: "ERROR",
+				elapsedMs: Date.now() - started,
+				error: `Caido replay dispatch did not complete within ${String(Math.round(budget.dispatchTimeoutMs / 1e3))}s — the target may be unroutable from the sandbox, or Caido's outbound HTTP client is stalled; check the target host/port and retry`,
+				response: null
+			};
+			await new Promise((resolve) => setTimeout(resolve, budget.pollIntervalMs));
+		}
+	}
+	/** Sitemap roots or descendants (strix list_sitemap_with_client). */
+	async listSitemap(options, signal) {
+		if (options.parentId !== void 0 && options.parentId !== "") return graphql(this.options, SITEMAP_DESCENDANTS_DOC, {
+			parentId: options.parentId,
+			depth: options.depth ?? "DIRECT"
+		}, signal);
+		return graphql(this.options, SITEMAP_ROOTS_DOC, options.scopeId !== void 0 && options.scopeId !== "" ? { scopeId: options.scopeId } : {}, signal);
+	}
+	/** One sitemap entry with its 30 most recent requests (strix view_sitemap_entry_with_client). */
+	async viewSitemapEntry(entryId, signal) {
+		return graphql(this.options, SITEMAP_ENTRY_DOC, { id: entryId }, signal);
+	}
+	/** All Caido scopes (strix scope_list). */
+	async scopeList(signal) {
+		return graphql(this.options, SCOPES_DOC, {}, signal);
+	}
+	/** One scope by id (strix scope_get). */
+	async scopeGet(scopeId, signal) {
+		return graphql(this.options, SCOPE_DOC, { id: scopeId }, signal);
+	}
+	/** Create a scope; empty lists allow-all/deny-none (strix scope_create). */
+	async scopeCreate(name, allowlist, denylist, signal) {
+		return graphql(this.options, CREATE_SCOPE_DOC, { input: {
+			name,
+			allowlist,
+			denylist
+		} }, signal);
+	}
+	/** Update a scope; allow/deny lists FULLY REPLACE the previous values (strix parity). */
+	async scopeUpdate(scopeId, name, allowlist, denylist, signal) {
+		return graphql(this.options, UPDATE_SCOPE_DOC, {
+			id: scopeId,
+			input: {
+				name,
+				allowlist,
+				denylist
+			}
+		}, signal);
+	}
+	/** Delete a scope (strix scope_delete). */
+	async scopeDelete(scopeId, signal) {
+		return graphql(this.options, DELETE_SCOPE_DOC, { id: scopeId }, signal);
+	}
+};
+//#endregion
+//#region src/index.ts
+const name = "pentest-tool-proxy";
+const inject = ["tools", "pentestSandbox"];
+const Config = z.object({
+	scanId: z.string().default("pentest"),
+	listPageSize: z.number().default(50),
+	replayTimeoutMs: z.number().default(3e4),
+	caidoTimeoutMs: z.number().default(6e4),
+	requireApproval: z.boolean().default(true),
+	authorizedTargets: z.array(z.string())
+});
+/**
+* Whether a repeat target host is inside the authorized list. Entries may be
+* bare hosts (`example.com`), wildcard subdomains (`*.example.com`), or full
+* URLs (hostname taken); a candidate matches on exact host or a dot-suffix
+* subdomain. An empty list allows everything (fail-open; warned once).
+* @param host - the replay target hostname.
+* @param authorized - the configured target entries.
+*/
+function targetHostAllowed(host, authorized) {
+	if (authorized.length === 0) return true;
+	const candidate = host.toLowerCase();
+	return authorized.some((entry) => {
+		let allowed = entry.trim().toLowerCase();
+		if (allowed === "") return false;
+		if (allowed.includes("://")) try {
+			allowed = new URL(allowed).hostname;
+		} catch {}
+		allowed = allowed.replace(/^\*\./, "").replace(/\/.*$/, "");
+		return allowed !== "" && (candidate === allowed || candidate.endsWith(`.${allowed}`));
+	});
+}
+/**
+* Resolve the replay target hostname: an explicit url modification wins;
+* otherwise the stored request's host.
+*/
+function resolveRepeatTargetHost(storedHost, modifications) {
+	const override = modifications?.["url"];
+	if (typeof override === "string" && override !== "") try {
+		return new URL(override).hostname;
+	} catch {}
+	return storedHost;
+}
+/** Sitemap page size (strix parity: 30 entries per page). */
+const SITEMAP_PAGE_SIZE = 30;
+/**
+* Slice one sitemap connection payload to a 1-indexed page of edges (the
+* total count is preserved). Payloads without a recognized connection pass
+* through untouched.
+*/
+function pageSitemapPayload(payload, page) {
+	for (const key of ["sitemapRootEntries", "sitemapDescendantEntries"]) {
+		const connection = payload[key];
+		if (typeof connection !== "object" || connection === null) continue;
+		const edges = connection.edges;
+		if (!Array.isArray(edges)) continue;
+		const start = Math.max(0, (page - 1) * 30);
+		const sliced = edges.slice(start, start + 30);
+		return {
+			...payload,
+			[key]: {
+				...connection,
+				edges: sliced,
+				page,
+				page_size: 30,
+				has_more: start + 30 < edges.length
+			}
+		};
+	}
+	return payload;
+}
+/**
+* Compact regex hits over raw content (strix `_format_search_hits`).
+* @param content - the raw text.
+* @param pattern - the model-supplied regex.
+* @returns the hits payload, or an error entry when the regex is invalid.
+*/
+function formatSearchHits(content, pattern) {
+	let regex;
+	try {
+		regex = new RegExp(pattern, "g");
+	} catch (error) {
+		return {
+			hits: [],
+			totalHits: 0,
+			error: `Invalid regex: ${String(error)}`
+		};
+	}
+	const hits = [];
+	for (const match of content.matchAll(regex)) {
+		const start = match.index ?? 0;
+		const end = start + match[0].length;
+		hits.push({
+			match: match[0],
+			position: start,
+			before: content.slice(Math.max(0, start - 40), start),
+			after: content.slice(end, end + 40)
+		});
+		if (hits.length >= 20) break;
+	}
+	return {
+		hits,
+		totalHits: hits.length
+	};
+}
+/**
+* Line-paginated raw content page (strix `_format_text_page`).
+* @param content - the raw text.
+* @param page - 1-indexed page number.
+* @param pageSize - lines per page.
+*/
+function formatTextPage(content, page, pageSize) {
+	const lines = content.split("\n");
+	const start = Math.max(0, (page - 1) * pageSize);
+	const end = start + pageSize;
+	return {
+		content: lines.slice(start, end).join("\n"),
+		page,
+		pageSize,
+		totalLines: lines.length,
+		hasMore: end < lines.length
+	};
+}
+/** Strip undefined values so an object satisfies the JsonValue index contract. */
+function structuredToPlain(value) {
+	return JSON.parse(JSON.stringify(value));
+}
+/** Unwrap the GraphQL envelope for one scope row. */
+function plainScope(envelope) {
+	const record = envelope;
+	for (const key of [
+		"scope",
+		"createScope",
+		"updateScope"
+	]) {
+		const inner = record[key];
+		if (typeof inner === "object" && inner !== null) {
+			const scope = inner["scope"];
+			if (typeof scope === "object" && scope !== null) return scope;
+		}
+	}
+	return record;
+}
+/** Unwrap a scopes list envelope. */
+function plainScopes(rows) {
+	return rows.filter((row) => typeof row === "object" && row !== null);
+}
+function apply(ctx, config = {}) {
+	const scanId = config.scanId ?? "pentest";
+	const listPageSize = config.listPageSize ?? 50;
+	const replayTimeoutMs = config.replayTimeoutMs ?? 3e4;
+	const caidoTimeoutMs = config.caidoTimeoutMs ?? 6e4;
+	let clientPromise;
+	let warnedNoAllowlist = false;
+	/** Authorized targets: Config first, else the preset's scan targets. Empty = fail-open (warned once). */
+	const authorizedTargets = () => {
+		if (config.authorizedTargets !== void 0) return config.authorizedTargets;
+		const values = ctx.get("pentestPreset")?.authorizedTargets?.map((target) => target.value) ?? [];
+		if (values.length === 0 && !warnedNoAllowlist) {
+			warnedNoAllowlist = true;
+			ctx.logger.warn("pentest-proxy: no authorizedTargets configured; repeat_request target enforcement is inactive (fail-open)");
+		}
+		return values;
+	};
+	/** Lazy client: resolves the session's Caido bootstrap on first use (strix parity). */
+	const client = (signal) => {
+		clientPromise ??= (async () => {
+			const endpoint = await (await ctx.pentestSandbox.createSession({ scanId })).caidoEndpoint();
+			return new CaidoClient({
+				baseUrl: endpoint.baseUrl,
+				token: endpoint.token
+			});
+		})().catch((error) => {
+			throw new Error(`Caido client not available in run context: ${String(error instanceof Error ? error.message : error)}`);
+		});
+		const settled = clientPromise;
+		if (settled === void 0) throw new Error("unreachable: client promise just assigned");
+		const timeout = new Promise((_resolve, reject) => {
+			signal.addEventListener("abort", () => reject(/* @__PURE__ */ new Error("caido call aborted")), { once: true });
+			const timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`caido call timed out after ${String(caidoTimeoutMs)}ms`)), caidoTimeoutMs);
+			settled.then(() => clearTimeout(timer), () => clearTimeout(timer));
+		});
+		return Promise.race([settled, timeout]);
+	};
+	if (config.requireApproval !== false) ctx.on("tools/pre-execute", async (exec, next) => {
+		if (exec.name === "repeat_request") return {
+			kind: "ask",
+			reason: "pentest: replay a captured request against the target"
+		};
+		return next();
+	});
+	ctx.tools.register(defineTool({
+		name: "list_requests",
+		description: `List captured HTTP requests from the Caido proxy with HTTPQL filtering. HTTPQL: integer fields (resp.code, req.port, id, roundtrip) use eq/gt/gte/lt/lte/ne e.g. 'resp.code.gte:400'; text fields (req.method, req.host, req.path, req.query, req.ext, req.raw) use regex/cont/eq e.g. 'req.path.cont:"/api/"'; dates use gt/lt with ISO e.g. 'req.created_at.gt:"2024-01-01T00:00:00Z"'; combine with AND/OR; no NOT — use ne/ncont/nregex. String values MUST be quoted, integers MUST NOT. A bare quoted string searches req.raw and resp.raw. Pagination: pass page_info.end_cursor as after.`,
+		parameters: {
+			httpql_filter: {
+				type: "string",
+				description: "Caido HTTPQL query (optional)."
+			},
+			first: {
+				type: "integer",
+				description: `Entries per page (default ${String(listPageSize)}).`
+			},
+			after: {
+				type: "string",
+				description: "Cursor from a previous response's page_info.end_cursor."
+			},
+			sort_by: {
+				type: "string",
+				enum: [
+					"timestamp",
+					"host",
+					"method",
+					"path",
+					"status_code",
+					"response_time",
+					"response_size",
+					"source"
+				],
+				description: "Sort key (default timestamp)."
+			},
+			sort_order: {
+				type: "string",
+				enum: ["asc", "desc"],
+				description: "Sort order (default desc)."
+			},
+			scope_id: {
+				type: "string",
+				description: "Restrict to a Caido scope."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				properties: {
+					success: {
+						type: "boolean",
+						required: true
+					},
+					entries: {
+						type: "array",
+						items: {
+							type: "object",
+							properties: {},
+							additionalProperties: true
+						}
+					},
+					page_info: {
+						type: "object",
+						properties: {},
+						additionalProperties: true
+					},
+					error: { type: "string" }
+				},
+				additionalProperties: false
+			},
+			render: (_args, value) => {
+				const result = value;
+				if (!result.success) return [{
+					type: "text",
+					text: `list_requests failed: ${result.error ?? "unknown"}`
+				}];
+				return [{
+					type: "text",
+					text: `${String(result.entries.length)} entries (cursor pagination via page_info)`
+				}];
+			}
+		},
+		execute: async (args, exec) => {
+			try {
+				const connection = await (await client(exec.signal)).listRequests({
+					httpqlFilter: args.httpql_filter,
+					first: args.first ?? listPageSize,
+					after: args.after,
+					sortBy: args.sort_by,
+					sortOrder: args.sort_order,
+					scopeId: args.scope_id
+				}, exec.signal);
+				return {
+					success: true,
+					entries: connection.entries.map((entry) => ({
+						cursor: entry.cursor,
+						request: {
+							id: entry.request.id,
+							host: entry.request.host,
+							port: entry.request.port,
+							method: entry.request.method,
+							path: entry.request.path,
+							query: entry.request.query,
+							is_tls: entry.request.tls,
+							created_at: entry.request.createdAt
+						},
+						response: entry.response === null ? null : {
+							id: entry.response.id,
+							status_code: entry.response.statusCode,
+							length: entry.response.length,
+							created_at: entry.response.createdAt
+						}
+					})),
+					page_info: {
+						has_next_page: connection.pageInfo.hasNextPage,
+						has_previous_page: connection.pageInfo.hasPreviousPage,
+						start_cursor: connection.pageInfo.startCursor,
+						end_cursor: connection.pageInfo.endCursor
+					}
+				};
+			} catch (error) {
+				return {
+					success: false,
+					entries: [],
+					page_info: {},
+					error: String(error instanceof Error ? error.message : error)
+				};
+			}
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "view_request",
+		description: `View a captured request or its response raw content, optionally regex-searched. With search_pattern: up to 20 compact hits with before/after context (hunting reflections, leaked URLs, hidden parameters). Without: full content line-paginated (page, page_size). Patterns like '/api/[a-zA-Z0-9._/-]+' (endpoints), 'https?://[^\\s<>"]+' (URLs), '[?&][a-zA-Z0-9_]+=([^&\\s]+)' (query params).`,
+		parameters: {
+			request_id: {
+				type: "string",
+				required: true,
+				description: "Request ID from list_requests."
+			},
+			part: {
+				type: "string",
+				enum: ["request", "response"],
+				description: "Which raw half to view (default request)."
+			},
+			search_pattern: {
+				type: "string",
+				description: "Optional regex; switches to compact hits mode."
+			},
+			page: {
+				type: "integer",
+				description: "1-indexed page (only without search_pattern)."
+			},
+			page_size: {
+				type: "integer",
+				description: "Lines per page (default 50)."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				properties: {
+					kind: {
+						type: "string",
+						required: true,
+						enum: [
+							"hits",
+							"page",
+							"error"
+						]
+					},
+					hits: {
+						type: "array",
+						items: {
+							type: "object",
+							properties: {},
+							additionalProperties: true
+						}
+					},
+					total_hits: { type: "integer" },
+					content: { type: "string" },
+					page: { type: "integer" },
+					page_size: { type: "integer" },
+					total_lines: { type: "integer" },
+					has_more: { type: "boolean" },
+					error: { type: "string" }
+				},
+				additionalProperties: false
+			},
+			render: (_args, value) => {
+				const result = value;
+				if (result.kind === "error") return [{
+					type: "text",
+					text: `view_request failed: ${result.error}`
+				}];
+				if (result.kind === "hits") return [{
+					type: "text",
+					text: `${String(result.total_hits)} regex hit(s)`
+				}];
+				return [{
+					type: "text",
+					text: `page ${String(result.page)}/${String(Math.ceil(result.total_lines / Math.max(1, result.page_size)))} of ${String(result.total_lines)} lines`
+				}];
+			}
+		},
+		execute: async (args, exec) => {
+			try {
+				const stored = await (await client(exec.signal)).getRequest(args.request_id, exec.signal);
+				if (stored === null) return {
+					kind: "error",
+					error: `Request ${args.request_id} not found`
+				};
+				const raw = args.part === "response" ? stored.responseRaw : stored.requestRaw;
+				if (raw === null) return {
+					kind: "error",
+					error: `No raw ${args.part === "response" ? "response" : "request"} for ${args.request_id}`
+				};
+				if (args.search_pattern !== void 0 && args.search_pattern !== "") {
+					const hits = formatSearchHits(raw, args.search_pattern);
+					if (hits.error !== void 0) return {
+						kind: "error",
+						error: hits.error
+					};
+					return {
+						kind: "hits",
+						hits: hits.hits.map((hit) => ({
+							match: hit.match,
+							position: hit.position,
+							before: hit.before,
+							after: hit.after
+						})),
+						total_hits: hits.totalHits
+					};
+				}
+				const textPage = formatTextPage(raw, args.page ?? 1, args.page_size ?? 50);
+				return {
+					kind: "page",
+					content: textPage.content,
+					page: textPage.page,
+					page_size: textPage.pageSize,
+					total_lines: textPage.totalLines,
+					has_more: textPage.hasMore
+				};
+			} catch (error) {
+				return {
+					kind: "error",
+					error: String(error instanceof Error ? error.message : error)
+				};
+			}
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "repeat_request",
+		description: `Repeat a captured request, optionally patching fields — the browse→capture→modify→test flow. modifications keys: url (replace), params (query additions), headers (additions), body (replace), cookies (additions). Inherits everything else from the original.`,
+		parameters: {
+			request_id: {
+				type: "string",
+				required: true,
+				description: "ID of the original request (from list_requests)."
+			},
+			modifications: {
+				type: "object",
+				properties: {
+					url: {
+						type: "string",
+						description: "Replace the URL."
+					},
+					params: {
+						type: "object",
+						properties: {},
+						additionalProperties: true,
+						description: "Query-string keys to add/update."
+					},
+					headers: {
+						type: "object",
+						properties: {},
+						additionalProperties: true,
+						description: "Headers to add/update."
+					},
+					body: {
+						type: "string",
+						description: "Replace the body."
+					},
+					cookies: {
+						type: "object",
+						properties: {},
+						additionalProperties: true,
+						description: "Cookies to add/update."
+					}
+				},
+				additionalProperties: false,
+				description: "Patch dict overlaying the original request."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				properties: {
+					success: {
+						type: "boolean",
+						required: true
+					},
+					status: { type: "string" },
+					session_id: { type: "string" },
+					elapsed_ms: { type: "integer" },
+					response: {
+						type: "object",
+						properties: {},
+						additionalProperties: true
+					},
+					error: { type: "string" }
+				},
+				additionalProperties: false
+			},
+			render: (_args, value) => {
+				const result = value;
+				if (!result.success) return [{
+					type: "text",
+					text: `repeat_request failed: ${result.error ?? result.status ?? "unknown"}`
+				}];
+				return [{
+					type: "text",
+					text: `replay ${result.status ?? "DONE"}${result.response?.status_code === void 0 ? "" : ` → HTTP ${String(result.response.status_code)}`}`
+				}];
+			}
+		},
+		execute: async (args, exec) => {
+			try {
+				const caido = await client(exec.signal);
+				const stored = await caido.getRequest(args.request_id, exec.signal);
+				if (stored === null) return {
+					success: false,
+					status: "ERROR",
+					error: `Request ${args.request_id} not found`
+				};
+				const allowlist = authorizedTargets();
+				const targetHost = resolveRepeatTargetHost(stored.host, args.modifications);
+				if (!targetHostAllowed(targetHost, allowlist)) return {
+					success: false,
+					status: "ERROR",
+					error: `repeat_request refused: target host '${targetHost}' is outside this scan's authorized targets`
+				};
+				const replay = await caido.replayRequest(args.request_id, args.modifications, exec.signal, {
+					dispatchTimeoutMs: replayTimeoutMs,
+					pollIntervalMs: 500
+				});
+				if (replay === null) return {
+					success: false,
+					status: "ERROR",
+					error: `Request ${args.request_id} not found`
+				};
+				return {
+					success: replay.status === "DONE",
+					status: replay.status,
+					session_id: replay.sessionId,
+					elapsed_ms: replay.elapsedMs,
+					response: replay.response === null ? {} : {
+						status_code: replay.response.statusCode,
+						length: replay.response.length,
+						headers: replay.response.headers,
+						body: replay.response.body,
+						body_truncated: replay.response.bodyTruncated
+					},
+					...replay.error !== void 0 ? { error: replay.error } : {}
+				};
+			} catch (error) {
+				return {
+					success: false,
+					status: "ERROR",
+					error: String(error instanceof Error ? error.message : error)
+				};
+			}
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "list_sitemap",
+		description: `Browse Caido's hierarchical sitemap: DOMAIN → DIRECTORY → REQUEST → REQUEST_BODY/REQUEST_QUERY. Start with no parent_id for root domains (optionally scope-filtered); drill in by passing an entry's id as parent_id (depth DIRECT or ALL). Pair with view_sitemap_entry.`,
+		parameters: {
+			scope_id: {
+				type: "string",
+				description: "Limit roots to a Caido scope (only without parent_id)."
+			},
+			parent_id: {
+				type: "string",
+				description: "Entry ID to expand; omit for root domains."
+			},
+			depth: {
+				type: "string",
+				enum: ["DIRECT", "ALL"],
+				description: "DIRECT children or the full subtree (default DIRECT)."
+			},
+			page: {
+				type: "integer",
+				description: "1-indexed page (30 entries per page, strix parity)."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				properties: {
+					success: {
+						type: "boolean",
+						required: true
+					},
+					payload: {
+						type: "object",
+						properties: {},
+						additionalProperties: true
+					},
+					error: { type: "string" }
+				},
+				additionalProperties: false
+			},
+			render: (_args, value) => {
+				const result = value;
+				return [{
+					type: "text",
+					text: result.success ? "sitemap payload returned" : `list_sitemap failed: ${result.error ?? "unknown"}`
+				}];
+			}
+		},
+		execute: async (args, exec) => {
+			try {
+				return {
+					success: true,
+					payload: structuredToPlain(pageSitemapPayload(await (await client(exec.signal)).listSitemap({
+						scopeId: args.scope_id,
+						parentId: args.parent_id,
+						depth: args.depth
+					}, exec.signal), args.page ?? 1))
+				};
+			} catch (error) {
+				return {
+					success: false,
+					payload: {},
+					error: String(error instanceof Error ? error.message : error)
+				};
+			}
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "scope_rules",
+		description: "Manage Caido scope rules: get/list/create/update/delete. Glob patterns (*, ?, [abc], [a-z], [^abc]); an EMPTY allowlist ALLOWS ALL; the denylist overrides the allowlist. Scopes feed list_requests' scope_id.",
+		parameters: {
+			action: {
+				type: "string",
+				required: true,
+				enum: [
+					"get",
+					"list",
+					"create",
+					"update",
+					"delete"
+				],
+				description: "Scope action."
+			},
+			allowlist: {
+				type: "array",
+				items: { type: "string" },
+				description: "Allow glob patterns (create/update)."
+			},
+			denylist: {
+				type: "array",
+				items: { type: "string" },
+				description: "Deny glob patterns; overrides the allowlist (create/update)."
+			},
+			scope_id: {
+				type: "string",
+				description: "Target scope id (get/update/delete)."
+			},
+			scope_name: {
+				type: "string",
+				description: "Scope name (create/update)."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				properties: {
+					success: {
+						type: "boolean",
+						required: true
+					},
+					scopes: {
+						type: "array",
+						items: {
+							type: "object",
+							properties: {},
+							additionalProperties: true
+						}
+					},
+					scope: {
+						type: "object",
+						properties: {},
+						additionalProperties: true
+					},
+					deleted: { type: "string" },
+					message: { type: "string" },
+					error: { type: "string" }
+				},
+				additionalProperties: false
+			},
+			render: (_args, value) => {
+				const result = value;
+				return [{
+					type: "text",
+					text: result.success ? "scope action succeeded" : `scope_rules failed: ${result.error ?? "unknown"}`
+				}];
+			}
+		},
+		execute: (async (rawArgs, rawExec) => {
+			const args = rawArgs;
+			const exec = rawExec;
+			try {
+				const caido = await client(exec.signal);
+				const allowlist = args.allowlist ?? [];
+				const denylist = args.denylist ?? [];
+				switch (args.action) {
+					case "list": return {
+						success: true,
+						scopes: plainScopes((await caido.scopeList(exec.signal)).scopes ?? [])
+					};
+					case "get":
+						if (args.scope_id === void 0 || args.scope_id === "") return {
+							success: false,
+							error: "Scope_id is required for action='get'"
+						};
+						return {
+							success: true,
+							scope: plainScope(await caido.scopeGet(args.scope_id, exec.signal))
+						};
+					case "create":
+						if (args.scope_name === void 0 || args.scope_name === "") return {
+							success: false,
+							error: "Scope_name is required for action='create'"
+						};
+						return {
+							success: true,
+							scope: plainScope(await caido.scopeCreate(args.scope_name, allowlist, denylist, exec.signal))
+						};
+					case "update":
+						if (args.scope_id === void 0 || args.scope_id === "" || args.scope_name === void 0 || args.scope_name === "") return {
+							success: false,
+							error: "Scope_id and scope_name are required for action='update'"
+						};
+						return {
+							success: true,
+							scope: plainScope(await caido.scopeUpdate(args.scope_id, args.scope_name, allowlist, denylist, exec.signal))
+						};
+					case "delete":
+						if (args.scope_id === void 0 || args.scope_id === "") return {
+							success: false,
+							error: "Scope_id is required for action='delete'"
+						};
+						return {
+							success: true,
+							deleted: (await caido.scopeDelete(args.scope_id, exec.signal)).deleteScope?.deletedId ?? args.scope_id,
+							message: `Scope ${args.scope_id} deleted`
+						};
+					default: return {
+						success: false,
+						error: `Unknown action: ${String(args.action)}`
+					};
+				}
+			} catch (error) {
+				return {
+					success: false,
+					error: `scope_rules failed: ${String(error instanceof Error ? error.message : error)}`
+				};
+			}
+		})
+	}));
+	ctx.tools.register(defineTool({
+		name: "view_sitemap_entry",
+		description: "Full detail for a sitemap entry plus its most recent 30 related requests. Pick entry_id from list_sitemap.",
+		parameters: { entry_id: {
+			type: "string",
+			required: true,
+			description: "ID from list_sitemap (or any nested entry)."
+		} },
+		output: {
+			schema: {
+				type: "object",
+				properties: {
+					success: {
+						type: "boolean",
+						required: true
+					},
+					payload: {
+						type: "object",
+						properties: {},
+						additionalProperties: true
+					},
+					error: { type: "string" }
+				},
+				additionalProperties: false
+			},
+			render: (_args, value) => {
+				const result = value;
+				return [{
+					type: "text",
+					text: result.success ? "sitemap entry payload returned" : `view_sitemap_entry failed: ${result.error ?? "unknown"}`
+				}];
+			}
+		},
+		execute: async (args, exec) => {
+			try {
+				return {
+					success: true,
+					payload: structuredToPlain(await (await client(exec.signal)).viewSitemapEntry(args.entry_id, exec.signal))
+				};
+			} catch (error) {
+				return {
+					success: false,
+					payload: {},
+					error: String(error instanceof Error ? error.message : error)
+				};
+			}
+		}
+	}));
+}
+//#endregion
+export { Config, SITEMAP_PAGE_SIZE, apply, formatSearchHits, formatTextPage, inject, name, pageSitemapPayload, resolveRepeatTargetHost, targetHostAllowed };
+
+//# sourceMappingURL=index.js.map