veil-browser 0.1.0

package/dist/mcp.js

@@ -0,0 +1,232 @@
+import { createServer } from 'http';
+import { getBrowser, closeBrowser, humanDelay } from './browser.js';
+import { searchCommand } from './commands/search.js';
+import { listSessions, loadSession } from './session.js';
+import chalk from 'chalk';
+const TOOLS = [
+    {
+        name: 'veil_navigate',
+        description: 'Navigate to a URL in stealth headless mode using a saved session',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'URL to navigate to' },
+                platform: { type: 'string', description: 'Platform session to use (e.g. twitter, reddit)' },
+                headed: { type: 'boolean', description: 'Run in visible browser mode' },
+            },
+            required: ['url'],
+        },
+    },
+    {
+        name: 'veil_act',
+        description: 'Perform a natural language action in the browser (click, type, post tweet, scroll, etc)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                instruction: { type: 'string', description: 'Natural language instruction, e.g. "post tweet: hello world"' },
+                platform: { type: 'string', description: 'Platform session to use' },
+                url: { type: 'string', description: 'Navigate to this URL first' },
+                headed: { type: 'boolean' },
+            },
+            required: ['instruction'],
+        },
+    },
+    {
+        name: 'veil_search',
+        description: 'Search the web using Google, Bing, DuckDuckGo, or Twitter. Returns JSON results.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query' },
+                engine: { type: 'string', description: 'Comma-separated engines: google,bing,duckduckgo,twitter', default: 'google' },
+                limit: { type: 'number', description: 'Max results', default: 10 },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'veil_extract',
+        description: 'Extract data from a web page. Supports: tweets, links, text, title, metadata.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'What to extract: tweets, links, text, title' },
+                url: { type: 'string', description: 'URL to extract from' },
+                platform: { type: 'string', description: 'Platform session to use' },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'veil_screenshot',
+        description: 'Take a screenshot of a page. Returns the file path.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: { type: 'string' },
+                platform: { type: 'string' },
+                output: { type: 'string', description: 'Output file path' },
+            },
+        },
+    },
+    {
+        name: 'veil_session_list',
+        description: 'List all saved platform sessions',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'veil_login_status',
+        description: 'Check if a session exists for a given platform',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                platform: { type: 'string' },
+            },
+            required: ['platform'],
+        },
+    },
+];
+async function callTool(name, args) {
+    switch (name) {
+        case 'veil_navigate': {
+            const { page } = await getBrowser({ headed: args.headed, platform: args.platform });
+            await page.goto(args.url, { waitUntil: 'domcontentloaded', timeout: 30000 });
+            await humanDelay(500, 1200);
+            const title = await page.title();
+            const url = page.url();
+            await closeBrowser(args.platform);
+            return { success: true, url, title };
+        }
+        case 'veil_act': {
+            const { actCommand } = await import('./commands/act.js');
+            // Capture stdout
+            const chunks = [];
+            const orig = process.stdout.write.bind(process.stdout);
+            process.stdout.write = (c) => chunks.push(c.toString());
+            await actCommand(args.instruction, { platform: args.platform, url: args.url, headed: args.headed, json: true });
+            process.stdout.write = orig;
+            const out = chunks.join('');
+            try {
+                return JSON.parse(out.split('\n').filter(Boolean).pop() ?? '{}');
+            }
+            catch {
+                return { success: true };
+            }
+        }
+        case 'veil_search': {
+            const chunks = [];
+            const orig = process.stdout.write.bind(process.stdout);
+            process.stdout.write = (c) => chunks.push(c.toString());
+            await searchCommand(args.query, { engine: args.engine ?? 'google', json: true, limit: String(args.limit ?? 10) });
+            process.stdout.write = orig;
+            const out = chunks.join('');
+            try {
+                return JSON.parse(out.split('\n').filter(Boolean).pop() ?? '{}');
+            }
+            catch {
+                return { success: false };
+            }
+        }
+        case 'veil_extract': {
+            const { extractCommand } = await import('./commands/extract.js');
+            const chunks = [];
+            const orig = process.stdout.write.bind(process.stdout);
+            process.stdout.write = (c) => chunks.push(c.toString());
+            await extractCommand(args.query, { platform: args.platform, url: args.url, json: true });
+            process.stdout.write = orig;
+            const out = chunks.join('');
+            try {
+                return JSON.parse(out.split('\n').filter(Boolean).pop() ?? '{}');
+            }
+            catch {
+                return { success: false };
+            }
+        }
+        case 'veil_screenshot': {
+            const { screenshotCommand } = await import('./commands/screenshot.js');
+            const chunks = [];
+            const orig = process.stdout.write.bind(process.stdout);
+            process.stdout.write = (c) => chunks.push(c.toString());
+            await screenshotCommand({ platform: args.platform, url: args.url, output: args.output, json: true });
+            process.stdout.write = orig;
+            const out = chunks.join('');
+            try {
+                return JSON.parse(out.split('\n').filter(Boolean).pop() ?? '{}');
+            }
+            catch {
+                return { success: false };
+            }
+        }
+        case 'veil_session_list': {
+            const sessions = await listSessions();
+            return { sessions };
+        }
+        case 'veil_login_status': {
+            const session = await loadSession(args.platform);
+            return { platform: args.platform, loggedIn: !!session };
+        }
+        default:
+            throw new Error(`Unknown tool: ${name}`);
+    }
+}
+function jsonRpc(id, result, error) {
+    if (error)
+        return { jsonrpc: '2.0', id, error: { code: -32000, message: error } };
+    return { jsonrpc: '2.0', id, result };
+}
+async function handleRequest(body) {
+    const { id, method, params } = body;
+    if (method === 'initialize') {
+        return jsonRpc(id, {
+            protocolVersion: '2024-11-05',
+            capabilities: { tools: {} },
+            serverInfo: { name: 'veil', version: '0.1.0' },
+        });
+    }
+    if (method === 'tools/list') {
+        return jsonRpc(id, { tools: TOOLS });
+    }
+    if (method === 'tools/call') {
+        try {
+            const result = await callTool(params.name, params.arguments ?? {});
+            return jsonRpc(id, { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] });
+        }
+        catch (err) {
+            return jsonRpc(id, undefined, err.message);
+        }
+    }
+    return jsonRpc(id, undefined, `Method not found: ${method}`);
+}
+export async function startMcpServer(port = 3456) {
+    const server = createServer(async (req, res) => {
+        if (req.method === 'POST') {
+            let body = '';
+            req.on('data', (chunk) => (body += chunk));
+            req.on('end', async () => {
+                try {
+                    const parsed = JSON.parse(body);
+                    const response = await handleRequest(parsed);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify(response));
+                }
+                catch (err) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+        }
+        else if (req.method === 'GET' && req.url === '/health') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ status: 'ok', version: '0.1.0' }));
+        }
+        else {
+            res.writeHead(404);
+            res.end();
+        }
+    });
+    server.listen(port, () => {
+        console.log(chalk.cyan(`\n🕶️  veil MCP server running on http://localhost:${port}`));
+        console.log(chalk.gray(`   Tools: ${TOOLS.map((t) => t.name).join(', ')}\n`));
+    });
+    process.on('SIGINT', () => { server.close(); process.exit(0); });
+}

package/dist/session.d.ts

@@ -0,0 +1,4 @@
+export declare function saveSession(platform: string, state: object): Promise<void>;
+export declare function loadSession(platform: string): Promise<any | null>;
+export declare function deleteSession(platform: string): Promise<boolean>;
+export declare function listSessions(): Promise<string[]>;

package/dist/session.js

@@ -0,0 +1,37 @@
+import { promises as fs } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const SESSION_DIR = join(homedir(), '.veil', 'sessions');
+async function ensureDir() {
+    await fs.mkdir(SESSION_DIR, { recursive: true });
+}
+export async function saveSession(platform, state) {
+    await ensureDir();
+    const file = join(SESSION_DIR, `${platform}.json`);
+    await fs.writeFile(file, JSON.stringify(state, null, 2), 'utf-8');
+}
+export async function loadSession(platform) {
+    const file = join(SESSION_DIR, `${platform}.json`);
+    try {
+        const raw = await fs.readFile(file, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function deleteSession(platform) {
+    const file = join(SESSION_DIR, `${platform}.json`);
+    try {
+        await fs.unlink(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function listSessions() {
+    await ensureDir();
+    const files = await fs.readdir(SESSION_DIR);
+    return files.filter((f) => f.endsWith('.json')).map((f) => f.replace('.json', ''));
+}

package/dist/startup.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Called once when veil starts any browser command.
+ * Boots FlareSolverr in the background so it's ready before we hit a CAPTCHA.
+ */
+export declare function veilStartup(): Promise<void>;

package/dist/startup.js

@@ -0,0 +1,9 @@
+import { ensureFlareSolverr } from './local-captcha.js';
+/**
+ * Called once when veil starts any browser command.
+ * Boots FlareSolverr in the background so it's ready before we hit a CAPTCHA.
+ */
+export async function veilStartup() {
+    // Start FlareSolverr silently in background — don't await, don't block
+    ensureFlareSolverr().catch(() => { });
+}

package/dist/state.d.ts

@@ -0,0 +1,13 @@
+export interface VeilState {
+    sessionId: string;
+    currentUrl: string;
+    platform?: string;
+    pageTitle?: string;
+    lastAction: string;
+    timestamp: number;
+    history: string[];
+    error?: string;
+}
+export declare function saveState(sessionId: string, state: Partial<VeilState>): Promise<void>;
+export declare function loadState(sessionId: string): Promise<VeilState | null>;
+export declare function clearState(sessionId: string): Promise<void>;

package/dist/state.js

@@ -0,0 +1,45 @@
+import { promises as fs } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const STATE_DIR = join(homedir(), '.veil', 'state');
+async function ensureDir() {
+    await fs.mkdir(STATE_DIR, { recursive: true });
+}
+export async function saveState(sessionId, state) {
+    await ensureDir();
+    const file = join(STATE_DIR, `${sessionId}.json`);
+    let existing = {
+        sessionId,
+        currentUrl: '',
+        lastAction: '',
+        timestamp: Date.now(),
+        history: [],
+    };
+    try {
+        const raw = await fs.readFile(file, 'utf-8');
+        existing = JSON.parse(raw);
+    }
+    catch { }
+    const updated = { ...existing, ...state, timestamp: Date.now() };
+    if (state.currentUrl && state.currentUrl !== existing.currentUrl) {
+        updated.history = [...(existing.history ?? []).slice(-19), state.currentUrl];
+    }
+    await fs.writeFile(file, JSON.stringify(updated, null, 2), 'utf-8');
+}
+export async function loadState(sessionId) {
+    const file = join(STATE_DIR, `${sessionId}.json`);
+    try {
+        const raw = await fs.readFile(file, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function clearState(sessionId) {
+    const file = join(STATE_DIR, `${sessionId}.json`);
+    try {
+        await fs.unlink(file);
+    }
+    catch { }
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "veil-browser",
+  "version": "0.1.0",
+  "description": "Stealth browser CLI for AI agents — bypass bot detection, persist sessions, local CAPTCHA solving, MCP server",
+  "keywords": [
+    "browser",
+    "automation",
+    "stealth",
+    "playwright",
+    "cli",
+    "captcha",
+    "ai-agent",
+    "mcp"
+  ],
+  "author": "CUTTLELAB",
+  "license": "MIT",
+  "homepage": "https://github.com/cuttlelab/veil",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cuttlelab/veil.git"
+  },
+  "bin": {
+    "veil": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node src/index.ts",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist/**/*",
+    "README.md"
+  ],
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "ora": "^8.1.1",
+    "playwright": "^1.50.0",
+    "playwright-extra": "^4.3.6",
+    "puppeteer-extra-plugin-stealth": "^2.11.2",
+    "tesseract.js": "^5.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.5"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "type": "module"
+}