@ignix-social/editor 0.1.0

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

@@ -0,0 +1,39 @@
+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 {
+  FEEDBACK_EMAIL_ENV
+} from "./chunk-IGLEPPTN.js";
+
+// src/utils/dotEnv.ts
+function valueOf(raw) {
+  const quote = raw.charAt(0);
+  if (quote === '"' || quote === "'") {
+    const end = raw.indexOf(quote, 1);
+    return end > 0 ? raw.slice(1, end) : raw.slice(1);
+  }
+  const comment = raw.match(/\s+#/);
+  return comment?.index === void 0 ? raw : raw.slice(0, comment.index).trim();
+}
+function entryOf(rawLine) {
+  let line = rawLine.trim();
+  if (!line || line.startsWith("#")) return null;
+  if (line.startsWith("export ")) line = line.slice(7).trim();
+  const eq = line.indexOf("=");
+  if (eq < 1) return null;
+  return [line.slice(0, eq).trim(), valueOf(line.slice(eq + 1).trim())];
+}
+function applyDotEnv(content, env) {
+  for (const entry of content.split("\n").map(entryOf)) {
+    if (!entry) continue;
+    const [key, value] = entry;
+    if (key && key.toUpperCase() !== FEEDBACK_EMAIL_ENV && !(key in env)) env[key] = value;
+  }
+}
+
+export {
+  applyDotEnv
+};

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

@@ -0,0 +1,43 @@
+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);
+
+// src/utils/runningCli.ts
+import { mkdirSync, 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 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 });
+    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 {
+  }
+}
+
+export {
+  RUNNING_DIR,
+  RUNNING_STALE_MS,
+  registerRunningCli
+};

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

@@ -0,0 +1,192 @@
+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 {
+  downloadFile
+} from "./chunk-X5HWXQPU.js";
+import {
+  findFFmpeg
+} from "./chunk-TVCRUG2S.js";
+
+// src/whisper/manager.ts
+import { execFileSync } from "child_process";
+import { existsSync, mkdirSync, rmSync } from "fs";
+import { homedir, platform } from "os";
+import { join } from "path";
+var MODELS_DIR = join(homedir(), ".cache", "hyperframes", "whisper", "models");
+var DEFAULT_MODEL = "small.en";
+var WhisperUnavailableError = class extends Error {
+  code = "WHISPER_UNAVAILABLE";
+  constructor(message) {
+    super(message);
+    this.name = "WhisperUnavailableError";
+  }
+};
+function isWhisperUnavailable(err) {
+  if (err instanceof WhisperUnavailableError) return true;
+  return err instanceof Error && "code" in err && err.code === "WHISPER_UNAVAILABLE";
+}
+function getModelUrl(model) {
+  return `https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-${model}.bin`;
+}
+function whichBinary(name) {
+  try {
+    const cmd = process.platform === "win32" ? "where" : "which";
+    const output = execFileSync(cmd, [name], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 5e3
+    });
+    const first = output.split(/\r?\n/).map((s) => s.trim()).find(Boolean);
+    return first || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function findFromEnv() {
+  const envPath = process.env["HYPERFRAMES_WHISPER_PATH"];
+  if (envPath && existsSync(envPath)) {
+    return { executablePath: envPath, source: "env" };
+  }
+  return void 0;
+}
+function findFromSystem() {
+  const path = whichBinary("whisper-cli");
+  if (path) return { executablePath: path, source: "system" };
+  if (platform() === "darwin") {
+    for (const p of ["/opt/homebrew/bin/whisper-cli", "/usr/local/bin/whisper-cli"]) {
+      if (existsSync(p)) return { executablePath: p, source: "system" };
+    }
+  }
+  return void 0;
+}
+var BUILD_DIR = join(homedir(), ".cache", "hyperframes", "whisper", "whisper.cpp");
+var WHISPER_REPO = "https://github.com/ggml-org/whisper.cpp.git";
+function findBuiltBinary() {
+  for (const p of [
+    join(BUILD_DIR, "build", "bin", "whisper-cli"),
+    join(BUILD_DIR, "build", "whisper-cli")
+  ]) {
+    if (existsSync(p)) return { executablePath: p, source: "build" };
+  }
+  return void 0;
+}
+function buildFromSource(onProgress) {
+  if (existsSync(BUILD_DIR) && !findBuiltBinary()) {
+    rmSync(BUILD_DIR, { recursive: true, force: true });
+  }
+  if (!existsSync(BUILD_DIR)) {
+    onProgress?.("Downloading whisper.cpp...");
+    mkdirSync(join(homedir(), ".cache", "hyperframes", "whisper"), {
+      recursive: true
+    });
+    execFileSync("git", ["clone", "--depth", "1", WHISPER_REPO, BUILD_DIR], {
+      stdio: "ignore",
+      timeout: 6e4,
+      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+    });
+  }
+  onProgress?.("Building whisper.cpp (this may take a minute)...");
+  try {
+    execFileSync("cmake", ["-B", "build"], {
+      cwd: BUILD_DIR,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 12e4
+    });
+    execFileSync("cmake", ["--build", "build", "--config", "Release", "-j"], {
+      cwd: BUILD_DIR,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 3e5
+    });
+  } catch (err) {
+    let detail = "";
+    if (err && typeof err === "object" && "stderr" in err) {
+      const stderr = String(err.stderr).trim();
+      if (stderr) detail = `
+${stderr.slice(-500)}`;
+    }
+    rmSync(BUILD_DIR, { recursive: true, force: true });
+    throw new Error(
+      `whisper-cpp build failed. Ensure cmake and a C compiler are installed.${detail}`
+    );
+  }
+  const result = findBuiltBinary();
+  if (!result) throw new Error("Build completed but whisper-cli not found");
+  return result;
+}
+function findWhisper() {
+  return findFromEnv() ?? findFromSystem() ?? findBuiltBinary();
+}
+function getInstallInstructions() {
+  if (platform() === "darwin") {
+    return "brew install whisper-cpp";
+  }
+  if (platform() === "linux") {
+    return "Build from source: https://github.com/ggml-org/whisper.cpp#building (requires cmake and a C compiler)";
+  }
+  if (platform() === "win32") {
+    return "Build with cmake: https://github.com/ggml-org/whisper.cpp#building";
+  }
+  return "See https://github.com/ggml-org/whisper.cpp#building";
+}
+function hasBrew() {
+  return whichBinary("brew") !== void 0;
+}
+function hasGit() {
+  return whichBinary("git") !== void 0;
+}
+function hasCmake() {
+  return whichBinary("cmake") !== void 0;
+}
+async function ensureWhisper(options) {
+  const existing = findWhisper();
+  if (existing) return existing;
+  if (platform() === "darwin" && hasBrew()) {
+    options?.onProgress?.("Installing whisper-cpp via Homebrew...");
+    try {
+      execFileSync("brew", ["install", "whisper-cpp"], {
+        stdio: "ignore",
+        timeout: 3e5
+      });
+      const installed = findFromSystem();
+      if (installed) return { ...installed, source: "brew" };
+    } catch {
+    }
+  }
+  if (hasGit() && hasCmake()) {
+    try {
+      return buildFromSource(options?.onProgress);
+    } catch {
+    }
+  }
+  throw new WhisperUnavailableError(`whisper-cpp not found. Install: ${getInstallInstructions()}`);
+}
+async function ensureModel(model = DEFAULT_MODEL, options) {
+  const modelPath = join(MODELS_DIR, `ggml-${model}.bin`);
+  if (existsSync(modelPath)) return modelPath;
+  mkdirSync(MODELS_DIR, { recursive: true });
+  options?.onProgress?.(`Downloading model ${model}...`);
+  await downloadFile(getModelUrl(model), modelPath);
+  if (!existsSync(modelPath)) {
+    throw new Error(`Model download failed: ${model}`);
+  }
+  return modelPath;
+}
+function hasFFmpeg() {
+  return findFFmpeg() !== void 0;
+}
+
+export {
+  MODELS_DIR,
+  DEFAULT_MODEL,
+  WhisperUnavailableError,
+  isWhisperUnavailable,
+  findWhisper,
+  getInstallInstructions,
+  ensureWhisper,
+  ensureModel,
+  hasFFmpeg
+};

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

@@ -0,0 +1,117 @@
+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);
+
+// ../core/dist/safePath.js
+import { resolve, sep, join, dirname, basename, relative, isAbsolute } from "path";
+import { lstatSync, mkdirSync, realpathSync, statSync } from "fs";
+function realpath(path) {
+  try {
+    return realpathSync.native(path);
+  } catch (error) {
+    if (error.code === "EISDIR")
+      return realpathSync(path);
+    throw error;
+  }
+}
+function isMissingPath(path) {
+  try {
+    lstatSync(path);
+    return false;
+  } catch (error) {
+    return Boolean(error && typeof error === "object" && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR"));
+  }
+}
+function isSafePath(base, resolved) {
+  let baseReal;
+  try {
+    baseReal = realpath(resolve(base));
+  } catch {
+    return false;
+  }
+  const target = resolve(resolved);
+  const trailing = [];
+  let probe = target;
+  for (; ; ) {
+    let ancestorReal;
+    try {
+      ancestorReal = realpath(probe);
+    } catch {
+      if (!isMissingPath(probe))
+        return false;
+      const parent = dirname(probe);
+      if (parent === probe)
+        return false;
+      trailing.push(basename(probe));
+      probe = parent;
+      continue;
+    }
+    const targetReal = trailing.length ? join(ancestorReal, ...[...trailing].reverse()) : ancestorReal;
+    return targetReal === baseReal || targetReal.startsWith(baseReal + sep);
+  }
+}
+function resolveWithinProject(base, relativePath) {
+  const resolved = resolve(base, relativePath);
+  return isSafePath(base, resolved) ? resolved : null;
+}
+var ProjectRootMissingError = class extends Error {
+  root;
+  constructor(root) {
+    super(`Project folder not found: ${root}`);
+    this.root = root;
+    this.name = "ProjectRootMissingError";
+  }
+};
+var isProjectRootMissing = (error) => error instanceof Error && error.name === "ProjectRootMissingError";
+function folderGone(dir) {
+  try {
+    return !statSync(dir, { throwIfNoEntry: false });
+  } catch {
+    return false;
+  }
+}
+function realProjectRoot(root) {
+  try {
+    return realpath(root);
+  } catch (error) {
+    if (folderGone(root))
+      throw new ProjectRootMissingError(root);
+    throw error;
+  }
+}
+function mkdirWithinProject(root, dir) {
+  if (folderGone(root))
+    throw new ProjectRootMissingError(root);
+  const inside = relative(resolve(root), resolve(dir));
+  if (inside === ".." || inside.startsWith(`..${sep}`) || isAbsolute(inside)) {
+    mkdirSync(dir, { recursive: true });
+    return;
+  }
+  let path = resolve(root);
+  for (const part of inside.split(sep).filter(Boolean)) {
+    path = join(path, part);
+    try {
+      mkdirSync(path);
+    } catch (error) {
+      const code = error.code;
+      if (code === "ENOENT" && folderGone(root))
+        throw new ProjectRootMissingError(root);
+      if (code !== "EEXIST")
+        throw error;
+    }
+  }
+}
+
+export {
+  realpath,
+  isSafePath,
+  resolveWithinProject,
+  ProjectRootMissingError,
+  isProjectRootMissing,
+  folderGone,
+  realProjectRoot,
+  mkdirWithinProject
+};