videogen-npm 0.1.0

package/README.md

@@ -0,0 +1,35 @@
+# videogen-npm
+
+Node/npm executable package for the VideoGen CLI.
+
+## Local usage (from this folder)
+
+```bash
+cd /Users/isaaccolomercasas/Documents/videogen-npm
+npm install
+npm run check
+```
+
+Run directly:
+
+```bash
+node ./bin/videogen.js help
+```
+
+Install as a local executable:
+
+```bash
+npm link
+videogen help
+```
+
+## Environment loading
+
+On startup, the CLI attempts to load these files (if they exist):
+
+- `.env`
+- `.env.local`
+- `apps/studio/.env`
+- `apps/studio/.env.local`
+
+Existing environment variables already set in the shell take precedence.

package/bin/videogen.js

@@ -0,0 +1,676 @@
+#!/usr/bin/env node
+
+import path from "node:path";
+import { access, readFile, writeFile } from "node:fs/promises";
+
+class CliError extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "CliError";
+    this.statusCode = options?.statusCode;
+    this.payload = options?.payload;
+  }
+}
+
+const loadEnvFiles = async () => {
+  const cwd = process.cwd();
+  const candidates = [
+    path.join(cwd, ".env"),
+    path.join(cwd, ".env.local"),
+    path.join(cwd, "apps/studio/.env"),
+    path.join(cwd, "apps/studio/.env.local"),
+  ];
+
+  for (const filePath of candidates) {
+    try {
+      const content = await readFile(filePath, "utf8");
+      applyEnv(content);
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+        continue;
+      }
+    }
+  }
+};
+
+const applyEnv = (content) => {
+  const lines = content.split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const match = trimmed.match(/^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
+    if (!match) continue;
+
+    const key = match[1];
+    let value = match[2] || "";
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+
+    if (process.env[key] === undefined) {
+      process.env[key] = value;
+    }
+  }
+};
+
+const HELP_TEXT = `VideoGen CLI (agent-friendly)
+
+Usage:
+  videogen <command> [options]
+
+Global options:
+  --base-url <url>               API base URL (default: VIDEOGEN_BASE_URL or http://localhost:3003)
+  --internal-service-token <t>   Internal service secret (default: VIDEOGEN_INTERNAL_SERVICE_TOKEN or INTERNAL_SERVICE_SECRET)
+  --internal-user-id <id>        Internal user id (default: VIDEOGEN_INTERNAL_USER_ID)
+  --cookie <cookieHeader>        Raw Cookie header value (default: VIDEOGEN_COOKIE)
+  --agent-token <token>          Legacy alias for --internal-service-token
+  --bearer <token>               Authorization Bearer token (default: VIDEOGEN_BEARER_TOKEN)
+  --timeout-ms <ms>              Request timeout in milliseconds (default: 60000)
+  --pretty                       Pretty-print JSON output
+
+Commands:
+  help
+  auth:check
+  auth:notes
+  projects:list
+  projects:create --name <name> [--orientation horizontal|vertical]
+  projects:rename --project <projectId> --name <name>
+  media:list
+  media:upload --project <projectId> --file <localPath>
+  video-editor:get --project <projectId>
+  video-editor:save --project <projectId> --file <jsonFile>
+  video-editor:capabilities
+  video-editor:asset-health --project <projectId> [--repair]
+  render:start --project <projectId>
+  render:status --job <jobId> [--poll] [--poll-ms <ms>] [--max-polls <n>] [--poll-token <token>]
+  ai-video:create --project <projectId> --prompt <text> [--duration-seconds 4|6|8] [--target-duration-seconds <n>] [--aspect-ratio 16:9|9:16] [--out <file>]
+  api:request --method <GET|POST|...> --path </api/...|full_url> [--body-json '{...}']
+
+Examples:
+  videogen auth:check --cookie "__session=..."
+  videogen auth:check --internal-service-token "$INTERNAL_SERVICE_SECRET" --internal-user-id "partner:mybot:runner1"
+  videogen projects:list --cookie "__session=..."
+  videogen render:start --project <projectId> --cookie "__session=..."
+  videogen render:status --job <jobId> --poll --poll-token <token>
+`;
+
+const parseArgs = (argv) => {
+  const flags = {};
+  const positionals = [];
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (!token) continue;
+    if (!token.startsWith("--")) {
+      positionals.push(token);
+      continue;
+    }
+
+    const withoutPrefix = token.slice(2);
+    if (!withoutPrefix) continue;
+
+    const eqIndex = withoutPrefix.indexOf("=");
+    if (eqIndex >= 0) {
+      const key = withoutPrefix.slice(0, eqIndex).trim();
+      const value = withoutPrefix.slice(eqIndex + 1);
+      flags[key] = value;
+      continue;
+    }
+
+    const key = withoutPrefix.trim();
+    const next = argv[i + 1];
+    if (next && !next.startsWith("--")) {
+      flags[key] = next;
+      i += 1;
+    } else {
+      flags[key] = true;
+    }
+  }
+
+  const command = positionals.length > 0 ? positionals[0] : null;
+  return { command, flags, positionals };
+};
+
+const parseNumberFlag = (flags, key, fallback) => {
+  const raw = flags[key];
+  if (typeof raw !== "string") return fallback;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) ? parsed : fallback;
+};
+
+const getRequiredFlag = (flags, key) => {
+  const raw = flags[key];
+  if (typeof raw !== "string" || raw.trim().length === 0) {
+    throw new CliError(`Missing required --${key}`);
+  }
+  return raw.trim();
+};
+
+const normalizeBaseUrl = (raw) => {
+  const trimmed = raw.trim();
+  if (!trimmed) return "http://localhost:3003";
+  return trimmed.endsWith("/") ? trimmed.slice(0, -1) : trimmed;
+};
+
+const toUrl = (ctx, pathOrUrl) => {
+  const raw = pathOrUrl.trim();
+  if (raw.startsWith("http://") || raw.startsWith("https://")) return raw;
+  if (!raw.startsWith("/")) return `${ctx.baseUrl}/${raw}`;
+  return `${ctx.baseUrl}${raw}`;
+};
+
+const parseJsonSafely = async (response) => {
+  return await response.json().catch(() => null);
+};
+
+const readResponseBody = async (response) => {
+  const contentType = String(response.headers.get("content-type") || "").toLowerCase();
+  if (contentType.includes("application/json")) {
+    return await parseJsonSafely(response);
+  }
+  const text = await response.text().catch(() => "");
+  return text;
+};
+
+const makeHeaders = (ctx, initHeaders, extra) => {
+  const headers = new Headers(initHeaders || {});
+
+  if (ctx.cookie && !headers.has("cookie")) {
+    headers.set("cookie", ctx.cookie);
+  }
+
+  const bearerToken = extra?.bearerOverride ?? ctx.bearer;
+  if (bearerToken && !headers.has("authorization")) {
+    headers.set("authorization", `Bearer ${bearerToken}`);
+  }
+
+  if (ctx.internalServiceToken && !headers.has("x-internal-service-token")) {
+    headers.set("x-internal-service-token", ctx.internalServiceToken);
+  }
+  if (ctx.internalUserId && !headers.has("x-internal-user-id")) {
+    headers.set("x-internal-user-id", ctx.internalUserId);
+  }
+
+  if (!headers.has("accept")) {
+    headers.set("accept", "application/json");
+  }
+
+  return headers;
+};
+
+const request = async (ctx, pathOrUrl, init, options) => {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), ctx.timeoutMs);
+
+  try {
+    const response = await fetch(toUrl(ctx, pathOrUrl), {
+      ...(init || {}),
+      headers: makeHeaders(ctx, init?.headers, { bearerOverride: options?.bearerOverride ?? null }),
+      signal: controller.signal,
+    });
+    return response;
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new CliError(`Request timed out after ${ctx.timeoutMs}ms`);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+  }
+};
+
+const requestJson = async (ctx, pathOrUrl, init, options) => {
+  const response = await request(ctx, pathOrUrl, init, options);
+  const payload = await readResponseBody(response);
+
+  if (!response.ok) {
+    const message =
+      typeof payload === "object" && payload && "details" in payload
+        ? String(payload.details || "")
+        : typeof payload === "object" && payload && "error" in payload
+          ? String(payload.error || "")
+          : `Request failed (${response.status})`;
+
+    throw new CliError(message || `Request failed (${response.status})`, {
+      statusCode: response.status,
+      payload,
+    });
+  }
+
+  return payload;
+};
+
+const guessMimeType = (filePath) => {
+  const ext = path.extname(filePath).toLowerCase();
+  if (ext === ".mp4") return "video/mp4";
+  if (ext === ".mov") return "video/quicktime";
+  if (ext === ".webm") return "video/webm";
+  if (ext === ".mp3") return "audio/mpeg";
+  if (ext === ".wav") return "audio/wav";
+  if (ext === ".m4a") return "audio/mp4";
+  if (ext === ".aac") return "audio/aac";
+  if (ext === ".png") return "image/png";
+  if (ext === ".jpg" || ext === ".jpeg") return "image/jpeg";
+  if (ext === ".webp") return "image/webp";
+  if (ext === ".gif") return "image/gif";
+  return "application/octet-stream";
+};
+
+const fileExists = async (filePath) => {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const loadJsonFile = async (filePath) => {
+  if (!(await fileExists(filePath))) {
+    throw new CliError(`File does not exist: ${filePath}`);
+  }
+
+  const text = await readFile(filePath, "utf8");
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new CliError(`Invalid JSON file: ${filePath} (${error instanceof Error ? error.message : "parse failed"})`);
+  }
+};
+
+const commandAuthCheck = async (ctx) => {
+  const payload = await requestJson(ctx, "/api/debug/identity", { method: "GET" });
+  const provider =
+    payload && typeof payload === "object" && "authProvider" in payload
+      ? String(payload.authProvider || "")
+      : "";
+
+  return {
+    ok: true,
+    auth: provider || "unknown",
+    endpoint: "/api/debug/identity",
+    identity: payload,
+  };
+};
+
+const commandAuthNotes = () => {
+  return {
+    ok: true,
+    authSummary: {
+      primary: "Clerk session via cookie (__session) OR internal service headers for agent/gateway flows",
+      alternate: [
+        "Remotion job status supports job poll token via Authorization: Bearer <pollToken> or ?pollToken=...",
+      ],
+      env: [
+        "For Clerk session: VIDEOGEN_COOKIE=__session=...",
+        "For internal service auth: INTERNAL_SERVICE_SECRET + VIDEOGEN_INTERNAL_USER_ID",
+      ],
+      noDedicatedApiLogin: false,
+      notes: [
+        "Internal auth uses X-Internal-Service-Token and X-Internal-User-Id headers.",
+        "Clerk remains active for frontend auth; internal service auth is additive for automation/gateway calls.",
+      ],
+    },
+  };
+};
+
+const commandProjectsList = async (ctx) => {
+  const payload = await requestJson(ctx, "/api/studio/projects", { method: "GET" });
+  return { ok: true, projects: payload };
+};
+
+const commandProjectsCreate = async (ctx, flags) => {
+  const name = getRequiredFlag(flags, "name");
+  const orientationRaw = typeof flags.orientation === "string" ? flags.orientation.trim().toLowerCase() : "";
+  const orientation =
+    orientationRaw === "vertical" ? "vertical" : orientationRaw === "horizontal" ? "horizontal" : undefined;
+  const payload = await requestJson(ctx, "/api/studio/projects", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ name, orientation, video_type: orientation || null }),
+  });
+  return { ok: true, project: payload };
+};
+
+const commandProjectsRename = async (ctx, flags) => {
+  const project = getRequiredFlag(flags, "project");
+  const name = getRequiredFlag(flags, "name");
+  const payload = await requestJson(ctx, `/api/studio/projects/${encodeURIComponent(project)}`, {
+    method: "PATCH",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ name }),
+  });
+  return { ok: true, project: payload };
+};
+
+const commandMediaList = async (ctx) => {
+  const payload = await requestJson(ctx, "/api/studio/db-assets?media=all", { method: "GET" });
+  return { ok: true, media: payload };
+};
+
+const commandMediaUpload = async (ctx, flags) => {
+  const project = getRequiredFlag(flags, "project");
+  const filePath = getRequiredFlag(flags, "file");
+
+  if (!(await fileExists(filePath))) {
+    throw new CliError(`File does not exist: ${filePath}`);
+  }
+
+  const mime = guessMimeType(filePath);
+  const bytes = await readFile(filePath);
+  const uploadBlob = new Blob([bytes], { type: mime });
+  const formData = new FormData();
+  formData.set("file", uploadBlob, path.basename(filePath));
+  formData.set("projectId", project);
+
+  const payload = await requestJson(
+    ctx,
+    `/api/studio/projects/${encodeURIComponent(project)}/video-editor/upload`,
+    {
+      method: "POST",
+      body: formData,
+    },
+  );
+
+  return { ok: true, upload: payload };
+};
+
+const commandVideoEditorGet = async (ctx, flags) => {
+  const project = getRequiredFlag(flags, "project");
+  const payload = await requestJson(ctx, `/api/studio/projects/${encodeURIComponent(project)}/video-editor`, {
+    method: "GET",
+  });
+  return { ok: true, state: payload };
+};
+
+const commandVideoEditorSave = async (ctx, flags) => {
+  const project = getRequiredFlag(flags, "project");
+  const filePath = getRequiredFlag(flags, "file");
+  const parsed = await loadJsonFile(filePath);
+  const videoEditor =
+    parsed && typeof parsed === "object" && !Array.isArray(parsed) && "videoEditor" in parsed
+      ? parsed.videoEditor
+      : parsed;
+
+  const payload = await requestJson(ctx, `/api/studio/projects/${encodeURIComponent(project)}/video-editor`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ videoEditor }),
+  });
+
+  return { ok: true, save: payload };
+};
+
+const commandCapabilities = async (ctx) => {
+  const payload = await requestJson(ctx, "/api/studio/video-editor/capabilities", { method: "GET" });
+  return { ok: true, capabilities: payload };
+};
+
+const commandAssetHealth = async (ctx, flags) => {
+  const project = getRequiredFlag(flags, "project");
+  const repair = flags.repair === true;
+  const payload = await requestJson(
+    ctx,
+    `/api/studio/projects/${encodeURIComponent(project)}/video-editor/asset-health`,
+    { method: repair ? "POST" : "GET" },
+  );
+  return { ok: true, assetHealth: payload };
+};
+
+const commandRenderStart = async (ctx, flags) => {
+  const project = getRequiredFlag(flags, "project");
+  const payload = await requestJson(ctx, `/api/studio/projects/${encodeURIComponent(project)}/video-editor/render`, {
+    method: "POST",
+  });
+  return { ok: true, renderStart: payload };
+};
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+const commandRenderStatus = async (ctx, flags) => {
+  const job = getRequiredFlag(flags, "job");
+  const pollToken = typeof flags["poll-token"] === "string" ? String(flags["poll-token"]).trim() : "";
+  const shouldPoll = flags.poll === true;
+  const pollMs = Math.max(200, parseNumberFlag(flags, "poll-ms", 2500));
+  const maxPolls = Math.max(1, parseNumberFlag(flags, "max-polls", 180));
+
+  let attempts = 0;
+  let lastPayload = null;
+
+  while (attempts < maxPolls) {
+    attempts += 1;
+
+    lastPayload = await requestJson(
+      ctx,
+      `/api/remotion/jobs/${encodeURIComponent(job)}`,
+      { method: "GET" },
+      { bearerOverride: pollToken || null },
+    );
+
+    const status =
+      lastPayload && typeof lastPayload === "object" && "status" in lastPayload
+        ? String(lastPayload.status || "").toLowerCase()
+        : "";
+
+    if (!shouldPoll || status === "completed" || status === "failed") {
+      return {
+        ok: true,
+        attempts,
+        jobId: job,
+        status: lastPayload,
+      };
+    }
+
+    await sleep(pollMs);
+  }
+
+  return {
+    ok: true,
+    attempts: maxPolls,
+    jobId: job,
+    timedOut: true,
+    status: lastPayload,
+  };
+};
+
+const commandAiVideoCreate = async (ctx, flags) => {
+  const project = getRequiredFlag(flags, "project");
+  const prompt = getRequiredFlag(flags, "prompt");
+  const aspectRatioRaw = typeof flags["aspect-ratio"] === "string" ? flags["aspect-ratio"] : "16:9";
+  const aspectRatio = aspectRatioRaw === "9:16" ? "9:16" : "16:9";
+
+  const durationSecondsRaw = parseNumberFlag(flags, "duration-seconds", 8);
+  const durationSeconds = durationSecondsRaw === 4 || durationSecondsRaw === 6 || durationSecondsRaw === 8 ? durationSecondsRaw : 8;
+
+  const targetDurationSecondsRaw = parseNumberFlag(flags, "target-duration-seconds", durationSeconds);
+  const targetDurationSeconds =
+    Number.isFinite(targetDurationSecondsRaw) && targetDurationSecondsRaw > 0
+      ? targetDurationSecondsRaw
+      : durationSeconds;
+
+  const response = await request(ctx, `/api/studio/projects/${encodeURIComponent(project)}/video-editor/create-ai-video`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      prompt,
+      durationSeconds,
+      targetDurationSeconds,
+      aspectRatio,
+    }),
+  });
+
+  if (!response.ok) {
+    const payload = await readResponseBody(response);
+    const message =
+      typeof payload === "object" && payload && "details" in payload
+        ? String(payload.details || "")
+        : typeof payload === "object" && payload && "error" in payload
+          ? String(payload.error || "")
+          : `AI video generation failed (${response.status})`;
+    throw new CliError(message || `AI video generation failed (${response.status})`, {
+      statusCode: response.status,
+      payload,
+    });
+  }
+
+  const outputPathRaw = typeof flags.out === "string" ? flags.out.trim() : "";
+  const outputPath = outputPathRaw || `/tmp/videogen-ai-${Date.now()}.mp4`;
+
+  const bytes = new Uint8Array(await response.arrayBuffer());
+  await writeFile(outputPath, bytes);
+
+  return {
+    ok: true,
+    aiVideo: {
+      project,
+      outputPath,
+      sizeBytes: bytes.byteLength,
+      contentType: response.headers.get("content-type") || "video/mp4",
+      trimStatus: response.headers.get("x-ai-video-trim") || null,
+      trimDetails: response.headers.get("x-ai-video-trim-details") || null,
+    },
+  };
+};
+
+const commandApiRequest = async (ctx, flags) => {
+  const method = typeof flags.method === "string" ? flags.method.toUpperCase().trim() : "GET";
+  const pathOrUrl = getRequiredFlag(flags, "path");
+  const bodyJsonRaw = typeof flags["body-json"] === "string" ? flags["body-json"] : "";
+
+  let body;
+  if (bodyJsonRaw) {
+    try {
+      const parsed = JSON.parse(bodyJsonRaw);
+      body = JSON.stringify(parsed);
+    } catch (error) {
+      throw new CliError(`Invalid --body-json: ${error instanceof Error ? error.message : "parse failed"}`);
+    }
+  }
+
+  const payload = await requestJson(ctx, pathOrUrl, {
+    method,
+    ...(body
+      ? {
+          headers: { "content-type": "application/json" },
+          body,
+        }
+      : {}),
+  });
+
+  return { ok: true, response: payload };
+};
+
+const main = async () => {
+  await loadEnvFiles();
+  const parsed = parseArgs(process.argv.slice(2));
+  const command = parsed.command;
+
+  const wantsHelp = !command || command === "help" || parsed.flags.help === true;
+  if (wantsHelp) {
+    process.stdout.write(HELP_TEXT);
+    return;
+  }
+
+  const ctx = {
+    baseUrl: normalizeBaseUrl(
+      typeof parsed.flags["base-url"] === "string"
+        ? parsed.flags["base-url"]
+        : process.env.VIDEOGEN_BASE_URL || "http://localhost:3003",
+    ),
+    cookie:
+      typeof parsed.flags.cookie === "string"
+        ? parsed.flags.cookie
+        : process.env.VIDEOGEN_COOKIE || null,
+    internalServiceToken:
+      typeof parsed.flags["internal-service-token"] === "string"
+        ? parsed.flags["internal-service-token"]
+        : typeof parsed.flags["agent-token"] === "string"
+          ? parsed.flags["agent-token"]
+          : process.env.VIDEOGEN_INTERNAL_SERVICE_TOKEN ||
+            process.env.INTERNAL_SERVICE_SECRET ||
+            process.env.VIDEOGEN_AGENT_TOKEN ||
+            null,
+    internalUserId:
+      typeof parsed.flags["internal-user-id"] === "string"
+        ? parsed.flags["internal-user-id"]
+        : process.env.VIDEOGEN_INTERNAL_USER_ID ||
+          process.env.AGENT_INTERNAL_USER_ID ||
+          null,
+    bearer:
+      typeof parsed.flags.bearer === "string"
+        ? parsed.flags.bearer
+        : process.env.VIDEOGEN_BEARER_TOKEN || null,
+    timeoutMs: Math.max(1000, parseNumberFlag(parsed.flags, "timeout-ms", 60_000)),
+    pretty: parsed.flags.pretty === true,
+  };
+
+  let result;
+  switch (command) {
+    case "auth:check":
+      result = await commandAuthCheck(ctx);
+      break;
+    case "auth:notes":
+      result = commandAuthNotes();
+      break;
+    case "projects:list":
+      result = await commandProjectsList(ctx);
+      break;
+    case "projects:create":
+      result = await commandProjectsCreate(ctx, parsed.flags);
+      break;
+    case "projects:rename":
+      result = await commandProjectsRename(ctx, parsed.flags);
+      break;
+    case "media:list":
+      result = await commandMediaList(ctx);
+      break;
+    case "media:upload":
+      result = await commandMediaUpload(ctx, parsed.flags);
+      break;
+    case "video-editor:get":
+      result = await commandVideoEditorGet(ctx, parsed.flags);
+      break;
+    case "video-editor:save":
+      result = await commandVideoEditorSave(ctx, parsed.flags);
+      break;
+    case "video-editor:capabilities":
+      result = await commandCapabilities(ctx);
+      break;
+    case "video-editor:asset-health":
+      result = await commandAssetHealth(ctx, parsed.flags);
+      break;
+    case "render:start":
+      result = await commandRenderStart(ctx, parsed.flags);
+      break;
+    case "render:status":
+      result = await commandRenderStatus(ctx, parsed.flags);
+      break;
+    case "ai-video:create":
+      result = await commandAiVideoCreate(ctx, parsed.flags);
+      break;
+    case "api:request":
+      result = await commandApiRequest(ctx, parsed.flags);
+      break;
+    default:
+      throw new CliError(`Unknown command: ${command}`);
+  }
+
+  process.stdout.write(`${JSON.stringify(result, null, ctx.pretty ? 2 : 0)}\n`);
+};
+
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : "Unknown error";
+  const statusCode = error instanceof CliError ? error.statusCode : undefined;
+  const payload = error instanceof CliError ? error.payload : undefined;
+  const output = {
+    ok: false,
+    error: message,
+    ...(statusCode ? { statusCode } : {}),
+    ...(payload !== undefined ? { payload } : {}),
+  };
+  process.stderr.write(`${JSON.stringify(output, null, 2)}\n`);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "videogen-npm",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "description": "Node/npm executable for the VideoGen CLI",
+  "license": "UNLICENSED",
+  "author": "Mindsight Ventures",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mindsightventures/AiVideoGen2.git",
+    "directory": "videogen-npm"
+  },
+  "homepage": "https://github.com/mindsightventures/AiVideoGen2/tree/main/videogen-npm",
+  "bugs": {
+    "url": "https://github.com/mindsightventures/AiVideoGen2/issues"
+  },
+  "files": [
+    "bin",
+    "README.md"
+  ],
+  "bin": {
+    "videogen": "bin/videogen.js"
+  },
+  "scripts": {
+    "check": "node ./bin/videogen.js help"
+  },
+  "engines": {
+    "node": ">=18.17.0"
+  }
+}