Videoagent Video Studio

{
  "name": "videoagent-video-studio",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "videoagent-video-studio",
      "version": "1.0.0",
      "engines": {
        "node": ">=18"
      }
    }
  }
}

{
  "name": "videoagent-video-studio",
  "version": "1.0.0",
  "description": "OpenClaw skill for text-to-video and image-to-video — zero API keys via hosted proxy.",
  "type": "module",
  "engines": {
    "node": ">=18"
  }
}

/**
 * videoagent-video-studio proxy — POST /api/generate
 * Body: { mode, prompt, imageUrl?, duration?, aspectRatio?, model? }
 * model: minimax | kling | veo | hunyuan | pixverse | grok | seedance
 */

const { fal } = require("@fal-ai/client");
const { getModel, listModels, resolveModel, FAL } = require("../models.js");

const FAL_KEY           = process.env.FAL_KEY || "";
const VALID_TOKENS      = (process.env.VALID_TOKENS || "").split(",").filter(Boolean);
const FREE_LIMIT_PER_IP = Math.max(0, parseInt(process.env.FREE_LIMIT_PER_IP || "100", 10));

const {
  getIssuedToken,
  getTokenUsage,
  incrementTokenUsage,
  trackGeneration,
  trackError,
  trackRateLimit,
} = require("../usage-store.js");

fal.config({ credentials: FAL_KEY });

function getClientIp(req) {
  const xff = req.headers["x-forwarded-for"];
  return (typeof xff === "string" ? xff.split(",")[0] : xff?.[0])?.trim()
    || req.headers["x-real-ip"]
    || req.socket?.remoteAddress
    || "unknown";
}

function json(res, status, data) {
  res.setHeader("Content-Type", "application/json");
  res.status(status).json(data);
}

function err(res, status, message, details = null) {
  json(res, status, { success: false, error: message, ...(details && { details }) });
}

function getBearerToken(req) {
  const h = req.headers.authorization;
  return h && h.startsWith("Bearer ") ? h.slice(7).trim() : null;
}

function clampDuration(d, max = 10) {
  const n = parseInt(d, 10);
  if (Number.isNaN(n) || n < 1) return 5;
  return Math.min(n, max);
}

async function runFal(modelId, mode, body) {
  const m = getModel(modelId);
  if (!m || m.provider !== FAL) throw new Error(`Unknown FAL model: ${modelId}`);
  const endpoint = mode === "image-to-video" ? m.i2v : m.t2v;
  if (!endpoint) throw new Error(`Model ${modelId} does not support ${mode}`);

  const normalized = {
    prompt:      body.prompt,
    imageUrl:    body.imageUrl || body.image_url,
    duration:    clampDuration(body.duration),
    aspectRatio: body.aspectRatio || "16:9",
  };
  const input  = m.falInput(normalized, mode);
  const result = await fal.subscribe(endpoint, { input, logs: false });

  const url = result?.data?.video?.url || result?.data?.url;
  if (!url) throw new Error("No video URL in response");

  return { success: true, mode, model: modelId, videoUrl: url,
           duration: normalized.duration, aspectRatio: normalized.aspectRatio };
}

function pickDefaultModel(mode) {
  const list = listModels();
  const m = list.find(m => m.provider === FAL && (mode === "text-to-video" ? m.t2v : m.i2v));
  return m ? m.id : "minimax";
}

module.exports = async function handler(req, res) {
  if (req.method === "OPTIONS") return res.status(204).end();

  // ── GET: health + model list ────────────────────────────────────────────────
  if (req.method === "GET") {
    return json(res, 200, {
      service: "videoagent-video-studio-proxy",
      version: "2.1.0",
      status: "ok",
      modes: ["text-to-video", "image-to-video"],
      models: listModels(),
      free_limit_per_token: FREE_LIMIT_PER_IP,
      free_limit_reset: "daily",
      max_tokens_per_ip_per_day: VALID_TOKENS.length === 0
        ? parseInt(process.env.MAX_TOKENS_PER_IP_PER_DAY || "3", 10) : null,
    });
  }

  if (req.method !== "POST") return err(res, 405, "Method not allowed");

  // ── Auth ────────────────────────────────────────────────────────────────────
  const bearerToken = getBearerToken(req);

  if (VALID_TOKENS.length > 0) {
    if (!bearerToken || !VALID_TOKENS.includes(bearerToken))
      return err(res, 401, "Invalid or missing token.");
  } else {
    if (!bearerToken)
      return err(res, 401, "Missing token. Get one from POST /api/token first.", {
        hint: "POST /api/token → use token as Authorization: Bearer <token>",
      });
    const tokenData = await getIssuedToken(bearerToken);
    if (!tokenData)
      return err(res, 401, "Invalid or expired token. Get a new one from POST /api/token.", {
        token_ttl_hours: 24,
      });
    if (FREE_LIMIT_PER_IP > 0) {
      const used = await getTokenUsage(bearerToken);
      if (used >= FREE_LIMIT_PER_IP) {
        await trackRateLimit("token");
        return json(res, 429, {
          success: false,
          error: "Free limit reached for this token",
          free_limit: FREE_LIMIT_PER_IP,
          used,
          hint: "Get a new token from POST /api/token.",
        });
      }
    }
  }

  // ── Validate input ──────────────────────────────────────────────────────────
  const body        = req.body || {};
  const mode        = (body.mode || "text-to-video").toLowerCase();
  const isI2V       = mode === "image-to-video";

  if (!body.prompt)
    return err(res, 400, "Missing prompt");
  if (isI2V && !body.imageUrl && !body.image_url)
    return err(res, 400, "Missing imageUrl for image-to-video");

  const modelId    = (body.model || "auto").toLowerCase().trim();
  const resolvedId = modelId === "auto" ? pickDefaultModel(mode) : modelId;
  const model      = resolveModel(resolvedId, mode);

  if (!model)
    return err(res, 400,
      `Unsupported model or mode: model=${resolvedId}, mode=${mode}. GET /api/generate for list.`);

  if (model.provider === FAL && !FAL_KEY)
    return err(res, 503, "Service not configured");

  // ── Generate ────────────────────────────────────────────────────────────────
  try {
    let out;
    if (model.provider === FAL) {
      out = await runFal(resolvedId, mode, body);
    } else {
      return err(res, 500, "Unknown provider");
    }

    // Increment usage + track stats only on success
    if (VALID_TOKENS.length === 0 && FREE_LIMIT_PER_IP > 0 && bearerToken) {
      await incrementTokenUsage(bearerToken);
    }
    await trackGeneration(resolvedId, mode).catch(() => {});

    return json(res, 200, out);
  } catch (e) {
    console.error("[vs-proxy]", resolvedId, mode, e.message);
    await trackError(resolvedId).catch(() => {});
    return err(res, 500, e.message || "Video generation failed");
  }
};

/**
 * GET /api/stats        — JSON usage statistics (default)
 * GET /api/stats?ui=1   — HTML dashboard (browser-friendly)
 *
 * Requires Authorization: Bearer <STATS_KEY> when STATS_KEY env is set.
 */

const STATS_KEY = process.env.STATS_KEY || "";
const { getStats, getDailyStats } = require("../usage-store.js");

function json(res, status, data) {
  res.setHeader("Content-Type", "application/json");
  res.status(status).json(data);
}

// ── HTML dashboard ────────────────────────────────────────────────────────────
function renderDashboard(stats, daily) {
  const { total_generations, total_errors, total_tokens_issued,
          rate_limit_hits, by_model, by_mode, using_kv } = stats;

  const now = new Date().toLocaleString("en-US", { timeZone: "UTC", hour12: false });
  const maxVal = Math.max(1, ...Object.values(by_model));

  const modelRows = Object.entries(by_model)
    .sort((a, b) => b[1] - a[1])
    .map(([id, count]) => {
      const pct = Math.round((count / maxVal) * 100);
      return `
      <tr>
        <td class="label">${id}</td>
        <td class="bar-cell">
          <div class="bar-wrap">
            <div class="bar" style="width:${pct}%"></div>
          </div>
        </td>
        <td class="num">${count}</td>
      </tr>`;
    }).join("");

  const modeRows = Object.entries(by_mode).map(([mode, count]) => `
      <tr>
        <td class="label">${mode}</td>
        <td class="num">${count}</td>
      </tr>`).join("");

  const maxDay = Math.max(1, ...daily.map(d => d.total));
  const dayRows = daily.map(d => {
    const pct = Math.round((d.total / maxDay) * 100);
    return `
      <tr>
        <td class="label">${d.date}</td>
        <td class="bar-cell">
          <div class="bar-wrap">
            <div class="bar bar-day" style="width:${Math.max(pct, d.total > 0 ? 2 : 0)}%"></div>
          </div>
        </td>
        <td class="num">${d.total}</td>
      </tr>`;
  }).join("");

  const storageLabel = using_kv
    ? `<span class="badge green">Redis</span>`
    : `<span class="badge yellow">In-memory</span>`;

  return `<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width,initial-scale=1">
<title>Video Studio — Usage Stats</title>
<style>
  *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
  body {
    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
    background: #0d1117; color: #e6edf3; min-height: 100vh; padding: 32px 24px;
  }
  h1 { font-size: 1.3rem; font-weight: 600; letter-spacing: -.3px; }
  h2 { font-size: .85rem; font-weight: 600; text-transform: uppercase;
       letter-spacing: .08em; color: #7d8590; margin-bottom: 12px; }
  .header { display: flex; align-items: center; gap: 10px; margin-bottom: 32px; }
  .header .meta { font-size: .8rem; color: #7d8590; margin-left: auto; }
  .cards { display: grid; grid-template-columns: repeat(auto-fill, minmax(160px, 1fr));
           gap: 12px; margin-bottom: 32px; }
  .card { background: #161b22; border: 1px solid #30363d; border-radius: 8px;
          padding: 16px 18px; }
  .card .val { font-size: 2rem; font-weight: 700; line-height: 1; margin-bottom: 4px; }
  .card .lbl { font-size: .75rem; color: #7d8590; }
  .card.red .val   { color: #f85149; }
  .card.orange .val{ color: #e3b341; }
  .section { background: #161b22; border: 1px solid #30363d; border-radius: 8px;
             padding: 20px 22px; margin-bottom: 20px; }
  table { width: 100%; border-collapse: collapse; }
  td { padding: 6px 4px; font-size: .85rem; vertical-align: middle; }
  td.label { width: 140px; color: #c9d1d9; font-family: monospace; }
  td.num   { width: 60px; text-align: right; font-variant-numeric: tabular-nums; color: #58a6ff; font-weight: 600; }
  td.bar-cell { padding: 6px 8px; }
  .bar-wrap { background: #21262d; border-radius: 4px; height: 10px; overflow: hidden; }
  .bar      { height: 100%; background: #58a6ff; border-radius: 4px;
              transition: width .3s ease; }
  .bar-day  { background: #3fb950; }
  .badge { display: inline-block; padding: 2px 8px; border-radius: 12px;
           font-size: .7rem; font-weight: 600; }
  .badge.green  { background: #1a4731; color: #3fb950; }
  .badge.yellow { background: #3d2e00; color: #e3b341; }
  .two-col { display: grid; grid-template-columns: 1fr 1fr; gap: 20px; }
  @media (max-width: 600px) { .two-col { grid-template-columns: 1fr; } }
  .footer { font-size: .75rem; color: #484f58; margin-top: 24px; text-align: center; }
</style>
</head>
<body>

<div class="header">
  <h1>🎬 Video Studio — Usage</h1>
  <span class="meta">Storage: ${storageLabel} &nbsp;·&nbsp; ${now} UTC</span>
</div>

<div class="cards">
  <div class="card">
    <div class="val">${total_generations}</div>
    <div class="lbl">Total generations</div>
  </div>
  <div class="card red">
    <div class="val">${total_errors}</div>
    <div class="lbl">Errors</div>
  </div>
  <div class="card">
    <div class="val">${total_tokens_issued}</div>
    <div class="lbl">Tokens issued</div>
  </div>
  <div class="card orange">
    <div class="val">${(rate_limit_hits.token || 0) + (rate_limit_hits.ip || 0)}</div>
    <div class="lbl">Rate limit hits</div>
  </div>
</div>

<div class="section">
  <h2>Last 14 days</h2>
  <table>
    <tbody>${dayRows}</tbody>
  </table>
</div>

<div class="two-col">
  <div class="section">
    <h2>By model</h2>
    <table><tbody>${modelRows}</tbody></table>
  </div>
  <div class="section">
    <h2>By mode</h2>
    <table><tbody>${modeRows}</tbody></table>
    <br>
    <h2 style="margin-top:16px">Rate limits</h2>
    <table>
      <tr><td class="label">token quota</td><td class="num">${rate_limit_hits.token || 0}</td></tr>
      <tr><td class="label">IP daily cap</td><td class="num">${rate_limit_hits.ip || 0}</td></tr>
    </table>
  </div>
</div>

<div class="footer">Refresh to update &nbsp;·&nbsp; JSON: <code>/api/stats</code>
${STATS_KEY ? " &nbsp;·&nbsp; Protected by STATS_KEY" : ""}</div>
</body>
</html>`;
}

// ── Handler ───────────────────────────────────────────────────────────────────
module.exports = async function handler(req, res) {
  if (req.method === "OPTIONS") return res.status(204).end();
  if (req.method !== "GET") return json(res, 405, { error: "Method not allowed" });

  if (STATS_KEY) {
    const bearer = req.headers.authorization || "";
    const token  = bearer.startsWith("Bearer ") ? bearer.slice(7).trim() : "";
    if (token !== STATS_KEY)
      return json(res, 401, { error: "Unauthorized. Set Authorization: Bearer <STATS_KEY>." });
  }

  try {
    const wantsHtml = (req.query && req.query.ui) ||
                      (req.headers.accept || "").includes("text/html");

    const [stats, daily] = await Promise.all([
      getStats(),
      getDailyStats(14),
    ]);

    if (wantsHtml) {
      res.setHeader("Content-Type", "text/html; charset=utf-8");
      res.status(200).end(renderDashboard(stats, daily));
      return;
    }

    return json(res, 200, { ...stats, daily, timestamp: new Date().toISOString() });
  } catch (e) {
    return json(res, 500, { error: "Failed to fetch stats", detail: e.message });
  }
};

/**
 * GET /api/status?jobId= — Optional async job status (for proxies that return jobId).
 * This proxy waits for completion and returns videoUrl directly, so jobId is never returned.
 * For custom proxies that do return jobId, implement status lookup here and return { status, videoUrl? }.
 */

function json(res, status, data) {
  res.setHeader("Content-Type", "application/json");
  res.status(status).json(data);
}

module.exports = async function handler(req, res) {
  if (req.method === "OPTIONS") return res.status(204).end();
  if (req.method !== "GET") return json(res, 405, { error: "Method not allowed" });

  const jobId = (req.query?.jobId || req.query?.job_id || "").trim();
  if (!jobId) {
    return json(res, 400, {
      success: false,
      error: "Missing jobId",
      hint: "Use GET /api/status?jobId=your-job-id",
    });
  }

  // This proxy does not use async jobs; it waits for FAL/Grok/Seedance and returns videoUrl.
  // If you deploy a custom proxy that returns jobId, implement your status store lookup here.
  return json(res, 501, {
    success: false,
    error: "Async job status not implemented",
    message: "This proxy waits for completion and returns videoUrl directly. No jobId is issued.",
    jobId,
  });
};

/**
 * POST /api/token — issue free-tier tokens for anonymous users.
 * Each token is capped at FREE_LIMIT_PER_IP uses.
 * Token issuance is capped at MAX_TOKENS_PER_IP_PER_DAY per IP per day.
 */

const VALID_TOKENS            = (process.env.VALID_TOKENS || "").split(",").filter(Boolean);
const FREE_LIMIT_PER_IP       = Math.max(0, parseInt(process.env.FREE_LIMIT_PER_IP || "100", 10));
const MAX_TOKENS_PER_IP_PER_DAY = Math.max(1, parseInt(process.env.MAX_TOKENS_PER_IP_PER_DAY || "3", 10));

const {
  setIssuedToken,
  getIssuanceCount,
  incrementIssuanceCount,
  trackRateLimit,
} = require("../usage-store.js");

function getClientIp(req) {
  const xff = req.headers["x-forwarded-for"];
  return (typeof xff === "string" ? xff.split(",")[0] : xff?.[0])?.trim()
    || req.headers["x-real-ip"]
    || req.socket?.remoteAddress
    || "unknown";
}

function json(res, status, data) {
  res.setHeader("Content-Type", "application/json");
  res.status(status).json(data);
}

module.exports = async function handler(req, res) {
  if (req.method === "OPTIONS") return res.status(204).end();
  if (req.method !== "POST") return json(res, 405, { error: "Method not allowed" });

  if (VALID_TOKENS.length > 0) {
    return json(res, 200, {
      token: null,
      free_limit: 0,
      message: "Proxy uses VALID_TOKENS; use one of those for Authorization.",
    });
  }

  const ip     = getClientIp(req);
  const issued = await getIssuanceCount(ip);

  if (issued >= MAX_TOKENS_PER_IP_PER_DAY) {
    await trackRateLimit("ip").catch(() => {});
    return json(res, 429, {
      success: false,
      error: "Too many tokens requested today",
      max_tokens_per_ip_per_day: MAX_TOKENS_PER_IP_PER_DAY,
      hint: "Limit resets daily.",
    });
  }

  const token = `vs_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
  await setIssuedToken(token, ip);
  await incrementIssuanceCount(ip);

  return json(res, 200, {
    token,
    free_limit: FREE_LIMIT_PER_IP,
    free_limit_reset: "daily",
    max_tokens_per_day: MAX_TOKENS_PER_IP_PER_DAY,
  });
};

/**
 * Video model registry: id -> { provider, endpoints, env key }.
 * Used by api/generate.js to route and build requests.
 */

const FAL = "fal";

// Maps a duration (seconds) to Veo's accepted discrete values.
function dur4s6s8s(sec) {
  const n = parseInt(sec, 10) || 5;
  if (n <= 4) return "4s";
  if (n <= 6) return "6s";
  return "8s";
}

// Categories: t2v = text-to-video, i2v = image-to-video, ref = reference-based
const MODELS = {
  minimax: {
    provider: FAL,
    name: "MiniMax Video 01",
    categories: ["t2v", "i2v", "ref"],
    t2v: "fal-ai/minimax/video-01",
    i2v: "fal-ai/minimax/video-01-live/image-to-video",
    // Subject reference: one reference image for character consistency
    referenceToVideo: "fal-ai/minimax/video-01-subject-reference",
    env: "FAL_KEY",
    falInput: (body, mode) => ({
      prompt: body.prompt.trim(),
      ...(mode === "image-to-video" && body.imageUrl && { image_url: body.imageUrl }),
      output_format: "url",
    }),
    refInput: (body) => ({
      prompt: body.prompt.trim(),
      subject_reference_image_url: body.imageUrl || body.referenceUrl,
    }),
  },

  // Kling uses v3 for T2V/I2V and a separate O3 endpoint for reference-based generation.
  kling: {
    provider: FAL,
    name: "Kling 3.0",
    categories: ["t2v", "i2v", "ref"],
    t2v: "fal-ai/kling-video/v3/standard/text-to-video",
    i2v: "fal-ai/kling-video/v3/standard/image-to-video",
    referenceToVideo: "fal-ai/kling-video/o3/standard/reference-to-video",
    env: "FAL_KEY",
    falInput: (body, mode) => ({
      prompt: body.prompt.trim(),
      aspect_ratio: body.aspectRatio || "16:9",
      ...(mode === "image-to-video" && { image_url: body.imageUrl.trim() }),
      output_format: "url",
    }),
    // Reference input: start/end keyframes, multi-image, or character elements
    refInput: (body) => ({
      prompt: body.prompt.trim(),
      aspect_ratio: body.aspectRatio || "16:9",
      duration: String(Math.min(15, Math.max(3, parseInt(body.duration, 10) || 5))),
      ...(body.imageUrl && { start_image_url: body.imageUrl }),
      ...(body.endImageUrl && { end_image_url: body.endImageUrl }),
      ...(body.imageUrls && { image_urls: body.imageUrls }),
      ...(body.elements && { elements: body.elements }),
    }),
  },

  veo: {
    provider: FAL,
    name: "Google Veo 3.1",
    categories: ["t2v", "i2v", "ref"],
    t2v: "fal-ai/veo3.1",
    i2v: "fal-ai/veo3.1/image-to-video",
    referenceToVideo: "fal-ai/veo3.1/reference-to-video",
    env: "FAL_KEY",
    falInput: (body, mode) => ({
      prompt: body.prompt.trim(),
      aspect_ratio: body.aspectRatio || "16:9",
      duration: dur4s6s8s(body.duration),
      ...(mode === "image-to-video" && body.imageUrl && { image_url: body.imageUrl }),
      output_format: "url",
    }),
    // veo3.1/reference-to-video only accepts duration "8s" (API constraint).
    refInput: (body) => ({
      prompt: body.prompt.trim(),
      aspect_ratio: body.aspectRatio || "16:9",
      duration: "8s",
      resolution: "720p",
      image_urls: body.imageUrls || (body.imageUrl ? [body.imageUrl] : []),
    }),
  },

  hunyuan: {
    provider: FAL,
    name: "Hunyuan Video",
    categories: ["t2v", "ref"],
    t2v: "fal-ai/hunyuan-video",
    // Reference: video-to-video style transfer via prompt (strength controls deviation)
    referenceToVideo: "fal-ai/hunyuan-video/video-to-video",
    env: "FAL_KEY",
    falInput: (body) => ({
      prompt: body.prompt.trim(),
      aspect_ratio: body.aspectRatio || "16:9",
      output_format: "url",
    }),
    refInput: (body) => ({
      prompt: body.prompt.trim(),
      video_url: body.videoUrl || body.referenceUrl,
      aspect_ratio: body.aspectRatio || "16:9",
      strength: body.strength ?? 0.85,
    }),
  },

  pixverse: {
    provider: FAL,
    name: "PixVerse v4.5",
    categories: ["i2v"],
    i2v: "fal-ai/pixverse/v4.5/image-to-video",
    env: "FAL_KEY",
    falInput: (body) => ({
      prompt: body.prompt.trim(),
      image_url: body.imageUrl.trim(),
      aspect_ratio: body.aspectRatio || "16:9",
      output_format: "url",
    }),
  },

  grok: {
    provider: FAL,
    name: "Grok Imagine Video",
    categories: ["t2v", "i2v", "ref"],
    t2v: "xai/grok-imagine-video/text-to-video",
    i2v: "xai/grok-imagine-video/image-to-video",
    // Reference: edit-video — apply prompt changes to a reference video (colorize, restyle, etc.)
    referenceToVideo: "xai/grok-imagine-video/edit-video",
    env: "FAL_KEY",
    falInput: (body, mode) => ({
      prompt: body.prompt.trim(),
      duration: Math.min(15, Math.max(1, parseInt(body.duration, 10) || 6)),
      aspect_ratio: body.aspectRatio || "16:9",
      resolution: "720p",
      ...(mode === "image-to-video" && body.imageUrl && { image_url: body.imageUrl }),
    }),
    refInput: (body) => ({
      prompt: body.prompt.trim(),
      video_url: body.videoUrl || body.referenceUrl,
    }),
  },

  // Seedance 1.5 Pro (ByteDance) — synchronized audio generation
  seedance: {
    provider: FAL,
    name: "Seedance 1.5 Pro",
    categories: ["t2v", "i2v", "ref"],
    t2v: "fal-ai/bytedance/seedance/v1.5/pro/text-to-video",
    i2v: "fal-ai/bytedance/seedance/v1.5/pro/image-to-video",
    env: "FAL_KEY",
    falInput: (body, mode) => ({
      prompt: body.prompt.trim(),
      aspect_ratio: body.aspectRatio || "16:9",
      resolution: "720p",
      duration: String(Math.min(12, Math.max(4, parseInt(body.duration, 10) || 5))),
      generate_audio: true,
      ...(mode === "image-to-video" && body.imageUrl && { image_url: body.imageUrl }),
    }),
  },
};

function getModel(id) {
  const key = (id || "").toLowerCase().replace(/\s+/g, "-");
  return MODELS[key] || null;
}

function listModels() {
  return Object.entries(MODELS).map(([id, m]) => ({
    id,
    name: m.name,
    provider: m.provider,
    categories: m.categories || (m.t2v && m.i2v ? ["t2v", "i2v"] : m.t2v ? ["t2v"] : ["i2v"]),
    t2v: !!m.t2v,
    i2v: !!m.i2v,
    ref: !!m.referenceToVideo,
    ...(m.referenceToVideo && { referenceToVideoEndpoint: m.referenceToVideo }),
  }));
}

function resolveModel(modelId, mode) {
  const m = getModel(modelId);
  if (!m) return null;
  if (mode === "text-to-video" && !m.t2v) return null;
  if (mode === "image-to-video" && !m.i2v) return null;
  return m;
}

module.exports = { MODELS, getModel, listModels, resolveModel, FAL };

{
  "name": "videoagent-video-studio-proxy",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "videoagent-video-studio-proxy",
      "version": "1.0.0",
      "dependencies": {
        "@fal-ai/client": "^1.2.0",
        "@upstash/redis": "^1.34.9"
      }
    },
    "node_modules/@fal-ai/client": {
      "version": "1.9.4",
      "resolved": "https://registry.npmjs.org/@fal-ai/client/-/client-1.9.4.tgz",
      "integrity": "sha512-mDjF2QDq+oficSSxzmErNkseQeRXnvUBEhJy39n4PPe7jRPZeSqM2SNb27SW50rDtCtay+stwFU8zRZehlt1Qg==",
      "license": "MIT",
      "dependencies": {
        "@msgpack/msgpack": "^3.0.0-beta2",
        "eventsource-parser": "^1.1.2",
        "robot3": "^0.4.1"
      },
      "engines": {
        "node": ">=18.0.0"
      }
    },
    "node_modules/@msgpack/msgpack": {
      "version": "3.1.3",
      "resolved": "https://registry.npmjs.org/@msgpack/msgpack/-/msgpack-3.1.3.tgz",
      "integrity": "sha512-47XIizs9XZXvuJgoaJUIE2lFoID8ugvc0jzSHP+Ptfk8nTbnR8g788wv48N03Kx0UkAv559HWRQ3yzOgzlRNUA==",
      "license": "ISC",
      "engines": {
        "node": ">= 18"
      }
    },
    "node_modules/@upstash/redis": {
      "version": "1.36.3",
      "resolved": "https://registry.npmjs.org/@upstash/redis/-/redis-1.36.3.tgz",
      "integrity": "sha512-wxo1ei4OHDHm4UGMgrNVz9QUEela9N/Iwi4p1JlHNSowQiPi+eljlGnfbZVkV0V4PIrjGtGFJt5GjWM5k28enA==",
      "license": "MIT",
      "dependencies": {
        "uncrypto": "^0.1.3"
      }
    },
    "node_modules/eventsource-parser": {
      "version": "1.1.2",
      "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-1.1.2.tgz",
      "integrity": "sha512-v0eOBUbiaFojBu2s2NPBfYUoRR9GjcDNvCXVaqEf5vVfpIAh9f8RCo4vXTP8c63QRKCFwoLpMpTdPwwhEKVgzA==",
      "license": "MIT",
      "engines": {
        "node": ">=14.18"
      }
    },
    "node_modules/robot3": {
      "version": "0.4.1",
      "resolved": "https://registry.npmjs.org/robot3/-/robot3-0.4.1.tgz",
      "integrity": "sha512-hzjy826lrxzx8eRgv80idkf8ua1JAepRc9Efdtj03N3KNJuznQCPlyCJ7gnUmDFwZCLQjxy567mQVKmdv2BsXQ==",
      "license": "BSD-2-Clause"
    },
    "node_modules/uncrypto": {
      "version": "0.1.3",
      "resolved": "https://registry.npmjs.org/uncrypto/-/uncrypto-0.1.3.tgz",
      "integrity": "sha512-Ql87qFHB3s/De2ClA9e0gsnS6zXG27SkTiSJwjCc9MebbfapQfuPzumMIUMi38ezPZVNFcHI9sUIepeQfw8J8Q==",
      "license": "MIT"
    }
  }
}

{
  "name": "videoagent-video-studio-proxy",
  "version": "1.0.0",
  "private": true,
  "dependencies": {
    "@fal-ai/client": "^1.2.0",
    "@upstash/redis": "^1.34.9"
  }
}

/**
 * Usage store — Upstash Redis with in-memory fallback for local dev.
 * Redis is used when UPSTASH_REDIS_REST_URL + UPSTASH_REDIS_REST_TOKEN are set.
 * Legacy Vercel KV env vars (KV_REST_API_URL / KV_REST_API_TOKEN) are also accepted.
 * Falls back to in-process Maps when Redis is not configured.
 *
 * Key schema (prefix: vs:)
 *   vs:tok:{token}               → { ip, createdAt }   TTL 24 h
 *   vs:usage:{token}             → int                  TTL 25 h
 *   vs:ip:{ip}:{dayKey}          → int                  TTL 25 h
 *
 *   vs:stats:total               → int  (lifetime successful generations)
 *   vs:stats:err                 → int  (lifetime generation errors)
 *   vs:stats:issued              → int  (lifetime tokens issued)
 *   vs:stats:429:token           → int  (rate-limit hits by token quota)
 *   vs:stats:429:ip              → int  (rate-limit hits by IP daily limit)
 *   vs:stats:model:{id}          → int  (per-model lifetime total)
 *   vs:stats:mode:{mode}         → int  (per-mode lifetime total)
 *   vs:stats:err:{id}            → int  (per-model error count)
 *
 *   vs:stats:day:{YYYYMMDD}             → int  (total generations that day)
 *   vs:stats:day:{YYYYMMDD}:{modelId}   → int  (per-model that day)
 */

const DAY_MS     = 86400000;
const TOKEN_TTL_S = 86400; // 24 h
const DAY_TTL_S  = 86400 * 90; // keep daily stats for 90 days

// ── Redis client (lazy-loaded) ────────────────────────────────────────────────
let _kv = null;
function getKV() {
  if (_kv) return _kv;
  const url   = process.env.UPSTASH_REDIS_REST_URL   || process.env.KV_REST_API_URL;
  const token = process.env.UPSTASH_REDIS_REST_TOKEN || process.env.KV_REST_API_TOKEN;
  if (!url || !token) return null;
  try {
    const { Redis } = require("@upstash/redis");
    _kv = new Redis({ url, token });
    return _kv;
  } catch {
    return null;
  }
}

// ── In-memory fallback ────────────────────────────────────────────────────────
const mem = {
  tokens: global._vs_tokens ?? (global._vs_tokens = new Map()),
  usage:  global._vs_usage  ?? (global._vs_usage  = new Map()),
  ip:     global._vs_ip     ?? (global._vs_ip     = new Map()),
  stats:  global._vs_stats  ?? (global._vs_stats  = new Map()),
};

function dayKey()        { return Math.floor(Date.now() / DAY_MS); }
function datestamp(d)    { // d = Date obj or offset from today (0 = today, -1 = yesterday)
  const dt = typeof d === "number"
    ? new Date(Date.now() + d * DAY_MS)
    : d;
  return dt.toISOString().slice(0, 10).replace(/-/g, "");
}

// ── Token ops ─────────────────────────────────────────────────────────────────
async function getIssuedToken(token) {
  if (!token || typeof token !== "string") return null;
  const kv = getKV();
  if (kv) return (await kv.get(`vs:tok:${token}`)) || null;

  const data = mem.tokens.get(token);
  if (!data) return null;
  if (Date.now() - data.createdAt > TOKEN_TTL_S * 1000) {
    mem.tokens.delete(token);
    mem.usage.delete(token);
    return null;
  }
  return data;
}

async function setIssuedToken(token, ip) {
  const data = { ip, createdAt: Date.now() };
  const kv = getKV();
  if (kv) {
    await Promise.all([
      kv.set(`vs:tok:${token}`, data, { ex: TOKEN_TTL_S }),
      kv.set(`vs:usage:${token}`, 0,    { ex: TOKEN_TTL_S + 3600 }),
      kv.incr("vs:stats:issued"),
    ]);
    return;
  }
  mem.tokens.set(token, data);
  mem.usage.set(token, 0);
  mem.stats.set("issued", (mem.stats.get("issued") || 0) + 1);
}

async function getTokenUsage(token) {
  const kv = getKV();
  if (kv) return (await kv.get(`vs:usage:${token}`)) || 0;
  return mem.usage.get(token) || 0;
}

async function incrementTokenUsage(token) {
  const kv = getKV();
  if (kv) return await kv.incr(`vs:usage:${token}`);
  const n = (mem.usage.get(token) || 0) + 1;
  mem.usage.set(token, n);
  return n;
}

// ── IP issuance ops ───────────────────────────────────────────────────────────
async function getIssuanceCount(ip) {
  const key = `vs:ip:${ip}:${dayKey()}`;
  const kv = getKV();
  if (kv) return (await kv.get(key)) || 0;
  return mem.ip.get(key) || 0;
}

async function incrementIssuanceCount(ip) {
  const key = `vs:ip:${ip}:${dayKey()}`;
  const kv = getKV();
  if (kv) {
    const n = await kv.incr(key);
    if (n === 1) await kv.expire(key, Math.floor(DAY_MS / 1000) + 3600);
    return n;
  }
  const n = (mem.ip.get(key) || 0) + 1;
  mem.ip.set(key, n);
  return n;
}

// ── Stats tracking ────────────────────────────────────────────────────────────
async function trackGeneration(modelId, mode) {
  const ds  = datestamp(0);
  const kv  = getKV();
  if (!kv) {
    mem.stats.set("total",           (mem.stats.get("total")           || 0) + 1);
    mem.stats.set(`model:${modelId}`, (mem.stats.get(`model:${modelId}`) || 0) + 1);
    mem.stats.set(`mode:${mode}`,     (mem.stats.get(`mode:${mode}`)     || 0) + 1);
    mem.stats.set(`day:${ds}`,        (mem.stats.get(`day:${ds}`)        || 0) + 1);
    mem.stats.set(`day:${ds}:${modelId}`, (mem.stats.get(`day:${ds}:${modelId}`) || 0) + 1);
    return;
  }
  await Promise.all([
    kv.incr("vs:stats:total"),
    kv.incr(`vs:stats:model:${modelId}`),
    kv.incr(`vs:stats:mode:${mode}`),
    kv.incr(`vs:stats:day:${ds}`).then(n => n === 1 && kv.expire(`vs:stats:day:${ds}`, DAY_TTL_S)),
    kv.incr(`vs:stats:day:${ds}:${modelId}`),
  ]);
}

async function trackError(modelId) {
  const kv = getKV();
  if (!kv) {
    mem.stats.set("err", (mem.stats.get("err") || 0) + 1);
    if (modelId) mem.stats.set(`err:${modelId}`, (mem.stats.get(`err:${modelId}`) || 0) + 1);
    return;
  }
  await Promise.all([
    kv.incr("vs:stats:err"),
    modelId && kv.incr(`vs:stats:err:${modelId}`),
  ].filter(Boolean));
}

async function trackRateLimit(type) { // "token" | "ip"
  const kv = getKV();
  if (!kv) { mem.stats.set(`429:${type}`, (mem.stats.get(`429:${type}`) || 0) + 1); return; }
  await kv.incr(`vs:stats:429:${type}`);
}

// ── Stats query ───────────────────────────────────────────────────────────────
const MODEL_IDS = ["minimax", "kling", "veo", "hunyuan", "pixverse", "grok", "seedance"];
const MODES     = ["text-to-video", "image-to-video"];

async function getDailyStats(days = 14) {
  const dates = Array.from({ length: days }, (_, i) => datestamp(-i)).reverse(); // oldest first
  const kv = getKV();

  if (!kv) {
    return dates.map(ds => ({
      date: ds,
      total: mem.stats.get(`day:${ds}`) || 0,
    }));
  }

  const keys = dates.map(ds => `vs:stats:day:${ds}`);
  const vals = await kv.mget(...keys);
  return dates.map((ds, i) => ({
    date: `${ds.slice(0, 4)}-${ds.slice(4, 6)}-${ds.slice(6, 8)}`,
    total: vals[i] || 0,
  }));
}

async function getStats() {
  const kv      = getKV();
  const using_kv = !!kv;

  if (!kv) {
    const byModel = {}, byMode = {};
    MODEL_IDS.forEach(m => { byModel[m] = mem.stats.get(`model:${m}`) || 0; });
    MODES.forEach(m      => { byMode[m]  = mem.stats.get(`mode:${m}`)  || 0; });
    return {
      using_kv,
      total_generations:   mem.stats.get("total")   || 0,
      total_errors:        mem.stats.get("err")     || 0,
      total_tokens_issued: mem.stats.get("issued")  || 0,
      rate_limit_hits: {
        token: mem.stats.get("429:token") || 0,
        ip:    mem.stats.get("429:ip")    || 0,
      },
      by_model: byModel,
      by_mode:  byMode,
    };
  }

  const keys = [
    "vs:stats:total", "vs:stats:err", "vs:stats:issued",
    "vs:stats:429:token", "vs:stats:429:ip",
    ...MODEL_IDS.map(m => `vs:stats:model:${m}`),
    ...MODES.map(m      => `vs:stats:mode:${m}`),
  ];
  const vals = await kv.mget(...keys);
  const [total, err, issued, rl_token, rl_ip] = vals.slice(0, 5).map(v => v || 0);
  const byModel = {}, byMode = {};
  MODEL_IDS.forEach((m, j) => { byModel[m] = vals[5 + j]                    || 0; });
  MODES.forEach((m, j)      => { byMode[m]  = vals[5 + MODEL_IDS.length + j] || 0; });

  return {
    using_kv,
    total_generations:   total,
    total_errors:        err,
    total_tokens_issued: issued,
    rate_limit_hits: { token: rl_token, ip: rl_ip },
    by_model: byModel,
    by_mode:  byMode,
  };
}

module.exports = {
  getIssuedToken, setIssuedToken,
  getTokenUsage, incrementTokenUsage,
  getIssuanceCount, incrementIssuanceCount,
  trackGeneration, trackError, trackRateLimit,
  getStats, getDailyStats,
  TOKEN_TTL_MS: TOKEN_TTL_S * 1000,
};

{
  "functions": {
    "api/generate.js": {
      "maxDuration": 300
    },
    "api/token.js": {
      "maxDuration": 10
    },
    "api/status.js": {
      "maxDuration": 10
    },
    "api/stats.js": {
      "maxDuration": 10
    }
  },
  "headers": [
    {
      "source": "/api/(.*)",
      "headers": [
        { "key": "Access-Control-Allow-Origin", "value": "*" },
        { "key": "Access-Control-Allow-Methods", "value": "GET, POST, OPTIONS" },
        { "key": "Access-Control-Allow-Headers", "value": "Content-Type, Authorization" }
      ]
    }
  ]
}

/**
 * Minimal local HTTP server for testing the proxy handlers.
 * No extra deps — uses Node.js built-in http module.
 * Wraps Vercel-style handlers (req.body, res.status().json()) into real HTTP.
 * Usage: node scripts/local-server.cjs [port]
 */

const http = require("http");
const path = require("path");

const PORT = parseInt(process.argv[2] || "3777", 10);
const proxyDir = path.join(__dirname, "../proxy");

// Load handlers (CommonJS)
const generateHandler = require(path.join(proxyDir, "api/generate.js"));
const tokenHandler    = require(path.join(proxyDir, "api/token.js"));
const statusHandler   = require(path.join(proxyDir, "api/status.js"));

// Adapt Node http IncomingMessage → Express-style req
async function adaptReq(nodeReq) {
  return new Promise((resolve, reject) => {
    let body = "";
    nodeReq.on("data", (c) => (body += c));
    nodeReq.on("end", () => {
      const url = new URL(nodeReq.url, `http://localhost:${PORT}`);
      const query = Object.fromEntries(url.searchParams.entries());
      let parsed = {};
      if (body) {
        try { parsed = JSON.parse(body); } catch {}
      }
      resolve({
        method: nodeReq.method,
        headers: nodeReq.headers,
        body: parsed,
        query,
        socket: { remoteAddress: nodeReq.socket?.remoteAddress || "127.0.0.1" },
      });
    });
    nodeReq.on("error", reject);
  });
}

// Adapt Express-style res → Node http ServerResponse
function adaptRes(nodeRes) {
  const res = {
    _status: 200,
    setHeader: (k, v) => nodeRes.setHeader(k, v),
    status: function(s) { res._status = s; return res; },
    json: function(data) {
      const body = JSON.stringify(data);
      nodeRes.writeHead(res._status, { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) });
      nodeRes.end(body);
      return res;
    },
    end: function() { nodeRes.writeHead(res._status); nodeRes.end(); return res; },
  };
  return res;
}

const server = http.createServer(async (nodeReq, nodeRes) => {
  const req = await adaptReq(nodeReq);
  const res = adaptRes(nodeRes);

  // CORS
  nodeRes.setHeader("Access-Control-Allow-Origin", "*");
  if (nodeReq.method === "OPTIONS") { nodeRes.writeHead(204); nodeRes.end(); return; }

  const pathname = new URL(nodeReq.url, `http://localhost:${PORT}`).pathname;

  if (pathname === "/api/generate") return generateHandler(req, res);
  if (pathname === "/api/token")    return tokenHandler(req, res);
  if (pathname === "/api/status")   return statusHandler(req, res);

  nodeRes.writeHead(404, { "Content-Type": "application/json" });
  nodeRes.end(JSON.stringify({ error: "Not found", path: pathname }));
});

server.listen(PORT, "127.0.0.1", () => {
  console.log(`[local-server] listening on http://127.0.0.1:${PORT}`);
  console.log(`[local-server] FAL_KEY: ${process.env.FAL_KEY ? "set (" + process.env.FAL_KEY.slice(0, 8) + "...)" : "NOT SET"}`);
  console.log("[local-server] ready");
});

server.on("error", (e) => {
  console.error("[local-server] error:", e.message);
  process.exit(1);
});

# ============================================================
# video-studio API test script (PowerShell, no node required)
# Usage:
#   Test against the backend API directly:
#     $env:FAL_KEY = "your-api-key"; .\test-api.ps1
#   Test via local or deployed proxy:
#     $env:FAL_KEY = "your-api-key"; $env:VIDEO_STUDIO_PROXY_URL = "http://localhost:3000"; .\test-api.ps1
# ============================================================

param(
  [string]$FalKey     = $env:FAL_KEY,
  [string]$ProxyUrl   = $env:VIDEO_STUDIO_PROXY_URL,
  [string]$TestMode   = "all"   # all | fal | proxy
)

$ErrorActionPreference = "Continue"

# helpers
function Write-Header($msg) { Write-Host "`n===[ $msg ]===" -ForegroundColor Cyan }
function Write-Ok($msg)     { Write-Host "[OK] $msg"   -ForegroundColor Green }
function Write-Fail($msg)   { Write-Host "[FAIL] $msg" -ForegroundColor Red }
function Write-Info($msg)   { Write-Host "     $msg"   -ForegroundColor Gray }

function Invoke-Json {
  param([string]$Uri, [string]$Method = "GET", $Body = $null, $Headers = @{})
  try {
    $params = @{ Uri = $Uri; Method = $Method; Headers = $Headers; ErrorAction = "Stop" }
    if ($Body) {
      $params.ContentType = "application/json"
      $params.Body        = ($Body | ConvertTo-Json -Depth 10)
    }
    $resp = Invoke-RestMethod @params
    return @{ ok = $true; data = $resp }
  } catch {
    $statusCode = $_.Exception.Response.StatusCode.value__
    $detail     = $_.ErrorDetails.Message
    return @{ ok = $false; status = $statusCode; error = $_.Exception.Message; detail = $detail }
  }
}

# ============================================================
# 1. Direct backend API tests (no proxy)
# ============================================================
function Test-FalDirect {
  Write-Header "Direct API Tests"
  if (-not $FalKey) { Write-Fail "API key not set, skipping"; return }

  $falHeaders = @{ Authorization = "Key $FalKey" }

  # 1-A. minimax text-to-video
  Write-Info "1-A: minimax text-to-video (submit)"
  $r = Invoke-Json `
    -Uri "https://queue.fal.run/fal-ai/minimax/video-01" `
    -Method POST `
    -Headers $falHeaders `
    -Body @{ prompt = "A cat walking in the rain, cinematic, 4K" }
  if ($r.ok) {
    Write-Ok "minimax T2V submitted, request_id=$($r.data.request_id)"
    $Script:minimaxReqId = $r.data.request_id
  } else {
    Write-Fail "minimax T2V failed status=$($r.status): $($r.detail)"
  }

  # 1-B. kling text-to-video
  Write-Info "1-B: kling text-to-video (submit)"
  $r = Invoke-Json `
    -Uri "https://queue.fal.run/fal-ai/kling-video/v3/standard/text-to-video" `
    -Method POST `
    -Headers $falHeaders `
    -Body @{ prompt = "Ocean waves at sunset, slow motion"; aspect_ratio = "16:9" }
  if ($r.ok) {
    Write-Ok "kling T2V submitted, request_id=$($r.data.request_id)"
  } else {
    Write-Fail "kling T2V failed status=$($r.status): $($r.detail)"
  }

  # 1-C. seedance 1.5 pro text-to-video
  Write-Info "1-C: seedance 1.5 pro text-to-video (submit)"
  $r = Invoke-Json `
    -Uri "https://queue.fal.run/fal-ai/bytedance/seedance/v1.5/pro/text-to-video" `
    -Method POST `
    -Headers $falHeaders `
    -Body @{ prompt = "A dog running in a park, sunny day"; duration = "5"; resolution = "720p"; generate_audio = $true }
  if ($r.ok) {
    Write-Ok "seedance 1.5 T2V submitted, request_id=$($r.data.request_id)"
  } else {
    Write-Fail "seedance 1.5 T2V failed status=$($r.status): $($r.detail)"
  }

  # 1-D. veo 3.1 reference-to-video (multiple reference images)
  Write-Info "1-D: veo 3.1 reference-to-video (submit)"
  $r = Invoke-Json `
    -Uri "https://queue.fal.run/fal-ai/veo3.1/reference-to-video" `
    -Method POST `
    -Headers $falHeaders `
    -Body @{
      prompt = "A person walking through a sunlit park"
      image_urls = @("https://upload.wikimedia.org/wikipedia/commons/thumb/4/47/PNG_transparency_demonstration_1.png/280px-PNG_transparency_demonstration_1.png")
      aspect_ratio = "16:9"
      duration = "8s"
    }
  if ($r.ok) {
    Write-Ok "veo reference-to-video submitted, request_id=$($r.data.request_id)"
  } else {
    Write-Fail "veo reference-to-video failed status=$($r.status): $($r.detail)"
  }

  # 1-E. hunyuan video-to-video (reference video)
  Write-Info "1-E: hunyuan video-to-video (submit)"
  $r = Invoke-Json `
    -Uri "https://queue.fal.run/fal-ai/hunyuan-video/video-to-video" `
    -Method POST `
    -Headers $falHeaders `
    -Body @{
      prompt = "Same scene but at night with neon lights"
      video_url = "https://storage.googleapis.com/falserverless/hunyuan_video/hunyuan_v2v_input.mp4"
      aspect_ratio = "16:9"
      strength = 0.85
    }
  if ($r.ok) {
    Write-Ok "hunyuan video-to-video submitted, request_id=$($r.data.request_id)"
  } else {
    Write-Fail "hunyuan video-to-video failed status=$($r.status): $($r.detail)"
  }

  # 1-F. grok text-to-video
  Write-Info "1-F: grok text-to-video (submit)"
  $r = Invoke-Json `
    -Uri "https://queue.fal.run/xai/grok-imagine-video/text-to-video" `
    -Method POST `
    -Headers $falHeaders `
    -Body @{ prompt = "A futuristic city at night with flying cars"; duration = 5; aspect_ratio = "16:9"; resolution = "720p" }
  if ($r.ok) {
    Write-Ok "grok T2V submitted, request_id=$($r.data.request_id)"
  } else {
    Write-Fail "grok T2V failed status=$($r.status): $($r.detail)"
  }

  # 1-G. Poll minimax job status (from 1-A)
  if ($Script:minimaxReqId) {
    Write-Info "1-G: check minimax job status (request_id=$($Script:minimaxReqId))"
    $r = Invoke-Json `
      -Uri "https://queue.fal.run/fal-ai/minimax/video-01/requests/$($Script:minimaxReqId)/status" `
      -Headers $falHeaders
    if ($r.ok) {
      Write-Ok "Queue status: $($r.data.status)"
    } else {
      Write-Fail "Status check failed: $($r.detail)"
    }
  }
}

# ============================================================
# 2. Proxy tests (full free-tier flow + generation)
# ============================================================
function Test-Proxy {
  Write-Header "Proxy Tests"
  if (-not $ProxyUrl) { Write-Fail "VIDEO_STUDIO_PROXY_URL not set, skipping"; return }

  # 2-A. GET /api/generate (health check)
  Write-Info "2-A: GET $ProxyUrl/api/generate"
  $r = Invoke-Json -Uri "$ProxyUrl/api/generate"
  if ($r.ok) {
    Write-Ok "Proxy online: service=$($r.data.service) version=$($r.data.version)"
    Write-Info "    models: $(($r.data.models | ForEach-Object { $_.id }) -join ', ')"
    Write-Info "    free_limit_per_token=$($r.data.free_limit_per_token)"
  } else {
    Write-Fail "Proxy unreachable: $($r.error)"; return
  }

  # 2-B. POST /api/token (get free-tier token)
  Write-Info "2-B: POST $ProxyUrl/api/token"
  $r = Invoke-Json -Uri "$ProxyUrl/api/token" -Method POST
  if ($r.ok) {
    $proxyToken = $r.data.token
    Write-Ok "Token issued: $proxyToken (free_limit=$($r.data.free_limit))"
  } else {
    Write-Fail "Token failed status=$($r.status): $($r.detail)"; return
  }

  $genHeaders = @{ Authorization = "Bearer $proxyToken" }

  # 2-C. Missing prompt should return 400
  Write-Info "2-C: Missing prompt (expect 400)"
  $r = Invoke-Json -Uri "$ProxyUrl/api/generate" -Method POST -Headers $genHeaders `
    -Body @{ mode = "text-to-video" }
  if (-not $r.ok -and $r.status -eq 400) {
    Write-Ok "Correct 400: $($r.detail)"
  } else {
    Write-Fail "Expected 400, got status=$($r.status)"
  }

  # 2-D. Invalid model should return 400
  Write-Info "2-D: Unknown model (expect 400)"
  $r = Invoke-Json -Uri "$ProxyUrl/api/generate" -Method POST -Headers $genHeaders `
    -Body @{ mode = "text-to-video"; prompt = "test"; model = "nonexistent" }
  if (-not $r.ok -and $r.status -eq 400) {
    Write-Ok "Correct 400: $($r.detail)"
  } else {
    Write-Fail "Expected 400, got status=$($r.status) $($r.detail)"
  }

  # 2-E. Real generation — minimax T2V (~30–60s)
  Write-Info "2-E: minimax text-to-video (real call, ~30-60s)"
  $r = Invoke-Json -Uri "$ProxyUrl/api/generate" -Method POST -Headers $genHeaders `
    -Body @{ mode = "text-to-video"; prompt = "A cat walking in the rain, cinematic"; model = "minimax"; duration = 5 }
  if ($r.ok -and $r.data.videoUrl) {
    Write-Ok "minimax T2V succeeded!"
    Write-Info "    videoUrl: $($r.data.videoUrl)"
  } elseif ($r.ok -and $r.data.jobId) {
    Write-Ok "minimax async, jobId=$($r.data.jobId) status=$($r.data.status)"
  } else {
    Write-Fail "minimax failed status=$($r.status): $($r.detail)"
  }

  # 2-F. Real generation — seedance 1.5 T2V
  Write-Info "2-F: seedance 1.5 text-to-video (real call)"
  $r = Invoke-Json -Uri "$ProxyUrl/api/generate" -Method POST -Headers $genHeaders `
    -Body @{ mode = "text-to-video"; prompt = "A dog playing fetch on a sunny beach"; model = "seedance"; duration = 5 }
  if ($r.ok -and $r.data.videoUrl) {
    Write-Ok "seedance 1.5 succeeded!"
    Write-Info "    videoUrl: $($r.data.videoUrl)"
  } elseif ($r.ok -and $r.data.jobId) {
    Write-Ok "seedance 1.5 async, jobId=$($r.data.jobId)"
  } else {
    Write-Fail "seedance 1.5 failed status=$($r.status): $($r.detail)"
  }

  # 2-G. Rate limit test — try to exceed daily token issuance limit
  Write-Info "2-G: Token issuance rate limit test (up to 10 attempts)"
  $hit429 = $false
  for ($i = 0; $i -lt 10; $i++) {
    $r = Invoke-Json -Uri "$ProxyUrl/api/token" -Method POST
    if (-not $r.ok -and $r.status -eq 429) { $hit429 = $true; break }
  }
  if ($hit429) {
    Write-Ok "Correct 429 — daily token limit reached"
  } else {
    Write-Info "429 not triggered (limit higher than 10, or in-memory store not yet reset)"
  }
}

# ============================================================
# 3. Run
# ============================================================
Write-Host "`n🎬 video-studio API Tests" -ForegroundColor Yellow
Write-Host "  API Key:   $(if ($FalKey) { 'set (' + $FalKey.Substring(0, [Math]::Min(8, $FalKey.Length)) + '...)' } else { 'not set' })"
Write-Host "  ProxyUrl:  $(if ($ProxyUrl) { $ProxyUrl } else { 'not set' })"
Write-Host "  TestMode:  $TestMode"

if ($TestMode -eq "all" -or $TestMode -eq "fal")   { Test-FalDirect }
if ($TestMode -eq "all" -or $TestMode -eq "proxy")  { Test-Proxy }

Write-Host "`n✅ Tests complete" -ForegroundColor Yellow

# Quick test for tools/generate.js. Set VIDEO_STUDIO_PROXY_URL to your proxy (e.g. http://localhost:3000).
$ErrorActionPreference = "Continue"
$SkillDir = Split-Path $PSScriptRoot -Parent
Set-Location $SkillDir

Write-Host "=== Test 1: missing --prompt (expect error) ==="
node tools/generate.js --mode text-to-video 2>&1

Write-Host ""
Write-Host "=== Test 2: text-to-video (fails if proxy unreachable) ==="
node tools/generate.js --mode text-to-video --prompt "A cat walking in the rain" --duration 5 2>&1

Write-Host ""
Write-Host "=== Test 3: image-to-video missing --image-url (expect error) ==="
node tools/generate.js --mode image-to-video --prompt "Gentle motion" 2>&1

Write-Host ""
Write-Host "=== Test 4: list-models (GET proxy; may fail if proxy unreachable) ==="
node tools/generate.js --list-models 2>&1

#!/usr/bin/env bash
# Quick test for tools/generate.js. Set VIDEO_STUDIO_PROXY_URL to your proxy (e.g. http://localhost:3000).
set -e
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
BASE_DIR="$(dirname "$SCRIPT_DIR")"
cd "$BASE_DIR"

echo "=== Test 1: missing --prompt (expect error) ==="
node tools/generate.js --mode text-to-video 2>&1 || true

echo ""
echo "=== Test 2: text-to-video (will fail if proxy unreachable) ==="
node tools/generate.js --mode text-to-video --prompt "A cat walking in the rain" --duration 5 2>&1 || true

echo ""
echo "=== Test 3: image-to-video missing --image-url (expect error) ==="
node tools/generate.js --mode image-to-video --prompt "Gentle motion" 2>&1 || true

echo ""
echo "=== Test 4: list-models (GET proxy; may fail if proxy unreachable) ==="
node tools/generate.js --list-models 2>&1 || true

/**
 * Local proxy unit test harness — no Vercel / HTTP server required.
 * Directly invokes handler(req, res) with mock req/res objects.
 * Run: node scripts/test-proxy.cjs
 */

process.env.FAL_KEY = process.env.FAL_KEY || "";
process.env.FREE_LIMIT_PER_IP = "3";
process.env.MAX_TOKENS_PER_IP_PER_DAY = "2";
delete process.env.VALID_TOKENS;
delete process.env.KV_REST_API_URL; // force in-memory fallback

const path = require("path");
const proxyDir = path.join(__dirname, "../proxy");

// ── Mock req / res ────────────────────────────────────────────────────────────
function mockReq(method, body = {}, headers = {}, ip = "1.2.3.4") {
  return { method, body, headers: { ...headers },
           socket: { remoteAddress: ip }, query: body };
}
function mockRes() {
  const res = { _status: 200, _body: null, _headers: {} };
  res.status = (s) => { res._status = s; return res; };
  res.json   = (d) => { res._body  = d; return res; };
  res.end    = ()  => res;
  res.setHeader = (k, v) => { res._headers[k] = v; };
  return res;
}

// ── Runner ────────────────────────────────────────────────────────────────────
let passed = 0, failed = 0;
async function test(label, fn) {
  try   { await fn(); console.log(`  ✓  ${label}`); passed++; }
  catch (e) { console.error(`  ✗  ${label}\n       ${e.message}`); failed++; }
}
function expect(val, label) {
  return {
    toBe:       (exp) => { if (val !== exp) throw new Error(`${label}: expected ${JSON.stringify(exp)}, got ${JSON.stringify(val)}`); },
    toContain:  (sub) => { if (!String(val).includes(sub)) throw new Error(`${label}: expected to contain "${sub}", got "${val}"`); },
    toBeTruthy: ()    => { if (!val) throw new Error(`${label}: expected truthy, got ${JSON.stringify(val)}`); },
    toBeNull:   ()    => { if (val !== null) throw new Error(`${label}: expected null, got ${JSON.stringify(val)}`); },
  };
}

// ── Tests ─────────────────────────────────────────────────────────────────────
async function runTests() {
  console.log("\n═══ proxy unit tests ═══\n");

  // ── usage-store (async) ───────────────────────────────────────────────────
  console.log("── usage-store ──");
  const store = require(path.join(proxyDir, "usage-store.js"));

  await test("setIssuedToken + getIssuedToken round-trip", async () => {
    await store.setIssuedToken("tok_test_1", "1.2.3.4");
    const data = await store.getIssuedToken("tok_test_1");
    expect(data.ip, "ip").toBe("1.2.3.4");
  });

  await test("getIssuedToken returns null for unknown token", async () => {
    const data = await store.getIssuedToken("tok_nonexistent");
    expect(data, "data").toBeNull();
  });

  await test("incrementTokenUsage increments counter", async () => {
    await store.setIssuedToken("tok_usage_1", "1.2.3.4");
    await store.incrementTokenUsage("tok_usage_1");
    await store.incrementTokenUsage("tok_usage_1");
    const n = await store.getTokenUsage("tok_usage_1");
    expect(n, "usage").toBe(2);
  });

  await test("getIssuanceCount + incrementIssuanceCount", async () => {
    const ip = "10.0.0.test_async";
    expect(await store.getIssuanceCount(ip), "initial count").toBe(0);
    await store.incrementIssuanceCount(ip);
    await store.incrementIssuanceCount(ip);
    expect(await store.getIssuanceCount(ip), "after 2 increments").toBe(2);
  });

  await test("getStats returns expected shape", async () => {
    const stats = await store.getStats();
    if (typeof stats.total_generations !== "number") throw new Error("missing total_generations");
    if (typeof stats.by_model !== "object") throw new Error("missing by_model");
    if (typeof stats.by_mode  !== "object") throw new Error("missing by_mode");
  });

  // ── models.js ─────────────────────────────────────────────────────────────
  console.log("\n── models.js ──");
  const { getModel, listModels, resolveModel } = require(path.join(proxyDir, "models.js"));

  await test("listModels returns array with id/name/categories", async () => {
    const list = listModels();
    if (!Array.isArray(list) || list.length === 0) throw new Error("empty list");
    const m = list[0];
    if (!m.id || !m.name || !Array.isArray(m.categories)) throw new Error("missing fields: " + JSON.stringify(m));
  });

  await test("getModel('minimax') returns correct config", async () => {
    const m = getModel("minimax");
    expect(m.t2v, "t2v").toBe("fal-ai/minimax/video-01");
    expect(m.referenceToVideo, "ref endpoint").toBe("fal-ai/minimax/video-01-subject-reference");
  });

  await test("getModel('kling') has correct O3 reference endpoint", async () => {
    const m = getModel("kling");
    expect(m.referenceToVideo, "kling O3").toBe("fal-ai/kling-video/o3/standard/reference-to-video");
  });

  await test("getModel('veo') refInput always returns duration 8s", async () => {
    const m = getModel("veo");
    const input = m.refInput({ prompt: "test", imageUrl: "http://x.com/img.jpg", duration: 4 });
    expect(input.duration, "veo ref duration").toBe("8s");
  });

  await test("getModel('seedance') uses fal-ai/bytedance endpoint", async () => {
    const m = getModel("seedance");
    expect(m.t2v, "seedance t2v").toContain("fal-ai/bytedance/seedance");
    expect(m.provider, "provider").toBe("fal");
  });

  await test("resolveModel returns null for unsupported mode", async () => {
    const m = resolveModel("pixverse", "text-to-video");
    expect(m, "pixverse t2v should be null").toBeNull();
  });

  await test("all models have categories array", async () => {
    for (const m of listModels()) {
      if (!Array.isArray(m.categories) || m.categories.length === 0)
        throw new Error(`${m.id} missing categories`);
    }
  });

  // ── POST /api/token ───────────────────────────────────────────────────────
  console.log("\n── POST /api/token ──");
  const tokenHandler = require(path.join(proxyDir, "api/token.js"));

  await test("GET /api/token → 405", async () => {
    const res = mockRes();
    await tokenHandler(mockReq("GET"), res);
    expect(res._status, "status").toBe(405);
  });

  await test("POST /api/token → issues token", async () => {
    const res = mockRes();
    await tokenHandler(mockReq("POST", {}, {}, "192.168.1.1"), res);
    expect(res._status, "status").toBe(200);
    if (!res._body.token?.startsWith("vs_")) throw new Error("bad token: " + res._body.token);
  });

  await test("POST /api/token → second token same IP works", async () => {
    const res = mockRes();
    await tokenHandler(mockReq("POST", {}, {}, "192.168.1.2"), res);
    const res2 = mockRes();
    await tokenHandler(mockReq("POST", {}, {}, "192.168.1.2"), res2);
    expect(res2._status, "second token").toBe(200);
  });

  await test("POST /api/token → 429 after MAX_TOKENS_PER_IP_PER_DAY (2)", async () => {
    const ip = "192.168.1.50";
    for (let i = 0; i < 2; i++) {
      const res = mockRes();
      await tokenHandler(mockReq("POST", {}, {}, ip), res);
      if (res._status !== 200) throw new Error(`expected 200 on call ${i+1}, got ${res._status}`);
    }
    const res3 = mockRes();
    await tokenHandler(mockReq("POST", {}, {}, ip), res3);
    expect(res3._status, "3rd token should 429").toBe(429);
  });

  // ── POST /api/generate ────────────────────────────────────────────────────
  console.log("\n── POST /api/generate ──");
  const generateHandler = require(path.join(proxyDir, "api/generate.js"));

  await test("GET /api/generate → health check 200", async () => {
    const res = mockRes();
    await generateHandler(mockReq("GET"), res);
    expect(res._status, "status").toBe(200);
    expect(res._body.service, "service").toBe("videoagent-video-studio-proxy");
    if (!Array.isArray(res._body.models)) throw new Error("models not array");
    expect(res._body.free_limit_per_token, "free_limit").toBe(3);
  });

  await test("POST /api/generate without token → 401", async () => {
    const res = mockRes();
    await generateHandler(mockReq("POST", { mode: "text-to-video", prompt: "test" }), res);
    expect(res._status, "status").toBe(401);
  });

  await test("POST /api/generate with unknown token → 401", async () => {
    const res = mockRes();
    await generateHandler(mockReq("POST", { mode: "text-to-video", prompt: "test" }, {
      authorization: "Bearer vs_fake_never_issued",
    }), res);
    expect(res._status, "status").toBe(401);
  });

  // issue real token for next tests
  const tr = mockRes();
  await tokenHandler(mockReq("POST", {}, {}, "test.harness.ip"), tr);
  const testToken = tr._body.token;

  await test("POST /api/generate missing prompt → 400", async () => {
    const res = mockRes();
    await generateHandler(mockReq("POST", { mode: "text-to-video" }, {
      authorization: `Bearer ${testToken}`,
    }), res);
    expect(res._status, "status").toBe(400);
    expect(res._body.error, "error").toContain("prompt");
  });

  await test("POST /api/generate image-to-video missing imageUrl → 400", async () => {
    const res = mockRes();
    await generateHandler(mockReq("POST", { mode: "image-to-video", prompt: "test" }, {
      authorization: `Bearer ${testToken}`,
    }), res);
    expect(res._status, "status").toBe(400);
    expect(res._body.error, "error").toContain("imageUrl");
  });

  await test("POST /api/generate invalid model → 400", async () => {
    const res = mockRes();
    await generateHandler(mockReq("POST",
      { mode: "text-to-video", prompt: "test", model: "nonexistent_xyz" },
      { authorization: `Bearer ${testToken}` }
    ), res);
    expect(res._status, "status").toBe(400);
  });

  await test("POST /api/generate pixverse with text-to-video → 400 (i2v only)", async () => {
    const res = mockRes();
    await generateHandler(mockReq("POST",
      { mode: "text-to-video", prompt: "test", model: "pixverse" },
      { authorization: `Bearer ${testToken}` }
    ), res);
    expect(res._status, "status").toBe(400);
  });

  await test("POST /api/generate with no FAL_KEY → 503", async () => {
    const saved = process.env.FAL_KEY;
    process.env.FAL_KEY = "";
    delete require.cache[require.resolve(path.join(proxyDir, "api/generate.js"))];
    const fresh = require(path.join(proxyDir, "api/generate.js"));
    const tr2 = mockRes();
    await tokenHandler(mockReq("POST", {}, {}, "no.fal.key.ip"), tr2);
    const res = mockRes();
    await fresh(mockReq("POST",
      { mode: "text-to-video", prompt: "test", model: "minimax" },
      { authorization: `Bearer ${tr2._body.token}` }
    ), res);
    process.env.FAL_KEY = saved;
    expect(res._status, "status").toBe(503);
  });

  await test("POST /api/generate rate-limit: 429 after FREE_LIMIT_PER_IP (3) calls", async () => {
    const tr3 = mockRes();
    await tokenHandler(mockReq("POST", {}, {}, "ratelimit.test.ip"), tr3);
    const tok = tr3._body.token;
    // burn usage to limit
    for (let i = 0; i < 3; i++) await store.incrementTokenUsage(tok);
    delete require.cache[require.resolve(path.join(proxyDir, "api/generate.js"))];
    const fresh = require(path.join(proxyDir, "api/generate.js"));
    process.env.FAL_KEY = "test_key";
    const res = mockRes();
    await fresh(mockReq("POST",
      { mode: "text-to-video", prompt: "test", model: "minimax" },
      { authorization: `Bearer ${tok}` }
    ), res);
    process.env.FAL_KEY = "";
    expect(res._status, "status").toBe(429);
    expect(res._body.error, "error").toContain("Free limit");
  });

  // ── GET /api/status ───────────────────────────────────────────────────────
  console.log("\n── GET /api/status ──");
  const statusHandler = require(path.join(proxyDir, "api/status.js"));

  await test("GET /api/status without jobId → 400", async () => {
    const res = mockRes();
    await statusHandler(mockReq("GET", {}), res);
    expect(res._status, "status").toBe(400);
  });

  await test("GET /api/status with jobId → 501", async () => {
    const req = mockReq("GET", {});
    req.query = { jobId: "test-job-123" };
    const res = mockRes();
    await statusHandler(req, res);
    expect(res._status, "status").toBe(501);
    expect(res._body.jobId, "jobId echoed").toBe("test-job-123");
  });

  // ── GET /api/stats ────────────────────────────────────────────────────────
  console.log("\n── GET /api/stats ──");
  const statsHandler = require(path.join(proxyDir, "api/stats.js"));

  await test("GET /api/stats open access (no STATS_KEY) → 200", async () => {
    delete process.env.STATS_KEY;
    delete require.cache[require.resolve(path.join(proxyDir, "api/stats.js"))];
    const fresh = require(path.join(proxyDir, "api/stats.js"));
    const res = mockRes();
    await fresh(mockReq("GET"), res);
    expect(res._status, "status").toBe(200);
    if (typeof res._body.total_generations !== "number") throw new Error("missing total_generations");
    if (!res._body.timestamp) throw new Error("missing timestamp");
  });

  await test("GET /api/stats with STATS_KEY set → 401 without token", async () => {
    process.env.STATS_KEY = "secret123";
    delete require.cache[require.resolve(path.join(proxyDir, "api/stats.js"))];
    const fresh = require(path.join(proxyDir, "api/stats.js"));
    const res = mockRes();
    await fresh(mockReq("GET"), res);
    expect(res._status, "status").toBe(401);
    delete process.env.STATS_KEY;
  });

  await test("GET /api/stats with correct STATS_KEY → 200", async () => {
    process.env.STATS_KEY = "secret123";
    delete require.cache[require.resolve(path.join(proxyDir, "api/stats.js"))];
    const fresh = require(path.join(proxyDir, "api/stats.js"));
    const res = mockRes();
    await fresh(mockReq("GET", {}, { authorization: "Bearer secret123" }), res);
    expect(res._status, "status").toBe(200);
    delete process.env.STATS_KEY;
  });

  await test("POST /api/stats → 405", async () => {
    const res = mockRes();
    await statsHandler(mockReq("POST"), res);
    expect(res._status, "status").toBe(405);
  });

  // ── Summary ───────────────────────────────────────────────────────────────
  console.log(`\n═══ Results: ${passed} passed, ${failed} failed ═══\n`);
  process.exit(failed > 0 ? 1 : 0);
}

runTests().catch(e => { console.error("Unhandled:", e); process.exit(1); });