dashcam 0.8.3 → 1.0.1-beta.2

package/README.md

@@ -1,260 +1,814 @@
-<img src="https://github.com/replayableio/cli/assets/318295/c8019bca-e4d8-42a2-af55-0f4c83ce133e" height="60px" />
+<div align="center">
 
-# Dashcam CLI
+# 🎬 Dashcam CLI
 
-Add Dashcam to your app or workflow. This package allows you to capture logs and control the Dashcam desktop application via CLI.
+### Screen Recording for Automated Tests, CI/CD, and AI Agents
 
-Requires that you [install Dashcam Desktop](https://dashcam.io).
+Capture video recordings of automated test runs with synchronized browser logs, application events, and file changes. Built for CI pipelines, custom VMs, and computer-use agents.
 
-# Manual
+[![npm version](https://img.shields.io/npm/v/dashcam.svg)](https://www.npmjs.com/package/dashcam)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D14.0.0-brightgreen.svg)](https://nodejs.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
+[Quick Start](#-quick-start) • [CI/CD](#-cicd-integration) • [Examples](#-examples) • [API](#-commands)
+
+</div>
+
+---
+
+## 🚀 Quick Start
+
+```bash
+# Install in your CI environment
+npm install -g dashcam
+
+# Authenticate with your API key (get it from app.testdriver.ai/team)
+dashcam auth $TD_API_KEY
+
+# Wrap your test command
+dashcam record --title "E2E Test Run" &
+DASHCAM_PID=$!
+
+# Run your tests
+npm run test:e2e
+
+# Stop recording and auto-upload
+dashcam stop
 ```
-Usage: dashcam [options] [command]
 
-Capture the steps to reproduce every bug.
+**That's it!** Your test run is recorded, uploaded, and ready to debug. 🎉
+
+> 💡 **Get your API key** from [app.testdriver.ai/team](https://app.testdriver.ai/team)
+
+---
+
+## ✨ Features
+
+### 🎥 **Automated Test Recording**
+- Capture full video of test executions in CI/CD
+- High-quality video powered by FFmpeg
+- Background recording that runs alongside your tests
+- Works with any test framework (Playwright, Selenium, Cypress, Puppeteer, etc.)
+
+### 🕵️ **Intelligent Log Tracking**
+Synchronize logs with video timeline for complete observability:
+
+- **📂 Application Logs**: Tail any log file in real-time
+  ```bash
+  dashcam logs --add --name=app-logs --type=file --file=/var/log/myapp.log
+  ```
+
+- **🌐 Browser Events**: Capture console logs, network requests, and navigation
+  ```bash
+  dashcam logs --add --name=webapp --type=web --pattern="*localhost:3000*"
+  ```
+
+- **🔄 Perfect Sync**: All events timestamped and aligned with video
+
+### ☁️ **CI-Friendly Upload**
+- Automatic cloud storage after test completion
+- Instant shareable links for team debugging
+- Project organization and retention policies
+- No manual intervention required
+
+### 🎯 **Perfect for...**
+- 🤖 **CI/CD Pipelines**: Record test runs in GitHub Actions, GitLab CI, Jenkins, etc.
+- 🖥️ **Custom VMs**: Capture agent behavior on headless or virtual machines
+- 🧠 **AI Agents**: Record computer-use agents (Claude, OpenAI, AutoGPT, etc.)
+- � **Test Debugging**: See exactly what happened when tests fail
+- 📊 **QA Validation**: Visual proof of test coverage and behavior
+
+---
+
+## � CI/CD Integration
+
+### GitHub Actions
+
+```yaml
+name: E2E Tests with Video Recording
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      
+      - name: Setup Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: '18'
+      
+      - name: Install dependencies
+        run: npm install
+      
+      - name: Install Dashcam
+        run: npm install -g dashcam
+      
+      - name: Authenticate Dashcam
+        run: dashcam auth ${{ secrets.TD_API_KEY }}
+      
+      - name: Start recording
+        run: |
+          dashcam record --title "E2E Tests - ${{ github.sha }}" \
+                         --description "Automated test run on branch ${{ github.ref_name }}" \
+                         --project ${{ secrets.DASHCAM_PROJECT_ID }} &
+          sleep 2
+      
+      - name: Run tests
+        run: npm run test:e2e
+      
+      - name: Stop recording and upload
+        if: always()
+        run: dashcam stop
+```
 
-Options:
-  -V, --version         output the version number
-  -h, --help            display help for command
+### GitLab CI
+
+```yaml
+e2e-tests:
+  stage: test
+  image: node:18
+  before_script:
+    - npm install -g dashcam
+    - dashcam auth $TD_API_KEY
+  script:
+    - dashcam record --title "E2E Tests - $CI_COMMIT_SHORT_SHA" &
+    - sleep 2
+    - npm run test:e2e
+  after_script:
+    - dashcam stop
+  variables:
+    TD_API_KEY: $TD_API_KEY
+    DASHCAM_PROJECT_ID: $DASHCAM_PROJECT_ID
+```
 
-Commands:
-  auth <api-key>    Authenticate the dashcam desktop using a team's apiKey
-  create [options]  Create a clip and output the resulting url or markdown. Will launch desktop app for local editing before publishing.
-  record [options]  Start a recording terminal to be included in your dashcam video recording
-  pipe              Pipe command output to dashcam to be included in recorded video
-  track [options]  Add a logs config to Dashcam
-  start             Start instant replay recording on dashcam
-  help [command]    display help for command
+### Jenkins
+
+```groovy
+pipeline {
+    agent any
+    
+    environment {
+        TD_API_KEY = credentials('dashcam-api-key')
+    }
+    
+    stages {
+        stage('Setup') {
+            steps {
+                sh 'npm install -g dashcam'
+                sh 'dashcam auth $TD_API_KEY'
+            }
+        }
+        
+        stage('Test') {
+            steps {
+                sh 'dashcam record --title "E2E Tests - ${BUILD_NUMBER}" &'
+                sh 'sleep 2'
+                sh 'npm run test:e2e'
+            }
+        }
+    }
+    
+    post {
+        always {
+            sh 'dashcam stop'
+        }
+    }
+}
 ```
 
-## Table of contents
+### Docker/Custom VMs
 
-- [Dashcam CLI](#dashcam-cli)
-- [Manual](#manual)
-  - [Table of contents](#table-of-contents)
-- [Examples](#examples)
-  - [CLI](#cli)
-    - [Setup](#setup)
-    - [Auth](#auth)
-    - [Record CLI](#record-cli)
-    - [Pipe command output into dashcam for recording](#pipe-command-output-into-dashcam-for-recording)
-    - [Create a Replay](#create-a-replay)
-    - [Return a rich markdown link](#return-a-rich-markdown-link)
-    - [Set a replay title](#set-a-replay-title)
-    - [Set a project to publish to](#set-a-project-to-publish-to)
-    - [Attach the last 20 CLI commands to the replay](#attach-the-last-20-cli-commands-to-the-replay)
-    - [Attach a logfile to the replay](#attach-a-logfile-to-the-replay)
-  - [GitHub CLI](#github-cli)
-    - [Create a github issue with a replay in the description](#create-a-github-issue-with-a-replay-in-the-description)
-    - [Create a github pull request with a replay in the description](#create-a-github-pull-request-with-a-replay-in-the-description)
-    - [Append a 30 second replay to a commit](#append-a-30-second-replay-to-a-commit)
-- [Advanced Usage](#advanced-usage)
-  - [Web](#web)
-    - [Setup](#setup-1)
-    - [HTML Anchor Tag](#html-anchor-tag)
-    - [JS Error Handler](#js-error-handler)
-  - [NodeJS SDK](#nodejs-sdk)
-    - [Setup](#setup-2)
-    - [Create a Replay](#create-a-replay-1)
-    - [Error Handler](#error-handler)
-  - [Ideas](#ideas)
+```dockerfile
+FROM node:18
 
-# Examples
+# Install Dashcam
+RUN npm install -g dashcam
 
-Also see [the examples folder](https://github.com/replayableio/cli/tree/main/examples).
+# Your app setup
+WORKDIR /app
+COPY . .
+RUN npm install
 
-## CLI
+# Authenticate (use build args or runtime env)
+ARG TD_API_KEY
+RUN dashcam auth $TD_API_KEY
 
-### Setup
+# Run tests with recording
+CMD ["sh", "-c", "dashcam record --title 'Container Tests' & sleep 2 && npm test && dashcam stop"]
+```
 
-```sh
-npm install dashcam -g
+---
+
+## 🤖 AI Agent Integration
+
+### Recording Computer-Use Agents
+
+Perfect for capturing AI agent behavior (Claude Computer Use, OpenAI Agents, AutoGPT, etc.):
+
+```javascript
+import { spawn } from 'child_process';
+
+async function runAgentWithRecording(agentTask) {
+  // Start recording
+  const recording = spawn('dashcam', [
+    'record',
+    '--title', `Agent Task: ${agentTask}`,
+    '--description', 'AI agent execution recording'
+  ]);
+  
+  // Wait for recording to initialize
+  await new Promise(resolve => setTimeout(resolve, 2000));
+  
+  try {
+    // Run your AI agent
+    await runAgent(agentTask);
+  } finally {
+    // Always stop and upload recording
+    spawn('dashcam', ['stop']);
+  }
+}
 ```
 
-### Auth
+### Python Agent Integration
+
+```python
+import subprocess
+import time
+
+def record_agent_execution(task_description):
+    # Start recording
+    recording = subprocess.Popen([
+        'dashcam', 'record',
+        '--title', f'Agent Task: {task_description}',
+        '--description', 'AI agent execution'
+    ])
+    
+    time.sleep(2)  # Let recording initialize
+    
+    try:
+        # Run your agent code
+        run_my_agent()
+    finally:
+        # Stop and upload
+        subprocess.run(['dashcam', 'stop'])
+
+# Usage
+record_agent_execution("Browse web and fill form")
+```
 
-To authenticate the Dashcam desktop app using a team's Api key, Use the following command
+---
 
-```
-dashcam auth <Api-Key>
+## �📦 Installation
+
+### NPM (Recommended for CI)
+```bash
+npm install -g dashcam
 ```
 
-### Record CLI
+### Project Dependency
+```bash
+npm install --save-dev dashcam
+```
 
-To record the CLI in the Dashcam app, use the following command
+Then in your package.json:
+```json
+{
+  "scripts": {
+    "test:recorded": "dashcam record --title 'Test Run' & sleep 2 && npm test; dashcam stop"
+  }
+}
+```
 
+### From Source
+```bash
+git clone https://github.com/testdriverai/dashcam.git
+cd dashcam
+npm install
+npm link
 ```
-dashcam record
+
+### Requirements
+- **Node.js** 14.0.0 or higher
+- **FFmpeg** (bundled automatically via ffmpeg-static)
+- **Display server** (X11, Wayland, or macOS windowing system)
+
+---
+
+## 🎯 Examples
+
+### Example 1: Playwright Test Suite
+
+```bash
+#!/bin/bash
+set -e
+
+# Setup
+dashcam auth $TD_API_KEY
+
+# Configure browser log tracking
+dashcam logs --add --name=playwright --type=web --pattern="*localhost:*"
+
+# Start recording
+dashcam record --title "Playwright E2E Suite" \
+               --description "Full test suite execution" &
+
+sleep 2
+
+# Run Playwright tests
+npx playwright test
+
+# Stop and upload
+dashcam stop
 ```
 
-Anything you type in your terminal will appear in your dash. To exit, simply type `exit`.
+### Example 2: Selenium Grid
+
+```bash
+#!/bin/bash
+
+# Track application logs
+dashcam logs --add --name=app --type=file --file=/var/log/app.log
+dashcam logs --add --name=selenium --type=file --file=/var/log/selenium.log
 
+# Start recording
+dashcam record --title "Selenium Grid Tests" --project my-project &
+
+sleep 2
+
+# Run tests on Selenium Grid
+pytest tests/selenium/ --hub=http://selenium-hub:4444
+
+# Cleanup
+dashcam stop
 ```
-exit
+
+### Example 3: Custom Test Framework
+
+```javascript
+// test-runner.js
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+async function runTestsWithRecording() {
+  // Start recording
+  exec('dashcam record --title "Custom Tests" &');
+  
+  // Wait for initialization
+  await new Promise(resolve => setTimeout(resolve, 2000));
+  
+  try {
+    // Run your custom test framework
+    await execAsync('node tests/runner.js');
+    console.log('Tests completed successfully');
+  } catch (error) {
+    console.error('Tests failed:', error);
+    throw error;
+  } finally {
+    // Always upload the recording
+    await execAsync('dashcam stop');
+  }
+}
+
+runTestsWithRecording().catch(console.error);
+```
+
+### Example 4: Multi-Service Test Environment
+
+```bash
+#!/bin/bash
+
+# Setup log tracking for all services
+dashcam logs --add --name=frontend --type=file --file=/var/log/frontend.log
+dashcam logs --add --name=backend --type=file --file=/var/log/backend.log
+dashcam logs --add --name=database --type=file --file=/var/log/postgres.log
+
+# Track web apps
+dashcam logs --add --name=app --type=web --pattern="*localhost:3000*"
+dashcam logs --add --name=admin --type=web --pattern="*localhost:8080*"
+
+# Start recording
+dashcam record --title "Integration Tests" \
+               --description "# Multi-service test\n\nFrontend, backend, and database" &
+
+sleep 2
+
+# Start services
+docker-compose up -d
+
+# Wait for services to be ready
+sleep 10
+
+# Run integration tests
+npm run test:integration
+
+# Cleanup
+docker-compose down
+dashcam stop
 ```
 
-## Add a new logs config to dashcam
+---
 
-Add a new logs config to dashcam by specifying a name, a type ("application" or "web"), and one or multiple patterns for the urls in the case of a web logs config, or for file paths in the case of an application logs config.
+## 📚 Commands
 
+### `dashcam auth <apiKey>`
+Authenticate with your TestDriver API key.
+
+> 💡 **Get your API key** from [app.testdriver.ai/team](https://app.testdriver.ai/team)
+
+```bash
+dashcam auth 4e93d8bf-3886-4d26-a144-116c4063522d
 ```
-dashcam track --name=social --type=web --pattern="*facebook.com*" --pattern="*twitter.com*"
+
+**In CI environments:**
+```bash
+# Use environment variable
+dashcam auth $TD_API_KEY
 ```
 
-## Pipe command output into dashcam for recording
+### `dashcam record [options]`
+Start a new background recording for your test run.
+
+**Options:**
+- `-t, --title <title>` - Recording title (e.g., "E2E Test Suite")
+- `-d, --description <description>` - Description (supports Markdown)
+- `-p, --project <project>` - Project ID for organization
+- `-f, --fps <fps>` - Frames per second (default: 30)
+- `-a, --audio` - Include audio (experimental)
+- `-o, --output <path>` - Custom output path
+- `-v, --verbose` - Enable verbose logging
+
+**Examples:**
+```bash
+# Basic test recording
+dashcam record --title "Nightly E2E Tests" &
+
+# With project and metadata
+dashcam record --title "Sprint 23 Tests" \
+               --description "Testing new authentication flow" \
+               --project proj_abc123 &
+
+# High FPS for smooth playback
+dashcam record --fps 60 --title "UI Animation Tests" &
+```
 
-To record the output of a command in the Dashcam app (In this example the `ping 1.1.1.1` command ), use the following command
+### `dashcam stop`
+Stop the current recording and upload it. Always call this in CI, even if tests fail.
 
+```bash
+dashcam stop
 ```
-ping 1.1.1.1 | dashcam pipe
+
+**CI Best Practice:**
+```yaml
+# GitHub Actions
+- name: Stop recording and upload
+  if: always()  # Run even if tests fail
+  run: dashcam stop
 ```
 
-## Create a Replay
+### `dashcam status`
+Check if a recording is in progress.
+
+```bash
+dashcam status
+# Output:
+# Recording in progress
+# Duration: 45.2 seconds
+# PID: 12345
+# Started: 11/6/2025, 2:30:15 PM
+# Title: Bug Investigation
+```
 
-```sh
-$ dashcam
-https://dashcam.io/replay/123?share=xyz
+### `dashcam logs [options]`
+Manage log tracking configurations.
+
+**Options:**
+- `--add` - Add a new log tracker
+- `--remove <id>` - Remove a tracker by ID
+- `--list` - List all configured trackers
+- `--status` - Show tracking status with event counts
+- `--name <name>` - Tracker name (required with --add)
+- `--type <type>` - Type: "web" or "file" (required with --add)
+- `--pattern <pattern>` - URL pattern for web trackers (can specify multiple)
+- `--file <file>` - File path for file trackers
+
+**Examples:**
+```bash
+# Add web tracker with multiple patterns
+dashcam logs --add --name=social --type=web \
+  --pattern="*facebook.com*" \
+  --pattern="*twitter.com*"
+
+# Add file tracker
+dashcam logs --add --name=app --type=file --file=/var/log/app.log
+
+# List all trackers
+dashcam logs --list
+
+# Check activity
+dashcam logs --status
 ```
 
-### Return a rich markdown link
+### `dashcam upload [filePath] [options]`
+Upload a recording file or recover from interruption.
 
-```sh
-$ dashcam --md
+**Options:**
+- `-t, --title <title>` - Recording title
+- `-d, --description <description>` - Description
+- `-p, --project <project>` - Project ID
+- `--recover` - Recover interrupted recording
 
-[![Dashcam - New Replay](https://replayable-api-production.herokuapp.com/replay/123/gif?shareKey=xyz)](https://replayable.io/replay/123?share=xyz)
+**Examples:**
+```bash
+# Upload specific file
+dashcam upload /path/to/recording.webm --title "My Recording"
 
-Watch [Dashcam - New Replay](https://dashcam.io/replay/123?share=xyz) on Dashcam
+# Recover from interruption
+dashcam upload --recover
 ```
 
-### Set a replay title
+### `dashcam logout`
+Clear authentication credentials.
 
-```sh
-$ dashcam -t "My New Title"
+```bash
+dashcam logout
 ```
 
-### Set a project to publish to
+---
+
+## 🔧 Advanced Usage
+
+### Pattern Matching for Web Trackers
+
+Web trackers support powerful wildcard patterns for capturing browser events during automated tests:
 
-```sh
-$ dashcam -k wef8we72h23012j
+```bash
+# Match any subdomain
+dashcam logs --add --name=app --type=web --pattern="*.myapp.com*"
+
+# Match specific paths
+dashcam logs --add --name=admin --type=web --pattern="*app.com/admin/*"
+
+# Match local dev servers (common in tests)
+dashcam logs --add --name=dev --type=web --pattern="*localhost:*"
+
+# Match test environments
+dashcam logs --add --name=staging --type=web \
+  --pattern="*staging.myapp.com*" \
+  --pattern="*test.myapp.com*"
 ```
 
-### Attach the last 20 CLI commands to the replay
+### Working with Log Files in Tests
+
+```bash
+# Ensure log files exist before starting
+mkdir -p /var/log/myapp
+touch /var/log/myapp/app.log
+touch /var/log/myapp/error.log
+
+# Add to tracking
+dashcam logs --add --name=app --type=file --file=/var/log/myapp/app.log
+dashcam logs --add --name=errors --type=file --file=/var/log/myapp/error.log
+
+# Start recording
+dashcam record --title "Test Run with Logs" &
 
-```sh
-$ history -20 | dashcam
+sleep 2
+
+# Your tests run and write logs
+npm test
+
+# All logs are synchronized with video
+dashcam stop
 ```
 
-### Attach a logfile to the replay
+### Environment Variables
+
+For CI/CD environments, use environment variables instead of hardcoding:
 
-This will attach the mac system log to the replay.
+```bash
+# Set in CI environment
+export TD_API_KEY="your-api-key"
+export DASHCAM_PROJECT_ID="proj_abc123"
 
-```sh
-$ cat /var/log/system.log | dashcam
+# Use in scripts
+dashcam auth $TD_API_KEY
+dashcam record --title "Tests" --project $DASHCAM_PROJECT_ID &
 ```
 
-## GitHub CLI
+### Programmatic Usage in Test Frameworks
+
+#### Jest Integration
+
+```javascript
+// jest.config.js
+module.exports = {
+  globalSetup: './test/setup.js',
+  globalTeardown: './test/teardown.js'
+};
+
+// test/setup.js
+import { exec } from 'child_process';
 
-The following examples depend on having the [GitHub CLI](https://cli.github.com/) installed.
+export default async function globalSetup() {
+  console.log('Starting Dashcam recording...');
+  exec('dashcam record --title "Jest Test Suite" &');
+  await new Promise(resolve => setTimeout(resolve, 2000));
+}
 
-### Create a github issue with a replay in the description
+// test/teardown.js
+import { execSync } from 'child_process';
 
-```sh
-$ gh issue create -w -t "Title" -b "`dashcam --md`"
+export default async function globalTeardown() {
+  console.log('Stopping Dashcam recording...');
+  execSync('dashcam stop');
+}
 ```
 
-This is where it gets really cool. For example, this single command will create a GitHub issue with a video replay and the mac system logs.
+#### Mocha Integration
+
+```javascript
+// test/hooks.js
+import { exec, execSync } from 'child_process';
+
+before(async function() {
+  this.timeout(5000);
+  console.log('Starting recording...');
+  exec('dashcam record --title "Mocha Tests" &');
+  await new Promise(resolve => setTimeout(resolve, 2000));
+});
 
+after(function() {
+  this.timeout(10000);
+  console.log('Uploading recording...');
+  execSync('dashcam stop');
+});
 ```
-gh issue create -w -t "Title" -b "`cat /var/log/system.log | dashcam --md`"
+
+#### Pytest Integration
+
+```python
+# conftest.py
+import subprocess
+import time
+import pytest
+
+@pytest.fixture(scope="session", autouse=True)
+def record_session():
+    # Start recording
+    print("Starting Dashcam recording...")
+    subprocess.Popen([
+        'dashcam', 'record',
+        '--title', 'Pytest Test Suite'
+    ])
+    time.sleep(2)
+    
+    yield
+    
+    # Stop and upload
+    print("Stopping recording...")
+    subprocess.run(['dashcam', 'stop'])
 ```
 
-### Create a github pull request with a replay in the description
+---
 
-```sh
-$ gh pr create -w -t "Title" -b "`dashcam --md`"
+## 🌐 Browser Extension for Test Automation
+
+For web test automation (Playwright, Selenium, Puppeteer, etc.), install the Dashcam browser extension to capture:
+
+- **Console logs** from your application
+- **Network requests** and responses
+- **JavaScript errors** and warnings
+- **Page navigation** events
+
+### Setup
+
+1. **Install extension** (Chrome/Firefox) 
+2. **Start Dashcam CLI** - Extension auto-connects via WebSocket
+3. **Run your tests** - All browser events captured automatically
+4. **Upload recording** - Browser logs included alongside video
+
+The CLI automatically starts a WebSocket server on available ports (10368, 16240, 21855, 24301, or 25928).
+
+### Headless Testing
+
+For headless browsers in CI, browser extension features won't be available, but you can still:
+- Record the full test execution video
+- Track application log files
+- Capture system-level events
+
+---
+
+## 💡 Tips for CI/CD
+
+### 1. Always Use `if: always()` in CI
+
+```yaml
+# GitHub Actions - Always upload recording
+- name: Stop recording
+  if: always()
+  run: dashcam stop
 ```
 
-### Append a 30 second replay to a commit
+### 2. Set Proper Timeouts
 
-```sh
-$ git commit -am "`dashcam`"
+```bash
+# Give recording time to initialize
+dashcam record --title "Tests" &
+sleep 2  # Important!
+npm test
 ```
 
-# Advanced Usage
+### 3. Use Descriptive Titles
 
+```bash
+# Include branch, commit, or build number
+dashcam record --title "E2E Tests - ${GITHUB_SHA}" \
+               --description "Branch: ${GITHUB_REF_NAME}"
 ```
-Usage: dashcam create [options]
 
-Create a replay and output the resulting url or markdown. Will launch desktop app for local editing before publishing.
+### 4. Organize with Projects
 
-Options:
-  -t, --title <string>      Title of the replay. Automatically generated if not supplied.
-  -d, --description [text]  Replay markdown body. This may also be piped in: `cat README.md | dashcam create`
-  --md                      Returns code for a rich markdown image link.
-  -h, --help                display help for command
+```bash
+# Group recordings by project
+dashcam record --project $DASHCAM_PROJECT_ID
 ```
 
-## Web
+### 5. Handle Failed Tests Gracefully
 
-### Setup
+```bash
+# Bash script with proper error handling
+set -e
+dashcam record --title "Tests" &
+sleep 2
 
-Nothing! The app exposes the protocol to the system natively via `dashcam://`.
+# Tests might fail, but still upload
+npm test || TEST_FAILED=true
 
-### HTML Anchor Tag
+dashcam stop
 
-```html
-<a href="dashcam://replay/create" target="_blank">Create a Replay</a>
+# Exit with test status
+if [ "$TEST_FAILED" = true ]; then
+  exit 1
+fi
 ```
 
-### JS Error Handler
+---
 
-```js
-window.onerror = function myErrorHandler() {
-  window.open("dashcam://replay/create", "_blank");
-};
+## 🗂️ Project Structure
 
-setTimeout(() => {
-  throw new Error("Throw makes it go boom!");
-}, 3000);
+```
+dashcam/
+├── bin/
+│   └── dashcam.js          # CLI entry point
+├── lib/
+│   ├── auth.js             # Authentication
+│   ├── recorder.js         # Screen recording engine
+│   ├── uploader.js         # Cloud upload
+│   ├── processManager.js   # Background process handling
+│   ├── logs/               # Log tracking core
+│   ├── tracking/           # File & activity tracking
+│   ├── extension-logs/     # Browser extension integration
+│   └── websocket/          # WebSocket server
+└── examples/               # Example scripts
 ```
 
-## NodeJS SDK
+---
 
-### Setup
+## 🤝 Contributing
 
-```sh
-npm install dashcam
-```
+We love contributions! Here's how you can help:
 
-### Create a Replay
+1. 🐛 **Report bugs** via GitHub issues
+2. 💡 **Suggest features** we should build
+3. 🔧 **Submit PRs** with improvements
+4. 📖 **Improve docs** for clarity
 
-```js
-const dashcam = require("dashcam");
+---
 
-let replay = await dashcam.createReplay({
-  title: "My New Replay",
-  description: `This **renders markdown** or plaintext in monospace font.`,
-});
-```
+## 📄 License
 
-### Error Handler
+MIT © TestDriver.ai
 
-```js
-const dashcam = require("dashcam");
+---
 
-process.on("uncaughtException", async (err) => {
-  let replay = await dashcam.createReplay({
-    title: "uncaughtException",
-    description: err,
-  });
-  console.log("Dashcam", replay);
-});
+## 🔗 Links
 
-setTimeout(() => {
-  throw new Error("Throw makes it go boom!");
-}, 3000);
-```
+- **Documentation**: [Full Guide](./LOG_TRACKING_GUIDE.md)
+- **Issues**: [GitHub Issues](https://github.com/testdriverai/dashcam/issues)
+- **Website**: [testdriver.ai](https://testdriver.ai)
+
+---
+
+<div align="center">
+
+**Made with ❤️ by the TestDriver.ai team**
 
-## Ideas
+[⭐ Star us on GitHub](https://github.com/testdriverai/dashcam) • [🐦 Follow us on Twitter](https://twitter.com/testdriverai)
 
-It would be possible to string this along in [a git hook](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks) to publish with every commit.
+</div>