Bulk YouTube video uploads: Data API quotas and Studio automation

[
  {
    "uuid": "profile_UUID_1",
    "channel": "channel_name_1",
    "videos": [
      {
        "file": "file_path_1",
        "title": "YouTube_video_title",
        "description": "YouTube_video_description",
        "tags": ["tag1", "tag2"],
        "visibility": "PUBLIC"
      },
      {
        "file": "file_path_2",
        "title": "YouTube_video_title",
        "description": "YouTube_video_description",
        "tags": ["tag1", "tag2"],
        "visibility": "UNLISTED"
      }
    ]
  },
  {
    "uuid": "profile_UUID_2",
    "channel": "channel_name_2",
    "videos": [
      {
        "file": "file_path_3",
        "title": "YouTube_video_title",
        "description": "YouTube_video_description",
        "tags": ["tag1", "tag2"],
        "visibility": "PRIVATE"
      }
    ]
  }
]

const axios = require('axios');
const puppeteer = require('rebrowser-puppeteer');
const fs = require('fs').promises;
const path = require('path');


const config = {
    octo_local_api_base_url: 'http://localhost:58888/api/profiles',
    headless_mode: false,
    queue_file: 'upload_queue.json',
    results_dir: 'youtube_results',
    daily_limit_per_channel: 8,
    upload_timeout_min: 40,
    // These two pauses account for roughly 90% of the total run time.
    // Shortening them speeds things up but makes the pattern easier to
    // spot, so treat it as a risk decision rather than an optimization.
    delay_between_uploads: { min: 180, max: 420 },
    delay_between_profiles: { min: 120, max: 300 }
};


const MOD_KEY = process.platform === 'darwin' ? 'Meta' : 'Control';
const SELECTORS = {
    file: 'input[type="file"]',
    title: ['#title-textarea #textbox', 'ytcp-social-suggestions-textbox#title-textarea #textbox'],
    description: ['#description-textarea #textbox', 'ytcp-video-description #textbox'],
    tags_toggle: '#toggle-button',
    tags_input: '#tags-container input',
    not_for_kids: 'tp-yt-paper-radio-button[name="VIDEO_MADE_FOR_KIDS_NOT_MFK"]',
    next: '#next-button',
    done: '#done-button',
    progress: '.progress-label',
    dialogs: ['#close-button', 'ytcp-dialog #dismiss-button']
};


const random_range = (min, max) => min + Math.random() * (max - min);
const sleep = seconds => new Promise(r => setTimeout(r, seconds * 1000));
const human_delay = (min_ms = 80, max_ms = 300) => sleep(random_range(min_ms, max_ms) / 1000);


async function check_limits(response) {
    for (const entry of (response.headers.ratelimit || '').split(',')) {
        const left = entry.match(/;r=(\d+)/);
        const reset = entry.match(/;t=(\d+)/);
        if (left && reset && +left[1] < 5) {
            const wait = +reset[1] + 1;
            console.log(`⏳ Octo rate limit reached, waiting ${wait}s`);
            await sleep(wait);
        }
    }
}


async function octo_call(action, body) {
    const res = await axios.post(`${config.octo_local_api_base_url}/${action}`, body,
        { headers: { 'Content-Type': 'application/json' } });
    await check_limits(res);
    return res.data;
}


// Resolves all selectors in a single round trip instead of one call per
// selector: on a 0.5s poll that adds up over a long run.
async function wait_for_any(page, selectors, timeout = 30000) {
    const list = Array.isArray(selectors) ? selectors : [selectors];
    const started = Date.now();
    while (Date.now() - started < timeout) {
        const hit = await page.evaluate(sels => sels.find(s => {
            const el = document.querySelector(s);
            if (!el) return false;
            const r = el.getBoundingClientRect();
            return r.width > 0 && r.height > 0;
        }), list);
        if (hit) return await page.$(hit);
        await sleep(0.5);
    }
    throw new Error(`None of the selectors matched: ${list.join(' | ')}`);
}


async function type_into_box(page, handle, text) {
    await handle.click();
    await human_delay(200, 500);
    await page.keyboard.down(MOD_KEY);
    await page.keyboard.press('KeyA');
    await page.keyboard.up(MOD_KEY);
    await page.keyboard.press('Backspace');
    await human_delay(150, 400);
    for (const chunk of text.split(/(?<=\s)/)) {
        await page.keyboard.type(chunk, { delay: random_range(15, 55) });
        if (Math.random() < 0.15) await human_delay(200, 700);
    }
}


async function dismiss_dialogs(page) {
    for (const selector of SELECTORS.dialogs) {
        const handle = await page.$(selector);
        if (!handle) continue;
        await handle.click().catch(() => { });
        await human_delay(500, 1200);
    }
}


// Closes tabs we do not need. Studio opens some on its own, and Octo
// persists the session, so leftovers reappear on the next launch.
// Without `keep` the last surviving tab is parked on about:blank.
async function prune_tabs(browser, keep = null) {
    try {
        const pages = await browser.pages();
        const survivor = keep || pages[0];
        for (const p of pages) {
            if (p !== survivor) await p.close().catch(() => { });
        }
        if (!keep && survivor) {
            await survivor.goto('about:blank', { timeout: 15000 }).catch(() => { });
        }
    } catch (e) {
        console.log(`   ⚠️ Tab cleanup failed: ${e.message}`);
    }
}




async function wait_for_processing(page, timeout_min) {
    const deadline = Date.now() + timeout_min * 60 * 1000;
    let last_report = 0;
    while (Date.now() < deadline) {
        const percent = await page.evaluate(sel => {
            const el = document.querySelector(sel);
            const m = el && el.textContent.match(/(\d+)\s*%/);
            return m ? Number(m[1]) : null;
        }, SELECTORS.progress);
        // The percentage disappearing from the label means the upload is
        // done and Studio switched to its processing or checks message.
        if (percent === null || percent >= 100) return true;
        if (percent - last_report >= 10) {
            console.log(`   ⬆️ Uploaded ${percent}%`);
            last_report = percent;
        }
        await sleep(5);
    }
    return false;
}


async function fill_metadata(page, video) {
    const title_box = await wait_for_any(page, SELECTORS.title, 90000);
    await human_delay(1500, 3000);
    await type_into_box(page, title_box, video.title);
    console.log(`   ✏️ Title: ${video.title}`);


    if (video.description?.trim()) {
        const box = await wait_for_any(page, SELECTORS.description);
        await type_into_box(page, box, video.description);
        console.log('   📝 Description filled in');
    }


    if (video.tags?.length) {
        const toggle = await page.$(SELECTORS.tags_toggle);
        if (toggle) {
            await toggle.click();
            await human_delay(1000, 2000);
            const input = await page.$(SELECTORS.tags_input);
            if (input) {
                await input.click();
                for (const tag of video.tags) {
                    await page.keyboard.type(tag, { delay: random_range(20, 60) });
                    await page.keyboard.press('Comma');
                    await human_delay(300, 800);
                }
                console.log(`   🏷 Tags: ${video.tags.join(', ')}`);
            }
        }
    }


    const not_for_kids = await page.$(SELECTORS.not_for_kids);
    if (not_for_kids) {
        await not_for_kids.click();
        await human_delay(600, 1400);
    }
}


async function upload_one(page, video) {
    console.log(`\n🎬 ${path.basename(video.file)}`);


    await page.goto('https://www.youtube.com/upload', {
        waitUntil: 'domcontentloaded',
        timeout: 60000
    });
    await human_delay(2000, 4000);
    await dismiss_dialogs(page);


    const file_input = await page.waitForSelector(SELECTORS.file, { timeout: 45000 });
    await file_input.uploadFile(video.file);
    console.log('   📤 File handed to the input, waiting for the metadata dialog');


    await fill_metadata(page, video);


    // Three wizard steps: details, video elements, checks.
    for (let step = 0; step < 3; step++) {
        const next = await wait_for_any(page, SELECTORS.next);
        await next.click();
        await human_delay(1500, 3000);
    }


    const visibility = video.visibility || 'PRIVATE';
    const radio = await wait_for_any(page, `tp-yt-paper-radio-button[name="${visibility}"]`);
    await radio.click();
    console.log(`   👁 Visibility: ${visibility}`);
    await human_delay(1000, 2000);


    if (!await wait_for_processing(page, config.upload_timeout_min)) {
        console.log('   ⚠️ Processing timed out, the video stays a draft');
        return { file: video.file, success: false, reason: 'processing_timeout' };
    }


    const done = await wait_for_any(page, SELECTORS.done, 60000);
    await done.click();
    await human_delay(3000, 6000);


    await dismiss_dialogs(page);
    await prune_tabs(page.browser(), page);


    console.log('   ✅ Published');
    return { file: video.file, success: true, visibility };
}


async function process_profile(entry, index, total) {
    const line = '='.repeat(70);
    console.log(`\n${line}\n📋 Profile ${index + 1}/${total} — ${entry.channel} (${entry.uuid})`);
    console.log(`   Videos queued: ${entry.videos.length}\n${line}`);


    const stats = { channel: entry.channel, uuid: entry.uuid, status: 'ok', uploads: [] };


    await octo_call('stop', { uuid: entry.uuid }).catch(() => { });
    await sleep(3);


    let start_data;
    try {
        start_data = await octo_call('start', {
            uuid: entry.uuid,
            headless: config.headless_mode,
            debug_port: true,
            timeout: 120
        });
    } catch (e) {
        const body = e.response?.data ? JSON.stringify(e.response.data) : e.message;
        console.error(`❌ Profile failed to start: ${body}`);
        return { ...stats, status: 'start_failed' };
    }


    if (!start_data?.ws_endpoint) {
        console.error('❌ Octo returned no ws_endpoint');
        await octo_call('stop', { uuid: entry.uuid }).catch(() => { });
        return { ...stats, status: 'no_ws' };
    }


    let browser;
    try {
        browser = await puppeteer.connect({
            browserWSEndpoint: start_data.ws_endpoint,
            defaultViewport: null,
            protocolTimeout: 3600000
        });


        // The profile starts with a tab already open. Reuse it, otherwise
        // a second, empty one shows up next to it.
        const pages = await browser.pages();
        const page = pages[0] || await browser.newPage();
        await page.setViewport({ width: 1440, height: 900 });


        await page.goto('https://studio.youtube.com/', {
            waitUntil: 'domcontentloaded',
            timeout: 60000
        });
        await human_delay(1500, 2500);


        if (page.url().includes('accounts.google.com')) {
            console.error('❌ Profile is not signed in to Google');
            return { ...stats, status: 'not_logged_in' };
        }


        const limit = Math.min(entry.videos.length, config.daily_limit_per_channel);
        for (let i = 0; i < limit; i++) {
            try {
                stats.uploads.push(await upload_one(page, entry.videos[i]));
            } catch (e) {
                console.error(`❌ Upload error: ${e.message}`);
                stats.uploads.push({ file: entry.videos[i].file, success: false, reason: e.message });
            }
            if (i < limit - 1) {
                const pause = random_range(config.delay_between_uploads.min, config.delay_between_uploads.max);
                console.log(`⏰ Pause before the next video: ${Math.round(pause)}s`);
                await sleep(pause);
            }
        }


        if (entry.videos.length > limit) {
            console.log(`ℹ️ Left in the queue for tomorrow: ${entry.videos.length - limit}`);
        }
    } catch (e) {
        console.error(`❌ Profile processing error: ${e.message}`);
        stats.status = 'error';
        stats.error = e.message;
    } finally {
        if (browser) {
            await prune_tabs(browser);
            browser.disconnect();
        }
        await octo_call('stop', { uuid: entry.uuid }).catch(() => { });
        await sleep(2);
    }


    return stats;
}


// Validate the queue before launching a browser. An empty title or a wrong
// file path would otherwise pass silently: there is nothing to type, no
// error is raised, and the video lands on YouTube named after its file.
async function validate_queue(queue) {
    const VISIBILITY = ['PRIVATE', 'UNLISTED', 'PUBLIC'];
    if (!Array.isArray(queue) || !queue.length) return ['the queue is empty or is not an array'];


    const problems = [];
    for (const [i, entry] of queue.entries()) {
        const where = `entry ${i + 1} (${entry.channel || 'unnamed'})`;
        if (!entry.uuid) problems.push(`${where}: no profile uuid`);
        if (!Array.isArray(entry.videos) || !entry.videos.length) {
            problems.push(`${where}: no videos at all`);
            continue;
        }


        for (const [j, video] of entry.videos.entries()) {
            const at = `${where}, video ${j + 1}`;
            const readable = video.file && await fs.access(video.file).then(() => true, () => false);


            if (!video.file) problems.push(`${at}: no file path`);
            else if (!readable) problems.push(`${at}: file not found — ${video.file}`);


            if (!video.title?.trim()) problems.push(`${at}: empty title`);
            else if (video.title.length > 100) problems.push(`${at}: title over 100 chars (${video.title.length})`);


            if (video.description?.length > 5000) problems.push(`${at}: description over 5000 chars`);
            if (video.visibility && !VISIBILITY.includes(video.visibility)) {
                problems.push(`${at}: visibility "${video.visibility}", allowed: ${VISIBILITY.join(', ')}`);
            }
        }
    }
    return problems;
}


(async () => {
    console.log('🚀 Octo YouTube Bulk Uploader');


    const queue = JSON.parse(await fs.readFile(path.join(__dirname, config.queue_file), 'utf8'));
    const problems = await validate_queue(queue);
    if (problems.length) {
        console.error(`\n❌ Queue validation failed (${problems.length}):`);
        for (const p of problems) console.error(`   • ${p}`);
        console.error('\nFix the queue and run again. No browser was launched.');
        process.exit(1);
    }


    const total_videos = queue.reduce((sum, e) => sum + e.videos.length, 0);
    console.log(`   ✅ Queue validated — ${queue.length} channels, ${total_videos} videos`);
    console.log(`   Per-channel limit for this run: ${config.daily_limit_per_channel}\n`);


    const results_dir = path.join(__dirname, config.results_dir);
    await fs.mkdir(results_dir, { recursive: true });


    const all_stats = [];
    for (let i = 0; i < queue.length; i++) {
        all_stats.push(await process_profile(queue[i], i, queue.length));
        if (i < queue.length - 1) {
            const pause = random_range(config.delay_between_profiles.min, config.delay_between_profiles.max);
            console.log(`\n⏰ Pause before the next profile: ${Math.round(pause)}s`);
            await sleep(pause);
        }
    }


    console.log(`\n${'='.repeat(70)}\n📊 SUMMARY\n${'='.repeat(70)}`);
    for (const s of all_stats) {
        const ok = s.uploads.filter(u => u.success).length;
        console.log(`\n${s.channel} → ${s.status}, succeeded ${ok}/${s.uploads.length}`);
        for (const u of s.uploads) {
            console.log(u.success
                ? `   ✅ ${path.basename(u.file)} → ${u.visibility}`
                : `   ❌ ${path.basename(u.file)}: ${u.reason}`);
        }
    }


    const report_path = path.join(results_dir, `report_${Date.now()}.json`);
    await fs.writeFile(report_path, JSON.stringify(all_stats, null, 2), 'utf8');
    console.log(`\n📄 Report: ${report_path}\n🎉 Done.`);
})();