hub-repo-tracker 1.0.0

package/dist/app.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/app.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+import Fastify from 'fastify';
+import cors from '@fastify/cors';
+import multipart from '@fastify/multipart';
+import fastifyStatic from '@fastify/static';
+import open from 'open';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+import { config, validateConfig } from './shared/config/index.js';
+import { initializeDatabase, closeDatabase } from './shared/db/index.js';
+import { errorHandler, errorSchema } from './shared/middleware/error.js';
+import { repoRoutes } from './features/repos/routes.js';
+import { syncRoutes } from './features/sync/routes.js';
+import { dashboardRoutes } from './features/dashboard/routes.js';
+import { categoryRoutes } from './features/categories/routes.js';
+import { importRoutes } from './features/import/routes.js';
+import { systemRoutes } from './features/system/routes.js';
+import { backupRoutes } from './features/backup/routes.js';
+import { startSyncJob, stopSyncJob } from './shared/jobs/sync-job.js';
+import { repoSchemas } from './features/repos/schema.js';
+import { categorySchemas } from './features/categories/schema.js';
+// Validate config on startup
+try {
+    validateConfig();
+}
+catch (error) {
+    console.error('Configuration error:', error);
+    process.exit(1);
+}
+// Initialize database
+initializeDatabase();
+// Create Fastify instance
+const app = Fastify({
+    logger: {
+        level: config.nodeEnv === 'development' ? 'info' : 'warn',
+        transport: config.nodeEnv === 'development'
+            ? { target: 'pino-pretty', options: { colorize: true } }
+            : undefined,
+    },
+    ajv: {
+        customOptions: {
+            coerceTypes: true,
+        },
+    },
+});
+// Register plugins
+await app.register(cors, {
+    origin: true, // Allow all origins in development
+});
+// Register multipart for file uploads
+await app.register(multipart, {
+    limits: {
+        fileSize: 100 * 1024 * 1024, // 100MB limit for SQLite backups
+    },
+});
+// Set custom error handler
+app.setErrorHandler(errorHandler);
+// Add response schema for errors
+app.addSchema({
+    $id: 'error',
+    ...errorSchema,
+});
+// Add shared schemas for repos and categories
+app.addSchema({
+    $id: 'repo',
+    ...repoSchemas.repo,
+});
+app.addSchema({
+    $id: 'category',
+    ...categorySchemas.category,
+});
+// Health check
+app.get('/health', async () => ({
+    status: 'ok',
+    timestamp: new Date().toISOString(),
+}));
+// Register routes
+await app.register(repoRoutes);
+await app.register(syncRoutes);
+await app.register(dashboardRoutes);
+await app.register(categoryRoutes);
+await app.register(importRoutes);
+await app.register(systemRoutes);
+await app.register(backupRoutes);
+// Serve static files (Frontend) - MUST be after API routes to avoid conflicts (or use prefix)
+// configured to serve from 'public' directory which will be in 'dist/public'
+await app.register(fastifyStatic, {
+    root: path.join(__dirname, 'public'),
+    prefix: '/',
+    constraints: {} // optional
+});
+// SPA Fallback: Serve index.html for any non-API route not handled above
+app.setNotFoundHandler(async (req, reply) => {
+    if (req.raw.url?.startsWith('/api')) {
+        return reply.status(404).send({
+            error: 'Not Found',
+            message: 'Route not found',
+            statusCode: 404
+        });
+    }
+    return reply.sendFile('index.html');
+});
+// Start scheduled sync job
+startSyncJob();
+// Graceful shutdown
+const gracefulShutdown = async (signal) => {
+    app.log.info(`Received ${signal}, shutting down gracefully...`);
+    try {
+        stopSyncJob();
+        await app.close();
+        closeDatabase();
+        app.log.info('Server closed');
+        process.exit(0);
+    }
+    catch (error) {
+        app.log.error(error, 'Error during shutdown');
+        process.exit(1);
+    }
+};
+process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+// Start server
+const start = async () => {
+    try {
+        const address = await app.listen({ port: config.port, host: '0.0.0.0' });
+        app.log.info(`Server listening at ${address}`);
+        // Auto-open browser in production/CLI mode (not in Docker)
+        if (config.nodeEnv !== 'development' && !process.env.DOCKER) {
+            try {
+                const url = `http://localhost:${config.port}`;
+                app.log.info(`Opening browser at ${url}`);
+                await open(url);
+            }
+            catch {
+                app.log.warn('Failed to open browser automatically');
+            }
+        }
+    }
+    catch (error) {
+        app.log.error(error, 'Failed to start server');
+        process.exit(1);
+    }
+};
+// Only start server if run directly
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    start();
+}

package/dist/features/backup/repository.d.ts

@@ -0,0 +1,24 @@
+import type { BackupData, BackupRepo, BackupCategory, BackupSyncState, BackupVersionHistory, RestoreResult } from './types.js';
+export declare const backupRepository: {
+    exportRepos(): BackupRepo[];
+    exportCategories(): BackupCategory[];
+    exportSyncStates(): BackupSyncState[];
+    exportVersionHistory(): BackupVersionHistory[];
+    clearAllData(): void;
+    importCategory(category: BackupCategory, idMapping: Map<number, number>): number | null;
+    importRepo(repo: BackupRepo, categoryIdMapping: Map<number, number>, repoIdMapping: Map<number, number>): number | null;
+    importSyncState(syncState: BackupSyncState, repoIdMapping: Map<number, number>): boolean;
+    importVersionHistory(history: BackupVersionHistory, repoIdMapping: Map<number, number>): boolean;
+    _clearDataIfReplace(mode: "merge" | "replace"): void;
+    _importCategories(categories: BackupCategory[], categoryIdMapping: Map<number, number>): {
+        imported: number;
+        skipped: number;
+    };
+    _importRepos(repos: BackupRepo[], categoryIdMapping: Map<number, number>, repoIdMapping: Map<number, number>): {
+        imported: number;
+        skipped: number;
+    };
+    _importSyncStates(syncStates: BackupSyncState[], repoIdMapping: Map<number, number>): number;
+    _importVersionHistoryFromRepos(repos: BackupRepo[], repoIdMapping: Map<number, number>): number;
+    restoreFromBackup(data: BackupData, mode: "merge" | "replace"): RestoreResult;
+};

package/dist/features/backup/repository.js

@@ -0,0 +1,236 @@
+import { db } from '../../shared/db/index.js';
+export const backupRepository = {
+    // Export all repos with version history
+    exportRepos() {
+        const repos = db.prepare(`
+      SELECT * FROM repos ORDER BY created_at ASC
+    `).all();
+        // Get version history for each repo
+        const historyStmt = db.prepare(`
+      SELECT * FROM version_history WHERE repo_id = ? ORDER BY detected_at DESC
+    `);
+        return repos.map(repo => ({
+            ...repo,
+            version_history: historyStmt.all(repo.id),
+        }));
+    },
+    // Export all categories
+    exportCategories() {
+        return db.prepare(`
+      SELECT * FROM categories ORDER BY created_at ASC
+    `).all();
+    },
+    // Export all sync states
+    exportSyncStates() {
+        return db.prepare(`
+      SELECT * FROM sync_state
+    `).all();
+    },
+    // Export all version history
+    exportVersionHistory() {
+        return db.prepare(`
+      SELECT * FROM version_history ORDER BY detected_at DESC
+    `).all();
+    },
+    // Clear all data (for replace mode)
+    clearAllData() {
+        db.exec(`
+      DELETE FROM version_history;
+      DELETE FROM sync_state;
+      DELETE FROM repos;
+      DELETE FROM categories;
+    `);
+    },
+    // Import category
+    importCategory(category, idMapping) {
+        // Check if category already exists by name
+        const existing = db.prepare('SELECT id FROM categories WHERE name = ?').get(category.name);
+        if (existing) {
+            idMapping.set(category.id, existing.id);
+            return null; // Skipped
+        }
+        const result = db.prepare(`
+      INSERT INTO categories (name, type, color, icon, owner_name, created_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(category.name, category.type || 'custom', category.color || '#6366f1', category.icon || null, category.owner_name || null, category.created_at);
+        const newId = result.lastInsertRowid;
+        idMapping.set(category.id, newId);
+        return newId;
+    },
+    // Import repo
+    importRepo(repo, categoryIdMapping, repoIdMapping) {
+        // Check if repo already exists by full_name
+        const existing = db.prepare('SELECT id FROM repos WHERE full_name = ?').get(repo.full_name);
+        if (existing) {
+            repoIdMapping.set(repo.id, existing.id);
+            return null; // Skipped
+        }
+        // Map old category_id to new one
+        const newCategoryId = repo.category_id ? categoryIdMapping.get(repo.category_id) ?? null : null;
+        const result = db.prepare(`
+      INSERT INTO repos (github_id, owner, name, full_name, url, description, notes, category_id, installed_version, local_path, is_favorite, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(repo.github_id || null, repo.owner, repo.name, repo.full_name, repo.url, repo.description || null, repo.notes || null, newCategoryId, repo.installed_version || null, repo.local_path || null, repo.is_favorite || 0, repo.created_at, repo.updated_at);
+        const newId = result.lastInsertRowid;
+        repoIdMapping.set(repo.id, newId);
+        return newId;
+    },
+    // Import sync state
+    importSyncState(syncState, repoIdMapping) {
+        const newRepoId = repoIdMapping.get(syncState.repo_id);
+        if (!newRepoId)
+            return false;
+        // Check if sync state already exists
+        const existing = db.prepare('SELECT repo_id FROM sync_state WHERE repo_id = ?').get(newRepoId);
+        if (existing) {
+            // Update existing
+            db.prepare(`
+        UPDATE sync_state SET
+          last_commit_sha = ?,
+          last_commit_date = ?,
+          last_commit_message = ?,
+          last_commit_author = ?,
+          last_release_tag = ?,
+          last_release_date = ?,
+          last_release_notes = ?,
+          last_tag = ?,
+          last_tag_date = ?,
+          acknowledged_release = ?,
+          release_notification_active = ?,
+          last_sync_at = ?,
+          has_updates = ?
+        WHERE repo_id = ?
+      `).run(syncState.last_commit_sha, syncState.last_commit_date, syncState.last_commit_message, syncState.last_commit_author, syncState.last_release_tag, syncState.last_release_date, syncState.last_release_notes, syncState.last_tag, syncState.last_tag_date, syncState.acknowledged_release, syncState.release_notification_active, syncState.last_sync_at, syncState.has_updates, newRepoId);
+        }
+        else {
+            // Insert new
+            db.prepare(`
+        INSERT INTO sync_state (
+          repo_id, last_commit_sha, last_commit_date, last_commit_message, last_commit_author,
+          last_release_tag, last_release_date, last_release_notes, last_tag, last_tag_date,
+          acknowledged_release, release_notification_active, last_sync_at, has_updates
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(newRepoId, syncState.last_commit_sha, syncState.last_commit_date, syncState.last_commit_message, syncState.last_commit_author, syncState.last_release_tag, syncState.last_release_date, syncState.last_release_notes, syncState.last_tag, syncState.last_tag_date, syncState.acknowledged_release, syncState.release_notification_active, syncState.last_sync_at, syncState.has_updates);
+        }
+        return true;
+    },
+    // Import version history
+    importVersionHistory(history, repoIdMapping) {
+        const newRepoId = repoIdMapping.get(history.repo_id);
+        if (!newRepoId)
+            return false;
+        // Check if this version history entry already exists
+        const existing = db.prepare(`
+      SELECT id FROM version_history
+      WHERE repo_id = ? AND version_type = ? AND version_value = ? AND detected_at = ?
+    `).get(newRepoId, history.version_type, history.version_value, history.detected_at);
+        if (existing)
+            return false;
+        db.prepare(`
+      INSERT INTO version_history (repo_id, version_type, version_value, release_notes, detected_at, acknowledged_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(newRepoId, history.version_type, history.version_value, history.release_notes, history.detected_at, history.acknowledged_at);
+        return true;
+    },
+    // Clear data if replace mode (internal)
+    _clearDataIfReplace(mode) {
+        if (mode === 'replace') {
+            this.clearAllData();
+        }
+    },
+    // Import all categories from backup (internal)
+    _importCategories(categories, categoryIdMapping) {
+        let imported = 0;
+        let skipped = 0;
+        for (const category of categories) {
+            const result = this.importCategory(category, categoryIdMapping);
+            if (result !== null) {
+                imported++;
+            }
+            else {
+                skipped++;
+            }
+        }
+        return { imported, skipped };
+    },
+    // Import all repos from backup (internal)
+    _importRepos(repos, categoryIdMapping, repoIdMapping) {
+        let imported = 0;
+        let skipped = 0;
+        for (const repo of repos) {
+            const result = this.importRepo(repo, categoryIdMapping, repoIdMapping);
+            if (result !== null) {
+                imported++;
+            }
+            else {
+                skipped++;
+            }
+        }
+        return { imported, skipped };
+    },
+    // Import all sync states from backup (internal)
+    _importSyncStates(syncStates, repoIdMapping) {
+        let restored = 0;
+        for (const syncState of syncStates) {
+            if (this.importSyncState(syncState, repoIdMapping)) {
+                restored++;
+            }
+        }
+        return restored;
+    },
+    // Import all version history from backup repos (internal)
+    _importVersionHistoryFromRepos(repos, repoIdMapping) {
+        let restored = 0;
+        for (const repo of repos) {
+            if (repo.version_history) {
+                for (const history of repo.version_history) {
+                    if (this.importVersionHistory(history, repoIdMapping)) {
+                        restored++;
+                    }
+                }
+            }
+        }
+        return restored;
+    },
+    // Full restore from backup data
+    restoreFromBackup(data, mode) {
+        const result = {
+            success: true,
+            message: '',
+            stats: {
+                repos_imported: 0,
+                repos_skipped: 0,
+                categories_imported: 0,
+                categories_skipped: 0,
+                sync_states_restored: 0,
+                version_history_restored: 0,
+            },
+            errors: [],
+        };
+        try {
+            const restoreTransaction = db.transaction(() => {
+                const categoryIdMapping = new Map();
+                const repoIdMapping = new Map();
+                this._clearDataIfReplace(mode);
+                const categoryResult = this._importCategories(data.data.categories, categoryIdMapping);
+                result.stats.categories_imported = categoryResult.imported;
+                result.stats.categories_skipped = categoryResult.skipped;
+                const repoResult = this._importRepos(data.data.repos, categoryIdMapping, repoIdMapping);
+                result.stats.repos_imported = repoResult.imported;
+                result.stats.repos_skipped = repoResult.skipped;
+                result.stats.sync_states_restored = this._importSyncStates(data.data.sync_state, repoIdMapping);
+                result.stats.version_history_restored = this._importVersionHistoryFromRepos(data.data.repos, repoIdMapping);
+            });
+            restoreTransaction();
+            result.message = mode === 'replace'
+                ? 'Data replaced successfully'
+                : 'Data merged successfully';
+        }
+        catch (error) {
+            result.success = false;
+            result.message = 'Restore failed';
+            result.errors.push(error instanceof Error ? error.message : 'Unknown error');
+        }
+        return result;
+    },
+};

package/dist/features/backup/routes.d.ts

@@ -0,0 +1,2 @@
+import { FastifyInstance } from 'fastify';
+export declare function backupRoutes(app: FastifyInstance): Promise<void>;