@http-forge/core 0.1.0 → 0.2.0

package/dist/collection/json-collection-loader.d.ts

@@ -0,0 +1,95 @@
+/**
+ * JSON Collection Loader
+ *
+ * Loads collections from single JSON files (legacy format)
+ * Each collection is stored as a single .json file
+ *
+ * For JSON format, all item-level operations fall back to saving the entire collection
+ * since everything is in one file anyway.
+ */
+import type { Collection, CollectionItem, RequestScripts } from './collection-service-interfaces';
+import type { CollectionMetadata, ICollectionStore } from './collection-store';
+/**
+ * Loads collections from JSON files
+ * Format: collections/{collection-id}.json
+ */
+export declare class JsonCollectionLoader implements ICollectionStore {
+    private collectionsDir;
+    private cache;
+    constructor(collectionsDir: string);
+    /**
+     * Ensure collections directory exists
+     */
+    private ensureDirectory;
+    /**
+     * Load all collections from disk
+     */
+    loadAll(): Collection[];
+    /**
+     * Load a single collection by ID
+     */
+    load(id: string): Collection | undefined;
+    /**
+     * Save a collection
+     */
+    save(collection: Collection): Promise<void>;
+    /**
+     * Delete a collection
+     */
+    delete(id: string): Promise<boolean>;
+    /**
+     * Check if a collection exists
+     */
+    exists(id: string): boolean;
+    /**
+     * Get the file path for a collection
+     */
+    getCollectionPath(id: string): string;
+    /**
+     * Create a new collection
+     */
+    create(name: string, id?: string): Promise<Collection>;
+    /**
+     * Save scripts for a specific item
+     * In JSON format, scripts are embedded in the collection JSON
+     */
+    saveScripts(collectionId: string, itemId: string, scripts: RequestScripts): Promise<void>;
+    /**
+     * Load scripts for a specific item
+     */
+    loadScripts(collectionId: string, itemId: string): RequestScripts | undefined;
+    /**
+     * Update collection metadata
+     */
+    updateCollectionMetadata(collectionId: string, updates: Partial<CollectionMetadata>): Promise<void>;
+    /**
+     * Save/update a single item
+     * For JSON format: saves entire collection
+     */
+    saveItem(collectionId: string, item: CollectionItem, parentId?: string): Promise<void>;
+    /**
+     * Delete a single item
+     */
+    deleteItem(collectionId: string, itemId: string): Promise<boolean>;
+    /**
+     * Update a single item
+     */
+    updateItem(collectionId: string, itemId: string, updates: Partial<CollectionItem>): Promise<boolean>;
+    /**
+     * Move an item to a new parent
+     */
+    moveItem(collectionId: string, itemId: string, newParentId?: string): Promise<boolean>;
+    /**
+     * Reorder items within a parent (collection or folder)
+     * For JSON format, just reorder the items array and save
+     */
+    reorderItems(collectionId: string, parentId: string | undefined, orderedItemIds: string[]): Promise<boolean>;
+    /**
+     * Find an item by ID in the collection tree
+     */
+    private findItemById;
+    /**
+     * Delete an item by ID from the collection tree
+     */
+    private deleteItemById;
+}

package/dist/{services → collection}/parser-registry.d.ts

@@ -4,7 +4,7 @@
  * Open/Closed Principle: New parsers can be added without modifying existing code
  * Single Responsibility: Manage collection parser registration and lookup
  */
-import { ICollectionParser } from '../interfaces';
+import { ICollectionParser } from './interfaces';
 /**
  * Registry for collection parsers
  * Allows registering parsers for different collection formats
@@ -46,4 +46,3 @@ export declare class ParserRegistry {
      */
     clear(): void;
 }
-//# sourceMappingURL=parser-registry.d.ts.map

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

@@ -0,0 +1,79 @@
+/**
+ * HTTP Forge Configuration Service
+ *
+ * Single Responsibility: Manages loading and accessing configuration
+ * from http-forge.config.json
+ *
+ * Platform-agnostic — uses IFileWatcherFactory and INotificationService
+ * instead of VS Code APIs.
+ */
+import { IFileWatcherFactory, INotificationService } from '../types/platform';
+import type { EnvironmentsConfig, HttpForgeConfig, IConfigService, ProxyConfig, RequestConfig, RunnerConfig, ScriptsConfig, StorageConfig } from './config.interface';
+/**
+ * Configuration Service Implementation
+ *
+ * Loads configuration from http-forge.config.json in workspace root.
+ * Falls back to default values for missing fields.
+ */
+export declare class ConfigService implements IConfigService {
+    private workspacePath;
+    private fileWatcherFactory?;
+    private notifications?;
+    private config;
+    private configPath;
+    private fileWatcher?;
+    constructor(workspacePath: string, fileWatcherFactory?: IFileWatcherFactory | undefined, notifications?: INotificationService | undefined);
+    /**
+     * Load configuration from file, merging with defaults
+     */
+    private loadConfig;
+    /**
+     * Merge user configuration with defaults
+     */
+    private mergeWithDefaults;
+    /**
+     * Setup file watcher for configuration changes
+     */
+    private setupFileWatcher;
+    getConfig(): HttpForgeConfig;
+    getStorageConfig(): StorageConfig;
+    getRequestConfig(): RequestConfig;
+    getScriptsConfig(): ScriptsConfig;
+    getRunnerConfig(): RunnerConfig;
+    getEnvironmentsConfig(): EnvironmentsConfig;
+    /**
+     * Path where REST-Client export files should be saved. The returned
+     * string is an absolute path, resolved against the workspace when a
+     * relative value is configured.
+     */
+    getRestClientExportPath(): string;
+    /**
+     * Whether to merge global variables into each environment export.
+     */
+    getRestClientMergeGlobals(): boolean;
+    getProxyConfig(): ProxyConfig | null;
+    /**
+     * Resolve a path relative to workspace
+     */
+    private resolvePath;
+    getRootPath(): string;
+    getCollectionsPath(): string;
+    getEnvironmentsPath(): string;
+    getFlowsPath(): string;
+    getHistoryPath(): string;
+    getResultsPath(): string;
+    getSuitesPath(): string;
+    getModulePaths(): string[];
+    getWorkspacePath(): string;
+    reload(): void;
+    configExists(): boolean;
+    createDefaultConfig(): Promise<void>;
+    /**
+     * Create sample environment files
+     */
+    private createSampleEnvironments;
+    /**
+     * Dispose resources
+     */
+    dispose(): void;
+}

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

@@ -0,0 +1,140 @@
+/**
+ * HTTP Forge Configuration Interfaces
+ *
+ * Defines the structure of http-forge.config.json
+ */
+/**
+ * Storage configuration
+ */
+export interface StorageConfig {
+    /** Storage format: 'folder' for directory structure, 'json' for single files */
+    format: 'folder' | 'json';
+    /** Root directory for HTTP Forge data (relative to workspace) */
+    root: string;
+    /** Directory for request history (relative to workspace, typically gitignored) */
+    history: string;
+    /** Directory for test results (relative to workspace, typically gitignored) */
+    results: string;
+}
+/**
+ * Request configuration
+ */
+export interface RequestConfig {
+    /** Request timeout in milliseconds */
+    timeout: number;
+    /** Whether to automatically follow redirects */
+    followRedirects: boolean;
+    /** Maximum number of redirects to follow */
+    maxRedirects: number;
+    /** Whether to verify SSL certificates */
+    strictSSL: boolean;
+}
+/**
+ * Script configuration
+ */
+export interface ScriptsConfig {
+    /** Paths to search for importable modules (relative to workspace) */
+    modulePaths: string[];
+}
+/**
+ * Runner configuration
+ */
+export interface RunnerConfig {
+    /** Number of days to retain test results */
+    resultsRetentionDays: number;
+    /** Number of result summaries per index page file */
+    indexPageSize: number;
+    /** Maximum number of recent errors to track */
+    recentErrorsLimit: number;
+}
+/**
+ * Environments configuration
+ */
+export interface EnvironmentsConfig {
+    /** Default environment to use */
+    default: string;
+}
+/**
+ * REST-Client export configuration
+ */
+export interface RestClientExportConfig {
+    /** Output path for exported REST-Client files */
+    path?: string;
+    /** When exporting environments, merge global variables into each environment file */
+    mergeGlobals?: boolean;
+}
+/**
+ * Proxy configuration
+ */
+export interface ProxyConfig {
+    /** HTTP proxy URL */
+    http?: string;
+    /** HTTPS proxy URL */
+    https?: string;
+    /** List of hosts to bypass proxy */
+    bypass?: string[];
+}
+/**
+ * Main HTTP Forge configuration (http-forge.config.json)
+ */
+export interface HttpForgeConfig {
+    /** Configuration version */
+    version: string;
+    /** Storage configuration */
+    storage: StorageConfig;
+    /** Request defaults */
+    request: RequestConfig;
+    /** Script configuration */
+    scripts: ScriptsConfig;
+    /** Test runner configuration */
+    runner: RunnerConfig;
+    /** Environment configuration */
+    environments: EnvironmentsConfig;
+    /** REST-Client export preferences */
+    restClientExport?: RestClientExportConfig;
+    /** Proxy configuration (optional) */
+    proxy?: ProxyConfig | null;
+}
+/**
+ * Configuration service interface
+ */
+export interface IConfigService {
+    /** Get the full configuration */
+    getConfig(): HttpForgeConfig;
+    /** Get storage configuration */
+    getStorageConfig(): StorageConfig;
+    /** Get request configuration */
+    getRequestConfig(): RequestConfig;
+    /** Get scripts configuration */
+    getScriptsConfig(): ScriptsConfig;
+    /** Get runner configuration */
+    getRunnerConfig(): RunnerConfig;
+    /** Get environments configuration */
+    getEnvironmentsConfig(): EnvironmentsConfig;
+    /** Get proxy configuration */
+    getProxyConfig(): ProxyConfig | null;
+    /** Get the resolved root path for HTTP Forge data */
+    getRootPath(): string;
+    /** Get the resolved collections path */
+    getCollectionsPath(): string;
+    /** Get the resolved environments path */
+    getEnvironmentsPath(): string;
+    /** Get the resolved flows path */
+    getFlowsPath(): string;
+    /** Get the resolved history path */
+    getHistoryPath(): string;
+    /** Get the resolved results path */
+    getResultsPath(): string;
+    /** Get the resolved suites path */
+    getSuitesPath(): string;
+    /** Get resolved module paths for script imports */
+    getModulePaths(): string[];
+    /** Get the workspace root path */
+    getWorkspacePath(): string;
+    /** Reload configuration from disk */
+    reload(): void;
+    /** Check if configuration file exists */
+    configExists(): boolean;
+    /** Create default configuration file */
+    createDefaultConfig(): Promise<void>;
+}

package/dist/config/default-config.d.ts

@@ -0,0 +1,29 @@
+/**
+ * HTTP Forge Default Configuration
+ */
+import { HttpForgeConfig } from './config.interface';
+/**
+ * Default configuration values
+ * Used when http-forge.config.json doesn't exist or has missing fields
+ */
+export declare const DEFAULT_CONFIG: HttpForgeConfig;
+/**
+ * Configuration file names
+ */
+export declare const CONFIG_FILES: {
+    /** Main configuration file */
+    config: string;
+};
+/**
+ * Directory names within the root
+ */
+export declare const ROOT_DIRECTORIES: {
+    /** Collections directory */
+    collections: string;
+    /** Environments directory */
+    environments: string;
+    /** Flows directory */
+    flows: string;
+    /** Suites directory */
+    suites: string;
+};

package/dist/config/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Config Services
+ */
+export type { EnvironmentsConfig, HttpForgeConfig, IConfigService, ProxyConfig, RequestConfig, RestClientExportConfig, RunnerConfig, ScriptsConfig, StorageConfig } from './config.interface';
+export { CONFIG_FILES, DEFAULT_CONFIG, ROOT_DIRECTORIES } from './default-config';
+export { ConfigService } from './config-service';

package/dist/container.d.ts

@@ -4,10 +4,20 @@
  * Single Responsibility: Wire up all components with proper dependencies
  * Factory Pattern: Creates configured instances of services
  */
-import { IDataFileParser, IErrorInterceptor, IInterceptorChain, IRequestInterceptor, IRequestPreprocessor, IResponseInterceptor } from './implementations';
-import { ICollectionLoader, ICookieJar, IFileSystem, IHttpClient, IRequestHistory, IScriptRunner, IVariableInterpolator } from './interfaces';
-import { HttpRequest, HttpResponse, RequestSettings, UnifiedCollection, UnifiedRequest } from './interfaces/types';
-import { EnvironmentConfig, EnvironmentResolver, ForgeEnv, ParserRegistry, RequestExecutor, ScriptPipeline } from './services';
+import { ICookieService } from './cookie/interfaces';
+import { IDataFileParser } from './platform/data-file-parser';
+import { IErrorInterceptor, IInterceptorChain, IRequestInterceptor, IResponseInterceptor } from './http/interceptor-chain';
+import { IRequestPreprocessor } from './http/request-preprocessor';
+import { IFileSystem, IHttpClient } from './types/platform';
+import { ICollectionLoader } from './collection/interfaces';
+import { IRequestHistory } from './history/history-interfaces';
+import { IScriptExecutor } from './script/interfaces';
+import { IVariableInterpolator } from './environment/interfaces';
+import { HttpRequest, HttpResponse, RequestSettings, UnifiedCollection, UnifiedRequest } from './types/types';
+import { EnvironmentResolver, EnvironmentStoreConfig } from './environment/environment-resolver';
+import { ForgeEnv } from './environment/forge-env';
+import { ParserRegistry } from './collection/parser-registry';
+import { RequestExecutor } from './execution/request-executor';
 /**
  * Container configuration options
  */
@@ -31,7 +41,7 @@ export interface ForgeContainerOptions {
     /** Enable cookie jar for automatic cookie management */
     enableCookies?: boolean;
     /** Custom cookie jar implementation */
-    cookieJar?: ICookieJar;
+    cookieJar?: ICookieService;
     /** Request interceptors to register */
     requestInterceptors?: IRequestInterceptor[];
     /** Response interceptors to register */
@@ -40,8 +50,8 @@ export interface ForgeContainerOptions {
     errorInterceptors?: IErrorInterceptor[];
     /** Custom interceptor chain (overrides individual interceptors) */
     interceptorChain?: IInterceptorChain;
-    /** Custom script runner implementation */
-    scriptRunner?: IScriptRunner;
+    /** Custom script executor implementation (vm-based, session architecture) */
+    scriptExecutor?: IScriptExecutor;
     /** Script execution timeout (ms) */
     scriptTimeout?: number;
     /** Custom file system implementation */
@@ -59,7 +69,7 @@ export interface ForgeContainerOptions {
     /** Custom request history implementation */
     requestHistory?: IRequestHistory;
     /** Environment configuration */
-    environmentConfig?: EnvironmentConfig;
+    environmentConfig?: EnvironmentStoreConfig;
 }
 /**
  * Forge Container - Main entry point for HTTP Forge Core
@@ -74,9 +84,9 @@ export interface ForgeContainerOptions {
 export declare class ForgeContainer {
     readonly httpClient: IHttpClient;
     readonly fileSystem: IFileSystem;
-    readonly scriptRunner: IScriptRunner;
+    readonly scriptExecutor: IScriptExecutor;
     readonly interpolator: IVariableInterpolator;
-    readonly cookieJar: ICookieJar;
+    readonly cookieJar: ICookieService;
     readonly interceptorChain: IInterceptorChain;
     readonly preprocessor: IRequestPreprocessor;
     readonly dataFileParser: IDataFileParser;
@@ -85,7 +95,6 @@ export declare class ForgeContainer {
     readonly collectionLoader: ICollectionLoader;
     readonly environmentStore: EnvironmentResolver;
     readonly forgeEnv: ForgeEnv;
-    readonly scriptPipeline: ScriptPipeline;
     readonly requestExecutor: RequestExecutor;
     private readonly options;
     constructor(options?: ForgeContainerOptions);
@@ -106,7 +115,7 @@ export declare class ForgeContainer {
     /**
      * Execute a request with full pipeline
      */
-    execute(request: UnifiedRequest, collection: UnifiedCollection, options?: any): Promise<import("./services").ExecuteResult>;
+    execute(request: UnifiedRequest, collection: UnifiedCollection, options?: any): Promise<import(".").ExecuteResult>;
     /**
      * Execute a simple HTTP request
      */
@@ -118,7 +127,7 @@ export declare class ForgeContainer {
     /**
      * Set environment configuration
      */
-    setEnvironmentConfig(config: EnvironmentConfig): void;
+    setEnvironmentConfig(config: EnvironmentStoreConfig): void;
     /**
      * Create a new container with custom options
      */
@@ -143,4 +152,3 @@ export declare class ForgeContainer {
      */
     static fromForgeRoot(forgeRoot?: string, options?: Omit<ForgeContainerOptions, 'forgeRoot' | 'environmentConfig'>): ForgeContainer;
 }
-//# sourceMappingURL=container.d.ts.map

package/dist/{implementations → cookie}/cookie-jar.d.ts

@@ -11,12 +11,12 @@
  *
  * DO NOT modify the core logic - it has been tested and is reliable.
  */
-import { Cookie, ICookieJar } from '../interfaces/cookie';
+import { Cookie, ICookieService } from './interfaces';
 /**
  * In-memory cookie storage
  * Equivalent to plugin's CookieService but without VS Code persistence
  */
-export declare class CookieJar implements ICookieJar {
+export declare class CookieJar implements ICookieService {
     private cookies;
     /**
      * Generate a unique key for a cookie
@@ -94,4 +94,3 @@ export declare class CookieJar implements ICookieJar {
      */
     cleanExpiredCookies(): void;
 }
-//# sourceMappingURL=cookie-jar.d.ts.map

package/dist/cookie/cookie-service.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Cookie Service
+ *
+ * Manages cookies across HTTP Forge sessions.
+ * Platform-agnostic — uses IKeyValueStore for persistence
+ * instead of VS Code globalState.
+ */
+import { Cookie, ICookieParser, ICookieReader } from './interfaces';
+import { IKeyValueStore } from '../types/platform';
+/**
+ * Full cookie service interface (async write operations for platform persistence)
+ */
+export interface IAsyncCookieServiceFull extends ICookieReader, ICookieParser {
+    readonly count: number;
+    set(cookie: Cookie): Promise<void>;
+    setFromResponse(cookies: Cookie[]): Promise<void>;
+    delete(name: string, domain?: string, path?: string): Promise<boolean>;
+    clear(): Promise<void>;
+    clearDomain(domain: string): Promise<void>;
+}
+/**
+ * Service for managing cookies across HTTP Forge sessions.
+ * Provides persistent cookie storage via IKeyValueStore.
+ */
+export declare class CookieService implements IAsyncCookieServiceFull {
+    private store;
+    private storeKey;
+    private cookies;
+    constructor(store: IKeyValueStore, storeKey?: string);
+    /**
+     * Load cookies from persistent storage
+     */
+    private loadCookies;
+    /**
+     * Save cookies to persistent storage
+     */
+    private saveCookies;
+    /**
+     * Generate a unique key for a cookie
+     */
+    private getCookieKey;
+    /**
+     * Get a cookie by name
+     */
+    get(name: string, domain?: string): Cookie | undefined;
+    /**
+     * Set a cookie
+     */
+    set(cookie: Cookie): Promise<void>;
+    /**
+     * Set multiple cookies from a response
+     */
+    setFromResponse(cookies: Cookie[]): Promise<void>;
+    /**
+     * Check if a cookie exists
+     */
+    has(name: string, domain?: string): boolean;
+    /**
+     * Delete a cookie
+     */
+    delete(name: string, domain?: string, path?: string): Promise<boolean>;
+    /**
+     * Get all cookies, optionally filtered by domain
+     */
+    getAll(domain?: string): Cookie[];
+    /**
+     * Get cookies formatted for HTTP Cookie header
+     */
+    getCookieHeader(domain?: string): string;
+    /**
+     * Clear all cookies
+     */
+    clear(): Promise<void>;
+    /**
+     * Clear cookies for a specific domain
+     */
+    clearDomain(domain: string): Promise<void>;
+    /**
+     * Parse Set-Cookie headers from response
+     */
+    parseCookieHeaders(headers: Record<string, string | string[]>, domain?: string): Cookie[];
+    /**
+     * Check if a cookie is expired
+     */
+    private isExpired;
+    /**
+     * Clean expired cookies
+     */
+    private cleanExpiredCookies;
+    /**
+     * Check if a domain matches a cookie domain
+     */
+    private domainMatches;
+    /**
+     * Get cookie count
+     */
+    get count(): number;
+}

package/dist/{implementations → cookie}/cookie-utils.d.ts

@@ -6,7 +6,7 @@
  *
  * Single Responsibility: Cookie parsing, formatting, and validation
  */
-import { Cookie } from '../interfaces/cookie';
+import { Cookie } from './interfaces';
 export declare class CookieUtils {
     /**
      * Parse a single Set-Cookie header value
@@ -75,4 +75,3 @@ export declare class CookieUtils {
      */
     static extractPath(url: string): string;
 }
-//# sourceMappingURL=cookie-utils.d.ts.map

package/dist/cookie/in-memory-cookie-jar.d.ts

@@ -0,0 +1,44 @@
+/**
+ * In-Memory Cookie Jar
+ *
+ * Lightweight ICookieJar implementation for isolated script execution contexts
+ * (e.g., test suite runs). All cookies are stored in-memory and lost when the
+ * instance is discarded.
+ *
+ * For persistent cookie handling (across requests in a session), use
+ * PersistentCookieJar which wraps an ICookieService backend.
+ */
+import type { Cookie } from './interfaces';
+import type { ICookieJar } from '../script/interfaces';
+export declare class InMemoryCookieJar implements ICookieJar {
+    private cookies;
+    /**
+     * Generate a unique key for a cookie (based on CookieService pattern)
+     */
+    private getCookieKey;
+    /**
+     * Get cookies for a specific domain
+     */
+    getCookiesForDomain(domain: string): Cookie[];
+    has(name: string, domain?: string): boolean;
+    get(name: string, domain?: string): Cookie | undefined;
+    set(cookie: Cookie): void;
+    delete(name: string, domain?: string, path?: string): boolean;
+    /**
+     * Get all cookies, optionally filtered by domain
+     */
+    getAll(domain?: string): Cookie[];
+    /**
+     * Add cookies from Set-Cookie headers
+     */
+    setCookiesFromResponse(url: string, headers: Record<string, string | string[]>): void;
+    /**
+     * Get Cookie header value for a request URL
+     * Filters by domain and path matching
+     */
+    getCookieHeader(url: string): string | undefined;
+    /**
+     * Clear all cookies
+     */
+    clear(): void;
+}

package/dist/{interfaces/cookie.d.ts → cookie/interfaces.d.ts}

@@ -89,13 +89,32 @@ export interface ICookieWriter {
     clearDomain(domain: string): void;
 }
 /**
- * Full cookie jar interface (memory-based, no persistence)
+ * Full cookie service interface
  * Core package version - no VS Code dependency
  */
-export interface ICookieJar extends ICookieReader, ICookieWriter, ICookieParser {
+export interface ICookieService extends ICookieReader, ICookieWriter, ICookieParser {
     /**
      * Get cookie count
      */
     readonly count: number;
 }
-//# sourceMappingURL=cookie.d.ts.map
+/**
+ * Async cookie service interface for platform integrations that require
+ * asynchronous persistence (e.g., VS Code globalState, IndexedDB, etc.)
+ *
+ * Read operations remain synchronous (from in-memory cache).
+ * Write operations return Promises to allow async persistence after mutation.
+ */
+export interface IAsyncCookieService extends ICookieReader, ICookieParser {
+    readonly count: number;
+    /** Set a cookie (persists asynchronously) */
+    set(cookie: Cookie): Promise<void>;
+    /** Set multiple cookies from response headers (persists asynchronously) */
+    setFromResponse(cookies: Cookie[]): Promise<void>;
+    /** Delete a cookie (persists asynchronously) */
+    delete(name: string, domain?: string, path?: string): Promise<boolean>;
+    /** Clear all cookies (persists asynchronously) */
+    clear(): Promise<void>;
+    /** Clear cookies for a specific domain (persists asynchronously) */
+    clearDomain(domain: string): Promise<void>;
+}