@http-forge/core 0.3.3 → 0.4.1

package/dist/infrastructure/config/config.interface.d.ts

@@ -110,6 +110,36 @@ export interface ProxyConfig {
     /** List of hosts to bypass proxy */
     bypass?: string[];
 }
+/**
+ * Cloud secret provider configuration (used in SecretsConfig.providers)
+ */
+export interface SecretProviderEntry {
+    /** Provider type */
+    provider: 'aws' | 'azure' | 'gcp' | 'vault' | '1password' | 'doppler';
+    /** AWS region (aws only) */
+    region?: string;
+    /** Azure Key Vault URL (azure only) */
+    vaultUrl?: string;
+    /** GCP project ID (gcp only) */
+    projectId?: string;
+    /** Vault server address (vault only) */
+    address?: string;
+    /** Vault mount path (vault only, default "secret") */
+    mountPath?: string;
+    /** Vault namespace (vault only, Enterprise/HCP) */
+    namespace?: string;
+    /** 1Password vault name (1password only) */
+    vault?: string;
+    /** Doppler service token (doppler only; falls back to DOPPLER_TOKEN env var) */
+    serviceToken?: string;
+}
+/**
+ * Top-level secrets block in http-forge.config.json
+ * Configures named cloud secret providers for {{secret:alias/path}} tokens.
+ */
+export interface SecretsConfig {
+    providers: Record<string, SecretProviderEntry>;
+}
 /**
  * Main HTTP Forge configuration (http-forge.config.json)
  */
@@ -132,6 +162,8 @@ export interface HttpForgeConfig {
     mcp?: McpConfig;
     /** Proxy configuration (optional) */
     proxy?: ProxyConfig | null;
+    /** Cloud secret provider configuration (optional) */
+    secrets?: SecretsConfig;
 }
 /**
  * Configuration service interface

package/dist/infrastructure/environment/environment-config-service.d.ts

@@ -5,13 +5,14 @@
  * VS Code's workspaceState/globalState.
  */
 import type { IEnvironmentConfigService, ImportedEnvironment, LocalConfig, ResolvedEnvironment, SharedConfig } from '../../types/environment-config';
-import { IFileWatcherFactory, IKeyValueStore } from '../../types/platform';
+import { IFileWatcherFactory, IKeyValueStore, ISecretStore } from '../../types/platform';
 import { IConfigService } from '../config';
 export declare class EnvironmentConfigService implements IEnvironmentConfigService {
     private workspaceFolder;
     private workspaceStore;
     private configService;
     private fileWatcherFactory?;
+    private secretStore?;
     private environmentsPath;
     private sharedConfigPath;
     private localConfigPath;
@@ -27,12 +28,14 @@ export declare class EnvironmentConfigService implements IEnvironmentConfigServi
      */
     private localGlobalValues;
     private localEnvironmentValues;
+    /** In-memory cache of secret values fetched from SecretStorage — keyed by envName */
+    private secretValuesCache;
     /**
      * Callback invoked when environment files change on disk.
      * Set by the extension host to refresh tree views and panels.
      */
     onEnvironmentsChanged?: () => void;
-    constructor(workspaceFolder: string, workspaceStore: IKeyValueStore, configService: IConfigService, fileWatcherFactory?: IFileWatcherFactory | undefined);
+    constructor(workspaceFolder: string, workspaceStore: IKeyValueStore, configService: IConfigService, fileWatcherFactory?: IFileWatcherFactory | undefined, secretStore?: ISecretStore | undefined);
     private setupFileWatcher;
     dispose(): void;
     getWorkspaceFolder(): string;
@@ -53,9 +56,9 @@ export declare class EnvironmentConfigService implements IEnvironmentConfigServi
      * Persist current environment overrides to workspace state (fire-and-forget).
      */
     private persistEnvironmentOverrides;
-    setEnvironmentVariable(key: string, value: unknown): void;
-    deleteEnvironmentVariable(key: string): void;
-    clearEnvironmentVariables(): void;
+    setEnvironmentVariable(key: string, value: unknown, envName?: string): void;
+    deleteEnvironmentVariable(key: string, envName?: string): void;
+    clearEnvironmentVariables(envName?: string): void;
     /**
      * Reset all runtime environment overrides for the current environment.
      * Equivalent to Postman's "Reset All" — reverts Current Values to Initial Values.
@@ -70,19 +73,28 @@ export declare class EnvironmentConfigService implements IEnvironmentConfigServi
     getGlobalVariableLocals(): Record<string, string>;
     deleteGlobalVariable(key: string): void;
     clearGlobalVariables(): void;
-    /** @deprecated Use setEnvironmentVariable instead */
-    setSessionVariable(key: string, value: unknown): Promise<void>;
-    /** @deprecated Use getEnvironmentVariableLocal instead */
-    getSessionVariable(key: string): string | undefined;
-    /** @deprecated Use getEnvironmentVariableLocals instead */
-    getSessionVariables(): Record<string, string>;
-    /** @deprecated Use deleteEnvironmentVariable instead */
-    deleteSessionVariable(key: string): Promise<void>;
-    /** @deprecated Use clearEnvironmentVariables instead */
-    clearSessionVariables(): Promise<void>;
-    /** @deprecated Use getEnvironmentVariableLocal instead */
-    hasSessionVariable(key: string): boolean;
     getResolvedEnvironment(envName?: string): ResolvedEnvironment | null;
+    /**
+     * Retrieve a secret variable value from SecretStorage.
+     * Returns undefined when no SecretStorage is available (e.g. CLI context).
+     */
+    getSecretVariable(envName: string, key: string): Promise<string | undefined>;
+    /**
+     * Store a secret variable value in SecretStorage.
+     * No-op when no SecretStorage is available (e.g. CLI context).
+     */
+    setSecretVariable(envName: string, key: string, value: string): Promise<void>;
+    /**
+     * Delete a secret variable from SecretStorage.
+     * No-op when no SecretStorage is available (e.g. CLI context).
+     */
+    deleteSecretVariable(envName: string, key: string): Promise<void>;
+    /**
+     * Pre-load all secret values for an environment into the in-memory cache.
+     * Call this when switching environments or on extension activation so that
+     * the synchronous getResolvedEnvironment() always has secret values available.
+     */
+    loadSecretVariables(envName?: string): Promise<void>;
     resolveVariables(input: string, envName?: string): string;
     exportEnvironmentsToFolder(outDir: string, mergeGlobals?: boolean): void;
     resolveVariablesWithExtra(input: string, extraVariables: Record<string, string>, envName?: string): string;

package/dist/infrastructure/environment/environment-file-loader.d.ts

@@ -28,6 +28,11 @@ export interface EnvironmentEntry {
     description?: string;
     requiresConfirmation?: boolean;
     variables: Record<string, string>;
+    /**
+     * Names of variables whose values are stored in SecretStorage, not in the JSON file.
+     * These names are persisted in the JSON; the values are never written to disk.
+     */
+    secretVariables?: string[];
 }
 /**
  * Determine whether a filename is a system/meta file (not an environment file).

package/dist/infrastructure/execution/request-executor.d.ts

@@ -4,11 +4,11 @@
  * Single Responsibility: Orchestrate the complete request execution flow
  * Facade Pattern: Provides simplified interface to complex subsystem
  */
+import { IHttpClient } from '../../types/platform';
+import { HttpRequest, HttpResponse, RequestOverrides, ScriptResult, UnifiedCollection, UnifiedRequest } from '../../types/types';
 import { IForgeEnv } from '../environment/forge-env';
 import { IRequestPreprocessor } from '../http/request-preprocessor';
 import { IScriptExecutor } from '../script/interfaces';
-import { IHttpClient } from '../../types/platform';
-import { HttpRequest, HttpResponse, RequestOverrides, ScriptResult, UnifiedCollection, UnifiedRequest } from '../../types/types';
 /**
  * Options for request execution
  */
@@ -25,8 +25,6 @@ export interface ExecuteOptions {
     additionalVariables?: Record<string, string>;
     /** Timeout override */
     timeout?: number;
-    /** Callback when scripts modify session variables */
-    onSessionChange?: (action: 'set' | 'unset' | 'clear', key?: string, value?: string) => void;
     /** Callback when scripts modify environment variables */
     onEnvironmentChange?: (action: 'set' | 'unset' | 'clear', key?: string, value?: string) => void;
 }

package/dist/infrastructure/execution/request-preparer.d.ts

@@ -15,6 +15,7 @@ import { ExecutionRequest, PreparedRequest } from '../../types/types';
 import { IOAuth2TokenManager } from '../auth/interfaces';
 import { IHttpRequestService } from '../http/interfaces';
 import { IRequestPreprocessor } from '../http/request-preprocessor';
+import { SecretResolverRegistry } from '../secrets/secret-resolver-registry';
 import { IRequestPreparer } from './request-preparer-interfaces';
 /**
  * RequestPreparer implementation
@@ -28,7 +29,8 @@ export declare class RequestPreparer implements IRequestPreparer {
     private readonly preprocessor;
     private readonly tokenManager?;
     private readonly appInfo?;
-    constructor(envConfigService: IEnvironmentConfigService, httpService: IHttpRequestService, preprocessor: IRequestPreprocessor, tokenManager?: IOAuth2TokenManager | undefined, appInfo?: IApplicationInfo | undefined);
+    private readonly secretRegistry?;
+    constructor(envConfigService: IEnvironmentConfigService, httpService: IHttpRequestService, preprocessor: IRequestPreprocessor, tokenManager?: IOAuth2TokenManager | undefined, appInfo?: IApplicationInfo | undefined, secretRegistry?: SecretResolverRegistry | undefined);
     prepareRequest(input: ExecutionRequest, environment: string, resolvedEnv: ResolvedEnvironment, extraVariables?: Record<string, string>): Promise<PreparedRequest>;
     private applyOAuth2;
     private applyApiKey;

package/dist/infrastructure/script/interfaces.d.ts

@@ -7,8 +7,8 @@
  * Dependency Inversion: Define abstractions for request execution components
  * Interface Segregation: Each interface has a focused purpose
  */
-import { Cookie } from '../cookie/interfaces';
 import { PreparedRequest, RequestAuth, RequestBody, RequestScripts, RequestSettings, ScriptInfo, TestAssertion } from '../../types/types';
+import { Cookie } from '../cookie/interfaces';
 export type { Cookie, ScriptInfo };
 /**
  * Cookie Jar Interface
@@ -69,7 +69,6 @@ export interface CommonScriptContext {
     iteration?: number;
     iterationCount?: number;
     iterationData?: Record<string, any>;
-    onSessionChange?: (action: 'set' | 'unset' | 'clear', key?: string, value?: string) => void;
     onEnvironmentChange?: (action: 'set' | 'unset' | 'clear', key?: string, value?: string) => void;
 }
 /**

package/dist/infrastructure/script/script-executor.d.ts

@@ -9,6 +9,7 @@
  * It configures the VM sandbox and delegates session management to RequestScriptSession.
  */
 import { IHttpRequestService } from '../http/interfaces';
+import { SecretResolverRegistry } from '../secrets/secret-resolver-registry';
 import { IRequestScriptSession, IScriptExecutor, PreRequestScriptContext } from './interfaces';
 /**
  * Script Executor Implementation
@@ -20,8 +21,9 @@ import { IRequestScriptSession, IScriptExecutor, PreRequestScriptContext } from
  */
 export declare class ScriptExecutor implements IScriptExecutor {
     private readonly httpService?;
+    private readonly secretRegistry?;
     private readonly moduleLoader;
-    constructor(httpService?: IHttpRequestService | undefined, modulePaths?: string[]);
+    constructor(httpService?: IHttpRequestService | undefined, modulePaths?: string[], secretRegistry?: SecretResolverRegistry | undefined);
     /**
      * Create a request execution session
      * Factory method implementing IScriptExecutor
@@ -60,6 +62,13 @@ export declare class ScriptExecutor implements IScriptExecutor {
      * Create environment variable scope with change callbacks
      */
     private createEnvironmentScope;
+    /**
+     * Create the Postman-compatible pm.vault namespace.
+     * Reads are backed by HTTP Forge's secret provider system using the same
+     * {{secret:provider/path}} resolution. Writes are not supported (read-only),
+     * and resolved values are never persisted to console/report output here.
+     */
+    private createVault;
     /**
      * Create sendRequest function using httpService
      */

package/dist/infrastructure/script/script-factories.d.ts

@@ -5,6 +5,15 @@
  * Open/Closed: New factory methods can be added without modifying existing ones
  */
 import { ResponseContext } from './interfaces';
+/**
+ * Minimal, dependency-free JSON Schema validator.
+ *
+ * Supports the common subset used in API tests (draft-04 style):
+ * `type`, `properties`, `required`, `items`, `enum`, `additionalProperties`
+ * (boolean), `minimum`/`maximum`, `minLength`/`maxLength`, and `pattern`.
+ * Returns a list of human-readable error strings (empty when valid).
+ */
+export declare function validateJsonSchema(data: any, schema: any, path?: string): string[];
 /**
  * Response object interface for script context
  */
@@ -36,6 +45,7 @@ export interface ResponseAssertions {
         header(headerName: string, expectedValue?: string): void;
         body(expectedBody?: string): void;
         jsonBody(expectedJson?: any): void;
+        jsonSchema(schema: any): void;
     };
     be: {
         readonly ok: any;
@@ -62,12 +72,27 @@ export interface ExpectChain {
     be: ExpectChain;
     have: ExpectChain;
     deep: ExpectChain;
+    and: ExpectChain;
+    that: ExpectChain;
+    which: ExpectChain;
+    is: ExpectChain;
+    been: ExpectChain;
+    has: ExpectChain;
+    with: ExpectChain;
+    at: ExpectChain;
+    of: ExpectChain;
+    same: ExpectChain;
+    but: ExpectChain;
+    does: ExpectChain;
+    still: ExpectChain;
+    also: ExpectChain;
     equal(expected: any): ExpectChain;
     eql(expected: any): ExpectChain;
     property(name: string, value?: any): ExpectChain;
     ok: ExpectChain;
     exist: ExpectChain;
     include(value: any): ExpectChain;
+    contain(value: any): ExpectChain;
     oneOf(values: any[]): ExpectChain;
     match(pattern: RegExp): ExpectChain;
     above(num: number): ExpectChain;

package/dist/infrastructure/secrets/aws-secret-resolver.d.ts

@@ -0,0 +1,18 @@
+/**
+ * AWS Secrets Manager resolver
+ *
+ * Uses the AWS SDK v3 credential chain — no credentials are stored in HTTP Forge config.
+ * Order: env vars → ~/.aws/credentials → IAM instance role → ECS task role
+ *
+ * Token syntax: {{secret:aws/<secretId>}}
+ * e.g.          {{secret:aws/myapp/prod/db-password}}
+ *               {{secret:aws/myapp/prod/api-key#field}}  (JSON secret field)
+ */
+import type { AwsSecretsConfig, ISecretResolver } from '../../types/secret-resolver';
+export declare class AwsSecretResolver implements ISecretResolver {
+    readonly providerName = "aws";
+    private readonly region;
+    private readonly moduleRequire;
+    constructor(config: AwsSecretsConfig, moduleRequire?: (name: string) => any);
+    resolve(path: string): Promise<string | undefined>;
+}

package/dist/infrastructure/secrets/azure-keyvault-resolver.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Azure Key Vault resolver
+ *
+ * Uses DefaultAzureCredential — no credentials stored in HTTP Forge config.
+ * Order: env vars (AZURE_*) → managed identity → Azure CLI login → VS Code login
+ *
+ * Token syntax: {{secret:azure/<secretName>}}
+ * e.g.          {{secret:azure/my-api-key}}
+ *               {{secret:azure/my-api-key/1.0}}  (specific version)
+ *
+ * Config requires vaultUrl, e.g. "https://myvault.vault.azure.net"
+ */
+import type { AzureKeyVaultConfig, ISecretResolver } from '../../types/secret-resolver';
+export declare class AzureKeyVaultResolver implements ISecretResolver {
+    readonly providerName = "azure";
+    private readonly vaultUrl;
+    private readonly moduleRequire;
+    constructor(config: AzureKeyVaultConfig, moduleRequire?: (name: string) => any);
+    resolve(path: string): Promise<string | undefined>;
+}

package/dist/infrastructure/secrets/doppler-resolver.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Doppler secret resolver
+ *
+ * Uses the Doppler REST API — no SDK required, just a service token.
+ * Credentials: DOPPLER_TOKEN env var (or serviceToken in config for per-project override)
+ *
+ * Token syntax: {{secret:doppler/<secretName>}}
+ * e.g.          {{secret:doppler/API_KEY}}
+ *               {{secret:doppler/DATABASE_URL}}
+ *
+ * The Doppler project/config are baked into the service token itself —
+ * no project or config fields needed in http-forge.config.json.
+ *
+ * Prerequisites: none (uses Node.js built-in https)
+ */
+import type { DopplerConfig, ISecretResolver } from '../../types/secret-resolver';
+export declare class DopplerResolver implements ISecretResolver {
+    readonly providerName = "doppler";
+    private readonly token;
+    constructor(config: DopplerConfig);
+    resolve(path: string): Promise<string | undefined>;
+}

package/dist/infrastructure/secrets/gcp-secret-resolver.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Google Cloud Secret Manager resolver
+ *
+ * Uses Application Default Credentials — no credentials stored in HTTP Forge config.
+ * Order: GOOGLE_APPLICATION_CREDENTIALS env var → gcloud CLI login → Workload Identity (GKE)
+ *        → Metadata server (Cloud Run, Compute Engine)
+ *
+ * Token syntax: {{secret:gcp/<secretName>}}
+ *               {{secret:gcp/<secretName>/versions/<version>}}  (specific version, default: latest)
+ *
+ * Config: { "provider": "gcp", "projectId": "my-project" }
+ * projectId falls back to GOOGLE_CLOUD_PROJECT / GCLOUD_PROJECT env vars.
+ */
+import type { GcpSecretsConfig, ISecretResolver } from '../../types/secret-resolver';
+export declare class GcpSecretResolver implements ISecretResolver {
+    readonly providerName = "gcp";
+    private readonly projectId;
+    private readonly moduleRequire;
+    constructor(config: GcpSecretsConfig, moduleRequire?: (name: string) => any);
+    resolve(path: string): Promise<string | undefined>;
+}

package/dist/infrastructure/secrets/hashicorp-vault-resolver.d.ts

@@ -0,0 +1,25 @@
+/**
+ * HashiCorp Vault resolver
+ *
+ * Credentials are NEVER stored in HTTP Forge config.
+ * Authentication uses:
+ *   VAULT_TOKEN     env var (token auth)
+ *   VAULT_ADDR      env var (server address, overrides config)
+ *   VAULT_NAMESPACE env var (Enterprise/HCP namespace, overridden by config.namespace)
+ *
+ * Token syntax: {{secret:vault/<mountPath>/<secretPath>#<field>}}
+ * e.g.          {{secret:vault/secret/myapp/prod#db_password}}
+ *               {{secret:vault/kv/myapp/config#api_key}}
+ *
+ * The path format after the provider prefix: <mount>/<path>#<field>
+ * If no field is specified and the secret has a single key "value", that is returned.
+ */
+import type { HashiCorpVaultConfig, ISecretResolver } from '../../types/secret-resolver';
+export declare class HashiCorpVaultResolver implements ISecretResolver {
+    readonly providerName = "vault";
+    private readonly address;
+    private readonly mountPath;
+    private readonly namespace;
+    constructor(config: HashiCorpVaultConfig);
+    resolve(path: string): Promise<string | undefined>;
+}

package/dist/infrastructure/secrets/onepassword-resolver.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 1Password Connect / Service Account resolver
+ *
+ * Credentials are NEVER stored in HTTP Forge config.
+ * Authentication uses:
+ *   OP_SERVICE_ACCOUNT_TOKEN  env var  (1Password Service Account — recommended for CI)
+ *   OP_CONNECT_TOKEN + OP_CONNECT_HOST env vars  (1Password Connect Server)
+ *
+ * Token syntax: {{secret:1password/<vault>/<item>/<field>}}
+ * e.g.          {{secret:1password/MyVault/MyApp/api_key}}
+ *               {{secret:1password/Shared/prod-db/password}}
+ *
+ * If `vault` is specified in the provider config, the token path may omit it:
+ *   {{secret:1password/<item>/<field>}}
+ *
+ * Uses the 1Password CLI (`op`) via child_process if SDK is unavailable.
+ */
+import type { ISecretResolver, OnePasswordConfig } from '../../types/secret-resolver';
+export declare class OnePasswordResolver implements ISecretResolver {
+    readonly providerName = "1password";
+    private readonly defaultVault;
+    constructor(config: OnePasswordConfig);
+    resolve(path: string): Promise<string | undefined>;
+    private tryResolveSdk;
+    private resolveViaCli;
+}

package/dist/infrastructure/secrets/secret-resolver-registry.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Secret Resolver Registry — Phase 3
+ *
+ * Builds and caches ISecretResolver instances from config, and provides
+ * async pre-resolution of {{secret:provider/path}} tokens in template strings.
+ *
+ * Design:
+ * - Registry is created once at startup from IConfigService
+ * - resolveSecretTokens() is called BEFORE variable interpolation per-request
+ * - Resolved values are injected as extraVariables so the sync VariableResolver
+ *   picks them up transparently
+ * - Results are cached within a single request lifetime to avoid redundant API calls
+ */
+import type { IConfigService } from '../config/config.interface';
+export declare class SecretResolverRegistry {
+    private readonly resolvers;
+    /**
+     * Require function rooted at the user's project (via config `scripts.modulePaths`),
+     * so optional cloud SDKs resolve from the same place users install custom script
+     * modules — not from the extension's own bundle.
+     */
+    private readonly moduleRequire;
+    constructor(configService?: IConfigService);
+    /**
+     * Scan a string (or recursively, any object) for {{secret:alias/path}} tokens
+     * and resolve them all in parallel.
+     *
+     * Returns a flat map of  "secret:alias/path" → plaintext value
+     * suitable for injection as extraVariables into VariableResolver.
+     */
+    resolveSecretTokens(input: any, cache?: Map<string, string>): Promise<Record<string, string>>;
+    /** Whether any providers are configured */
+    get hasProviders(): boolean;
+    private collectTokens;
+    private createResolver;
+    /**
+     * Build a `require` function rooted at the user's project, so optional cloud SDKs
+     * resolve from the same `node_modules` where users install custom script modules
+     * (via config `scripts.modulePaths`). Falls back to the default `require` so the
+     * CLI (which lists SDKs in optionalDependencies) still works without modulePaths.
+     */
+    private buildModuleRequire;
+}

package/dist/infrastructure/test-suite/html-report-generator.d.ts

@@ -5,6 +5,13 @@
  * generates a self-contained single-file HTML report (no external dependencies).
  *
  * Output: {basePath}/{suiteId}/{runId}/report.html
+ *
+ * Each request entry expands to show:
+ *   - Full request URL, method, headers, body
+ *   - Response status, headers, body (pretty-printed)
+ *   - All test assertions (pass/fail + messages)
+ *   - Console output (if any)
+ *   - Error message (if any)
  */
 export declare class HtmlReportGenerator {
     private readonly basePath;
@@ -15,6 +22,22 @@ export declare class HtmlReportGenerator {
      */
     generate(suiteId: string, runId: string): Promise<string>;
     private loadAllSummaries;
-    private loadFailedDetails;
+    /** Load every result file for every request (pass + fail). */
+    private loadAllDetails;
+    /**
+     * Group summaries by iteration, then by (collection + folder path),
+     * preserving execution order within each tier.
+     */
+    private groupByIterCollectionFolder;
+    /**
+     * Build a combined group header label like:
+     *   "01 - MyCollection: Auth/Login"
+     * Collection or folder parts are omitted when empty; falls back to "(root)".
+     */
+    private groupLabel;
+    /** Render the detail accordions grouped by iteration → (collection + folder). */
+    private renderGroupedDetails;
+    /** Render the timeline table rows grouped by iteration → (collection + folder). */
+    private renderGroupedTimeline;
     private buildHtml;
 }

package/dist/infrastructure/test-suite/result-storage-service.d.ts

@@ -45,7 +45,7 @@ export declare class ResultStorageService implements IResultStorageService {
      * Finalize run
      * @returns path to the generated HTML report, or null if generation failed
      */
-    finalizeRun(status?: 'completed' | 'aborted' | 'error'): Promise<string | null>;
+    finalizeRun(status?: 'completed' | 'aborted' | 'error', generateHtmlReport?: boolean): Promise<string | null>;
     getCurrentStats(): {
         stats: RunStats;
         requestStats: Record<string, RequestStats>;

package/dist/infrastructure/test-suite/result-storage.d.ts

@@ -39,6 +39,10 @@ export interface ResultSummary {
     r: string;
     /** Error message if failed (e) - null if passed */
     e: string | null;
+    /** Folder path (fp) - slash-separated; omitted/empty for root-level requests */
+    fp?: string;
+    /** Collection name (cn) - omitted/empty when unknown */
+    cn?: string;
 }
 /**
  * Build result filename from summary components
@@ -169,6 +173,10 @@ export interface FullResultDetails {
     method: string;
     /** Full URL */
     url: string;
+    /** Folder path within the collection (slash-separated; empty for root) */
+    folderPath?: string;
+    /** Name of the collection this request belongs to */
+    collectionName?: string;
     /** HTTP status code */
     status: number;
     /** HTTP status text */
@@ -181,13 +189,27 @@ export interface FullResultDetails {
     timestamp: number;
     /** Request details */
     request: {
+        method: string;
+        url: string;
         headers: Record<string, string>;
-        body: any;
+        query: Record<string, string>;
+        params: Record<string, string>;
+        body: {
+            type: string;
+            format?: string;
+            content: any;
+        };
     };
     /** Response details */
     response: {
         headers: Record<string, string | string[]>;
         body: any;
+        time?: number;
+        size?: number;
+        cookies?: Array<{
+            name?: string;
+            value?: string;
+        }>;
     };
     /** Test assertions */
     assertions: Array<{
@@ -197,6 +219,23 @@ export interface FullResultDetails {
     }>;
     /** Error message */
     error: string | null;
+    /** Console output produced while running the request */
+    consoleOutput?: string[];
+    /** Variables modified by pre/post scripts */
+    modifiedVariables?: Record<string, string>;
+    /** Environment variables modified by scripts */
+    modifiedEnvironmentVariables?: Record<string, string>;
+    /** Collection variables modified by scripts */
+    modifiedCollectionVariables?: Record<string, string>;
+    /** Session variables modified by scripts */
+    modifiedSessionVariables?: Record<string, string>;
+    /** pm.execution.setNextRequest() value */
+    nextRequest?: string | null;
+    /** pm.visualizer.set() payload */
+    visualizerData?: {
+        template: string;
+        data?: any;
+    };
 }
 /**
  * Index page containing summaries
@@ -248,9 +287,12 @@ export interface IResultStorageService {
     saveResult(iteration: number, result: ExecutionResult): Promise<ResultSummary>;
     /**
      * Finalize run
-     * @returns path to the generated HTML report, or null if generation failed
+     * @param status final run status
+     * @param generateHtmlReport when false, the run is persisted (manifest + results)
+     *        but the HTML report is not generated; returns null in that case
+     * @returns path to the generated HTML report, or null if not generated / generation failed
      */
-    finalizeRun(status: 'completed' | 'aborted' | 'error'): Promise<string | null>;
+    finalizeRun(status: 'completed' | 'aborted' | 'error', generateHtmlReport?: boolean): Promise<string | null>;
     /**
      * Get current run stats
      */

package/dist/types/environment-config.d.ts

@@ -11,6 +11,11 @@ export interface EnvironmentConfig {
     description?: string;
     requiresConfirmation?: boolean;
     variables?: Record<string, string>;
+    /**
+     * Names of variables whose values are stored in SecretStorage rather than the JSON file.
+     * The JSON file stores the variable name only; the value is fetched at resolution time.
+     */
+    secretVariables?: string[];
 }
 /**
  * Shared configuration file structure
@@ -95,18 +100,14 @@ export interface IVariableResolver {
  * Variable management operations (for scripts)
  */
 export interface IVariableManager {
-    setEnvironmentVariable(key: string, value: unknown): void;
-    deleteEnvironmentVariable(key: string): void;
-    clearEnvironmentVariables(): void;
+    setEnvironmentVariable(key: string, value: unknown, envName?: string): void;
+    deleteEnvironmentVariable(key: string, envName?: string): void;
+    clearEnvironmentVariables(envName?: string): void;
     getEnvironmentVariableLocals(): Record<string, string>;
     setGlobalVariable(key: string, value: unknown): void;
     getGlobalVariable(key: string): string | undefined;
     deleteGlobalVariable(key: string): void;
     clearGlobalVariables(): void;
-    setSessionVariable(key: string, value: unknown): void;
-    deleteSessionVariable(key: string): Promise<void>;
-    clearSessionVariables(): Promise<void>;
-    getSessionVariables(): Record<string, string>;
     getGlobalVariables(): Record<string, string>;
 }
 /**
@@ -115,6 +116,14 @@ export interface IVariableManager {
 export interface IEnvironmentConfigService extends IEnvironmentConfigReader, IEnvironmentConfigWriter, IEnvironmentSelector, IVariableResolver, IVariableManager {
     loadConfigs(): void;
     exportEnvironmentsToFolder(outDir: string, mergeGlobals?: boolean): void;
+    /** Read a single secret variable from SecretStorage. */
+    getSecretVariable(envName: string, key: string): Promise<string | undefined>;
+    /** Store a secret variable value in SecretStorage. */
+    setSecretVariable(envName: string, key: string, value: string): Promise<void>;
+    /** Delete a secret variable from SecretStorage. */
+    deleteSecretVariable(envName: string, key: string): Promise<void>;
+    /** Load all secrets for an environment (or current) into cache. */
+    loadSecretVariables(envName?: string): Promise<void>;
 }
 /**
  * Interface for storing and retrieving environment variables