@curl-runner/cli 1.11.0 → 1.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@curl-runner/cli",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "description": "A powerful CLI tool for HTTP request management using YAML configuration",
   "type": "module",
   "main": "./dist/cli.js",

package/src/executor/request-executor.ts

@@ -11,6 +11,7 @@ import type {
   ResponseStoreContext,
   SnapshotConfig,
 } from '../types/config';
+import { evaluateCondition } from '../utils/condition-evaluator';
 import { CurlBuilder } from '../utils/curl-builder';
 import { Logger } from '../utils/logger';
 import { createStoreContext, extractStoreValues } from '../utils/response-store';
@@ -516,6 +517,23 @@ export class RequestExecutor {
     for (let i = 0; i < requests.length; i++) {
       // Interpolate store variables before execution
       const interpolatedRequest = this.interpolateStoreVariables(requests[i], storeContext);
+
+      // Evaluate `when` condition if present
+      if (interpolatedRequest.when) {
+        const conditionResult = evaluateCondition(interpolatedRequest.when, storeContext);
+        if (!conditionResult.shouldRun) {
+          const skippedResult: ExecutionResult = {
+            request: interpolatedRequest,
+            success: true, // Skipped requests are not failures
+            skipped: true,
+            skipReason: conditionResult.reason,
+          };
+          results.push(skippedResult);
+          this.logger.logSkipped(interpolatedRequest, i + 1, conditionResult.reason);
+          continue;
+        }
+      }
+
       const result = await this.executeRequest(interpolatedRequest, i + 1);
       results.push(result);
 
@@ -618,13 +636,15 @@ export class RequestExecutor {
   }
 
   private createSummary(results: ExecutionResult[], duration: number): ExecutionSummary {
-    const successful = results.filter((r) => r.success).length;
+    const skipped = results.filter((r) => r.skipped).length;
+    const successful = results.filter((r) => r.success && !r.skipped).length;
     const failed = results.filter((r) => !r.success).length;
 
     return {
       total: results.length,
       successful,
       failed,
+      skipped,
       duration,
       results,
     };

package/src/types/config.ts

@@ -57,6 +57,87 @@ export type FormDataConfig = Record<string, FormFieldValue>;
  */
 export type StoreConfig = Record<string, string>;
 
+/**
+ * Operators for conditional expressions.
+ */
+export type ConditionOperator =
+  | '=='
+  | '!='
+  | '>'
+  | '<'
+  | '>='
+  | '<='
+  | 'contains'
+  | 'matches'
+  | 'exists'
+  | 'not-exists';
+
+/**
+ * A single condition expression comparing a store value against an expected value.
+ *
+ * Examples:
+ * - `{ left: "store.status", operator: "==", right: 200 }`
+ * - `{ left: "store.userId", operator: "exists" }`
+ * - `{ left: "store.body.type", operator: "contains", right: "user" }`
+ */
+export interface ConditionExpression {
+  /** Left operand - typically a store path like "store.status" or "store.body.id" */
+  left: string;
+  /** Comparison operator */
+  operator: ConditionOperator;
+  /** Right operand - the value to compare against. Optional for exists/not-exists. */
+  right?: string | number | boolean;
+  /** Case-sensitive comparison for string operators. Default: false (case-insensitive) */
+  caseSensitive?: boolean;
+}
+
+/**
+ * Configuration for conditional request execution.
+ * Supports single conditions, AND (all), and OR (any) compound conditions.
+ *
+ * Examples:
+ * ```yaml
+ * # Single condition
+ * when:
+ *   left: store.status
+ *   operator: "=="
+ *   right: 200
+ *
+ * # AND condition (all must be true)
+ * when:
+ *   all:
+ *     - left: store.status
+ *       operator: "=="
+ *       right: 200
+ *     - left: store.userId
+ *       operator: exists
+ *
+ * # OR condition (any must be true)
+ * when:
+ *   any:
+ *     - left: store.type
+ *       operator: "=="
+ *       right: "admin"
+ *     - left: store.type
+ *       operator: "=="
+ *       right: "superuser"
+ * ```
+ */
+export interface WhenCondition {
+  /** All conditions must be true (AND logic) */
+  all?: ConditionExpression[];
+  /** Any condition must be true (OR logic) */
+  any?: ConditionExpression[];
+  /** Single condition - left operand */
+  left?: string;
+  /** Single condition - operator */
+  operator?: ConditionOperator;
+  /** Single condition - right operand */
+  right?: string | number | boolean;
+  /** Case-sensitive comparison for string operators. Default: false */
+  caseSensitive?: boolean;
+}
+
 /**
  * SSL/TLS certificate configuration options.
  *
@@ -140,6 +221,30 @@ export interface RequestConfig {
    *   contentType: headers.content-type
    */
   store?: StoreConfig;
+  /**
+   * Conditional execution - skip/run request based on previous results.
+   * Only works in sequential execution mode.
+   *
+   * @example
+   * # Object syntax
+   * when:
+   *   left: store.status
+   *   operator: "=="
+   *   right: 200
+   *
+   * # String shorthand
+   * when: "store.status == 200"
+   *
+   * # Compound conditions
+   * when:
+   *   all:
+   *     - left: store.userId
+   *       operator: exists
+   *     - left: store.status
+   *       operator: "<"
+   *       right: 400
+   */
+  when?: WhenCondition | string;
   expect?: {
     failure?: boolean; // If true, expect the request to fail (for negative testing)
     status?: number | number[];
@@ -264,12 +369,17 @@ export interface ExecutionResult {
   };
   /** Snapshot comparison result (if snapshot testing enabled). */
   snapshotResult?: SnapshotCompareResult;
+  /** Whether this request was skipped due to a `when` condition. */
+  skipped?: boolean;
+  /** Reason the request was skipped (condition that failed). */
+  skipReason?: string;
 }
 
 export interface ExecutionSummary {
   total: number;
   successful: number;
   failed: number;
+  skipped: number;
   duration: number;
   results: ExecutionResult[];
 }

package/src/utils/condition-evaluator.test.ts

@@ -0,0 +1,415 @@
+import { describe, expect, test } from 'bun:test';
+import type { ConditionExpression, ResponseStoreContext, WhenCondition } from '../types/config';
+import { evaluateCondition, evaluateExpression, parseStringCondition } from './condition-evaluator';
+
+describe('parseStringCondition', () => {
+  test('should parse equality condition', () => {
+    const result = parseStringCondition('store.status == 200');
+    expect(result).toEqual({
+      left: 'store.status',
+      operator: '==',
+      right: 200,
+    });
+  });
+
+  test('should parse inequality condition', () => {
+    const result = parseStringCondition('store.type != admin');
+    expect(result).toEqual({
+      left: 'store.type',
+      operator: '!=',
+      right: 'admin',
+    });
+  });
+
+  test('should parse greater than condition', () => {
+    const result = parseStringCondition('store.count > 10');
+    expect(result).toEqual({
+      left: 'store.count',
+      operator: '>',
+      right: 10,
+    });
+  });
+
+  test('should parse less than condition', () => {
+    const result = parseStringCondition('store.price < 100.5');
+    expect(result).toEqual({
+      left: 'store.price',
+      operator: '<',
+      right: 100.5,
+    });
+  });
+
+  test('should parse greater than or equal condition', () => {
+    const result = parseStringCondition('store.version >= 2');
+    expect(result).toEqual({
+      left: 'store.version',
+      operator: '>=',
+      right: 2,
+    });
+  });
+
+  test('should parse less than or equal condition', () => {
+    const result = parseStringCondition('store.age <= 65');
+    expect(result).toEqual({
+      left: 'store.age',
+      operator: '<=',
+      right: 65,
+    });
+  });
+
+  test('should parse contains condition', () => {
+    const result = parseStringCondition('store.message contains error');
+    expect(result).toEqual({
+      left: 'store.message',
+      operator: 'contains',
+      right: 'error',
+    });
+  });
+
+  test('should parse matches condition', () => {
+    const result = parseStringCondition('store.email matches ^[a-z]+@');
+    expect(result).toEqual({
+      left: 'store.email',
+      operator: 'matches',
+      right: '^[a-z]+@',
+    });
+  });
+
+  test('should parse exists condition', () => {
+    const result = parseStringCondition('store.userId exists');
+    expect(result).toEqual({
+      left: 'store.userId',
+      operator: 'exists',
+    });
+  });
+
+  test('should parse not-exists condition', () => {
+    const result = parseStringCondition('store.error not-exists');
+    expect(result).toEqual({
+      left: 'store.error',
+      operator: 'not-exists',
+    });
+  });
+
+  test('should parse boolean true', () => {
+    const result = parseStringCondition('store.enabled == true');
+    expect(result).toEqual({
+      left: 'store.enabled',
+      operator: '==',
+      right: true,
+    });
+  });
+
+  test('should parse boolean false', () => {
+    const result = parseStringCondition('store.disabled == false');
+    expect(result).toEqual({
+      left: 'store.disabled',
+      operator: '==',
+      right: false,
+    });
+  });
+
+  test('should parse quoted strings', () => {
+    const result = parseStringCondition('store.name == "John Doe"');
+    expect(result).toEqual({
+      left: 'store.name',
+      operator: '==',
+      right: 'John Doe',
+    });
+  });
+
+  test('should return null for invalid syntax', () => {
+    expect(parseStringCondition('invalid')).toBeNull();
+    expect(parseStringCondition('')).toBeNull();
+    expect(parseStringCondition('store.x')).toBeNull();
+  });
+});
+
+describe('evaluateExpression', () => {
+  const context: ResponseStoreContext = {
+    status: '200',
+    userId: '123',
+    name: 'John',
+    empty: '',
+    enabled: 'true',
+    count: '42',
+    body: '{"type":"user","nested":{"id":1}}',
+  };
+
+  describe('exists operator', () => {
+    test('should return true for existing value', () => {
+      const expr: ConditionExpression = { left: 'store.userId', operator: 'exists' };
+      expect(evaluateExpression(expr, context).passed).toBe(true);
+    });
+
+    test('should return false for empty string', () => {
+      const expr: ConditionExpression = { left: 'store.empty', operator: 'exists' };
+      expect(evaluateExpression(expr, context).passed).toBe(false);
+    });
+
+    test('should return false for missing value', () => {
+      const expr: ConditionExpression = { left: 'store.missing', operator: 'exists' };
+      expect(evaluateExpression(expr, context).passed).toBe(false);
+    });
+  });
+
+  describe('not-exists operator', () => {
+    test('should return true for missing value', () => {
+      const expr: ConditionExpression = { left: 'store.missing', operator: 'not-exists' };
+      expect(evaluateExpression(expr, context).passed).toBe(true);
+    });
+
+    test('should return true for empty string', () => {
+      const expr: ConditionExpression = { left: 'store.empty', operator: 'not-exists' };
+      expect(evaluateExpression(expr, context).passed).toBe(true);
+    });
+
+    test('should return false for existing value', () => {
+      const expr: ConditionExpression = { left: 'store.userId', operator: 'not-exists' };
+      expect(evaluateExpression(expr, context).passed).toBe(false);
+    });
+  });
+
+  describe('== operator', () => {
+    test('should compare numbers', () => {
+      const expr: ConditionExpression = { left: 'store.status', operator: '==', right: 200 };
+      expect(evaluateExpression(expr, context).passed).toBe(true);
+    });
+
+    test('should compare strings case-insensitively by default', () => {
+      const expr: ConditionExpression = { left: 'store.name', operator: '==', right: 'john' };
+      expect(evaluateExpression(expr, context).passed).toBe(true);
+    });
+
+    test('should compare strings case-sensitively when specified', () => {
+      const expr: ConditionExpression = {
+        left: 'store.name',
+        operator: '==',
+        right: 'john',
+        caseSensitive: true,
+      };
+      expect(evaluateExpression(expr, context).passed).toBe(false);
+    });
+
+    test('should compare booleans', () => {
+      const expr: ConditionExpression = { left: 'store.enabled', operator: '==', right: true };
+      expect(evaluateExpression(expr, context).passed).toBe(true);
+    });
+  });
+
+  describe('!= operator', () => {
+    test('should return true for different values', () => {
+      const expr: ConditionExpression = { left: 'store.status', operator: '!=', right: 404 };
+      expect(evaluateExpression(expr, context).passed).toBe(true);
+    });
+
+    test('should return false for equal values', () => {
+      const expr: ConditionExpression = { left: 'store.status', operator: '!=', right: 200 };
+      expect(evaluateExpression(expr, context).passed).toBe(false);
+    });
+  });
+
+  describe('comparison operators', () => {
+    test('should compare with >', () => {
+      const expr: ConditionExpression = { left: 'store.count', operator: '>', right: 40 };
+      expect(evaluateExpression(expr, context).passed).toBe(true);
+    });
+
+    test('should compare with <', () => {
+      const expr: ConditionExpression = { left: 'store.count', operator: '<', right: 50 };
+      expect(evaluateExpression(expr, context).passed).toBe(true);
+    });
+
+    test('should compare with >=', () => {
+      const expr: ConditionExpression = { left: 'store.count', operator: '>=', right: 42 };
+      expect(evaluateExpression(expr, context).passed).toBe(true);
+    });
+
+    test('should compare with <=', () => {
+      const expr: ConditionExpression = { left: 'store.count', operator: '<=', right: 42 };
+      expect(evaluateExpression(expr, context).passed).toBe(true);
+    });
+  });
+
+  describe('contains operator', () => {
+    test('should find substring case-insensitively', () => {
+      const expr: ConditionExpression = { left: 'store.name', operator: 'contains', right: 'OH' };
+      expect(evaluateExpression(expr, context).passed).toBe(true);
+    });
+
+    test('should find substring case-sensitively when specified', () => {
+      const expr: ConditionExpression = {
+        left: 'store.name',
+        operator: 'contains',
+        right: 'OH',
+        caseSensitive: true,
+      };
+      expect(evaluateExpression(expr, context).passed).toBe(false);
+    });
+
+    test('should return false when substring not found', () => {
+      const expr: ConditionExpression = { left: 'store.name', operator: 'contains', right: 'xyz' };
+      expect(evaluateExpression(expr, context).passed).toBe(false);
+    });
+  });
+
+  describe('matches operator', () => {
+    test('should match regex pattern', () => {
+      const expr: ConditionExpression = {
+        left: 'store.name',
+        operator: 'matches',
+        right: '^[A-Z]',
+      };
+      expect(evaluateExpression(expr, context).passed).toBe(true);
+    });
+
+    test('should be case-insensitive by default', () => {
+      const expr: ConditionExpression = {
+        left: 'store.name',
+        operator: 'matches',
+        right: '^john$',
+      };
+      expect(evaluateExpression(expr, context).passed).toBe(true);
+    });
+
+    test('should respect caseSensitive flag', () => {
+      const expr: ConditionExpression = {
+        left: 'store.name',
+        operator: 'matches',
+        right: '^john$',
+        caseSensitive: true,
+      };
+      expect(evaluateExpression(expr, context).passed).toBe(false);
+    });
+
+    test('should handle invalid regex', () => {
+      const expr: ConditionExpression = { left: 'store.name', operator: 'matches', right: '[' };
+      expect(evaluateExpression(expr, context).passed).toBe(false);
+    });
+  });
+});
+
+describe('evaluateCondition', () => {
+  const context: ResponseStoreContext = {
+    status: '200',
+    userId: '123',
+    type: 'admin',
+    enabled: 'true',
+  };
+
+  describe('string shorthand', () => {
+    test('should evaluate valid string condition', () => {
+      const result = evaluateCondition('store.status == 200', context);
+      expect(result.shouldRun).toBe(true);
+      expect(result.reason).toBeUndefined();
+    });
+
+    test('should return false with reason for failing condition', () => {
+      const result = evaluateCondition('store.status == 404', context);
+      expect(result.shouldRun).toBe(false);
+      expect(result.reason).toContain('condition not met');
+    });
+
+    test('should return false for invalid syntax', () => {
+      const result = evaluateCondition('invalid syntax', context);
+      expect(result.shouldRun).toBe(false);
+      expect(result.reason).toContain('invalid condition syntax');
+    });
+  });
+
+  describe('single condition object', () => {
+    test('should evaluate single condition', () => {
+      const condition: WhenCondition = {
+        left: 'store.userId',
+        operator: 'exists',
+      };
+      expect(evaluateCondition(condition, context).shouldRun).toBe(true);
+    });
+
+    test('should fail single condition', () => {
+      const condition: WhenCondition = {
+        left: 'store.missing',
+        operator: 'exists',
+      };
+      const result = evaluateCondition(condition, context);
+      expect(result.shouldRun).toBe(false);
+      expect(result.reason).toContain('condition not met');
+    });
+  });
+
+  describe('all (AND) conditions', () => {
+    test('should pass when all conditions true', () => {
+      const condition: WhenCondition = {
+        all: [
+          { left: 'store.status', operator: '==', right: 200 },
+          { left: 'store.userId', operator: 'exists' },
+          { left: 'store.type', operator: '==', right: 'admin' },
+        ],
+      };
+      expect(evaluateCondition(condition, context).shouldRun).toBe(true);
+    });
+
+    test('should fail when any condition false (short-circuit)', () => {
+      const condition: WhenCondition = {
+        all: [
+          { left: 'store.status', operator: '==', right: 200 },
+          { left: 'store.status', operator: '==', right: 404 }, // fails
+          { left: 'store.userId', operator: 'exists' },
+        ],
+      };
+      const result = evaluateCondition(condition, context);
+      expect(result.shouldRun).toBe(false);
+      expect(result.reason).toContain('store.status == 404');
+    });
+  });
+
+  describe('any (OR) conditions', () => {
+    test('should pass when any condition true (short-circuit)', () => {
+      const condition: WhenCondition = {
+        any: [
+          { left: 'store.status', operator: '==', right: 404 }, // fails
+          { left: 'store.status', operator: '==', right: 200 }, // passes
+          { left: 'store.status', operator: '==', right: 500 }, // skipped
+        ],
+      };
+      expect(evaluateCondition(condition, context).shouldRun).toBe(true);
+    });
+
+    test('should fail when all conditions false', () => {
+      const condition: WhenCondition = {
+        any: [
+          { left: 'store.status', operator: '==', right: 404 },
+          { left: 'store.status', operator: '==', right: 500 },
+        ],
+      };
+      const result = evaluateCondition(condition, context);
+      expect(result.shouldRun).toBe(false);
+      expect(result.reason).toContain('no conditions met');
+    });
+  });
+
+  describe('edge cases', () => {
+    test('should run when no valid condition specified', () => {
+      const condition: WhenCondition = {};
+      expect(evaluateCondition(condition, context).shouldRun).toBe(true);
+    });
+
+    test('should handle empty all array', () => {
+      const condition: WhenCondition = { all: [] };
+      expect(evaluateCondition(condition, context).shouldRun).toBe(true);
+    });
+
+    test('should handle empty any array', () => {
+      const condition: WhenCondition = { any: [] };
+      expect(evaluateCondition(condition, context).shouldRun).toBe(true);
+    });
+
+    test('should handle nested JSON in store', () => {
+      const nestedContext: ResponseStoreContext = {
+        body: '{"user":{"id":123,"role":"admin"}}',
+      };
+      const result = evaluateCondition('store.body.user.role == admin', nestedContext);
+      expect(result.shouldRun).toBe(true);
+    });
+  });
+});

package/src/utils/condition-evaluator.ts

@@ -0,0 +1,327 @@
+import type {
+  ConditionExpression,
+  ConditionOperator,
+  ResponseStoreContext,
+  WhenCondition,
+} from '../types/config';
+import { getValueByPath, valueToString } from './response-store';
+
+/**
+ * Result of evaluating a condition.
+ */
+export interface ConditionResult {
+  shouldRun: boolean;
+  reason?: string;
+}
+
+/**
+ * Parses a string shorthand condition into a ConditionExpression.
+ * Supports formats like:
+ * - "store.status == 200"
+ * - "store.userId exists"
+ * - "store.body.type contains user"
+ * - "store.version >= 2"
+ *
+ * @param condition - String condition to parse
+ * @returns Parsed ConditionExpression or null if invalid
+ */
+export function parseStringCondition(condition: string): ConditionExpression | null {
+  const trimmed = condition.trim();
+
+  // Check for exists/not-exists operators first (unary)
+  const existsMatch = trimmed.match(/^(.+?)\s+(exists|not-exists)$/i);
+  if (existsMatch) {
+    return {
+      left: existsMatch[1].trim(),
+      operator: existsMatch[2].toLowerCase() as ConditionOperator,
+    };
+  }
+
+  // Binary operators pattern
+  const operatorPattern = /^(.+?)\s*(==|!=|>=|<=|>|<|contains|matches)\s*(.+)$/i;
+  const match = trimmed.match(operatorPattern);
+
+  if (!match) {
+    return null;
+  }
+
+  const [, left, operator, right] = match;
+  const rightValue = parseRightValue(right.trim());
+
+  return {
+    left: left.trim(),
+    operator: operator.toLowerCase() as ConditionOperator,
+    right: rightValue,
+  };
+}
+
+/**
+ * Parses the right-hand value, converting to appropriate type.
+ */
+function parseRightValue(value: string): string | number | boolean {
+  // Boolean
+  if (value === 'true') {
+    return true;
+  }
+  if (value === 'false') {
+    return false;
+  }
+
+  // Number
+  const num = Number(value);
+  if (!Number.isNaN(num) && value !== '') {
+    return num;
+  }
+
+  // String - remove quotes if present
+  if (
+    (value.startsWith('"') && value.endsWith('"')) ||
+    (value.startsWith("'") && value.endsWith("'"))
+  ) {
+    return value.slice(1, -1);
+  }
+
+  return value;
+}
+
+/**
+ * Gets a value from the store context using a path.
+ * Handles "store.x" prefix by stripping it.
+ */
+function getStoreValue(path: string, context: ResponseStoreContext): unknown {
+  // Strip "store." prefix if present
+  const normalizedPath = path.startsWith('store.') ? path.slice(6) : path;
+
+  // First check if it's a direct key in context
+  if (normalizedPath in context) {
+    const value = context[normalizedPath];
+    // Try to parse JSON if it looks like an object/array
+    if (value.startsWith('{') || value.startsWith('[')) {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    }
+    // Try to parse as number
+    const num = Number(value);
+    if (!Number.isNaN(num) && value !== '') {
+      return num;
+    }
+    // Try to parse as boolean
+    if (value === 'true') {
+      return true;
+    }
+    if (value === 'false') {
+      return false;
+    }
+    return value;
+  }
+
+  // Handle nested paths like "body.data.id" where context has "body" as JSON string
+  const parts = normalizedPath.split('.');
+  const rootKey = parts[0];
+
+  if (rootKey in context) {
+    const rootValue = context[rootKey];
+    // Try to parse as JSON and navigate
+    try {
+      const parsed = JSON.parse(rootValue);
+      return getValueByPath(parsed, parts.slice(1).join('.'));
+    } catch {
+      // Not JSON, can't navigate further
+      return undefined;
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * Compares two values based on case sensitivity setting.
+ */
+function compareStrings(a: string, b: string, caseSensitive: boolean): boolean {
+  if (caseSensitive) {
+    return a === b;
+  }
+  return a.toLowerCase() === b.toLowerCase();
+}
+
+/**
+ * Evaluates a single condition expression against the store context.
+ */
+export function evaluateExpression(
+  expr: ConditionExpression,
+  context: ResponseStoreContext,
+): { passed: boolean; description: string } {
+  const leftValue = getStoreValue(expr.left, context);
+  const caseSensitive = expr.caseSensitive ?? false;
+
+  const formatValue = (v: unknown): string => {
+    if (v === undefined) {
+      return 'undefined';
+    }
+    if (v === null) {
+      return 'null';
+    }
+    if (typeof v === 'string') {
+      return `"${v}"`;
+    }
+    return String(v);
+  };
+
+  const description = `${expr.left} ${expr.operator}${expr.right !== undefined ? ` ${formatValue(expr.right)}` : ''}`;
+
+  switch (expr.operator) {
+    case 'exists': {
+      const passed = leftValue !== undefined && leftValue !== null && leftValue !== '';
+      return { passed, description };
+    }
+
+    case 'not-exists': {
+      const passed = leftValue === undefined || leftValue === null || leftValue === '';
+      return { passed, description };
+    }
+
+    case '==': {
+      let passed: boolean;
+      if (typeof leftValue === 'string' && typeof expr.right === 'string') {
+        passed = compareStrings(leftValue, expr.right, caseSensitive);
+      } else {
+        // biome-ignore lint/suspicious/noDoubleEquals: intentional loose equality for type coercion
+        passed = leftValue == expr.right;
+      }
+      return { passed, description };
+    }
+
+    case '!=': {
+      let passed: boolean;
+      if (typeof leftValue === 'string' && typeof expr.right === 'string') {
+        passed = !compareStrings(leftValue, expr.right, caseSensitive);
+      } else {
+        // biome-ignore lint/suspicious/noDoubleEquals: intentional loose equality for type coercion
+        passed = leftValue != expr.right;
+      }
+      return { passed, description };
+    }
+
+    case '>': {
+      const passed = Number(leftValue) > Number(expr.right);
+      return { passed, description };
+    }
+
+    case '<': {
+      const passed = Number(leftValue) < Number(expr.right);
+      return { passed, description };
+    }
+
+    case '>=': {
+      const passed = Number(leftValue) >= Number(expr.right);
+      return { passed, description };
+    }
+
+    case '<=': {
+      const passed = Number(leftValue) <= Number(expr.right);
+      return { passed, description };
+    }
+
+    case 'contains': {
+      const leftStr = valueToString(leftValue);
+      const rightStr = String(expr.right ?? '');
+      const passed = caseSensitive
+        ? leftStr.includes(rightStr)
+        : leftStr.toLowerCase().includes(rightStr.toLowerCase());
+      return { passed, description };
+    }
+
+    case 'matches': {
+      const leftStr = valueToString(leftValue);
+      const pattern = String(expr.right ?? '');
+      try {
+        const flags = caseSensitive ? '' : 'i';
+        const regex = new RegExp(pattern, flags);
+        const passed = regex.test(leftStr);
+        return { passed, description };
+      } catch {
+        // Invalid regex pattern
+        return { passed: false, description: `${description} (invalid regex)` };
+      }
+    }
+
+    default:
+      return { passed: false, description: `unknown operator: ${expr.operator}` };
+  }
+}
+
+/**
+ * Evaluates a WhenCondition against the store context.
+ *
+ * @param condition - The condition to evaluate
+ * @param context - The store context with values from previous requests
+ * @returns Result indicating whether the request should run
+ */
+export function evaluateCondition(
+  condition: WhenCondition | string,
+  context: ResponseStoreContext,
+): ConditionResult {
+  // Handle string shorthand
+  if (typeof condition === 'string') {
+    const parsed = parseStringCondition(condition);
+    if (!parsed) {
+      return { shouldRun: false, reason: `invalid condition syntax: "${condition}"` };
+    }
+    const result = evaluateExpression(parsed, context);
+    return {
+      shouldRun: result.passed,
+      reason: result.passed ? undefined : `condition not met: ${result.description}`,
+    };
+  }
+
+  // Handle compound "all" condition (AND logic with short-circuit)
+  if (condition.all && condition.all.length > 0) {
+    for (const expr of condition.all) {
+      const result = evaluateExpression(expr, context);
+      if (!result.passed) {
+        return {
+          shouldRun: false,
+          reason: `condition not met: ${result.description}`,
+        };
+      }
+    }
+    return { shouldRun: true };
+  }
+
+  // Handle compound "any" condition (OR logic with short-circuit)
+  if (condition.any && condition.any.length > 0) {
+    const descriptions: string[] = [];
+    for (const expr of condition.any) {
+      const result = evaluateExpression(expr, context);
+      if (result.passed) {
+        return { shouldRun: true };
+      }
+      descriptions.push(result.description);
+    }
+    return {
+      shouldRun: false,
+      reason: `no conditions met: ${descriptions.join(', ')}`,
+    };
+  }
+
+  // Handle single condition (inline left/operator/right)
+  if (condition.left && condition.operator) {
+    const expr: ConditionExpression = {
+      left: condition.left,
+      operator: condition.operator,
+      right: condition.right,
+      caseSensitive: condition.caseSensitive,
+    };
+    const result = evaluateExpression(expr, context);
+    return {
+      shouldRun: result.passed,
+      reason: result.passed ? undefined : `condition not met: ${result.description}`,
+    };
+  }
+
+  // No valid condition found - default to run
+  return { shouldRun: true };
+}

package/src/utils/logger.ts

@@ -573,6 +573,7 @@ export class Logger {
           total: summary.total,
           successful: summary.successful,
           failed: summary.failed,
+          skipped: summary.skipped,
           duration: summary.duration,
         },
         results: summary.results.map((result) => ({
@@ -608,10 +609,11 @@ export class Logger {
     if (level === 'minimal') {
       // Simple one-line summary for minimal, similar to docs example
       const statusColor = summary.failed === 0 ? 'green' : 'red';
+      const skippedText = summary.skipped > 0 ? `, ${summary.skipped} skipped` : '';
       const successText =
         summary.failed === 0
-          ? `${summary.total} request${summary.total === 1 ? '' : 's'} completed successfully`
-          : `${summary.successful}/${summary.total} request${summary.total === 1 ? '' : 's'} completed, ${summary.failed} failed`;
+          ? `${summary.total} request${summary.total === 1 ? '' : 's'} completed successfully${skippedText}`
+          : `${summary.successful}/${summary.total} request${summary.total === 1 ? '' : 's'} completed, ${summary.failed} failed${skippedText}`;
 
       const summaryPrefix = isGlobal ? '◆ Global Summary' : 'Summary';
       console.log(`${summaryPrefix}: ${this.color(successText, statusColor)}`);
@@ -621,10 +623,11 @@ export class Logger {
     // Compact summary for standard/detailed - much simpler
     const _successRate = ((summary.successful / summary.total) * 100).toFixed(1);
     const statusColor = summary.failed === 0 ? 'green' : 'red';
+    const skippedText = summary.skipped > 0 ? `, ${summary.skipped} skipped` : '';
     const successText =
       summary.failed === 0
-        ? `${summary.total} request${summary.total === 1 ? '' : 's'} completed successfully`
-        : `${summary.successful}/${summary.total} request${summary.total === 1 ? '' : 's'} completed, ${summary.failed} failed`;
+        ? `${summary.total} request${summary.total === 1 ? '' : 's'} completed successfully${skippedText}`
+        : `${summary.successful}/${summary.total} request${summary.total === 1 ? '' : 's'} completed, ${summary.failed} failed${skippedText}`;
 
     const summaryPrefix = isGlobal ? '◆ Global Summary' : 'Summary';
     console.log();
@@ -658,6 +661,41 @@ export class Logger {
     console.log(this.color(`✓ ${message}`, 'green'));
   }
 
+  logSkipped(config: RequestConfig, index: number, reason?: string): void {
+    if (!this.shouldShowOutput()) {
+      return;
+    }
+
+    const name = config.name || `Request ${index}`;
+
+    if (this.config.format === 'json') {
+      const jsonResult = {
+        request: {
+          name: config.name,
+          url: config.url,
+          method: config.method || 'GET',
+        },
+        skipped: true,
+        reason: reason || 'condition not met',
+      };
+      console.log(JSON.stringify(jsonResult, null, 2));
+      return;
+    }
+
+    // Pretty format
+    console.log(
+      `${this.color('⊘', 'yellow')} ${this.color(name, 'bright')} ${this.color('[SKIP]', 'yellow')}`,
+    );
+
+    if (reason) {
+      const treeNodes: TreeNode[] = [{ label: 'Reason', value: reason, color: 'yellow' }];
+      const renderer = new TreeRenderer(this.colors);
+      renderer.render(treeNodes);
+    }
+
+    console.log();
+  }
+
   logFileHeader(fileName: string, requestCount: number): void {
     if (!this.shouldShowOutput() || this.config.format !== 'pretty') {
       return;