@gannochenko/staticstripes 0.0.15 → 0.0.17

package/src/cli/youtube/youtube-upload-strategy.ts

@@ -4,7 +4,7 @@ import { YouTubeUpload } from '../../type';
 import { resolve } from 'path';
 import { YouTubeUploader } from '../../youtube-uploader';
 import ejs from 'ejs';
-import { readFileSync, existsSync } from 'fs';
+import { CredentialsManager, YouTubeCredentials } from '../credentials';
 
 export interface YouTubeUploadOptions {
   uploadName: string;
@@ -17,6 +17,8 @@ export interface YouTubeUploadOptions {
  * YouTube upload strategy implementation
  */
 export class YouTubeUploadStrategy implements UploadStrategy {
+  constructor(private credentialsManager?: CredentialsManager) {}
+
   getTag(): string {
     return 'youtube';
   }
@@ -30,14 +32,23 @@ export class YouTubeUploadStrategy implements UploadStrategy {
     upload: YouTubeUpload,
     projectPath: string,
   ): Promise<void> {
-    // Read credentials from .auth file
-    const authDir = resolve(projectPath, '.auth');
-    const credentialsPath = resolve(authDir, `${upload.name}.json`);
+    // Load credentials from local .auth/<upload-name>.json or global ~/.staticstripes/auth/<upload-name>.json
+    const manager =
+      this.credentialsManager ||
+      new CredentialsManager(projectPath, upload.name);
 
-    if (!existsSync(credentialsPath)) {
+    let credentials: YouTubeCredentials;
+    try {
+      credentials = manager.load<YouTubeCredentials>([
+        'clientId',
+        'clientSecret',
+      ]);
+    } catch (error) {
+      // Add helpful context about YouTube credentials
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
       throw new Error(
-        `❌ Error: YouTube credentials not found\n\n` +
-          `Expected location: ${credentialsPath}\n\n` +
+        `${errorMessage}\n\n` +
           `💡 Run authentication wizard:\n` +
           `   staticstripes auth --upload-name ${upload.name}\n\n` +
           `📖 Or view setup instructions:\n` +
@@ -45,22 +56,6 @@ export class YouTubeUploadStrategy implements UploadStrategy {
       );
     }
 
-    let credentials: { clientId?: string; clientSecret?: string };
-    try {
-      const credentialsJson = readFileSync(credentialsPath, 'utf-8');
-      credentials = JSON.parse(credentialsJson);
-
-      if (!credentials.clientId || !credentials.clientSecret) {
-        throw new Error('Missing clientId or clientSecret');
-      }
-    } catch (error) {
-      throw new Error(
-        `❌ Error: Failed to parse YouTube credentials from ${credentialsPath}\n` +
-          `Ensure the file contains clientId and clientSecret.\n` +
-          `Error: ${error instanceof Error ? error.message : String(error)}`,
-      );
-    }
-
     // Delegate to existing handler
     await handleYouTubeUpload(project, {
       uploadName: upload.name,
@@ -116,6 +111,9 @@ export async function handleYouTubeUpload(
   const title = upload.title || project.getTitle();
   console.log(`📝 Title: ${title}\n`);
 
+  // Get date from project
+  const date = project.getDate();
+
   // Build the project to populate fragment times (needed for timecodes)
   console.log('🔨 Building project to calculate timecodes...');
   await project.build(upload.outputName);
@@ -134,6 +132,7 @@ export async function handleYouTubeUpload(
 
   const processedDescription = ejs.render(ejsDescription, {
     title,
+    date,
     tags: formattedTags,
     timecodes: timecodes.join('\n'),
   });

package/src/html-project-parser.ts

@@ -105,6 +105,7 @@ export class HTMLProjectParser {
     const outputs = this.processOutputs();
     const ffmpegOptions = this.processFfmpegOptions();
     const title = this.processTitle();
+    const date = this.processDate();
     const globalTags = this.processGlobalTags();
     const uploads = this.processUploads(title, globalTags);
     const sequences = this.processSequences(assets);
@@ -118,6 +119,7 @@ export class HTMLProjectParser {
       uploads,
       aiProviders,
       title,
+      date,
       cssText,
       this.projectPath,
     );
@@ -894,8 +896,9 @@ export class HTMLProjectParser {
     let endpoint: string | undefined;
     let region = '';
     let bucket = '';
-    let path = '';
+    const paths = new Map<string, string>();
     let acl: string | undefined;
+    let thumbnailTimecode: number | undefined;
 
     if ('children' in element && element.children) {
       for (const child of element.children) {
@@ -917,20 +920,49 @@ export class HTMLProjectParser {
               break;
             }
             case 'path': {
-              path = childAttrs.get('name') || '';
+              // Extract path name from name attribute
+              const pathName = childAttrs.get('name') || 'file';
+
+              // Extract path value from text content
+              let pathValue = '';
+              if ('children' in childElement && childElement.children) {
+                for (const textNode of childElement.children) {
+                  if (textNode.type === 'text' && 'data' in textNode) {
+                    pathValue += textNode.data;
+                  }
+                }
+              }
+
+              pathValue = pathValue.trim();
+              if (pathValue) {
+                paths.set(pathName, pathValue);
+              }
               break;
             }
             case 'acl': {
               acl = childAttrs.get('name');
               break;
             }
+            case 'thumbnail': {
+              const timecode = childAttrs.get('data-timecode');
+              if (timecode) {
+                // Parse timecode (e.g., "1000ms" or "1s")
+                const match = timecode.match(/^(\d+(?:\.\d+)?)(ms|s)$/);
+                if (match) {
+                  const value = parseFloat(match[1]);
+                  const unit = match[2];
+                  thumbnailTimecode = unit === 's' ? value * 1000 : value;
+                }
+              }
+              break;
+            }
           }
         }
       }
     }
 
     // Validate required fields
-    if (!region || !bucket || !path) {
+    if (!region || !bucket || paths.size === 0) {
       console.warn(`S3 upload "${name}" missing required fields (region, bucket, or path)`);
       return null;
     }
@@ -945,11 +977,12 @@ export class HTMLProjectParser {
       category: '',
       language: '',
       description: '',
+      thumbnailTimecode,
       s3: {
         endpoint,
         region,
         bucket,
-        path,
+        paths,
         acl,
       },
     };
@@ -1242,6 +1275,31 @@ export class HTMLProjectParser {
     return title.trim() || 'Untitled Project';
   }
 
+  /**
+   * Processes the date from the parsed HTML
+   */
+  private processDate(): string | undefined {
+    const dateElements = this.findDateElements();
+
+    if (dateElements.length === 0) {
+      return undefined;
+    }
+
+    // Get text content from first date element
+    const dateElement = dateElements[0];
+    let date = '';
+
+    if ('children' in dateElement && dateElement.children) {
+      for (const textNode of dateElement.children) {
+        if (textNode.type === 'text' && 'data' in textNode) {
+          date += textNode.data;
+        }
+      }
+    }
+
+    return date.trim() || undefined;
+  }
+
   /**
    * Finds all title elements in the HTML (top-level only, not inside uploads)
    */
@@ -1276,6 +1334,43 @@ export class HTMLProjectParser {
     return results;
   }
 
+  /**
+   * Finds all date elements in the HTML (top-level only)
+   */
+  private findDateElements(): Element[] {
+    const results: Element[] = [];
+
+    const traverse = (node: ASTNode, insideProject: boolean = false) => {
+      if (node.type === 'tag') {
+        const element = node as Element;
+
+        // Find top-level <date> tags (not inside <project>, <uploads>, etc.)
+        if (element.name === 'date' && !insideProject) {
+          results.push(element);
+        }
+
+        // Mark that we're inside a project/uploads/outputs section
+        const isProjectSection =
+          element.name === 'project' ||
+          element.name === 'uploads' ||
+          element.name === 'outputs';
+
+        if ('children' in node && node.children) {
+          for (const child of node.children) {
+            traverse(child, insideProject || isProjectSection);
+          }
+        }
+      } else if ('children' in node && node.children) {
+        for (const child of node.children) {
+          traverse(child, insideProject);
+        }
+      }
+    };
+
+    traverse(this.html.ast);
+    return results;
+  }
+
   /**
    * Finds all uploads elements in the HTML
    */

package/src/project.ts

@@ -26,6 +26,7 @@ export class Project {
     private uploads: Map<string, Upload>,
     private aiProviders: Map<string, AIProvider>,
     private title: string,
+    private date: string | undefined,
     private cssText: string,
     private projectPath: string,
   ) {
@@ -141,6 +142,10 @@ export class Project {
     return this.title;
   }
 
+  public getDate(): string | undefined {
+    return this.date;
+  }
+
   public getCssText(): string {
     return this.cssText;
   }

package/src/time-utils.ts

@@ -0,0 +1,15 @@
+/**
+ * Formats milliseconds to HH:MM:SS format
+ * @param ms - Time in milliseconds
+ * @returns Formatted time string (e.g., "01:23:45" or "00:05:30")
+ */
+export function formatDuration(ms: number): string {
+  const totalSeconds = Math.floor(ms / 1000);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const seconds = totalSeconds % 60;
+
+  const pad = (num: number) => num.toString().padStart(2, '0');
+
+  return `${pad(hours)}:${pad(minutes)}:${pad(seconds)}`;
+}

package/src/type.ts

@@ -101,7 +101,7 @@ export type Upload = {
     endpoint?: string; // e.g. "digitaloceanspaces.com"
     region: string; // e.g. "ams3", "us-east-1"
     bucket: string; // e.g. "my-bucket"
-    path: string; // e.g. "videos/${slug}/${output}.mp4"
+    paths: Map<string, string>; // e.g. Map { "file" => "videos/${slug}/${output}.mp4", "metadata" => "videos/${slug}/metadata.json" }
     acl?: string; // e.g. "public-read", "private"
   };
   // Instagram-specific configuration