storyforge 0.1.2 → 0.2.2

package/dist/index.js

@@ -2,9 +2,11 @@
 
 // src/commands/dev.ts
 import * as fs2 from "fs";
+import * as os2 from "os";
 import * as path2 from "path";
 import * as http from "http";
-import { execFile } from "child_process";
+import { execFile, exec as execCb, execSync } from "child_process";
+import { promisify } from "util";
 
 // src/utils/log.ts
 var supportsColor = process.stdout.isTTY && process.env.TERM !== "dumb" && !process.env.NO_COLOR;
@@ -41,6 +43,7 @@ function loadCredentials() {
 }
 
 // src/commands/dev.ts
+var exec = promisify(execCb);
 var PORT = 4444;
 var WEB_URL = "https://forge.algo-thinker.com";
 function getApiConfig() {
@@ -183,6 +186,54 @@ async function findOrCreateProject(dir) {
   log.success(`Saved ${metaPath(dir)}`);
   return meta;
 }
+function findMonorepoRoot(startDir) {
+  let d = startDir;
+  for (let i = 0; i < 6; i++) {
+    const parent = path2.dirname(d);
+    if (parent === d) break;
+    if (fs2.existsSync(path2.join(parent, "turbo.json")) || fs2.existsSync(path2.join(parent, "apps")) && fs2.existsSync(path2.join(parent, "packages"))) return parent;
+    d = parent;
+  }
+  return startDir;
+}
+function findProjectCompositions(dir) {
+  const SKIP = /* @__PURE__ */ new Set(["Root.tsx", "index.tsx", "DocumentaryVideo.tsx", "DocumentaryVideoV2.tsx"]);
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  function scanDir(absoluteDir, base) {
+    if (!fs2.existsSync(absoluteDir)) return;
+    function scan(d, rel) {
+      if (!fs2.existsSync(d)) return;
+      for (const entry of fs2.readdirSync(d, { withFileTypes: true })) {
+        if (entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
+        const full = path2.join(d, entry.name);
+        const entryRel = rel ? `${rel}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+          scan(full, entryRel);
+          continue;
+        }
+        if (entry.name.endsWith(".tsx") && !SKIP.has(entry.name) && !seen.has(entry.name)) {
+          seen.add(entry.name);
+          result.push({ name: entry.name.replace(/\.tsx$/, ""), source: "project", relPath: entryRel, basePath: base, absolutePath: full });
+        }
+      }
+    }
+    scan(absoluteDir, "");
+  }
+  scanDir(path2.join(dir, "src", "remotion"), dir);
+  const root = findMonorepoRoot(dir);
+  if (root !== dir) {
+    scanDir(path2.join(root, "src", "remotion"), root);
+    const packagesDir = path2.join(root, "packages");
+    if (fs2.existsSync(packagesDir)) {
+      for (const pkg of fs2.readdirSync(packagesDir, { withFileTypes: true })) {
+        if (!pkg.isDirectory() || pkg.name.startsWith(".")) continue;
+        scanDir(path2.join(packagesDir, pkg.name, "src"), path2.join(packagesDir, pkg.name));
+      }
+    }
+  }
+  return result;
+}
 function getMime(file) {
   const ext = path2.extname(file).toLowerCase();
   const types = {
@@ -218,6 +269,9 @@ function collectFiles(dir, base = "") {
   }
   return result;
 }
+function stripFences(text) {
+  return text.replace(/^```(?:tsx?|jsx?|typescript|javascript)?\n?/m, "").replace(/\n?```\s*$/m, "").trim();
+}
 function openBrowser(url) {
   const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
   execFile(cmd, [url], (err) => {
@@ -272,9 +326,15 @@ async function devCommand(options) {
       return;
     }
     if (pathname === "/api/assets") {
+      const imgExts = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp", ".gif"]);
+      const legacyH = collectFiles(path2.join(dir, "images-horizontal"), "images-horizontal");
+      const geminiScenes = collectFiles(
+        path2.join(dir, "public", "tesla-fsd", "gemini-scenes"),
+        "public/tesla-fsd/gemini-scenes"
+      ).filter((f) => imgExts.has(path2.extname(f.name).toLowerCase()));
       const assets = {
         audio: collectFiles(path2.join(dir, "audio"), "audio"),
-        imagesH: collectFiles(path2.join(dir, "images-horizontal"), "images-horizontal"),
+        imagesH: [...legacyH, ...geminiScenes],
         imagesV: collectFiles(path2.join(dir, "images-vertical"), "images-vertical"),
         clips: collectFiles(path2.join(dir, "clips"), "clips"),
         scripts: collectFiles(path2.join(dir, "scripts"), "scripts"),
@@ -285,6 +345,298 @@ async function devCommand(options) {
       res.end(JSON.stringify(assets));
       return;
     }
+    if (pathname === "/api/compositions") {
+      const compositionsDir = path2.join(os2.homedir(), ".forge", "compositions", meta.projectId);
+      fs2.mkdirSync(compositionsDir, { recursive: true });
+      const savedFiles = fs2.readdirSync(compositionsDir).filter((f) => f.endsWith(".tsx"));
+      const saved = savedFiles.map((f) => ({ name: f.replace(/\.tsx$/, ""), source: "saved" }));
+      const project = findProjectCompositions(dir);
+      res.writeHead(200, { ...CORS_HEADERS, "Content-Type": "application/json" });
+      res.end(JSON.stringify([...saved, ...project]));
+      return;
+    }
+    const compGetMatch = pathname.match(/^\/api\/compositions\/([^/]+)$/);
+    if (req.method === "GET" && compGetMatch) {
+      const name = decodeURIComponent(compGetMatch[1]).replace(/[^a-zA-Z0-9_-]/g, "");
+      if (!name) {
+        res.writeHead(400, CORS_HEADERS);
+        res.end("Invalid name");
+        return;
+      }
+      const compositionsDir = path2.join(os2.homedir(), ".forge", "compositions", meta.projectId);
+      const savedPath = path2.join(compositionsDir, `${name}.tsx`);
+      if (fs2.existsSync(savedPath)) {
+        res.writeHead(200, { ...CORS_HEADERS, "Content-Type": "text/plain; charset=utf-8" });
+        res.end(fs2.readFileSync(savedPath, "utf-8"));
+        return;
+      }
+      const projectComps = findProjectCompositions(dir);
+      const found = projectComps.find((c2) => c2.name === name);
+      if (found) {
+        res.writeHead(200, { ...CORS_HEADERS, "Content-Type": "text/plain; charset=utf-8" });
+        res.end(fs2.readFileSync(found.absolutePath, "utf-8"));
+        return;
+      }
+      res.writeHead(404, CORS_HEADERS);
+      res.end("Not found");
+      return;
+    }
+    const compPostMatch = pathname.match(/^\/api\/compositions\/([^/]+)$/);
+    if (req.method === "POST" && compPostMatch) {
+      const name = compPostMatch[1].replace(/[^a-zA-Z0-9_-]/g, "");
+      if (!name) {
+        res.writeHead(400, CORS_HEADERS);
+        res.end("Invalid name");
+        return;
+      }
+      const compositionsDir = path2.join(os2.homedir(), ".forge", "compositions", meta.projectId);
+      fs2.mkdirSync(compositionsDir, { recursive: true });
+      const filePath = path2.join(compositionsDir, `${name}.tsx`);
+      const chunks = [];
+      req.on("data", (chunk) => chunks.push(chunk));
+      req.on("end", () => {
+        const body = Buffer.concat(chunks).toString("utf-8");
+        fs2.writeFileSync(filePath, body, "utf-8");
+        res.writeHead(200, { ...CORS_HEADERS, "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true, path: filePath }));
+      });
+      req.on("error", () => {
+        res.writeHead(500, CORS_HEADERS);
+        res.end("Upload error");
+      });
+      return;
+    }
+    if (pathname === "/api/ai-edit" && req.method === "POST") {
+      const bodyChunks = [];
+      req.on("data", (c2) => bodyChunks.push(c2));
+      req.on("end", async () => {
+        let parsed;
+        try {
+          parsed = JSON.parse(Buffer.concat(bodyChunks).toString("utf-8"));
+        } catch {
+          res.writeHead(400, CORS_HEADERS);
+          res.end(JSON.stringify({ error: "Invalid JSON body" }));
+          return;
+        }
+        const { code, instruction, context } = parsed;
+        const prompt2 = `You are editing a Remotion TSX composition for video production.
+
+SANDBOX RULES \u2014 strictly followed:
+- Only 'react' and 'remotion' can be imported
+- From remotion: AbsoluteFill, Img, Audio, OffthreadVideo, Sequence, useCurrentFrame, useVideoConfig, interpolate, spring
+- Use inline styles only (no className / CSS)
+- Always export a default function as the composition
+
+PROPS injected by the player at runtime:
+  images         \u2014 Array<{ url: string; name: string }>   (the chunk's images, 16:9)
+  narrationText  \u2014 string | null
+  masterAudioUrl \u2014 string | null
+  startSec       \u2014 number  (offset into master audio where this chunk begins)
+  fps            \u2014 number  (always 30)
+
+Chunk context:
+  title:    ${context?.chunkTitle ?? ""}
+  narration: ${(context?.narrationText ?? "").slice(0, 500)}
+  images:   ${context?.imageCount ?? 0} horizontal images
+  duration: ~${(context?.durationSec ?? 0).toFixed(1)}s
+
+Current composition:
+${code}
+
+User instruction: ${instruction}
+
+Return ONLY the complete updated TSX. No markdown fences, no explanation.`;
+        const tmpFile = path2.join(os2.tmpdir(), `forge-ai-${Date.now()}.txt`);
+        fs2.writeFileSync(tmpFile, prompt2, "utf-8");
+        const cleanup = () => {
+          if (fs2.existsSync(tmpFile)) fs2.unlinkSync(tmpFile);
+        };
+        const respond = (code2, model) => {
+          res.writeHead(200, { ...CORS_HEADERS, "Content-Type": "application/json" });
+          res.end(JSON.stringify({ code: code2, model }));
+        };
+        try {
+          const { stdout } = await exec(
+            `cat "${tmpFile}" | claude -p --model claude-sonnet-4-6 --no-session-persistence`,
+            { maxBuffer: 4 * 1024 * 1024, timeout: 9e4 }
+          );
+          const cleaned = stripFences(stdout.trim());
+          if (cleaned) {
+            cleanup();
+            respond(cleaned, "claude-sonnet-4-6 (CLI)");
+            return;
+          }
+        } catch {
+          log.warn("Claude CLI unavailable \u2014 trying Codex CLI...");
+        }
+        try {
+          const { stdout } = await exec(
+            `codex -q ${JSON.stringify(prompt2)}`,
+            { maxBuffer: 4 * 1024 * 1024, timeout: 9e4 }
+          );
+          const cleaned = stripFences(stdout.trim());
+          if (cleaned && cleaned.includes("export default")) {
+            cleanup();
+            respond(cleaned, "gpt-5.4 (codex CLI)");
+            return;
+          }
+        } catch {
+          log.warn("Codex CLI unavailable \u2014 trying API keys...");
+        }
+        const anthropicKey = process.env.ANTHROPIC_API_KEY;
+        if (anthropicKey) {
+          try {
+            const aResp = await fetch("https://api.anthropic.com/v1/messages", {
+              method: "POST",
+              headers: {
+                "x-api-key": anthropicKey,
+                "anthropic-version": "2023-06-01",
+                "content-type": "application/json"
+              },
+              body: JSON.stringify({
+                model: "claude-sonnet-4-6",
+                max_tokens: 4096,
+                messages: [{ role: "user", content: prompt2 }]
+              })
+            });
+            if (aResp.ok) {
+              const aData = await aResp.json();
+              const cleaned = stripFences((aData.content?.[0]?.text ?? "").trim());
+              if (cleaned) {
+                cleanup();
+                respond(cleaned, "claude-sonnet-4-6 (API)");
+                return;
+              }
+            }
+          } catch {
+            log.warn("Anthropic API failed \u2014 trying OpenAI API...");
+          }
+        }
+        const openAiKey = process.env.OPENAI_API_KEY;
+        if (openAiKey) {
+          try {
+            const oResp = await fetch("https://api.openai.com/v1/chat/completions", {
+              method: "POST",
+              headers: { "Authorization": `Bearer ${openAiKey}`, "Content-Type": "application/json" },
+              body: JSON.stringify({
+                model: "gpt-5.4",
+                max_tokens: 4096,
+                messages: [{ role: "user", content: prompt2 }]
+              })
+            });
+            if (oResp.ok) {
+              const oData = await oResp.json();
+              const cleaned = stripFences((oData.choices?.[0]?.message?.content ?? "").trim());
+              if (cleaned) {
+                cleanup();
+                respond(cleaned, "gpt-5.4 (API)");
+                return;
+              }
+            }
+          } catch {
+            log.warn("OpenAI API failed.");
+          }
+        }
+        cleanup();
+        res.writeHead(500, CORS_HEADERS);
+        res.end(JSON.stringify({
+          error: [
+            "No AI provider succeeded. Configure at least one:",
+            "  \u2022 Install Claude CLI: https://claude.ai/code   (free with Claude subscription)",
+            "  \u2022 Install Codex CLI:  npm install -g @openai/codex",
+            "  \u2022 Set ANTHROPIC_API_KEY in your shell",
+            "  \u2022 Set OPENAI_API_KEY in your shell"
+          ].join("\n")
+        }));
+      });
+      req.on("error", () => {
+        res.writeHead(500, CORS_HEADERS);
+        res.end("Request error");
+      });
+      return;
+    }
+    if (pathname === "/api/chunk-compositions") {
+      const compPath = path2.join(dir, "chunk-compositions.json");
+      if (!fs2.existsSync(compPath)) {
+        res.writeHead(404, CORS_HEADERS);
+        res.end("chunk-compositions.json not found");
+        return;
+      }
+      res.writeHead(200, { ...CORS_HEADERS, "Content-Type": "application/json" });
+      res.end(fs2.readFileSync(compPath));
+      return;
+    }
+    const listMatch = pathname.match(/^\/api\/list\/(.+)$/);
+    if (listMatch) {
+      const relPath = decodeURIComponent(listMatch[1]);
+      const fullPath = path2.resolve(path2.join(dir, relPath));
+      if (!fullPath.startsWith(path2.resolve(dir))) {
+        res.writeHead(403, CORS_HEADERS);
+        res.end("Forbidden");
+        return;
+      }
+      if (!fs2.existsSync(fullPath) || !fs2.statSync(fullPath).isDirectory()) {
+        res.writeHead(404, CORS_HEADERS);
+        res.end("Not a directory");
+        return;
+      }
+      const IMAGE_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp", ".gif"]);
+      const baseUrl = `http://localhost:${port}`;
+      const files = fs2.readdirSync(fullPath).filter((f) => !f.startsWith(".") && IMAGE_EXTS.has(path2.extname(f).toLowerCase())).filter((f) => fs2.statSync(path2.join(fullPath, f)).isFile()).sort().map((f) => {
+        const normalized = relPath.endsWith("/") ? relPath : relPath + "/";
+        const url2 = normalized.startsWith("public/") ? `${baseUrl}/api/public/${normalized.slice("public/".length)}${f}` : `${baseUrl}/api/file/${normalized}${f}`;
+        return { name: f, url: url2 };
+      });
+      res.writeHead(200, { ...CORS_HEADERS, "Content-Type": "application/json" });
+      res.end(JSON.stringify(files));
+      return;
+    }
+    const publicFileMatch = pathname.match(/^\/api\/public\/(.+)$/);
+    if (publicFileMatch) {
+      const filePath = decodeURIComponent(publicFileMatch[1]);
+      const publicDir = path2.join(dir, "public");
+      if (!fs2.existsSync(publicDir)) {
+        res.writeHead(404, CORS_HEADERS);
+        res.end("No public directory");
+        return;
+      }
+      const fullPath = path2.resolve(path2.join(publicDir, filePath));
+      if (!fullPath.startsWith(path2.resolve(publicDir))) {
+        res.writeHead(403, CORS_HEADERS);
+        res.end("Forbidden");
+        return;
+      }
+      if (!fs2.existsSync(fullPath)) {
+        res.writeHead(404, CORS_HEADERS);
+        res.end("Not found");
+        return;
+      }
+      const stat = fs2.statSync(fullPath);
+      const mime = getMime(fullPath);
+      const range = req.headers.range;
+      if (range && (mime.startsWith("audio/") || mime.startsWith("video/"))) {
+        const parts = range.replace(/bytes=/, "").split("-");
+        const start = parseInt(parts[0], 10);
+        const end = parts[1] ? parseInt(parts[1], 10) : stat.size - 1;
+        res.writeHead(206, {
+          ...CORS_HEADERS,
+          "Content-Range": `bytes ${start}-${end}/${stat.size}`,
+          "Accept-Ranges": "bytes",
+          "Content-Length": end - start + 1,
+          "Content-Type": mime
+        });
+        fs2.createReadStream(fullPath, { start, end }).pipe(res);
+        return;
+      }
+      res.writeHead(200, {
+        ...CORS_HEADERS,
+        "Content-Type": mime,
+        "Content-Length": stat.size,
+        "Cache-Control": "public, max-age=3600"
+      });
+      fs2.createReadStream(fullPath).pipe(res);
+      return;
+    }
     const fileMatch = pathname.match(/^\/api\/file\/(.+)$/);
     if (fileMatch) {
       const filePath = decodeURIComponent(fileMatch[1]);
@@ -324,11 +676,73 @@ async function devCommand(options) {
       fs2.createReadStream(fullPath).pipe(res);
       return;
     }
+    const uploadMatch = pathname.match(/^\/api\/upload\/(.+)$/);
+    if (uploadMatch && req.method === "POST") {
+      const relDir = decodeURIComponent(uploadMatch[1]);
+      const projectDir = path2.resolve(dir);
+      const fullDir = path2.resolve(path2.join(dir, relDir));
+      if (!fullDir.startsWith(projectDir)) {
+        res.writeHead(400, CORS_HEADERS);
+        res.end(JSON.stringify({ error: "path traversal" }));
+        return;
+      }
+      try {
+        const contentType = req.headers["content-type"] ?? "";
+        const boundaryM = contentType.match(/boundary=([^\s;]+)/);
+        if (!boundaryM) {
+          res.writeHead(400, CORS_HEADERS);
+          res.end(JSON.stringify({ error: "no boundary" }));
+          return;
+        }
+        const boundary = boundaryM[1];
+        const chunks = [];
+        await new Promise((resolve2, reject) => {
+          req.on("data", (c2) => chunks.push(Buffer.from(c2)));
+          req.on("end", resolve2);
+          req.on("error", reject);
+        });
+        const body = Buffer.concat(chunks);
+        const headerEnd = body.indexOf(Buffer.from("\r\n\r\n"));
+        if (headerEnd === -1) {
+          res.writeHead(400, CORS_HEADERS);
+          res.end(JSON.stringify({ error: "bad multipart" }));
+          return;
+        }
+        const headerSection = body.slice(0, headerEnd).toString();
+        const filenameM = headerSection.match(/filename="([^"]+)"/);
+        if (!filenameM) {
+          res.writeHead(400, CORS_HEADERS);
+          res.end(JSON.stringify({ error: "no filename" }));
+          return;
+        }
+        const filename = path2.basename(filenameM[1]);
+        const dataStart = headerEnd + 4;
+        const endMarker = Buffer.from(`\r
+--${boundary}--`);
+        const endIdx = body.indexOf(endMarker, dataStart);
+        const data = endIdx !== -1 ? body.slice(dataStart, endIdx) : body.slice(dataStart);
+        if (!fs2.existsSync(fullDir)) fs2.mkdirSync(fullDir, { recursive: true });
+        const writePath = path2.resolve(path2.join(fullDir, filename));
+        if (!writePath.startsWith(projectDir)) {
+          res.writeHead(400, CORS_HEADERS);
+          res.end(JSON.stringify({ error: "path traversal" }));
+          return;
+        }
+        fs2.writeFileSync(writePath, data);
+        const relativePath = path2.relative(dir, writePath).replace(/\\/g, "/");
+        res.writeHead(200, { ...CORS_HEADERS, "Content-Type": "application/json" });
+        res.end(JSON.stringify({ path: relativePath }));
+      } catch (e) {
+        res.writeHead(500, CORS_HEADERS);
+        res.end(JSON.stringify({ error: e.message }));
+      }
+      return;
+    }
     res.writeHead(404, CORS_HEADERS);
     res.end(JSON.stringify({ error: "Not found" }));
   });
   server.listen(port, () => {
-    const webUrl = `${WEB_URL}/forge/p/${meta.projectId}/assets`;
+    const webUrl = `${WEB_URL}/forge/p/${meta.projectId}/pipeline`;
     console.log("");
     log.success("Running");
     console.log("");
@@ -341,6 +755,30 @@ async function devCommand(options) {
       log.info("Opening browser...");
       openBrowser(webUrl);
     }
+    const aiMethods = [];
+    try {
+      execSync("which claude", { stdio: "ignore" });
+      aiMethods.push("Claude CLI \u2192 claude-sonnet-4-6");
+    } catch {
+    }
+    try {
+      execSync("which codex", { stdio: "ignore" });
+      aiMethods.push("Codex CLI \u2192 gpt-5.4");
+    } catch {
+    }
+    if (process.env.ANTHROPIC_API_KEY) aiMethods.push("Anthropic API \u2192 claude-sonnet-4-6");
+    if (process.env.OPENAI_API_KEY) aiMethods.push("OpenAI API \u2192 gpt-5.4");
+    console.log("");
+    if (aiMethods.length > 0) {
+      console.log("  AI edit chain (tried in order):");
+      aiMethods.forEach((m, i) => console.log(`    ${i + 1}. ${m}`));
+    } else {
+      console.log("  No AI providers found. To enable composition AI editing:");
+      console.log("     Install Claude CLI: https://claude.ai/code  (free with subscription)");
+      console.log("     Install Codex CLI:  npm install -g @openai/codex");
+      console.log("     Or set ANTHROPIC_API_KEY / OPENAI_API_KEY in your shell");
+    }
+    console.log("");
     console.log("  Ctrl+C to stop");
     console.log("");
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "storyforge",
-  "version": "0.1.2",
+  "version": "0.2.2",
   "description": "StoryForge — local bridge for the Forge video production web app. Zero runtime dependencies.",
   "type": "module",
   "bin": {