Enhance Node.js placeholder server with more API endpoints and improve user experience

start.sh

@@ -143,15 +143,18 @@ else
     echo "==> PostgreSQL connection successful"
 fi
 
-# Create Node.js placeholder server
+# Create enhanced Node.js placeholder server
-echo "==> Creating Node.js placeholder server..."
+echo "==> Creating enhanced Node.js placeholder server..."
 cat > /app/data/ente/server/server.js << 'EOF'
 const http = require('http');
 const fs = require('fs');
+const { promisify } = require('util');
+const { execSync } = require('child_process');
 const path = require('path');
 
 const PORT = 3080;
 const LOG_FILE = '/app/data/logs/museum.log';
+const DB_SCHEMA_FILE = '/app/data/ente/server/schema.sql';
 
 // Ensure log directory exists
 if (!fs.existsSync('/app/data/logs')) {
@@ -170,7 +173,176 @@ function log(message) {
   }
 }
 
-log('Starting Node.js placeholder server...');
+log('Starting enhanced Node.js placeholder server...');
+
+// Try to initialize the database schema
+function initializeDatabase() {
+  try {
+    // Create a basic schema file if it doesn't exist
+    if (!fs.existsSync(DB_SCHEMA_FILE)) {
+      log('Creating basic database schema file');
+      const basicSchema = `
+-- Basic schema for Ente Museum server
+CREATE TABLE IF NOT EXISTS users (
+  id SERIAL PRIMARY KEY,
+  email VARCHAR(255) UNIQUE NOT NULL,
+  created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS files (
+  id SERIAL PRIMARY KEY,
+  user_id INTEGER REFERENCES users(id),
+  filename VARCHAR(255) NOT NULL,
+  path VARCHAR(255) NOT NULL,
+  created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+`;
+      fs.writeFileSync(DB_SCHEMA_FILE, basicSchema);
+    }
+
+    // Try to initialize the database
+    const dbUser = process.env.CLOUDRON_POSTGRESQL_USERNAME;
+    const dbPassword = process.env.CLOUDRON_POSTGRESQL_PASSWORD;
+    const dbHost = process.env.CLOUDRON_POSTGRESQL_HOST;
+    const dbPort = process.env.CLOUDRON_POSTGRESQL_PORT;
+    const dbName = process.env.CLOUDRON_POSTGRESQL_DATABASE;
+
+    if (dbUser && dbPassword && dbHost && dbPort && dbName) {
+      log(`Initializing database ${dbName} on ${dbHost}:${dbPort}`);
+      const command = `PGPASSWORD="${dbPassword}" psql -h "${dbHost}" -p "${dbPort}" -U "${dbUser}" -d "${dbName}" -f "${DB_SCHEMA_FILE}"`;
+      execSync(command, { stdio: 'inherit' });
+      log('Database initialized successfully');
+      return true;
+    } else {
+      log('Database environment variables not set, skipping initialization');
+      return false;
+    }
+  } catch (err) {
+    log(`Error initializing database: ${err.message}`);
+    return false;
+  }
+}
+
+// Try to initialize database
+initializeDatabase();
+
+// API response handlers
+const apiHandlers = {
+  // Health check endpoint
+  '/health': (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ 
+      status: 'OK', 
+      server: 'Museum Placeholder',
+      version: '1.0.0'
+    }));
+    log('Health check request - responded with status OK');
+  },
+  
+  // User verification endpoint
+  '/api/users/verify': (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    log('User verify request - responding with success');
+    res.end(JSON.stringify({ 
+      success: true,
+      isValidEmail: true,
+      isAvailable: true,
+      isVerified: true,
+      canCreateAccount: true
+    }));
+  },
+  
+  // User login endpoint
+  '/api/users/login': (req, res) => {
+    if (req.method === 'POST') {
+      let body = '';
+      req.on('data', chunk => {
+        body += chunk.toString();
+      });
+      req.on('end', () => {
+        log('Login request received');
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+          success: true,
+          token: 'placeholder-jwt-token',
+          user: {
+            id: 1,
+            email: 'placeholder@example.com',
+            name: 'Placeholder User'
+          }
+        }));
+      });
+    } else {
+      res.writeHead(405, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        success: false,
+        message: 'Method not allowed'
+      }));
+    }
+  },
+  
+  // User signup endpoint
+  '/api/users/signup': (req, res) => {
+    if (req.method === 'POST') {
+      let body = '';
+      req.on('data', chunk => {
+        body += chunk.toString();
+      });
+      req.on('end', () => {
+        log('Signup request received');
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+          success: true,
+          token: 'placeholder-jwt-token',
+          user: {
+            id: 1,
+            email: 'placeholder@example.com',
+            name: 'New User'
+          }
+        }));
+      });
+    } else {
+      res.writeHead(405, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        success: false, 
+        message: 'Method not allowed'
+      }));
+    }
+  },
+  
+  // Files endpoint
+  '/api/files': (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    log('Files request - responding with empty list');
+    res.end(JSON.stringify({ 
+      success: true,
+      files: []
+    }));
+  },
+  
+  // Collections endpoint
+  '/api/collections': (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    log('Collections request - responding with empty list');
+    res.end(JSON.stringify({ 
+      success: true,
+      collections: []
+    }));
+  },
+  
+  // Default API handler
+  'default': (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    log(`API request to ${req.url} - responding with generic success`);
+    res.end(JSON.stringify({ 
+      success: true,
+      message: 'Placeholder API response',
+      path: req.url 
+    }));
+  }
+};
 
 // Create server
 const server = http.createServer((req, res) => {
@@ -188,37 +360,24 @@ const server = http.createServer((req, res) => {
     return;
   }
   
-  // Health check endpoint
+  // Check if there's a specific handler for this path
-  if (req.url === '/health' || req.url === '/api/health') {
+  const handler = apiHandlers[req.url] || apiHandlers['default'];
-    res.writeHead(200, { 'Content-Type': 'application/json' });
+  
-    res.end(JSON.stringify({ status: 'OK', server: 'Museum Placeholder' }));
+  // Handle paths that exactly match defined endpoints
-    log('Health check request - responded with status OK');
+  if (apiHandlers[req.url]) {
+    handler(req, res);
     return;
   }
   
-  // Authentication endpoints
+  // Handle health check endpoint
-  if (req.url === '/api/users/verify') {
+  if (req.url === '/api/health') {
-    res.writeHead(200, { 'Content-Type': 'application/json' });
+    apiHandlers['/health'](req, res);
-    log('User verify request - responding with success');
-    res.end(JSON.stringify({ 
-      success: true,
-      isValidEmail: true,
-      isAvailable: true,
-      isVerified: true,
-      canCreateAccount: true
-    }));
     return;
   }
   
-  // Handle all API requests with a generic success response
+  // Route based on URL pattern
   if (req.url.startsWith('/api/')) {
-    res.writeHead(200, { 'Content-Type': 'application/json' });
+    handler(req, res);
-    log(`API request to ${req.url} - responding with generic success`);
-    res.end(JSON.stringify({ 
-      success: true,
-      message: 'Placeholder API response',
-      path: req.url 
-    }));
     return;
   }
   
@@ -226,7 +385,7 @@ const server = http.createServer((req, res) => {
   res.writeHead(200, { 'Content-Type': 'application/json' });
   log(`Unknown request to ${req.url} - responding with default message`);
   res.end(JSON.stringify({ 
-    message: 'Placeholder Museum Server', 
+    message: 'Ente Placeholder Server', 
     path: req.url,
     server: 'Node.js Placeholder'
   }));
@@ -256,12 +415,11 @@ server.on('error', (error) => {
 });
 
 // Log startup
-log('Museum placeholder server initialization complete');
+log('Enhanced Museum placeholder server initialization complete');
 EOF
-echo "==> Created Node.js placeholder server"
+echo "==> Created enhanced Node.js placeholder server"
 
-# Function to start the Node.js placeholder server
+# Start the Node.js placeholder server
-start_placeholder_server() {
 echo "==> Starting Node.js placeholder server..."
 cd /app/data/ente/server
 node server.js > /app/data/logs/museum.log 2>&1 &
@@ -274,116 +432,18 @@ start_placeholder_server() {
 while [ $ATTEMPT -lt $MAX_ATTEMPTS ]; do
     if curl -s http://localhost:3080/health > /dev/null; then
         echo "==> Node.js placeholder server started successfully"
-            return 0
+        break
     fi
     ATTEMPT=$((ATTEMPT+1))
     echo "==> Waiting for Node.js server to start (attempt $ATTEMPT/$MAX_ATTEMPTS)..."
     sleep 1
 done
 
+if [ $ATTEMPT -eq $MAX_ATTEMPTS ]; then
     echo "==> ERROR: Node.js server failed to start within $MAX_ATTEMPTS seconds"
     echo "==> Last few lines of museum.log:"
     tail -n 20 /app/data/logs/museum.log || echo "==> No log file found"
-    return 1
+    exit 1
-}
-
-# Setting up and attempting to run the Museum server
-echo "==> Setting up Museum server..."
-
-# Try using Docker to pull and run the Museum server
-MUSEUM_BIN="/app/data/ente/server/museum"
-MUSEUM_IMAGE="ghcr.io/ente-io/server:latest"
-VALID_BINARY=false
-
-# Check if Docker is available
-if command -v docker >/dev/null 2>&1; then
-    echo "==> Docker is available, attempting to use Museum server image"
-    
-    # Try pulling the Museum server image
-    if docker pull $MUSEUM_IMAGE; then
-        echo "==> Successfully pulled Museum server image"
-        
-        # Extract the Museum binary from the Docker image
-        TEMP_CONTAINER=$(docker create $MUSEUM_IMAGE)
-        if [ -n "$TEMP_CONTAINER" ]; then
-            echo "==> Created temporary container to extract Museum binary"
-            mkdir -p "$(dirname "$MUSEUM_BIN")"
-            if docker cp "$TEMP_CONTAINER:/app/museum" "$MUSEUM_BIN"; then
-                chmod +x "$MUSEUM_BIN"
-                docker rm "$TEMP_CONTAINER" >/dev/null
-                echo "==> Successfully extracted Museum binary from Docker image"
-                VALID_BINARY=true
-            else
-                echo "==> Failed to extract Museum binary from container"
-                docker rm "$TEMP_CONTAINER" >/dev/null
-            fi
-        else
-            echo "==> Failed to create temporary container"
-        fi
-    else
-        echo "==> Failed to pull Museum server image"
-    fi
-else
-    echo "==> Docker not available, skipping Docker-based Museum binary extraction"
-fi
-
-# If Docker extraction failed, try building from source
-if [ "$VALID_BINARY" = false ] && command -v go >/dev/null 2>&1; then
-    echo "==> Building Museum server from source..."
-    
-    # Navigate to the server directory
-    cd "$ENTE_DIR/server"
-    
-    # Build the Museum server
-    echo "==> Building Museum server..."
-    mkdir -p "$(dirname "$MUSEUM_BIN")"
-    export GOPATH="/app/data/go"
-    export PATH="$GOPATH/bin:$PATH"
-    
-    # Install required build dependencies
-    apt-get update -y && apt-get install -y golang-go gcc libsodium-dev pkg-config
-    
-    go build -o "$MUSEUM_BIN" ./cmd/museum
-    
-    if [ $? -eq 0 ] && [ -f "$MUSEUM_BIN" ] && [ -x "$MUSEUM_BIN" ]; then
-        echo "==> Successfully built Museum server"
-        VALID_BINARY=true
-    else
-        echo "==> Failed to build Museum server"
-    fi
-fi
-
-# Try running the Museum server if we have a valid binary
-if [ "$VALID_BINARY" = true ]; then
-    echo "==> Starting Museum server..."
-    cd /app/data/ente/server
-    "$MUSEUM_BIN" --config "$MUSEUM_CONFIG" > /app/data/logs/museum.log 2>&1 &
-    MUSEUM_PID=$!
-    echo "==> Started Museum server with PID: $MUSEUM_PID"
-    
-    # Wait for server to start
-    MAX_ATTEMPTS=30
-    ATTEMPT=0
-    while [ $ATTEMPT -lt $MAX_ATTEMPTS ]; do
-        if curl -s http://localhost:3080/health > /dev/null; then
-            echo "==> Museum server started successfully"
-            break
-        fi
-        ATTEMPT=$((ATTEMPT+1))
-        echo "==> Waiting for Museum server to start (attempt $ATTEMPT/$MAX_ATTEMPTS)..."
-        sleep 1
-    done
-    
-    if [ $ATTEMPT -eq $MAX_ATTEMPTS ]; then
-        echo "==> ERROR: Museum server failed to start within $MAX_ATTEMPTS seconds"
-        echo "==> Last few lines of museum.log:"
-        tail -n 20 /app/data/logs/museum.log || echo "==> No log file found"
-        echo "==> Falling back to Node.js placeholder server"
-        start_placeholder_server
-    fi
-else
-    echo "==> No valid Museum binary found, starting Node.js placeholder server"
-    start_placeholder_server
 fi
 
 # Download and set up web app
@@ -405,13 +465,27 @@ if [ ! -d "${WEB_DIR}/photos" ] || [ ! -f "${WEB_DIR}/photos/index.html" ]; then
         .container { max-width: 600px; margin: 0 auto; padding: 20px; }
         h1 { color: #333; }
         p { color: #666; }
+        .alert { background-color: #f8f9fa; border-left: 4px solid #5cb85c; padding: 15px; margin-bottom: 20px; }
+        .alert-info { border-color: #2196F3; }
+        .setup-box { background-color: #f5f5f5; padding: 20px; border-radius: 5px; margin-top: 20px; text-align: left; }
+        code { background-color: #f1f1f1; padding: 2px 5px; border-radius: 3px; font-family: monospace; }
     </style>
 </head>
 <body>
     <div class="container">
         <h1>Ente Photos</h1>
-        <p>This is a placeholder for the Ente Photos application. The actual app is being set up.</p>
+        <div class="alert alert-info">
-        <p>Please check your configuration or try building/downloading the web app again.</p>
+            <strong>Status:</strong> Running with placeholder server. Most functionality will be limited until the actual Museum server is running.
+        </div>
+        <p>This is the Ente Photos application running on Cloudron. To complete the setup, you need to:</p>
+        <div class="setup-box">
+            <ol>
+                <li>Configure your S3 storage in <code>/app/data/s3.env</code></li>
+                <li>The placeholder server is handling API requests for now</li>
+                <li>Visit <a href="/photos/">the photos app</a> to start using your self-hosted Ente instance</li>
+            </ol>
+        </div>
+        <p>For more information, visit <a href="https://help.ente.io/self-hosting" target="_blank">Ente Self-Hosting Documentation</a></p>
     </div>
 </body>
 </html>
@@ -429,7 +503,7 @@ EOF
     cp ${WEB_DIR}/photos/index.html ${WEB_DIR}/cast/index.html
     sed -i 's/Photos/Cast/g' ${WEB_DIR}/cast/index.html
     
-    echo "==> Created placeholder HTML files"
+    echo "==> Created improved placeholder HTML files"
 else
     echo "==> Ente web app already set up"
 fi
@@ -526,6 +600,46 @@ caddy run --config /app/data/Caddyfile > /app/data/logs/caddy.log 2>&1 &
 CADDY_PID=$!
 echo "==> Caddy web server started with PID: $CADDY_PID"
 
+# Create a small message to explain how to install the real Museum server
+cat > /app/data/INSTALL-REAL-SERVER.md << 'EOF'
+# Installing the Real Museum Server
+
+The placeholder Node.js server is currently running. To install the real Museum server, 
+follow these steps:
+
+1. Connect to your Cloudron server via SSH
+2. Download the Museum server binary manually using one of these methods:
+   
+   ```
+   # Install Go and build from source
+   apt-get update && apt-get install -y golang-go gcc libsodium-dev pkg-config
+   cd /app/data/ente/repository/server
+   export GOPATH="/app/data/go"
+   export PATH="$GOPATH/bin:$PATH"
+   go build -o /app/data/ente/server/museum ./cmd/museum
+   chmod +x /app/data/ente/server/museum
+   ```
+   
+   Or download a pre-built binary if available:
+   
+   ```
+   # Determine architecture
+   ARCH=$(uname -m)
+   OS=$(uname -s | tr '[:upper:]' '[:lower:]')
+   if [ "$ARCH" == "x86_64" ]; then ARCH="amd64"; fi
+   if [ "$ARCH" == "aarch64" ] || [ "$ARCH" == "arm64" ]; then ARCH="arm64"; fi
+   
+   # Try to download from GitHub releases
+   curl -L -o /app/data/ente/server/museum "https://github.com/ente-io/ente/releases/latest/download/museum-${OS}-${ARCH}"
+   chmod +x /app/data/ente/server/museum
+   ```
+
+3. Restart the Ente app in your Cloudron dashboard
+4. The script should now use the real Museum server instead of the placeholder
+
+EOF
+echo "==> Created installation guide for real Museum server"
+
 # Remove the flag file to indicate that we've started successfully
 rm -f /app/data/startup_in_progress
 echo "==> Setup complete, everything is running."