@pensar/apex 2.5.0 → 2.6.1-canary.0cc77dcc

package/build/lib/core/eventBus.d.ts

@@ -0,0 +1,195 @@
+import type { TextStreamPart, ToolSet } from "ai";
+/**
+ * Typed event map for the agent event bus.
+ *
+ * Events mirror the AI SDK's `TextStreamPart` types, plus native identity
+ * (`sessionId`/`messageId`/`partId`) for routing without inference.
+ * `subagentId` is kept as a backward-compatible alias of `sessionId`.
+ * Lifecycle events (`subagent-spawn`, `subagent-complete`) and side-channel
+ * events (`command-output`, `error`) round out the map.
+ */
+export type AgentEventMap = {
+    "text-delta": {
+        text: string;
+        subagentId?: string;
+        sessionId?: string;
+        messageId?: string;
+        partId?: string;
+    };
+    /**
+     * Extended-thinking / reasoning output streamed incrementally. Mirrors
+     * `text-delta` but carries the model's reasoning tokens (Anthropic
+     * extended thinking, OpenAI reasoning) so consumers can surface a
+     * "thinking" indicator instead of appearing to hang between tool calls.
+     */
+    "reasoning-delta": {
+        text: string;
+        subagentId?: string;
+        sessionId?: string;
+        messageId?: string;
+    };
+    /** A reasoning block opened. Lets consumers time the thinking window. */
+    "reasoning-start": {
+        subagentId?: string;
+        sessionId?: string;
+        messageId?: string;
+    };
+    /** A reasoning block closed. Paired with `reasoning-start` to derive duration. */
+    "reasoning-end": {
+        subagentId?: string;
+        sessionId?: string;
+        messageId?: string;
+    };
+    "tool-call-start": {
+        toolCallId: string;
+        toolName: string;
+        subagentId?: string;
+        sessionId?: string;
+        messageId?: string;
+        partId?: string;
+    };
+    "tool-call-delta": {
+        toolCallId: string;
+        argsTextDelta: string;
+        subagentId?: string;
+        sessionId?: string;
+        messageId?: string;
+        partId?: string;
+    };
+    "tool-call-complete": {
+        toolCallId: string;
+        toolName: string;
+        args: unknown;
+        subagentId?: string;
+        sessionId?: string;
+        messageId?: string;
+        partId?: string;
+    };
+    "tool-result": {
+        toolCallId: string;
+        toolName: string;
+        result: unknown;
+        subagentId?: string;
+        sessionId?: string;
+        messageId?: string;
+        partId?: string;
+    };
+    "subagent-spawn": {
+        subagentId: string;
+        /** The spawned child's own session id (`ses_…`). */
+        sessionId?: string;
+        name?: string;
+        input: unknown;
+        /** Omitted means top-level. Auto-populated by {@link AgentEventBus.attachChild}. */
+        parentSubagentId?: string;
+        /** Parent agent's session id (`ses_…`). Auto-populated by {@link AgentEventBus.attachChild}. */
+        parentSessionId?: string;
+    };
+    "subagent-complete": {
+        subagentId: string;
+        /** The completed child's own session id (`ses_…`). */
+        sessionId?: string;
+        status: "completed" | "failed";
+        /** Omitted means top-level. Auto-populated by {@link AgentEventBus.attachChild}. */
+        parentSubagentId?: string;
+        /** Parent agent's session id (`ses_…`). Auto-populated by {@link AgentEventBus.attachChild}. */
+        parentSessionId?: string;
+    };
+    "workflow-phase-start": {
+        phase: "discovery" | "pentesting" | "reporting";
+        label: string;
+        metadata?: Record<string, unknown>;
+    };
+    "workflow-phase-complete": {
+        phase: "discovery" | "pentesting" | "reporting";
+        summary: Record<string, unknown>;
+    };
+    "app-analysis-progress": {
+        totalApps: number;
+        completedApps: number;
+        appName?: string;
+    };
+    "step-finish": {
+        messages: unknown[];
+        subagentId?: string;
+        sessionId?: string;
+        /** The assistant message (`msg_…`) that just closed this step. */
+        messageId?: string;
+    };
+    "command-output": {
+        data: string;
+        subagentId?: string;
+    };
+    error: {
+        error: unknown;
+        subagentId?: string;
+    };
+    "trace-record": {
+        record: import("./agents/offSecAgent/trace").TraceRecord;
+        subagentId?: string;
+    };
+};
+/**
+ * Centralized, typed event bus for agent streaming output.
+ *
+ * Replaces the callback-based `ConsumeCallbacks` / `SubagentConsumeCallbacks`
+ * pattern with a publish-subscribe model.  Multiple consumers (TUI rendering,
+ * DB persistence, metrics, logging) subscribe independently.
+ *
+ * Usage:
+ * ```ts
+ * const bus = new AgentEventBus();
+ * bus.on("text-delta", (e) => process.stdout.write(e.text));
+ * bus.on("tool-call-complete", (e) => console.log(`→ ${e.toolName}`));
+ * await agent.consume();
+ * ```
+ */
+export declare class AgentEventBus {
+    private readonly emitter;
+    constructor();
+    on<K extends keyof AgentEventMap>(event: K, handler: (payload: AgentEventMap[K]) => void): this;
+    once<K extends keyof AgentEventMap>(event: K, handler: (payload: AgentEventMap[K]) => void): this;
+    off<K extends keyof AgentEventMap>(event: K, handler: (payload: AgentEventMap[K]) => void): this;
+    emit<K extends keyof AgentEventMap>(event: K, payload: AgentEventMap[K]): boolean;
+    removeAllListeners(event?: keyof AgentEventMap): this;
+    /**
+     * Forward selected events from a child bus to a parent bus, stamping
+     * `sessionId`/`subagentId` (and `parentSessionId`/`parentSubagentId`
+     * for lifecycle events) so the parent's routing works without inference.
+     */
+    static attachChild(child: AgentEventBus, parent: AgentEventBus | undefined, childSessionId: string): void;
+    /**
+     * Emit the appropriate bus event for an AI SDK `fullStream` chunk.
+     *
+     * Maps Vercel AI SDK `TextStreamPart` types to `AgentEventMap` keys:
+     *   text-delta        → text-delta
+     *   reasoning-start   → reasoning-start
+     *   reasoning-delta   → reasoning-delta
+     *   reasoning-end     → reasoning-end
+     *   tool-input-start  → tool-call-start
+     *   tool-input-delta  → tool-call-delta
+     *   tool-call         → tool-call-complete
+     *   tool-result       → tool-result
+     *   error             → error
+     *
+     * `ids` accepts a bare `subagentId` string for backward compatibility, or
+     * a {@link StreamIdContext} to also stamp `sessionId`/`messageId`/`partId`.
+     */
+    emitStreamPart(chunk: TextStreamPart<ToolSet>, ids?: string | StreamIdContext): void;
+}
+/**
+ * Identity context the emitting agent threads through
+ * {@link AgentEventBus.emitStreamPart}.
+ */
+export interface StreamIdContext {
+    /** Legacy multi-agent delineator; equals {@link sessionId} when set. */
+    subagentId?: string;
+    /** Emitting agent's session id (`ses_…`). */
+    sessionId?: string;
+    /** Current open assistant message id (`msg_…`) for this step. */
+    messageId?: string;
+    /** Current text part id (`prt_…`); minted per text run by the agent. */
+    textPartId?: string;
+    /** Resolves a stable part id (`prt_…`) for a `toolCallId`, minting on first use. */
+    toolPartId?: (toolCallId: string) => string;
+}

package/build/lib/core/eventBus.js

@@ -0,0 +1,6 @@
+import {
+  AgentEventBus2
+} from "../chunk-7gjdygcx.js";
+export {
+  AgentEventBus2 as AgentEventBus
+};

package/build/lib/core/findings/attackSurfaceRegistry.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Minimal asset shape the registry needs for dedup.
+ * Compatible with `DocumentedEndpointRecord` (persisted record)
+ * and the inline records passed by `document_endpoint`.
+ */
+export interface AssetRecord {
+    appName?: string;
+    assetName: string;
+    assetType: string;
+    description: string;
+    details?: {
+        url?: string;
+        [key: string]: unknown;
+    };
+    riskLevel?: string;
+}
+export interface AssetDuplicateCheckResult {
+    duplicate: boolean;
+    matchedAsset?: AssetRecord;
+    matchType?: "exact-url" | "exact-name";
+}
+/**
+ * Public surface {@link AttackSurfaceRegistry} exposes to workflows.
+ * Extracted so a DB-backed registry (atomic upsert-by-fingerprint) can stand
+ * in for the in-memory implementation behind {@link WorkflowSeams}
+ * `registries` — see `../workflows/seams.ts`.
+ */
+export interface AttackSurfaceRegistryOps {
+    readonly size: number;
+    getAssets(): readonly AssetRecord[];
+    isDuplicate(asset: AssetRecord): AssetDuplicateCheckResult;
+    register(asset: AssetRecord): Promise<AssetDuplicateCheckResult>;
+    unregister(asset: AssetRecord): Promise<void>;
+}
+/**
+ * Thread-safe, in-memory registry of known attack surface assets.
+ *
+ * Supports two dedup tiers:
+ *   1. **Exact URL** — same normalised URL + same asset type
+ *   2. **Exact name** — same normalised name + same asset type
+ *
+ * The registry is designed to be created once per session and shared
+ * across concurrent attack surface agents via `ToolContext`.
+ */
+export declare class AttackSurfaceRegistry implements AttackSurfaceRegistryOps {
+    private urlKeys;
+    private nameKeys;
+    private assets;
+    private mutex;
+    /** How many assets are tracked. */
+    get size(): number;
+    /** Return a snapshot of all tracked assets. */
+    getAssets(): readonly AssetRecord[];
+    /**
+     * Create a registry pre-loaded with assets from a directory.
+     * Reads every `.json` file, parses each as an asset record, and indexes it.
+     * Malformed files are silently skipped.
+     */
+    static fromDirectory(assetsPath: string): AttackSurfaceRegistry;
+    /**
+     * Create a registry pre-loaded with an array of assets (e.g. from Console DB).
+     */
+    static fromAssets(assets: AssetRecord[]): AttackSurfaceRegistry;
+    /**
+     * Check whether an asset is a duplicate of something already registered.
+     * Synchronous.
+     *
+     * Tier 1: exact URL + asset type
+     * Tier 2: exact name + asset type
+     */
+    isDuplicate(asset: AssetRecord): AssetDuplicateCheckResult;
+    /**
+     * Register a new asset in the registry.
+     *
+     * Thread-safe via an async mutex. Returns the dedup check result.
+     * If the asset is a duplicate it is **not** added to the registry.
+     */
+    register(asset: AssetRecord): Promise<AssetDuplicateCheckResult>;
+    /**
+     * Remove a previously-registered asset from all indexes.
+     *
+     * Rollback counterpart to {@link register}: call it when an asset was
+     * accepted by the registry but the caller failed to persist it.
+     */
+    unregister(asset: AssetRecord): Promise<void>;
+    private removeAsset;
+    private indexAsset;
+}

package/build/lib/core/findings/attackSurfaceRegistry.js

@@ -0,0 +1,6 @@
+import {
+  AttackSurfaceRegistry2
+} from "../../chunk-b8eq85d2.js";
+export {
+  AttackSurfaceRegistry2 as AttackSurfaceRegistry
+};

package/build/lib/core/findings/registry.d.ts

@@ -0,0 +1,177 @@
+import type { LanguageModelMiddleware } from "ai";
+import type { Finding } from "../agents/offSecAgent";
+import { type AIAuthConfig, type AIModel, type UsageRecorder } from "../ai";
+/**
+ * Classify a finding title into a canonical vulnerability class.
+ * Returns a kebab-case identifier (e.g. "sql-injection", "xss").
+ * Falls back to a normalised form of the title when no keyword matches.
+ */
+export declare function extractVulnClass(title: string): string;
+/**
+ * Content-aware vulnerability classification.
+ *
+ * Starts with the title-based class from {@link extractVulnClass}, then
+ * inspects the finding's description and evidence to correct common
+ * mis-classifications.  In particular, an `idor` classification is
+ * upgraded to `missing-authentication` when the content indicates that
+ * no authentication exists at all (IDOR requires auth to be present but
+ * authorisation to be insufficient).
+ */
+export declare function classifyFromContent(finding: Finding): string;
+/**
+ * Derive a normalised "stem" from a finding title by stripping
+ * endpoint-specific references (URLs, paths) and collapsing whitespace.
+ *
+ * Two findings that differ only by the affected endpoint will produce
+ * the same stem, enabling application-wide dedup.
+ */
+export declare function extractTitleStem(title: string): string;
+/**
+ * Normalise an endpoint URL for comparison:
+ * lowercase, strip trailing slash, strip query string and fragment.
+ */
+export declare function normalizeEndpoint(endpoint: string): string;
+/**
+ * Build the two fingerprint keys for a finding.
+ *
+ * - `exactKey`:   `<normalized_endpoint>||<vuln_class>` — precise per-endpoint dedup
+ * - `appWideKey`: `<title_stem>` — catches the same root issue across endpoints
+ *
+ * The app-wide key intentionally uses only the stem (no vuln class prefix).
+ * The stem already carries the semantic identity of the finding, and keeping
+ * it independent of the pattern list means unknown vuln types still get
+ * correct application-wide dedup.
+ */
+export declare function generateFingerprint(finding: Finding): {
+    exactKey: string;
+    appWideKey: string;
+};
+export interface DuplicateCheckResult {
+    duplicate: boolean;
+    matchedFinding?: Finding;
+    matchType?: "exact" | "application-wide" | "semantic";
+}
+export interface RootCauseGroup {
+    groupId: string;
+    findingIndices: number[];
+    rootCause: string;
+    /** The highest severity among the group's findings, applied to all of them. */
+    normalizedSeverity: Finding["severity"];
+    /** Index (into the snapshot passed to groupByRootCause) of the group's lead finding. */
+    leadFindingIndex: number;
+}
+export interface FindingsRegistryOptions {
+    /** AI model for Tier 3 semantic dedup. When omitted, Tier 3 is skipped. */
+    model?: AIModel;
+    /** Per-provider API key overrides for the model. */
+    authConfig?: AIAuthConfig;
+    /** Signal to cancel in-flight LLM calls (Tier 3 semantic dedup). */
+    abortSignal?: AbortSignal;
+    /** Session id — stamps the registry's LLM calls with session attribution. */
+    sessionId?: string;
+    /** Provider middleware applied to the registry's LLM calls. */
+    languageModelMiddleware?: LanguageModelMiddleware | LanguageModelMiddleware[];
+    /** Per-run usage recorder for the registry's LLM calls. */
+    usageRecorder?: UsageRecorder;
+}
+/**
+ * Public surface {@link FindingsRegistry} exposes to workflows. Extracted so
+ * a DB-backed registry (atomic upsert-by-fingerprint) can stand in for the
+ * in-memory implementation behind {@link WorkflowSeams} `registries` —
+ * see `../workflows/seams.ts`.
+ */
+export interface FindingsRegistryOps {
+    readonly size: number;
+    getFindings(): readonly Finding[];
+    isDuplicate(finding: Finding): DuplicateCheckResult;
+    register(finding: Finding): Promise<DuplicateCheckResult>;
+    unregister(finding: Finding): Promise<void>;
+    groupByRootCause(): Promise<RootCauseGroup[]>;
+}
+/**
+ * Thread-safe, in-memory registry of known findings.
+ *
+ * Supports three dedup tiers:
+ *   1. **Exact** — same normalised endpoint + same vuln class
+ *   2. **Application-wide** — same title stem (endpoint-stripped title)
+ *      (catches the same root vulnerability rediscovered on different endpoints)
+ *   3. **Semantic** — LLM comparison against existing findings
+ *      (catches differently-phrased duplicates that string matching misses)
+ *
+ * The registry is designed to be created once per session and shared
+ * across all concurrent pentest agents via `ToolContext`.
+ */
+export declare class FindingsRegistry implements FindingsRegistryOps {
+    private exactKeys;
+    private appWideKeys;
+    private findings;
+    private model?;
+    private authConfig?;
+    private abortSignal?;
+    private sessionId?;
+    private languageModelMiddleware?;
+    private usageRecorder?;
+    private mutex;
+    constructor(opts?: FindingsRegistryOptions);
+    /** How many findings are tracked. */
+    get size(): number;
+    /** Return a snapshot of all tracked findings. */
+    getFindings(): readonly Finding[];
+    /**
+     * Create a registry pre-loaded with findings from a directory.
+     * Reads every `.json` file, parses each as a `Finding`, and indexes it.
+     * Malformed files are silently skipped.
+     */
+    static fromDirectory(findingsPath: string, opts?: FindingsRegistryOptions): FindingsRegistry;
+    /**
+     * Create a registry pre-loaded with an array of findings (e.g. from Console).
+     */
+    static fromFindings(findings: Finding[], opts?: FindingsRegistryOptions): FindingsRegistry;
+    /**
+     * Check whether a finding is a duplicate of something already registered.
+     * Synchronous — only checks Tier 1 and Tier 2 (string-based).
+     *
+     * Tier 1: exact endpoint + vuln class
+     * Tier 2: title stem only (application-wide)
+     */
+    isDuplicate(finding: Finding): DuplicateCheckResult;
+    /**
+     * Register a new finding in the registry.
+     *
+     * Flow:
+     *   1. Tier 1+2 check inside the mutex (fast, deterministic)
+     *   2. If no match and a model is configured, Tier 3 LLM check
+     *      runs **outside** the mutex to avoid blocking other agents
+     *   3. Re-check Tier 1+2 inside the mutex before final accept
+     *      (guards against races during the LLM call)
+     *
+     * Returns the dedup check result. If the finding is a duplicate it is
+     * **not** added to the registry.
+     */
+    register(finding: Finding): Promise<DuplicateCheckResult>;
+    private semanticDedup;
+    /**
+     * Remove a previously-registered finding from all indexes.
+     *
+     * This is the rollback counterpart to {@link register}: call it when a
+     * finding was accepted by the registry but the caller failed to persist
+     * it (e.g. disk-write error).  Without rollback the finding would remain
+     * phantom-indexed — blocking future attempts to document the same issue.
+     *
+     * The operation is mutex-guarded so it is safe to call concurrently.
+     */
+    unregister(finding: Finding): Promise<void>;
+    /**
+     * Analyse all registered findings and group those that share a common
+     * root cause (e.g. same misconfiguration, one enables another).
+     *
+     * This is NOT deduplication — grouped findings are distinct issues that
+     * happen to stem from the same underlying weakness.
+     *
+     * Annotates findings in-place with `rootCauseGroup` and `relatedFindings`.
+     * Returns the groups array (empty when fewer than 2 findings or no model).
+     */
+    groupByRootCause(): Promise<RootCauseGroup[]>;
+    private removeFinding;
+    private indexFinding;
+}

package/build/lib/core/findings/registry.js

@@ -0,0 +1,21 @@
+import {
+  extractVulnClass2,
+  classifyFromContent2,
+  extractTitleStem2,
+  normalizeEndpoint2,
+  generateFingerprint2,
+  FindingsRegistry2
+} from "../../chunk-02awpt3c.js";
+import"../../chunk-3502z798.js";
+import"../../chunk-8vhr65w3.js";
+import"../../chunk-2njv7wz3.js";
+import"../../chunk-jdjagvgr.js";
+import"../../chunk-3w05jmk6.js";
+export {
+  FindingsRegistry2 as FindingsRegistry,
+  classifyFromContent2 as classifyFromContent,
+  extractTitleStem2 as extractTitleStem,
+  extractVulnClass2 as extractVulnClass,
+  generateFingerprint2 as generateFingerprint,
+  normalizeEndpoint2 as normalizeEndpoint
+};

package/build/lib/core/history.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Persistent command history stored at ~/.pensar/command-history.json
+ *
+ * Lazily loads from disk on first access. Writes are fire-and-forget
+ * so callers never block on I/O. The in-memory array is the source
+ * of truth after initial load; disk is kept in sync best-effort.
+ */
+/**
+ * Load history from disk (or return cached entries).
+ * Call once at startup; subsequent calls return immediately.
+ */
+export declare function load(): Promise<string[]>;
+/**
+ * Append an entry. Skips consecutive duplicates and redacts header
+ * secrets before persisting. Writes are fire-and-forget.
+ */
+export declare function push(entry: string): Promise<void>;
+export declare function redactSecretsInHistoryEntry(entry: string): string;
+/**
+ * Synchronous accessor — returns whatever is currently loaded.
+ * Returns an empty array if load() hasn't resolved yet.
+ */
+export declare function getEntries(): string[];

package/build/lib/core/hoonify.d.ts

@@ -0,0 +1,8 @@
+export declare const HOONIFY_BASE_URL = "https://api.hoonify.ai/v1";
+export interface HoonifyModel {
+    id: string;
+    contextLength: number;
+    maxOutputTokens: number;
+}
+export declare function loadHoonifyModels(apiKey: string, refresh?: boolean): Promise<HoonifyModel[]>;
+export declare function resolveHoonifyModel(id: string, models?: HoonifyModel[]): HoonifyModel;

package/build/lib/core/http/parse.d.ts

@@ -0,0 +1,50 @@
+export type HeaderEntry = {
+    readonly name: string;
+    readonly value: string;
+};
+export type ParseError = {
+    kind: "missing-colon";
+    input: string;
+} | {
+    kind: "empty-name";
+    input: string;
+} | {
+    kind: "name-has-whitespace";
+    input: string;
+} | {
+    kind: "invalid-name-char";
+    input: string;
+    position: number;
+    char: string;
+} | {
+    kind: "control-char-in-value";
+    input: string;
+    position: number;
+} | {
+    kind: "crlf-in-value";
+    input: string;
+    position: number;
+} | {
+    kind: "duplicate-key-in-bulk";
+    key: string;
+    firstAt: number;
+    secondAt: number;
+} | {
+    kind: "invalid-json";
+    input: string;
+    message: string;
+} | {
+    kind: "file-read-failed";
+    path: string;
+    message: string;
+};
+export type Result<T, E> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: E;
+};
+export declare function parseHeaderLine(input: string): Result<HeaderEntry, ParseError>;
+export declare function parseHeadersFromFile(filePath: string): Promise<Result<HeaderEntry[], ParseError[]>>;
+export declare function formatParseError(error: ParseError): string;

package/build/lib/core/http/redirects.d.ts

@@ -0,0 +1,23 @@
+import type { HeaderRecord } from "./types";
+export declare const MAX_TARGET_REDIRECTS = 20;
+export interface RedirectHeaderContext {
+    readonly redirectCount: number;
+    readonly bodyDropped: boolean;
+}
+export interface RedirectFetchResult {
+    readonly response: Response;
+    readonly redirectChain: string[];
+}
+export declare class TargetRedirectError extends TypeError {
+    readonly redirectChain: string[];
+    constructor(message: string, redirectChain: string[]);
+}
+export declare function redirectRequest<T>(status: number, method: string, body: T | undefined): {
+    method: string;
+    body: T | undefined;
+    bodyDropped: boolean;
+};
+export declare function isRedirectStatus(status: number): boolean;
+export declare function resolveRedirectUrl(currentUrl: string, location: string): string;
+export declare function sanitizeRedirectHeaders(headers: HeaderRecord, context: RedirectHeaderContext): HeaderRecord;
+export declare function fetchWithScopedRedirects(initialUrl: string, init: Omit<RequestInit, "headers">, headersForUrl: (url: string, context: RedirectHeaderContext) => HeaderRecord): Promise<RedirectFetchResult>;

package/build/lib/core/http/targetHeaders.d.ts

@@ -0,0 +1,30 @@
+import { type RedirectFetchResult } from "./redirects";
+import type { HeaderRecord } from "./types";
+export interface ResolverSession {
+    readonly targets?: ReadonlyArray<string>;
+    readonly config?: {
+        readonly headers?: HeaderRecord;
+        readonly scopeConstraints?: {
+            readonly allowedHosts?: ReadonlyArray<string>;
+        };
+        readonly authCredentials?: unknown;
+    };
+    readonly credentialManager?: {
+        listCredentialsWithHeaders?: () => ReadonlyArray<{
+            readonly tokens?: {
+                readonly customHeaders?: HeaderRecord;
+            };
+        }>;
+    };
+}
+export declare function resolveEffectiveHeaders(session: ResolverSession, url: string, requestOverrides?: HeaderRecord): HeaderRecord;
+export declare function stripBrowserManagedHeaders(headers: HeaderRecord | undefined): HeaderRecord | undefined;
+export declare function targetFetch(session: ResolverSession, url: string, init?: RequestInit): Promise<RedirectFetchResult>;
+export declare function shellQuote(value: string): string;
+export type ApplyShellStatus = "injected" | "no-headers" | "unknown-tool";
+export type ApplyShellResult = {
+    readonly command: string;
+    readonly status: ApplyShellStatus;
+    readonly tool: string | null;
+};
+export declare function applyHeadersToShellCommand(command: string, session: ResolverSession, commandHosts: ReadonlyArray<string>, platform?: "posix" | "windows"): ApplyShellResult;

package/build/lib/core/http/targetScope.d.ts

@@ -0,0 +1,12 @@
+export interface TargetScope {
+    readonly targets?: ReadonlyArray<string>;
+    readonly config?: {
+        readonly scopeConstraints?: {
+            readonly allowedHosts?: ReadonlyArray<string>;
+        };
+    };
+}
+export declare function getRegistrableDomain(hostname: string): string;
+export declare function getSessionAllowedHosts(scope: TargetScope): string[];
+export declare function isHostInScope(hostname: string, allowedHosts: ReadonlyArray<string>): boolean;
+export declare function isUrlInSessionScope(url: string, scope: TargetScope): boolean;

package/build/lib/core/http/types.d.ts

@@ -0,0 +1,11 @@
+export type HeaderRecord = Record<string, string>;
+/** Source layer of an effective header. Later layers win on collision. */
+export type Layer = "global" | "session" | "credential" | "request";
+export type EffectiveHeader = {
+    readonly name: string;
+    readonly value: string;
+    readonly source: Layer;
+};
+export declare function isSensitiveHeaderName(name: string): boolean;
+/** Mask sensitive values to `****<last4>` unless `showSecrets` is true. */
+export declare function renderHeaderValue(name: string, value: string, showSecrets: boolean): string;