@mogulmoretti/skrape 0.1.0 → 0.2.1

package/README.md

@@ -3,7 +3,7 @@
 Read Skool course content instead of watching it.
 
 `skrape` pulls the classroom of a Skool community **you already pay for and
-belong to**, and writes clean, readable, timestamped transcripts to disk —
+belong to**, and writes clean, readable, timestamped transcripts to disk,
 so you can read a lesson in two minutes instead of watching a 20-minute video.
 
 It works because Skool ships the whole course tree as structured data inside
@@ -15,13 +15,13 @@ that isn't already sitting on the page you're allowed to see.
 
 **This is a personal tool for your own communities.** It signs in as *you*,
 using *your* real browser session, and only ever touches courses your account
-already has access to — it can't and won't bypass Skool's own paywall or
+already has access to. It can't and won't bypass Skool's own paywall or
 membership checks.
 
 Automating access to a platform like this generally sits outside most
 platforms' terms of service, even when you're a legitimate paying member and
 even when nothing is being redistributed. Running this is a decision about
-your own account, and it's yours to make — this tool doesn't make it for you,
+your own account, and it's yours to make. This tool doesn't make it for you,
 and it doesn't hide what it's doing (see [How it works](#how-it-works)).
 Don't use it on communities you don't belong to, don't share or republish
 what it produces, and don't run it in a way designed to look like normal
@@ -39,33 +39,49 @@ one-time, ~150MB download) if it isn't already on your machine, then walks
 you through everything:
 
 1. Checks whether you're signed in, and if not, opens a real Chrome window for
-   you to sign in yourself — nothing is typed on your behalf, and your
+   you to sign in yourself. Nothing is typed on your behalf, and your
    password never passes through this tool.
 2. Looks up the communities your account belongs to and lets you pick one
    with the arrow keys (an "enter a slug manually" option is always there
    too, in case discovery doesn't find one).
-3. Shows you what's about to happen — the community, how many courses were
-   found, where files will land — and waits for you to confirm before any
-   work starts.
+3. Shows you what's about to happen (the community, how many courses were
+   found, where files will land) and waits for you to confirm before any
+   work starts. Pick **Transcripts** or **Transcripts + videos**.
 4. Runs the sync with a live progress bar. You can Ctrl+C at any point; it
    cleans up after itself.
 5. Prints a summary: outcome counts, total words, the output path, and a
-   readable list of anything that wasn't transcribed and why — nothing is
+   readable list of anything that wasn't transcribed and why. Nothing is
    silently dropped from the count.
 
 From there you can sync another community, re-sync the same one (it's
-incremental — already-fetched lessons are skipped), open the output folder,
+incremental: already-fetched lessons are skipped), open the output folder,
 or quit.
 
-Output lands in `./out/<slug>/transcripts/<course>/NN-lesson.md`.
+Output lands in `~/skrape/<slug>/transcripts/<course>/NN-lesson.md`, and videos
+(if you asked for them) in `~/skrape/<slug>/videos/<course>/NN-lesson.mp4`,
+wherever you run skrape from.
+
+### Downloading videos
+
+Video downloads are opt-in and use [yt-dlp](https://github.com/yt-dlp/yt-dlp),
+which you install once yourself:
+
+    brew install yt-dlp ffmpeg      # macOS; see yt-dlp's docs for other platforms
+
+skrape hands each lesson's video link to yt-dlp, which covers Loom, YouTube,
+Vimeo, Wistia and most other hosts. A video that's already on disk is skipped,
+so re-running a sync only fetches what's missing. Videos are big (a 20-minute
+Loom lesson is ~150MB), so check your free disk space before pulling a whole
+community.
 
 ### Scripting / advanced use
 
 The underlying subcommands work directly too, without the guided flow:
 
-    skrape login                     # once — sign in by hand, session persists
+    skrape login                     # once: sign in by hand, session persists
     skrape sync <slug>                # slug is the part after skool.com/
-    skrape sync <slug> -o ./out -c 4  # custom output dir / concurrency
+    skrape sync <slug> -o ~/notes -c 4  # custom output dir / concurrency
+    skrape sync <slug> --videos       # transcripts + every lesson video
 
 ### Building from source
 
@@ -79,7 +95,7 @@ The underlying subcommands work directly too, without the guided flow:
 
 ## How it works
 
-Skool ships the full course tree as JSON inside each classroom page — no
+Skool ships the full course tree as JSON inside each classroom page, with no
 clicking through lesson by lesson. `skrape` reads that structure the way any
 browser or crawler would: an authenticated request to a page your account
 can already open.
@@ -89,8 +105,8 @@ moment). Where a caption track exists, it's downloaded and cleaned into
 readable prose with timestamp anchors. Where one doesn't, the lesson is
 reported as not transcribed rather than silently skipped.
 
-When a page doesn't come back with the data the tool expects — an expired
-session, or Skool changing how a page is built — it falls back to driving an
+When a page doesn't come back with the data the tool expects (an expired
+session, or Skool changing how a page is built), it falls back to driving an
 actual browser window using your already-authenticated profile, rather than
 guessing or failing silently.
 
@@ -100,18 +116,22 @@ run the command.
 
 ## What this doesn't do
 
-- Doesn't work on communities you're not a member of — there's no bypass for
+- Doesn't work on communities you're not a member of. There's no bypass for
   Skool's own access checks, because none of the data is reachable without
   them.
 - Doesn't redistribute or publish anything. Output is written to your local
   disk for you to read.
 - Doesn't store your password. Sign-in happens in a real Chrome window that
   only you interact with.
+- Doesn't download videos unless you ask it to (`--videos`, or **Transcripts + videos**
+  in the guided flow).
+- Doesn't download lesson `resources`: those are links to outside docs
+  (Google Docs, etc.), not files hosted on Skool.
 - Doesn't transcribe video hosts it doesn't recognize. Those lessons show up
   in the summary as not transcribed, with a reason.
 
 ## License
 
-MIT — see [LICENSE](LICENSE). In short: do what you like with the code, no
+MIT. See [LICENSE](LICENSE). In short: do what you like with the code, no
 warranty, use it at your own risk and your own judgment about the platforms
 you point it at.

package/dist/auth/session.d.ts

@@ -1,4 +1,6 @@
 export declare function profileDir(): string;
+/** Where synced communities land unless -o says otherwise: one fixed place, whatever the cwd. */
+export declare function defaultOutRoot(): string;
 export declare function dbPath(): string;
 /**
  * Marker file written once the one-time Chrome/Playwright browser install
@@ -6,6 +8,12 @@ export declare function dbPath(): string;
  * Its presence lets later runs skip re-probing with a real browser launch.
  */
 export declare function chromeMarkerPath(): string;
+/** Launch the browser first-run setup confirmed; before any setup ran, assume the user's Chrome. */
+export declare function browserLaunchOptions(): {
+    executablePath: string;
+} | {
+    channel: string;
+};
 export declare function ensureRoot(): Promise<void>;
 export declare function isLoggedIn(html: string): boolean;
 /** A handle callers can use to force-close a launched login context, e.g. on Ctrl+C. */

package/dist/auth/session.js

@@ -2,10 +2,15 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { mkdir } from 'node:fs/promises';
 import { extractNextData, PayloadParseError } from '../fetch/nextdata.js';
+import { markedExecutablePath } from '../fetch/chromeSetup.js';
 const ROOT = join(homedir(), '.skool-skrape');
 export function profileDir() {
     return join(ROOT, 'chrome-profile');
 }
+/** Where synced communities land unless -o says otherwise: one fixed place, whatever the cwd. */
+export function defaultOutRoot() {
+    return join(homedir(), 'skrape');
+}
 export function dbPath() {
     return join(ROOT, 'skool.db');
 }
@@ -17,6 +22,11 @@ export function dbPath() {
 export function chromeMarkerPath() {
     return join(ROOT, 'chrome-installed');
 }
+/** Launch the browser first-run setup confirmed; before any setup ran, assume the user's Chrome. */
+export function browserLaunchOptions() {
+    const executablePath = markedExecutablePath(chromeMarkerPath());
+    return executablePath ? { executablePath } : { channel: 'chrome' };
+}
 export async function ensureRoot() {
     await mkdir(ROOT, { recursive: true });
 }
@@ -46,14 +56,12 @@ export async function login(onContext) {
     await ensureRoot();
     const { chromium } = await import('playwright');
     const context = await chromium.launchPersistentContext(profileDir(), {
-        channel: 'chrome',
+        ...browserLaunchOptions(),
         headless: false,
     });
     onContext?.(context);
     const page = context.pages()[0] ?? (await context.newPage());
     await page.goto('https://www.skool.com/login', { waitUntil: 'domcontentloaded' });
-    console.log('\nA browser window is open. Sign in to Skool there.');
-    console.log('Waiting for you to reach a logged-in page (Ctrl+C to cancel)...\n');
     await page.waitForFunction(() => {
         const el = document.getElementById('__NEXT_DATA__');
         if (!el?.textContent)
@@ -65,6 +73,5 @@ export async function login(onContext) {
             return false;
         }
     }, undefined, { timeout: 0 });
-    console.log('Signed in. Session saved — future runs will not need this.');
     await context.close();
 }

package/dist/cli.js

@@ -1,14 +1,19 @@
 #!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { join, resolve } from 'node:path';
+import { styleText } from 'node:util';
 import { Command } from 'commander';
 import { HttpFetcher } from './fetch/http.js';
 import { BrowserFetcher } from './fetch/browser.js';
 import { ResilientFetcher } from './fetch/resilient.js';
 import { openDb } from './store/db.js';
 import { syncClassroom } from './sync.js';
-import { login, profileDir, dbPath, ensureRoot, isLoggedIn } from './auth/session.js';
-const MARKS = {
-    ok: '+', skipped: '=', 'no-video': '.', 'no-access': '-', unavailable: '!', failed: 'x',
-};
+import { formatSummary } from './tui/summary.js';
+import { OUTCOME_STYLE, displayPath, formatDuration } from './tui/theme.js';
+import { login, profileDir, dbPath, defaultOutRoot, ensureRoot, isLoggedIn } from './auth/session.js';
+// Color only for a human at a terminal; pipes and NO_COLOR get plain text.
+const useColor = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+const paint = (color, text) => (useColor ? styleText(color, text) : text);
 const MAX_CONCURRENCY = 16;
 /** Parse the --concurrency flag to a positive integer, or return null if invalid. */
 function parseConcurrency(raw) {
@@ -18,19 +23,27 @@ function parseConcurrency(raw) {
     return Math.min(n, MAX_CONCURRENCY);
 }
 const program = new Command();
-program.name('skrape').description('Read Skool content instead of watching it');
+const { version } = createRequire(import.meta.url)('../package.json');
+program
+    .name('skrape')
+    .description('Read Skool course content instead of watching it')
+    .version(version, '-v, --version')
+    .addHelpText('after', '\nRun `skrape` with no arguments for the guided, interactive flow.');
 program
     .command('login')
     .description('Sign in to Skool once; the session is reused by later runs')
     .action(async () => {
+    console.log('A browser window is opening. Sign in to Skool there (Ctrl+C to cancel)…');
     await login();
+    console.log(`${paint('green', '✓')} Signed in. Future runs reuse this session.`);
 });
 program
     .command('sync')
     .argument('<slug>', 'community slug, e.g. demo from skool.com/demo')
-    .option('-o, --out <dir>', 'output directory', './out')
+    .option('-o, --out <dir>', 'output directory', defaultOutRoot())
     .option('-c, --concurrency <n>', 'parallel requests', '4')
-    .description('Pull a community classroom to disk as transcripts')
+    .option('--videos', 'also download every lesson video (needs yt-dlp)')
+    .description('Pull a community classroom to disk as transcripts (and optionally videos)')
     .action(async (slug, options) => {
     const concurrency = parseConcurrency(options.concurrency);
     if (concurrency === null) {
@@ -40,10 +53,12 @@ program
         return;
     }
     await ensureRoot();
-    const outDir = `${options.out}/${slug}`;
+    const outDir = join(resolve(options.out), slug);
     const db = openDb(dbPath());
     const browser = new BrowserFetcher(profileDir());
     const fetcher = new ResilientFetcher(new HttpFetcher(), async () => browser, isLoggedIn);
+    const startedAt = Date.now();
+    console.log(`${paint('bold', '◆ skrape')} ${paint('dim', `syncing skool.com/${slug}${options.videos ? ' · with videos' : ''}`)}\n`);
     try {
         const summary = await syncClassroom({
             slug,
@@ -51,39 +66,35 @@ program
             db,
             fetcher,
             concurrency,
+            videos: options.videos,
             onProgress: (event) => {
-                const mark = MARKS[event.outcome] ?? '?';
-                console.log(`${mark} [${event.done}/${event.total}] ${event.course.slice(0, 28).padEnd(28)} ${event.title.slice(0, 50)}`);
+                const style = OUTCOME_STYLE[event.outcome];
+                const counter = `${event.done}/${event.total}`.padStart(String(event.total).length * 2 + 1);
+                console.log(`${paint(style.color, style.icon)} ${paint('dim', counter)}  ${paint('dim', `${event.course.slice(0, 28)} ›`)} ${event.title.slice(0, 60)}`);
             },
         });
-        console.log('\n--- summary ---');
-        for (const [outcome, count] of Object.entries(summary.counts)) {
-            if (count > 0)
-                console.log(`  ${outcome.padEnd(14)} ${count}`);
-        }
-        console.log(`  ${'words'.padEnd(14)} ${summary.totalWords.toLocaleString('en-US')}`);
+        console.log('');
+        for (const line of formatSummary(summary, displayPath(outDir), paint))
+            console.log(line);
+        console.log(paint('dim', `Finished in ${formatDuration(Date.now() - startedAt)}`));
         if (fetcher.escalatedRoutes.size > 0) {
-            console.log(`\n  escalated to browser: ${[...fetcher.escalatedRoutes].join(', ')}`);
-        }
-        if (summary.problems.length > 0) {
-            console.log('\n--- not transcribed ---');
-            for (const problem of summary.problems) {
-                console.log(`  [${problem.outcome}] ${problem.course} / ${problem.title}: ${problem.reason}`);
-            }
+            console.log(paint('dim', `Escalated to browser: ${[...fetcher.escalatedRoutes].join(', ')}`));
         }
-        console.log(`\nOutput: ${outDir}`);
     }
     catch (error) {
-        console.error(`\nSync failed: ${error.message}`);
-        if (fetcher.escalatedRoutes.size > 0) {
+        console.error(`\n${paint('red', '✗ Sync failed:')} ${error.message}`);
+        if (error.message.includes('HTTP 404')) {
+            console.error(`No classroom at skool.com/${slug}. Check the slug (the part after skool.com/).`);
+        }
+        else if (fetcher.escalatedRoutes.size > 0) {
             console.error(`\n  escalated to browser: ${[...fetcher.escalatedRoutes].join(', ')}`);
             console.error('If this mentions an unexpected payload, the authenticated browser path was already tried ' +
                 "for the route(s) above, so Skool's page structure most likely changed rather than the " +
-                'session being expired. A fresh `skool login` is still worth trying, but treat it as a ' +
+                'session being expired. A fresh `skrape login` is still worth trying, but treat it as a ' +
                 'secondary guess.');
         }
         else {
-            console.error('If this mentions an unexpected payload, your session may have expired — run: skool login. ' +
+            console.error('If this mentions an unexpected payload, your session may have expired. Run: skrape login. ' +
                 "It is also possible Skool's page structure changed; if a retry after login fails the same " +
                 'way, that is more likely.');
         }

package/dist/fetch/browser.js

@@ -1,3 +1,4 @@
+import { browserLaunchOptions } from '../auth/session.js';
 /**
  * Playwright-backed fallback. Playwright is imported dynamically so that users
  * who never hit the fallback never pay its startup cost — and so the package
@@ -13,14 +14,14 @@ export class BrowserFetcher {
     }
     async ensureContext() {
         if (this.closed) {
-            throw new Error('BrowserFetcher is closed — cannot open a new context after close()');
+            throw new Error('BrowserFetcher is closed, cannot open a new context after close()');
         }
         if (!this.context) {
             try {
                 this.contextPromise ??= (async () => {
                     const { chromium } = await import('playwright');
                     return await chromium.launchPersistentContext(this.profileDir, {
-                        channel: 'chrome',
+                        ...browserLaunchOptions(),
                         headless: true,
                     });
                 })();

package/dist/fetch/chromeSetup.d.ts

@@ -15,6 +15,8 @@
  * A missing/unreadable/empty marker is just treated as "not installed".
  */
 export declare function isChromeMarkedInstalled(markerPath: string): boolean;
+/** The browser executable a past run confirmed, if the marker exists and that path still does. */
+export declare function markedExecutablePath(markerPath: string): string | null;
 /** Records the confirmed Chrome executable's path, so later runs can skip
  *  the probe by cheaply checking that path still exists on disk. */
 export declare function markChromeInstalled(markerPath: string, executablePath: string): Promise<void>;
@@ -37,6 +39,8 @@ export declare function markChromeInstalled(markerPath: string, executablePath:
  * run) never pays Playwright's module-load cost at all.
  */
 export declare function probeChromeLaunchable(): Promise<string | undefined>;
+/** Which browser to install when none is launchable: Chrome where that needs no root, Chromium on Linux. */
+export declare const INSTALL_TARGET: string;
 /**
  * Runs the equivalent of `npx playwright install chrome` in-process, by
  * spawning Playwright's own bundled CLI script directly. Preferred over

package/dist/fetch/chromeSetup.js

@@ -20,16 +20,20 @@ import { fileURLToPath } from 'node:url';
  * A missing/unreadable/empty marker is just treated as "not installed".
  */
 export function isChromeMarkedInstalled(markerPath) {
+    return markedExecutablePath(markerPath) !== null;
+}
+/** The browser executable a past run confirmed, if the marker exists and that path still does. */
+export function markedExecutablePath(markerPath) {
     if (!existsSync(markerPath))
-        return false;
+        return null;
     let storedPath;
     try {
         storedPath = readFileSync(markerPath, 'utf8').trim();
     }
     catch {
-        return false;
+        return null;
     }
-    return storedPath.length > 0 && existsSync(storedPath);
+    return storedPath.length > 0 && existsSync(storedPath) ? storedPath : null;
 }
 /** Records the confirmed Chrome executable's path, so later runs can skip
  *  the probe by cheaply checking that path still exists on disk. */
@@ -55,20 +59,36 @@ export async function markChromeInstalled(markerPath, executablePath) {
  * run) never pays Playwright's module-load cost at all.
  */
 export async function probeChromeLaunchable() {
+    let chromium;
     try {
-        const { chromium } = await import('playwright');
-        const server = await chromium.launchServer({ channel: 'chrome', headless: true });
-        try {
-            return server.process().spawnfile;
-        }
-        finally {
-            await server.close();
-        }
+        ({ chromium } = await import('playwright'));
     }
     catch {
         return undefined;
     }
+    // Prefer the user's real Chrome; fall back to Playwright's own Chromium (what gets
+    // installed on Linux, where installing Chrome itself needs root).
+    const candidates = [{ channel: 'chrome' }];
+    if (existsSync(chromium.executablePath()))
+        candidates.push({ executablePath: chromium.executablePath() });
+    for (const options of candidates) {
+        try {
+            const server = await chromium.launchServer({ ...options, headless: true });
+            try {
+                return server.process().spawnfile;
+            }
+            finally {
+                await server.close();
+            }
+        }
+        catch {
+            // try the next candidate
+        }
+    }
+    return undefined;
 }
+/** Which browser to install when none is launchable: Chrome where that needs no root, Chromium on Linux. */
+export const INSTALL_TARGET = process.platform === 'linux' ? 'chromium' : 'chrome';
 /** Resolves the on-disk path to Playwright's own bundled CLI script, via the
  *  package's exported `./package.json` subpath (not `./cli.js`, which isn't
  *  in Playwright's `exports` map and so can't be resolved directly) — this
@@ -94,7 +114,7 @@ async function resolvePlaywrightCliPath() {
 export async function installChromeViaCli(onProgress) {
     const cliPath = await resolvePlaywrightCliPath();
     await new Promise((resolve, reject) => {
-        const child = spawn(process.execPath, [cliPath, 'install', 'chrome'], {
+        const child = spawn(process.execPath, [cliPath, 'install', INSTALL_TARGET], {
             stdio: ['ignore', 'pipe', 'pipe'],
         });
         let stdout = '';

package/dist/media/download.d.ts

@@ -0,0 +1,12 @@
+export declare function hasYtDlp(): Promise<boolean>;
+export type DownloadResult = {
+    status: 'downloaded' | 'exists';
+} | {
+    status: 'failed';
+    reason: string;
+};
+/**
+ * Download one lesson video to `destPath` (an .mp4). An existing file is treated as complete:
+ * yt-dlp writes to a .part file and only renames on success, so a partial never lands at destPath.
+ */
+export declare function downloadVideo(videoUrl: string, destPath: string): Promise<DownloadResult>;

package/dist/media/download.js

@@ -0,0 +1,54 @@
+import { spawn } from 'node:child_process';
+import { access, mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+/** Run yt-dlp, resolving with its exit code and the tail of stderr. Never rejects on a bad exit. */
+function run(args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.env.SKRAPE_YT_DLP ?? 'yt-dlp', args, { stdio: ['ignore', 'ignore', 'pipe'] });
+        let stderr = '';
+        child.stderr.on('data', (chunk) => {
+            stderr = (stderr + chunk.toString()).slice(-2000);
+        });
+        child.on('error', reject);
+        child.on('close', (code) => resolve({ code: code ?? 1, stderr }));
+    });
+}
+export async function hasYtDlp() {
+    try {
+        return (await run(['--version'])).code === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Download one lesson video to `destPath` (an .mp4). An existing file is treated as complete:
+ * yt-dlp writes to a .part file and only renames on success, so a partial never lands at destPath.
+ */
+export async function downloadVideo(videoUrl, destPath) {
+    try {
+        await access(destPath);
+        return { status: 'exists' };
+    }
+    catch {
+        // not there yet — download it
+    }
+    await mkdir(dirname(destPath), { recursive: true });
+    try {
+        const { code, stderr } = await run([
+            '--quiet', '--no-progress', '--no-playlist',
+            '--referer', 'https://www.skool.com/',
+            '--merge-output-format', 'mp4', '--remux-video', 'mp4',
+            // Let yt-dlp pick the source extension; --remux-video lands the final file at destPath.
+            '-o', destPath.replace(/\.mp4$/, '.%(ext)s'),
+            videoUrl,
+        ]);
+        if (code === 0)
+            return { status: 'downloaded' };
+        const lastError = stderr.split('\n').filter((line) => line.includes('ERROR')).pop();
+        return { status: 'failed', reason: (lastError ?? stderr.trim().split('\n').pop() ?? `yt-dlp exit ${code}`).trim() };
+    }
+    catch (error) {
+        return { status: 'failed', reason: error.message };
+    }
+}

package/dist/store/markdown.d.ts

@@ -1,6 +1,7 @@
 import type { ContentItem } from '../types.js';
 export declare function slugify(text: string, maxLength?: number): string;
 export declare function transcriptPath(outDir: string, item: ContentItem, padWidth?: number): string;
+export declare function videoPath(outDir: string, item: ContentItem, padWidth?: number): string;
 export declare function writeTranscript(outDir: string, item: ContentItem, body: string, meta: {
     wordCount: number;
     sourceUrl: string;

package/dist/store/markdown.js

@@ -12,18 +12,24 @@ export function slugify(text, maxLength = 60) {
         .replace(/-+$/g, '');
     return cleaned || 'untitled';
 }
-export function transcriptPath(outDir, item, padWidth = 2) {
+function lessonPath(outDir, kind, ext, item, padWidth) {
     const course = slugify(item.course ?? 'uncategorized');
     const width = Math.max(2, padWidth);
-    const name = `${String(item.index).padStart(width, '0')}-${slugify(item.title)}.md`;
-    return join(outDir, 'transcripts', course, name);
+    const name = `${String(item.index).padStart(width, '0')}-${slugify(item.title)}.${ext}`;
+    return join(outDir, kind, course, name);
+}
+export function transcriptPath(outDir, item, padWidth = 2) {
+    return lessonPath(outDir, 'transcripts', 'md', item, padWidth);
+}
+export function videoPath(outDir, item, padWidth = 2) {
+    return lessonPath(outDir, 'videos', 'mp4', item, padWidth);
 }
 export async function writeTranscript(outDir, item, body, meta, padWidth = 2) {
     const path = transcriptPath(outDir, item, padWidth);
     await mkdir(dirname(path), { recursive: true });
     const minutes = Math.round(item.durationMs / 60_000);
     const cleanTitle = item.title.replace(/\s+/g, ' ');
-    const cleanCourse = (item.course ?? '—').replace(/\s+/g, ' ');
+    const cleanCourse = (item.course ?? '-').replace(/\s+/g, ' ');
     const cleanSection = item.section?.replace(/\s+/g, ' ');
     const header = [
         `# ${cleanTitle}`,

package/dist/sync.d.ts

@@ -18,6 +18,13 @@ export interface SyncSummary {
     counts: Record<Outcome, number>;
     problems: Problem[];
     totalWords: number;
+    /** Present only when the sync was asked to download videos. */
+    videos?: VideoCounts;
+}
+export interface VideoCounts {
+    downloaded: number;
+    existing: number;
+    failed: number;
 }
 export interface SyncOptions {
     slug: string;
@@ -25,6 +32,8 @@ export interface SyncOptions {
     db: Db;
     fetcher: Fetcher;
     concurrency?: number;
+    /** Also download each lesson's video (needs yt-dlp on PATH). */
+    videos?: boolean;
     onProgress?: (event: ProgressEvent) => void;
 }
 export declare function syncClassroom(options: SyncOptions): Promise<SyncSummary>;

package/dist/sync.js

@@ -1,6 +1,8 @@
 import { listCourses, listLessons } from './discover/skool.js';
 import { getTranscript } from './media/index.js';
-import { writeTranscript } from './store/markdown.js';
+import { downloadVideo, hasYtDlp } from './media/download.js';
+import { existsSync } from 'node:fs';
+import { transcriptPath, videoPath, writeTranscript } from './store/markdown.js';
 /** Run tasks with a bounded number in flight. */
 async function pooled(tasks, limit) {
     const results = new Array(tasks.length);
@@ -31,7 +33,12 @@ function errorMessage(error) {
     }
 }
 export async function syncClassroom(options) {
-    const { slug, outDir, db, fetcher, concurrency = 4, onProgress } = options;
+    const { slug, outDir, db, fetcher, concurrency = 4, videos = false, onProgress } = options;
+    if (videos && !(await hasYtDlp())) {
+        throw new Error('Video downloads need yt-dlp, which was not found on your PATH. ' +
+            'Install it (macOS: brew install yt-dlp ffmpeg; others: https://github.com/yt-dlp/yt-dlp#installation) and try again.');
+    }
+    const videoCounts = videos ? { downloaded: 0, existing: 0, failed: 0 } : undefined;
     const counts = {
         ok: 0, skipped: 0, 'no-video': 0, 'no-access': 0, unavailable: 0, failed: 0,
     };
@@ -44,7 +51,7 @@ export async function syncClassroom(options) {
         counts['no-access']++;
         problems.push({
             outcome: 'no-access', course: locked.title, title: '(entire course)',
-            reason: 'hasAccess is 0 — not entitled, skipped without probing',
+            reason: 'hasAccess is 0, not entitled, skipped without probing',
         });
     }
     // One course's listing failing (network blip, malformed payload) must not take down the whole
@@ -90,12 +97,12 @@ export async function syncClassroom(options) {
     const record = (outcome, item, reason) => {
         counts[outcome]++;
         if (reason) {
-            problems.push({ outcome, course: item.course ?? '—', title: item.title, reason });
+            problems.push({ outcome, course: item.course ?? '-', title: item.title, reason });
         }
         done++;
         // Progress reporting is cosmetic. A caller's callback throwing must never fail the sync.
         try {
-            onProgress?.({ outcome, course: item.course ?? '—', title: item.title, done, total });
+            onProgress?.({ outcome, course: item.course ?? '-', title: item.title, done, total });
         }
         catch {
             // swallow — the caller's callback is not our concern
@@ -129,6 +136,20 @@ export async function syncClassroom(options) {
             return record('no-access', item, 'lesson locked');
         if (!item.videoUrl)
             return record('no-video', item, 'lesson has no video attached');
+        // Download before the transcript step so an already-transcribed lesson still gets its video.
+        if (videoCounts) {
+            const download = await downloadVideo(item.videoUrl, videoPath(outDir, item, padWidth));
+            if (download.status === 'failed') {
+                videoCounts.failed++;
+                problems.push({
+                    outcome: 'failed', course: item.course ?? '-', title: item.title,
+                    reason: `video download: ${download.reason}`,
+                });
+            }
+            else {
+                videoCounts[download.status === 'downloaded' ? 'downloaded' : 'existing']++;
+            }
+        }
         let status;
         try {
             status = db.getTranscriptStatus(id);
@@ -136,7 +157,8 @@ export async function syncClassroom(options) {
         catch (error) {
             return record('failed', item, `could not read transcript status: ${errorMessage(error)}`);
         }
-        if (status === 'ok')
+        // 'ok' in the db only means it was written *somewhere*; skip only when the file is in this outDir.
+        if (status === 'ok' && existsSync(transcriptPath(outDir, item, padWidth)))
             return record('skipped', item);
         let result;
         try {
@@ -174,5 +196,5 @@ export async function syncClassroom(options) {
         return record(result.status, item, result.reason);
     }), concurrency);
     db.markSynced(slug);
-    return { counts, problems, totalWords };
+    return { counts, problems, totalWords, videos: videoCounts };
 }

package/dist/tui/App.d.ts

@@ -2,13 +2,15 @@ import React from 'react';
 import type { CommunityRef } from '../discover/communities.js';
 import type { ProgressEvent, SyncSummary } from '../sync.js';
 export interface AppControllers {
-    /** Output root directory, e.g. './out' — the community slug is appended. */
+    /** Absolute output root, e.g. ~/skrape; the community slug is appended. */
     outRoot: string;
     checkLoggedIn: () => Promise<boolean>;
     login: () => Promise<void>;
     discoverCommunities: () => Promise<CommunityRef[] | null>;
     countAccessibleCourses: (slug: string) => Promise<number>;
-    runSync: (slug: string, outDir: string, onProgress: (event: ProgressEvent) => void) => Promise<SyncSummary>;
+    /** Checked when the user picks videos, so installing it in another terminal works without a restart. */
+    hasYtDlp: () => Promise<boolean>;
+    runSync: (slug: string, outDir: string, onProgress: (event: ProgressEvent) => void, videos: boolean) => Promise<SyncSummary>;
 }
 /**
  * Caps error text shown in the TUI. Some failures (e.g. a raw Playwright

package/dist/tui/App.js

@@ -3,7 +3,8 @@ import React from 'react';
 import { Box, Text, useApp, useInput } from 'ink';
 import { SelectList } from './SelectList.js';
 import { applyProgress, createProgressState, formatProgressBar } from './progress.js';
-import { formatSummary } from './summary.js';
+import { formatVideoLine, nothingTranscribed, sortedProblems } from './summary.js';
+import { ACCENT, OUTCOME_STYLE, displayPath, estimateRemainingMs, formatDuration } from './theme.js';
 import { isValidSlug, normalizeSlug } from './slug.js';
 import { MENU_ITEMS, nextStepForMenuChoice } from './flow.js';
 import { revealOutputFolder } from './reveal.js';
@@ -35,8 +36,46 @@ function ConfirmPrompt({ onConfirm }) {
         else if (input === 'q' || key.escape)
             exit();
     });
-    return _jsx(Text, { dimColor: true, children: "[enter] continue    [q] quit" });
+    return _jsx(Text, { dimColor: true, children: "enter continue \u00B7 q quit" });
 }
+function Header() {
+    return (_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { color: ACCENT, bold: true, children: "\u25C6 skrape" }), _jsx(Text, { dimColor: true, children: "  read the course, skip the video" })] }));
+}
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+function Spinner({ label }) {
+    const [frame, setFrame] = React.useState(0);
+    React.useEffect(() => {
+        const timer = setInterval(() => setFrame((current) => (current + 1) % SPINNER_FRAMES.length), 80);
+        return () => clearInterval(timer);
+    }, []);
+    return (_jsxs(Text, { children: [_jsx(Text, { color: ACCENT, children: SPINNER_FRAMES[frame] }), " ", label] }));
+}
+/** Label/value rows inside a rounded card, labels aligned. */
+function Card({ rows }) {
+    const width = Math.max(...rows.map(([label]) => label.length));
+    return (_jsx(Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, alignSelf: "flex-start", children: rows.map(([label, value]) => (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: label.padEnd(width + 3) }), _jsx(Text, { children: value })] }, label))) }));
+}
+function OutcomeChips({ counts, always = [] }) {
+    const shown = Object.keys(OUTCOME_STYLE).filter((o) => counts[o] > 0 || always.includes(o));
+    return (_jsx(Text, { children: shown.map((outcome, index) => (_jsxs(Text, { children: [index > 0 && '   ', _jsx(Text, { color: OUTCOME_STYLE[outcome].color, children: OUTCOME_STYLE[outcome].icon }), " ", counts[outcome], ' ', _jsx(Text, { dimColor: true, children: OUTCOME_STYLE[outcome].label })] }, outcome))) }));
+}
+/** Ticks once a second on its own so the rest of the screen only re-renders on progress. */
+function Timing({ startedAt, done, total }) {
+    const [now, setNow] = React.useState(Date.now());
+    React.useEffect(() => {
+        const timer = setInterval(() => setNow(Date.now()), 1000);
+        return () => clearInterval(timer);
+    }, []);
+    const elapsed = now - startedAt;
+    const remaining = estimateRemainingMs(elapsed, done, total);
+    return (_jsxs(Text, { dimColor: true, children: [formatDuration(elapsed), " elapsed", remaining !== null && ` · ~${formatDuration(remaining)} left`] }));
+}
+const YT_DLP_MISSING = 'Video downloads need yt-dlp, which isn\'t installed. In another terminal run: brew install yt-dlp ffmpeg (or see github.com/yt-dlp/yt-dlp), then pick again.';
+const MODE_ITEMS = [
+    { label: 'Transcripts', value: 'transcripts', hint: 'fast · text only' },
+    { label: 'Transcripts + videos', value: 'videos', hint: 'needs yt-dlp · large download' },
+    { label: 'Quit', value: 'quit' },
+];
 function ExitPrompt({ label }) {
     const { exit } = useApp();
     useInput(() => exit());
@@ -166,16 +205,16 @@ export function App({ controllers }) {
         if (step.kind !== 'syncing')
             return;
         let cancelled = false;
-        const { slug, name, courseCount, outDir } = step;
+        const { slug, name, courseCount, outDir, videos, startedAt } = step;
         controllers
             .runSync(slug, outDir, (event) => {
             if (cancelled)
                 return;
             setStep((previous) => previous.kind === 'syncing' ? { ...previous, progress: applyProgress(previous.progress, event) } : previous);
-        })
+        }, videos)
             .then((summary) => {
             if (!cancelled)
-                setStep({ kind: 'done', slug, name, courseCount, outDir, summary });
+                setStep({ kind: 'done', slug, name, courseCount, outDir, elapsedMs: Date.now() - startedAt, summary });
         })
             .catch((error) => {
             if (!cancelled)
@@ -218,68 +257,105 @@ export function App({ controllers }) {
             });
         }
     }, [exit]);
-    switch (step.kind) {
-        case 'checking-session':
-            return _jsx(Text, { children: "Checking your Skool session\u2026" });
-        case 'login-needed':
-            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "yellow", children: "You are not signed in to Skool." }), _jsx(Text, { dimColor: true, children: "Nothing is typed for you \u2014 a browser window opens and you sign in yourself." }), _jsx(ConfirmPrompt, { onConfirm: () => setStep({ kind: 'logging-in' }) })] }));
-        case 'logging-in':
-            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "A browser window is open. Sign in there." }), _jsx(Text, { dimColor: true, children: "Waiting for you to finish (Ctrl+C to cancel)\u2026" })] }));
-        case 'discovering':
-            return _jsx(Text, { children: "Looking up the communities you belong to\u2026" });
-        case 'picking': {
-            const items = [
-                ...step.communities.map((community) => ({
-                    label: `${community.name}  (skool.com/${community.slug})`,
-                    value: community,
-                })),
-                { label: 'Enter a slug manually…', value: null },
-            ];
-            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Which community?" }), _jsx(SelectList, { items: items, onSelect: (value) => {
-                            if (value === null)
-                                setStep({ kind: 'manual-slug', value: '', error: null });
-                            else
-                                chooseCommunity(value.slug, value.name);
-                        } })] }));
-        }
-        case 'manual-slug':
-            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Enter the community slug \u2014 the part after skool.com/" }), _jsxs(Text, { children: ["Slug: ", step.value, _jsx(Text, { color: "gray", children: "\u2588" })] }), step.error && _jsx(Text, { color: "red", children: step.error }), _jsx(ManualSlugInput, { value: step.value, onChange: (value) => setStep({ kind: 'manual-slug', value, error: null }), onSubmit: (value) => {
-                            const slug = normalizeSlug(value);
-                            if (!isValidSlug(slug)) {
-                                setStep({ kind: 'manual-slug', value, error: `"${value}" doesn't look like a valid slug.` });
-                                return;
-                            }
-                            chooseCommunity(slug, slug);
-                        } })] }));
-        case 'counting':
-            return _jsxs(Text, { children: ["Looking up courses in ", step.name, "\u2026"] });
-        case 'confirming':
-            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["Community: ", step.name, " (skool.com/", step.slug, ")"] }), _jsxs(Text, { children: ["Courses found: ", step.courseCount] }), _jsxs(Text, { children: ["Output will be written to: ", step.outDir] }), _jsx(Text, { children: " " }), _jsx(ConfirmPrompt, { onConfirm: () => setStep({
-                            kind: 'syncing',
-                            slug: step.slug,
-                            name: step.name,
-                            courseCount: step.courseCount,
-                            outDir: step.outDir,
-                            progress: createProgressState(0),
-                        }) })] }));
-        case 'syncing': {
-            const { progress } = step;
-            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: formatProgressBar(progress.done, progress.total) }), progress.current && (_jsxs(Text, { dimColor: true, children: ["current: ", progress.current.course, " / ", progress.current.title] })), _jsxs(Text, { dimColor: true, children: ["ok ", progress.counts.ok, "  skipped ", progress.counts.skipped, "  no-video ", progress.counts['no-video'], ' ', "no-access ", progress.counts['no-access'], "  unavailable ", progress.counts.unavailable, "  failed", ' ', progress.counts.failed] })] }));
-        }
-        case 'done': {
-            const lines = formatSummary(step.summary, step.outDir);
-            const done = {
-                slug: step.slug,
-                name: step.name,
-                courseCount: step.courseCount,
-                outDir: step.outDir,
-                summary: step.summary,
-            };
-            return (_jsxs(Box, { flexDirection: "column", children: [lines.map((line, index) => (
-                    // eslint-disable-next-line react/no-array-index-key
-                    _jsx(Text, { children: line || ' ' }, index))), _jsx(Text, { children: " " }), _jsx(Text, { children: "What next?" }), _jsx(SelectList, { items: MENU_ITEMS, onSelect: (choice) => handleMenuChoice(done, choice) })] }));
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(Header, {}), renderStep()] }));
+    function renderStep() {
+        switch (step.kind) {
+            case 'checking-session':
+                return _jsx(Spinner, { label: "Checking your Skool session\u2026" });
+            case 'login-needed':
+                return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "yellow", children: "You're not signed in to Skool yet." }), _jsx(Text, { dimColor: true, children: "A browser window will open and you sign in yourself. skrape never sees your password." }), _jsx(Text, { children: " " }), _jsx(ConfirmPrompt, { onConfirm: () => setStep({ kind: 'logging-in' }) })] }));
+            case 'logging-in':
+                return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Spinner, { label: "Waiting for you to sign in in the browser window\u2026" }), _jsx(Text, { dimColor: true, children: "Ctrl+C to cancel" })] }));
+            case 'discovering':
+                return _jsx(Spinner, { label: "Finding your communities\u2026" });
+            case 'picking': {
+                const items = [
+                    ...step.communities.map((community) => ({
+                        label: community.name,
+                        hint: `skool.com/${community.slug}`,
+                        value: community,
+                    })),
+                    { label: 'Enter a slug manually…', value: null },
+                ];
+                return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Which community?" }), _jsx(Text, { children: " " }), _jsx(SelectList, { items: items, onSelect: (value) => {
+                                if (value === null)
+                                    setStep({ kind: 'manual-slug', value: '', error: null });
+                                else
+                                    chooseCommunity(value.slug, value.name);
+                            } })] }));
+            }
+            case 'manual-slug':
+                return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Community slug" }), _jsxs(Text, { dimColor: true, children: ["The part after skool.com/, e.g. skool.com/", _jsx(Text, { color: ACCENT, children: "my-community" })] }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsx(Text, { color: ACCENT, children: "\u276F " }), step.value, _jsx(Text, { color: ACCENT, children: "\u258C" })] }), step.error && _jsx(Text, { color: "red", children: step.error }), _jsx(ManualSlugInput, { value: step.value, onChange: (value) => setStep({ kind: 'manual-slug', value, error: null }), onSubmit: (value) => {
+                                const slug = normalizeSlug(value);
+                                if (!isValidSlug(slug)) {
+                                    setStep({ kind: 'manual-slug', value, error: `"${value}" doesn't look like a valid slug.` });
+                                    return;
+                                }
+                                chooseCommunity(slug, slug);
+                            } })] }));
+            case 'counting':
+                return _jsx(Spinner, { label: `Looking up courses in ${step.name}…` });
+            case 'confirming': {
+                const { slug, name, courseCount, outDir } = step;
+                return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Card, { rows: [
+                                ['Community', _jsx(Text, { bold: true, children: name })],
+                                ['URL', `skool.com/${slug}`],
+                                ['Courses', `${courseCount} you can access`],
+                                ['Saving to', displayPath(outDir)],
+                            ] }), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: "What should skrape pull?" }), _jsx(Text, { children: " " }), _jsx(SelectList, { items: MODE_ITEMS, onSelect: (mode) => {
+                                if (mode === 'quit') {
+                                    exit();
+                                    return;
+                                }
+                                const start = () => setStep({
+                                    kind: 'syncing', slug, name, courseCount, outDir,
+                                    videos: mode === 'videos',
+                                    startedAt: Date.now(),
+                                    progress: createProgressState(0),
+                                });
+                                if (mode !== 'videos') {
+                                    start();
+                                    return;
+                                }
+                                controllers
+                                    .hasYtDlp()
+                                    .catch(() => false)
+                                    .then((ok) => {
+                                    if (ok)
+                                        start();
+                                    else
+                                        setStep({ ...step, notice: YT_DLP_MISSING });
+                                });
+                            } }), step.notice && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "yellow", children: step.notice }) }))] }));
+            }
+            case 'syncing': {
+                const { progress } = step;
+                return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["Syncing ", _jsx(Text, { bold: true, children: step.name }), _jsx(Text, { dimColor: true, children: step.videos ? '  · transcripts + videos' : '  · transcripts' })] }), _jsx(Text, { children: " " }), _jsx(Text, { color: ACCENT, children: formatProgressBar(progress.done, progress.total, 32) }), progress.current ? (_jsx(Spinner, { label: `${progress.current.course} › ${progress.current.title}` })) : (_jsx(Spinner, { label: "Reading the course tree\u2026" })), _jsx(Text, { children: " " }), _jsx(OutcomeChips, { counts: progress.counts, always: ['ok'] }), _jsx(Timing, { startedAt: step.startedAt, done: progress.done, total: progress.total })] }));
+            }
+            case 'done': {
+                const { summary } = step;
+                const empty = nothingTranscribed(summary);
+                const videoLine = formatVideoLine(summary);
+                const done = {
+                    slug: step.slug,
+                    name: step.name,
+                    courseCount: step.courseCount,
+                    outDir: step.outDir,
+                    summary,
+                };
+                const rows = [
+                    ['Words', summary.totalWords.toLocaleString('en-US')],
+                    ['Lessons', _jsx(OutcomeChips, { counts: summary.counts })],
+                ];
+                if (videoLine)
+                    rows.push(['Videos', videoLine]);
+                rows.push(['Saved to', _jsx(Text, { color: ACCENT, children: displayPath(step.outDir) })]);
+                return (_jsxs(Box, { flexDirection: "column", children: [empty && summary.counts.skipped === 0 ? (_jsx(Text, { color: "yellow", bold: true, children: "\u26A0 Nothing was transcribed." })) : (_jsxs(Text, { color: "green", bold: true, children: ["\u2713 ", empty ? `${step.name} is up to date` : `Synced ${step.name}`, _jsxs(Text, { dimColor: true, bold: false, children: ["  in ", formatDuration(step.elapsedMs)] })] })), _jsx(Text, { children: " " }), _jsx(Card, { rows: rows }), summary.problems.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { bold: true, children: ["Needs attention (", summary.problems.length, ")"] }), sortedProblems(summary).map((problem, index) => (
+                                // eslint-disable-next-line react/no-array-index-key
+                                _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { color: OUTCOME_STYLE[problem.outcome].color, children: OUTCOME_STYLE[problem.outcome].icon }), ' ', problem.course, " \u203A ", problem.title, "  ", _jsx(Text, { dimColor: true, children: problem.reason })] }, index)))] })), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: "What next?" }), _jsx(Text, { children: " " }), _jsx(SelectList, { items: MENU_ITEMS, onSelect: (choice) => handleMenuChoice(done, choice) })] }));
+            }
+            case 'error':
+                return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "red", paddingX: 1, alignSelf: "flex-start", children: [_jsx(Text, { color: "red", bold: true, children: "\u2717 Something went wrong" }), _jsx(Text, { children: step.message }), _jsx(Text, { children: " " }), _jsx(ExitPrompt, { label: "Press any key to exit." })] }));
         }
-        case 'error':
-            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "red", children: ["Something went wrong: ", step.message] }), _jsx(ExitPrompt, { label: "Press any key to exit." })] }));
     }
 }

package/dist/tui/SelectList.d.ts

@@ -2,6 +2,8 @@ import React from 'react';
 export interface SelectItem<T> {
     label: string;
     value: T;
+    /** Dim text shown after the label. */
+    hint?: string;
 }
 interface SelectListProps<T> {
     items: Array<SelectItem<T>>;

package/dist/tui/SelectList.js

@@ -1,6 +1,7 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from 'react';
 import { Box, Text, useInput } from 'ink';
+import { ACCENT } from './theme.js';
 /** Minimal arrow-key list, built directly on Ink's useInput rather than pulling
  *  in a select-input dependency. Cheap to render: a handful of Text lines,
  *  re-rendered only on cursor movement or selection. */
@@ -21,5 +22,9 @@ export function SelectList({ items, onSelect }) {
                 onSelect(item.value);
         }
     });
-    return (_jsx(Box, { flexDirection: "column", children: items.map((item, index) => (_jsxs(Text, { color: index === cursor ? 'cyan' : undefined, children: [index === cursor ? '> ' : '  ', item.label] }, item.label))) }));
+    const labelWidth = Math.max(...items.map((item) => item.label.length));
+    return (_jsxs(Box, { flexDirection: "column", children: [items.map((item, index) => {
+                const active = index === cursor;
+                return (_jsxs(Text, { children: [_jsx(Text, { color: ACCENT, children: active ? '❯ ' : '  ' }), _jsx(Text, { color: active ? ACCENT : undefined, bold: active, children: item.hint ? item.label.padEnd(labelWidth) : item.label }), item.hint && _jsxs(Text, { dimColor: true, children: ["   ", item.hint] })] }, item.label));
+            }), _jsxs(Text, { dimColor: true, children: ['\n', "\u2191\u2193 move \u00B7 enter select"] })] }));
 }

package/dist/tui/browserLifecycle.js

@@ -13,7 +13,7 @@ export function isProfileLockError(error) {
  */
 export function translateLaunchError(error) {
     if (isProfileLockError(error)) {
-        const friendly = new Error('The Chrome profile is already in use. Another skrape process may be running — ' +
+        const friendly = new Error('The Chrome profile is already in use. Another skrape process may be running. ' +
             'if not, delete ~/.skool-skrape/chrome-profile/SingletonLock and try again.');
         friendly.cause = error;
         return friendly;

package/dist/tui/chromeSetup.js

@@ -1,11 +1,5 @@
-/**
- * Pure decision logic for the one-time "make sure Chrome is installed" step
- * that runs before the session check. Kept free of fs/child_process/Playwright
- * details (those live in `../fetch/chromeSetup.ts`) so the branching here is
- * unit-testable against plain fakes, the same split used by `flow.ts` and
- * `browserLifecycle.ts` elsewhere in this package.
- */
-const MANUAL_FALLBACK = 'npx playwright install chrome';
+import { INSTALL_TARGET } from '../fetch/chromeSetup.js';
+const MANUAL_FALLBACK = `npx playwright install ${INSTALL_TARGET}`;
 /** Thrown when the automatic install fails. Its message is already
  *  human-actionable (includes the manual fallback command) — callers can
  *  surface `.message` directly without needing to know install internals. */

package/dist/tui/progress.js

@@ -26,6 +26,5 @@ export function formatProgressBar(done, total, width = 24) {
     const safeTotal = total > 0 ? total : 1;
     const ratio = Math.min(1, Math.max(0, done / safeTotal));
     const filled = Math.round(ratio * width);
-    const bar = '#'.repeat(filled) + '-'.repeat(width - filled);
-    return `[${bar}] ${done}/${total}`;
+    return `${'█'.repeat(filled)}${'░'.repeat(width - filled)}  ${done}/${total}  ${Math.round(ratio * 100)}%`;
 }

package/dist/tui/run.js

@@ -5,13 +5,13 @@ import { BrowserFetcher } from '../fetch/browser.js';
 import { isChromeMarkedInstalled, installChromeViaCli, markChromeInstalled, probeChromeLaunchable } from '../fetch/chromeSetup.js';
 import { openDb } from '../store/db.js';
 import { syncClassroom } from '../sync.js';
-import { chromeMarkerPath, dbPath, ensureRoot, isLoggedIn, login, profileDir } from '../auth/session.js';
+import { hasYtDlp } from '../media/download.js';
+import { chromeMarkerPath, dbPath, defaultOutRoot, ensureRoot, isLoggedIn, login, profileDir } from '../auth/session.js';
 import { listCourses } from '../discover/skool.js';
 import { listUserCommunities } from '../discover/communities.js';
 import { App } from './App.js';
 import { createBrowserLifecycle } from './browserLifecycle.js';
 import { ensureChromeReady } from './chromeSetup.js';
-const OUT_ROOT = './out';
 /**
  * Runs the guided, no-arguments flow: session check, community picker,
  * confirmation, live sync progress, and a result summary. Owns the db and
@@ -33,13 +33,13 @@ export async function runGuidedFlow() {
         probeLaunchable: probeChromeLaunchable,
         markInstalled: (executablePath) => markChromeInstalled(chromeMarkerPath(), executablePath),
         installChrome: async (onProgress) => {
-            console.log('\nSetting up the browser skrape needs — this happens once, ~150MB.\n');
+            console.log('\nSetting up the browser skrape needs. This happens once, ~150MB.\n');
             await installChromeViaCli(onProgress);
             console.log('\nBrowser setup complete.\n');
             const executablePath = await probeChromeLaunchable();
             if (!executablePath) {
-                throw new Error('Chrome installed, but still could not be launched. This usually means a platform-specific ' +
-                    'dependency is missing — see the Playwright install output above for details.');
+                throw new Error('The browser installed, but still could not be launched. This usually means a system library is missing' +
+                    (process.platform === 'linux' ? '. Fix it with: sudo npx playwright install-deps chromium' : '. See the install output above.'));
             }
             return executablePath;
         },
@@ -73,7 +73,7 @@ export async function runGuidedFlow() {
     };
     process.on('SIGINT', onSigint);
     const controllers = {
-        outRoot: OUT_ROOT,
+        outRoot: defaultOutRoot(),
         checkLoggedIn: async () => lifecycle.checkLoggedIn(),
         login: async () => {
             await lifecycle.login();
@@ -83,7 +83,8 @@ export async function runGuidedFlow() {
             const courses = await listCourses(slug, lifecycle.getFetcher());
             return courses.filter((course) => course.hasAccess).length;
         },
-        runSync: async (slug, outDir, onProgress) => syncClassroom({ slug, outDir, db, fetcher: lifecycle.getFetcher(), concurrency: 4, onProgress }),
+        hasYtDlp,
+        runSync: async (slug, outDir, onProgress, videos) => syncClassroom({ slug, outDir, db, fetcher: lifecycle.getFetcher(), concurrency: 4, videos, onProgress }),
     };
     const { waitUntilExit } = render(React.createElement(App, { controllers }));
     try {

package/dist/tui/summary.d.ts

@@ -1,7 +1,11 @@
 import type { SyncSummary } from '../sync.js';
-export declare function formatCountLines(summary: SyncSummary): string[];
-export declare function formatProblemLines(summary: SyncSummary): string[];
+import { type OutcomeColor } from './theme.js';
+/** Colors a piece of text; identity by default so output stays plain for tests and pipes. */
+export type Paint = (color: OutcomeColor | 'bold' | 'dim', text: string) => string;
+export declare function formatVideoLine(summary: SyncSummary): string | null;
+/** Problems worst-first, so real failures aren't buried under routine "no video" lessons. */
+export declare function sortedProblems(summary: SyncSummary): SyncSummary['problems'];
 /** True when nothing was transcribed at all — the case that must never be
  *  rendered as a cheerful, empty-looking summary. */
 export declare function nothingTranscribed(summary: SyncSummary): boolean;
-export declare function formatSummary(summary: SyncSummary, outDir: string): string[];
+export declare function formatSummary(summary: SyncSummary, outDir: string, paint?: Paint): string[];

package/dist/tui/summary.js

@@ -1,29 +1,49 @@
-export function formatCountLines(summary) {
-    const lines = [];
-    for (const [outcome, count] of Object.entries(summary.counts)) {
-        if (count > 0)
-            lines.push(`  ${outcome.padEnd(14)} ${count}`);
-    }
-    return lines;
+import { OUTCOME_STYLE } from './theme.js';
+const plain = (_color, text) => text;
+export function formatVideoLine(summary) {
+    const v = summary.videos;
+    if (!v)
+        return null;
+    return `${v.downloaded} downloaded · ${v.existing} already on disk · ${v.failed} failed`;
 }
-export function formatProblemLines(summary) {
-    return summary.problems.map((problem) => `  [${problem.outcome}] ${problem.course} / ${problem.title}: ${problem.reason}`);
+const SEVERITY = ['failed', 'unavailable', 'no-access', 'no-video', 'skipped', 'ok'];
+/** Problems worst-first, so real failures aren't buried under routine "no video" lessons. */
+export function sortedProblems(summary) {
+    return [...summary.problems].sort((a, b) => SEVERITY.indexOf(a.outcome) - SEVERITY.indexOf(b.outcome));
 }
 /** True when nothing was transcribed at all — the case that must never be
  *  rendered as a cheerful, empty-looking summary. */
 export function nothingTranscribed(summary) {
     return summary.counts.ok === 0 && summary.totalWords === 0;
 }
-export function formatSummary(summary, outDir) {
+function headline(summary, paint) {
+    if (!nothingTranscribed(summary)) {
+        return paint('green', `✓ Transcribed ${summary.totalWords.toLocaleString('en-US')} words`);
+    }
+    // A re-sync where every lesson was already on disk is a success, not an empty run.
+    if (summary.counts.skipped > 0)
+        return paint('green', '✓ Up to date, nothing new to transcribe.');
+    return paint('yellow', '⚠ Nothing was transcribed.');
+}
+export function formatSummary(summary, outDir, paint = plain) {
     const lines = [];
-    if (nothingTranscribed(summary)) {
-        lines.push('Nothing was transcribed.', '');
+    lines.push(headline(summary, paint), '');
+    for (const [outcome, count] of Object.entries(summary.counts)) {
+        if (count === 0)
+            continue;
+        const style = OUTCOME_STYLE[outcome];
+        lines.push(`  ${paint(style.color, style.icon)} ${style.label.padEnd(14)} ${count}`);
     }
-    lines.push('--- summary ---', ...formatCountLines(summary));
-    lines.push(`  ${'words'.padEnd(14)} ${summary.totalWords.toLocaleString('en-US')}`);
+    const videoLine = formatVideoLine(summary);
+    if (videoLine)
+        lines.push(`  ${paint('dim', '▸')} ${'videos'.padEnd(14)} ${videoLine}`);
     if (summary.problems.length > 0) {
-        lines.push('', '--- not transcribed ---', ...formatProblemLines(summary));
+        lines.push('', paint('bold', `Needs attention (${summary.problems.length})`));
+        for (const problem of sortedProblems(summary)) {
+            const style = OUTCOME_STYLE[problem.outcome];
+            lines.push(`  ${paint(style.color, style.icon)} ${problem.course} › ${problem.title}  ${paint('dim', problem.reason)}`);
+        }
     }
-    lines.push('', `Output: ${outDir}`);
+    lines.push('', `${paint('dim', 'Saved to')} ${outDir}`);
     return lines;
 }

package/dist/tui/theme.d.ts

@@ -0,0 +1,14 @@
+import type { Outcome } from '../sync.js';
+/** Brand accent: peach. Ink takes hex; the plain CLI falls back to a named color. */
+export declare const ACCENT = "#FFB38A";
+export type OutcomeColor = 'green' | 'gray' | 'yellow' | 'red';
+export declare const OUTCOME_STYLE: Record<Outcome, {
+    icon: string;
+    label: string;
+    color: OutcomeColor;
+}>;
+/** A path as a person reads it: absolute, with the home folder shortened to ~. */
+export declare function displayPath(path: string): string;
+export declare function formatDuration(ms: number): string;
+/** Remaining time from a linear rate; null until there's at least one data point. */
+export declare function estimateRemainingMs(elapsedMs: number, done: number, total: number): number | null;

package/dist/tui/theme.js

@@ -0,0 +1,31 @@
+import { homedir } from 'node:os';
+/** Brand accent: peach. Ink takes hex; the plain CLI falls back to a named color. */
+export const ACCENT = '#FFB38A';
+export const OUTCOME_STYLE = {
+    ok: { icon: '✓', label: 'transcribed', color: 'green' },
+    skipped: { icon: '↷', label: 'already done', color: 'gray' },
+    'no-video': { icon: '·', label: 'no video', color: 'gray' },
+    'no-access': { icon: '⊘', label: 'locked', color: 'yellow' },
+    unavailable: { icon: '!', label: 'unavailable', color: 'yellow' },
+    failed: { icon: '✗', label: 'failed', color: 'red' },
+};
+/** A path as a person reads it: absolute, with the home folder shortened to ~. */
+export function displayPath(path) {
+    const home = homedir();
+    return path === home || path.startsWith(`${home}/`) ? `~${path.slice(home.length)}` : path;
+}
+export function formatDuration(ms) {
+    const seconds = Math.max(0, Math.round(ms / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ${seconds % 60}s`;
+    return `${Math.floor(minutes / 60)}h ${minutes % 60}m`;
+}
+/** Remaining time from a linear rate; null until there's at least one data point. */
+export function estimateRemainingMs(elapsedMs, done, total) {
+    if (done <= 0 || done >= total)
+        return null;
+    return (elapsedMs / done) * (total - done);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mogulmoretti/skrape",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Read Skool course content instead of watching it — pulls the classroom of a community you belong to into clean, readable transcripts.",
   "keywords": [
     "skool",