offcourse 0.0.2 → 1.0.0

package/src/state/index.ts

@@ -0,0 +1,14 @@
+export {
+  CourseDatabase,
+  LessonStatus,
+  VideoType,
+  extractCommunitySlug,
+  getDbDir,
+  getDbPath,
+  type CourseMetadata,
+  type LessonRecord,
+  type LessonStatusType,
+  type LessonWithModule,
+  type ModuleRecord,
+  type VideoTypeValue,
+} from "./database.js";

package/src/storage/fileSystem.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest";
+import {
+  getLessonBasename,
+  getVideoPath,
+  getMarkdownPath,
+  getDownloadFilePath,
+} from "./fileSystem.js";
+
+describe("fileSystem", () => {
+  describe("getLessonBasename", () => {
+    it("creates numbered filename from lesson name", () => {
+      expect(getLessonBasename(0, "Introduction")).toBe("01-introduction");
+      expect(getLessonBasename(9, "Final Lesson")).toBe("10-final-lesson");
+      expect(getLessonBasename(99, "Bonus")).toBe("100-bonus");
+    });
+
+    it("handles special characters", () => {
+      expect(getLessonBasename(0, "What's Next?")).toBe("01-whats-next");
+      expect(getLessonBasename(0, "Module 1: Basics")).toBe("01-module-1-basics");
+    });
+  });
+
+  describe("getVideoPath", () => {
+    it("creates video path with .mp4 extension", () => {
+      const path = getVideoPath("/courses/my-course/01-intro", 0, "Welcome");
+      expect(path).toBe("/courses/my-course/01-intro/01-welcome.mp4");
+    });
+
+    it("handles nested paths", () => {
+      const path = getVideoPath("/home/user/Downloads/courses/test", 5, "Lesson Six");
+      expect(path).toBe("/home/user/Downloads/courses/test/06-lesson-six.mp4");
+    });
+  });
+
+  describe("getMarkdownPath", () => {
+    it("creates markdown path with .md extension", () => {
+      const path = getMarkdownPath("/courses/my-course/01-intro", 0, "Welcome");
+      expect(path).toBe("/courses/my-course/01-intro/01-welcome.md");
+    });
+  });
+
+  describe("getDownloadFilePath", () => {
+    it("prefixes filename with lesson basename", () => {
+      const path = getDownloadFilePath("/module", 2, "Resources", "workbook.pdf");
+      expect(path).toBe("/module/03-resources-workbook.pdf");
+    });
+
+    it("sanitizes dangerous filename characters", () => {
+      // Characters that are invalid in filenames on various OS
+      const path = getDownloadFilePath("/module", 0, "Intro", 'file<>:"/\\|?*.pdf');
+      expect(path).toBe("/module/01-intro-file_________.pdf");
+    });
+
+    it("preserves safe special characters", () => {
+      const path = getDownloadFilePath("/module", 0, "Intro", "my-file_v2 (1).pdf");
+      expect(path).toBe("/module/01-intro-my-file_v2 (1).pdf");
+    });
+
+    it("handles filenames with multiple extensions", () => {
+      const path = getDownloadFilePath("/module", 0, "Intro", "archive.tar.gz");
+      expect(path).toBe("/module/01-intro-archive.tar.gz");
+    });
+  });
+});

package/src/storage/fileSystem.ts

@@ -0,0 +1,175 @@
+import { createWriteStream } from "node:fs";
+import { join } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { expandPath, getSyncStatePath } from "../config/paths.js";
+import type { CourseSyncState } from "../config/schema.js";
+import { courseSyncStateSchema } from "../config/schema.js";
+import { createFolderName } from "../scraper/navigator.js";
+import { ensureDir, outputFile, pathExists, readJson, outputJson } from "../shared/fs.js";
+import { http } from "../shared/http.js";
+
+// ============================================
+// Pure functions - testable without mocking
+// ============================================
+
+/**
+ * Gets the base filename for a lesson (without extension).
+ * Format: "01-lesson-name"
+ */
+export function getLessonBasename(lessonIndex: number, lessonName: string): string {
+  return createFolderName(lessonIndex, lessonName);
+}
+
+/**
+ * Gets the video file path for a lesson.
+ * Videos are stored directly in the module directory with lesson name.
+ */
+export function getVideoPath(moduleDir: string, lessonIndex: number, lessonName: string): string {
+  return join(moduleDir, `${getLessonBasename(lessonIndex, lessonName)}.mp4`);
+}
+
+/**
+ * Gets the markdown file path for a lesson.
+ * Markdown files are stored directly in the module directory with lesson name.
+ */
+export function getMarkdownPath(
+  moduleDir: string,
+  lessonIndex: number,
+  lessonName: string
+): string {
+  return join(moduleDir, `${getLessonBasename(lessonIndex, lessonName)}.md`);
+}
+
+/**
+ * Gets the path for a downloadable file.
+ * Files are stored in the module directory with lesson prefix.
+ */
+export function getDownloadFilePath(
+  moduleDir: string,
+  lessonIndex: number,
+  lessonName: string,
+  filename: string
+): string {
+  const lessonPrefix = getLessonBasename(lessonIndex, lessonName);
+  // Sanitize filename
+  const safeFilename = filename.replace(/[<>:"/\\|?*]/g, "_");
+  return join(moduleDir, `${lessonPrefix}-${safeFilename}`);
+}
+
+// ============================================
+// I/O functions - require filesystem access
+// ============================================
+/* v8 ignore start */
+
+/**
+ * Creates the output directory structure for a course.
+ */
+export async function createCourseDirectory(
+  outputBase: string,
+  courseName: string
+): Promise<string> {
+  const expanded = expandPath(outputBase);
+  const courseDir = join(expanded, createFolderName(0, courseName).replace(/^\d+-/, ""));
+  await ensureDir(courseDir);
+  return courseDir;
+}
+
+/**
+ * Creates a module directory within a course.
+ */
+export async function createModuleDirectory(
+  courseDir: string,
+  moduleIndex: number,
+  moduleName: string
+): Promise<string> {
+  const moduleDir = join(courseDir, createFolderName(moduleIndex, moduleName));
+  await ensureDir(moduleDir);
+  return moduleDir;
+}
+
+/**
+ * Saves markdown content to a file.
+ */
+export async function saveMarkdown(
+  directory: string,
+  filename: string,
+  content: string
+): Promise<string> {
+  const filePath = join(directory, filename);
+  await outputFile(filePath, content);
+  return filePath;
+}
+
+/**
+ * Loads the sync state for a course.
+ */
+export async function loadSyncState(courseSlug: string): Promise<CourseSyncState | null> {
+  const statePath = getSyncStatePath(courseSlug);
+  const data = await readJson(statePath);
+
+  if (!data) {
+    return null;
+  }
+
+  try {
+    return courseSyncStateSchema.parse(data);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Saves the sync state for a course.
+ */
+export async function saveSyncState(courseSlug: string, state: CourseSyncState): Promise<void> {
+  const statePath = getSyncStatePath(courseSlug);
+  await outputJson(statePath, state);
+}
+
+/**
+ * Checks if a lesson has been fully synced.
+ */
+export async function isLessonSynced(
+  moduleDir: string,
+  lessonIndex: number,
+  lessonName: string
+): Promise<{ video: boolean; content: boolean }> {
+  const [video, content] = await Promise.all([
+    pathExists(getVideoPath(moduleDir, lessonIndex, lessonName)),
+    pathExists(getMarkdownPath(moduleDir, lessonIndex, lessonName)),
+  ]);
+  return { video, content };
+}
+
+/**
+ * Downloads a file from a URL to the specified path.
+ */
+export async function downloadFile(
+  url: string,
+  outputPath: string
+): Promise<{ success: boolean; error?: string }> {
+  if (await pathExists(outputPath)) {
+    return { success: true }; // Already downloaded
+  }
+
+  await ensureDir(join(outputPath, ".."));
+
+  try {
+    const response = await http.get(url);
+    const body = response.body;
+
+    if (!body) {
+      return { success: false, error: "No response body" };
+    }
+
+    const fileStream = createWriteStream(outputPath);
+    await pipeline(Readable.fromWeb(body as import("stream/web").ReadableStream), fileStream);
+
+    return { success: true };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+}
+
+/* v8 ignore stop */

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "target": "ES2024",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2024", "DOM"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "exactOptionalPropertyTypes": true,
+    "isolatedModules": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}
+

package/vitest.config.ts

@@ -0,0 +1,29 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    include: ["src/**/*.test.ts"],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "html", "lcov"],
+      include: ["src/**/*.ts"],
+      exclude: [
+        // Test files
+        "src/**/*.test.ts",
+        // CLI commands (interactive, hard to test)
+        "src/cli/**",
+        // Re-export index files
+        "src/**/index.ts",
+        // Pure I/O wrappers (testing would just test Node.js/packages)
+        "src/shared/fs.ts",
+        "src/config/configManager.ts",
+        // Browser automation (requires Playwright, not unit testable)
+        "src/scraper/videoInterceptor.ts",
+        // Network validation (requires live connections)
+        "src/downloader/hlsValidator.ts",
+      ],
+    },
+  },
+});

package/cli.js

@@ -1,45 +0,0 @@
-#!/usr/bin/env node
-
-const VERSION = "0.0.2";
-
-const banner = `
-╔═══════════════════════════════════════════════════════════════╗
-║                                                               ║
-║   ┌─┐┌─┐┌─┐┌─┐┌─┐┬ ┬┬─┐┌─┐┌─┐                                ║
-║   │ │├┤ ├┤ │  │ ││ │├┬┘└─┐├┤                                 ║
-║   └─┘└  └  └─┘└─┘└─┘┴└─└─┘└─┘                                ║
-║                                                               ║
-║   Download online courses for offline access – of course! 📚  ║
-║                                                               ║
-╚═══════════════════════════════════════════════════════════════╝
-`;
-
-const comingSoon = `
-🚧 Coming Soon!
-
-This package is currently in private development.
-The full release will include:
-
-  • 🔐 Browser-based authentication with session caching
-  • 📚 Course structure preservation (module/lesson hierarchy)
-  • 🎬 Video downloads (Loom, Vimeo, YouTube, Wistia)
-  • 📝 Content extraction to clean Markdown
-  • ⏸️ Resumable syncs
-  • ⚡ Concurrent downloads
-
-Supported platforms:
-  • Skool.com (ready)
-  • LearningSuite.io (planned)
-
-Follow the project:
-  → https://github.com/sebastian-software/offcourse
-
-`;
-
-console.log(banner);
-console.log(comingSoon);
-
-if (process.argv.includes("--version") || process.argv.includes("-v")) {
-  console.log(`v${VERSION}`);
-}
-