assure-testing 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 Assure Testing Language
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,257 @@
+# 🧪 Assure - Custom Testing Language
+
+**Assure** is a custom testing language (DSL) built from scratch with a unique browser automation engine using Chrome DevTools Protocol (CDP).
+
+## ✨ Features
+
+- 🎯 **Custom Syntax** - Human-readable test commands
+- 🔧 **Built from Scratch** - No Playwright, no Selenium - pure CDP implementation
+- ⚡ **Lightweight** - Minimal dependencies
+- 🚀 **Fast** - Direct Chrome DevTools Protocol communication
+- 📝 **Simple** - Easy to learn and write tests
+
+## 🏗️ Architecture
+
+```
+assure/
+│
+├── language/
+│   ├── parser.ts        # Parses Assure syntax
+│   ├── tokenizer.ts     # Tokenizes lines
+│
+├── engine/
+│   ├── browser.ts       # Custom CDP browser engine
+│   ├── executor.ts      # Command executor
+│
+├── commands/
+│   ├── open.ts          # OPEN command
+│   ├── click.ts         # CLICK command
+│   ├── type.ts          # TYPE command
+│   ├── expect.ts        # EXPECT command
+│
+├── runner.ts            # Main test runner
+└── *.assure             # Test files
+```
+
+## 📦 Installation
+
+### Install from npm (Recommended)
+
+```bash
+# Install globally
+npm install -g assure-testing
+
+# Or install locally in your project
+npm install --save-dev assure-testing
+```
+
+### Install from source
+
+```bash
+git clone https://github.com/yourusername/assure.git
+cd assure
+npm install
+npm run build
+```
+
+**Requirements:**
+- Node.js 18+
+- Chrome or Chromium browser installed
+
+**File Extension:**
+- All test files must use the `.assure` extension (e.g., `test.assure`, `login.assure`)
+
+## 🚀 Quick Start
+
+1. **Create a test file with `.assure` extension** (`example.assure`):
+
+```
+TEST "My First Test"
+
+OPEN "https://example.com"
+WAIT 2
+EXPECT TITLE CONTAINS "Example"
+```
+
+2. **Install dependencies**:
+
+```bash
+npm install
+```
+
+3. **Run the test**:
+
+```bash
+# If installed globally
+assure example.assure
+
+# If installed locally
+npx assure example.assure
+
+# Or using npm script
+npm test example.assure
+```
+
+## 📚 Language Syntax
+
+### Basic Commands
+
+#### OPEN
+Navigate to a URL:
+```
+OPEN "https://example.com"
+```
+
+#### CLICK
+Click an element:
+```
+CLICK "#button"
+CLICK ".submit-btn"
+CLICK "button[type='submit']"
+```
+
+#### TYPE
+Type text into an input:
+```
+TYPE "#username" "admin"
+TYPE "#password" "secret123"
+```
+
+#### WAIT
+Wait for specified seconds:
+```
+WAIT 2
+WAIT 5
+```
+
+#### EXPECT
+Assert conditions:
+
+**Title:**
+```
+EXPECT TITLE CONTAINS "Dashboard"
+EXPECT TITLE EQUALS "My App"
+```
+
+**URL:**
+```
+EXPECT URL CONTAINS "/dashboard"
+EXPECT URL EQUALS "https://example.com/home"
+```
+
+**Text:**
+```
+EXPECT TEXT "#welcome" CONTAINS "Welcome"
+EXPECT TEXT ".message" EQUALS "Success"
+```
+
+**Visibility:**
+```
+EXPECT VISIBLE "#modal"
+```
+
+### Comments
+
+Lines starting with `#` are comments:
+```
+# This is a comment
+OPEN "https://example.com"
+```
+
+### Test Labels
+
+```
+TEST "User Login Flow"
+```
+
+## 🔧 Custom Browser Engine
+
+Assure uses a **custom-built browser engine** that communicates directly with Chrome via Chrome DevTools Protocol (CDP). This gives you:
+
+- **Full Control** - Direct access to browser internals
+- **No Heavy Dependencies** - Just `chrome-remote-interface` for CDP
+- **Unique Implementation** - Built specifically for Assure
+
+### How It Works
+
+1. Launches Chrome with remote debugging enabled
+2. Connects via WebSocket to Chrome DevTools Protocol
+3. Executes commands using CDP methods
+4. Handles element selection, clicking, typing, etc.
+
+## 📝 Example Test File
+
+Save your tests with the `.assure` extension (e.g., `login.assure`, `checkout.assure`):
+
+```assure
+TEST "User Login"
+
+OPEN "https://example.com/login"
+
+TYPE "#username" "admin"
+TYPE "#password" "password123"
+CLICK "#login-button"
+
+WAIT 2
+
+EXPECT URL CONTAINS "/dashboard"
+EXPECT TEXT "#welcome" CONTAINS "Welcome"
+EXPECT VISIBLE "#user-menu"
+```
+
+## 🛠️ Configuration
+
+### Chrome Path
+
+If Chrome is not in the default location, set the `CHROME_PATH` environment variable:
+
+```bash
+export CHROME_PATH="/path/to/chrome"
+node runner.js test.assure
+```
+
+### Headless Mode
+
+Currently runs in headless mode by default. To run with visible browser, modify `runner.ts`:
+
+```typescript
+session = await createBrowser(false); // visible browser
+```
+
+## 🎯 Supported Commands
+
+| Command | Description | Example |
+|---------|-------------|---------|
+| `OPEN` | Navigate to URL | `OPEN "https://example.com"` |
+| `CLICK` | Click element | `CLICK "#button"` |
+| `TYPE` | Type text | `TYPE "#input" "text"` |
+| `WAIT` | Wait seconds | `WAIT 2` |
+| `EXPECT TITLE` | Assert title | `EXPECT TITLE CONTAINS "Page"` |
+| `EXPECT URL` | Assert URL | `EXPECT URL CONTAINS "/home"` |
+| `EXPECT TEXT` | Assert text | `EXPECT TEXT "#el" CONTAINS "text"` |
+| `EXPECT VISIBLE` | Assert visibility | `EXPECT VISIBLE "#modal"` |
+| `TEST` | Test label | `TEST "My Test"` |
+
+## 🚧 Future Enhancements
+
+- [ ] Variables and functions
+- [ ] IF/ELSE conditionals
+- [ ] RETRY mechanisms
+- [ ] Parallel test execution
+- [ ] HTML/JSON reports
+- [ ] Screenshot support
+- [ ] VS Code syntax highlighting
+- [ ] CI/CD integration
+
+## 📄 License
+
+MIT
+
+## 🤝 Contributing
+
+This is a custom testing language built from scratch. Feel free to extend it!
+
+---
+
+**Built with ❤️ using Chrome DevTools Protocol**
+

package/dist/commands/click.js

@@ -0,0 +1,11 @@
+/**
+ * CLICK command - Clicks an element
+ */
+import { clickElement } from '../engine/browser.js';
+export async function executeClick(session, args) {
+    if (args.length === 0) {
+        throw new Error('CLICK command requires a selector argument');
+    }
+    const selector = args[0];
+    await clickElement(session, selector);
+}

package/dist/commands/expect.js

@@ -0,0 +1,79 @@
+/**
+ * EXPECT command - Asserts conditions
+ * Built from scratch using CDP
+ */
+import { getTitle, getUrl, getTextContent, isVisible } from '../engine/browser.js';
+export async function executeExpect(session, args) {
+    if (args.length < 2) {
+        throw new Error('EXPECT command requires at least 2 arguments');
+    }
+    const [target, condition, ...valueParts] = args;
+    const value = valueParts.join(' ');
+    switch (target.toUpperCase()) {
+        case 'TITLE':
+            const title = await getTitle(session);
+            if (condition.toUpperCase() === 'CONTAINS') {
+                if (!title.includes(value)) {
+                    throw new Error(`Expected title to contain "${value}", but got "${title}"`);
+                }
+            }
+            else if (condition.toUpperCase() === 'EQUALS') {
+                if (title !== value) {
+                    throw new Error(`Expected title to equal "${value}", but got "${title}"`);
+                }
+            }
+            else {
+                throw new Error(`Unknown condition for TITLE: ${condition}`);
+            }
+            break;
+        case 'URL':
+            const url = await getUrl(session);
+            if (condition.toUpperCase() === 'CONTAINS') {
+                if (!url.includes(value)) {
+                    throw new Error(`Expected URL to contain "${value}", but got "${url}"`);
+                }
+            }
+            else if (condition.toUpperCase() === 'EQUALS') {
+                if (url !== value) {
+                    throw new Error(`Expected URL to equal "${value}", but got "${url}"`);
+                }
+            }
+            else {
+                throw new Error(`Unknown condition for URL: ${condition}`);
+            }
+            break;
+        case 'TEXT':
+            if (args.length < 3) {
+                throw new Error('EXPECT TEXT requires a selector, condition, and value');
+            }
+            // For TEXT, the format is: EXPECT TEXT selector condition value
+            // But args already has target removed, so: [selector, condition, ...value]
+            const selector = args[0];
+            const textCondition = args[1];
+            const textValue = args.slice(2).join(' ');
+            const elementText = await getTextContent(session, selector);
+            if (textCondition.toUpperCase() === 'CONTAINS') {
+                if (!elementText.includes(textValue)) {
+                    throw new Error(`Expected text to contain "${textValue}", but got "${elementText}"`);
+                }
+            }
+            else if (textCondition.toUpperCase() === 'EQUALS') {
+                if (elementText.trim() !== textValue.trim()) {
+                    throw new Error(`Expected text to equal "${textValue}", but got "${elementText}"`);
+                }
+            }
+            else {
+                throw new Error(`Unknown condition for TEXT: ${textCondition}`);
+            }
+            break;
+        case 'VISIBLE':
+            const visibleSelector = args[0];
+            const visible = await isVisible(session, visibleSelector);
+            if (!visible) {
+                throw new Error(`Expected element "${visibleSelector}" to be visible`);
+            }
+            break;
+        default:
+            throw new Error(`Unknown EXPECT target: ${target}`);
+    }
+}

package/dist/commands/open.js

@@ -0,0 +1,11 @@
+/**
+ * OPEN command - Navigates to a URL
+ */
+import { navigate } from '../engine/browser.js';
+export async function executeOpen(session, args) {
+    if (args.length === 0) {
+        throw new Error('OPEN command requires a URL argument');
+    }
+    const url = args[0];
+    await navigate(session, url);
+}

package/dist/commands/type.js

@@ -0,0 +1,12 @@
+/**
+ * TYPE command - Types text into an input field
+ */
+import { typeText } from '../engine/browser.js';
+export async function executeType(session, args) {
+    if (args.length < 2) {
+        throw new Error('TYPE command requires a selector and text argument');
+    }
+    const selector = args[0];
+    const text = args.slice(1).join(' '); // Join in case text has spaces
+    await typeText(session, selector, text);
+}

package/dist/engine/browser.js

@@ -0,0 +1,279 @@
+/**
+ * Browser Engine - Custom CDP-based browser automation
+ * Built from scratch using Chrome DevTools Protocol
+ */
+import CDP from 'chrome-remote-interface';
+import { spawn } from 'child_process';
+import { setTimeout } from 'timers/promises';
+import { existsSync } from 'fs';
+const DEFAULT_CHROME_ARGS = [
+    '--headless',
+    '--disable-gpu',
+    '--no-sandbox',
+    '--disable-setuid-sandbox',
+    '--disable-dev-shm-usage',
+    '--remote-debugging-port=9222'
+];
+/**
+ * Find Chrome/Chromium executable path
+ */
+function findChromeExecutable() {
+    const platform = process.platform;
+    if (platform === 'darwin') {
+        // macOS
+        const paths = [
+            '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+            '/Applications/Chromium.app/Contents/MacOS/Chromium',
+            '/usr/bin/google-chrome',
+            '/usr/bin/chromium'
+        ];
+        for (const path of paths) {
+            if (existsSync(path))
+                return path;
+        }
+    }
+    else if (platform === 'linux') {
+        // Try common Linux Chrome/Chromium paths
+        const linuxPaths = ['google-chrome', 'chromium', 'chromium-browser'];
+        for (const chromePath of linuxPaths) {
+            // On Linux, we'll try to execute it to see if it exists
+            // For now, return the first one and let spawn handle errors
+            return chromePath;
+        }
+        return 'google-chrome'; // fallback
+    }
+    else if (platform === 'win32') {
+        const paths = [
+            'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
+            'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe'
+        ];
+        for (const path of paths) {
+            if (existsSync(path))
+                return path;
+        }
+    }
+    throw new Error('Chrome/Chromium not found. Please install Chrome or set CHROME_PATH environment variable.');
+}
+/**
+ * Launch Chrome and connect via CDP
+ */
+export async function createBrowser(headless = true) {
+    const chromePath = process.env.CHROME_PATH || findChromeExecutable();
+    const args = headless ? DEFAULT_CHROME_ARGS : DEFAULT_CHROME_ARGS.filter(arg => arg !== '--headless');
+    // Launch Chrome
+    const chromeProcess = spawn(chromePath, args, {
+        stdio: 'ignore',
+        detached: false
+    });
+    // Wait for Chrome to start
+    await setTimeout(2000);
+    // Connect to Chrome via CDP
+    let client;
+    let retries = 10;
+    while (retries > 0) {
+        try {
+            client = await CDP({ port: 9222 });
+            break;
+        }
+        catch (error) {
+            retries--;
+            if (retries === 0) {
+                chromeProcess.kill();
+                throw new Error('Failed to connect to Chrome DevTools Protocol');
+            }
+            await setTimeout(500);
+        }
+    }
+    if (!client) {
+        chromeProcess.kill();
+        throw new Error('Failed to connect to Chrome DevTools Protocol');
+    }
+    // Enable required domains
+    const { Page, Runtime, DOM, Input, Network } = client;
+    await Page.enable();
+    await Runtime.enable();
+    await DOM.enable();
+    await Network.enable();
+    return {
+        chromeProcess,
+        client,
+        Page,
+        Runtime,
+        DOM,
+        Input,
+        Network
+    };
+}
+/**
+ * Close browser and cleanup
+ */
+export async function closeBrowser(session) {
+    try {
+        await session.client.close();
+    }
+    catch (error) {
+        // Ignore close errors
+    }
+    try {
+        session.chromeProcess.kill();
+    }
+    catch (error) {
+        // Ignore kill errors
+    }
+}
+/**
+ * Navigate to URL
+ */
+export async function navigate(session, url) {
+    await session.Page.navigate({ url });
+    await session.Page.loadEventFired();
+}
+/**
+ * Get page title
+ */
+export async function getTitle(session) {
+    const result = await session.Runtime.evaluate({ expression: 'document.title' });
+    return result.result.value;
+}
+/**
+ * Get current URL
+ */
+export async function getUrl(session) {
+    const result = await session.Runtime.evaluate({ expression: 'window.location.href' });
+    return result.result.value;
+}
+/**
+ * Wait for element to be available
+ */
+export async function waitForSelector(session, selector, timeout = 5000) {
+    const startTime = Date.now();
+    const checkInterval = 100;
+    while (Date.now() - startTime < timeout) {
+        try {
+            const nodeId = await querySelector(session, selector);
+            if (nodeId !== null) {
+                return nodeId;
+            }
+        }
+        catch (error) {
+            // Element not found, continue waiting
+        }
+        await setTimeout(checkInterval);
+    }
+    throw new Error(`Element "${selector}" not found within ${timeout}ms`);
+}
+/**
+ * Query selector and return nodeId
+ */
+export async function querySelector(session, selector) {
+    const document = await session.DOM.getDocument();
+    const { nodeId } = await session.DOM.querySelector({
+        nodeId: document.root.nodeId,
+        selector: selector
+    });
+    return nodeId;
+}
+/**
+ * Click an element
+ */
+export async function clickElement(session, selector) {
+    const nodeId = await waitForSelector(session, selector);
+    // Get bounding box
+    const boxModel = await session.DOM.getBoxModel({ nodeId });
+    if (!boxModel.model) {
+        throw new Error(`Could not get bounding box for selector: ${selector}`);
+    }
+    const content = boxModel.model.content;
+    const x = (content[0] + content[2]) / 2; // Center X
+    const y = (content[1] + content[5]) / 2; // Center Y
+    // Click at coordinates
+    await session.Input.dispatchMouseEvent({
+        type: 'mousePressed',
+        x: x,
+        y: y,
+        button: 'left',
+        clickCount: 1
+    });
+    await session.Input.dispatchMouseEvent({
+        type: 'mouseReleased',
+        x: x,
+        y: y,
+        button: 'left',
+        clickCount: 1
+    });
+    // Wait a bit for any navigation or updates
+    await setTimeout(100);
+}
+/**
+ * Type text into an input field
+ */
+export async function typeText(session, selector, text) {
+    const nodeId = await waitForSelector(session, selector);
+    // Focus the element
+    await session.DOM.focus({ nodeId });
+    // Clear existing value using nodeId
+    const result = await session.DOM.resolveNode({ nodeId });
+    if (result.object.objectId) {
+        await session.Runtime.callFunctionOn({
+            objectId: result.object.objectId,
+            functionDeclaration: 'function() { this.value = ""; this.focus(); }'
+        });
+    }
+    // Type character by character
+    for (const char of text) {
+        await session.Input.dispatchKeyEvent({
+            type: 'char',
+            text: char
+        });
+        await setTimeout(10); // Small delay between keystrokes
+    }
+}
+/**
+ * Get text content of an element
+ */
+export async function getTextContent(session, selector) {
+    const nodeId = await waitForSelector(session, selector);
+    const result = await session.DOM.resolveNode({ nodeId });
+    if (result.object.objectId) {
+        const textResult = await session.Runtime.callFunctionOn({
+            objectId: result.object.objectId,
+            functionDeclaration: 'function() { return this.textContent || this.innerText || ""; }',
+            returnByValue: true
+        });
+        return textResult.result.value || '';
+    }
+    return '';
+}
+/**
+ * Check if element is visible
+ */
+export async function isVisible(session, selector) {
+    try {
+        const nodeId = await querySelector(session, selector);
+        if (nodeId === null)
+            return false;
+        const result = await session.DOM.resolveNode({ nodeId });
+        if (!result.object.objectId)
+            return false;
+        const visibilityResult = await session.Runtime.callFunctionOn({
+            objectId: result.object.objectId,
+            functionDeclaration: `
+        function() {
+          const style = window.getComputedStyle(this);
+          return style.display !== 'none' && style.visibility !== 'hidden' && style.opacity !== '0';
+        }
+      `,
+            returnByValue: true
+        });
+        return visibilityResult.result.value === true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Wait for specified seconds
+ */
+export async function wait(seconds) {
+    await setTimeout(seconds * 1000);
+}

package/dist/engine/executor.js

@@ -0,0 +1,52 @@
+/**
+ * Command Executor - Executes Assure commands
+ */
+import { executeOpen } from '../commands/open.js';
+import { executeClick } from '../commands/click.js';
+import { executeType } from '../commands/type.js';
+import { executeExpect } from '../commands/expect.js';
+import { wait } from './browser.js';
+export async function execute(commands, session) {
+    for (const cmd of commands) {
+        const { action, args, lineNumber } = cmd;
+        try {
+            switch (action) {
+                case 'OPEN':
+                    await executeOpen(session, args);
+                    console.log(`✓ Line ${lineNumber}: OPEN "${args[0]}"`);
+                    break;
+                case 'CLICK':
+                    await executeClick(session, args);
+                    console.log(`✓ Line ${lineNumber}: CLICK "${args[0]}"`);
+                    break;
+                case 'TYPE':
+                    await executeType(session, args);
+                    console.log(`✓ Line ${lineNumber}: TYPE "${args[0]}" "${args.slice(1).join(' ')}"`);
+                    break;
+                case 'WAIT':
+                    const seconds = Number(args[0]);
+                    if (isNaN(seconds)) {
+                        throw new Error(`WAIT command requires a valid number, got: ${args[0]}`);
+                    }
+                    await wait(seconds);
+                    console.log(`✓ Line ${lineNumber}: WAIT ${seconds}`);
+                    break;
+                case 'EXPECT':
+                    await executeExpect(session, args);
+                    console.log(`✓ Line ${lineNumber}: EXPECT ${args.join(' ')}`);
+                    break;
+                case 'TEST':
+                    // TEST is just a label, skip execution
+                    console.log(`\n🧪 ${args.join(' ')}`);
+                    break;
+                default:
+                    throw new Error(`Unknown command: ${action} at line ${lineNumber}`);
+            }
+        }
+        catch (error) {
+            console.error(`\n❌ Error at line ${lineNumber}: ${action} ${args.join(' ')}`);
+            console.error(`   ${error.message}`);
+            throw error;
+        }
+    }
+}

package/dist/language/parser.js

@@ -0,0 +1,26 @@
+/**
+ * Parser - Parses Assure test scripts into command arrays
+ */
+import { tokenize } from './tokenizer.js';
+export function parse(script) {
+    const lines = script.split('\n');
+    const commands = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        // Skip empty lines and comments
+        if (!line || line.startsWith('#')) {
+            continue;
+        }
+        const tokens = tokenize(line);
+        if (tokens.length === 0) {
+            continue;
+        }
+        const [action, ...args] = tokens;
+        commands.push({
+            action: action.toUpperCase(),
+            args: args.map(arg => arg.replace(/^["']|["']$/g, '')), // Remove quotes
+            lineNumber: i + 1
+        });
+    }
+    return commands;
+}

package/dist/language/tokenizer.js

@@ -0,0 +1,42 @@
+/**
+ * Tokenizer - Breaks lines into tokens
+ * Handles quoted strings and whitespace-separated tokens
+ */
+export function tokenize(line) {
+    const tokens = [];
+    let current = '';
+    let inQuotes = false;
+    let quoteChar = '';
+    for (let i = 0; i < line.length; i++) {
+        const char = line[i];
+        if ((char === '"' || char === "'") && !inQuotes) {
+            inQuotes = true;
+            quoteChar = char;
+            continue;
+        }
+        if (char === quoteChar && inQuotes) {
+            inQuotes = false;
+            if (current.trim()) {
+                tokens.push(current.trim());
+                current = '';
+            }
+            continue;
+        }
+        if (inQuotes) {
+            current += char;
+        }
+        else if (char === ' ' || char === '\t') {
+            if (current.trim()) {
+                tokens.push(current.trim());
+                current = '';
+            }
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current.trim()) {
+        tokens.push(current.trim());
+    }
+    return tokens;
+}

package/dist/runner.js

@@ -0,0 +1,74 @@
+/**
+ * Assure Test Runner
+ * Runs .assure test files using custom CDP-based engine
+ */
+import fs from 'fs';
+import { parse } from './language/parser.js';
+import { createBrowser, closeBrowser } from './engine/browser.js';
+import { execute } from './engine/executor.js';
+async function runTest(testFile) {
+    console.log(`\n🚀 Assure Test Runner`);
+    console.log(`📄 Running: ${testFile}\n`);
+    // Validate file extension
+    if (!testFile.endsWith('.assure')) {
+        console.error(`❌ Error: Test files must have .assure extension`);
+        console.error(`   Received: ${testFile}`);
+        console.error(`   Expected: *.assure`);
+        process.exit(1);
+    }
+    // Read test file
+    if (!fs.existsSync(testFile)) {
+        console.error(`❌ Test file not found: ${testFile}`);
+        console.error(`   Make sure the file exists and has the .assure extension`);
+        process.exit(1);
+    }
+    const script = fs.readFileSync(testFile, 'utf-8');
+    const commands = parse(script);
+    if (commands.length === 0) {
+        console.error('❌ No commands found in test file');
+        process.exit(1);
+    }
+    let session;
+    try {
+        // Create browser session
+        console.log('🌐 Launching browser...');
+        session = await createBrowser(true); // headless mode
+        console.log('✓ Browser launched\n');
+        // Execute commands
+        await execute(commands, session);
+        console.log('\n✅ TEST COMPLETED SUCCESSFULLY');
+    }
+    catch (error) {
+        console.error(`\n❌ TEST FAILED: ${error.message}`);
+        process.exit(1);
+    }
+    finally {
+        // Cleanup
+        if (session) {
+            console.log('\n🧹 Cleaning up...');
+            await closeBrowser(session);
+            console.log('✓ Browser closed');
+        }
+    }
+}
+// Main entry point
+const testFile = process.argv[2];
+if (!testFile) {
+    console.log(`
+🧪 Assure Testing Language
+
+Usage:
+  assure <test-file.assure>
+
+Examples:
+  assure login.assure
+  assure tests/checkout.assure
+
+For more information, visit: https://github.com/yourusername/assure
+`);
+    process.exit(0);
+}
+runTest(testFile).catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "assure-testing",
+  "version": "1.0.0",
+  "description": "Assure - A custom testing language (DSL) for browser automation. Test files use .assure extension.",
+  "type": "module",
+  "main": "dist/runner.js",
+  "bin": {
+    "assure": "./dist/runner.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "tsx runner.ts",
+    "run": "tsx runner.ts",
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/runner.js"
+  },
+  "keywords": [
+    "testing",
+    "test",
+    "dsl",
+    "browser-automation",
+    "cdp",
+    "custom-engine",
+    "e2e",
+    "end-to-end",
+    "automation",
+    "chrome-devtools-protocol",
+    "assure"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yourusername/assure.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yourusername/assure/issues"
+  },
+  "homepage": "https://github.com/yourusername/assure#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "chrome-remote-interface": "^0.33.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0"
+  }
+}
+