@gcoredev/fastedge-test 0.0.1-beta.4 → 0.1.0-beta.2

package/dist/lib/runner/HostFunctions.d.ts

@@ -31,6 +31,7 @@ export declare class HostFunctions {
     private pendingHttpCall;
     private httpCallResponse;
     private streamClosed;
+    private localResponse;
     private secretStore;
     private dictionary;
     constructor(memory: MemoryManager, propertyResolver: PropertyResolver, propertyAccessControl: PropertyAccessControl, getCurrentHook: () => HookContext | null, debug?: boolean, secretStore?: SecretStore, dictionary?: Dictionary);
@@ -53,6 +54,13 @@ export declare class HostFunctions {
     clearHttpCallResponse(): void;
     isStreamClosed(): boolean;
     resetStreamClosed(): void;
+    hasLocalResponse(): boolean;
+    getLocalResponse(): {
+        statusCode: number;
+        statusText: string;
+        body: Uint8Array;
+    } | null;
+    resetLocalResponse(): void;
     getRequestHeaders(): HeaderMap;
     getResponseHeaders(): HeaderMap;
     getRequestBody(): string;

package/dist/lib/runner/HttpWasmRunner.d.ts

@@ -18,10 +18,12 @@ export declare class HttpWasmRunner implements IWasmRunner {
     private port;
     private cliPath;
     private tempWasmPath;
+    private currentWasmPath;
     private logs;
     private stateManager;
     private portManager;
     private dotenvEnabled;
+    private dotenvPath;
     constructor(portManager: PortManager, dotenvEnabled?: boolean);
     /**
      * Load WASM binary and spawn fastedge-run process
@@ -34,11 +36,16 @@ export declare class HttpWasmRunner implements IWasmRunner {
     /**
      * Not supported for HTTP WASM (proxy-wasm only)
      */
-    callHook(hookCall: HookCall): Promise<HookResult>;
+    callHook(_hookCall: HookCall): Promise<HookResult>;
     /**
      * Not supported for HTTP WASM (proxy-wasm only)
      */
-    callFullFlow(url: string, method: string, headers: Record<string, string>, body: string, responseHeaders: Record<string, string>, responseBody: string, responseStatus: number, responseStatusText: string, properties: Record<string, unknown>, enforceProductionPropertyRules: boolean): Promise<FullFlowResult>;
+    callFullFlow(_url: string, _method: string, _headers: Record<string, string>, _body: string, _responseHeaders: Record<string, string>, _responseBody: string, _responseStatus: number, _responseStatusText: string, _properties: Record<string, unknown>, _enforceProductionPropertyRules: boolean): Promise<FullFlowResult>;
+    /**
+     * Apply dotenv settings by restarting the fastedge-run process.
+     * The WASM file is not re-read; only the --dotenv flag changes.
+     */
+    applyDotenv(enabled: boolean, dotenvPath?: string): Promise<void>;
     /**
      * Clean up resources
      */
@@ -47,10 +54,20 @@ export declare class HttpWasmRunner implements IWasmRunner {
      * Get runner type
      */
     getType(): WasmType;
+    /**
+     * Get the port the fastedge-run HTTP server is listening on
+     */
+    getPort(): number | null;
     /**
      * Set state manager
      */
     setStateManager(stateManager: IStateManager): void;
+    /**
+     * Parse log level from a process output line.
+     * Matches bare prefixes (e.g. "INFO  target > msg") and bracketed prefixes (e.g. "[INFO] msg").
+     * Falls back to the provided default if no known level prefix is found.
+     */
+    private parseLogLevel;
     /**
      * Setup log capture from process stdout/stderr
      */
@@ -60,21 +77,24 @@ export declare class HttpWasmRunner implements IWasmRunner {
      */
     private setupErrorHandlers;
     /**
-     * Probe port with a single HTTP GET, returning true if any response is received.
-     * Uses Node.js http module with explicit content-length: 0 so that wasi-http
-     * runtimes (fastedge-run) immediately signal EOF to the WASM request body
-     * stream. Without this, newer fastedge-run builds hold the body stream open
-     * on keep-alive connections, causing the WASM's event.request.text() to hang
-     * indefinitely and never send a response.
-     */
-    private probePort;
-    /**
-     * Wait for server to be ready by polling
+     * Wait for the fastedge-run HTTP server to be ready by watching process logs
+     * for the "Listening on" message.
+     *
+     * We intentionally avoid HTTP probing here. HTTP probes trigger WASM execution
+     * (the app calls event.request.text() to read the body), which can hang for
+     * many seconds in CI due to WASM JIT compilation on the first request, or
+     * because newer fastedge-run builds hold the body stream open regardless of
+     * content-length. Watching logs avoids all of this: fastedge-run emits
+     * "Listening on http://127.0.0.1:<port>" as soon as the HTTP listener is bound,
+     * before any WASM execution occurs.
      */
     private waitForServerReady;
     /**
-     * Kill the process gracefully (SIGINT) with fallback to SIGKILL
-     * FastEdge-run responds to SIGINT for graceful shutdown
+     * Kill the process gracefully (SIGINT) with platform-specific force-kill fallback.
+     * SIGINT is sent first on all platforms — Node.js translates it for Windows.
+     * If the process does not exit within 2 seconds:
+     *   - Windows: taskkill /F /T to terminate the process tree
+     *   - Unix: SIGKILL
      */
     private killProcess;
     /**

package/dist/lib/runner/IStateManager.d.ts

@@ -45,9 +45,10 @@ export interface IStateManager {
         body: string;
         contentType: string | null;
         isBase64?: boolean;
-    }, logs: Array<{
+    }, source?: EventSource): void;
+    emitHttpWasmLog(log: {
         level: number;
         message: string;
-    }>, source?: EventSource): void;
+    }, source?: EventSource): void;
     emitReloadWorkspaceWasm(path: string, source?: EventSource): void;
 }

package/dist/lib/runner/IWasmRunner.d.ts

@@ -7,7 +7,14 @@ import type { IStateManager } from "./IStateManager.js";
 import type { HookCall, HookResult, FullFlowResult } from "./types.js";
 export type WasmType = "http-wasm" | "proxy-wasm";
 export interface RunnerConfig {
-    dotenvEnabled?: boolean;
+    dotenv?: {
+        enabled?: boolean;
+        /** Directory path to load dotenv files from. Passes --dotenv <path> to fastedge-run.
+         *  When omitted, fastedge-run uses process CWD (correct for npm package users whose
+         *  .env files live at their project root). Use this only when dotenv files are not in CWD,
+         *  e.g. test fixture directories or non-standard project layouts. */
+        path?: string;
+    };
     enforceProductionPropertyRules?: boolean;
     /** Override automatic WASM type detection. Use when detection produces wrong results. */
     runnerType?: WasmType;
@@ -73,6 +80,14 @@ export interface IWasmRunner {
      * @returns Full flow execution result
      */
     callFullFlow(url: string, method: string, headers: Record<string, string>, body: string, responseHeaders: Record<string, string>, responseBody: string, responseStatus: number, responseStatusText: string, properties: Record<string, unknown>, enforceProductionPropertyRules: boolean): Promise<FullFlowResult>;
+    /**
+     * Apply dotenv settings to the current runner without reloading the WASM.
+     * For ProxyWasmRunner: resets stores and re-loads dotenv files in-place.
+     * For HttpWasmRunner: restarts the fastedge-run process with updated flags.
+     * @param enabled Whether dotenv loading should be enabled
+     * @param path Optional directory to load dotenv files from
+     */
+    applyDotenv(enabled: boolean, path?: string): Promise<void>;
     /**
      * Clean up resources (processes, temp files, etc.)
      */

package/dist/lib/runner/NullStateManager.d.ts

@@ -13,5 +13,6 @@ export declare class NullStateManager implements IStateManager {
     emitWasmLoaded(): void;
     emitPropertiesUpdated(): void;
     emitHttpWasmRequestCompleted(): void;
+    emitHttpWasmLog(): void;
     emitReloadWorkspaceWasm(): void;
 }

package/dist/lib/runner/PortManager.d.ts

@@ -1,8 +1,12 @@
 /**
  * Port Manager
  *
- * Manages port allocation for HTTP WASM server instances
- * Allocates ports from 8100-8199 range
+ * Manages port allocation for HTTP WASM server instances.
+ * Allocates ports from 8100-8199 range.
+ *
+ * Uses OS-level availability checks in addition to in-memory tracking so that
+ * multiple server processes running simultaneously (one per app) don't collide
+ * on the same inner ports.
  */
 export declare class PortManager {
     private readonly minPort;
@@ -10,32 +14,26 @@ export declare class PortManager {
     private allocatedPorts;
     private lastAllocatedPort;
     /**
-     * Allocate an available port from the pool
-     * Sequential allocation to avoid reusing recently released ports (TCP TIME_WAIT)
-     * Synchronous to prevent race conditions when allocating in parallel
+     * Check whether a port is actually free at the OS level.
+     * This is necessary when multiple server processes run simultaneously —
+     * each has its own PortManager with independent in-memory state, so
+     * in-memory tracking alone is not enough to prevent cross-process conflicts.
+     */
+    private isPortFree;
+    /**
+     * Allocate an available port from the pool.
+     * Combines in-memory tracking (avoids TCP TIME_WAIT reuse within this process)
+     * with an OS-level check (avoids cross-process collisions).
      * @returns The allocated port number
      * @throws Error if no ports are available
      */
-    allocate(): number;
+    allocate(): Promise<number>;
     /**
      * Release a previously allocated port back to the pool
-     * @param port The port number to release
      */
     release(port: number): void;
-    /**
-     * Get the number of currently allocated ports
-     */
     getAllocatedCount(): number;
-    /**
-     * Get the number of available ports
-     */
     getAvailableCount(): number;
-    /**
-     * Check if a specific port is allocated
-     */
     isAllocated(port: number): boolean;
-    /**
-     * Reset all allocations (useful for testing)
-     */
     reset(): void;
 }

package/dist/lib/runner/ProxyWasmRunner.d.ts

@@ -20,6 +20,7 @@ export declare class ProxyWasmRunner implements IWasmRunner {
     private secretStore;
     private dictionary;
     private dotenvEnabled;
+    private dotenvPath;
     constructor(fastEdgeConfig?: FastEdgeConfig, dotenvEnabled?: boolean);
     /**
      * Set state manager for event emission
@@ -29,6 +30,12 @@ export declare class ProxyWasmRunner implements IWasmRunner {
      * Load dotenv files if enabled and merge with existing FastEdge config
      */
     private loadDotenvIfEnabled;
+    /**
+     * Apply dotenv settings to the running module without recompiling.
+     * Resets SecretStore/Dictionary to empty, then re-loads dotenv files
+     * using the new settings. The compiled WASM module is untouched.
+     */
+    applyDotenv(enabled: boolean, dotenvPath?: string): Promise<void>;
     load(bufferOrPath: Buffer | string, config?: RunnerConfig): Promise<void>;
     /**
      * Original callFullFlow signature for backward compatibility

package/dist/lib/schemas/api.d.ts

@@ -2,7 +2,10 @@ import { z } from 'zod';
 export declare const ApiLoadBodySchema: z.ZodObject<{
     wasmBase64: z.ZodOptional<z.ZodString>;
     wasmPath: z.ZodOptional<z.ZodString>;
-    dotenvEnabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    dotenv: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const ApiSendBodySchema: z.ZodObject<{
     url: z.ZodString;
@@ -54,7 +57,10 @@ export declare const ApiConfigBodySchema: z.ZodObject<{
             body: z.ZodDefault<z.ZodOptional<z.ZodString>>;
         }, z.core.$strip>>;
         properties: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-        dotenvEnabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        dotenv: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type ApiLoadBody = z.infer<typeof ApiLoadBodySchema>;

package/dist/lib/schemas/config.d.ts

@@ -31,7 +31,10 @@ export declare const TestConfigSchema: z.ZodObject<{
         body: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     }, z.core.$strip>>;
     properties: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    dotenvEnabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    dotenv: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type WasmConfig = z.infer<typeof WasmConfigSchema>;
 export type RequestConfig = z.infer<typeof RequestConfigSchema>;