scriptorium 0.6.1 → 0.7.2

data/ui/web/app/app.rb

@@ -1,5 +1,20 @@
 #!/usr/bin/env ruby
 
+require 'optparse'
+
+# Parse command line arguments for test mode BEFORE requiring Sinatra
+# Starting web app, ARGV: #{ARGV.inspect}
+TEST_MODE = false
+OptionParser.new do |opts|
+  opts.on("--test", "Use test repository (scriptorium-TEST)") do
+    TEST_MODE = true
+    # --test flag detected
+  end
+end.parse!
+
+# Command line parsing complete, test_mode: #{TEST_MODE}
+# ARGV remaining: #{ARGV.inspect}
+
 require 'sinatra'
 require 'sinatra/reloader' if development?
 require 'fileutils'
@@ -12,14 +27,59 @@ end
 require_relative '../../../lib/scriptorium'
 require_relative 'error_helpers'
 
-include ErrorHelpers
-
 class ScriptoriumWeb < Sinatra::Base
+  include ErrorHelpers
+  include Scriptorium::Helpers
+  
   set :port, 4567
   set :bind, '0.0.0.0'
   set :views, File.join(__dir__, 'views')
   set :show_exceptions, false  # Disable Sinatra's default error display
   
+  # Configure static file serving for assets
+  configure do
+    # Set public folder to serve static files from the current view's output directory
+    # This will be updated dynamically based on the current view
+    set :public_folder, File.join(__dir__, '..', 'scriptorium-TEST', 'views', 'computing', 'output')
+  end
+  
+  # Update static file serving based on current view
+  before do
+    if @api&.current_view
+      public_path = @api.root/"views"/@api.current_view.name/"output"
+      if Dir.exist?(public_path)
+        settings.public_folder = public_path.to_s
+      end
+    end
+  end
+
+  # Helper method to render dashboard with error/message
+  def render_dashboard(error: nil, message: nil)
+    @error = error
+    @message = message
+    @current_view = @api&.current_view
+    @views = @api&.views || []
+    @posts = []
+    erb :dashboard
+  end
+  
+  # Helper method to add file/line info to error messages
+  def error_with_location(error, message)
+    error_location = "#{error.backtrace.first}" if error.backtrace
+    result = message
+    result += " (#{error_location})" if error_location
+    result
+  end
+  
+  # Set test mode
+  def self.test_mode=(value)
+    @@test_mode = value
+  end
+  
+  def self.test_mode
+    @@test_mode
+  end
+  
   # Enable reloading in development
   configure :development do
     register Sinatra::Reloader
@@ -36,11 +96,24 @@ class ScriptoriumWeb < Sinatra::Base
   # Initialize API instance
   before do
     begin
-      @api = Scriptorium::API.new
-      # Use absolute path to the test repository
-      test_repo_path = File.join(__dir__, "..", "scriptorium-TEST")
-      @api.open_repo(test_repo_path) if Dir.exist?(test_repo_path)
+      # Use the TEST_MODE constant that was set before OptionParser consumed ARGV
+      # Before block - test_mode: #{TEST_MODE}
+      @api = Scriptorium::API.new(testmode: TEST_MODE)
+      
+      if TEST_MODE
+        # Use test repository in the ui/web/ directory
+        test_repo_path = File.join(__dir__, "..", "scriptorium-TEST")
+        # Opening test repo: #{test_repo_path}
+        @api.open_repo(test_repo_path) if Dir.exist?(test_repo_path)
+      else
+        # Use production repository
+        home = ENV['HOME']
+        production_path = "#{home}/.scriptorium"
+        # Opening production repo: #{production_path}
+        @api.open_repo(production_path) if Dir.exist?(production_path)
+      end
     rescue => e
+      # Error in before block: #{e.message}
       @api = nil
     end
   end
@@ -54,10 +127,13 @@ class ScriptoriumWeb < Sinatra::Base
         
         # Only try to load posts if we have a current view
         if @current_view
-          @posts = @api.posts(@current_view.name) || []
+          File.write("/tmp/debug.log", "DEBUG: Route reached, current_view: #{@current_view.name}\n", mode: 'a')
+          @posts = @api.posts(@current_view.name, include_deleted: true) || []
+          File.write("/tmp/debug.log", "DEBUG: Posts loaded: #{@posts.length}\n", mode: 'a')
           if @posts.length > 0
           end
         else
+          File.write("/tmp/debug.log", "DEBUG: No current view\n", mode: 'a')
           @posts = []
         end
       else
@@ -77,16 +153,16 @@ class ScriptoriumWeb < Sinatra::Base
     view_name = params[:view_name]
     
     if view_name.nil? || view_name.strip.empty?
-      redirect "/?error=No view selected"
+      render_dashboard(error: "No view selected")
       return
     end
     
     begin
       view = @api.lookup_view(view_name)
       @api.view(view_name)
-      redirect '/?message=View changed successfully'
+      render_dashboard(message: "View changed successfully")
     rescue => e
-      redirect "/?error=Failed to change view: #{e.message}"
+      render_dashboard(error: error_with_location(e, "Failed to change view: #{e.message}"))
     end
   end
   
@@ -130,29 +206,32 @@ class ScriptoriumWeb < Sinatra::Base
         return
       end
       
+      # Get selected views from checkboxes
+      selected_views = params[:views] || [current_view.name]
+      selected_views = [current_view.name] if selected_views.empty?
+      
+      # Process tags
+      tags = params[:tags]&.strip
+      tags = tags&.split(',')&.map(&:strip) if tags && !tags.empty?
+      
       # Create a draft first
       draft_path = @api.create_draft(
         title: params[:title].strip,
         body: "",  # Empty body to start
-        views: current_view.name,
-        tags: nil,
-        blurb: nil
+        views: selected_views,
+        tags: tags,
+        blurb: params[:blurb]&.strip
       )
       
       # Convert draft to post immediately
       post_num = @api.finish_draft(draft_path)
       # Generate the post to create meta.txt and other files
       begin
-        STDERR.puts "DEBUG: About to call generate_post for post #{post_num}"
-        STDERR.puts "DEBUG: Current working directory: #{Dir.pwd}"
-        STDERR.puts "DEBUG: API root: #{@api.root}"
         @api.generate_post(post_num)
-        STDERR.puts "DEBUG: generate_post completed successfully"
         # Check if meta.txt was created
         meta_file = @api.root/"posts"/"#{post_num.to_s.rjust(4, '0')}"/"meta.txt"
-        STDERR.puts "DEBUG: Meta file path: #{meta_file}"
-        STDERR.puts "DEBUG: Meta file exists: #{File.exist?(meta_file)}"
-        redirect "/?message=Post '#{params[:title].strip}' created successfully (##{post_num})"
+        # Redirect back to dashboard with modal parameter to open CodeMirror editor
+        redirect "/view/#{current_view.name}?edit_post=#{post_num}"
               rescue => e
           # Log the actual error for debugging
           STDERR.puts "ERROR in generate_post: #{e.class}: #{e.message}"
@@ -182,14 +261,46 @@ class ScriptoriumWeb < Sinatra::Base
         return
       end
       
-      # Redirect to the edit page
-      redirect "/edit_post/#{params[:post_id]}"
+      # Redirect back to the view dashboard
+      current_view = @api&.current_view
+      if current_view
+        redirect "/view/#{current_view.name}?message=Post saved successfully"
+      else
+        redirect "/?message=Post saved successfully"
+      end
     rescue => e
       error_info = friendly_error_message(e)
       redirect "/?error=#{error_info[:message]}&suggestion=#{error_info[:suggestion]}"
     end
   end
 
+  # API endpoint to get post content for modal
+  get '/api/post_content/:id' do
+    begin
+      post_id = params[:id].to_i
+      post = @api.post(post_id)
+      
+      if post.nil?
+        status 404
+        return "Post not found"
+      end
+      
+      # Read the source file
+      source_file = @api.root/"posts"/"#{post.num.to_s.rjust(4, '0')}"/"source.lt3"
+      if File.exist?(source_file)
+        content = File.read(source_file)
+        content_type :text
+        content
+      else
+        status 404
+        "Source file not found"
+      end
+    rescue => e
+      status 500
+      "Error loading post content: #{e.message}"
+    end
+  end
+
   # Show edit post page
   get '/edit_post/:id' do
     post_id = params[:id]&.to_i
@@ -209,11 +320,14 @@ class ScriptoriumWeb < Sinatra::Base
       # Read the source file content
       source_file = @api.root/"posts"/@post.num/"source.lt3"
       if File.exist?(source_file)
-        @content = File.read(source_file)
+        @content = read_file(source_file)
       else
         @content = "# #{@post.title}\n\n"
       end
       
+      # Set current view for template
+      @current_view = @api&.current_view
+      
       erb :edit_post
     rescue => e
       redirect "/?error=Failed to load post: #{e.message}"
@@ -222,38 +336,84 @@ class ScriptoriumWeb < Sinatra::Base
 
   # Save edited post
   post '/save_post/:id' do
-    post_id = params[:id]&.to_i
-    content = params[:content]
-    
-    if post_id.nil? || post_id <= 0
-      redirect "/?error=Invalid post ID"
-      return
-    end
-    
-    if content.nil?
-      redirect "/edit_post/#{post_id}?error=No content provided"
-      return
-    end
-    
     begin
+      File.write('/tmp/save_post_debug.log', "=== SAVE POST ATTEMPT ===\n", mode: 'a')
+      File.write('/tmp/save_post_debug.log', "Time: #{Time.now}\n", mode: 'a')
+      File.write('/tmp/save_post_debug.log', "Post ID: #{params[:id]}\n", mode: 'a')
+      File.write('/tmp/save_post_debug.log', "Content length: #{params[:content]&.length || 0}\n", mode: 'a')
+
+      File.write('/tmp/save_post_debug.log', "API instance: #{@api.inspect}\n", mode: 'a')
+      
+      post_id = params[:id]&.to_i
+      content = params[:content]
+      
+      if post_id.nil? || post_id <= 0
+        File.write('/tmp/save_post_debug.log', "ERROR: Invalid post ID\n", mode: 'a')
+        redirect "/?error=Invalid post ID"
+        return
+      end
+      
+      if content.nil?
+        File.write('/tmp/save_post_debug.log', "ERROR: No content provided\n", mode: 'a')
+        redirect "/edit_post/#{post_id}?error=No content provided"
+        return
+      end
+      
+      File.write('/tmp/save_post_debug.log', "Looking up post #{post_id}\n", mode: 'a')
       post = @api.post(post_id)
       if post.nil?
+        File.write('/tmp/save_post_debug.log', "ERROR: Post not found\n", mode: 'a')
         redirect "/?error=Post not found"
         return
       end
       
+      File.write('/tmp/save_post_debug.log', "Post found: #{post.inspect}\n", mode: 'a')
+      File.write('/tmp/save_post_debug.log', "Post num: #{post.num}\n", mode: 'a')
+      
       # Write the content to the source file
       source_file = @api.root/"posts"/post.num/"source.lt3"
-      File.write(source_file, content)
+      File.write('/tmp/save_post_debug.log', "Source file: #{source_file}\n", mode: 'a')
+      write_file(source_file, content)
+      File.write('/tmp/save_post_debug.log', "File written successfully\n", mode: 'a')
       
       # Generate the post after saving
-      @api.generate_post(post_id)
+      File.write('/tmp/save_post_debug.log', "Generating post...\n", mode: 'a')
+      begin
+        @api.generate_post(post_id)
+        File.write('/tmp/save_post_debug.log', "Post generated successfully\n", mode: 'a')
+      rescue => e
+        File.write('/tmp/save_post_debug.log', "Generate post failed: #{e.class}: #{e.message}\n", mode: 'a')
+        File.write('/tmp/save_post_debug.log', "Backtrace: #{e.backtrace.first(3).join("\n")}\n", mode: 'a')
+        raise e
+      end
       
-      redirect "/?message=Post ##{post_id} saved and generated successfully"
+      # Regenerate the view index to include the updated post
+      File.write('/tmp/save_post_debug.log', "Regenerating view index...\n", mode: 'a')
+      begin
+        current_view = @api&.current_view
+        if current_view
+          @api.generate_view(current_view.name)
+          File.write('/tmp/save_post_debug.log', "View index regenerated successfully\n", mode: 'a')
+        end
+      rescue => e
+        File.write('/tmp/save_post_debug.log', "View regeneration failed: #{e.class}: #{e.message}\n", mode: 'a')
+        # Don't fail the save if view regeneration fails
+      end
+      
+      File.write('/tmp/save_post_debug.log', "SUCCESS: Redirecting to view dashboard\n", mode: 'a')
+      current_view = @api&.current_view
+      if current_view
+        redirect "/view/#{current_view.name}?message=Post saved successfully"
+      else
+        redirect "/?message=Post ##{post_id} saved and generated successfully"
+      end
     rescue => e
-      redirect "/edit_post/#{post_id}?error=Failed to save post: #{e.message}"
-    end
+      File.write('/tmp/save_post_debug.log', "EXCEPTION: #{e.class}: #{e.message}\n", mode: 'a')
+      File.write('/tmp/save_post_debug.log', "Backtrace: #{e.backtrace.first(5).join("\n")}\n", mode: 'a')
+      error_location = e.backtrace&.first || "unknown location"
+      redirect "/edit_post/#{post_id}?error=Failed to save post: #{e.message} at #{error_location}"
     end
+  end
 
   # Generate post
   post '/generate_post' do
@@ -285,44 +445,86 @@ class ScriptoriumWeb < Sinatra::Base
     
     begin
       if view_name.nil? || view_name.strip.empty?
-        redirect "/?error=No view specified"
+        render_dashboard(error: "No view specified")
         return
       end
       
       # Generate the view
       @api.generate_view(view_name)
-      redirect "/?message=View '#{view_name}' generated successfully"
+      render_dashboard(message: "View '#{view_name}' generated successfully")
     rescue => e
-      redirect "/?error=Failed to generate view: #{e.message}"
+      render_dashboard(error: error_with_location(e, "Failed to generate view: #{e.message}"))
     end
   end
 
   # Preview view
-  post '/preview_view' do
+  get '/preview' do
+    @current_view = @api&.current_view
+    if @current_view.nil?
+      render_dashboard(error: "No view selected. Please select a view first.")
+      return
+    end
+    
+    begin
+      # Generate the view first to ensure it's up to date
+      @api.generate_view(@current_view.name)
+      
+      # Redirect to the index route under /preview/:view_name so relative links resolve
+      redirect "/preview/#{@current_view.name}/index.html"
+    rescue => e
+      render_dashboard(error: error_with_location(e, "Failed to preview view: #{e.message}"))
+    end
+  end
+  
+  # Preview specific view index
+  get '/preview/:view_name/index.html' do
     view_name = params[:view_name]
     
     begin
       if view_name.nil? || view_name.strip.empty?
-        redirect "/?error=No view specified"
-        return
+        status 400
+        return "Bad request: missing view name"
       end
       
-      # Generate the view first to ensure it's up to date
+      # Generate the view to ensure it's up to date
       @api.generate_view(view_name)
       
-      # Redirect to the generated index.html file
-      view_dir = @api.root/"views"/view_name
-      index_file = view_dir/"output"/"index.html"
-      
+      # Serve the generated index.html file
+      index_file = @api.root/"views"/view_name/"output"/"index.html"
       if File.exist?(index_file)
-        # Return the HTML content directly for preview
         content_type :html
-        File.read(index_file)
+        read_file(index_file)
+      else
+        status 404
+        "Index file not found for view: #{view_name}"
+      end
+    rescue => e
+      status 500
+      "Error loading view: #{e.message}"
+    end
+  end
+
+  # Serve post_index.html fragment for SPA back navigation
+  get '/preview/:view_name/post_index.html' do
+    view_name = params[:view_name]
+    begin
+      if view_name.nil? || view_name.strip.empty?
+        status 400
+        return "Bad request: missing view name"
+      end
+      # Ensure view is generated
+      @api.generate_view(view_name)
+      fragment = @api.root/"views"/view_name/"output"/"post_index.html"
+      if File.exist?(fragment)
+        content_type :html
+        read_file(fragment)
       else
-        redirect "/?error=Preview file not found - view may not have been generated properly"
+        status 404
+        "Not found"
       end
     rescue => e
-      redirect "/?error=Failed to preview view: #{e.message}"
+      status 500
+      "Error loading post_index: #{e.message}"
     end
   end
 
@@ -331,35 +533,267 @@ class ScriptoriumWeb < Sinatra::Base
     view_name = params[:view_name]
     filename = params[:filename]
     
-    STDERR.puts "DEBUG: Preview request - view_name: #{view_name}, filename: #{filename}"
+    begin
+      if view_name.nil? || view_name.strip.empty? || filename.nil? || filename.strip.empty?
+        status 404
+        return "File not found"
+      end
+      
+      # Check if view has been generated (index.html exists)
+      index_file = @api.root/"views"/view_name/"output"/"index.html"
+      unless File.exist?(index_file)
+        status 404
+        return "View '#{view_name}' has not been generated. Please generate the view first."
+      end
+      
+      # Construct the file path
+      post_file = @api.root/"views"/view_name/"output"/"posts"/filename
+      
+      if File.exist?(post_file)
+        content_type :html
+        read_file(post_file)
+      else
+        status 404
+        "File not found: #{filename}"
+      end
+    rescue => e
+      status 500
+      "Error loading file: #{e.message}"
+    end
+  end
+
+  # Serve post content for iframe (with syntax highlighting)
+  get '/preview/:view_name/posts/:filename/content' do
+    view_name = params[:view_name]
+    filename = params[:filename]
     
     begin
       if view_name.nil? || view_name.strip.empty? || filename.nil? || filename.strip.empty?
-        STDERR.puts "DEBUG: Missing parameters"
         status 404
         return "File not found"
       end
       
       # Construct the file path
       post_file = @api.root/"views"/view_name/"output"/"posts"/filename
-      STDERR.puts "DEBUG: Looking for file: #{post_file}"
-      STDERR.puts "DEBUG: File exists: #{File.exist?(post_file)}"
       
       if File.exist?(post_file)
         content_type :html
-        File.read(post_file)
+        
+        # Read the post content
+        post_content = read_file(post_file)
+        
+        # Wrap in HTML document with syntax highlighting (Highlight.js)
+        html = <<~HTML
+          <!DOCTYPE html>
+          <html>
+          <head>
+            <meta charset="utf-8">
+            <title>Post Content</title>
+            <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/styles/default.min.css">
+            <style>
+              body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; margin: 20px; line-height: 1.6; }
+              pre { background: #f5f5f5; padding: 15px; border-radius: 5px; overflow-x: auto; }
+              code { background: #f5f5f5; padding: 2px 4px; border-radius: 3px; }
+            </style>
+          </head>
+          <body>
+            #{post_content}
+            <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/highlight.min.js"></script>
+            <script>
+              document.addEventListener('DOMContentLoaded', function() {
+                if (typeof hljs !== 'undefined') { hljs.highlightAll(); }
+              });
+            </script>
+          </body>
+          </html>
+        HTML
+        
+        html
+      else
+        status 404
+        "File not found: #{filename}"
+      end
+    rescue => e
+      status 500
+      "Error loading file: #{e.message}"
+    end
+  end
+  
+  # Serve permalink files for preview
+  get '/preview/:view_name/permalink/:filename' do
+    view_name = params[:view_name]
+    filename = params[:filename]
+    
+    begin
+      if view_name.nil? || view_name.strip.empty? || filename.nil? || filename.strip.empty?
+        status 404
+        return "File not found"
+      end
+      
+      # Check if view has been generated (index.html exists)
+      index_file = @api.root/"views"/view_name/"output"/"index.html"
+      unless File.exist?(index_file)
+        status 404
+        return "View '#{view_name}' has not been generated. Please generate the view first."
+      end
+      
+      # Construct the file path
+      permalink_file = @api.root/"views"/view_name/"output"/"permalink"/filename
+      
+      if File.exist?(permalink_file)
+        content_type :html
+        read_file(permalink_file)
+      else
+        status 404
+        "File not found: #{filename}"
+      end
+    rescue => e
+      status 500
+      "Error loading file: #{e.message}"
+    end
+  end
+
+  # Serve assets for preview
+  get '/preview/:view_name/assets/*' do
+    view_name = params[:view_name]
+    asset_path = params[:splat].first
+    
+    begin
+      if view_name.nil? || view_name.strip.empty? || asset_path.nil? || asset_path.strip.empty?
+        status 404
+        return "Asset not found"
+      end
+      
+      # Check if view has been generated (index.html exists)
+      index_file = @api.root/"views"/view_name/"output"/"index.html"
+      unless File.exist?(index_file)
+        status 404
+        return "View '#{view_name}' has not been generated. Please generate the view first."
+      end
+      
+      # Construct the asset file path (serve from generated output assets)
+      asset_file = @api.root/"views"/view_name/"output"/"assets"/asset_path
+      # Fallback: if not present in output assets, try view assets directly
+      unless File.exist?(asset_file)
+        fallback_asset = @api.root/"views"/view_name/"assets"/asset_path
+        asset_file = fallback_asset if File.exist?(fallback_asset)
+      end
+      
+      if File.exist?(asset_file)
+        # Set appropriate content type based on file extension
+        case File.extname(asset_file).downcase
+        when '.png'
+          content_type 'image/png'
+        when '.jpg', '.jpeg'
+          content_type 'image/jpeg'
+        when '.gif'
+          content_type 'image/gif'
+        when '.svg'
+          content_type 'image/svg+xml'
+        when '.css'
+          content_type 'text/css'
+        when '.js'
+          content_type 'application/javascript'
+        else
+          content_type 'application/octet-stream'
+        end
+        
+        read_file(asset_file)
+      else
+        status 404
+        "Asset not found: #{asset_path}"
+      end
+    rescue => e
+      status 500
+      "Error loading asset: #{e.message}"
+    end
+  end
+
+  # (timing route removed)
+
+  # Serve post files relative to preview route
+  get '/posts/:filename' do
+    filename = params[:filename]
+    @current_view = @api&.current_view
+    
+    begin
+      if filename.nil? || filename.strip.empty? || @current_view.nil?
+        status 404
+        return "File not found"
+      end
+      
+      # Construct the file path
+      post_file = @api.root/"views"/@current_view.name/"output"/"posts"/filename
+      
+      if File.exist?(post_file)
+        content_type :html
+        read_file(post_file)
       else
-        STDERR.puts "DEBUG: File not found"
         status 404
         "File not found: #{filename}"
       end
     rescue => e
-      STDERR.puts "DEBUG: Error: #{e.message}"
       status 500
       "Error loading file: #{e.message}"
     end
   end
 
+  # Handle direct access to posts via index.html?post=filename
+  get '/index.html' do
+    post_param = params[:post]
+    @current_view = @api&.current_view
+    
+    begin
+      if @current_view.nil?
+        status 404
+        return "View not found"
+      end
+      
+      # Always return the full index.html page
+      # The JavaScript will handle loading the specific post if post_param is provided
+      index_file = @api.root/"views"/@current_view.name/"output"/"index.html"
+      
+      if File.exist?(index_file)
+        content_type :html
+        read_file(index_file)
+      else
+        status 404
+        "Index page not found"
+      end
+    rescue => e
+      status 500
+      "Error loading page: #{e.message}"
+    end
+  end
+
+  # Handle permalink access to posts
+  get '/permalink/:filename' do
+    filename = params[:filename]
+    @current_view = @api&.current_view
+    
+    begin
+      if filename.nil? || filename.strip.empty? || @current_view.nil?
+        status 404
+        return "Post not found"
+      end
+      
+      # Construct the file path
+      post_file = @api.root/"views"/@current_view.name/"output"/"posts"/filename
+      
+      if File.exist?(post_file)
+        # Redirect to the index page with the post parameter
+        # This allows the JavaScript to handle the post loading properly
+        redirect "/index.html?post=#{filename}"
+      else
+        status 404
+        "Post not found: #{filename}"
+      end
+    rescue => e
+      status 500
+      "Error loading post: #{e.message}"
+    end
+  end
+
   # Show view configuration page
   get '/configure_view/:name' do
     begin
@@ -411,7 +845,7 @@ class ScriptoriumWeb < Sinatra::Base
         config_content += "theme    #{params[:view_theme]}\n"
         
         config_file = @api.root/"views"/view_name/"config.txt"
-        File.write(config_file, config_content)
+        write_file(config_file, config_content)
       end
       
       # Step 2: Save layout configuration
@@ -438,7 +872,7 @@ class ScriptoriumWeb < Sinatra::Base
         
         layout_file = @api.root/"views"/view_name/"config"/"layout.txt"
         FileUtils.mkdir_p(File.dirname(layout_file))
-        File.write(layout_file, layout_content)
+        write_file(layout_file, layout_content)
       end
       
       # Step 3: Save container content files
@@ -449,7 +883,7 @@ class ScriptoriumWeb < Sinatra::Base
         if params[content_param]
           content_file = @api.root/"views"/view_name/"config"/"#{container}.txt"
           FileUtils.mkdir_p(File.dirname(content_file))
-          File.write(content_file, params[content_param])
+          write_file(content_file, params[content_param])
           
           # If this is header with "banner svg", create default svg.txt
           if container == 'header' && params[content_param].strip == 'banner svg'
@@ -461,7 +895,7 @@ class ScriptoriumWeb < Sinatra::Base
               default_svg_content += "back.linear #f8f9fa #e9ecef lr\n"
               default_svg_content += "text.color #374151\n"
               default_svg_content += "title.style bold\n"
-              File.write(svg_file, default_svg_content)
+              write_file(svg_file, default_svg_content)
             end
           end
         end
@@ -483,7 +917,7 @@ class ScriptoriumWeb < Sinatra::Base
     
     # Get current SVG config
     svg_file = @api.root/"views"/@current_view.name/"config"/"svg.txt"
-    @svg_config = File.exist?(svg_file) ? File.read(svg_file) : ""
+    @svg_config = File.exist?(svg_file) ? read_file(svg_file) : ""
     
     # Generate current banner for display
     begin
@@ -498,7 +932,7 @@ class ScriptoriumWeb < Sinatra::Base
         banner.parse_header_svg
       end
       
-      @banner_svg = banner.generate_svg
+      @banner_svg = banner.get_svg
     rescue => e
       @banner_svg = "<p>Error generating banner: #{e.message}</p>"
     end
@@ -520,7 +954,7 @@ class ScriptoriumWeb < Sinatra::Base
       # Save the SVG configuration
       svg_file = @api.root/"views"/@current_view.name/"config"/"svg.txt"
       FileUtils.mkdir_p(File.dirname(svg_file))
-      File.write(svg_file, svg_config)
+              write_file(svg_file, svg_config)
       
       # Update status
       update_config_status(@current_view.name, "banner", true)
@@ -541,7 +975,7 @@ class ScriptoriumWeb < Sinatra::Base
     
     # Get current navbar config
     navbar_file = @api.root/"views"/@current_view.name/"config"/"navbar.txt"
-    @navbar_config = File.exist?(navbar_file) ? File.read(navbar_file).strip : ""
+    @navbar_config = File.exist?(navbar_file) ? read_file(navbar_file).strip : ""
     
     # Generate current navbar preview
     begin
@@ -574,7 +1008,7 @@ class ScriptoriumWeb < Sinatra::Base
       
       # Read current navbar config
       navbar_file = @api.root/"views"/@current_view.name/"config"/"navbar.txt"
-      current_config = File.exist?(navbar_file) ? File.read(navbar_file).strip : ""
+      current_config = File.exist?(navbar_file) ? read_file(navbar_file).strip : ""
       
       # Add new item based on action
       if action == "link"
@@ -594,7 +1028,7 @@ class ScriptoriumWeb < Sinatra::Base
       
       # Save the updated configuration
       FileUtils.mkdir_p(File.dirname(navbar_file))
-      File.write(navbar_file, updated_config.rstrip + "\n")
+      write_file(navbar_file, updated_config.rstrip + "\n")
       
       redirect "/navbar_config?message=#{message}"
     rescue => e
@@ -632,7 +1066,7 @@ class ScriptoriumWeb < Sinatra::Base
       
       # Read current navbar config
       navbar_file = @api.root/"views"/@current_view.name/"config"/"navbar.txt"
-      current_config = File.exist?(navbar_file) ? File.read(navbar_file).strip : ""
+      current_config = File.exist?(navbar_file) ? read_file(navbar_file).strip : ""
       
       # Find the parent and add child after it
       lines = current_config.lines
@@ -655,7 +1089,7 @@ class ScriptoriumWeb < Sinatra::Base
       
       # Save the updated configuration
       FileUtils.mkdir_p(File.dirname(navbar_file))
-      File.write(navbar_file, new_lines.join.rstrip + "\n")
+      write_file(navbar_file, new_lines.join.rstrip + "\n")
       
       redirect "/navbar_config?message=Added #{label} as child of #{parent}"
     rescue => e
@@ -681,7 +1115,7 @@ class ScriptoriumWeb < Sinatra::Base
       # Save the configuration
       navbar_file = @api.root/"views"/@current_view.name/"config"/"navbar.txt"
       FileUtils.mkdir_p(File.dirname(navbar_file))
-      File.write(navbar_file, config.rstrip + "\n")
+      write_file(navbar_file, config.rstrip + "\n")
       
       # Check for missing pages and create them
       pages_created = []
@@ -709,7 +1143,7 @@ class ScriptoriumWeb < Sinatra::Base
               page_file = pages_dir/filename
               unless File.exist?(page_file)
                 content = ".page_title #{title}\n\n"
-                File.write(page_file, content)
+                write_file(page_file, content)
                 pages_created << filename
               end
             end
@@ -730,7 +1164,7 @@ class ScriptoriumWeb < Sinatra::Base
               page_file = pages_dir/filename
               unless File.exist?(page_file)
                 content = ".page_title #{title}\n\n"
-                File.write(page_file, content)
+                write_file(page_file, content)
                 pages_created << filename
               end
             end
@@ -766,7 +1200,7 @@ class ScriptoriumWeb < Sinatra::Base
       Dir.glob(pages_dir/"*").each do |file|
         next unless File.file?(file)
         filename = File.basename(file)
-        content = File.read(file)
+        content = read_file(file)
         
         # Extract page title from .page_title directive
         title = nil
@@ -791,8 +1225,15 @@ class ScriptoriumWeb < Sinatra::Base
 
   # Save page content
   post '/edit_pages/save' do
+    File.write('/tmp/edit_pages_debug.log', "=== SAVE ATTEMPT ===\n", mode: 'a')
+    File.write('/tmp/edit_pages_debug.log', "Time: #{Time.now}\n", mode: 'a')
+    File.write('/tmp/edit_pages_debug.log', "API instance: #{@api.inspect}\n", mode: 'a')
+    File.write('/tmp/edit_pages_debug.log', "Current view: #{@api&.current_view&.inspect}\n", mode: 'a')
+    File.write('/tmp/edit_pages_debug.log', "Params: #{params.inspect}\n", mode: 'a')
+    
     @current_view = @api&.current_view
     if @current_view.nil?
+      File.write('/tmp/edit_pages_debug.log', "ERROR: No current view\n", mode: 'a')
       redirect "/?error=No view selected. Please select a view first."
       return
     end
@@ -801,19 +1242,28 @@ class ScriptoriumWeb < Sinatra::Base
       filename = params[:filename]&.strip
       content = params[:content]&.strip || ""
       
+      File.write('/tmp/edit_pages_debug.log', "Filename: #{filename.inspect}\n", mode: 'a')
+      File.write('/tmp/edit_pages_debug.log', "Content length: #{content.length}\n", mode: 'a')
+      
       if filename.nil? || filename.empty?
+        File.write('/tmp/edit_pages_debug.log', "ERROR: Filename is empty\n", mode: 'a')
         redirect "/edit_pages?error=Filename is required"
         return
       end
       
       # Save the page
       pages_dir = @api.root/"views"/@current_view.name/"pages"
+      File.write('/tmp/edit_pages_debug.log', "Pages dir: #{pages_dir}\n", mode: 'a')
       FileUtils.mkdir_p(pages_dir)
       page_file = pages_dir/filename
+      File.write('/tmp/edit_pages_debug.log', "Page file: #{page_file}\n", mode: 'a')
       File.write(page_file, content)
+      File.write('/tmp/edit_pages_debug.log', "SUCCESS: File written\n", mode: 'a')
       
       redirect "/edit_pages?message=Page '#{filename}' saved successfully"
     rescue => e
+      File.write('/tmp/edit_pages_debug.log', "EXCEPTION: #{e.class}: #{e.message}\n", mode: 'a')
+      File.write('/tmp/edit_pages_debug.log', "Backtrace: #{e.backtrace.first(5).join("\n")}\n", mode: 'a')
       redirect "/edit_pages?error=Failed to save page: #{e.message}"
     end
   end
@@ -822,68 +1272,111 @@ class ScriptoriumWeb < Sinatra::Base
   get '/view/:name' do
     view_name = params[:name]
     
+    # Debug logging
+    File.write('/tmp/dashboard_debug.log', "Dashboard accessed for view: #{view_name} at #{Time.now}\n", mode: 'a')
+    
     begin
       # Look up the view
-      view = @api.lookup_view(view_name)
-      if view.nil?
+      @current_view = @api.lookup_view(view_name)
+      if @current_view.nil?
         redirect "/?error=View '#{view_name}' not found"
         return
       end
       
+      # Get all views for the checkbox list
+      @views = @api.views || []
+      
       # Set as current view
       @api.view(view_name)
-      @current_view = @api.current_view
+      # @current_view = @api.current_view # This line is now redundant as @current_view is set above
+      
+      # Auto-generate view if not already generated
+      index_file = @api.root/"views"/view_name/"output"/"index.html"
+      unless File.exist?(index_file)
+        begin
+          @api.generate_view(view_name)
+        rescue => e
+          # Log the error but don't fail the dashboard load
+          File.write('/tmp/dashboard_debug.log', "Auto-generation failed: #{e.message}\n", mode: 'a')
+        end
+      end
       
       # Generate banner for display
       begin
-        bsvg = Scriptorium::BannerSVG.new(view.title, view.subtitle)
+        bsvg = Scriptorium::BannerSVG.new(@current_view.title, @current_view.subtitle)
         svg_config_file = @api.root/"views"/view_name/"config"/"svg.txt"
         if File.exist?(svg_config_file)
-          # Temporarily rename svg.txt to config.txt for BannerSVG compatibility
-          config_dir = @api.root/"views"/view_name/"config"
-          Dir.chdir(config_dir) do
-            if File.exist?("config.txt")
-              File.rename("config.txt", "config.txt.backup")
-            end
-            File.rename("svg.txt", "config.txt")
-            
-            begin
-              bsvg.parse_header_svg
-            ensure
-              # Restore original files
-              File.rename("config.txt", "svg.txt")
-              if File.exist?("config.txt.backup")
-                File.rename("config.txt.backup", "config.txt")
-              end
-            end
-          end
+          bsvg.parse_header_svg(svg_config_file)
         else
           bsvg.parse_header_svg
         end
         # Generate responsive SVG for web display
-        svg_html = bsvg.generate_svg
-        # Extract the SVG element and make it responsive
-        svg_match = svg_html.match(/<svg[^>]*>(.*)<\/svg>/m)
-        if svg_match
-          svg_content = svg_match[1]
-          # Calculate height based on aspect ratio (7.0 from config)
-          width = 800
-          height = (width / 7.0).to_i
-          @banner_svg = <<~HTML
-            <svg xmlns='http://www.w3.org/2000/svg' 
-                 width='100%' height='auto' 
-                 viewBox='0 0 #{width} #{height}' 
-                 preserveAspectRatio='xMidYMid meet'>
-              #{svg_content}
-            </svg>
-          HTML
-        else
-          @banner_svg = svg_html
-        end
+        svg_html = bsvg.get_svg
+        File.write('/tmp/dashboard_debug.log', "get_svg returned: #{svg_html[0..200]}...\n", mode: 'a')
+        @banner_svg = svg_html
       rescue => e
         @banner_svg = "<p>Error generating banner: #{e.message}</p>"
       end
       
+      # Get posts for pagination
+      begin
+        posts = @api.posts(view_name, include_deleted: true) || []
+        
+        # Debug: check if include_deleted is working
+        File.write('/tmp/dashboard_debug.log', "Found #{posts.length} posts (including deleted)\n", mode: 'a')
+        deleted_count = posts.count(&:deleted)
+        File.write('/tmp/dashboard_debug.log', "Deleted posts: #{deleted_count}\n", mode: 'a')
+        
+        # Debug: log first few posts and their dates for ordering analysis
+        posts.first(5).each_with_index do |post, i|
+          File.write('/tmp/dashboard_debug.log', "Post #{i}: #{post.num} - #{post.title} - date: #{post.date}\n", mode: 'a')
+        end
+        
+        posts.sort! { |a, b| post_compare(a, b) } # Sort by date, newest first
+        
+        # Get posts per page from config, default to 10
+        config_file = @api.root/"views"/view_name/"config"/"post_index.txt"
+        posts_per_page = 10
+        if File.exist?(config_file)
+          config_content = read_file(config_file)
+          if config_content.strip.length > 0
+            posts_per_page = config_content.lines.first.strip.split.last.to_i
+          end
+        end
+        
+        # Pagination logic
+        page = (params[:page] || 1).to_i
+        total_posts = posts.length
+        total_pages = (total_posts.to_f / posts_per_page).ceil
+        
+        # Debug pagination
+        File.write('/tmp/dashboard_debug.log', "Page requested: #{params[:page]}, calculated: #{page}, total_pages: #{total_pages}\n", mode: 'a')
+        
+        # Preserve current page if possible, otherwise reset to 1
+        if page > total_pages && total_pages > 0
+          page = total_pages
+          File.write('/tmp/dashboard_debug.log', "Page adjusted to total_pages: #{page}\n", mode: 'a')
+        elsif page < 1 || total_pages == 0
+          page = 1
+          File.write('/tmp/dashboard_debug.log', "Page reset to 1\n", mode: 'a')
+        end
+        
+        start_index = (page - 1) * posts_per_page
+        end_index = [start_index + posts_per_page - 1, total_posts - 1].min
+        
+        @posts = posts[start_index..end_index] || []
+        @current_page = page
+        @total_pages = total_pages
+        @total_posts = total_posts
+        @posts_per_page = posts_per_page
+      rescue => e
+        @posts = []
+        @current_page = 1
+        @total_pages = 1
+        @total_posts = 0
+        @posts_per_page = 10
+      end
+      
       erb :view_dashboard
     rescue => e
       redirect "/?error=Failed to load view dashboard: #{e.message}"
@@ -904,14 +1397,9 @@ class ScriptoriumWeb < Sinatra::Base
     @configs = {}
     
     if File.exist?(status_file)
-      status_content = File.read(status_file)
-      status_content.lines.each do |line|
-        line = line.strip
-        next if line.empty? || line.start_with?('#')
-        if line.include?(' ')
-          key, value = line.split(/\s+/, 2)
-          @configs[key.to_sym] = value == 'y'
-        end
+      status_config = @api.parse_commented_file(status_file)
+      status_config.each do |key, value|
+        @configs[key.to_sym] = value == 'y'
       end
     else
       # Default to all 'n' if status file doesn't exist
@@ -930,16 +1418,9 @@ class ScriptoriumWeb < Sinatra::Base
     layout_file = config_dir/"layout.txt"
     @layout_containers = []
     if File.exist?(layout_file)
-      layout_content = File.read(layout_file)
-      layout_content.lines.each do |line|
-        line = line.strip
-        next if line.empty? || line.start_with?('#')
-        if line.include?(' ')
-          container = line.split(/\s+/, 2)[0]
-          @layout_containers << container
-        else
-          @layout_containers << line
-        end
+      layout_config = @api.parse_commented_file(layout_file)
+      layout_config.each do |container, _|
+        @layout_containers << container
       end
     end
     
@@ -958,7 +1439,7 @@ class ScriptoriumWeb < Sinatra::Base
     header_file = @api.root/"views"/@current_view.name/"config"/"header.txt"
     @current_config = ""
     if File.exist?(header_file)
-      @current_config = File.read(header_file).strip
+      @current_config = read_file(header_file).strip
     end
     
     # Parse current settings
@@ -988,7 +1469,7 @@ class ScriptoriumWeb < Sinatra::Base
       # Save the header configuration
       header_file = @api.root/"views"/@current_view.name/"config"/"header.txt"
       FileUtils.mkdir_p(File.dirname(header_file))
-      File.write(header_file, header_content.join("\n") + "\n")
+              write_file(header_file, header_content.join("\n") + "\n")
       
       # Update status
       update_config_status(@current_view.name, "header", true)
@@ -1011,7 +1492,7 @@ class ScriptoriumWeb < Sinatra::Base
     deploy_file = @api.root/"views"/@current_view.name/"config"/"deploy.txt"
     @deploy_config = ""
     if File.exist?(deploy_file)
-      @deploy_config = File.read(deploy_file).strip
+      @deploy_config = read_file(deploy_file).strip
     end
     
     erb :deploy_config
@@ -1031,17 +1512,168 @@ class ScriptoriumWeb < Sinatra::Base
       # Save the deployment configuration
       deploy_file = @api.root/"views"/@current_view.name/"config"/"deploy.txt"
       FileUtils.mkdir_p(File.dirname(deploy_file))
-      File.write(deploy_file, deploy_config + "\n")
+              write_file(deploy_file, deploy_config + "\n")
       
       # Update status
       update_config_status(@current_view.name, "deploy", true)
       
-      redirect "/advanced_config?message=Deployment configuration updated successfully"
+      # Check if user came from deploy button - if so, auto-deploy
+      if params[:from_deploy] == "1"
+        # User came from deploy button, perform deployment automatically
+        begin
+          # Log deployment attempt
+          File.open("/tmp/web_deploy.log", "a") do |f|
+            f.puts "=== AUTO-DEPLOYMENT AFTER CONFIG #{Time.now} ==="
+            f.puts "  View name: #{@current_view.name}"
+            f.puts "  API object: #{@api.class}"
+            f.puts "  Repo root: #{@api.root}"
+          end
+          
+          # Perform deployment
+          result = @api.deploy(@current_view.name)
+          
+          # Log deployment result
+          File.open("/tmp/web_deploy.log", "a") do |f|
+            f.puts "  Auto-deployment result: #{result}"
+            f.puts "  Auto-deployment completed successfully"
+          end
+          
+          if result
+            redirect "/view/#{@current_view.name}?deploy_success=Deployment completed successfully&hide_uploading=1"
+          else
+            redirect "/view/#{@current_view.name}?error=Deployment failed&hide_uploading=1"
+          end
+        rescue => e
+          # Log deployment error
+          File.open("/tmp/web_deploy.log", "a") do |f|
+            f.puts "  Auto-deployment error: #{e.message}"
+            f.puts "  Backtrace: #{e.backtrace.first(5).join("\n    ")}"
+          end
+          redirect "/view/#{@current_view.name}?error=Deployment configuration updated but deployment failed: #{e.message}&hide_uploading=1"
+        end
+      else
+        # Normal case - user went to deploy config directly, just return to advanced config
+        redirect "/advanced_config?message=Deployment configuration updated successfully"
+      end
     rescue => e
       redirect "/deploy_config?error=Failed to save deployment configuration: #{e.message}"
     end
   end
 
+  # Deploy current view
+  get '/deploy' do
+    @current_view = @api&.current_view
+    if @current_view.nil?
+      redirect "/?error=No view selected. Please select a view first."
+      return
+    end
+    
+    # Check if deployment is ready
+    unless @api.can_deploy?(@current_view.name)
+      redirect "/deploy_config?error=View is not ready for deployment. Please configure deployment first.&from_deploy=1"
+      return
+    end
+    
+    # Perform deployment directly
+    begin
+      # Log deployment attempt
+      File.open("/tmp/web_deploy.log", "a") do |f|
+        f.puts "=== WEB DEPLOYMENT ATTEMPT #{Time.now} ==="
+        f.puts "  View name: #{@current_view.name}"
+        f.puts "  API object: #{@api.class}"
+        f.puts "  Repo root: #{@api.root}"
+      end
+      
+      # Perform deployment
+      result = @api.deploy(@current_view.name)
+      
+      # Log deployment result
+      File.open("/tmp/web_deploy.log", "a") do |f|
+        f.puts "  Deployment result: #{result}"
+        f.puts "  Deployment completed successfully"
+      end
+      
+      if result
+        redirect "/view/#{@current_view.name}?deploy_success=Deployment completed successfully&hide_uploading=1"
+      else
+        redirect "/view/#{@current_view.name}?error=Deployment failed&hide_uploading=1"
+      end
+    rescue => e
+      # Log deployment error
+      File.open("/tmp/web_deploy.log", "a") do |f|
+        f.puts "  Deployment error: #{e.message}"
+        f.puts "  Backtrace: #{e.backtrace.first(5).join("\n    ")}"
+      end
+      redirect "/view/#{@current_view.name}?error=Deployment failed: #{e.message}"
+    end
+  end
+
+
+
+  # Browse deployed view
+  get '/browse' do
+    @current_view = @api&.current_view
+    if @current_view.nil?
+      redirect "/?error=No view selected. Please select a view first."
+      return
+    end
+    
+    # Check if deployment configuration exists
+    deploy_file = @api.root/"views"/@current_view.name/"config"/"deploy.txt"
+    unless File.exist?(deploy_file)
+      redirect "/deploy_config?error=No deployment configuration found. Please configure deployment first."
+      return
+    end
+    
+    # Read deployment configuration and extract domain
+    deploy_config = read_file(deploy_file).strip
+    if deploy_config.empty?
+      redirect "/deploy_config?error=Deployment configuration is empty."
+      return
+    end
+    
+    # Extract domain and path from deploy config (simple parsing)
+    lines = deploy_config.split("\n")
+    domain = nil
+    path = nil
+    lines.each do |line|
+      line = line.strip
+      next if line.empty? || line.start_with?('#')
+      if line.match(/^(\w+)\s+(.+)$/)
+        key = $1.strip
+        value = $2.strip
+        if key == 'proto' && value.start_with?('http')
+          # Look for server and path fields to construct URL
+          lines.each do |config_line|
+            config_line = config_line.strip
+            next if config_line.empty? || config_line.start_with?('#')
+            if config_line.match(/^(\w+)\s+(.+)$/)
+              config_key = $1.strip
+              config_value = $2.strip
+              if config_key == 'server'
+                domain = "#{value}://#{config_value}"
+              elsif config_key == 'path'
+                path = config_value
+              end
+            end
+          end
+          break
+        end
+      end
+    end
+    
+    if domain
+      # Append path if it exists
+      if path && !path.empty?
+        redirect "#{domain}/#{path}"
+      else
+        redirect domain
+      end
+    else
+      redirect "/deploy_config?error=Could not extract domain from deployment configuration."
+    end
+  end
+
   # Layout configuration page
   get '/layout_config' do
     @current_view = @api&.current_view
@@ -1054,7 +1686,7 @@ class ScriptoriumWeb < Sinatra::Base
     layout_file = @api.root/"views"/@current_view.name/"config"/"layout.txt"
     @layout_config = ""
     if File.exist?(layout_file)
-      @layout_config = File.read(layout_file).strip
+      @layout_config = read_file(layout_file).strip
     end
     
     erb :layout_config
@@ -1074,7 +1706,7 @@ class ScriptoriumWeb < Sinatra::Base
       # Save the layout configuration
       layout_file = @api.root/"views"/@current_view.name/"config"/"layout.txt"
       FileUtils.mkdir_p(File.dirname(layout_file))
-      File.write(layout_file, layout_config + "\n")
+              write_file(layout_file, layout_config + "\n")
       
       redirect "/advanced_config?message=Layout configuration updated successfully"
     rescue => e
@@ -1082,32 +1714,34 @@ class ScriptoriumWeb < Sinatra::Base
     end
   end
 
-  # Serve global assets
-  get '/assets/*' do
-    asset_path = params[:splat].first
-    asset_file = @api.root/"assets"/asset_path
-    
-    if File.exist?(asset_file) && File.file?(asset_file)
-      send_file asset_file
-    else
-      status 404
-      "Asset not found"
+  # Serve web app's own assets (like livetext_mode.js)
+  get '/web_assets/*' do
+    begin
+      asset_path = params[:splat].first
+      asset_file = File.join(Dir.pwd, 'ui', 'web', 'app', 'assets', asset_path)
+      
+      puts "DEBUG: Asset path: #{asset_path}"
+      puts "DEBUG: Asset file: #{asset_file}"
+      puts "DEBUG: File exists: #{File.exist?(asset_file)}"
+      puts "DEBUG: Is file: #{File.file?(asset_file)}"
+      
+      if File.exist?(asset_file) && File.file?(asset_file)
+        send_file asset_file
+      else
+        status 404
+        "Web asset not found"
+      end
+    rescue => e
+      puts "DEBUG: Exception in web_assets: #{e.class}: #{e.message}"
+      puts "DEBUG: Backtrace: #{e.backtrace.first(3).join("\n")}"
+      status 500
+      "Internal server error: #{e.message}"
     end
   end
 
-  # Serve view-specific assets
-  get '/views/:view_name/assets/*' do
-    view_name = params[:view_name]
-    asset_path = params[:splat].first
-    asset_file = @api.root/"views"/view_name/"assets"/asset_path
-    
-    if File.exist?(asset_file) && File.file?(asset_file)
-      send_file asset_file
-    else
-      status 404
-      "Asset not found"
-    end
-  end
+  # Static files are now served directly by Sinatra from the public_folder
+  # No custom routes needed for assets
+
 
   # Server status endpoint
   get '/status' do
@@ -1184,14 +1818,76 @@ class ScriptoriumWeb < Sinatra::Base
       end
     end
     
+    # Get post-specific assets
+    @post_assets = []
+    posts_dir = @api.root/:posts
+    if Dir.exist?(posts_dir)
+      Dir.glob(posts_dir/"*").each do |post_dir|
+        next unless Dir.exist?(post_dir)
+        post_num = File.basename(post_dir)
+        next unless post_num.match?(/^\d{4}$/) # Only process 4-digit post numbers
+        
+        post_id = post_num.to_i
+        assets = @api.list_assets('post', post_id)
+        assets.each do |asset|
+          @post_assets << asset.merge({
+            post_id: post_id,
+            post_title: get_post_title(post_id)
+          })
+        end
+      end
+    end
+    
     # Sort all asset lists
     @global_assets.sort_by! { |asset| asset[:filename] }
     @library_assets.sort_by! { |asset| asset[:filename] }
     @view_assets.sort_by! { |asset| asset[:filename] }
+    @post_assets.sort_by! { |asset| [asset[:post_id], asset[:filename]] }
     
     erb :asset_management
   end
 
+  # Upload post-specific asset
+  post '/upload_post_asset' do
+    @current_view = @api&.current_view
+    if @current_view.nil?
+      redirect "/?error=No view selected. Please select a view first."
+      return
+    end
+    
+    begin
+      post_id = params[:post_id]&.to_i
+      file = params[:file]
+      
+      if post_id.nil? || post_id <= 0
+        redirect "/view/#{@current_view.name}?error=Invalid post ID"
+        return
+      end
+      
+      if file.nil? || file[:tempfile].nil?
+        redirect "/view/#{@current_view.name}?error=No file selected"
+        return
+      end
+      
+      # Check if post exists
+      post = @api.post(post_id)
+      if post.nil?
+        redirect "/view/#{@current_view.name}?error=Post #{post_id} not found"
+        return
+      end
+      
+      filename = file[:filename]
+      tempfile = file[:tempfile]
+      
+      # Use the API to upload the asset with original filename
+      target_file = @api.upload_asset(tempfile.path, 'post', post_id, filename: filename)
+      
+      redirect "/view/#{@current_view.name}?message=Asset '#{filename}' uploaded successfully to post ##{post_id}"
+    rescue => e
+      redirect "/view/#{@current_view.name}?error=Failed to upload asset: #{e.message}"
+    end
+  end
+
   # Upload asset
   post '/asset_management/upload' do
     @current_view = @api&.current_view
@@ -1327,12 +2023,151 @@ class ScriptoriumWeb < Sinatra::Base
     end
   end
 
+  # Widget Management Routes
+  
+  # List widgets for current view
+  get '/widgets' do
+    if @api&.instance_variable_get(:@repo) && @current_view
+      @available_widgets = @api.widgets_available
+      @configured_widgets = []
+      @widget_containers = {}
+      
+      @available_widgets.each do |widget|
+        widget_dir = @api.root/"views"/@current_view.name/"widgets"/widget
+        if Dir.exist?(widget_dir)
+          @configured_widgets << widget
+          # Determine which container this widget is in
+          @widget_containers[widget] = determine_widget_container(@current_view)
+        end
+      end
+      
+      erb :widgets
+    else
+      redirect "/?error=No repository or view selected"
+    end
+  end
+
+  # Add widget to current view
+  post '/add_widget' do
+    if @api&.instance_variable_get(:@repo) && @current_view
+      widget_name = params[:widget_name]&.strip
+      
+      if widget_name.nil? || widget_name.empty?
+        redirect "/widgets?error=Widget name required"
+        return
+      end
+      
+      # Check if widget is available
+      available_widgets = @api.widgets_available
+      unless available_widgets.include?(widget_name)
+        redirect "/widgets?error=Widget '#{widget_name}' not available"
+        return
+      end
+      
+      # Check if widget is already configured
+      widget_dir = @api.root/"views"/@current_view.name/"widgets"/widget_name
+      if Dir.exist?(widget_dir)
+        redirect "/widgets?error=Widget '#{widget_name}' already configured"
+        return
+      end
+      
+      # Determine container (left/right) for widget placement
+      container = determine_widget_container(@current_view)
+      unless container
+        redirect "/widgets?error=No left or right container found in layout. Add a left or right container to your layout first."
+        return
+      end
+      
+      # Create widget directory and list.txt
+      FileUtils.mkdir_p(widget_dir)
+      list_file = widget_dir/"list.txt"
+      File.write(list_file, "# Add #{widget_name} items here\n")
+      
+      # Generate the widget after creation
+      begin
+        @api.generate_widget(widget_name)
+        redirect "/widgets?message=Widget '#{widget_name}' added successfully to #{container} container and generated"
+      rescue => e
+        # Widget created but generation failed
+        redirect "/widgets?message=Widget '#{widget_name}' added successfully to #{container} container, but generation failed: #{e.message}"
+      end
+    else
+      redirect "/?error=No repository or view selected"
+    end
+  end
+
+  # Configure widget data
+  get '/config_widget/:widget_name' do
+    if @api&.instance_variable_get(:@repo) && @current_view
+      @widget_name = params[:widget_name]
+      widget_dir = @api.root/"views"/@current_view.name/"widgets"/@widget_name
+      
+      unless Dir.exist?(widget_dir)
+        redirect "/widgets?error=Widget '#{@widget_name}' not configured"
+        return
+      end
+      
+      list_file = widget_dir/"list.txt"
+      @widget_data = File.exist?(list_file) ? File.read(list_file) : ""
+      
+      erb :config_widget
+    else
+      redirect "/?error=No repository or view selected"
+    end
+  end
+
+  # Update widget data
+  post '/update_widget/:widget_name' do
+    if @api&.instance_variable_get(:@repo) && @current_view
+      widget_name = params[:widget_name]
+      widget_data = params[:widget_data]
+      
+      widget_dir = @api.root/"views"/@current_view.name/"widgets"/widget_name
+      list_file = widget_dir/"list.txt"
+      
+      File.write(list_file, widget_data)
+      
+      # Generate the widget after updating
+      begin
+        @api.generate_widget(widget_name)
+        redirect "/widgets?message=Widget '#{widget_name}' updated and generated successfully"
+      rescue => e
+        # Widget updated but generation failed
+        redirect "/widgets?error=Widget '#{widget_name}' updated successfully, but generation failed: #{e.message}"
+      end
+    else
+      redirect "/?error=No repository or view selected"
+    end
+  end
+
+  # Remove widget from current view
+  post '/remove_widget' do
+    if @api&.instance_variable_get(:@repo) && @current_view
+      widget_name = params[:widget_name]&.strip
+      
+      if widget_name.nil? || widget_name.empty?
+        redirect "/widgets?error=Widget name required"
+        return
+      end
+      
+      widget_dir = @api.root/"views"/@current_view.name/"widgets"/widget_name
+      if Dir.exist?(widget_dir)
+        FileUtils.rm_rf(widget_dir)
+        redirect "/widgets?message=Widget '#{widget_name}' removed successfully"
+      else
+        redirect "/widgets?error=Widget '#{widget_name}' not found"
+      end
+    else
+      redirect "/?error=No repository or view selected"
+    end
+  end
+
   # Helper method to update status
   private def update_config_status(view_name, config_name, status)
     status_file = @api.root/"views"/view_name/"config"/"status.txt"
     return unless File.exist?(status_file)
     
-    content = File.read(status_file)
+          content = read_file(status_file)
     lines = content.lines.map do |line|
       if line.strip.start_with?("#{config_name} ")
         "#{config_name} #{status ? 'y' : 'n'}\n"
@@ -1340,7 +2175,7 @@ class ScriptoriumWeb < Sinatra::Base
         line
       end
     end
-    File.write(status_file, lines.join)
+            write_file(status_file, lines.join)
   end
 
   # Helper method for formatting file sizes
@@ -1352,8 +2187,20 @@ class ScriptoriumWeb < Sinatra::Base
     "#{(bytes / k**i.to_f).round(2)} #{sizes[i]}"
   end
 
+  # Helper method to determine which container (left/right) widgets should be placed in
+  private def determine_widget_container(view)
+    layout_file = @api.root/"views"/view.name/"config"/"layout.txt"
+    return nil unless File.exist?(layout_file)
+    
+    layout_config = @api.parse_commented_file(layout_file)
+    containers = layout_config.keys
+    
+    # Prefer left container, fall back to right
+    containers.find { |c| c == 'left' } || containers.find { |c| c == 'right' }
+  end
+
   def get_image_dimensions(file_path)
-    return nil unless File.exist?(file_path)
+    return nil unless file_path && File.exist?(file_path)
     
     # Check if it's an image file
     image_extensions = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff', '.webp']
@@ -1362,17 +2209,392 @@ class ScriptoriumWeb < Sinatra::Base
     # Check if FastImage is available
     return nil unless defined?(FastImage)
     
+    dimensions = FastImage.size(file_path)
+    return dimensions ? "#{dimensions[0]}×#{dimensions[1]}" : nil
+  rescue => e
+    # If FastImage fails, return nil
+    return nil
+  end
+
+  def get_post_title(post_id)
+    begin
+      post = @api.post(post_id)
+      post.title
+    rescue => e
+      "Post ##{post_id}"
+    end
+  end
+
+  def format_backup_age(timestamp)
+    # Parse timestamp (format: YYYYMMDD-HHMMSS)
+    year = timestamp[0..3].to_i
+    month = timestamp[4..5].to_i
+    day = timestamp[6..7].to_i
+    hour = timestamp[9..10].to_i
+    minute = timestamp[11..12].to_i
+    second = timestamp[13..14].to_i
+    
+    backup_time = Time.new(year, month, day, hour, minute, second)
+    now = Time.now
+    diff = now - backup_time
+    
+    if diff < 60
+      "#{diff.to_i} seconds ago"
+    elsif diff < 3600
+      "#{(diff / 60).to_i} minutes ago"
+    elsif diff < 86400
+      "#{(diff / 3600).to_i} hours ago"
+    elsif diff < 2592000  # 30 days
+      "#{(diff / 86400).to_i} days ago"
+    else
+      "#{(diff / 2592000).to_i} months ago"
+    end
+  end
+
+
+
+  # Delete a post (move to _postnum directory)
+  post '/delete_post/:id' do
+    post_id = params[:id]
+    
+    begin
+      # Set current view before proceeding
+      @current_view = @api&.current_view
+      if @current_view.nil?
+        redirect "/?error=No view selected"
+        return
+      end
+      
+      post = @api.post(post_id.to_i)
+      if post.nil?
+        redirect "/?error=Post #{post_id} not found"
+        return
+      end
+      
+      # Mark as deleted in metadata
+      post.deleted = true
+      
+      # Move post directory to _postnum
+      post_dir = @api.root/"posts"/post.num
+      deleted_dir = @api.root/"posts"/"_#{post.num}"
+      
+      if Dir.exist?(post_dir)
+        FileUtils.mkdir_p(File.dirname(deleted_dir))
+        FileUtils.mv(post_dir, deleted_dir)
+      else
+        redirect "/?error=Post directory #{post_dir} not found"
+        return
+      end
+      
+      # Preserve current page if available
+      current_page = params[:page] || request.env['HTTP_REFERER']&.match(/[?&]page=(\d+)/)&.[](1) || 1
+      redirect "/view/#{@current_view.name}?page=#{current_page}&message=Post #{post_id} deleted successfully"
+    rescue => e
+      redirect "/?error=Failed to delete post: #{e.message}"
+    end
+  end
+
+  # Restore a deleted post
+  post '/restore_post/:id' do
+    post_id = params[:id]
+    
+    begin
+      # Set current view before proceeding
+      @current_view = @api&.current_view
+      if @current_view.nil?
+        redirect "/?error=No view selected"
+        return
+      end
+      
+      # Find the deleted post directory
+      formatted_id = post_id.to_s.rjust(4, '0')  # Ensure 4-digit format (e.g., "28" -> "0028")
+      deleted_dir = @api.root/"posts"/"_#{formatted_id}"
+      post_dir = @api.root/"posts"/formatted_id
+      
+      if Dir.exist?(deleted_dir)
+        # Move back to normal posts directory
+        FileUtils.mv(deleted_dir, post_dir)
+        
+        # Update metadata to mark as not deleted
+        post = @api.post(post_id.to_i)
+        if post
+          # Debug: log both date fields before and after
+          File.write('/tmp/restore_debug.log', "Restoring post #{post_id}: pubdate before = #{post.pubdate}, created before = #{post.created}\n", mode: 'a')
+          post.deleted = false
+          File.write('/tmp/restore_debug.log', "Restoring post #{post_id}: pubdate after = #{post.pubdate}, created after = #{post.created}\n", mode: 'a')
+        end
+        
+        # Preserve current page if available
+        current_page = params[:page] || request.env['HTTP_REFERER']&.match(/[?&]page=(\d+)/)&.[](1) || 1
+        redirect "/view/#{@current_view.name}?page=#{current_page}&message=Post #{post_id} restored successfully"
+      else
+        redirect "/?error=Deleted post #{post_id} not found"
+      end
+    rescue => e
+      redirect "/?error=Failed to restore post: #{e.message}"
+    end
+  end
+
+  # Toggle post published status
+  post '/toggle_post_status/:id' do
+    post_id = params[:id]
+    
+    begin
+      # Set current view before proceeding
+      @current_view = @api&.current_view
+      if @current_view.nil?
+        redirect "/?error=No view selected"
+        return
+      end
+      
+      post = @api.post(post_id.to_i)
+      if post.nil?
+        redirect "/?error=Post #{post_id} not found"
+        return
+      end
+      
+      # Toggle between published and unpublished
+      if post.meta["post.published"] == "no" || post.meta["post.published"].nil?
+        # Publish the post - only change published status, don't touch pubdate
+        post.meta["post.published"] = "yes"
+        post.save_metadata
+        content_type :json
+        { success: true, message: "Post #{post_id} published successfully", published: true }.to_json
+      else
+        # Unpublish the post - only change published status, don't touch pubdate
+        post.meta["post.published"] = "no"
+        post.save_metadata
+        content_type :json
+        { success: true, message: "Post #{post_id} unpublished successfully", published: false }.to_json
+      end
+    rescue => e
+      redirect "/?error=Failed to toggle post status: #{e.message}"
+    end
+  end
+
+  # Backup management
+  get '/backup_management' do
+    @current_view = @api&.current_view
+    if @current_view.nil?
+      redirect "/?error=No view selected. Please select a view first."
+      return
+    end
+    
+    begin
+      @backups = @api.list_backups
+      # Sort backups by timestamp (newest first)
+      @backups.sort_by! { |backup| backup[:timestamp] }.reverse!
+      
+      # Add human-readable age to each backup
+      @backups.each do |backup|
+        # Convert Time object to string if needed
+        timestamp_str = backup[:timestamp].is_a?(Time) ? backup[:timestamp].strftime("%Y%m%d-%H%M%S") : backup[:timestamp]
+        backup[:age] = format_backup_age(timestamp_str)
+        # Also ensure timestamp is a string for display
+        backup[:timestamp] = timestamp_str
+      end
+    rescue => e
+      @backups = []
+      @error = "Failed to load backups: #{e.message}"
+    end
+    
+    erb :backup_management
+  end
+
+  # Create backup
+  post '/backup_management/create' do
+    @current_view = @api&.current_view
+    if @current_view.nil?
+      redirect "/backup_management?error=No view selected. Please select a view first."
+      return
+    end
+    
+    begin
+      type = params[:type] # 'full' or 'incr'
+      description = params[:description]
+      
+      # Validate type
+      unless %w[full incr].include?(type)
+        redirect "/backup_management?error=Invalid backup type. Must be 'full' or 'incr'."
+        return
+      end
+      
+      # Create backup
+      timestamp = @api.create_backup(type: type.to_sym, label: description)
+      
+      redirect "/backup_management?message=Backup created successfully: #{timestamp}"
+    rescue => e
+      redirect "/backup_management?error=Failed to create backup: #{e.message}"
+    end
+  end
+
+  # Theme management routes
+  
+  # Theme management page
+  get '/theme_management' do
+    begin
+      @themes = @api.themes_available
+      @system_themes = @api.system_themes
+      @user_themes = @api.user_themes
+      erb :theme_management
+    rescue => e
+      redirect "/?error=Failed to load themes: #{e.message}"
+    end
+  end
+  
+  # Clone theme
+  post '/theme_management/clone' do
     begin
-      dimensions = FastImage.size(file_path)
-      return dimensions ? "#{dimensions[0]}×#{dimensions[1]}" : nil
+      source_theme = params[:source_theme]&.strip
+      new_name = params[:new_name]&.strip
+      
+      if source_theme.nil? || source_theme.empty?
+        redirect "/theme_management?error=Source theme is required"
+        return
+      end
+      
+      if new_name.nil? || new_name.empty?
+        redirect "/theme_management?error=New theme name is required"
+        return
+      end
+      
+      # Validate new name format
+      unless new_name.match?(/^[a-zA-Z0-9_-]+$/)
+        redirect "/theme_management?error=Theme name can only contain letters, numbers, hyphens, and underscores"
+        return
+      end
+      
+      # Clone the theme
+      @api.clone_theme(source_theme, new_name)
+      redirect "/theme_management?message=Theme '#{new_name}' cloned successfully from '#{source_theme}'"
     rescue => e
-      # If FastImage fails, return nil
-      return nil
+      error_info = friendly_error_message(e)
+      redirect "/theme_management?error=#{error_info[:message]}&suggestion=#{error_info[:suggestion]}"
     end
   end
+  
+  # Delete theme (user themes only)
+  post '/theme_management/delete' do
+    begin
+      theme_name = params[:theme_name]&.strip
+      
+      if theme_name.nil? || theme_name.empty?
+        redirect "/theme_management?error=Theme name is required"
+        return
+      end
+      
+      # Check if it's a system theme
+      if @api.system_themes.include?(theme_name)
+        redirect "/theme_management?error=Cannot delete system theme '#{theme_name}'"
+        return
+      end
+      
+      # Check if it's a user theme
+      unless @api.user_themes.include?(theme_name)
+        redirect "/theme_management?error=Theme '#{theme_name}' not found or not a user theme"
+        return
+      end
+      
+      # Delete the theme directory
+      theme_dir = @api.root/:themes/theme_name
+      if Dir.exist?(theme_dir)
+        FileUtils.rm_rf(theme_dir)
+        redirect "/theme_management?message=Theme '#{theme_name}' deleted successfully"
+      else
+        redirect "/theme_management?error=Theme directory not found"
+      end
+    rescue => e
+      redirect "/theme_management?error=Failed to delete theme: #{e.message}"
+    end
+  end
+  
+  # Edit theme files
+  get '/edit_theme/:theme_name' do
+    begin
+      theme_name = params[:theme_name]&.strip
+      unless @api.theme_exists?(theme_name)
+        redirect "/theme_management?error=Theme '#{theme_name}' not found."
+      end
+      
+      @theme_name = theme_name
+      @theme_dir = @api.root/:themes/theme_name
+      
+      # List all editable files within the theme directory
+      @editable_files = []
+      if Dir.exist?(@theme_dir)
+        Dir.glob(File.join(@theme_dir, "**", "*.txt")).each do |file_path|
+          relative_path = Pathname.new(file_path).relative_path_from(Pathname.new(@theme_dir)).to_s
+          @editable_files << relative_path
+        end
+      end
+      
+      erb :edit_theme
+    rescue => e
+      "Error in edit_theme route: #{e.class}: #{e.message}\n#{e.backtrace.first(5).join("\n")}"
+    end
+  end
+  
+  # Edit specific theme file
+  get '/edit_theme/:theme_name/*' do
+    theme_name = params[:theme_name]&.strip
+    file_path_param = params[:splat].first
+    
+    unless @api.theme_exists?(theme_name)
+      redirect "/theme_management?error=Theme '#{theme_name}' not found."
+    end
+    
+    theme_file_path = File.join(@api.root/:themes/theme_name, file_path_param)
+    
+    unless File.exist?(theme_file_path)
+      redirect "/edit_theme/#{theme_name}?error=File '#{file_path_param}' not found in theme '#{theme_name}'."
+    end
+    
+    @theme_name = theme_name
+    @file_name = file_path_param
+    @file_content = File.read(theme_file_path)
+    
+    erb :edit_theme_file
+  end
+  
+  # Save theme file
+  post '/save_theme_file/:theme_name/*' do
+    theme_name = params[:theme_name]&.strip
+    file_path_param = params[:splat].first
+    file_content = params[:content]
+    
+    unless @api.theme_exists?(theme_name)
+      redirect "/theme_management?error=Theme '#{theme_name}' not found."
+    end
+    
+    # Ensure it's a user theme if we're allowing edits
+    unless @api.user_themes.include?(theme_name)
+      redirect "/edit_theme/#{theme_name}?error=Cannot edit system theme files directly."
+    end
+    
+    theme_file_path = File.join(@api.root/:themes/theme_name, file_path_param)
+    
+    unless File.exist?(theme_file_path)
+      redirect "/edit_theme/#{theme_name}?error=File '#{file_path_param}' not found in theme '#{theme_name}'."
+    end
+    
+    File.write(theme_file_path, file_content)
+    redirect "/edit_theme/#{theme_name}/#{file_path_param}?message=File saved successfully."
+  rescue => e
+    redirect "/edit_theme/#{theme_name}/#{file_path_param}?error=Failed to save file: #{e.message}"
+  end
+
+  # Debug route to verify code is updated
+  get '/debug' do
+    "Server is running updated code at #{Time.now}"
+  end
+  
+  
 end
 
 # Start the server if this file is run directly
 if __FILE__ == $0
   ScriptoriumWeb.run!
-end 
+end
+
+# Set initial test mode from command line after class definition
+ScriptoriumWeb.test_mode = TEST_MODE