screencraft 0.1.0

package/src/pipeline/aeSwap.js

@@ -0,0 +1,369 @@
+/**
+ * src/pipeline/aeSwap.js
+ * ----------------------
+ * Prepares an After Effects project for rendering by:
+ *
+ *   1. Copying the AE template + footage folder to the output directory
+ *   2. Replacing screenshot footage files with the user's actual screenshots
+ *   3. Writing a render_manifest.json with brand/text/screenshot data
+ *   4. Copying ae_swap.jsx into the project folder
+ *   5. Optionally running aerender to produce the final video
+ *
+ * The ae_swap.jsx ExtendScript reads the manifest and swaps all
+ * [SWAP_*] layers (colors, text, screenshots, images) when AE opens.
+ */
+
+const path  = require('path');
+const fs    = require('fs');
+const { execSync, exec } = require('child_process');
+
+const TEMPLATES_DIR = path.join(__dirname, '../../templates');
+
+/**
+ * prepareAEProject(opts)
+ *
+ * @param {Object} opts
+ * @param {string} opts.templatePath  — path to the AE template .aep (or auto-detect)
+ * @param {Object} opts.brand         — brand object from detectBrand
+ * @param {Array}  opts.texts         — array of { white, accent } per screen
+ * @param {Array}  opts.screenshots   — array of { file } paths to raw screenshots
+ * @param {string} opts.outputDir     — launch-kit output directory
+ * @param {Object} opts.log           — { info, success, warn } log helpers
+ *
+ * @returns {Object} { aepPath, manifestPath, canRender }
+ */
+async function prepareAEProject(opts) {
+  const {
+    templatePath = null,
+    brand         = {},
+    texts         = [],
+    screenshots   = [],
+    outputDir,
+    log,
+  } = opts;
+
+  const sourceDir = path.join(outputDir, 'source');
+  fs.mkdirSync(sourceDir, { recursive: true });
+
+  // ── 1. Find the AE template ────────────────────────────────────
+  const aepTemplate = templatePath || findAETemplate();
+
+  if (!aepTemplate) {
+    if (log) log.warn('No AE template found in templates/. Skipping video generation.');
+    return { aepPath: null, manifestPath: null, canRender: false };
+  }
+
+  // ── 2. Copy AE project to output ──────────────────────────────
+  const aepName = 'app-launch.aep';
+  const aepDest = path.join(sourceDir, aepName);
+
+  // Copy the AEP file
+  fs.copyFileSync(aepTemplate, aepDest);
+
+  // Copy the footage folder structure
+  const templateDir = path.dirname(aepTemplate);
+  const footageDir = findFootageDir(templateDir);
+
+  if (footageDir) {
+    const destFootageDir = path.join(sourceDir, path.basename(footageDir));
+    copyDirSync(footageDir, destFootageDir);
+  }
+
+  // ── 3. Replace screenshot footage files ───────────────────────
+  // The AE template references screen_01_raw.png, screen_02_raw.png, etc.
+  // We replace those files with the user's actual screenshots.
+  const assetsDir = findAssetsDir(sourceDir);
+
+  if (assetsDir) {
+    for (let i = 0; i < screenshots.length; i++) {
+      const srcFile = screenshots[i].file || screenshots[i].png;
+      if (!srcFile || !fs.existsSync(srcFile)) continue;
+
+      const destFile = path.join(assetsDir, `screen_${String(i + 1).padStart(2, '0')}_raw.png`);
+      fs.copyFileSync(srcFile, destFile);
+    }
+  }
+
+  // ── 4. Write render manifest ──────────────────────────────────
+  const manifest = {
+    brand: {
+      appName:    brand.appName    || null,
+      primary:    brand.primary    || '#1B2A4A',
+      secondary:  brand.secondary  || '#435B98',
+      accent:     brand.accent     || '#9B7FD4',
+      background: brand.background || '#1B2A4A',
+      icon:       brand.icon       || null,
+      logo:       brand.logo       || null,
+      font:       brand.font       || null,
+      tagline:    brand.tagline    || null,
+    },
+    texts: texts.map(t => ({
+      white:  t.white  || '',
+      accent: t.accent || '',
+    })),
+    screenshots: screenshots.map((s, i) => ({
+      file: `screen_${String(i + 1).padStart(2, '0')}_raw.png`,
+    })),
+    template:  'app_launch_vertical_v1',
+    timestamp: new Date().toISOString(),
+  };
+
+  const manifestPath = path.join(sourceDir, 'render_manifest.json');
+  fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+
+  // ── 5. Copy ae_swap.jsx into the project folder ───────────────
+  const swapScript = path.join(TEMPLATES_DIR, 'ae_swap.jsx');
+  if (fs.existsSync(swapScript)) {
+    fs.copyFileSync(swapScript, path.join(sourceDir, 'ae_swap.jsx'));
+  }
+
+  // ── 6. Check if aerender is available ─────────────────────────
+  const canRender = isAERenderAvailable();
+
+  if (log) {
+    log.success(`AE project prepared: ${aepName}`);
+    log.info(`Manifest: render_manifest.json (${texts.length} screens)`);
+    if (canRender) {
+      log.info('aerender found — can render locally');
+    } else {
+      log.info('aerender not found — use AE manually or submit to render server');
+    }
+  }
+
+  return { aepPath: aepDest, manifestPath, canRender };
+}
+
+/**
+ * renderLocally(opts)
+ *
+ * Runs aerender to produce the video. Only works if AE is installed.
+ *
+ * @param {string} opts.aepPath    — path to the prepared .aep file
+ * @param {string} opts.outputDir  — where to save the rendered video
+ * @param {string} opts.comp       — comp name to render (default: auto-detect MASTER_*)
+ * @param {Function} opts.onProgress — callback for progress updates
+ *
+ * @returns {string} path to rendered video file
+ */
+async function renderLocally(opts) {
+  const {
+    aepPath,
+    outputDir,
+    comp = null,
+    onProgress,
+  } = opts;
+
+  const outputFile = path.join(outputDir, 'video', 'preview.mp4');
+  fs.mkdirSync(path.join(outputDir, 'video'), { recursive: true });
+
+  // First run the swap script
+  const swapScript = path.join(path.dirname(aepPath), 'ae_swap.jsx');
+  const aerenderPath = findAERender();
+
+  if (!aerenderPath) {
+    throw new Error('aerender not found. Install After Effects or use the render server.');
+  }
+
+  // Step 1: Run the swap script via AppleScript (opens AE, runs JSX, saves, quits)
+  // Note: aerender's -s flag causes timeSpanStart errors on many projects,
+  // so we use AppleScript to run the swap script in the AE GUI instead.
+  if (fs.existsSync(swapScript)) {
+    if (onProgress) onProgress('Running swap script in After Effects...');
+    try {
+      execSync(
+        `osascript` +
+        ` -e 'with timeout of 120 seconds'` +
+        ` -e 'tell application "Adobe After Effects 2026"'` +
+        ` -e 'activate'` +
+        ` -e 'open file (POSIX file "${aepPath}" as string)'` +
+        ` -e 'delay 10'` +
+        ` -e 'DoScriptFile "${swapScript}"'` +
+        ` -e 'delay 3'` +
+        ` -e 'DoScript "app.project.save();"'` +
+        ` -e 'delay 2'` +
+        ` -e 'DoScript "app.quit();"'` +
+        ` -e 'end tell'` +
+        ` -e 'end timeout'`,
+        { timeout: 180000, stdio: 'pipe' }
+      );
+      // Wait for AE to fully quit before aerender starts
+      await new Promise(r => setTimeout(r, 5000));
+    } catch (err) {
+      // Swap script errors are non-fatal — render with whatever state we have
+    }
+  }
+
+  // Step 2: Build aerender command for the actual render
+  const args = [
+    '-project', `"${aepPath}"`,
+    '-output', `"${outputFile}"`,
+    '-RStemplate', '"Best Settings"',
+    '-v', 'ERRORS_AND_PROGRESS',
+    '-continueOnMissingFootage',
+  ];
+
+  if (comp) {
+    args.push('-comp', `"${comp}"`);
+  }
+
+  const cmd = `"${aerenderPath}" ${args.join(' ')}`;
+
+  return new Promise((resolve, reject) => {
+    if (onProgress) onProgress('Starting After Effects render...');
+
+    const proc = exec(cmd, { timeout: 300000 }); // 5 min timeout
+
+    proc.stdout.on('data', (data) => {
+      const line = data.toString().trim();
+      if (onProgress && line.length > 0) {
+        // Parse AE progress output
+        const frameMatch = line.match(/PROGRESS:\s+(.+)/);
+        if (frameMatch) {
+          onProgress(frameMatch[1]);
+        }
+      }
+    });
+
+    proc.stderr.on('data', (data) => {
+      // AE logs to stderr sometimes
+    });
+
+    proc.on('close', (code) => {
+      if (code === 0 && fs.existsSync(outputFile)) {
+        resolve(outputFile);
+      } else {
+        reject(new Error(`aerender exited with code ${code}`));
+      }
+    });
+
+    proc.on('error', (err) => {
+      reject(err);
+    });
+  });
+}
+
+module.exports = { prepareAEProject, renderLocally };
+
+
+// ── Helpers ──────────────────────────────────────────────────────
+
+/**
+ * Find the AE template in the templates directory.
+ * Looks for .aep files in templates/ or templates/ae/
+ */
+function findAETemplate() {
+  const searchDirs = [
+    TEMPLATES_DIR,
+    path.join(TEMPLATES_DIR, 'ae'),
+  ];
+
+  for (const dir of searchDirs) {
+    if (!fs.existsSync(dir)) continue;
+    try {
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name.endsWith('.aep')) {
+          return path.join(dir, entry.name);
+        }
+        // Check inside subdirectories
+        if (entry.isDirectory()) {
+          const subDir = path.join(dir, entry.name);
+          for (const sub of fs.readdirSync(subDir)) {
+            if (sub.endsWith('.aep')) {
+              return path.join(subDir, sub);
+            }
+          }
+        }
+      }
+    } catch {}
+  }
+
+  return null;
+}
+
+/**
+ * Find the (Footage) directory inside a template folder.
+ */
+function findFootageDir(dir) {
+  try {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory() && entry.name.includes('Footage')) {
+        return path.join(dir, entry.name);
+      }
+    }
+  } catch {}
+  return null;
+}
+
+/**
+ * Find the assets directory inside the output source folder.
+ * Walks into (Footage)/Assets/ or similar.
+ */
+function findAssetsDir(sourceDir) {
+  const candidates = [
+    path.join(sourceDir, '(Footage)', 'Assets'),
+    path.join(sourceDir, 'Footage', 'Assets'),
+    path.join(sourceDir, '(Footage)'),
+    path.join(sourceDir, 'Assets'),
+  ];
+
+  for (const dir of candidates) {
+    if (fs.existsSync(dir)) return dir;
+  }
+
+  // Create a default
+  const defaultDir = path.join(sourceDir, '(Footage)', 'Assets');
+  fs.mkdirSync(defaultDir, { recursive: true });
+  return defaultDir;
+}
+
+/**
+ * Check if aerender is available on this system.
+ */
+function isAERenderAvailable() {
+  return !!findAERender();
+}
+
+/**
+ * Find the aerender executable.
+ */
+function findAERender() {
+  // macOS paths
+  const macPaths = [
+    '/Applications/Adobe After Effects 2025/aerender',
+    '/Applications/Adobe After Effects 2024/aerender',
+    '/Applications/Adobe After Effects 2026/aerender',
+    '/Applications/Adobe After Effects CC 2024/aerender',
+  ];
+
+  for (const p of macPaths) {
+    if (fs.existsSync(p)) return p;
+  }
+
+  // Try which/where
+  try {
+    const result = execSync('which aerender 2>/dev/null', { encoding: 'utf8' }).trim();
+    if (result) return result;
+  } catch {}
+
+  return null;
+}
+
+/**
+ * Recursively copy a directory.
+ */
+function copyDirSync(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath  = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.name.startsWith('.')) continue; // skip .DS_Store etc.
+
+    if (entry.isDirectory()) {
+      copyDirSync(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}

package/src/pipeline/download.js

@@ -0,0 +1,32 @@
+/**
+ * src/pipeline/download.js
+ * Fetches the completed render bundle (ZIP) and unpacks it.
+ */
+
+const fs      = require('fs');
+const path    = require('path');
+const https   = require('https');
+
+const API_BASE = process.env.SCREENCRAFT_API || 'https://api.screencraft.dev';
+
+async function downloadBundle(jobId, outputDir) {
+  if (jobId.startsWith('dev-')) return; // Dev mode
+
+  const zipPath = path.join(outputDir, '_bundle.zip');
+
+  // Download ZIP
+  await new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(zipPath);
+    https.get(`${API_BASE}/v1/render/${jobId}/download`, res => {
+      res.pipe(file);
+      file.on('finish', () => { file.close(); resolve(); });
+    }).on('error', reject);
+  });
+
+  // Unpack — requires unzipper or archiver
+  // For now: leave the zip and note it's there
+  // In production: unzip to outputDir and delete the zip
+  return zipPath;
+}
+
+module.exports = { downloadBundle };

package/src/pipeline/queue.js

@@ -0,0 +1,101 @@
+/**
+ * src/pipeline/queue.js
+ * ---------------------
+ * Submits a render job to the ScreenCraft render server.
+ * The render server runs After Effects via aerender on a Mac.
+ *
+ * In Phase 1 (manual rendering), this just packages the job
+ * and logs instructions for you to render manually.
+ *
+ * In Phase 2 (automated), it POSTs to your render API and polls.
+ */
+
+const fs    = require('fs');
+const path  = require('path');
+const chalk = require('chalk');
+
+const API_BASE = process.env.SCREENCRAFT_API || 'https://api.screencraft.dev';
+
+/**
+ * Submit a render job.
+ * Returns a jobId string.
+ */
+async function submitRenderJob({ brand, screenshots, texts, config }) {
+  const isDev = process.env.NODE_ENV === 'development' || process.env.SCREENCRAFT_DEV;
+
+  if (isDev) {
+    // In dev mode: write a render manifest locally instead of POSTing
+    const manifest = {
+      brand,
+      texts,
+      template:   'app_launch_vertical_v1',
+      duration:   config.video?.duration || 30,
+      music:      config.video?.music    || 'upbeat',
+      createdAt:  new Date().toISOString(),
+      screenshots: screenshots.map(s => ({ png: s.png })),
+    };
+
+    const manifestPath = path.join(process.cwd(), 'launch-kit', 'render_manifest.json');
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+
+    console.log('');
+    console.log(chalk.hex('#C9A84C')('  DEV MODE: Render manifest written to launch-kit/render_manifest.json'));
+    console.log(chalk.dim('  To render manually:'));
+    console.log(chalk.dim('    1. Open source/app-launch.aep in After Effects'));
+    console.log(chalk.dim('    2. Run the swap script: File → Scripts → Run Script → ae_swap.jsx'));
+    console.log(chalk.dim('    3. Add to render queue → render'));
+    console.log('');
+
+    return 'dev-' + Date.now();
+  }
+
+  // Production: POST to render API
+  const res = await fetch(`${API_BASE}/v1/render`, {
+    method:  'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      brand,
+      texts,
+      template:   'app_launch_vertical_v1',
+      duration:   config.video?.duration || 30,
+      music:      config.video?.music    || 'upbeat',
+      screenshots: screenshots.map(s => ({ png: s.png })),
+    }),
+  });
+
+  if (!res.ok) throw new Error(`Render API error: ${res.status}`);
+  const data = await res.json();
+  return data.jobId;
+}
+
+/**
+ * Poll for job completion.
+ * Calls onProgress(stepLabel) as the job advances.
+ */
+async function pollJob(jobId, { onProgress } = {}) {
+  if (jobId.startsWith('dev-')) return; // Dev mode — skip polling
+
+  const maxWait = 180_000; // 3 minutes
+  const interval = 3_000;
+  const start    = Date.now();
+
+  while (Date.now() - start < maxWait) {
+    await sleep(interval);
+
+    const res  = await fetch(`${API_BASE}/v1/render/${jobId}/status`);
+    const data = await res.json();
+
+    if (onProgress) onProgress(data.step || 'Rendering...');
+
+    if (data.status === 'complete') return data;
+    if (data.status === 'error')    throw new Error(data.message || 'Render failed');
+  }
+
+  throw new Error('Render timed out after 3 minutes');
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+module.exports = { submitRenderJob, pollJob };