cyreader 0.1.0

package/bundle/server/dist/app.js

@@ -0,0 +1,23 @@
+import { Hono } from 'hono';
+import { mountLibraryStaticRoutes, refreshLibraryStaticRoutes } from './library-static.js';
+import { mountWebStaticRoutes } from './web-static.js';
+import { createConfigRoutes } from './routes/config.js';
+import { createLibraryRoutes } from './routes/library.js';
+import { createReadingRoutes } from './routes/reading.js';
+export function createApp(configService, libraryService, recentService, progressService) {
+    const app = new Hono();
+    const api = new Hono();
+    const config = configService.get();
+    mountLibraryStaticRoutes(app, config);
+    const refreshStatic = () => refreshLibraryStaticRoutes(configService.get());
+    api.route('/config', createConfigRoutes(configService, libraryService, {
+        onConfigChange: () => {
+            refreshStatic();
+        },
+    }));
+    api.route('/library', createLibraryRoutes(libraryService, progressService));
+    api.route('/reading', createReadingRoutes(recentService, progressService));
+    app.route('/api', api);
+    mountWebStaticRoutes(app);
+    return app;
+}

package/bundle/server/dist/app.test.js

@@ -0,0 +1,9 @@
+import { describe, expect, it } from 'vitest';
+import app from './app.js';
+describe('app', () => {
+    it('GET / returns Hello Hono!', async () => {
+        const res = await app.request('/');
+        expect(res.status).toBe(200);
+        expect(await res.text()).toBe('Hello Hono!');
+    });
+});

package/bundle/server/dist/config/defaults.js

@@ -0,0 +1,7 @@
+export function createDefaultConfig() {
+    return {
+        novelDirectories: [],
+        comicDirectories: [],
+        gbkNovelHandling: 'ignore',
+    };
+}

package/bundle/server/dist/config/paths.js

@@ -0,0 +1,18 @@
+import { homedir } from 'node:os';
+import path from 'node:path';
+export function getConfigDir() {
+    const override = process.env.CYREADER_CONFIG_DIR;
+    if (override) {
+        return path.resolve(override);
+    }
+    return path.join(homedir(), '.cyreader');
+}
+export function getConfigFilePath() {
+    return path.join(getConfigDir(), 'config.json');
+}
+export function getRecentFilePath() {
+    return path.join(getConfigDir(), 'recent.json');
+}
+export function getProgressFilePath() {
+    return path.join(getConfigDir(), 'progress.json');
+}

package/bundle/server/dist/config/schema.js

@@ -0,0 +1,84 @@
+import path from 'node:path';
+import { nanoid } from 'nanoid';
+import { z } from 'zod';
+const absoluteDirectoryPath = z
+    .string()
+    .min(1, 'Directory path cannot be empty')
+    .refine((value) => path.isAbsolute(value), {
+    message: 'Directory path must be absolute',
+});
+const directoryEntrySchema = z.preprocess((value) => {
+    if (typeof value === 'string') {
+        return { id: nanoid(), path: value };
+    }
+    if (value && typeof value === 'object' && 'path' in value) {
+        const entry = value;
+        const id = typeof entry.id === 'string' && entry.id.length > 0 ? entry.id : nanoid();
+        return {
+            id,
+            path: entry.path,
+        };
+    }
+    return value;
+}, z.object({
+    id: z.string().min(1),
+    path: absoluteDirectoryPath,
+}));
+export const gbkNovelHandlingSchema = z.enum(['ignore', 'convert-to-utf-8']);
+const cyreaderConfigObjectSchema = z.object({
+    novelDirectories: z.array(directoryEntrySchema),
+    comicDirectories: z.array(directoryEntrySchema),
+    gbkNovelHandling: gbkNovelHandlingSchema.default('ignore'),
+});
+export const cyreaderConfigSchema = cyreaderConfigObjectSchema.superRefine((config, ctx) => {
+    addUniquePathIssues(config.novelDirectories, 'novelDirectories', ctx);
+    addUniquePathIssues(config.comicDirectories, 'comicDirectories', ctx);
+});
+export const cyreaderConfigPatchSchema = cyreaderConfigObjectSchema
+    .partial()
+    .superRefine((config, ctx) => {
+    if (config.novelDirectories) {
+        addUniquePathIssues(config.novelDirectories, 'novelDirectories', ctx);
+    }
+    if (config.comicDirectories) {
+        addUniquePathIssues(config.comicDirectories, 'comicDirectories', ctx);
+    }
+});
+function addUniquePathIssues(directories, field, ctx) {
+    const seen = new Set();
+    for (const [index, directory] of directories.entries()) {
+        if (seen.has(directory.path)) {
+            ctx.addIssue({
+                code: 'custom',
+                message: 'Directory path must be unique',
+                path: [field, index, 'path'],
+            });
+        }
+        seen.add(directory.path);
+    }
+}
+export function createDirectoryEntry(pathValue) {
+    return {
+        id: nanoid(),
+        path: pathValue,
+    };
+}
+export function normalizeConfig(config) {
+    return {
+        novelDirectories: config.novelDirectories,
+        comicDirectories: config.comicDirectories,
+        gbkNovelHandling: config.gbkNovelHandling ?? 'ignore',
+    };
+}
+export function parseConfig(data) {
+    return normalizeConfig(cyreaderConfigSchema.parse(data));
+}
+export function formatZodError(error) {
+    return {
+        error: 'Validation failed',
+        details: error.issues.map((issue) => ({
+            path: issue.path.filter((segment) => typeof segment !== 'symbol'),
+            message: issue.message,
+        })),
+    };
+}

package/bundle/server/dist/config/schema.test.js

@@ -0,0 +1,76 @@
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { createDirectoryEntry, cyreaderConfigSchema, parseConfig } from './schema.js';
+describe('cyreaderConfigSchema', () => {
+    it('accepts directory entries with absolute paths', () => {
+        const config = {
+            novelDirectories: [{ id: 'novel-1', path: '/home/user/novels' }],
+            comicDirectories: [{ id: 'comic-1', path: '/home/user/comics' }],
+        };
+        expect(parseConfig(config)).toEqual({ ...config, gbkNovelHandling: 'ignore' });
+    });
+    it('migrates legacy string directories to entries with ids', () => {
+        expect(parseConfig({
+            novelDirectories: ['/home/user/novels'],
+            comicDirectories: [],
+        })).toEqual({
+            novelDirectories: [
+                expect.objectContaining({ path: '/home/user/novels', id: expect.any(String) }),
+            ],
+            comicDirectories: [],
+            gbkNovelHandling: 'ignore',
+        });
+    });
+    it('assigns an id when a directory entry omits id', () => {
+        expect(parseConfig({
+            novelDirectories: [{ path: '/home/user/novels' }],
+            comicDirectories: [],
+        })).toEqual({
+            novelDirectories: [
+                expect.objectContaining({ path: '/home/user/novels', id: expect.any(String) }),
+            ],
+            comicDirectories: [],
+            gbkNovelHandling: 'ignore',
+        });
+    });
+    it('defaults gbkNovelHandling to ignore when omitted', () => {
+        expect(parseConfig({
+            novelDirectories: [],
+            comicDirectories: [],
+        }).gbkNovelHandling).toBe('ignore');
+    });
+    it('rejects relative directory paths', () => {
+        const cases = ['novels', './novels', '../novels', 'Books/Novels'];
+        for (const directory of cases) {
+            const result = cyreaderConfigSchema.safeParse({
+                novelDirectories: [createDirectoryEntry(directory)],
+                comicDirectories: [],
+            });
+            expect(result.success).toBe(false);
+            if (!result.success) {
+                expect(result.error.issues[0]?.message).toBe('Directory path must be absolute');
+            }
+        }
+    });
+    it('rejects empty directory paths', () => {
+        const result = cyreaderConfigSchema.safeParse({
+            novelDirectories: [{ id: 'novel-1', path: '' }],
+            comicDirectories: [],
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects duplicate directory paths within the same list', () => {
+        const directory = path.resolve('/tmp/novels');
+        const result = cyreaderConfigSchema.safeParse({
+            novelDirectories: [
+                { id: 'novel-1', path: directory },
+                { id: 'novel-2', path: directory },
+            ],
+            comicDirectories: [],
+        });
+        expect(result.success).toBe(false);
+        if (!result.success) {
+            expect(result.error.issues[0]?.message).toBe('Directory path must be unique');
+        }
+    });
+});

package/bundle/server/dist/config/service.js

@@ -0,0 +1,38 @@
+import { cyreaderConfigPatchSchema, cyreaderConfigSchema, normalizeConfig, parseConfig, } from './schema.js';
+import { ensureConfig, ensureConfigDirectories, writeConfig } from './storage.js';
+export class ConfigService {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    static async create() {
+        const config = await ensureConfig();
+        return new ConfigService(config);
+    }
+    static fromConfig(config) {
+        return new ConfigService(normalizeConfig(cyreaderConfigSchema.parse(config)));
+    }
+    get() {
+        return this.config;
+    }
+    async replace(input) {
+        const normalized = parseConfig(input);
+        await ensureConfigDirectories(normalized);
+        await writeConfig(normalized);
+        this.config = normalized;
+        return normalized;
+    }
+    async patch(input) {
+        const parsed = cyreaderConfigPatchSchema.parse(input);
+        const merged = {
+            novelDirectories: parsed.novelDirectories ?? this.config.novelDirectories,
+            comicDirectories: parsed.comicDirectories ?? this.config.comicDirectories,
+            gbkNovelHandling: parsed.gbkNovelHandling ?? this.config.gbkNovelHandling,
+        };
+        const normalized = parseConfig(merged);
+        await ensureConfigDirectories(normalized);
+        await writeConfig(normalized);
+        this.config = normalized;
+        return normalized;
+    }
+}

package/bundle/server/dist/config/storage.js

@@ -0,0 +1,54 @@
+import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { createDefaultConfig } from './defaults.js';
+import { getConfigDir, getConfigFilePath } from './paths.js';
+import { parseConfig } from './schema.js';
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureDirectories(directories) {
+    await Promise.all(directories.map((directory) => mkdir(directory, { recursive: true })));
+}
+export async function ensureConfigDirectories(config) {
+    await ensureDirectories([
+        ...config.novelDirectories.map((directory) => directory.path),
+        ...config.comicDirectories.map((directory) => directory.path),
+    ]);
+}
+export async function writeConfig(config) {
+    const configDir = getConfigDir();
+    const configFile = getConfigFilePath();
+    const normalized = parseConfig(config);
+    await mkdir(configDir, { recursive: true });
+    await writeFile(configFile, `${JSON.stringify(normalized, null, 2)}\n`, 'utf-8');
+}
+export async function readConfigFromDisk() {
+    const configFile = getConfigFilePath();
+    const content = await readFile(configFile, 'utf-8');
+    let data;
+    try {
+        data = JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse config file: ${configFile}`, { cause: error });
+    }
+    return parseConfig(data);
+}
+export async function ensureConfig() {
+    const configDir = getConfigDir();
+    const configFile = getConfigFilePath();
+    await mkdir(configDir, { recursive: true });
+    if (!(await fileExists(configFile))) {
+        const defaultConfig = createDefaultConfig();
+        await writeConfig(defaultConfig);
+        return defaultConfig;
+    }
+    const config = await readConfigFromDisk();
+    await ensureConfigDirectories(config);
+    return config;
+}

package/bundle/server/dist/config/storage.test.js

@@ -0,0 +1,79 @@
+import { access, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { getConfigFilePath } from './paths.js';
+import { ensureConfig, readConfigFromDisk } from './storage.js';
+describe('ensureConfig', () => {
+    let tempDir;
+    let previousConfigDir;
+    beforeEach(async () => {
+        previousConfigDir = process.env.CYREADER_CONFIG_DIR;
+        tempDir = await mkdtemp(path.join(tmpdir(), 'cyreader-config-'));
+        process.env.CYREADER_CONFIG_DIR = tempDir;
+    });
+    afterEach(async () => {
+        if (previousConfigDir === undefined) {
+            delete process.env.CYREADER_CONFIG_DIR;
+        }
+        else {
+            process.env.CYREADER_CONFIG_DIR = previousConfigDir;
+        }
+        await rm(tempDir, { recursive: true, force: true });
+    });
+    it('creates config directory and default config file when missing', async () => {
+        const config = await ensureConfig();
+        const configFile = getConfigFilePath();
+        expect(config).toEqual({
+            novelDirectories: [],
+            comicDirectories: [],
+            gbkNovelHandling: 'ignore',
+        });
+        await expect(access(configFile)).resolves.toBeUndefined();
+        const content = await readFile(configFile, 'utf-8');
+        expect(JSON.parse(content)).toEqual({
+            novelDirectories: [],
+            comicDirectories: [],
+            gbkNovelHandling: 'ignore',
+        });
+    });
+    it('reads an existing valid config', async () => {
+        const configFile = getConfigFilePath();
+        await writeFile(configFile, `${JSON.stringify({
+            novelDirectories: [{ id: 'novel-1', path: '/tmp/novels' }],
+            comicDirectories: [{ id: 'comic-1', path: '/tmp/comics' }],
+        })}\n`, 'utf-8');
+        const config = await ensureConfig();
+        expect(config).toEqual({
+            novelDirectories: [{ id: 'novel-1', path: '/tmp/novels' }],
+            comicDirectories: [{ id: 'comic-1', path: '/tmp/comics' }],
+            gbkNovelHandling: 'ignore',
+        });
+    });
+    it('migrates legacy string directories when reading config', async () => {
+        const configFile = getConfigFilePath();
+        await writeFile(configFile, `${JSON.stringify({
+            novelDirectories: ['/tmp/novels'],
+            comicDirectories: [],
+        })}\n`, 'utf-8');
+        const config = await ensureConfig();
+        expect(config).toEqual({
+            novelDirectories: [expect.objectContaining({ path: '/tmp/novels', id: expect.any(String) })],
+            comicDirectories: [],
+            gbkNovelHandling: 'ignore',
+        });
+    });
+    it('throws when config file contains invalid JSON', async () => {
+        const configFile = getConfigFilePath();
+        await writeFile(configFile, '{ invalid json', 'utf-8');
+        await expect(readConfigFromDisk()).rejects.toThrow('Failed to parse config file');
+    });
+    it('throws when config file contains non-absolute paths', async () => {
+        const configFile = getConfigFilePath();
+        await writeFile(configFile, `${JSON.stringify({
+            novelDirectories: [{ id: 'novel-1', path: 'relative/path' }],
+            comicDirectories: [],
+        })}\n`, 'utf-8');
+        await expect(readConfigFromDisk()).rejects.toThrow();
+    });
+});

package/bundle/server/dist/index.js

@@ -0,0 +1,28 @@
+import { serve } from '@hono/node-server';
+import { createApp } from './app.js';
+import { ConfigService } from './config/service.js';
+import { LibraryService } from './library/service.js';
+import { formatListenUrl, getListenHostname, getListenPort } from './listen-config.js';
+import { ProgressService } from './reading/progress/service.js';
+import { RecentService } from './reading/recent/service.js';
+async function main() {
+    const configService = await ConfigService.create();
+    const libraryService = new LibraryService(() => configService.get());
+    const recentService = await RecentService.create(libraryService);
+    const progressService = await ProgressService.create(libraryService);
+    const app = createApp(configService, libraryService, recentService, progressService);
+    libraryService.tryScan();
+    const port = getListenPort();
+    const hostname = getListenHostname();
+    serve({
+        fetch: app.fetch,
+        port,
+        ...(hostname ? { hostname } : {}),
+    }, (info) => {
+        console.log(`Server is running on ${formatListenUrl(info.port, hostname)}`);
+    });
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/bundle/server/dist/library/comic-url.js

@@ -0,0 +1,4 @@
+const STATIC_PREFIX = '/static';
+export function buildComicImageUrl(directoryId, title, filename) {
+    return `${STATIC_PREFIX}/${directoryId}/${encodeURIComponent(title)}/${encodeURIComponent(filename)}`;
+}

package/bundle/server/dist/library/cover.js

@@ -0,0 +1,44 @@
+import { access, rename, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import sharp from 'sharp';
+import { COMIC_COVER_FILENAME } from './files.js';
+const COVER_SCALE = 3;
+const JPEG_QUALITY = 75;
+function comicCoverPath(comicDir) {
+    return path.join(comicDir, COMIC_COVER_FILENAME);
+}
+async function comicCoverExists(comicDir) {
+    try {
+        await access(comicCoverPath(comicDir));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function resolveComicCoverFilename(comicDir) {
+    return (await comicCoverExists(comicDir)) ? COMIC_COVER_FILENAME : null;
+}
+export async function generateComicCoverIfMissing(comicDir, sourceImagePath) {
+    const coverPath = comicCoverPath(comicDir);
+    if (await comicCoverExists(comicDir)) {
+        return false;
+    }
+    try {
+        const metadata = await sharp(sourceImagePath).metadata();
+        const width = Math.max(1, Math.round((metadata.width ?? 1) / COVER_SCALE));
+        const height = Math.max(1, Math.round((metadata.height ?? 1) / COVER_SCALE));
+        const buffer = await sharp(sourceImagePath)
+            .resize(width, height)
+            .jpeg({ quality: JPEG_QUALITY })
+            .toBuffer();
+        const tempPath = `${coverPath}.cyreader-tmp`;
+        await writeFile(tempPath, buffer);
+        await rename(tempPath, coverPath);
+        return true;
+    }
+    catch (error) {
+        console.error(`Failed to generate comic cover: ${coverPath}`, error);
+        return false;
+    }
+}

package/bundle/server/dist/library/errors.js

@@ -0,0 +1,12 @@
+export class ScanInProgressError extends Error {
+    constructor() {
+        super('Scan already in progress');
+        this.name = 'ScanInProgressError';
+    }
+}
+export class NotFoundError extends Error {
+    constructor(message = 'Not found') {
+        super(message);
+        this.name = 'NotFoundError';
+    }
+}

package/bundle/server/dist/library/files.js

@@ -0,0 +1,35 @@
+import path from 'node:path';
+const IMAGE_EXTENSIONS = new Set(['.jpg', '.jpeg', '.png', '.webp']);
+export const COMIC_COVER_FILENAME = 'cover.jpg';
+const naturalCollator = new Intl.Collator(undefined, {
+    numeric: true,
+    sensitivity: 'base',
+});
+export function isHiddenName(name) {
+    return name.startsWith('.');
+}
+export function isTxtFile(name) {
+    return path.extname(name).toLowerCase() === '.txt';
+}
+export function isImageFile(name) {
+    return IMAGE_EXTENSIONS.has(path.extname(name).toLowerCase());
+}
+export function isComicCoverFile(name) {
+    return path.basename(name).toLowerCase() === COMIC_COVER_FILENAME;
+}
+export function compareByNaturalName(a, b) {
+    return naturalCollator.compare(path.basename(a), path.basename(b));
+}
+export function sortByNaturalName(paths) {
+    return paths.toSorted(compareByNaturalName);
+}
+const IMAGE_MIME_TYPES = {
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.png': 'image/png',
+    '.webp': 'image/webp',
+};
+export function getImageMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return IMAGE_MIME_TYPES[ext] ?? 'application/octet-stream';
+}

package/bundle/server/dist/library/files.test.js

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+import { isImageFile, isTxtFile, sortByNaturalName } from './files.js';
+describe('isTxtFile', () => {
+    it('accepts .txt case-insensitively', () => {
+        expect(isTxtFile('book.txt')).toBe(true);
+        expect(isTxtFile('book.TXT')).toBe(true);
+    });
+    it('rejects non-txt extensions', () => {
+        expect(isTxtFile('book.pdf')).toBe(false);
+    });
+});
+describe('isImageFile', () => {
+    it('accepts jpg, jpeg, png, webp case-insensitively', () => {
+        expect(isImageFile('a.jpg')).toBe(true);
+        expect(isImageFile('a.JPEG')).toBe(true);
+        expect(isImageFile('a.png')).toBe(true);
+        expect(isImageFile('a.webp')).toBe(true);
+    });
+    it('rejects other extensions', () => {
+        expect(isImageFile('a.gif')).toBe(false);
+        expect(isImageFile('a.txt')).toBe(false);
+    });
+});
+describe('sortByNaturalName', () => {
+    it('sorts filenames naturally', () => {
+        const sorted = sortByNaturalName(['/comic/10.jpg', '/comic/2.jpg', '/comic/1.jpg']);
+        expect(sorted).toEqual(['/comic/1.jpg', '/comic/2.jpg', '/comic/10.jpg']);
+    });
+});

package/bundle/server/dist/library/id.js

@@ -0,0 +1,6 @@
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+export function makeLocalItemId(absolutePath) {
+    const normalized = path.resolve(absolutePath);
+    return createHash('sha256').update(normalized).digest('hex').slice(0, 16);
+}

package/bundle/server/dist/library/novel-url.js

@@ -0,0 +1,4 @@
+const STATIC_PREFIX = '/static';
+export function buildNovelContentUrl(directoryId, filename) {
+    return `${STATIC_PREFIX}/${directoryId}/${encodeURIComponent(filename)}`;
+}