@gannochenko/staticstripes 0.0.12 → 0.0.15

package/src/html-project-parser.ts

@@ -9,6 +9,7 @@ import {
   Container,
   FFmpegOption,
   Upload,
+  AIProvider,
 } from './type';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
@@ -42,7 +43,60 @@ export class HTMLProjectParser {
     this.projectDir = dirname(projectPath);
   }
 
+  /**
+   * Extracts AI asset generation requirements without full parsing
+   * Used to generate AI assets before full project parsing
+   */
+  public extractAIGenerationRequirements(): {
+    providers: Map<string, AIProvider>;
+    assetsToGenerate: Array<{
+      name: string;
+      path: string;
+      integrationName: string;
+      prompt: string;
+      duration?: number;
+    }>;
+  } {
+    const providers = this.processAIProviders();
+    const assetsToGenerate: Array<{
+      name: string;
+      path: string;
+      integrationName: string;
+      prompt: string;
+      duration?: number;
+    }> = [];
+
+    const assetElements = this.findAssetElements();
+
+    for (const element of assetElements) {
+      const attrs = getAttrs(element);
+      const name = attrs.get('data-name') || attrs.get('id');
+      const relativePath = attrs.get('data-path') || attrs.get('src');
+
+      if (!name || !relativePath) {
+        continue;
+      }
+
+      const absolutePath = resolve(this.projectDir, relativePath);
+      const aiConfig = this.extractAssetAIConfig(element);
+
+      // Only include if it has AI config and file doesn't exist
+      if (aiConfig && !existsSync(absolutePath)) {
+        assetsToGenerate.push({
+          name,
+          path: absolutePath,
+          integrationName: aiConfig.integrationName,
+          prompt: aiConfig.prompt,
+          duration: aiConfig.duration,
+        });
+      }
+    }
+
+    return { providers, assetsToGenerate };
+  }
+
   public async parse(): Promise<Project> {
+    const aiProviders = this.processAIProviders();
     const assets = await this.processAssets();
 
     // Preflight check: verify all assets exist
@@ -50,8 +104,9 @@ export class HTMLProjectParser {
 
     const outputs = this.processOutputs();
     const ffmpegOptions = this.processFfmpegOptions();
-    const uploads = this.processUploads();
     const title = this.processTitle();
+    const globalTags = this.processGlobalTags();
+    const uploads = this.processUploads(title, globalTags);
     const sequences = this.processSequences(assets);
     const cssText = this.html.cssText;
 
@@ -61,6 +116,7 @@ export class HTMLProjectParser {
       outputs,
       ffmpegOptions,
       uploads,
+      aiProviders,
       title,
       cssText,
       this.projectPath,
@@ -70,11 +126,17 @@ export class HTMLProjectParser {
   /**
    * Validates that all asset files exist on the filesystem
    * Throws an error with a list of missing files if any are not found
+   * Note: Assets with AI configuration are skipped if they don't exist (will be generated)
    */
   private validateAssetFiles(assets: Asset[]): void {
     const missingFiles: string[] = [];
 
     for (const asset of assets) {
+      // Skip validation for assets with AI config (they will be generated if missing)
+      if (asset.ai) {
+        continue;
+      }
+
       if (!existsSync(asset.path)) {
         missingFiles.push(asset.path);
       }
@@ -191,6 +253,9 @@ export class HTMLProjectParser {
     // Extract author (optional)
     const author = attrs.get('data-author');
 
+    // Extract AI configuration from child <ai> element (optional)
+    const aiConfig = this.extractAssetAIConfig(element);
+
     return {
       name,
       path: absolutePath,
@@ -202,9 +267,80 @@ export class HTMLProjectParser {
       hasVideo,
       hasAudio,
       ...(author && { author }),
+      ...(aiConfig && { ai: aiConfig }),
     };
   }
 
+  /**
+   * Extracts AI configuration from an asset's child <ai> element
+   */
+  private extractAssetAIConfig(
+    element: Element,
+  ): { integrationName: string; prompt: string; duration?: number } | null {
+    // Find first <ai> child
+    if (!('children' in element) || !element.children) {
+      return null;
+    }
+
+    for (const child of element.children) {
+      if (child.type === 'tag' && child.name === 'ai') {
+        const aiElement = child as Element;
+        const attrs = getAttrs(aiElement);
+
+        const integrationName = attrs.get('data-integration-name');
+        if (!integrationName) {
+          console.warn('Asset <ai> element missing data-integration-name attribute');
+          return null;
+        }
+
+        // Extract prompt and duration from child elements
+        let prompt = '';
+        let duration: number | undefined;
+
+        if ('children' in aiElement && aiElement.children) {
+          for (const aiChild of aiElement.children) {
+            if (aiChild.type === 'tag') {
+              const aiChildElement = aiChild as Element;
+
+              if (aiChildElement.name === 'prompt') {
+                if ('children' in aiChildElement && aiChildElement.children) {
+                  for (const textNode of aiChildElement.children) {
+                    if (textNode.type === 'text' && 'data' in textNode) {
+                      prompt += textNode.data;
+                    }
+                  }
+                }
+              } else if (aiChildElement.name === 'duration') {
+                const durationAttrs = getAttrs(aiChildElement);
+                const durationValue = durationAttrs.get('value');
+                if (durationValue) {
+                  const parsed = parseInt(durationValue, 10);
+                  if (!isNaN(parsed)) {
+                    duration = parsed;
+                  }
+                }
+              }
+            }
+          }
+        }
+
+        prompt = prompt.trim();
+        if (!prompt) {
+          console.warn('Asset <ai> element missing <prompt>');
+          return null;
+        }
+
+        return {
+          integrationName,
+          prompt,
+          ...(duration !== undefined && { duration }),
+        };
+      }
+    }
+
+    return null;
+  }
+
   /**
    * Infers asset type from tag name or file path
    */
@@ -563,7 +699,10 @@ export class HTMLProjectParser {
   /**
    * Processes all uploads (YouTube, S3, etc.) from the parsed HTML
    */
-  private processUploads(): Map<string, Upload> {
+  private processUploads(
+    projectTitle: string,
+    globalTags: string[],
+  ): Map<string, Upload> {
     const uploadsElements = this.findUploadsElements();
     const uploads = new Map<string, Upload>();
 
@@ -575,9 +714,19 @@ export class HTMLProjectParser {
             let upload: Upload | null = null;
 
             if (childElement.name === 'youtube') {
-              upload = this.parseYouTubeElement(childElement);
+              upload = this.parseYouTubeElement(
+                childElement,
+                projectTitle,
+                globalTags,
+              );
             } else if (childElement.name === 's3') {
               upload = this.parseS3Element(childElement);
+            } else if (childElement.name === 'instagram') {
+              upload = this.parseInstagramElement(
+                childElement,
+                projectTitle,
+                globalTags,
+              );
             }
 
             if (upload) {
@@ -594,7 +743,11 @@ export class HTMLProjectParser {
   /**
    * Parses a single <youtube> element
    */
-  private parseYouTubeElement(element: Element): Upload | null {
+  private parseYouTubeElement(
+    element: Element,
+    projectTitle: string,
+    globalTags: string[],
+  ): Upload | null {
     const attrs = getAttrs(element);
 
     const name = attrs.get('name');
@@ -611,7 +764,7 @@ export class HTMLProjectParser {
     let uploadTitle: string | undefined;
     let privacy: 'public' | 'unlisted' | 'private' = 'private';
     let madeForKids = false;
-    const tags: string[] = [];
+    const localTags: string[] = [];
     let category = 'entertainment';
     let language = 'en';
     let description = '';
@@ -651,7 +804,7 @@ export class HTMLProjectParser {
               const tagAttrs = getAttrs(childElement);
               const tagName = tagAttrs.get('name');
               if (tagName) {
-                tags.push(tagName);
+                localTags.push(tagName);
               }
               break;
             }
@@ -701,15 +854,21 @@ export class HTMLProjectParser {
       }
     }
 
+    // Merge global tags + local tags (global first)
+    const allTags = [...globalTags, ...localTags];
+
+    // Use project title if upload doesn't have its own
+    const finalTitle = uploadTitle || projectTitle;
+
     return {
       name,
       tag: element.name, // e.g., "youtube", "s3", etc.
       outputName,
-      title: uploadTitle,
+      title: finalTitle,
       videoId,
       privacy,
       madeForKids,
-      tags,
+      tags: allTags,
       category,
       language,
       description: description.trim(),
@@ -796,6 +955,268 @@ export class HTMLProjectParser {
     };
   }
 
+  /**
+   * Parses a single <instagram> element
+   */
+  private parseInstagramElement(
+    element: Element,
+    projectTitle: string,
+    globalTags: string[],
+  ): Upload | null {
+    const attrs = getAttrs(element);
+
+    const name = attrs.get('name');
+    const outputName = attrs.get('data-output-name');
+
+    if (!name || !outputName) {
+      console.warn('Instagram upload missing name or data-output-name attribute');
+      return null;
+    }
+
+    // Parse Instagram-specific child elements
+    let caption = '';
+    let shareToFeed = false;
+    let thumbOffset: number | undefined;
+    let coverUrl: string | undefined;
+    let videoUrl: string | undefined;
+    const localTags: string[] = [];
+
+    if ('children' in element && element.children) {
+      for (const child of element.children) {
+        if (child.type === 'tag') {
+          const childElement = child as Element;
+          const childAttrs = getAttrs(childElement);
+
+          switch (childElement.name) {
+            case 'pre': {
+              // Get text content (unified with YouTube description)
+              if ('children' in childElement && childElement.children) {
+                for (const textNode of childElement.children) {
+                  if (textNode.type === 'text' && 'data' in textNode) {
+                    caption += textNode.data;
+                  }
+                }
+              }
+              break;
+            }
+            case 'caption': {
+              // Legacy syntax (deprecated, but still supported)
+              if ('children' in childElement && childElement.children) {
+                for (const textNode of childElement.children) {
+                  if (textNode.type === 'text' && 'data' in textNode) {
+                    caption += textNode.data;
+                  }
+                }
+              }
+              caption = caption.trim();
+              break;
+            }
+            case 'share-to-feed': {
+              shareToFeed = true;
+              break;
+            }
+            case 'thumbnail': {
+              // Unified syntax like YouTube: <thumbnail data-timecode="1000ms" />
+              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];
+                  thumbOffset = unit === 's' ? value * 1000 : value;
+                }
+              }
+              break;
+            }
+            case 'thumb-offset': {
+              // Legacy syntax (deprecated, but still supported)
+              const offset = childAttrs.get('value');
+              if (offset) {
+                thumbOffset = parseInt(offset, 10);
+              }
+              break;
+            }
+            case 'cover-url': {
+              coverUrl = childAttrs.get('value');
+              break;
+            }
+            case 'video-url': {
+              videoUrl = childAttrs.get('value');
+              break;
+            }
+            case 'tag': {
+              const tagName = childAttrs.get('name');
+              if (tagName) {
+                localTags.push(tagName);
+              }
+              break;
+            }
+          }
+        }
+      }
+    }
+
+    // Merge global tags + local tags
+    const allTags = [...globalTags, ...localTags];
+
+    return {
+      name,
+      tag: element.name, // "instagram"
+      outputName,
+      title: projectTitle,
+      privacy: 'private', // Default values (not used but required by Upload type)
+      madeForKids: false,
+      tags: allTags,
+      category: '',
+      language: '',
+      description: '',
+      instagram: {
+        caption, // Raw caption with ${variables}, will be rendered by upload strategy
+        shareToFeed,
+        thumbOffset,
+        coverUrl,
+        videoUrl,
+      },
+    };
+  }
+
+  /**
+   * Processes all AI providers from the parsed HTML
+   */
+  private processAIProviders(): Map<string, AIProvider> {
+    const aiElements = this.findAIElements();
+    const providers = new Map<string, AIProvider>();
+
+    for (const aiElement of aiElements) {
+      if ('children' in aiElement && aiElement.children) {
+        for (const child of aiElement.children) {
+          if (child.type === 'tag') {
+            const childElement = child as Element;
+            const provider = this.parseAIProviderElement(childElement);
+
+            if (provider) {
+              providers.set(provider.name, provider);
+            }
+          }
+        }
+      }
+    }
+
+    return providers;
+  }
+
+  /**
+   * Parses a single AI provider element (e.g., <music-api-ai>)
+   */
+  private parseAIProviderElement(element: Element): AIProvider | null {
+    const attrs = getAttrs(element);
+
+    const name = attrs.get('name');
+    if (!name) {
+      console.warn('AI provider missing name attribute');
+      return null;
+    }
+
+    const tag = element.name; // e.g., "music-api-ai"
+
+    // Extract optional model from child elements
+    let model: string | undefined;
+
+    if ('children' in element && element.children) {
+      for (const child of element.children) {
+        if (child.type === 'tag' && child.name === 'model') {
+          const childElement = child as Element;
+          const childAttrs = getAttrs(childElement);
+          model = childAttrs.get('name');
+          break; // Only use first model element
+        }
+      }
+    }
+
+    return {
+      name,
+      tag,
+      ...(model && { model }),
+    };
+  }
+
+  /**
+   * Finds all <ai> configuration elements in the HTML (excludes <ai> elements inside <asset>)
+   */
+  private findAIElements(): Element[] {
+    const results: Element[] = [];
+
+    const traverse = (node: ASTNode, insideAsset: boolean = false) => {
+      if (node.type === 'tag') {
+        const element = node as Element;
+
+        // Track if we're entering an <asset> element
+        const isAsset = element.name === 'asset';
+        const nowInsideAsset = insideAsset || isAsset;
+
+        // Only collect <ai> elements that are NOT inside <asset> elements
+        if (element.name === 'ai' && !insideAsset) {
+          results.push(element);
+        }
+
+        // Continue traversing children with updated insideAsset flag
+        if ('children' in element && element.children) {
+          for (const child of element.children) {
+            traverse(child, nowInsideAsset);
+          }
+        }
+      } else if ('children' in node && node.children) {
+        for (const child of node.children) {
+          traverse(child, insideAsset);
+        }
+      }
+    };
+
+    traverse(this.html.ast);
+    return results;
+  }
+
+  /**
+   * Processes global tags from the top of the HTML file (before <project>)
+   */
+  private processGlobalTags(): string[] {
+    const tags: string[] = [];
+
+    const traverse = (node: ASTNode, insideProject: boolean = false) => {
+      if (node.type === 'tag') {
+        const element = node as Element;
+
+        // Stop when we hit <project>, <uploads>, or <outputs>
+        if (
+          element.name === 'project' ||
+          element.name === 'uploads' ||
+          element.name === 'outputs'
+        ) {
+          insideProject = true;
+        }
+
+        // Only parse <tag> elements outside of project/uploads/outputs
+        if (!insideProject && element.name === 'tag') {
+          const attrs = getAttrs(element);
+          const tagName = attrs.get('name');
+          if (tagName) {
+            tags.push(tagName);
+          }
+        }
+      }
+
+      if ('children' in node && node.children) {
+        for (const child of node.children) {
+          traverse(child, insideProject);
+        }
+      }
+    };
+
+    traverse(this.html.ast);
+    return tags;
+  }
+
   /**
    * Processes the title from the parsed HTML
    */

package/src/lib/file.ts

@@ -0,0 +1,11 @@
+import { existsSync, writeFileSync, mkdirSync } from 'fs';
+import { dirname } from 'path';
+
+export function writeFile(filePath: string, buffer: Buffer) {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+
+  writeFileSync(filePath, buffer);
+}

package/src/lib/net.ts

@@ -0,0 +1,120 @@
+import https from 'https';
+import http from 'http';
+
+export interface HttpRequestOptions {
+  url: string;
+  method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+  headers?: Record<string, string>;
+  body?: unknown | URLSearchParams;
+}
+
+/**
+ * Makes an HTTP/HTTPS request
+ * @param options Request options
+ * @returns Parsed JSON response
+ */
+export async function makeRequest<T>(options: HttpRequestOptions): Promise<T> {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(options.url);
+    const protocol = urlObj.protocol === 'https:' ? https : http;
+
+    // Determine content type and serialize body
+    let bodyString: string | undefined;
+    let defaultContentType: string;
+
+    if (options.body) {
+      if (options.body instanceof URLSearchParams) {
+        bodyString = options.body.toString();
+        defaultContentType = 'application/x-www-form-urlencoded';
+      } else {
+        bodyString = JSON.stringify(options.body);
+        defaultContentType = 'application/json';
+      }
+    } else {
+      defaultContentType = 'application/json';
+    }
+
+    const requestOptions = {
+      hostname: urlObj.hostname,
+      port: urlObj.port || (protocol === https ? 443 : 80),
+      path: urlObj.pathname + urlObj.search,
+      method: options.method,
+      headers: {
+        'Content-Type': defaultContentType,
+        ...options.headers,
+      },
+    };
+
+    const req = protocol.request(requestOptions, (res) => {
+      const chunks: Buffer[] = [];
+
+      res.on('data', (chunk) => chunks.push(chunk));
+      res.on('end', () => {
+        try {
+          const responseText = Buffer.concat(chunks).toString('utf-8');
+          const data = JSON.parse(responseText) as T;
+
+          if (res.statusCode && res.statusCode >= 400) {
+            reject(
+              new Error(
+                `HTTP request failed with status ${res.statusCode}: ${responseText}`,
+              ),
+            );
+            return;
+          }
+
+          resolve(data);
+        } catch (error) {
+          reject(
+            new Error(
+              `Failed to parse response: ${error instanceof Error ? error.message : String(error)}`,
+            ),
+          );
+        }
+      });
+    });
+
+    req.on('error', (error) => {
+      reject(new Error(`Request failed: ${error.message}`));
+    });
+
+    if (bodyString) {
+      req.write(bodyString);
+    }
+
+    req.end();
+  });
+}
+
+/**
+ * Downloads a file from URL to buffer
+ * @param url URL to download from
+ * @returns Buffer containing the file data
+ */
+export async function downloadFile(url: string): Promise<Buffer> {
+  return new Promise((resolve, reject) => {
+    const protocol = url.startsWith('https') ? https : http;
+
+    protocol
+      .get(url, (response) => {
+        if (response.statusCode !== 200) {
+          reject(
+            new Error(`Download failed: HTTP ${response.statusCode}`),
+          );
+          return;
+        }
+
+        const chunks: Buffer[] = [];
+        response.on('data', (chunk) => chunks.push(chunk));
+        response.on('end', () => {
+          try {
+            const buffer = Buffer.concat(chunks);
+            resolve(buffer);
+          } catch (error) {
+            reject(error);
+          }
+        });
+      })
+      .on('error', reject);
+  });
+}

package/src/project.ts

@@ -4,6 +4,7 @@ import {
   SequenceDefinition,
   FFmpegOption,
   Upload,
+  AIProvider,
 } from './type';
 import { Label } from './ffmpeg';
 import { AssetManager } from './asset-manager';
@@ -23,6 +24,7 @@ export class Project {
     private outputs: Map<string, Output>,
     private ffmpegOptions: Map<string, FFmpegOption>,
     private uploads: Map<string, Upload>,
+    private aiProviders: Map<string, AIProvider>,
     private title: string,
     private cssText: string,
     private projectPath: string,
@@ -127,6 +129,14 @@ export class Project {
     return this.getUpload(name);
   }
 
+  public getAIProviders(): Map<string, AIProvider> {
+    return this.aiProviders;
+  }
+
+  public getAIProvider(name: string): AIProvider | undefined {
+    return this.aiProviders.get(name);
+  }
+
   public getTitle(): string {
     return this.title;
   }