@gannochenko/staticstripes 0.0.15 → 0.0.17

package/src/cli/credentials.ts

@@ -0,0 +1,171 @@
+import { readFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { homedir } from 'os';
+
+/**
+ * Generic credentials interface for upload services
+ */
+export interface Credentials {
+  [key: string]: any;
+}
+
+/**
+ * S3-specific credentials format
+ */
+export interface S3Credentials extends Credentials {
+  accessKeyId: string;
+  secretAccessKey: string;
+}
+
+/**
+ * YouTube-specific credentials format
+ */
+export interface YouTubeCredentials extends Credentials {
+  clientId: string;
+  clientSecret: string;
+}
+
+/**
+ * Instagram-specific credentials format
+ */
+export interface InstagramCredentials extends Credentials {
+  accessToken: string;
+  igUserId: string;
+}
+
+/**
+ * AI Music API credentials format
+ */
+export interface MusicAPICredentials extends Credentials {
+  apiKey: string;
+}
+
+/**
+ * Credentials manager that handles loading credentials from local or global locations
+ *
+ * Search priority:
+ * 1. Local: <projectPath>/.auth/<credentialName>.json
+ * 2. Global: $HOME/.staticstripes/auth/<credentialName>.json
+ */
+export class CredentialsManager {
+  private projectPath: string;
+  private credentialName: string;
+
+  constructor(projectPath: string, credentialName: string) {
+    this.projectPath = projectPath;
+    this.credentialName = credentialName;
+  }
+
+  /**
+   * Get the local credentials path
+   */
+  private getLocalPath(): string {
+    const authDir = resolve(this.projectPath, '.auth');
+    return resolve(authDir, `${this.credentialName}.json`);
+  }
+
+  /**
+   * Get the global credentials path
+   * Works cross-platform (Windows, macOS, Linux)
+   */
+  private getGlobalPath(): string {
+    const homeDir = homedir();
+    const globalAuthDir = resolve(homeDir, '.staticstripes', 'auth');
+    return resolve(globalAuthDir, `${this.credentialName}.json`);
+  }
+
+  /**
+   * Find and return the credentials file path
+   * Returns the path and whether it was found locally or globally
+   */
+  private findCredentialsPath(): { path: string; location: 'local' | 'global' } | null {
+    const localPath = this.getLocalPath();
+    if (existsSync(localPath)) {
+      return { path: localPath, location: 'local' };
+    }
+
+    const globalPath = this.getGlobalPath();
+    if (existsSync(globalPath)) {
+      return { path: globalPath, location: 'global' };
+    }
+
+    return null;
+  }
+
+  /**
+   * Load credentials from local or global location
+   *
+   * @param requiredFields - Array of required field names to validate
+   * @returns The credentials object
+   * @throws Error if credentials not found or invalid
+   */
+  load<T extends Credentials>(requiredFields: string[] = []): T {
+    const found = this.findCredentialsPath();
+
+    if (!found) {
+      const localPath = this.getLocalPath();
+      const globalPath = this.getGlobalPath();
+
+      throw new Error(
+        `❌ Error: Credentials not found for "${this.credentialName}"\n\n` +
+          `Searched in:\n` +
+          `   1. Local:  ${localPath}\n` +
+          `   2. Global: ${globalPath}\n\n` +
+          `💡 Create a JSON file in one of these locations with your credentials.\n` +
+          `   The global location is useful for sharing credentials across projects.\n`,
+      );
+    }
+
+    const { path: credentialsPath, location } = found;
+    console.log(`🔐 Loading credentials from ${location} storage: ${credentialsPath}`);
+
+    try {
+      const credentialsJson = readFileSync(credentialsPath, 'utf-8');
+      const credentials = JSON.parse(credentialsJson) as T;
+
+      // Validate required fields
+      const missingFields = requiredFields.filter(
+        (field) => !credentials[field],
+      );
+
+      if (missingFields.length > 0) {
+        throw new Error(
+          `Missing required fields: ${missingFields.join(', ')}`,
+        );
+      }
+
+      return credentials;
+    } catch (error) {
+      throw new Error(
+        `❌ Error: Failed to parse credentials from ${credentialsPath}\n` +
+          `Ensure the file contains valid JSON.\n` +
+          `Error: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  /**
+   * Check if credentials exist (locally or globally)
+   */
+  exists(): boolean {
+    return this.findCredentialsPath() !== null;
+  }
+
+  /**
+   * Get information about where credentials are stored
+   */
+  getInfo(): {
+    localPath: string;
+    globalPath: string;
+    exists: boolean;
+    location?: 'local' | 'global';
+  } {
+    const found = this.findCredentialsPath();
+    return {
+      localPath: this.getLocalPath(),
+      globalPath: this.getGlobalPath(),
+      exists: found !== null,
+      location: found?.location,
+    };
+  }
+}

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

@@ -2,23 +2,20 @@ import { UploadStrategy } from '../upload-strategy';
 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';
+import { readFileSync, existsSync, mkdirSync } from 'fs';
+import { CredentialsManager, S3Credentials } from '../credentials';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { dirname, resolve } from 'path';
 
-/**
- * S3 credentials format stored in .auth/<upload-name>.json
- */
-interface S3Credentials {
-  accessKeyId: string;
-  secretAccessKey: string;
-}
+const execAsync = promisify(exec);
 
 /**
  * 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 +37,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 +56,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 +84,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 +97,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 +121,18 @@ 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}`);
+    }
+    if (upload.thumbnailTimecode !== undefined && paths.has('thumbnail')) {
+      const thumbnailPath = interpolatePath(paths.get('thumbnail')!);
+      console.log(`   Thumbnail path: ${thumbnailPath}`);
+      console.log(`   Thumbnail timecode: ${upload.thumbnailTimecode}ms`);
+    }
+    console.log('');
 
     // Configure S3 client
     const s3Config: any = {
@@ -138,41 +154,126 @@ 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(`\n✅ Upload successful!`);
-      console.log(`🔗 Public URL: ${publicUrl}\n`);
+      console.log(`✅ Video uploaded successfully!`);
+      console.log(`🔗 Video URL: ${fileUrl}`);
+
+      // Upload thumbnail if specified
+      if (upload.thumbnailTimecode !== undefined && paths.has('thumbnail')) {
+        console.log(
+          `\n🖼️  Extracting thumbnail at ${upload.thumbnailTimecode}ms...`,
+        );
+        const thumbnailPath = resolve(
+          dirname(projectPath),
+          '.cache',
+          'thumbnail.jpeg',
+        );
+        await this.extractThumbnail(
+          output.path,
+          upload.thumbnailTimecode,
+          thumbnailPath,
+        );
+
+        console.log(`📤 Uploading thumbnail...`);
+        const s3ThumbnailPath = interpolatePath(paths.get('thumbnail')!);
+        const thumbnailBuffer = readFileSync(thumbnailPath);
+
+        const thumbnailUploadParams: any = {
+          Bucket: bucket,
+          Key: s3ThumbnailPath,
+          Body: thumbnailBuffer,
+          ContentType: 'image/jpeg',
+        };
+
+        // Add ACL if specified
+        if (acl) {
+          thumbnailUploadParams.ACL = acl;
+        }
+
+        await s3Client.send(new PutObjectCommand(thumbnailUploadParams));
+
+        // Construct public URL for thumbnail
+        let thumbnailUrl: string;
+        if (endpoint) {
+          thumbnailUrl = `https://${bucket}.${region}.${endpoint}/${s3ThumbnailPath}`;
+        } else {
+          thumbnailUrl = `https://${bucket}.s3.${region}.amazonaws.com/${s3ThumbnailPath}`;
+        }
+
+        console.log(`✅ Thumbnail uploaded successfully!`);
+        console.log(`🔗 Thumbnail URL: ${thumbnailUrl}`);
+      }
+
+      // 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('');
     } catch (error) {
       throw new Error(
         `❌ Error: Failed to upload to S3\n` +
@@ -195,4 +296,24 @@ export class S3UploadStrategy implements UploadStrategy {
       .replace(/^-+/, '') // Trim - from start
       .replace(/-+$/, ''); // Trim - from end
   }
+
+  /**
+   * Extracts a frame from video at specific timecode using ffmpeg
+   */
+  private async extractThumbnail(
+    videoPath: string,
+    timecode: number,
+    outputPath: string,
+  ): Promise<void> {
+    // Ensure the output directory exists
+    const outputDir = dirname(outputPath);
+    if (!existsSync(outputDir)) {
+      mkdirSync(outputDir, { recursive: true });
+    }
+
+    const timeInSeconds = timecode / 1000;
+    const command = `ffmpeg -y -ss ${timeInSeconds} -i "${videoPath}" -frames:v 1 -q:v 2 "${outputPath}"`;
+
+    await execAsync(command);
+  }
 }