@ignix-social/editor 0.1.0

package/vendor/hyperframes/dist/chunk-ZTZ7NCJT.js

@@ -0,0 +1,58 @@
+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 {
+  credentialPath,
+  deleteStore,
+  hasPreservedUnknownData,
+  readStore,
+  writeStore
+} from "./chunk-I465DBM6.js";
+
+// src/auth/user.ts
+function isUserInfoEmpty(u) {
+  return !u.email && !u.first_name && !u.last_name && !u.username;
+}
+function userDisplayName(u) {
+  if (u.email) return u.email;
+  const name = combineName(u.first_name, u.last_name);
+  if (name) return name;
+  return u.username || void 0;
+}
+function combineName(first, last) {
+  if (first && last) return `${first} ${last}`;
+  return first || last || "";
+}
+async function saveUserInfo(info, path = credentialPath()) {
+  if (isUserInfoEmpty(info)) return;
+  const { credentials } = await readStore(path);
+  credentials.user = { ...info };
+  await writeStore(credentials, path);
+}
+async function loadUserInfo(path = credentialPath()) {
+  const { credentials, source } = await readStore(path);
+  if (source === "absent") return null;
+  if (!credentials.user || isUserInfoEmpty(credentials.user)) return null;
+  return credentials.user;
+}
+async function clearUserInfo(path = credentialPath()) {
+  const { credentials, source } = await readStore(path);
+  if (source === "absent" || !credentials.user) return;
+  delete credentials.user;
+  if (!credentials.api_key && !credentials.oauth && !hasPreservedUnknownData(credentials)) {
+    await deleteStore(path);
+    return;
+  }
+  await writeStore(credentials, path);
+}
+
+export {
+  isUserInfoEmpty,
+  userDisplayName,
+  saveUserInfo,
+  loadUserInfo,
+  clearUserInfo
+};

package/vendor/hyperframes/dist/chunk-ZTZA4UWZ.js

@@ -0,0 +1,108 @@
+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 {
+  __commonJS,
+  __toESM
+} from "./chunk-M2WBOQ2Q.js";
+
+// ../../node_modules/.bun/picocolors@1.1.1/node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "../../node_modules/.bun/picocolors@1.1.1/node_modules/picocolors/picocolors.js"(exports, module) {
+    "use strict";
+    var p = process || {};
+    var argv = p.argv || [];
+    var env = p.env || {};
+    var isColorSupported2 = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+    var formatter = (open, close, replace = open) => (input) => {
+      let string = "" + input, index = string.indexOf(close, open.length);
+      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    };
+    var replaceClose = (string, close, replace, index) => {
+      let result = "", cursor = 0;
+      do {
+        result += string.substring(cursor, index) + replace;
+        cursor = index + close.length;
+        index = string.indexOf(close, cursor);
+      } while (~index);
+      return result + string.substring(cursor);
+    };
+    var createColors = (enabled = isColorSupported2) => {
+      let f = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: f("\x1B[0m", "\x1B[0m"),
+        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f("\x1B[3m", "\x1B[23m"),
+        underline: f("\x1B[4m", "\x1B[24m"),
+        inverse: f("\x1B[7m", "\x1B[27m"),
+        hidden: f("\x1B[8m", "\x1B[28m"),
+        strikethrough: f("\x1B[9m", "\x1B[29m"),
+        black: f("\x1B[30m", "\x1B[39m"),
+        red: f("\x1B[31m", "\x1B[39m"),
+        green: f("\x1B[32m", "\x1B[39m"),
+        yellow: f("\x1B[33m", "\x1B[39m"),
+        blue: f("\x1B[34m", "\x1B[39m"),
+        magenta: f("\x1B[35m", "\x1B[39m"),
+        cyan: f("\x1B[36m", "\x1B[39m"),
+        white: f("\x1B[37m", "\x1B[39m"),
+        gray: f("\x1B[90m", "\x1B[39m"),
+        bgBlack: f("\x1B[40m", "\x1B[49m"),
+        bgRed: f("\x1B[41m", "\x1B[49m"),
+        bgGreen: f("\x1B[42m", "\x1B[49m"),
+        bgYellow: f("\x1B[43m", "\x1B[49m"),
+        bgBlue: f("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f("\x1B[45m", "\x1B[49m"),
+        bgCyan: f("\x1B[46m", "\x1B[49m"),
+        bgWhite: f("\x1B[47m", "\x1B[49m"),
+        blackBright: f("\x1B[90m", "\x1B[39m"),
+        redBright: f("\x1B[91m", "\x1B[39m"),
+        greenBright: f("\x1B[92m", "\x1B[39m"),
+        yellowBright: f("\x1B[93m", "\x1B[39m"),
+        blueBright: f("\x1B[94m", "\x1B[39m"),
+        magentaBright: f("\x1B[95m", "\x1B[39m"),
+        cyanBright: f("\x1B[96m", "\x1B[39m"),
+        whiteBright: f("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+      };
+    };
+    module.exports = createColors();
+    module.exports.createColors = createColors;
+  }
+});
+
+// src/ui/colors.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+var isColorSupported = process.stdout.isTTY === true && !process.env["NO_COLOR"] && process.env["FORCE_COLOR"] !== "0";
+function wrap(fn) {
+  return isColorSupported ? fn : (s) => s;
+}
+var teal = (s) => `\x1B[38;2;60;230;172m${s}\x1B[39m`;
+var c = {
+  success: wrap(import_picocolors.default.green),
+  error: wrap(import_picocolors.default.red),
+  warn: wrap(import_picocolors.default.yellow),
+  dim: wrap(import_picocolors.default.dim),
+  bold: wrap(import_picocolors.default.bold),
+  accent: wrap(teal),
+  cyan: wrap(import_picocolors.default.cyan),
+  gray: wrap(import_picocolors.default.gray),
+  progress: wrap(import_picocolors.default.magenta),
+  reset: isColorSupported ? import_picocolors.default.reset : (s) => s
+};
+
+export {
+  isColorSupported,
+  c
+};

package/vendor/hyperframes/dist/clean-W57E5YQ3.js

@@ -0,0 +1,293 @@
+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 {
+  redactHome
+} from "./chunk-5IAKAQA7.js";
+import "./chunk-Z27A7NUB.js";
+import "./chunk-5ETJX6WM.js";
+import {
+  loadProducer
+} from "./chunk-3ZP5DXE7.js";
+import {
+  DEFAULT_HISTORY_ROOT,
+  listProjectHistories,
+  pruneGoneProjectHistories
+} from "./chunk-S7NPLFWV.js";
+import "./chunk-RMHUQGRK.js";
+import "./chunk-EOVYQ3IG.js";
+import "./chunk-QC4FJVLM.js";
+import {
+  CACHE_DIR_NAME,
+  cleanupProxyCache
+} from "./chunk-TCLGPL65.js";
+import {
+  formatBytes
+} from "./chunk-IHFUKJOR.js";
+import "./chunk-FCSIGXXP.js";
+import "./chunk-TVCRUG2S.js";
+import "./chunk-4NWOGZZS.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
+import "./chunk-IUZFXWSV.js";
+import "./chunk-AMKC3AXA.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import {
+  setCommandExitCode
+} from "./chunk-PBN6GBJE.js";
+import "./chunk-KC5XXX3X.js";
+import "./chunk-TJSTGSAW.js";
+import {
+  EXTRACT_CACHE_MIN_AGE_MS,
+  directorySizeBytes,
+  gcExtractionCache,
+  resolveExtractCacheDir
+} from "./chunk-K2FTXJYH.js";
+import "./chunk-2YN64IN5.js";
+import "./chunk-AVUUN2XD.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-Z6B37SNM.js";
+import "./chunk-HWKCIWQT.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-4PFZPP2N.js";
+import "./chunk-LCSMOLGX.js";
+import "./chunk-TWWSYAKJ.js";
+import "./chunk-ZJUKFZ2P.js";
+import "./chunk-HBBJFK6I.js";
+import "./chunk-PJ3HDUCY.js";
+import "./chunk-TQFG7HTI.js";
+import "./chunk-GK4AIFIH.js";
+import "./chunk-2PSPARWP.js";
+import {
+  withMeta
+} from "./chunk-HW6OYASV.js";
+import "./chunk-K4WIOZFP.js";
+import "./chunk-XUXGIA7H.js";
+import "./chunk-WERLJGIC.js";
+import "./chunk-ISN5GRYI.js";
+import "./chunk-FLWXXDNS.js";
+import "./chunk-KNU5COPB.js";
+import "./chunk-XT5P4QMO.js";
+import "./chunk-6BEFEWFB.js";
+import "./chunk-3GXQPCJC.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-PMRBLBUP.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/clean.ts
+import { existsSync, readFileSync, realpathSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join, resolve } from "path";
+var examples = [
+  ["See what HyperFrames left on disk, remove nothing", "hyperframes clean --dry-run"],
+  ["Remove it", "hyperframes clean"],
+  ["Also remove snapshot folders", "hyperframes clean --snapshots"],
+  ["For agents", "hyperframes clean --json"]
+];
+var OWNERLESS_IDLE_MS = 6 * 60 * 60 * 1e3;
+var PROXY_IDLE_MS = 60 * 60 * 1e3;
+function recordError(sweep, error) {
+  sweep.result.errors.push(error instanceof Error ? error.message : String(error));
+}
+async function attempt(sweep, step) {
+  try {
+    await step();
+  } catch (error) {
+    recordError(sweep, error);
+  }
+}
+function isProject(dir) {
+  try {
+    return readFileSync(join(dir, "index.html"), "utf-8").includes("data-composition-id");
+  } catch {
+    return false;
+  }
+}
+function realDir(dir) {
+  try {
+    return realpathSync(dir);
+  } catch {
+    return resolve(dir);
+  }
+}
+function knownProjectDirs(sweep, historyRoot) {
+  try {
+    return listProjectHistories(historyRoot).map((record) => record.projectDir);
+  } catch (error) {
+    recordError(sweep, error);
+    return [];
+  }
+}
+function drop(sweep, what, path) {
+  const bytes = directorySizeBytes(path);
+  try {
+    if (!sweep.dryRun)
+      rmSync(path, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+    sweep.result.removed.push({ what, path, bytes });
+  } catch (error) {
+    recordError(sweep, error);
+  }
+}
+function sweepProxies(sweep, project) {
+  const proxies = join(project, CACHE_DIR_NAME);
+  const swept = cleanupProxyCache(proxies, {
+    maxBytes: Number.POSITIVE_INFINITY,
+    maxIdleMs: PROXY_IDLE_MS,
+    minSweepIntervalMs: 0,
+    dryRun: sweep.dryRun
+  });
+  if (swept.removed.length === 0) return;
+  sweep.result.removed.push({
+    what: "Video proxies",
+    path: proxies,
+    bytes: swept.bytesBefore - swept.bytesAfter
+  });
+}
+function sweepSnapshots(sweep, project, remove) {
+  const snapshots = join(project, "snapshots");
+  if (!existsSync(snapshots)) return;
+  if (remove) drop(sweep, "Snapshots", snapshots);
+  else
+    sweep.result.alsoReclaimable.push({
+      what: "Snapshots",
+      path: snapshots,
+      bytes: directorySizeBytes(snapshots)
+    });
+}
+async function sweepHistories(sweep, historyRoot, tempDir) {
+  const pruned = await pruneGoneProjectHistories(historyRoot, {
+    dryRun: sweep.dryRun,
+    onError: (error) => recordError(sweep, error),
+    tempDir
+  });
+  for (const history of pruned) {
+    sweep.result.removed.push({
+      what: "Project history",
+      path: join(historyRoot, history.id),
+      bytes: history.bytes
+    });
+  }
+}
+function sweepExtractCache(sweep) {
+  const extractCache = resolveExtractCacheDir().dir;
+  if (!extractCache) return;
+  const swept = gcExtractionCache(extractCache, {
+    maxBytes: 0,
+    minAgeMs: EXTRACT_CACHE_MIN_AGE_MS,
+    dryRun: sweep.dryRun
+  });
+  if (swept.evictedEntries + swept.agedPartialsRemoved === 0) return;
+  sweep.result.removed.push({
+    what: "Extracted video frames",
+    path: extractCache,
+    bytes: swept.evictedBytes
+  });
+}
+async function cleanLeftovers(options) {
+  const historyRoot = options.historyRoot ?? DEFAULT_HISTORY_ROOT;
+  const tempDir = options.tempDir ?? tmpdir();
+  const { RENDER_JOB_DIR, listAbandonedRenderDirs, resolveRenderDebugDir } = await loadProducer();
+  const sweep = {
+    dryRun: options.dryRun,
+    result: { removed: [], alsoReclaimable: [], errors: [] }
+  };
+  const dropAbandoned = (what, parent, names) => {
+    for (const dir of listAbandonedRenderDirs(parent, {
+      ownerlessIdleMs: OWNERLESS_IDLE_MS,
+      names
+    }))
+      drop(sweep, what, dir);
+  };
+  const projects = new Set(
+    [options.projectDir, ...knownProjectDirs(sweep, historyRoot)].map(realDir)
+  );
+  const renderParents = /* @__PURE__ */ new Set([
+    ...[...projects].flatMap((project) => [project, join(project, "renders")]),
+    realDir(tempDir)
+  ]);
+  for (const parent of renderParents) dropAbandoned("Render leftovers", parent);
+  dropAbandoned("Debug renders", options.debugDir ?? resolveRenderDebugDir(), RENDER_JOB_DIR);
+  for (const project of projects) {
+    if (!isProject(project)) continue;
+    await attempt(sweep, () => sweepProxies(sweep, project));
+    sweepSnapshots(sweep, project, options.snapshots);
+  }
+  await attempt(sweep, () => sweepHistories(sweep, historyRoot, tempDir));
+  await attempt(sweep, () => sweepExtractCache(sweep));
+  return sweep.result;
+}
+function printTable(rows) {
+  const whatWidth = Math.max(...rows.map((row) => row.what.length));
+  for (const row of rows) {
+    console.log(
+      `  ${row.what.padEnd(whatWidth)}  ${formatBytes(row.bytes).padStart(9)}  ${c.dim(row.path)}`
+    );
+  }
+}
+var total = (rows) => rows.reduce((sum, row) => sum + row.bytes, 0);
+var redactPaths = (rows) => rows.map((row) => ({ ...row, path: redactHome(row.path) }));
+var clean_default = defineCommand({
+  meta: { name: "clean", description: "Find and remove what HyperFrames left on disk" },
+  args: {
+    dir: {
+      type: "positional",
+      description: "Project directory (default: current); its subfolders are not searched",
+      required: false
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "List what would be removed, remove nothing",
+      default: false
+    },
+    snapshots: { type: "boolean", description: "Also remove snapshots/ folders", default: false },
+    json: { type: "boolean", description: "Output as JSON", default: false }
+  },
+  async run({ args }) {
+    const dryRun = args["dry-run"];
+    const result = await cleanLeftovers({
+      projectDir: args.dir ?? process.cwd(),
+      dryRun,
+      snapshots: args.snapshots
+    });
+    if (result.errors.length > 0) setCommandExitCode(1);
+    if (args.json) {
+      const report = withMeta({
+        dryRun,
+        removed: redactPaths(result.removed),
+        alsoReclaimable: redactPaths(result.alsoReclaimable),
+        errors: result.errors.map(redactHome),
+        totalBytes: total(result.removed)
+      });
+      console.log(JSON.stringify(report, null, 2));
+      return;
+    }
+    if (result.removed.length === 0) {
+      console.log(`${c.success("\u25C7")}  Nothing to clean`);
+    } else {
+      console.log(
+        `${c.success("\u25C7")}  ${dryRun ? "Would remove" : "Removed"} ${formatBytes(total(result.removed))}`
+      );
+      printTable(result.removed);
+    }
+    if (result.alsoReclaimable.length > 0) {
+      console.log(
+        `
+   Also reclaimable with --snapshots: ${formatBytes(total(result.alsoReclaimable))}`
+      );
+      printTable(result.alsoReclaimable);
+    }
+    for (const error of result.errors) console.log(c.warn(`  ${error}`));
+  }
+});
+export {
+  cleanLeftovers,
+  clean_default as default,
+  examples
+};