storyforge 0.1.0

package/README.md

@@ -0,0 +1,78 @@
+# StoryForge
+
+Local bridge for the [Forge](https://forge.algo-thinker.com) video production web app.
+
+**Zero runtime dependencies.** Single-file bundled output, no transitive installs.
+
+## Quick start
+
+```bash
+cd your-video-project
+npx storyforge
+```
+
+That's it. `storyforge` auto-detects the folder, links it to a project in your dashboard, starts a local server, and opens your browser.
+
+## What it does
+
+1. **Auto-detects** the current folder as a project (name from folder name)
+2. **Links** to an existing project in the dashboard, or creates a new one
+3. **Saves** `forge.json` in the folder so next time it's instant
+4. **Starts** a local HTTP server at `http://localhost:4444`
+5. **Opens** `https://forge.algo-thinker.com/forge/p/{id}/assets` in your browser
+
+The web UI then reads local files directly from your disk — no upload/download cycle needed for audio, images, or rendered clips.
+
+## Folder structure
+
+StoryForge expects any of these subfolders (all optional):
+
+```
+your-project/
+├── audio/                    # Narration audio files
+├── images-horizontal/        # 16:9 images  
+├── images-vertical/          # 9:16 images
+├── clips/                    # Rendered video clips
+├── scripts/                  # Narration text files
+├── gemini-prompts/           # AI image prompts
+├── word-timings/             # Word-level timestamp JSON
+└── brand/                    # Brand assets (logos, intros, etc.)
+```
+
+## Installation
+
+```bash
+# One-time use (recommended)
+npx storyforge
+
+# Global install
+npm install -g storyforge
+storyforge
+```
+
+## Commands
+
+```
+storyforge                    Start dev server + open browser (default)
+storyforge login              Log in to the Forge API
+storyforge --help             Show help
+storyforge --version          Show version
+```
+
+## Options
+
+```
+--port <port>     HTTP server port (default: 4444)
+--dir <dir>       Project directory (default: current)
+--no-open         Do not open browser automatically
+```
+
+## Security
+
+- **Zero runtime dependencies** — the entire CLI is one bundled 14KB file
+- **No telemetry** — makes outbound calls only to the Forge API you configure
+- **Local-first** — your files never leave your disk unless you explicitly push them
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,455 @@
+#!/usr/bin/env node
+
+// src/commands/dev.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as http from "http";
+import { execFile } from "child_process";
+
+// src/utils/log.ts
+var supportsColor = process.stdout.isTTY && process.env.TERM !== "dumb" && !process.env.NO_COLOR;
+var c = supportsColor ? { blue: "\x1B[34m", green: "\x1B[32m", yellow: "\x1B[33m", red: "\x1B[31m", gray: "\x1B[90m", bold: "\x1B[1m", reset: "\x1B[0m" } : { blue: "", green: "", yellow: "", red: "", gray: "", bold: "", reset: "" };
+var log = {
+  info: (msg) => console.log(c.blue + "i" + c.reset, msg),
+  success: (msg) => console.log(c.green + "\u2713" + c.reset, msg),
+  warn: (msg) => console.log(c.yellow + "!" + c.reset, msg),
+  error: (msg) => console.error(c.red + "\u2717" + c.reset, msg),
+  step: (n, total, msg) => console.log(c.gray + `[${n}/${total}]` + c.reset, msg),
+  banner: (msg) => console.log(c.bold + msg + c.reset)
+};
+
+// src/config.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+var FORGE_DIR = path.join(os.homedir(), ".forge");
+var CREDS_PATH = path.join(FORGE_DIR, "credentials.json");
+function getForgeDir() {
+  fs.mkdirSync(FORGE_DIR, { recursive: true });
+  return FORGE_DIR;
+}
+function saveCredentials(creds) {
+  getForgeDir();
+  fs.writeFileSync(CREDS_PATH, JSON.stringify(creds, null, 2));
+}
+function loadCredentials() {
+  try {
+    return JSON.parse(fs.readFileSync(CREDS_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/dev.ts
+var PORT = 4444;
+var WEB_URL = "https://forge.algo-thinker.com";
+function getApiConfig() {
+  const creds = loadCredentials();
+  return {
+    url: process.env.NEXT_PUBLIC_SUPABASE_URL || creds?.apiUrl || "https://5ermrkmy.us-west.insforge.app",
+    key: process.env.INSFORGE_API_KEY || creds?.accessToken || creds?.anonKey || ""
+  };
+}
+var DEFAULT_USER_ID = "00000000-0000-0000-0000-000000000001";
+var CORS_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, POST, PATCH, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type"
+};
+function metaPath(dir) {
+  return path2.join(dir, "forge.json");
+}
+function loadMeta(dir) {
+  try {
+    return JSON.parse(fs2.readFileSync(metaPath(dir), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveMeta(dir, meta) {
+  fs2.writeFileSync(metaPath(dir), JSON.stringify(meta, null, 2));
+}
+function detectFolderName(dir) {
+  return path2.basename(path2.resolve(dir)).replace(/[-_]/g, " ").replace(/\b\w/g, (c2) => c2.toUpperCase());
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+}
+function scanAssets(dir) {
+  const subdirs = [
+    "audio",
+    "images-horizontal",
+    "images-vertical",
+    "clips",
+    "scripts",
+    "gemini-prompts",
+    "word-timings",
+    "brand"
+  ];
+  const found = {};
+  for (const sub of subdirs) {
+    const p = path2.join(dir, sub);
+    if (fs2.existsSync(p)) {
+      const entries = fs2.readdirSync(p, { withFileTypes: true });
+      found[sub] = entries.filter((e) => !e.name.startsWith(".") && !e.isDirectory()).length;
+    }
+  }
+  return found;
+}
+async function dbQuery(method, apiPath, body) {
+  const { url, key } = getApiConfig();
+  if (!key) {
+    throw new Error("Not authenticated. Run: forge login");
+  }
+  const resp = await fetch(`${url}${apiPath}`, {
+    method,
+    headers: {
+      "Authorization": `Bearer ${key}`,
+      "Content-Type": "application/json",
+      "Prefer": "return=representation"
+    },
+    body: body ? JSON.stringify(body) : void 0
+  });
+  if (!resp.ok) {
+    const text = await resp.text();
+    throw new Error(`API ${method} ${apiPath} failed (${resp.status}): ${text}`);
+  }
+  if (resp.status === 204) return null;
+  return resp.json();
+}
+async function findOrCreateProject(dir) {
+  const existing = loadMeta(dir);
+  if (existing) {
+    try {
+      const projects = await dbQuery("GET", `/api/database/records/projects?id=eq.${existing.projectId}`);
+      if (projects && projects.length > 0) return existing;
+    } catch {
+    }
+    log.warn("Previous link is stale. Creating fresh link...");
+  }
+  const folderName = detectFolderName(dir);
+  const slug = slugify(folderName);
+  log.info(`Auto-detected project: "${folderName}"`);
+  let channel;
+  const channels = await dbQuery("GET", "/api/database/records/channels?select=id,name,slug&limit=1");
+  if (channels && channels.length > 0) {
+    channel = channels[0];
+  } else {
+    const created = await dbQuery("POST", "/api/database/records/channels", [{
+      user_id: DEFAULT_USER_ID,
+      name: "My Channel",
+      slug: "my-channel",
+      style_preset: "custom",
+      brand_config: {
+        colors: { primary: "#000000", accent: "#3b82f6", bg: "#ffffff" },
+        fonts: { title: "Inter", body: "Inter", mono: "JetBrains Mono", karaoke: "Inter" },
+        social: {}
+      }
+    }]);
+    channel = created[0];
+    log.success(`Created channel: ${channel.name}`);
+  }
+  let project;
+  const existingProjects = await dbQuery(
+    "GET",
+    `/api/database/records/projects?channel_id=eq.${channel.id}&slug=eq.${slug}&limit=1`
+  );
+  if (existingProjects && existingProjects.length > 0) {
+    project = existingProjects[0];
+    log.info(`Linked to existing project: ${project.title}`);
+  } else {
+    const created = await dbQuery("POST", "/api/database/records/projects", [{
+      channel_id: channel.id,
+      title: folderName,
+      slug,
+      style: "custom",
+      status: "draft",
+      aspect_ratios: ["16:9", "9:16"]
+    }]);
+    project = created[0];
+    log.success(`Created project: ${project.title}`);
+  }
+  const meta = {
+    projectId: project.id,
+    channelId: channel.id,
+    title: project.title,
+    channelName: channel.name,
+    channelSlug: channel.slug,
+    linkedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  saveMeta(dir, meta);
+  log.success(`Saved ${metaPath(dir)}`);
+  return meta;
+}
+function getMime(file) {
+  const ext = path2.extname(file).toLowerCase();
+  const types = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".m4a": "audio/mp4",
+    ".mp4": "video/mp4",
+    ".mov": "video/quicktime",
+    ".webm": "video/webm",
+    ".json": "application/json",
+    ".md": "text/markdown",
+    ".txt": "text/plain"
+  };
+  return types[ext] || "application/octet-stream";
+}
+function collectFiles(dir, base = "") {
+  if (!fs2.existsSync(dir)) return [];
+  const result = [];
+  for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name.startsWith(".")) continue;
+    const full = path2.join(dir, entry.name);
+    const rel = base ? `${base}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      result.push(...collectFiles(full, rel));
+    } else {
+      const stat = fs2.statSync(full);
+      result.push({ path: rel, name: entry.name, size: stat.size, type: getMime(full) });
+    }
+  }
+  return result;
+}
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  execFile(cmd, [url], (err) => {
+    if (err) log.warn(`Could not open browser automatically. Open manually: ${url}`);
+  });
+}
+async function devCommand(options) {
+  const port = parseInt(options.port || String(PORT), 10);
+  const dir = path2.resolve(options.dir || process.cwd());
+  console.log("");
+  log.info(`Forge \u2014 ${dir}`);
+  const counts = scanAssets(dir);
+  const total = Object.values(counts).reduce((a, b) => a + b, 0);
+  if (total > 0) {
+    console.log("");
+    console.log("  Detected assets:");
+    for (const [name, count] of Object.entries(counts)) {
+      if (count > 0) console.log(`    ${name.padEnd(20)} ${count} files`);
+    }
+    console.log("");
+  }
+  let meta;
+  try {
+    meta = await findOrCreateProject(dir);
+  } catch (err) {
+    log.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+  const server = http.createServer(async (req, res) => {
+    if (req.method === "OPTIONS") {
+      res.writeHead(204, CORS_HEADERS);
+      res.end();
+      return;
+    }
+    const url = new URL(req.url || "/", `http://localhost:${port}`);
+    const pathname = url.pathname;
+    if (pathname === "/api/health") {
+      res.writeHead(200, { ...CORS_HEADERS, "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        status: "ok",
+        projectId: meta.projectId,
+        channelId: meta.channelId,
+        title: meta.title,
+        channelSlug: meta.channelSlug,
+        dir
+      }));
+      return;
+    }
+    if (pathname === "/api/project") {
+      res.writeHead(200, { ...CORS_HEADERS, "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ...meta, dir }));
+      return;
+    }
+    if (pathname === "/api/assets") {
+      const assets = {
+        audio: collectFiles(path2.join(dir, "audio")),
+        imagesH: collectFiles(path2.join(dir, "images-horizontal")),
+        imagesV: collectFiles(path2.join(dir, "images-vertical")),
+        clips: collectFiles(path2.join(dir, "clips")),
+        scripts: collectFiles(path2.join(dir, "scripts")),
+        prompts: collectFiles(path2.join(dir, "gemini-prompts")),
+        brand: collectFiles(path2.join(dir, "brand"))
+      };
+      res.writeHead(200, { ...CORS_HEADERS, "Content-Type": "application/json" });
+      res.end(JSON.stringify(assets));
+      return;
+    }
+    const fileMatch = pathname.match(/^\/api\/file\/(.+)$/);
+    if (fileMatch) {
+      const filePath = decodeURIComponent(fileMatch[1]);
+      const fullPath = path2.join(dir, filePath);
+      if (!fullPath.startsWith(dir)) {
+        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
+      });
+      fs2.createReadStream(fullPath).pipe(res);
+      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`;
+    console.log("");
+    log.success("Running");
+    console.log("");
+    console.log(`  Project   ${meta.title}`);
+    console.log(`  Channel   ${meta.channelName}`);
+    console.log(`  Server    http://localhost:${port}`);
+    console.log(`  Dashboard ${webUrl}`);
+    console.log("");
+    if (!options.noOpen) {
+      log.info("Opening browser...");
+      openBrowser(webUrl);
+    }
+    console.log("  Ctrl+C to stop");
+    console.log("");
+  });
+}
+
+// src/commands/login.ts
+import * as readline from "readline";
+function prompt(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve2(answer.trim());
+    });
+  });
+}
+async function loginCommand() {
+  log.banner("\nStoryForge \u2014 Login\n");
+  const apiUrl = await prompt("API URL (enter for default): ") || "https://5ermrkmy.us-west.insforge.app";
+  const anonKey = await prompt("Anon/API key: ");
+  const email = await prompt("Email: ");
+  const password = await prompt("Password: ");
+  try {
+    const resp = await fetch(`${apiUrl}/api/auth/sessions`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ email, password })
+    });
+    if (!resp.ok) {
+      const errText = await resp.text();
+      log.error(`Login failed (${resp.status}): ${errText}`);
+      process.exit(1);
+    }
+    const data = await resp.json();
+    saveCredentials({
+      apiUrl,
+      anonKey,
+      accessToken: data.accessToken || anonKey,
+      refreshToken: data.refreshToken
+    });
+    log.success(`Logged in as ${email}`);
+    log.info("Credentials saved to ~/.forge/credentials.json");
+  } catch (err) {
+    log.error(`Login failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+var HELP = `
+storyforge \u2014 local bridge for the Forge video production web app
+
+Usage:
+  storyforge                       Auto-link current folder, start server, open browser (default)
+  storyforge [options]
+  storyforge login                 Log in
+  storyforge --help                Show this help
+  storyforge --version             Show version
+
+Options:
+  --port <port>      Port number (default: 4444)
+  --dir <dir>        Project directory (default: current)
+  --no-open          Do not open browser automatically
+
+In any folder with assets (audio/, images-horizontal/, images-vertical/, scripts/),
+just run: storyforge
+`.trim();
+function parseArgs(argv) {
+  const opts = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith("--")) continue;
+    const key = arg.slice(2);
+    if (key === "no-open") {
+      opts.open = false;
+      continue;
+    }
+    const next = argv[i + 1];
+    if (next && !next.startsWith("--")) {
+      opts[key] = next;
+      i++;
+    } else {
+      opts[key] = true;
+    }
+  }
+  return opts;
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(HELP);
+    process.exit(0);
+  }
+  if (args.includes("--version") || args.includes("-v")) {
+    console.log(VERSION);
+    process.exit(0);
+  }
+  const firstArg = args[0];
+  if (firstArg === "login") {
+    await loginCommand();
+    return;
+  }
+  const opts = parseArgs(args);
+  await devCommand({
+    port: typeof opts.port === "string" ? opts.port : void 0,
+    dir: typeof opts.dir === "string" ? opts.dir : void 0,
+    noOpen: opts.open === false
+  });
+}
+main().catch((err) => {
+  console.error("\x1B[31m\u2717\x1B[0m", err?.message ?? err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "storyforge",
+  "version": "0.1.0",
+  "description": "StoryForge — local bridge for the Forge video production web app. Zero runtime dependencies.",
+  "type": "module",
+  "bin": { "storyforge": "./dist/index.js" },
+  "files": ["dist/", "README.md"],
+  "scripts": {
+    "build": "tsup",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "tsup": "8.5.0",
+    "typescript": "5.8.3"
+  },
+  "publishConfig": { "access": "public" },
+  "keywords": ["video", "remotion", "storyforge", "cli", "forge"],
+  "license": "MIT",
+  "engines": { "node": ">=18.0.0" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/backspacevenkat/forge.git",
+    "directory": "packages/cli"
+  }
+}