@gannochenko/staticstripes 0.0.14 → 0.0.16

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

@@ -1,18 +1,9 @@
 import { UploadStrategy } from '../upload-strategy';
 import { Project } from '../../project';
 import { Upload } from '../../type';
-import { readFileSync, existsSync } from 'fs';
-import { resolve } from 'path';
 import ejs from 'ejs';
 import { makeRequest } from '../../lib/net';
-
-/**
- * Instagram credentials format stored in .auth/<upload-name>.json
- */
-interface InstagramCredentials {
-  accessToken: string; // Long-lived Instagram Graph API access token
-  igUserId: string; // Instagram User ID (not the username)
-}
+import { CredentialsManager, InstagramCredentials } from '../credentials';
 
 /**
  * Instagram upload strategy implementation
@@ -22,7 +13,7 @@ export class InstagramUploadStrategy implements UploadStrategy {
   private readonly API_VERSION = 'v21.0';
   private readonly GRAPH_API_BASE = 'https://graph.instagram.com';
 
-  constructor() {}
+  constructor(private credentialsManager?: CredentialsManager) {}
 
   getTag(): string {
     return 'instagram';
@@ -47,36 +38,32 @@ export class InstagramUploadStrategy implements UploadStrategy {
     const { caption, shareToFeed, thumbOffset, coverUrl, videoUrl } =
       upload.instagram;
 
-    // Load credentials from .auth/<upload-name>.json
-    const authDir = resolve(projectPath, '.auth');
-    const credentialsPath = resolve(authDir, `${upload.name}.json`);
-
-    if (!existsSync(credentialsPath)) {
-      throw new Error(
-        `❌ Error: Instagram credentials not found\n\n` +
-          `Expected location: ${credentialsPath}\n\n` +
-          `💡 Run authentication wizard:\n` +
-          `   staticstripes auth --upload-name ${upload.name}\n\n` +
-          `📖 Or view detailed setup instructions:\n` +
-          `   staticstripes auth-help instagram\n`,
-      );
-    }
-
-    console.log(`🔐 Loading credentials from: ${credentialsPath}`);
+    // Load credentials from local .auth/<upload-name>.json or global ~/.staticstripes/auth/<upload-name>.json
+    const manager =
+      this.credentialsManager ||
+      new CredentialsManager(projectPath, upload.name);
 
     let credentials: InstagramCredentials;
     try {
-      const credentialsJson = readFileSync(credentialsPath, 'utf-8');
-      credentials = JSON.parse(credentialsJson);
-
-      if (!credentials.accessToken || !credentials.igUserId) {
-        throw new Error('Missing accessToken or igUserId');
-      }
+      credentials = manager.load<InstagramCredentials>([
+        'accessToken',
+        'igUserId',
+      ]);
     } catch (error) {
+      // Add helpful context about Instagram credentials
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
       throw new Error(
-        `❌ Error: Failed to parse Instagram credentials from ${credentialsPath}\n` +
-          `Ensure the file contains valid JSON with accessToken and igUserId.\n` +
-          `Error: ${error instanceof Error ? error.message : String(error)}`,
+        `${errorMessage}\n\n` +
+          `💡 Instagram credentials file should contain:\n` +
+          `{\n` +
+          `  "accessToken": "YOUR_LONG_LIVED_ACCESS_TOKEN",\n` +
+          `  "igUserId": "YOUR_INSTAGRAM_USER_ID"\n` +
+          `}\n\n` +
+          `📖 Run authentication wizard:\n` +
+          `   staticstripes auth --upload-name ${upload.name}\n\n` +
+          `Or view detailed setup instructions:\n` +
+          `   staticstripes auth-help instagram\n`,
       );
     }
 
@@ -108,6 +95,9 @@ export class InstagramUploadStrategy implements UploadStrategy {
     // Determine title (use upload-specific title or fall back to project title)
     const title = upload.title || project.getTitle();
 
+    // Get date from project
+    const date = project.getDate();
+
     // Format tags with # and space-separated (Instagram style)
     const formattedTags = upload.tags.map((tag) => `#${tag}`).join(' ');
 
@@ -116,6 +106,7 @@ export class InstagramUploadStrategy implements UploadStrategy {
 
     const processedCaption = ejs.render(ejsCaption, {
       title,
+      date,
       tags: formattedTags,
     });
 
@@ -329,18 +320,26 @@ export class InstagramUploadStrategy implements UploadStrategy {
       throw new Error('S3 configuration missing');
     }
 
-    const { endpoint, region, bucket, path } = s3Upload.s3;
+    const { endpoint, region, bucket, paths } = s3Upload.s3;
     const output = project.getOutput(s3Upload.outputName);
     if (!output) {
       throw new Error(`Output "${s3Upload.outputName}" not found`);
     }
 
+    // Get the file path
+    const filePath = paths.get('file');
+    if (!filePath) {
+      throw new Error('S3 upload missing "file" path');
+    }
+
     // Interpolate path variables
     const slug = this.slugify(project.getTitle());
     const outputName = output.name;
-    const interpolatedPath = path
+    const date = project.getDate() || '';
+    const interpolatedPath = filePath
       .replace(/\$\{slug\}/g, slug)
-      .replace(/\$\{output\}/g, outputName);
+      .replace(/\$\{output\}/g, outputName)
+      .replace(/\$\{date\}/g, date);
 
     // Construct URL
     if (endpoint) {

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

@@ -3,22 +3,14 @@ import { Project } from '../../project';
 import { Upload } from '../../type';
 import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
 import { readFileSync, existsSync } from 'fs';
-import { resolve } from 'path';
-
-/**
- * S3 credentials format stored in .auth/<upload-name>.json
- */
-interface S3Credentials {
-  accessKeyId: string;
-  secretAccessKey: string;
-}
+import { CredentialsManager, S3Credentials } from '../credentials';
 
 /**
  * S3 upload strategy implementation
  * Supports generic S3-compatible storage (AWS S3, DigitalOcean Spaces, etc.)
  */
 export class S3UploadStrategy implements UploadStrategy {
-  constructor() {}
+  constructor(private credentialsManager?: CredentialsManager) {}
 
   getTag(): string {
     return 's3';
@@ -40,7 +32,14 @@ export class S3UploadStrategy implements UploadStrategy {
       );
     }
 
-    const { endpoint, region, bucket, path, acl } = upload.s3;
+    const { endpoint, region, bucket, paths, acl } = upload.s3;
+
+    // Validate that we have a "file" path
+    if (!paths.has('file')) {
+      throw new Error(
+        `❌ Error: S3 upload "${upload.name}" missing required <path name="file"> element`,
+      );
+    }
 
     // Validate ACL value if specified
     const allowedAcls = ['private', 'public-read', 'authenticated-read'];
@@ -52,15 +51,24 @@ export class S3UploadStrategy implements UploadStrategy {
       );
     }
 
-    // Load credentials from .auth/<upload-name>.json
-    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: S3Credentials;
+    try {
+      credentials = manager.load<S3Credentials>([
+        'accessKeyId',
+        'secretAccessKey',
+      ]);
+    } catch (error) {
+      // Add helpful context about S3 credentials format
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
       throw new Error(
-        `❌ Error: S3 credentials not found\n\n` +
-          `Expected location: ${credentialsPath}\n\n` +
-          `💡 Create a JSON file with your S3 credentials:\n` +
+        `${errorMessage}\n\n` +
+          `💡 S3 credentials file should contain:\n` +
           `{\n` +
           `  "accessKeyId": "YOUR_ACCESS_KEY",\n` +
           `  "secretAccessKey": "YOUR_SECRET_KEY"\n` +
@@ -71,24 +79,6 @@ export class S3UploadStrategy implements UploadStrategy {
       );
     }
 
-    console.log(`🔐 Loading credentials from: ${credentialsPath}`);
-
-    let credentials: S3Credentials;
-    try {
-      const credentialsJson = readFileSync(credentialsPath, 'utf-8');
-      credentials = JSON.parse(credentialsJson);
-
-      if (!credentials.accessKeyId || !credentials.secretAccessKey) {
-        throw new Error('Missing accessKeyId or secretAccessKey');
-      }
-    } catch (error) {
-      throw new Error(
-        `❌ Error: Failed to parse S3 credentials from ${credentialsPath}\n` +
-          `Ensure the file contains valid JSON with accessKeyId and secretAccessKey.\n` +
-          `Error: ${error instanceof Error ? error.message : String(error)}`,
-      );
-    }
-
     // Get the output file
     const output = project.getOutput(upload.outputName);
     if (!output) {
@@ -102,12 +92,23 @@ export class S3UploadStrategy implements UploadStrategy {
       );
     }
 
-    // Interpolate path variables
+    // Prepare interpolation variables
     const slug = this.slugify(project.getTitle());
     const outputName = output.name;
-    const interpolatedPath = path
-      .replace(/\$\{slug\}/g, slug)
-      .replace(/\$\{output\}/g, outputName);
+    const date = project.getDate() || '';
+    const title = project.getTitle();
+    const tags = upload.tags;
+
+    // Helper function to interpolate path variables
+    const interpolatePath = (pathTemplate: string): string => {
+      return pathTemplate
+        .replace(/\$\{slug\}/g, slug)
+        .replace(/\$\{output\}/g, outputName)
+        .replace(/\$\{date\}/g, date);
+    };
+
+    // Get and interpolate the file path
+    const filePath = interpolatePath(paths.get('file')!);
 
     console.log(`\n📦 Preparing S3 upload...`);
     console.log(`   Bucket: ${bucket}`);
@@ -115,8 +116,13 @@ export class S3UploadStrategy implements UploadStrategy {
     if (endpoint) {
       console.log(`   Endpoint: ${endpoint}`);
     }
-    console.log(`   Path: ${interpolatedPath}`);
-    console.log(`   File: ${output.path}\n`);
+    console.log(`   File path: ${filePath}`);
+    console.log(`   Video file: ${output.path}`);
+    if (paths.has('metadata')) {
+      const metadataPath = interpolatePath(paths.get('metadata')!);
+      console.log(`   Metadata path: ${metadataPath}`);
+    }
+    console.log('');
 
     // Configure S3 client
     const s3Config: any = {
@@ -138,41 +144,80 @@ export class S3UploadStrategy implements UploadStrategy {
 
     const s3Client = new S3Client(s3Config);
 
-    // Read file
-    console.log(`📤 Uploading to S3...`);
+    // Upload video file
+    console.log(`📤 Uploading video file...`);
     const fileBuffer = readFileSync(output.path);
 
-    // Upload file
-    const uploadParams: any = {
+    const fileUploadParams: any = {
       Bucket: bucket,
-      Key: interpolatedPath,
+      Key: filePath,
       Body: fileBuffer,
       ContentType: 'video/mp4',
     };
 
     // Add ACL if specified in configuration
     if (acl) {
-      uploadParams.ACL = acl;
+      fileUploadParams.ACL = acl;
     }
 
-    const command = new PutObjectCommand(uploadParams);
-
     try {
-      await s3Client.send(command);
+      await s3Client.send(new PutObjectCommand(fileUploadParams));
 
-      // Construct public URL
-      let publicUrl: string;
+      // Construct public URL for video
+      let fileUrl: string;
       if (endpoint) {
         // For DigitalOcean Spaces and similar services
         // Format: https://{bucket}.{region}.{endpoint}/{path}
-        publicUrl = `https://${bucket}.${region}.${endpoint}/${interpolatedPath}`;
+        fileUrl = `https://${bucket}.${region}.${endpoint}/${filePath}`;
       } else {
         // For AWS S3
-        publicUrl = `https://${bucket}.s3.${region}.amazonaws.com/${interpolatedPath}`;
+        fileUrl = `https://${bucket}.s3.${region}.amazonaws.com/${filePath}`;
+      }
+
+      console.log(`✅ Video uploaded successfully!`);
+      console.log(`🔗 Video URL: ${fileUrl}`);
+
+      // Upload metadata file if specified
+      if (paths.has('metadata')) {
+        console.log(`\n📤 Uploading metadata file...`);
+        const metadataPath = interpolatePath(paths.get('metadata')!);
+
+        // Create metadata JSON
+        const metadata = {
+          title,
+          date: date || null,
+          tags,
+        };
+
+        const metadataBuffer = Buffer.from(JSON.stringify(metadata, null, 2), 'utf-8');
+
+        const metadataUploadParams: any = {
+          Bucket: bucket,
+          Key: metadataPath,
+          Body: metadataBuffer,
+          ContentType: 'application/json',
+        };
+
+        // Add ACL if specified
+        if (acl) {
+          metadataUploadParams.ACL = acl;
+        }
+
+        await s3Client.send(new PutObjectCommand(metadataUploadParams));
+
+        // Construct public URL for metadata
+        let metadataUrl: string;
+        if (endpoint) {
+          metadataUrl = `https://${bucket}.${region}.${endpoint}/${metadataPath}`;
+        } else {
+          metadataUrl = `https://${bucket}.s3.${region}.amazonaws.com/${metadataPath}`;
+        }
+
+        console.log(`✅ Metadata uploaded successfully!`);
+        console.log(`🔗 Metadata URL: ${metadataUrl}`);
       }
 
-      console.log(`\n✅ Upload successful!`);
-      console.log(`🔗 Public URL: ${publicUrl}\n`);
+      console.log('');
     } catch (error) {
       throw new Error(
         `❌ Error: Failed to upload to S3\n` +

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,7 +896,7 @@ export class HTMLProjectParser {
     let endpoint: string | undefined;
     let region = '';
     let bucket = '';
-    let path = '';
+    const paths = new Map<string, string>();
     let acl: string | undefined;
 
     if ('children' in element && element.children) {
@@ -917,7 +919,23 @@ 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': {
@@ -930,7 +948,7 @@ export class HTMLProjectParser {
     }
 
     // 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;
     }
@@ -949,7 +967,7 @@ export class HTMLProjectParser {
         endpoint,
         region,
         bucket,
-        path,
+        paths,
         acl,
       },
     };
@@ -1242,6 +1260,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 +1319,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/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