shooty

#!/usr/bin/env node

const puppeteer = require('puppeteer');
const path = require('path');
const urlx = require('url');
const meow = require('meow');
const onDie = require('death'); 
const fs = require('fs')

let browser = null;
let page = null;
let interval_id = null;
let images = [];
let index = 0;

const removeImageByLimit = async (path, limit = 0) => {
    
    if(limit === 0) return true;

    index++;
    index = index%limit;
    
    if(images[index]){
        fs.stat(path, (err) => {
            if(!err){
                fs.unlink(path, err => {
                    if(err){
                        console.log("shit:",err);
                    }
                });
            }
        });
    }
    images[index] = path;
};

const cli = meow(`
    Usage
        $ shooty <url>

    Options
        --start           Date it will start (optional)
        --stop            Date it will stop (optional)
        --every, -e       Time between every shoot (2m,3h,1d)
        --limit, -l       Limit of shoots to take (optional)
        --timeout, -t     Page load timeout in seconds (default:60)
        --fullpage, -f    Shoot the entire page not only the viewport (default: false)
        --mobile, -m      Enforces a mobile user agent (default: true)
        --version         Displays current version
        --help            Displays help

    Examples
        $ shooty https://google.com --every 1h
        $ shooty https://google.com --every 3h --start "10 Jul 2018 22:09:00 GMT+4" --stop "11 Jul 2018 22:09:00 GMT+4"
`, {
	flags: {
		output: {
			type: 'string',
			alias: 'o',
			default: '.'
        },
        start: {
			type: 'string'
        },
        stop: {
			type: 'string'
        },
        limit: {
			type: 'number',
            alias: 'l',
            default: 0
		},
		every: {
			type: 'string',
			alias: 'e',
			default: '1h'
        },
        timeout: {
			type: 'number',
			alias: 't',
			default: 60
		},
		mobile: {
			type: 'boolean',
			alias: 'm',
			default: true
		},
		fullpage: {
			type: 'boolean',
			alias: 'f',
			default: false
		}
	}
});

const error = (msg) => {
    console.error('\x1b[31m%s\x1b[0m',`\n  Error: ${msg}`);
    cli.showHelp()
}
const isValidUrl = (str) => {
pattern = new RegExp('^(https?:\/\/)');
return pattern.test(str)
}
const extractURL = (input) => {
    let url = input[0] || null;
    if(!url){
        error("you need to specify an URL");
    }
    if(!isValidUrl(url)){
        error("please introduce a valid URL");
    }
    return url;
}
const extractInterval = (time) => {
    if(!/^\d+[mhd]$/.test(flags.every)){
        error("only minutes (5m), hours (1h) and days (2d) are accepted.");
    }
    let letter = time.substr(time.length - 1);
    let number = parseInt(time.substr(0,time.length - 1));
    let multiplier = letter == 'm' && 60 || letter == 'h' && 60*60 || letter == 'd' && 60*60*24;
    return number*1000*multiplier;
}
const getSecondsToDate = (date) => {
    if(!date) return 0;
    let start = Date.parse(date);
    if(isNaN(start)){
        return error("you need to specify a valid date format that can be parsed.\n\n  Check: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/parse");
    }
    secondsToDate = start - (new Date().getTime());
    if(secondsToDate < 0){
        return error("you need to specify a future date");
    }
    return secondsToDate;
}
const shoot = async (url,flags) => {
    
    try{
        if(!browser)
            browser = await puppeteer.launch({ignoreHTTPSErrors:true});
        if(!page)
            page = await browser.newPage();

        page.setDefaultNavigationTimeout(flags.timeout*1000);
        if(flags.mobile){
            page.setUserAgent('Mozilla/5.0 (iPhone; CPU iPhone OS 6_0 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/6.0 Mobile/10A5376e Safari/8536.25');
        }

        let now = (new Date()).toLocaleTimeString();
        let name = `${flags.domain}_`+now.replace(/[:]/g,'-')+".png";
        
        console.log("Taking screenshot at:",now);

        await page.goto(url);
        let filename = path.format({dir:flags.o,base:name}).replace("//","/");
        await page.screenshot({path: filename, fullPage: flags.fullpage});
        removeImageByLimit(filename,flags.limit);
        console.log("Screenshot taken with name:",name);

    }catch(e){
        console.error('\x1b[31m%s\x1b[0m',`\n  ${e}`);
    }

};
function record(){
    interval_id = setInterval(shoot.bind(null,url,flags),interval);
    shoot(url,flags);
};

const Exit = (signal, err) => {
    if(browser){
        (async () => {
            await browser.close();
        })();
    }
    if(interval_id)
        clearInterval(interval_id);
    
    console.log('\x1b[32m%s\x1b[0m',`Stopped at ${(new Date()).toString()}.`);
};

onDie(Exit);

const flags = cli.flags;
const url = extractURL(cli.input);
const interval = extractInterval(flags.every);
flags.domain = urlx.parse(url).hostname;

console.log('\x1b[32m%s\x1b[0m',`Screenshot of ${flags.domain} every ${flags.every}`);
let boot = getSecondsToDate(flags.start);
if(boot > 0)
    console.log('\x1b[33m%s\x1b[0m',`Will start at ${flags.start}, in ${boot/1000} seconds`);

let finish = getSecondsToDate(flags.stop);
if(finish && finish-boot > 60){
    console.log('\x1b[33m%s\x1b[0m',`Will stop at ${flags.stop}, in ${finish/1000} seconds`);
    setTimeout(() => {
        Exit();
    },finish);
}
setTimeout(record,boot); // Start time