@gannochenko/staticstripes 0.0.11 → 0.0.14

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

@@ -0,0 +1,398 @@
+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)
+}
+
+/**
+ * Instagram upload strategy implementation
+ * Uses Instagram Graph API to post Reels/Videos
+ */
+export class InstagramUploadStrategy implements UploadStrategy {
+  private readonly API_VERSION = 'v21.0';
+  private readonly GRAPH_API_BASE = 'https://graph.instagram.com';
+
+  constructor() {}
+
+  getTag(): string {
+    return 'instagram';
+  }
+
+  validate(): void {
+    // Validation happens in execute() since we need upload config
+  }
+
+  async execute(
+    project: Project,
+    upload: Upload,
+    projectPath: string,
+  ): Promise<void> {
+    // Validate Instagram configuration exists
+    if (!upload.instagram) {
+      throw new Error(
+        `❌ Error: Instagram configuration missing for upload "${upload.name}"`,
+      );
+    }
+
+    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}`);
+
+    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');
+      }
+    } catch (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)}`,
+      );
+    }
+
+    // Determine video URL
+    let publicVideoUrl: string;
+
+    if (videoUrl) {
+      // Use explicitly provided URL
+      publicVideoUrl = videoUrl;
+      console.log(`\n📹 Using provided video URL: ${publicVideoUrl}`);
+    } else {
+      // Try to infer from S3 upload if available
+      const s3Upload = this.findS3Upload(project, upload);
+      if (s3Upload && s3Upload.s3) {
+        publicVideoUrl = this.constructS3Url(project, s3Upload);
+        console.log(
+          `\n📹 Using S3 URL from upload "${s3Upload.name}": ${publicVideoUrl}`,
+        );
+      } else {
+        throw new Error(
+          `❌ Error: No video URL specified for Instagram upload "${upload.name}"\n\n` +
+            `Either:\n` +
+            `1. Add <video-url value="https://..." /> to your Instagram config, or\n` +
+            `2. Configure an S3 upload with the same output name to auto-generate the URL`,
+        );
+      }
+    }
+
+    // Determine title (use upload-specific title or fall back to project title)
+    const title = upload.title || project.getTitle();
+
+    // Format tags with # and space-separated (Instagram style)
+    const formattedTags = upload.tags.map((tag) => `#${tag}`).join(' ');
+
+    // Convert ${variable} syntax to <%= variable %> for EJS compatibility
+    const ejsCaption = caption.replace(/\$\{(\w+)\}/g, '<%= $1 %>');
+
+    const processedCaption = ejs.render(ejsCaption, {
+      title,
+      tags: formattedTags,
+    });
+
+    console.log(`\n📸 Preparing Instagram Reel upload...`);
+    console.log(`   Title: ${title}`);
+    console.log(`   Tags: ${formattedTags}`);
+    console.log(`   Caption: ${processedCaption.substring(0, 50)}${processedCaption.length > 50 ? '...' : ''}`);
+    console.log(`   Share to Feed: ${shareToFeed ? 'Yes' : 'No'}`);
+    if (thumbOffset) {
+      console.log(`   Thumbnail offset: ${thumbOffset}ms`);
+    }
+    console.log('');
+
+    // Step 1: Create media container
+    console.log('📦 Step 1: Creating media container...');
+    const containerId = await this.createMediaContainer(
+      credentials,
+      publicVideoUrl,
+      processedCaption,
+      shareToFeed,
+      thumbOffset,
+      coverUrl,
+    );
+
+    console.log(`✅ Container created: ${containerId}`);
+
+    // Step 2: Wait for container to be ready
+    console.log('\n⏳ Step 2: Waiting for Instagram to process video...');
+    await this.waitForContainerReady(credentials, containerId);
+
+    // Step 3: Publish the Reel
+    console.log('\n📤 Step 3: Publishing Reel...');
+    const mediaId = await this.publishMedia(credentials, containerId);
+
+    // Step 4: Get permalink
+    console.log('\n🔗 Getting permalink...');
+    const permalink = await this.getPermalink(credentials, mediaId);
+
+    console.log(`\n✅ Reel published successfully!`);
+    console.log(`🔗 Media ID: ${mediaId}`);
+    console.log(`📺 View at: ${permalink}\n`);
+  }
+
+  /**
+   * Creates a media container for the Reel
+   */
+  private async createMediaContainer(
+    credentials: InstagramCredentials,
+    videoUrl: string,
+    caption: string,
+    shareToFeed: boolean,
+    thumbOffset?: number,
+    coverUrl?: string,
+  ): Promise<string> {
+    const params = new URLSearchParams({
+      media_type: 'REELS',
+      video_url: videoUrl,
+      caption: caption,
+      access_token: credentials.accessToken,
+    });
+
+    if (shareToFeed) {
+      params.append('share_to_feed', 'true');
+    }
+
+    if (thumbOffset !== undefined) {
+      params.append('thumb_offset', thumbOffset.toString());
+    }
+
+    if (coverUrl) {
+      params.append('cover_url', coverUrl);
+    }
+
+    const url = `${this.GRAPH_API_BASE}/${this.API_VERSION}/${credentials.igUserId}/media`;
+
+    try {
+      const data = await makeRequest<{ id?: string }>({
+        url,
+        method: 'POST',
+        body: params,
+      });
+
+      if (!data.id) {
+        throw new Error('No container ID returned from API');
+      }
+
+      return data.id;
+    } catch (error) {
+      throw new Error(
+        `❌ Error: Failed to create media container\n` +
+          `${error instanceof Error ? error.message : String(error)}\n\n` +
+          `Common issues:\n` +
+          `- Video URL must be publicly accessible\n` +
+          `- Access token may be expired (refresh it)\n` +
+          `- Video must be MP4 format and meet Instagram requirements\n` +
+          `- Instagram User ID must be correct`,
+      );
+    }
+  }
+
+  /**
+   * Waits for the container to be ready for publishing
+   * Polls the status endpoint until status_code is FINISHED
+   */
+  private async waitForContainerReady(
+    credentials: InstagramCredentials,
+    containerId: string,
+  ): Promise<void> {
+    const maxAttempts = 60; // Maximum 60 attempts (5 minutes)
+    const delayMs = 5000; // 5 seconds between checks
+
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      const params = new URLSearchParams({
+        fields: 'status_code',
+        access_token: credentials.accessToken,
+      });
+
+      const url = `${this.GRAPH_API_BASE}/${this.API_VERSION}/${containerId}?${params.toString()}`;
+
+      try {
+        const data = await makeRequest<{ status_code?: string }>({
+          url,
+          method: 'GET',
+        });
+
+        if (data.status_code === 'FINISHED') {
+          console.log(`✅ Video processed and ready!`);
+          return;
+        } else if (data.status_code === 'ERROR') {
+          throw new Error('Instagram failed to process the video');
+        } else if (data.status_code === 'IN_PROGRESS') {
+          console.log(`   Processing... (${attempt}/${maxAttempts})`);
+        } else {
+          console.log(
+            `   Status: ${data.status_code || 'UNKNOWN'} (${attempt}/${maxAttempts})`,
+          );
+        }
+      } catch (error) {
+        console.log(`   Warning: Status check failed, continuing...`);
+      }
+
+      // Wait before next check
+      if (attempt < maxAttempts) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+      }
+    }
+
+    // If we get here, we timed out, but let's try to publish anyway
+    console.log(
+      `⚠️  Timeout waiting for status. Attempting to publish anyway...`,
+    );
+  }
+
+  /**
+   * Publishes the media container
+   */
+  private async publishMedia(
+    credentials: InstagramCredentials,
+    containerId: string,
+  ): Promise<string> {
+    const params = new URLSearchParams({
+      creation_id: containerId,
+      access_token: credentials.accessToken,
+    });
+
+    const url = `${this.GRAPH_API_BASE}/${this.API_VERSION}/${credentials.igUserId}/media_publish`;
+
+    try {
+      const data = await makeRequest<{ id?: string }>({
+        url,
+        method: 'POST',
+        body: params,
+      });
+
+      if (!data.id) {
+        throw new Error('No media ID returned from API');
+      }
+
+      return data.id;
+    } catch (error) {
+      throw new Error(
+        `❌ Error: Failed to publish media\n` +
+          `${error instanceof Error ? error.message : String(error)}\n\n` +
+          `The container may still be processing. Wait a few seconds and try again.`,
+      );
+    }
+  }
+
+  /**
+   * Finds a corresponding S3 upload for the same output
+   */
+  private findS3Upload(project: Project, upload: Upload): Upload | undefined {
+    const uploads = project.getUploads();
+    for (const [name, u] of uploads.entries()) {
+      if (
+        u.tag === 's3' &&
+        u.outputName === upload.outputName &&
+        name !== upload.name
+      ) {
+        return u;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Constructs the public S3 URL for a video
+   */
+  private constructS3Url(project: Project, s3Upload: Upload): string {
+    if (!s3Upload.s3) {
+      throw new Error('S3 configuration missing');
+    }
+
+    const { endpoint, region, bucket, path } = s3Upload.s3;
+    const output = project.getOutput(s3Upload.outputName);
+    if (!output) {
+      throw new Error(`Output "${s3Upload.outputName}" not found`);
+    }
+
+    // Interpolate path variables
+    const slug = this.slugify(project.getTitle());
+    const outputName = output.name;
+    const interpolatedPath = path
+      .replace(/\$\{slug\}/g, slug)
+      .replace(/\$\{output\}/g, outputName);
+
+    // Construct URL
+    if (endpoint) {
+      return `https://${bucket}.${region}.${endpoint}/${interpolatedPath}`;
+    } else {
+      return `https://${bucket}.s3.${region}.amazonaws.com/${interpolatedPath}`;
+    }
+  }
+
+  /**
+   * Converts a string to a URL-friendly slug
+   */
+  private slugify(text: string): string {
+    return text
+      .toString()
+      .toLowerCase()
+      .trim()
+      .replace(/\s+/g, '-')
+      .replace(/[^\w\-]+/g, '')
+      .replace(/\-\-+/g, '-')
+      .replace(/^-+/, '')
+      .replace(/-+$/, '');
+  }
+
+  /**
+   * Gets the permalink (URL) for the published media
+   */
+  private async getPermalink(
+    credentials: InstagramCredentials,
+    mediaId: string,
+  ): Promise<string> {
+    const params = new URLSearchParams({
+      fields: 'permalink',
+      access_token: credentials.accessToken,
+    });
+
+    const url = `${this.GRAPH_API_BASE}/${this.API_VERSION}/${mediaId}?${params.toString()}`;
+
+    try {
+      const data = await makeRequest<{ permalink?: string }>({
+        url,
+        method: 'GET',
+      });
+
+      if (!data.permalink) {
+        return `https://www.instagram.com/ (check your profile)`;
+      }
+
+      return data.permalink;
+    } catch (error) {
+      console.log(`   Warning: Failed to get permalink: ${error}`);
+      return `https://www.instagram.com/ (check your profile)`;
+    }
+  }
+}

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

@@ -0,0 +1,198 @@
+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';
+
+/**
+ * S3 credentials format stored in .auth/<upload-name>.json
+ */
+interface S3Credentials {
+  accessKeyId: string;
+  secretAccessKey: string;
+}
+
+/**
+ * S3 upload strategy implementation
+ * Supports generic S3-compatible storage (AWS S3, DigitalOcean Spaces, etc.)
+ */
+export class S3UploadStrategy implements UploadStrategy {
+  constructor() {}
+
+  getTag(): string {
+    return 's3';
+  }
+
+  validate(): void {
+    // Validation happens in execute() since we need upload config
+  }
+
+  async execute(
+    project: Project,
+    upload: Upload,
+    projectPath: string,
+  ): Promise<void> {
+    // Validate S3 configuration exists
+    if (!upload.s3) {
+      throw new Error(
+        `❌ Error: S3 configuration missing for upload "${upload.name}"`,
+      );
+    }
+
+    const { endpoint, region, bucket, path, acl } = upload.s3;
+
+    // Validate ACL value if specified
+    const allowedAcls = ['private', 'public-read', 'authenticated-read'];
+    if (acl && !allowedAcls.includes(acl)) {
+      throw new Error(
+        `❌ Error: Invalid ACL value "${acl}" for upload "${upload.name}"\n\n` +
+          `Allowed values: ${allowedAcls.join(', ')}\n` +
+          `Note: "public-read-write" is not supported for security reasons.`,
+      );
+    }
+
+    // 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: S3 credentials not found\n\n` +
+          `Expected location: ${credentialsPath}\n\n` +
+          `💡 Create a JSON file with your S3 credentials:\n` +
+          `{\n` +
+          `  "accessKeyId": "YOUR_ACCESS_KEY",\n` +
+          `  "secretAccessKey": "YOUR_SECRET_KEY"\n` +
+          `}\n\n` +
+          `📖 Get credentials from:\n` +
+          `   • AWS: IAM → Users → Security Credentials\n` +
+          `   • DigitalOcean: API → Spaces Keys\n`,
+      );
+    }
+
+    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) {
+      throw new Error(`❌ Error: Output "${upload.outputName}" not found`);
+    }
+
+    if (!existsSync(output.path)) {
+      throw new Error(
+        `❌ Error: Output file not found: ${output.path}\n` +
+          '💡 Please generate the video first',
+      );
+    }
+
+    // Interpolate path variables
+    const slug = this.slugify(project.getTitle());
+    const outputName = output.name;
+    const interpolatedPath = path
+      .replace(/\$\{slug\}/g, slug)
+      .replace(/\$\{output\}/g, outputName);
+
+    console.log(`\n📦 Preparing S3 upload...`);
+    console.log(`   Bucket: ${bucket}`);
+    console.log(`   Region: ${region}`);
+    if (endpoint) {
+      console.log(`   Endpoint: ${endpoint}`);
+    }
+    console.log(`   Path: ${interpolatedPath}`);
+    console.log(`   File: ${output.path}\n`);
+
+    // Configure S3 client
+    const s3Config: any = {
+      region,
+      credentials: {
+        accessKeyId: credentials.accessKeyId,
+        secretAccessKey: credentials.secretAccessKey,
+      },
+    };
+
+    // Add custom endpoint for S3-compatible services (DigitalOcean Spaces, etc.)
+    if (endpoint) {
+      // Construct the endpoint URL with region for S3-compatible services
+      // e.g., "ams3.digitaloceanspaces.com" for DigitalOcean Spaces
+      s3Config.endpoint = `https://${region}.${endpoint}`;
+      // Use virtual-hosted-style addressing (bucket.region.endpoint.com)
+      s3Config.forcePathStyle = false;
+    }
+
+    const s3Client = new S3Client(s3Config);
+
+    // Read file
+    console.log(`📤 Uploading to S3...`);
+    const fileBuffer = readFileSync(output.path);
+
+    // Upload file
+    const uploadParams: any = {
+      Bucket: bucket,
+      Key: interpolatedPath,
+      Body: fileBuffer,
+      ContentType: 'video/mp4',
+    };
+
+    // Add ACL if specified in configuration
+    if (acl) {
+      uploadParams.ACL = acl;
+    }
+
+    const command = new PutObjectCommand(uploadParams);
+
+    try {
+      await s3Client.send(command);
+
+      // Construct public URL
+      let publicUrl: string;
+      if (endpoint) {
+        // For DigitalOcean Spaces and similar services
+        // Format: https://{bucket}.{region}.{endpoint}/{path}
+        publicUrl = `https://${bucket}.${region}.${endpoint}/${interpolatedPath}`;
+      } else {
+        // For AWS S3
+        publicUrl = `https://${bucket}.s3.${region}.amazonaws.com/${interpolatedPath}`;
+      }
+
+      console.log(`\n✅ Upload successful!`);
+      console.log(`🔗 Public URL: ${publicUrl}\n`);
+    } catch (error) {
+      throw new Error(
+        `❌ Error: Failed to upload to S3\n` +
+          `${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  /**
+   * Converts a string to a URL-friendly slug
+   */
+  private slugify(text: string): string {
+    return text
+      .toString()
+      .toLowerCase()
+      .trim()
+      .replace(/\s+/g, '-') // Replace spaces with -
+      .replace(/[^\w\-]+/g, '') // Remove non-word chars
+      .replace(/\-\-+/g, '-') // Replace multiple - with single -
+      .replace(/^-+/, '') // Trim - from start
+      .replace(/-+$/, ''); // Trim - from end
+  }
+}

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

@@ -0,0 +1,55 @@
+import { UploadStrategy } from './upload-strategy';
+import { YouTubeUploadStrategy } from './youtube/youtube-upload-strategy';
+import { S3UploadStrategy } from './s3/s3-upload-strategy';
+import { InstagramUploadStrategy } from './instagram/instagram-upload-strategy';
+
+/**
+ * Factory for creating upload strategies based on upload tag
+ */
+export class UploadStrategyFactory {
+  private strategies: Map<string, UploadStrategy> = new Map();
+
+  /**
+   * Registers an upload strategy
+   */
+  register(strategy: UploadStrategy): void {
+    this.strategies.set(strategy.getTag(), strategy);
+  }
+
+  /**
+   * Gets a strategy for the given tag
+   * @param tag The upload provider tag (e.g., "youtube", "s3", "instagram")
+   * @returns The strategy for this tag
+   * @throws Error if no strategy is registered for the tag
+   */
+  getStrategy(tag: string): UploadStrategy {
+    const strategy = this.strategies.get(tag);
+    if (!strategy) {
+      const availableTags = Array.from(this.strategies.keys());
+      throw new Error(
+        `No upload strategy registered for tag "${tag}".\n` +
+          (availableTags.length > 0
+            ? `Available: ${availableTags.join(', ')}`
+            : 'No upload strategies registered.'),
+      );
+    }
+    return strategy;
+  }
+
+  /**
+   * Creates a factory with all available strategies registered
+   */
+  static createDefault(): UploadStrategyFactory {
+    const factory = new UploadStrategyFactory();
+
+    factory.register(new YouTubeUploadStrategy());
+
+    // Register S3 strategy
+    factory.register(new S3UploadStrategy());
+
+    // Register Instagram strategy
+    factory.register(new InstagramUploadStrategy());
+
+    return factory;
+  }
+}

package/src/cli/upload-strategy.ts

@@ -0,0 +1,31 @@
+import { Project } from '../project';
+import { YouTubeUpload } from '../type';
+
+/**
+ * Interface for upload strategies
+ * Each upload provider (YouTube, S3, etc.) implements this interface
+ */
+export interface UploadStrategy {
+  /**
+   * Returns the tag name this strategy handles (e.g., "youtube", "s3")
+   */
+  getTag(): string;
+
+  /**
+   * Validates that required environment variables and configuration are present
+   * @throws Error if validation fails
+   */
+  validate(): void;
+
+  /**
+   * Executes the upload
+   * @param project The parsed project
+   * @param upload The upload configuration
+   * @param projectPath The absolute path to the project directory
+   */
+  execute(
+    project: Project,
+    upload: YouTubeUpload,
+    projectPath: string,
+  ): Promise<void>;
+}