@gannochenko/staticstripes 0.0.10 → 0.0.12

package/src/cli/commands/upload.ts

@@ -0,0 +1,83 @@
+import { Command } from 'commander';
+import { resolve } from 'path';
+import { existsSync } from 'fs';
+import { HTMLParser } from '../../html-parser.js';
+import { HTMLProjectParser } from '../../html-project-parser.js';
+import { UploadStrategyFactory } from '../upload-strategy-factory.js';
+
+/**
+ * Registers the generic upload command that works with any upload provider
+ */
+export function registerUploadCommand(
+  program: Command,
+  handleError: (error: any, operation: string) => void,
+): void {
+  program
+    .command('upload')
+    .description('Upload video to configured platform (YouTube, S3, etc.)')
+    .option('-p, --project <path>', 'Path to project directory', '.')
+    .requiredOption('--upload-name <name>', 'Name of the upload configuration')
+    .action(async (options) => {
+      try {
+        // Resolve project path
+        const projectPath = resolve(process.cwd(), options.project);
+        const projectFilePath = resolve(projectPath, 'project.html');
+
+        // Validate project.html exists
+        if (!existsSync(projectFilePath)) {
+          console.error(`❌ Error: project.html not found in ${projectPath}`);
+          process.exit(1);
+        }
+
+        console.log(`📁 Project: ${projectPath}`);
+        console.log(`📄 Loading: ${projectFilePath}\n`);
+
+        // Parse the project HTML file
+        const parser = new HTMLProjectParser(
+          await new HTMLParser().parseFile(projectFilePath),
+          projectFilePath,
+        );
+        const project = await parser.parse();
+
+        // Get the upload configuration
+        const upload = project.getUpload(options.uploadName);
+        if (!upload) {
+          const availableUploads = Array.from(
+            project.getUploads().keys(),
+          );
+          console.error(
+            `❌ Upload "${options.uploadName}" not found in project.html\n`,
+          );
+          if (availableUploads.length > 0) {
+            console.error(`Available uploads: ${availableUploads.join(', ')}`);
+          } else {
+            console.error('No uploads defined in project.html');
+          }
+          process.exit(1);
+        }
+
+        // Validate output file exists
+        const output = project.getOutput(upload.outputName);
+        if (output && !existsSync(output.path)) {
+          console.error(`❌ Error: Output file not found: ${output.path}`);
+          console.error(
+            '💡 Please generate the video first with: staticstripes generate\n',
+          );
+          process.exit(1);
+        }
+
+        // Get the appropriate strategy for this upload tag
+        const factory = UploadStrategyFactory.createDefault();
+        const strategy = factory.getStrategy(upload.tag);
+
+        // Validate strategy requirements
+        strategy.validate();
+
+        // Execute the upload
+        await strategy.execute(project, upload, projectPath);
+      } catch (error) {
+        handleError(error, 'Upload');
+        process.exit(1);
+      }
+    });
+}

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

@@ -0,0 +1,194 @@
+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 at ${credentialsPath}\n\n` +
+          `💡 Create a JSON file with the following format:\n` +
+          `{\n` +
+          `  "accessKeyId": "YOUR_ACCESS_KEY",\n` +
+          `  "secretAccessKey": "YOUR_SECRET_KEY"\n` +
+          `}\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,58 @@
+import { UploadStrategy } from './upload-strategy';
+import { YouTubeUploadStrategy } from './youtube/youtube-upload-strategy';
+import { S3UploadStrategy } from './s3/s3-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")
+   * @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();
+
+    // Register YouTube strategy (validation happens during execute)
+    const youtubeClientId = process.env.STATICSTRIPES_GOOGLE_CLIENT_ID || '';
+    const youtubeClientSecret =
+      process.env.STATICSTRIPES_GOOGLE_CLIENT_SECRET || '';
+
+    factory.register(
+      new YouTubeUploadStrategy(youtubeClientId, youtubeClientSecret),
+    );
+
+    // Register S3 strategy
+    factory.register(new S3UploadStrategy());
+
+    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>;
+}

package/src/cli/youtube/auth-commands.ts

@@ -0,0 +1,312 @@
+import { Command } from 'commander';
+import { resolve } from 'path';
+import { existsSync } from 'fs';
+import { YouTubeUploader } from '../../youtube-uploader.js';
+import open from 'open';
+import http from 'http';
+import { parse as parseUrl } from 'url';
+
+function getOAuthInstructions(): string {
+  let instructions = '';
+  instructions +=
+    '❌ Error: STATICSTRIPES_GOOGLE_CLIENT_ID and STATICSTRIPES_GOOGLE_CLIENT_SECRET environment variables are not set\n\n';
+  instructions += '📋 Getting Google OAuth Credentials:\n\n';
+  instructions += '1. Go to Google Cloud Console:\n';
+  instructions += '   https://console.cloud.google.com/\n\n';
+  instructions += '2. Create or select a project\n\n';
+  instructions += '3. Enable YouTube Data API v3:\n';
+  instructions += '   - Go to "APIs & Services" > "Library"\n';
+  instructions += '   - Search for "YouTube Data API v3"\n';
+  instructions += '   - Click "Enable"\n\n';
+  instructions += '4. Configure OAuth Consent Screen:\n';
+  instructions += '   - Go to "APIs & Services" > "OAuth consent screen"\n';
+  instructions += '   - Choose "External" user type\n';
+  instructions += '   - Fill in app name and contact emails\n';
+  instructions +=
+    '   - Add scope: https://www.googleapis.com/auth/youtube.upload\n';
+  instructions += '   - Add your email as a test user\n\n';
+  instructions += '5. Create OAuth 2.0 Credentials:\n';
+  instructions += '   - Go to "APIs & Services" > "Credentials"\n';
+  instructions += '   - Click "Create Credentials" > "OAuth client ID"\n';
+  instructions += '   - Choose "Web application"\n';
+  instructions +=
+    '   - Add redirect URI: http://localhost:3000/oauth2callback\n';
+  instructions += '   - Click "Create"\n\n';
+  instructions += '6. Copy your Client ID and Client Secret\n\n';
+  instructions += '7. Publish your OAuth app (IMPORTANT):\n';
+  instructions +=
+    '   - Go to "APIs & Services" > "OAuth consent screen"\n';
+  instructions += '   - Click "PUBLISH APP" button\n';
+  instructions +=
+    '   - This makes refresh tokens permanent (otherwise they expire in 7 days)\n';
+  instructions +=
+    '   - Note: For personal use, you don\'t need Google verification\n\n';
+  instructions += '8. Set environment variables:\n\n';
+
+  // Platform-specific instructions
+  const platform = process.platform;
+  if (platform === 'win32') {
+    instructions += '   PowerShell (Recommended) - Run as Administrator:\n';
+    instructions +=
+      '     [System.Environment]::SetEnvironmentVariable("STATICSTRIPES_GOOGLE_CLIENT_ID", "your-client-id.apps.googleusercontent.com", "User")\n';
+    instructions +=
+      '     [System.Environment]::SetEnvironmentVariable("STATICSTRIPES_GOOGLE_CLIENT_SECRET", "your-client-secret", "User")\n';
+    instructions += '   Then restart your terminal\n\n';
+    instructions += '   Or Command Prompt - Run as Administrator:\n';
+    instructions +=
+      '     setx STATICSTRIPES_GOOGLE_CLIENT_ID "your-client-id.apps.googleusercontent.com"\n';
+    instructions +=
+      '     setx STATICSTRIPES_GOOGLE_CLIENT_SECRET "your-client-secret"\n';
+    instructions += '   Then restart your terminal\n\n';
+  } else if (platform === 'darwin') {
+    instructions += '   Add to ~/.zshrc (or ~/.bash_profile for bash):\n';
+    instructions +=
+      '     export STATICSTRIPES_GOOGLE_CLIENT_ID="your-client-id.apps.googleusercontent.com"\n';
+    instructions +=
+      '     export STATICSTRIPES_GOOGLE_CLIENT_SECRET="your-client-secret"\n\n';
+    instructions += '   Then reload your shell:\n';
+    instructions += '     source ~/.zshrc\n\n';
+  } else {
+    // Linux and others
+    instructions += '   Add to ~/.bashrc (or ~/.zshrc for zsh):\n';
+    instructions +=
+      '     export STATICSTRIPES_GOOGLE_CLIENT_ID="your-client-id.apps.googleusercontent.com"\n';
+    instructions +=
+      '     export STATICSTRIPES_GOOGLE_CLIENT_SECRET="your-client-secret"\n\n';
+    instructions += '   Then reload your shell:\n';
+    instructions += '     source ~/.bashrc  # or source ~/.zshrc\n\n';
+  }
+
+  return instructions;
+}
+
+export function registerYouTubeAuthCommands(program: Command): void {
+  program
+    .command('auth')
+    .description('Authenticate with YouTube for uploading')
+    .option('-p, --project <path>', 'Path to project directory', '.')
+    .requiredOption('--upload-name <name>', 'Name of the upload configuration')
+    .action(async (options) => {
+      try {
+        // Get OAuth credentials from environment variables
+        const clientId = process.env.STATICSTRIPES_GOOGLE_CLIENT_ID;
+        const clientSecret = process.env.STATICSTRIPES_GOOGLE_CLIENT_SECRET;
+
+        if (!clientId || !clientSecret) {
+          console.error(getOAuthInstructions());
+          process.exit(1);
+        }
+
+        // Resolve project path
+        const projectPath = resolve(process.cwd(), options.project);
+        const projectFilePath = resolve(projectPath, 'project.html');
+
+        // Validate project.html exists
+        if (!existsSync(projectFilePath)) {
+          console.error(`Error: project.html not found in ${projectPath}`);
+          process.exit(1);
+        }
+
+        console.log(`📁 Project: ${projectPath}`);
+        console.log(`🔐 Authenticating: ${options.uploadName}\n`);
+
+        // Create uploader instance
+        const uploader = new YouTubeUploader(clientId, clientSecret);
+
+        // Get authorization URL
+        const authUrl = uploader.getAuthUrl();
+
+        console.log('🌐 Starting local server on http://localhost:3000...\n');
+
+        // Create a promise that resolves when we get the OAuth callback
+        const authPromise = new Promise<string>((resolve, reject) => {
+          // Track all connections to force-close them
+          const connections = new Set<any>();
+
+          const server = http.createServer((req, res) => {
+            const url = parseUrl(req.url || '', true);
+
+            if (url.pathname === '/oauth2callback') {
+              const code = url.query.code as string;
+              const error = url.query.error as string;
+
+              const closeServer = () => {
+                // Destroy all connections
+                connections.forEach((socket) => {
+                  socket.destroy();
+                });
+                connections.clear();
+                server.close();
+              };
+
+              if (error) {
+                res.writeHead(200, { 'Content-Type': 'text/html' });
+                res.end(`
+                  <html>
+                    <body style="font-family: system-ui; padding: 40px; text-align: center;">
+                      <h1>❌ Authorization Failed</h1>
+                      <p>Error: ${error}</p>
+                      <p>You can close this window.</p>
+                    </body>
+                  </html>
+                `);
+                res.on('finish', closeServer);
+                reject(new Error(`Authorization failed: ${error}`));
+                return;
+              }
+
+              if (code) {
+                res.writeHead(200, { 'Content-Type': 'text/html' });
+                res.end(`
+                  <html>
+                    <body style="font-family: system-ui; padding: 40px; text-align: center;">
+                      <h1>✅ Authorization Successful!</h1>
+                      <p>You can close this window and return to the terminal.</p>
+                    </body>
+                  </html>
+                `);
+                res.on('finish', closeServer);
+                resolve(code);
+              } else {
+                res.writeHead(400, { 'Content-Type': 'text/html' });
+                res.end(`
+                  <html>
+                    <body style="font-family: system-ui; padding: 40px; text-align: center;">
+                      <h1>❌ No Authorization Code</h1>
+                      <p>No code was received from Google.</p>
+                      <p>You can close this window.</p>
+                    </body>
+                  </html>
+                `);
+                res.on('finish', closeServer);
+                reject(new Error('No authorization code received'));
+              }
+            } else {
+              res.writeHead(404);
+              res.end('Not found');
+            }
+          });
+
+          // Track connections
+          server.on('connection', (socket) => {
+            connections.add(socket);
+            socket.on('close', () => {
+              connections.delete(socket);
+            });
+          });
+
+          server.listen(3000, () => {
+            console.log('✅ Server started successfully\n');
+          });
+
+          // Set timeout to avoid hanging forever
+          setTimeout(
+            () => {
+              connections.forEach((socket) => {
+                socket.destroy();
+              });
+              connections.clear();
+              server.close();
+              reject(new Error('Authentication timeout (5 minutes)'));
+            },
+            5 * 60 * 1000,
+          );
+        });
+
+        console.log('🌐 Opening browser for authorization...\n');
+
+        // Open browser automatically
+        try {
+          await open(authUrl);
+          console.log('✅ Browser opened successfully\n');
+        } catch (err) {
+          console.log('⚠️  Could not open browser automatically');
+          console.log('🌐 Please visit this URL to authorize:\n');
+          console.log(authUrl);
+          console.log();
+        }
+
+        console.log('⏳ Waiting for authorization...\n');
+
+        // Wait for the OAuth callback
+        const code = await authPromise;
+
+        console.log('🔑 Authorization code received\n');
+        console.log('💾 Saving authentication tokens...\n');
+
+        // Complete authentication
+        await uploader.authenticate(code, options.uploadName, projectPath);
+
+        console.log(`✅ Authentication complete for ${options.uploadName}!\n`);
+      } catch (error: any) {
+        console.error(`\n❌ Authentication failed\n`);
+        if (error.message) {
+          console.error(`Error: ${error.message}\n`);
+        }
+        process.exit(1);
+      }
+    });
+
+  program
+    .command('auth-complete')
+    .description(
+      '(Fallback) Complete authentication with authorization code manually',
+    )
+    .option('-p, --project <path>', 'Path to project directory', '.')
+    .requiredOption('--upload-name <name>', 'Name of the upload configuration')
+    .requiredOption('--code <code>', 'Authorization code from OAuth flow')
+    .action(async (options) => {
+      try {
+        const clientId = process.env.STATICSTRIPES_GOOGLE_CLIENT_ID;
+        const clientSecret = process.env.STATICSTRIPES_GOOGLE_CLIENT_SECRET;
+
+        if (!clientId || !clientSecret) {
+          console.error(
+            '❌ Error: STATICSTRIPES_GOOGLE_CLIENT_ID and STATICSTRIPES_GOOGLE_CLIENT_SECRET environment variables are not set',
+          );
+          console.error('\n💡 Run: staticstripes auth --help');
+          console.error('   for complete setup instructions\n');
+          process.exit(1);
+        }
+
+        const projectPath = resolve(process.cwd(), options.project);
+
+        // Create uploader and complete authentication
+        const uploader = new YouTubeUploader(clientId, clientSecret);
+        await uploader.authenticate(
+          options.code,
+          options.uploadName,
+          projectPath,
+        );
+
+        console.log(`✅ Authentication complete for ${options.uploadName}`);
+      } catch (error: any) {
+        console.error(`\n❌ Authentication completion failed\n`);
+        if (error.message) {
+          console.error(`Error: ${error.message}\n`);
+        }
+
+        // Provide helpful guidance for common OAuth errors
+        if (error.message === 'invalid_grant' || error.code === 400) {
+          console.error('💡 Common causes:\n');
+          console.error(
+            '   • Authorization code expired (codes expire in ~60 seconds)',
+          );
+          console.error('   • Code was already used');
+          console.error('   • Code was copied incorrectly\n');
+          console.error(
+            '🔄 Solution: Run the auth command again and complete it quickly:\n',
+          );
+          console.error(
+            `   1. staticstripes auth --upload-name ${options.uploadName}`,
+          );
+          console.error('   2. Authorize in browser immediately');
+          console.error('   3. Copy the code from the URL');
+          console.error(
+            '   4. Run auth-complete right away with the fresh code\n',
+          );
+        }
+        process.exit(1);
+      }
+    });
+}

package/src/cli/youtube/cli.ts

@@ -0,0 +1,11 @@
+import { Command } from 'commander';
+import { registerYouTubeAuthCommands } from './auth-commands.js';
+
+/**
+ * Registers YouTube-specific commands (authentication only)
+ * Upload functionality is handled by the generic upload command with strategy pattern
+ */
+export function registerYouTubeCommands(program: Command): void {
+  // Register YouTube auth commands
+  registerYouTubeAuthCommands(program);
+}