@vfrey/vfrey 0.0.1 → 1.0.0-beta.1

package/vendor/framey/dist/cli.js

@@ -0,0 +1,439 @@
+#!/usr/bin/env node
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  resolveExtraPositionals
+} from "./chunk-5SG54JRS.js";
+import "./chunk-K4WKGXRC.js";
+import {
+  isRenderSucceeded
+} from "./chunk-66LREXGS.js";
+import {
+  assertKnownFlags,
+  guardSwallowedFlagValues
+} from "./chunk-U242RTCT.js";
+import {
+  defineCommand,
+  parseArgs,
+  runCommand
+} from "./chunk-S3S4TGEH.js";
+import {
+  getRunId
+} from "./chunk-54HJ63Q2.js";
+import {
+  isDevMode
+} from "./chunk-ISN5GRYI.js";
+import "./chunk-VORQIH64.js";
+import {
+  CliResultSignal,
+  CliRuntimeError,
+  CliUsageError,
+  consumeCommandResult,
+  outputWritten,
+  registerRootExitCodeSanitizer,
+  registerRootExitRequester
+} from "./chunk-JVBRJMOP.js";
+import {
+  VERSION
+} from "./chunk-AHX34EFP.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/cli.ts
+import { dirname, join as join2, resolve } from "path";
+import { fileURLToPath } from "url";
+import { existsSync } from "fs";
+
+// src/utils/command-failure-tracking.ts
+function trackCommandFailures(load) {
+  return () => load().then((cmd) => wrapCommand(cmd, commandName(cmd)));
+}
+function commandName(cmd) {
+  const name = cmd.meta?.name;
+  return typeof name === "string" ? name : "";
+}
+function wrapCommand(cmd, path) {
+  const run = cmd.run;
+  if (typeof run !== "function" && !cmd.subCommands) return cmd;
+  const wrapped = { ...cmd };
+  if (typeof run === "function") {
+    wrapped.run = async (ctx) => {
+      const rawArgs = ctx?.rawArgs ?? [];
+      const firstPositional = rawArgs.find((tok) => tok && !tok.startsWith("-"));
+      const delegatesToSub = cmd.subCommands != null && firstPositional != null && Object.prototype.hasOwnProperty.call(cmd.subCommands, firstPositional);
+      if (!delegatesToSub) guardLeafFlags(cmd, path, ctx, rawArgs);
+      if (!cmd.subCommands) resolveExtraPositionals(cmd, path, ctx?.args);
+      return await run(ctx);
+    };
+  }
+  if (cmd.subCommands) {
+    const wrappedSubs = {};
+    for (const [name, sub] of Object.entries(cmd.subCommands)) {
+      wrappedSubs[name] = () => Promise.resolve(typeof sub === "function" ? sub() : sub).then(
+        (c) => wrapCommand(c, `${path} ${name}`)
+      );
+    }
+    wrapped.subCommands = wrappedSubs;
+  }
+  return wrapped;
+}
+function guardLeafFlags(cmd, path, ctx, rawArgs) {
+  assertKnownFlags(cmd, rawArgs);
+  const guarded = guardSwallowedFlagValues(cmd, path, rawArgs);
+  if (!guarded.rewritten) return;
+  ctx.rawArgs = guarded.rawArgs;
+  ctx.args = parseArgs(guarded.rawArgs, cmd.args ?? {});
+}
+async function reportCommandFailure(command2, err) {
+  try {
+    const { trackCommandFailure } = await import("./events-ACY3P2PA.js");
+    trackCommandFailure(command2, err);
+  } catch {
+  }
+}
+
+// src/utils/commandUsageResolution.ts
+async function loadSubcommand(command2, name) {
+  const subcommands = command2.subCommands;
+  const candidate = subcommands?.[name];
+  if (!candidate) return void 0;
+  return typeof candidate === "function" ? candidate() : candidate;
+}
+async function resolveCommandUsage(root, argv2) {
+  let command2 = root;
+  let parent;
+  for (const argument of argv2) {
+    if (argument.startsWith("-")) break;
+    const child = await loadSubcommand(command2, argument);
+    if (!child) break;
+    parent = command2;
+    command2 = child;
+  }
+  return { command: command2, parent };
+}
+
+// src/utils/runningCli.ts
+import { mkdirSync, readdirSync, statSync, unlinkSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var RUNNING_DIR = join(homedir(), ".hyperframes", "running");
+var RUNNING_HEARTBEAT_MS = 3e4;
+var RUNNING_STALE_MS = 10 * 6e4;
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error instanceof Error && "code" in error && error.code === "EPERM";
+  }
+}
+function pruneExitedClis(dir, own) {
+  let names = [];
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    if (name === own) continue;
+    const file = join(dir, name);
+    try {
+      const pid = Number(name);
+      const beating = Date.now() - statSync(file).mtimeMs <= RUNNING_STALE_MS;
+      if (Number.isInteger(pid) && pid > 0 && isAlive(pid) && beating) continue;
+      unlinkSync(file);
+    } catch {
+    }
+  }
+}
+function registerRunningCli(dir = RUNNING_DIR, heartbeatMs = RUNNING_HEARTBEAT_MS) {
+  try {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+    const file = join(dir, String(process.pid));
+    writeFileSync(file, "", { mode: 384 });
+    pruneExitedClis(dir, String(process.pid));
+    const heartbeat = setInterval(() => {
+      try {
+        mkdirSync(dir, { recursive: true, mode: 448 });
+        writeFileSync(file, String(Date.now()), { mode: 384 });
+      } catch {
+      }
+    }, heartbeatMs);
+    heartbeat.unref();
+    process.on("exit", () => {
+      clearInterval(heartbeat);
+      try {
+        unlinkSync(file);
+      } catch {
+      }
+    });
+  } catch {
+  }
+}
+
+// src/cli.ts
+var commandFailed = false;
+for (const stream of [process.stdout, process.stderr]) {
+  stream.on("error", (err) => {
+    if (err.code === "EPIPE") {
+      handleStreamEpipe();
+    }
+  });
+}
+(() => {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const shader = join2(here, "shaderTransitionWorker.js");
+  if (!process.env.HF_SHADER_WORKER_ENTRY && existsSync(shader)) {
+    process.env.HF_SHADER_WORKER_ENTRY = shader;
+  }
+})();
+var argv = process.argv.slice(2);
+var commandArg = argv[0];
+var rootVersionRequested = commandArg === "--version" || commandArg === "-V" || commandArg === void 0 && (argv.includes("--version") || argv.includes("-V"));
+if (rootVersionRequested) {
+  console.log(VERSION);
+  process.exit(0);
+}
+var { applyDotEnv } = await import("./dotEnv-7PZQTVIM.js");
+try {
+  const { readFileSync } = await import("fs");
+  const envPath = resolve(process.cwd(), ".env");
+  applyDotEnv(readFileSync(envPath, "utf-8"), process.env);
+} catch {
+}
+registerRunningCli();
+var isHelp = process.argv.includes("--help") || process.argv.includes("-h");
+async function assertStudioWorkspaceBuilt() {
+  if (!isDevMode()) return;
+  const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+  const { checkStudioWorkspaceBuild, formatWorkspaceBuildProblems } = await import("./workspaceBuildCheck-XYD2YTFW.js");
+  const problems = checkStudioWorkspaceBuild(repoRoot);
+  if (problems.length === 0) return;
+  console.error(formatWorkspaceBuildProblems(problems));
+  throw new CliRuntimeError("Studio workspace build check failed", {
+    exitCode: 1,
+    presented: true
+  });
+}
+var commandLoaders = {
+  init: () => import("./init-G4WGLYGD.js").then((m) => m.default),
+  add: () => import("./add-VMJD5KBS.js").then((m) => m.default),
+  catalog: () => import("./catalog-5JVDEUWK.js").then((m) => m.default),
+  "media-use": () => import("./media-use-LWH3MANK.js").then((m) => m.default),
+  play: () => import("./play-BUTDQ4DV.js").then((m) => m.default),
+  present: () => import("./present-GXYSM7NX.js").then((m) => m.default),
+  preview: () => assertStudioWorkspaceBuilt().then(() => import("./preview-EKZ33JOJ.js").then((m) => m.default)),
+  open: () => import("./open-E3TB6P6J.js").then((m) => m.default),
+  "catch-up": () => import("./catch-up-NEBCL5NO.js").then((m) => m.default),
+  render: () => import("./render-YE5YAMOD.js").then((m) => m.default),
+  lint: () => import("./lint-I7FZN2VJ.js").then((m) => m.default),
+  check: () => import("./check-F5N544ML.js").then((m) => m.default),
+  beats: () => import("./beats-HL2BDUZI.js").then((m) => m.default),
+  audio: () => import("./audio-RSJWVWRA.js").then((m) => m.default),
+  "normalize-audio": () => import("./normalize-audio-VDWYRHN6.js").then((m) => m.default),
+  inspect: () => import("./inspect-5IQ6CNEQ.js").then((m) => m.default),
+  keyframes: () => import("./keyframes-Q6XJO7VW.js").then((m) => m.default),
+  layout: () => import("./layout-YET6XNXA.js").then((m) => m.default),
+  info: () => import("./info-WPCJHBMU.js").then((m) => m.default),
+  compositions: () => import("./compositions-XT3PMNDF.js").then((m) => m.default),
+  timeline: () => import("./timeline-LHUUMK63.js").then((m) => m.default),
+  history: () => import("./history-ENGZEVFT.js").then((m) => m.default),
+  benchmark: () => import("./benchmark-RWCWHI5Z.js").then((m) => m.default),
+  browser: () => import("./browser-ECYET3Q2.js").then((m) => m.default),
+  "remove-background": () => import("./remove-background-OY5L7XN2.js").then((m) => m.default),
+  transcribe: () => import("./transcribe-O7HQKMIV.js").then((m) => m.default),
+  usage: () => import("./usage-HG4WMM7A.js").then((m) => m.default),
+  models: () => import("./models-K363FYM4.js").then((m) => m.default),
+  tts: () => import("./tts-YCCQHZD4.js").then((m) => m.default),
+  docs: () => import("./docs-VKIRFEEX.js").then((m) => m.default),
+  doctor: () => import("./doctor-2UNJ2G7U.js").then((m) => m.default),
+  clean: () => import("./clean-ZJOGDKDM.js").then((m) => m.default),
+  telemetry: () => import("./telemetry-DQGPEKM6.js").then((m) => m.default),
+  events: () => import("./events-IHB3B2MK.js").then((m) => m.default),
+  validate: () => import("./validate-F2XMN6EV.js").then((m) => m.default),
+  snapshot: () => import("./snapshot-TUXL6LBQ.js").then((m) => m.default),
+  "media-treatment": () => import("./media-treatment-BXYS4WVA.js").then((m) => m.mediaTreatmentCommand),
+  "grade-compare": () => import("./grade-compare-GAXFQ74C.js").then((m) => m.default),
+  compare: () => import("./compare-W7UY3BAZ.js").then((m) => m.default),
+  lambda: () => import("./lambda-A7JC74JF.js").then((m) => m.default),
+  cloudrun: () => import("./cloudrun-HGJ3B6ZV.js").then((m) => m.default),
+  figma: () => import("./figma-BODVUPHB.js").then((m) => m.default)
+};
+var subCommands = Object.fromEntries(
+  Object.entries(commandLoaders).map(([name, load]) => [name, trackCommandFailures(load)])
+);
+var main = defineCommand({
+  meta: {
+    name: "framey",
+    version: VERSION,
+    description: "Create and render HTML video compositions"
+  },
+  subCommands
+});
+var cliCommandArg = process.argv[2];
+var command = cliCommandArg && cliCommandArg in subCommands ? cliCommandArg : "unknown";
+var _flushSync;
+var _trackCliError;
+var _trackCommandResult;
+var telemetryReady = Promise.resolve();
+if (!isHelp && command !== "telemetry" && command !== "events" && command !== "usage" && command !== "unknown") {
+  telemetryReady = import("./telemetry-UN55N6U6.js").then((mod) => {
+    _flushSync = mod.flushSync;
+    _trackCliError = mod.trackCliError;
+    _trackCommandResult = mod.trackCommandResult;
+    mod.showTelemetryNotice();
+    mod.trackCommand(command, runId);
+    if (mod.shouldTrack()) mod.incrementCommandCount();
+  });
+}
+var _appHistoryNotice = null;
+if (!isHelp && !["unknown", "catch-up", "events", "telemetry"].includes(command)) {
+  import("./appHistory-WW56FZTT.js").then((mod) => {
+    _appHistoryNotice = mod.appHistoryNotice(process.cwd(), process.argv.slice(3));
+  }).catch(() => {
+  });
+}
+var commandStart = Date.now();
+var runId = getRunId();
+var finalized = false;
+async function finalizeCli(result) {
+  if (finalized) return;
+  finalized = true;
+  const exitCode = isRenderSucceeded() ? 0 : result.exitCode;
+  commandFailed ||= exitCode !== 0;
+  await telemetryReady.catch(() => {
+  });
+  _trackCommandResult?.({
+    command,
+    success: exitCode === 0 && commandSucceededForTelemetry(),
+    exitCode,
+    durationMs: Date.now() - commandStart,
+    runId
+  });
+  if (_appHistoryNotice) process.stderr.write(`\u25C7  ${_appHistoryNotice}
+`);
+  process.exitCode = exitCode;
+}
+registerRootExitRequester((exitCode) => {
+  void finalizeCli({
+    exitCode,
+    kind: exitCode === 0 ? "success" : "runtime_error",
+    presented: true
+  }).finally(async () => {
+    await outputWritten();
+    process.exit(exitCode);
+  });
+});
+registerRootExitCodeSanitizer(() => {
+  if (process.exitCode !== void 0 && process.exitCode !== 0) {
+    process.exitCode = 0;
+  }
+});
+process.on(
+  "exit",
+  // fallow-ignore-next-line complexity
+  (code) => {
+    if (!finalized) {
+      _trackCommandResult?.({
+        command,
+        success: code === 0 && commandSucceededForTelemetry(),
+        exitCode: code,
+        durationMs: Date.now() - commandStart,
+        runId
+      });
+    }
+    _flushSync?.();
+  }
+);
+function emitCliErrorEvent(kind, error) {
+  _trackCliError?.({
+    error_name: error.name,
+    error_message: error.message,
+    stack_trace: error.stack,
+    command,
+    kind
+  });
+}
+function reportPostRenderTerminationEvent(label, kind, error) {
+  process.stderr.write(
+    `  [hyperframes] Post-render ${label} (render already succeeded): ${error.message}
+`
+  );
+  emitCliErrorEvent(kind, error);
+}
+function exitAfterPostRenderTermination(label, kind, error) {
+  reportPostRenderTerminationEvent(label, kind, error);
+  _flushSync?.();
+  process.exit(0);
+}
+function handleStreamEpipe() {
+  if (!isRenderSucceeded()) commandFailed = true;
+  process.exit(0);
+}
+function commandSucceededForTelemetry() {
+  return !commandFailed || isRenderSucceeded();
+}
+function exitAfterCliFailure(kind, error) {
+  commandFailed = true;
+  emitCliErrorEvent(kind, error);
+  _flushSync?.();
+  process.exit(1);
+}
+process.on("uncaughtException", (error) => {
+  if (error.code === "EPIPE") {
+    handleStreamEpipe();
+  }
+  if (isRenderSucceeded()) {
+    exitAfterPostRenderTermination("uncaughtException", "uncaught_exception", error);
+  }
+  exitAfterCliFailure("uncaught_exception", error);
+});
+process.on("unhandledRejection", (reason) => {
+  const error = reason instanceof Error ? reason : new Error(String(reason));
+  if (isRenderSucceeded()) {
+    reportPostRenderTerminationEvent("unhandledRejection", "unhandled_rejection", error);
+    return;
+  }
+  commandFailed = true;
+  process.exitCode = 1;
+  emitCliErrorEvent("unhandled_rejection", error);
+});
+async function showUsage(cmd, parent) {
+  const { showUsage: impl } = await import("./help-VCB5X2HS.js");
+  return impl(cmd, parent);
+}
+async function showRequestedUsage() {
+  const requested = await resolveCommandUsage(main, argv);
+  return showUsage(requested.command, requested.parent);
+}
+function commandResultForError(error) {
+  if (error instanceof CliResultSignal) return error.result;
+  if (error instanceof CliUsageError || error instanceof CliRuntimeError) return error.result;
+  return { exitCode: 1, kind: "runtime_error" };
+}
+async function executeCli() {
+  let result = { exitCode: 0, kind: "success" };
+  try {
+    if (isHelp) await showRequestedUsage();
+    else await runCommand(main, { rawArgs: argv });
+  } catch (error) {
+    result = commandResultForError(error);
+    if (!(error instanceof CliResultSignal)) {
+      commandFailed = true;
+      await reportCommandFailure(command, error);
+      const typed = error instanceof CliUsageError || error instanceof CliRuntimeError;
+      if (error instanceof CliUsageError && !error.result.presented) await showRequestedUsage();
+      if (!typed || !error.result.presented) {
+        console.error(error instanceof Error ? error.message : String(error));
+      }
+    }
+  } finally {
+    const pending = consumeCommandResult();
+    if (pending.exitCode !== 0 || result.exitCode === 0) result = pending;
+    await finalizeCli(result);
+  }
+}
+await executeCli();