Add dist/ to gitignore and remove from tracking

Build artifacts should not be committed as they are generated during Docker build.

.gitignore

@@ -11,6 +11,9 @@
 # deps
 node_modules/
 
+# build output (TypeScript)
+dist/
+
 # env
 .env
 .env.production

dist/index.js

@@ -1,219 +0,0 @@
-import { serve } from '@hono/node-server';
-import { Hono } from 'hono';
-import { cors } from 'hono/cors';
-import { uploadFile } from '@huggingface/hub';
-import { createHash } from 'crypto';
-import { createDb } from './lib/db/index.js';
-import { user, session } from './lib/db/schema.js';
-import { eq } from 'drizzle-orm';
-import { createHash as createSha256 } from 'crypto';
-const app = new Hono();
-// Environment variables
-const HF_TOKEN = process.env.HF_TOKEN || '';
-const HF_DATASET_REPO = process.env.HF_DATASET_REPO || '';
-const UPLOAD_SERVER_TOKEN = process.env.UPLOAD_SERVER_TOKEN || '';
-const ALLOWED_ORIGIN = process.env.ALLOWED_ORIGIN || '*';
-const DATABASE_URL = process.env.DATABASE_URL || '';
-const DATABASE_AUTH_TOKEN = process.env.DATABASE_AUTH_TOKEN || '';
-// CORS configuration
-app.use('/*', cors({
-    origin: ALLOWED_ORIGIN,
-    allowMethods: ['POST', 'GET', 'OPTIONS'],
-    allowHeaders: ['Content-Type', 'Authorization'],
-    exposeHeaders: ['Content-Length'],
-    maxAge: 86400,
-    credentials: true,
-}));
-// Helper function to validate session token and get userId
-async function validateSessionToken(sessionToken) {
-    try {
-        // Hash the session token with SHA-256 (same as hugstream main app)
-        const sessionId = createSha256('sha256').update(sessionToken).digest('hex');
-        const db = createDb({
-            DATABASE_URL,
-            DATABASE_AUTH_TOKEN,
-            HF_TOKEN,
-            HF_DATASET_REPO
-        });
-        // Query session from database
-        const [sessionRecord] = await db
-            .select({
-            userId: session.userId,
-            expiresAt: session.expiresAt
-        })
-            .from(session)
-            .where(eq(session.id, sessionId))
-            .limit(1);
-        if (!sessionRecord) {
-            return null;
-        }
-        // Check if session is expired
-        if (new Date() >= new Date(sessionRecord.expiresAt)) {
-            return null;
-        }
-        return sessionRecord.userId;
-    }
-    catch (error) {
-        console.error('[AUTH] Session validation error:', error);
-        return null;
-    }
-}
-// Auth middleware
-const authMiddleware = async (c, next) => {
-    const authHeader = c.req.header('Authorization');
-    if (!authHeader || !authHeader.startsWith('Bearer ')) {
-        return c.json({ error: 'Unauthorized: Missing or invalid Authorization header' }, 401);
-    }
-    const token = authHeader.substring(7); // Remove "Bearer " prefix
-    if (token !== UPLOAD_SERVER_TOKEN) {
-        return c.json({ error: 'Unauthorized: Invalid token' }, 401);
-    }
-    await next();
-};
-// Health check endpoint
-app.get('/health', (c) => {
-    return c.json({
-        status: 'ok',
-        service: 'hugstream-upload',
-        timestamp: new Date().toISOString()
-    });
-});
-/**
- * Upload endpoint: POST /upload
- *
- * Receives file from hugstream main app and uploads to Hugging Face Dataset
- *
- * Request body (multipart/form-data):
- * - file: File to upload
- * - sessionToken: Session token from auth-session cookie (for authentication)
- * - hash: MD5 hash of the file (for deduplication)
- * - filename: Original filename
- *
- * Response:
- * - success: boolean
- * - hfPath: Path in HF Dataset where file was uploaded
- * - message: Status message
- */
-app.post('/upload', authMiddleware, async (c) => {
-    try {
-        // Validate HF configuration
-        if (!HF_TOKEN || !HF_DATASET_REPO) {
-            console.error('Missing HF_TOKEN or HF_DATASET_REPO environment variables');
-            return c.json({
-                error: 'Server configuration error: Missing HF credentials'
-            }, 500);
-        }
-        // Parse multipart form data
-        const formData = await c.req.formData();
-        const file = formData.get('file');
-        const sessionToken = formData.get('sessionToken');
-        const hash = formData.get('hash');
-        const filename = formData.get('filename');
-        // Validate required fields
-        if (!file) {
-            return c.json({ error: 'Missing file in request' }, 400);
-        }
-        if (!sessionToken) {
-            return c.json({ error: 'Missing sessionToken in request' }, 400);
-        }
-        if (!hash) {
-            return c.json({ error: 'Missing hash in request' }, 400);
-        }
-        if (!filename) {
-            return c.json({ error: 'Missing filename in request' }, 400);
-        }
-        // Validate session and get userId
-        const userId = await validateSessionToken(sessionToken);
-        if (!userId) {
-            console.error('[UPLOAD] Invalid or expired session token');
-            return c.json({ error: 'Unauthorized: Invalid or expired session' }, 401);
-        }
-        console.log(`[UPLOAD] Session validated for user ${userId}`);
-        console.log(`[UPLOAD] Starting upload, file: ${filename}, hash: ${hash}, size: ${file.size} bytes`);
-        // Convert file to buffer for hash verification
-        const arrayBuffer = await file.arrayBuffer();
-        const buffer = Buffer.from(arrayBuffer);
-        // Verify hash to ensure data integrity
-        const calculatedHash = createHash('md5').update(buffer).digest('hex');
-        if (calculatedHash !== hash) {
-            console.error(`[UPLOAD] Hash mismatch! Expected: ${hash}, Got: ${calculatedHash}`);
-            return c.json({
-                error: 'Hash verification failed: File may be corrupted'
-            }, 400);
-        }
-        // Build HF path using only hash (global deduplication)
-        const hfPath = hash;
-        console.log(`[UPLOAD] Hash verified. Uploading to HF path: ${hfPath}`);
-        // Upload to Hugging Face Dataset
-        try {
-            await uploadFile({
-                repo: {
-                    type: 'dataset',
-                    name: HF_DATASET_REPO
-                },
-                accessToken: HF_TOKEN,
-                file: {
-                    path: hfPath,
-                    content: new Blob([buffer])
-                }
-            });
-            console.log(`[UPLOAD] Successfully uploaded to Hugging Face: ${hfPath}`);
-            return c.json({
-                success: true,
-                hfPath,
-                message: 'File uploaded successfully',
-                size: buffer.length,
-                hash: calculatedHash
-            });
-        }
-        catch (hfError) {
-            console.error('[UPLOAD] Hugging Face upload failed:', hfError);
-            // Check if it's a conflict error (file already exists)
-            if (hfError.message && hfError.message.includes('conflict')) {
-                console.log(`[UPLOAD] File already exists in HF (deduplication): ${hfPath}`);
-                return c.json({
-                    success: true,
-                    hfPath,
-                    message: 'File already exists (deduplicated)',
-                    size: buffer.length,
-                    hash: calculatedHash,
-                    deduplicated: true
-                });
-            }
-            throw hfError;
-        }
-    }
-    catch (error) {
-        console.error('[UPLOAD] Upload error:', error);
-        return c.json({
-            error: 'Failed to upload file',
-            details: error.message || 'Unknown error'
-        }, 500);
-    }
-});
-/**
- * Chunked upload endpoint: POST /upload/chunked
- * For large files that need to be uploaded in chunks
- * (Future implementation - not used yet)
- */
-app.post('/upload/chunked', authMiddleware, async (c) => {
-    return c.json({
-        error: 'Chunked upload not implemented yet'
-    }, 501);
-});
-const port = parseInt(process.env.PORT || '7860');
-serve({
-    fetch: app.fetch,
-    port: port,
-    hostname: '0.0.0.0'
-}, (info) => {
-    console.log(`
-╔════════════════════════════════════════════╗
-║   Hugstream Upload Server                  ║
-║   Status: Running                          ║
-║   Port: ${info.port}                             ║
-║   HF Dataset: ${HF_DATASET_REPO ? '✓ Configured' : '✗ Not configured'}           ║
-║   Auth Token: ${UPLOAD_SERVER_TOKEN ? '✓ Configured' : '✗ Not configured'}           ║
-╚════════════════════════════════════════════╝
-  `);
-});

dist/lib/db/index.js

@@ -1,15 +0,0 @@
-import { drizzle } from 'drizzle-orm/libsql';
-import * as schema from './schema.js';
-/**
- * Create database instance for Cloudflare Worker
- * This is called per-request in the worker context
- */
-export function createDb(env) {
-    return drizzle({
-        connection: {
-            url: env.DATABASE_URL,
-            authToken: env.DATABASE_AUTH_TOKEN
-        },
-        schema
-    });
-}

dist/lib/db/schema.js

@@ -1,46 +0,0 @@
-import { sqliteTable, integer, text, index } from 'drizzle-orm/sqlite-core';
-export const user = sqliteTable('user', {
-    id: text('id').primaryKey(),
-    age: integer('age'),
-    username: text('username').notNull().unique(),
-    passwordHash: text('password_hash').notNull(),
-    storageQuota: integer('storage_quota').notNull().default(10995116277760) // 10TB default quota
-});
-export const session = sqliteTable('session', {
-    id: text('id').primaryKey(),
-    userId: text('user_id').notNull().references(() => user.id),
-    expiresAt: integer('expires_at', { mode: 'timestamp' }).notNull()
-}, (table) => ({
-    userIdIdx: index('session_user_id_idx').on(table.userId),
-    expiresAtIdx: index('session_expires_at_idx').on(table.expiresAt)
-}));
-export const file = sqliteTable('file', {
-    id: text('id').primaryKey(),
-    name: text('name').notNull(),
-    path: text('path').notNull(),
-    size: integer('size').notNull(),
-    mimeType: text('mime_type').notNull(),
-    userId: text('user_id').notNull().references(() => user.id),
-    parentId: text('parent_id'),
-    isFolder: integer('is_folder', { mode: 'boolean' }).notNull().default(false),
-    deletedAt: integer('deleted_at', { mode: 'timestamp' }),
-    createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
-    updatedAt: integer('updated_at', { mode: 'timestamp' }).notNull(),
-    // Hugging Face storage fields
-    hash: text('hash'), // MD5 hash for deduplication
-    hfPath: text('hf_path'), // Path in HF Dataset: {userId}/{hash}/{filename}
-    isUploaded: integer('is_uploaded', { mode: 'boolean' }).default(false), // Upload status to HF
-    uploadedAt: integer('uploaded_at', { mode: 'timestamp' }) // When successfully uploaded to HF
-}, (table) => ({
-    userIdIdx: index('file_user_id_idx').on(table.userId),
-    parentIdIdx: index('file_parent_id_idx').on(table.parentId),
-    isFolderIdx: index('file_is_folder_idx').on(table.isFolder),
-    deletedAtIdx: index('file_deleted_at_idx').on(table.deletedAt),
-    nameIdx: index('file_name_idx').on(table.name),
-    userFolderIdx: index('file_user_folder_idx').on(table.userId, table.isFolder, table.deletedAt),
-    userParentDeletedIdx: index('file_user_parent_deleted_idx').on(table.userId, table.parentId, table.deletedAt),
-    hashIdx: index('file_hash_idx').on(table.hash),
-    userHashIdx: index('file_user_hash_idx').on(table.userId, table.hash),
-    uploadedHashIdx: index('file_uploaded_hash_idx').on(table.isUploaded, table.hash),
-    hfPathIdx: index('file_hf_path_idx').on(table.hfPath)
-}));