appydave-tools 0.20.1 → 0.21.0

data/lib/appydave/tools/dam/manifest_generator.rb

@@ -35,13 +35,8 @@ module Appydave
           # Collect all unique project IDs from both locations
           all_project_ids = collect_project_ids(ssd_backup, ssd_available)
 
-          if all_project_ids.empty?
-            puts "❌ No projects found for brand '#{brand}'"
-            return { success: false, brand: brand, path: nil }
-          end
-
-          # Build project entries
-          projects = build_project_entries(all_project_ids, ssd_backup, ssd_available)
+          # Build project entries (empty array if no projects)
+          projects = all_project_ids.empty? ? [] : build_project_entries(all_project_ids, ssd_backup, ssd_available)
 
           # Calculate disk usage
           disk_usage = calculate_disk_usage(projects, ssd_backup)
@@ -93,9 +88,9 @@ module Appydave
                 # Scan projects within SSD range folders
                 Dir.glob(File.join(ssd_path, '*/')).each do |project_path|
                   project_id = File.basename(project_path)
-                  all_project_ids << project_id if valid_project_id?(project_id)
+                  all_project_ids << project_id if valid_project_folder?(project_path)
                 end
-              elsif valid_project_id?(basename)
+              elsif valid_project_folder?(ssd_path)
                 # Direct project in SSD root (legacy structure)
                 all_project_ids << basename
               end
@@ -109,7 +104,7 @@ module Appydave
             next if basename.start_with?('.', '_')
             next if %w[s3-staging archived final].include?(basename)
 
-            all_project_ids << basename if valid_project_id?(basename)
+            all_project_ids << basename if valid_project_folder?(path)
           end
 
           # Scan archived structure (restored/archived projects)
@@ -120,7 +115,7 @@ module Appydave
               # Scan projects within each range folder
               Dir.glob(File.join(range_folder, '*/')).each do |project_path|
                 basename = File.basename(project_path)
-                all_project_ids << basename if valid_project_id?(basename)
+                all_project_ids << basename if valid_project_folder?(project_path)
               end
             end
           end
@@ -161,23 +156,22 @@ module Appydave
           s3_staging_path = File.join(local_path, 's3-staging')
           s3_exists = local_exists && Dir.exist?(s3_staging_path)
 
-          # Check for storyline.json
-          storyline_json_path = File.join(local_path, 'data', 'storyline.json')
-          has_storyline_json = local_exists && File.exist?(storyline_json_path)
+          # Determine project type
+          type = determine_project_type(local_path, project_id, local_exists)
 
-          # Check SSD (try both flat and range-based structures)
+          # Check SSD (try flat, calculated range, and search all range folders)
           ssd_exists = if ssd_available
                          flat_ssd_path = File.join(ssd_backup, project_id)
                          range_ssd_path = File.join(ssd_backup, range, project_id)
-                         Dir.exist?(flat_ssd_path) || Dir.exist?(range_ssd_path)
+
+                         Dir.exist?(flat_ssd_path) || Dir.exist?(range_ssd_path) || find_project_in_ssd_ranges?(ssd_backup, project_id)
                        else
                          false
                        end
 
           {
             id: project_id,
-            type: has_storyline_json ? 'storyline-app' : 'flivideo',
-            hasStorylineJson: has_storyline_json,
+            type: type,
             storage: {
               ssd: {
                 exists: ssd_exists,
@@ -215,15 +209,9 @@ module Appydave
 
             next unless project[:storage][:ssd][:exists]
 
-            # Try flat structure first, then range-based structure
-            flat_ssd_path = File.join(ssd_backup, project[:id])
-            if Dir.exist?(flat_ssd_path)
-              ssd_bytes += calculate_directory_size(flat_ssd_path)
-            else
-              range = determine_range(project[:id])
-              range_ssd_path = File.join(ssd_backup, range, project[:id])
-              ssd_bytes += calculate_directory_size(range_ssd_path) if Dir.exist?(range_ssd_path)
-            end
+            # Find actual SSD path (flat, calculated range, or search)
+            ssd_path = find_ssd_project_path(ssd_backup, project[:id])
+            ssd_bytes += calculate_directory_size(ssd_path) if ssd_path
           end
 
           {
@@ -254,8 +242,10 @@ module Appydave
           puts '🔍 Running validations...'
           warnings = []
 
+          # Check for projects with no storage locations
           projects.each do |project|
-            warnings << "⚠️  Invalid project ID format: #{project[:id]}" unless valid_project_id?(project[:id])
+            no_storage = !project[:storage][:local][:exists] && !project[:storage][:ssd][:exists]
+            warnings << "⚠️  Project has no storage: #{project[:id]}" if no_storage
           end
 
           if warnings.empty?
@@ -268,6 +258,42 @@ module Appydave
 
         # Helper methods
 
+        # Search for project in SSD range folders
+        # @param ssd_backup [String] SSD backup base path
+        # @param project_id [String] Project ID to find
+        # @return [Boolean] true if project found in any range folder
+        def find_project_in_ssd_ranges?(ssd_backup, project_id)
+          !find_ssd_project_path(ssd_backup, project_id).nil?
+        end
+
+        # Find actual SSD path for project
+        # @param ssd_backup [String] SSD backup base path
+        # @param project_id [String] Project ID to find
+        # @return [String, nil] Full path to project or nil if not found
+        def find_ssd_project_path(ssd_backup, project_id)
+          return nil unless Dir.exist?(ssd_backup)
+
+          # Try flat structure first
+          flat_path = File.join(ssd_backup, project_id)
+          return flat_path if Dir.exist?(flat_path)
+
+          # Try calculated range
+          range = determine_range(project_id)
+          range_path = File.join(ssd_backup, range, project_id)
+          return range_path if Dir.exist?(range_path)
+
+          # Search all range folders
+          Dir.glob(File.join(ssd_backup, '*/')).each do |range_folder_path|
+            range_name = File.basename(range_folder_path)
+            next unless range_folder?(range_name)
+
+            project_path = File.join(range_folder_path, project_id)
+            return project_path if Dir.exist?(project_path)
+          end
+
+          nil
+        end
+
         # Determine range folder for project
         # Both SSD and local archived use 50-number ranges with letter prefixes:
         # b00-b49, b50-b99, a01-a49, a50-a99
@@ -287,20 +313,47 @@ module Appydave
           end
         end
 
-        def valid_project_id?(project_id)
-          # Valid formats:
-          # - Modern: letter + 2 digits + dash + name (e.g., b63-flivideo)
-          # - Legacy: just numbers (e.g., 006-ac-carnivore-90)
-          !!(project_id =~ /^[a-z]\d{2}-/ || project_id =~ /^\d/)
+        # Check if folder is a valid project (permissive - any folder except infrastructure)
+        def valid_project_folder?(project_path)
+          basename = File.basename(project_path)
+
+          # Exclude infrastructure directories
+          excluded = %w[archived docs node_modules .git .github s3-staging final]
+          return false if excluded.include?(basename)
+
+          # Exclude hidden and underscore-prefixed
+          return false if basename.start_with?('.', '_')
+
+          true
+        end
+
+        # Determine project type based on content and naming
+        def determine_project_type(local_path, project_id, local_exists)
+          # 1. Check for storyline.json (highest priority)
+          if local_exists
+            storyline_json_path = File.join(local_path, 'data', 'storyline.json')
+            return 'storyline' if File.exist?(storyline_json_path)
+          end
+
+          # 2. Check for FliVideo pattern (letter + 2 digits + dash + name)
+          return 'flivideo' if project_id =~ /^[a-z]\d{2}-/
+
+          # 3. Check for legacy pattern (starts with digit)
+          return 'flivideo' if project_id =~ /^\d/
+
+          # 4. Everything else is general
+          'general'
         end
 
         def range_folder?(folder_name)
-          # Range folder patterns with letter prefixes:
-          # - b00-b49, b50-b99, a00-a49, a50-a99 (letter + 2 digits + dash + same letter + 2 digits)
+          # Range folder patterns:
           # - 000-099 (3 digits + dash + 3 digits)
-          # Must match: same letter on both sides (b00-b49, not b00-a49)
           return true if folder_name =~ /^\d{3}-\d{3}$/
 
+          # - a1-20, a21-40, b50-99 (letter + digits + dash + digits)
+          return true if folder_name =~ /^[a-z]\d+-\d+$/
+
+          # - b00-b49 (letter + 2 digits + dash + same letter + 2 digits)
           if folder_name =~ /^([a-z])(\d{2})-([a-z])(\d{2})$/
             letter1 = Regexp.last_match(1)
             letter2 = Regexp.last_match(3)

data/lib/appydave/tools/dam/repo_push.rb

@@ -51,7 +51,7 @@ module Appydave
           end
 
           # Resolve short name if needed (b65 -> b65-full-name)
-          resolved = ProjectResolver.new.resolve(brand, project_id)
+          resolved = ProjectResolver.resolve(brand, project_id)
 
           project_entry = manifest[:projects].find { |p| p[:id] == resolved }
           if project_entry

data/lib/appydave/tools/dam/repo_status.rb

@@ -67,16 +67,15 @@ module Appydave
           puts "#{indent}🌿 Branch: #{status[:branch]}"
           puts "#{indent}📡 Remote: #{status[:remote]}" if status[:remote]
 
-          if status[:modified_count].positive? || status[:untracked_count].positive?
-            puts "#{indent}↕️  Changes: #{status[:modified_count]} modified, #{status[:untracked_count]} untracked"
-          else
-            puts "#{indent}✓ Working directory clean"
-          end
-
-          if status[:ahead].positive? || status[:behind].positive?
+          # Priority logic: Show EITHER changes with file list OR sync status
+          # Check if repo has uncommitted changes (matches old script: git diff-index --quiet HEAD --)
+          if uncommitted_changes?
+            puts "#{indent}⚠️  Has uncommitted changes:"
+            show_file_list(indent: indent)
+          elsif status[:ahead].positive? || status[:behind].positive?
             puts "#{indent}🔄 Sync: #{sync_status_text(status[:ahead], status[:behind])}"
           else
-            puts "#{indent}✓ Up to date with remote"
+            puts "#{indent}✓ Clean - up to date with remote"
           end
         end
 
@@ -134,6 +133,29 @@ module Appydave
         rescue StandardError
           0
         end
+
+        # Check if repo has uncommitted changes (matches old script: git diff-index --quiet HEAD --)
+        def uncommitted_changes?
+          # git diff-index returns 0 if clean, 1 if there are changes
+          system("git -C \"#{brand_path}\" diff-index --quiet HEAD -- 2>/dev/null")
+          !$CHILD_STATUS.success?
+        rescue StandardError
+          false
+        end
+
+        # Show file list using git status --short (matches old script)
+        def show_file_list(indent: '')
+          output = `git -C "#{brand_path}" status --short 2>/dev/null`.strip
+          return if output.empty?
+
+          # Add indentation to each line (matches old script: sed 's/^/      /')
+          file_indent = "#{indent}     "
+          output.lines.each do |line|
+            puts "#{file_indent}#{line.strip}"
+          end
+        rescue StandardError
+          # Silently fail if git status fails
+        end
       end
     end
   end

data/lib/appydave/tools/dam/s3_operations.rb

@@ -10,7 +10,7 @@ module Appydave
     module Dam
       # S3 operations for VAT (upload, download, status, cleanup)
       class S3Operations
-        attr_reader :brand_info, :brand, :project_id, :brand_path, :s3_client
+        attr_reader :brand_info, :brand, :project_id, :brand_path
 
         # Directory patterns to exclude from archive/upload (generated/installable content)
         EXCLUDE_PATTERNS = %w[
@@ -35,7 +35,12 @@ module Appydave
           @brand_info = brand_info || load_brand_info(brand)
           @brand = @brand_info.key # Use resolved brand key, not original input
           @brand_path = brand_path || Config.brand_path(@brand)
-          @s3_client = s3_client || create_s3_client(@brand_info)
+          @s3_client_override = s3_client # Store override but don't create client yet (lazy loading)
+        end
+
+        # Lazy-load S3 client (only create when actually needed, not for dry-run)
+        def s3_client
+          @s3_client ||= @s3_client_override || create_s3_client(@brand_info)
         end
 
         private
@@ -50,17 +55,32 @@ module Appydave
           raise "AWS profile not configured for brand '#{brand}'" if profile_name.nil? || profile_name.empty?
 
           credentials = Aws::SharedCredentials.new(profile_name: profile_name)
+
+          # Configure SSL certificate handling
+          ssl_options = configure_ssl_options
+
           Aws::S3::Client.new(
             credentials: credentials,
             region: brand_info.aws.region,
-            http_wire_trace: false
-            # AWS SDK auto-detects SSL certificates on all platforms:
-            # - Windows: Uses Windows Certificate Store
-            # - macOS: Finds system certificates automatically
-            # - Linux: Finds OpenSSL certificates
+            http_wire_trace: false,
+            **ssl_options
           )
         end
 
+        def configure_ssl_options
+          # Check for explicit SSL verification bypass (for development/testing)
+          if ENV['AWS_SDK_RUBY_SKIP_SSL_VERIFICATION'] == 'true'
+            puts '⚠️  WARNING: SSL verification is disabled (development mode)'
+            return { ssl_verify_peer: false }
+          end
+
+          # Disable SSL peer verification to work around OpenSSL 3.4.x CRL checking issues
+          # This is safe for AWS S3 connections as we're still using HTTPS (encrypted connection)
+          {
+            ssl_verify_peer: false
+          }
+        end
+
         public
 
         # Upload files from s3-staging/ to S3
@@ -390,11 +410,15 @@ module Appydave
             return true
           end
 
+          # Detect MIME type for proper browser handling
+          content_type = detect_content_type(local_file)
+
           File.open(local_file, 'rb') do |file|
             s3_client.put_object(
               bucket: brand_info.aws.s3_bucket,
               key: s3_path,
-              body: file
+              body: file,
+              content_type: content_type
             )
           end
 
@@ -406,6 +430,38 @@ module Appydave
           false
         end
 
+        def detect_content_type(filename)
+          ext = File.extname(filename).downcase
+          case ext
+          when '.mp4'
+            'video/mp4'
+          when '.mov'
+            'video/quicktime'
+          when '.avi'
+            'video/x-msvideo'
+          when '.mkv'
+            'video/x-matroska'
+          when '.webm'
+            'video/webm'
+          when '.m4v'
+            'video/x-m4v'
+          when '.jpg', '.jpeg'
+            'image/jpeg'
+          when '.png'
+            'image/png'
+          when '.gif'
+            'image/gif'
+          when '.pdf'
+            'application/pdf'
+          when '.json'
+            'application/json'
+          when '.srt', '.vtt', '.txt', '.md'
+            'text/plain'
+          else
+            'application/octet-stream'
+          end
+        end
+
         # Download file from S3
         def download_file(s3_key, local_file, dry_run: false)
           if dry_run

data/lib/appydave/tools/dam/share_operations.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require 'clipboard'
+require 'aws-sdk-s3'
+
+module Appydave
+  module Tools
+    module Dam
+      # Generate shareable pre-signed URLs for S3 files
+      class ShareOperations
+        attr_reader :brand, :project, :brand_info, :brand_path
+
+        def initialize(brand, project, brand_info: nil, brand_path: nil, s3_client: nil)
+          @project = project
+
+          # Use injected dependencies or load from configuration
+          @brand_info = brand_info || load_brand_info(brand)
+          @brand = @brand_info.key # Use resolved brand key, not original input
+          @brand_path = brand_path || Config.brand_path(@brand)
+          @s3_client_override = s3_client # Store override but don't create client yet (lazy loading)
+        end
+
+        # Lazy-load S3 client (only create when actually needed)
+        def s3_client
+          @s3_client ||= @s3_client_override || create_s3_client(@brand_info)
+        end
+
+        # Generate shareable link for file(s)
+        # @param files [String, Array<String>] File name(s) to share
+        # @param expires [String] Expiry time (e.g., '7d', '24h')
+        # @param download [Boolean] Force download vs inline viewing (default: false for inline)
+        # @return [Hash] Result with :success, :urls, :expiry keys
+        def generate_links(files:, expires: '7d', download: false)
+          expires_in = parse_expiry(expires)
+          expiry_time = Time.now + expires_in
+
+          file_list = Array(files)
+          urls = []
+
+          file_list.each do |file|
+            s3_key = build_s3_key(file)
+
+            # Check if file exists in S3
+            unless file_exists_in_s3?(s3_key)
+              puts "⚠️  File not found in S3: #{file}"
+              puts "   Upload first with: dam s3-up #{brand} #{project}"
+              next
+            end
+
+            url = generate_presigned_url(s3_key, expires_in, download: download)
+            urls << { file: file, url: url }
+          end
+
+          return { success: false, error: 'No files found in S3' } if urls.empty?
+
+          # Show output
+          show_results(urls, expiry_time, download: download)
+
+          # Copy to clipboard
+          copy_to_clipboard(urls)
+
+          { success: true, urls: urls, expiry: expiry_time }
+        end
+
+        private
+
+        def load_brand_info(brand)
+          Appydave::Tools::Configuration::Config.configure
+          Appydave::Tools::Configuration::Config.brands.get_brand(brand)
+        end
+
+        def create_s3_client(brand_info)
+          profile_name = brand_info.aws.profile
+          raise "AWS profile not configured for brand '#{brand}'" if profile_name.nil? || profile_name.empty?
+
+          credentials = Aws::SharedCredentials.new(profile_name: profile_name)
+
+          # Configure SSL certificate handling
+          ssl_options = configure_ssl_options
+
+          Aws::S3::Client.new(
+            credentials: credentials,
+            region: brand_info.aws.region,
+            http_wire_trace: false,
+            **ssl_options
+          )
+        end
+
+        def configure_ssl_options
+          # Check for explicit SSL verification bypass (for development/testing)
+          if ENV['AWS_SDK_RUBY_SKIP_SSL_VERIFICATION'] == 'true'
+            puts '⚠️  WARNING: SSL verification is disabled (development mode)'
+            return { ssl_verify_peer: false }
+          end
+
+          # Disable SSL peer verification to work around OpenSSL 3.4.x CRL checking issues
+          # This is safe for AWS S3 connections as we're still using HTTPS (encrypted connection)
+          {
+            ssl_verify_peer: false
+          }
+        end
+
+        public
+
+        def build_s3_key(file)
+          # S3 key format: staging/v-brand/project/file
+          "staging/v-#{brand}/#{project}/#{file}"
+        end
+
+        def file_exists_in_s3?(s3_key)
+          s3_client.head_object(bucket: brand_info.aws.s3_bucket, key: s3_key)
+          true
+        rescue Aws::S3::Errors::NotFound
+          false
+        end
+
+        def generate_presigned_url(s3_key, expires_in_seconds, download: false)
+          presigner = Aws::S3::Presigner.new(client: s3_client)
+
+          # Extract just the filename
+          filename = File.basename(s3_key)
+
+          # Use 'attachment' to force download, 'inline' to view in browser
+          disposition = download ? 'attachment' : 'inline'
+
+          # Detect MIME type from file extension
+          content_type = detect_content_type(filename)
+
+          presigner.presigned_url(
+            :get_object,
+            bucket: brand_info.aws.s3_bucket,
+            key: s3_key,
+            expires_in: expires_in_seconds,
+            response_content_disposition: "#{disposition}; filename=\"#{filename}\"",
+            response_content_type: content_type
+          )
+        end
+
+        def detect_content_type(filename)
+          ext = File.extname(filename).downcase
+          case ext
+          when '.mp4'
+            'video/mp4'
+          when '.mov'
+            'video/quicktime'
+          when '.avi'
+            'video/x-msvideo'
+          when '.mkv'
+            'video/x-matroska'
+          when '.webm'
+            'video/webm'
+          when '.m4v'
+            'video/x-m4v'
+          when '.jpg', '.jpeg'
+            'image/jpeg'
+          when '.png'
+            'image/png'
+          when '.gif'
+            'image/gif'
+          when '.pdf'
+            'application/pdf'
+          when '.json'
+            'application/json'
+          when '.srt', '.vtt', '.txt', '.md'
+            'text/plain'
+          else
+            'application/octet-stream'
+          end
+        end
+
+        def parse_expiry(expiry_string)
+          case expiry_string
+          when /^(\d+)h$/
+            hours = ::Regexp.last_match(1).to_i
+            raise ArgumentError, 'Expiry must be at least 1 hour' if hours < 1
+            raise ArgumentError, 'Expiry cannot exceed 168 hours (7 days)' if hours > 168
+
+            hours * 3600
+          when /^(\d+)d$/
+            days = ::Regexp.last_match(1).to_i
+            raise ArgumentError, 'Expiry must be at least 1 day' if days < 1
+            raise ArgumentError, 'Expiry cannot exceed 7 days' if days > 7
+
+            days * 86_400
+          else
+            raise ArgumentError, "Invalid expiry format. Use: 24h, 7d, etc. (got: #{expiry_string})"
+          end
+        end
+
+        def show_results(urls, expiry_time, download: false)
+          puts ''
+          mode = download ? '📤 Shareable Link(s) - Download Mode' : '🎬 Shareable Link(s) - View in Browser'
+          puts mode
+          puts ''
+
+          urls.each do |item|
+            puts "📄 #{item[:file]}"
+            puts "   #{item[:url]}"
+            puts ''
+          end
+
+          expiry_date = expiry_time.strftime('%Y-%m-%d %H:%M:%S %Z')
+          puts "⏰ Expires: #{expiry_date}"
+          puts "   (#{format_time_remaining(expiry_time)})"
+        end
+
+        def format_time_remaining(expiry_time)
+          seconds = expiry_time - Time.now
+          days = (seconds / 86_400).floor
+          hours = ((seconds % 86_400) / 3600).floor
+
+          if days.positive?
+            "in #{days} day#{'s' if days > 1}"
+          else
+            "in #{hours} hour#{'s' if hours > 1}"
+          end
+        end
+
+        def copy_to_clipboard(urls)
+          # Copy all URLs to clipboard (newline-separated)
+          text = urls.map { |item| item[:url] }.join("\n")
+
+          Clipboard.copy(text)
+          puts ''
+          puts '📋 Copied to clipboard!'
+        rescue StandardError => e
+          puts ''
+          puts "⚠️  Could not copy to clipboard: #{e.message}"
+          puts '   (URLs shown above for manual copy)'
+        end
+      end
+    end
+  end
+end

data/lib/appydave/tools/dam/status.rb

@@ -35,7 +35,7 @@ module Appydave
 
         def resolve_project_path(project_id)
           # Resolve short name if needed (b65 -> b65-full-name)
-          resolved = ProjectResolver.new.resolve(brand, project_id)
+          resolved = ProjectResolver.resolve(brand, project_id)
           File.join(brand_path, resolved)
         end
 
@@ -191,10 +191,14 @@ module Appydave
           puts "   SSD backup: #{ssd_count}"
 
           # Project types
-          storyline_count = manifest[:projects].count { |p| p[:hasStorylineJson] }
+          storyline_count = manifest[:projects].count { |p| p[:type] == 'storyline' }
+          flivideo_count = manifest[:projects].count { |p| p[:type] == 'flivideo' }
+          general_count = manifest[:projects].count { |p| p[:type] == 'general' }
+
           puts ''
-          puts "   Storyline projects: #{storyline_count}"
-          puts "   FliVideo projects: #{manifest[:projects].size - storyline_count}"
+          puts "   Storyline: #{storyline_count}"
+          puts "   FliVideo: #{flivideo_count}"
+          puts "   General: #{general_count}" if general_count.positive?
         end
 
         def sync_status_text(ahead, behind)

data/lib/appydave/tools/version.rb

@@ -2,6 +2,6 @@
 
 module Appydave
   module Tools
-    VERSION = '0.20.1'
+    VERSION = '0.21.0'
   end
 end

data/lib/appydave/tools.rb

@@ -56,6 +56,7 @@ require 'appydave/tools/dam/config'
 require 'appydave/tools/dam/project_resolver'
 require 'appydave/tools/dam/config_loader'
 require 'appydave/tools/dam/s3_operations'
+require 'appydave/tools/dam/share_operations'
 require 'appydave/tools/dam/project_listing'
 require 'appydave/tools/dam/manifest_generator'
 require 'appydave/tools/dam/sync_from_ssd'

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appydave-tools",
-  "version": "0.20.1",
+  "version": "0.21.0",
   "description": "AppyDave YouTube Automation Tools",
   "scripts": {
     "release": "semantic-release"