feat: initialize k-tv-frontend with Next.js and Tailwind CSS

- Added package.json with dependencies and scripts for development, build, and linting.
- Created postcss.config.mjs for Tailwind CSS integration.
- Added SVG assets for UI components including file, globe, next, vercel, and window icons.
- Configured TypeScript with tsconfig.json for strict type checking and module resolution.

k-tv-backend/api/src/main.rs

@@ -0,0 +1,168 @@
+//! API Server Entry Point
+//!
+//! Configures and starts the HTTP server with JWT-based authentication.
+
+use std::net::SocketAddr;
+use std::time::Duration as StdDuration;
+
+use axum::Router;
+use std::sync::Arc;
+
+use domain::{ChannelService, IMediaProvider, ScheduleEngineService, UserService};
+use infra::factory::{build_channel_repository, build_schedule_repository, build_user_repository};
+use infra::run_migrations;
+use k_core::http::server::{ServerConfig, apply_standard_middleware};
+use k_core::logging;
+use tokio::net::TcpListener;
+use tracing::info;
+
+mod config;
+mod dto;
+mod error;
+mod extractors;
+mod routes;
+mod state;
+
+use crate::config::Config;
+use crate::state::AppState;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    logging::init("api");
+
+    let config = Config::from_env();
+
+    info!("Starting server on {}:{}", config.host, config.port);
+
+    // Setup database
+    tracing::info!("Connecting to database: {}", config.database_url);
+
+    #[cfg(all(feature = "sqlite", not(feature = "postgres")))]
+    let db_type = k_core::db::DbType::Sqlite;
+
+    #[cfg(all(feature = "postgres", not(feature = "sqlite")))]
+    let db_type = k_core::db::DbType::Postgres;
+
+    // Both features enabled: fall back to URL inspection at runtime
+    #[cfg(all(feature = "sqlite", feature = "postgres"))]
+    let db_type = if config.database_url.starts_with("postgres") {
+        k_core::db::DbType::Postgres
+    } else {
+        k_core::db::DbType::Sqlite
+    };
+
+    let db_config = k_core::db::DatabaseConfig {
+        db_type,
+        url: config.database_url.clone(),
+        max_connections: config.db_max_connections,
+        min_connections: config.db_min_connections,
+        acquire_timeout: StdDuration::from_secs(30),
+    };
+
+    let db_pool = k_core::db::connect(&db_config).await?;
+    run_migrations(&db_pool).await?;
+
+    let user_repo = build_user_repository(&db_pool).await?;
+    let channel_repo = build_channel_repository(&db_pool).await?;
+    let schedule_repo = build_schedule_repository(&db_pool).await?;
+
+    let user_service = UserService::new(user_repo);
+    let channel_service = ChannelService::new(channel_repo.clone());
+
+    // Build media provider — Jellyfin if configured, no-op fallback otherwise.
+    let media_provider: Arc<dyn IMediaProvider> = build_media_provider(&config);
+
+    let schedule_engine = ScheduleEngineService::new(media_provider, channel_repo, schedule_repo);
+
+    let state = AppState::new(user_service, channel_service, schedule_engine, config.clone()).await?;
+
+    let server_config = ServerConfig {
+        cors_origins: config.cors_allowed_origins.clone(),
+    };
+
+    let app = Router::new()
+        .nest("/api/v1", routes::api_v1_router())
+        .with_state(state);
+
+    let app = apply_standard_middleware(app, &server_config);
+
+    let addr: SocketAddr = format!("{}:{}", config.host, config.port).parse()?;
+    let listener = TcpListener::bind(addr).await?;
+
+    tracing::info!("🚀 API server running at http://{}", addr);
+    tracing::info!("🔒 Authentication mode: JWT (Bearer token)");
+
+    #[cfg(feature = "auth-jwt")]
+    tracing::info!("  ✓ JWT auth enabled");
+
+    #[cfg(feature = "auth-oidc")]
+    tracing::info!("  ✓ OIDC integration enabled (stateless cookie state)");
+
+    tracing::info!("📝 API endpoints available at /api/v1/...");
+
+    axum::serve(listener, app).await?;
+
+    Ok(())
+}
+
+/// Build the media provider from config.
+/// Falls back to a no-op provider that returns an informative error when
+/// Jellyfin env vars are not set, so other API features still work in dev.
+fn build_media_provider(config: &Config) -> Arc<dyn IMediaProvider> {
+    #[cfg(feature = "jellyfin")]
+    if let (Some(base_url), Some(api_key), Some(user_id)) = (
+        &config.jellyfin_base_url,
+        &config.jellyfin_api_key,
+        &config.jellyfin_user_id,
+    ) {
+        tracing::info!("Media provider: Jellyfin at {}", base_url);
+        return Arc::new(infra::JellyfinMediaProvider::new(infra::JellyfinConfig {
+            base_url: base_url.clone(),
+            api_key: api_key.clone(),
+            user_id: user_id.clone(),
+        }));
+    }
+
+    tracing::warn!(
+        "No media provider configured. Set JELLYFIN_BASE_URL, JELLYFIN_API_KEY, \
+         and JELLYFIN_USER_ID to enable schedule generation."
+    );
+    Arc::new(NoopMediaProvider)
+}
+
+/// Stand-in provider used when no real media source is configured.
+/// Returns a descriptive error for every call so schedule endpoints fail
+/// gracefully rather than panicking at startup.
+struct NoopMediaProvider;
+
+#[async_trait::async_trait]
+impl IMediaProvider for NoopMediaProvider {
+    async fn fetch_items(
+        &self,
+        _: &domain::MediaFilter,
+    ) -> domain::DomainResult<Vec<domain::MediaItem>> {
+        Err(domain::DomainError::InfrastructureError(
+            "No media provider configured. Set JELLYFIN_BASE_URL, JELLYFIN_API_KEY, \
+             and JELLYFIN_USER_ID."
+                .into(),
+        ))
+    }
+
+    async fn fetch_by_id(
+        &self,
+        _: &domain::MediaItemId,
+    ) -> domain::DomainResult<Option<domain::MediaItem>> {
+        Err(domain::DomainError::InfrastructureError(
+            "No media provider configured.".into(),
+        ))
+    }
+
+    async fn get_stream_url(
+        &self,
+        _: &domain::MediaItemId,
+    ) -> domain::DomainResult<String> {
+        Err(domain::DomainError::InfrastructureError(
+            "No media provider configured.".into(),
+        ))
+    }
+}