@vfrey/vfrey 0.0.1 → 1.0.0-beta.0

package/vendor/framey/dist/synthesize-PKTB5ATG.js

@@ -0,0 +1,183 @@
+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 {
+  DEFAULT_VOICE,
+  ensureModel,
+  ensureVoices,
+  inferLangFromVoiceId
+} from "./chunk-AHPGAESX.js";
+import {
+  findPython,
+  hasPythonPackage
+} from "./chunk-5ETJX6WM.js";
+import "./chunk-WQ6ZXHFQ.js";
+import {
+  writeNewFileSync
+} from "./chunk-4YYJOFKS.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/tts/synthesize.ts
+import { execFileSync } from "child_process";
+import { existsSync, mkdirSync, readdirSync, unlinkSync } from "fs";
+import { join, dirname, basename } from "path";
+import { homedir } from "os";
+var SYNTH_SCRIPT = `
+import sys, json, inspect, re
+
+model_path = sys.argv[1]
+voices_path = sys.argv[2]
+text = sys.argv[3]
+voice = sys.argv[4]
+speed = float(sys.argv[5])
+output_path = sys.argv[6]
+lang = sys.argv[7] if len(sys.argv) > 7 else ""
+
+import kokoro_onnx
+import soundfile as sf
+
+model = kokoro_onnx.Kokoro(model_path, voices_path)
+
+kwargs = {"voice": voice, "speed": speed}
+supports_lang = "lang" in inspect.signature(model.create).parameters
+if lang and supports_lang:
+    kwargs["lang"] = lang
+
+def is_voice_token_overflow(error):
+    return bool(re.search(
+        r"index \\d+ is out of bounds for axis 0 with size 510",
+        str(error),
+        re.IGNORECASE,
+    ))
+
+def split_for_retry(value):
+    midpoint = len(value) // 2
+    boundaries = [
+        index + 1
+        for index, char in enumerate(value)
+        if (char in "\u3002\uFF01\uFF1F!?\\n" or char.isspace()) and 0 < index < len(value) - 1
+    ]
+    split_at = min(boundaries, key=lambda index: abs(index - midpoint)) if boundaries else midpoint
+    return value[:split_at], value[split_at:]
+
+def synthesize_text(value):
+    try:
+        return model.create(value, **kwargs)
+    except IndexError as error:
+        if not is_voice_token_overflow(error) or len(value) < 2:
+            raise
+        left, right = split_for_retry(value)
+        left_samples, left_rate = synthesize_text(left)
+        right_samples, right_rate = synthesize_text(right)
+        if left_rate != right_rate:
+            raise RuntimeError("Kokoro returned inconsistent sample rates across text chunks")
+        samples = list(left_samples)
+        samples.extend(right_samples)
+        return samples, left_rate
+
+samples, sample_rate = synthesize_text(text)
+sf.write(output_path, samples, sample_rate)
+
+duration = len(samples) / sample_rate
+print(json.dumps({
+    "outputPath": output_path,
+    "sampleRate": sample_rate,
+    "durationSeconds": round(duration, 3),
+    "langApplied": bool(lang and supports_lang),
+}))
+`;
+var ESPEAK_LANG_OVERRIDES = {
+  zh: "cmn"
+};
+var SCRIPT_DIR = join(homedir(), ".cache", "hyperframes", "tts");
+var SCRIPT_PATH = join(SCRIPT_DIR, "synth-v3.py");
+function ensureSynthScript() {
+  if (!existsSync(SCRIPT_PATH)) {
+    mkdirSync(SCRIPT_DIR, { recursive: true });
+    writeNewFileSync(SCRIPT_PATH, SYNTH_SCRIPT);
+    const currentName = basename(SCRIPT_PATH);
+    try {
+      for (const entry of readdirSync(SCRIPT_DIR)) {
+        if (entry !== currentName && /^synth(-v\d+)?\.py$/.test(entry)) {
+          try {
+            unlinkSync(join(SCRIPT_DIR, entry));
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return SCRIPT_PATH;
+}
+async function synthesize(text, outputPath, options) {
+  const voice = options?.voice ?? DEFAULT_VOICE;
+  const speed = options?.speed ?? 1;
+  const lang = options?.lang ?? inferLangFromVoiceId(voice);
+  options?.onProgress?.("Checking Python runtime...");
+  const python = findPython();
+  if (!python) {
+    throw new Error(
+      "Python 3 is required for text-to-speech. Install Python 3.10+ and run: pip install kokoro-onnx soundfile (or point HYPERFRAMES_PYTHON at a venv python that has them)"
+    );
+  }
+  if (!hasPythonPackage(python, "kokoro_onnx")) {
+    throw new Error(
+      "The kokoro-onnx package is not installed. Run: pip install kokoro-onnx soundfile (or point HYPERFRAMES_PYTHON at a venv python that has them)"
+    );
+  }
+  if (!hasPythonPackage(python, "soundfile")) {
+    throw new Error("The soundfile package is not installed. Run: pip install soundfile");
+  }
+  const [modelPath, voicesPath] = await Promise.all([
+    ensureModel(options?.model, { onProgress: options?.onProgress }),
+    ensureVoices({ onProgress: options?.onProgress })
+  ]);
+  const scriptPath = ensureSynthScript();
+  mkdirSync(dirname(outputPath), { recursive: true });
+  options?.onProgress?.(`Generating speech with voice ${voice} (${lang})...`);
+  try {
+    const espeakLang = ESPEAK_LANG_OVERRIDES[lang] ?? lang;
+    const stdout = execFileSync(
+      python,
+      [scriptPath, modelPath, voicesPath, text, voice, String(speed), outputPath, espeakLang],
+      {
+        encoding: "utf-8",
+        timeout: 3e5,
+        stdio: ["pipe", "pipe", "pipe"],
+        env: { ...process.env, ORT_DISABLE_TELEMETRY: "1" }
+      }
+    );
+    if (!existsSync(outputPath)) {
+      throw new Error("Synthesis completed but no output file was created");
+    }
+    const lines = stdout.trim().split("\n");
+    const jsonLine = lines[lines.length - 1] ?? "";
+    const result = JSON.parse(jsonLine);
+    return {
+      outputPath: result.outputPath,
+      sampleRate: result.sampleRate,
+      durationSeconds: result.durationSeconds,
+      langApplied: result.langApplied
+    };
+  } catch (err) {
+    if (err instanceof SyntaxError && existsSync(outputPath)) {
+      throw new Error(
+        "Speech was generated but metadata could not be read. Check the output file manually."
+      );
+    }
+    let detail = "";
+    if (err && typeof err === "object" && "stderr" in err) {
+      const stderr = String(err.stderr).trim();
+      if (stderr) detail = `
+${stderr.slice(-500)}`;
+    }
+    throw new Error(`Speech synthesis failed${detail}`);
+  }
+}
+export {
+  synthesize
+};

package/vendor/framey/dist/system-7F3UEHQT.js

@@ -0,0 +1,27 @@
+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 {
+  bytesToMb,
+  getAvailableMemoryMb,
+  getFreeDiskMb,
+  getPowerState,
+  getShmSizeMb,
+  getSystemMeta,
+  parsePmsetPowerSource
+} from "./chunk-T6AGUTZJ.js";
+import "./chunk-XT6MXC7A.js";
+import "./chunk-W2LGJSEN.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  bytesToMb,
+  getAvailableMemoryMb,
+  getFreeDiskMb,
+  getPowerState,
+  getShmSizeMb,
+  getSystemMeta,
+  parsePmsetPowerSource
+};

package/vendor/framey/dist/telemetry-DQGPEKM6.js

@@ -0,0 +1,145 @@
+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 {
+  CONFIG_PATH,
+  STATE_PATH,
+  effectiveTelemetryStatus,
+  readConfigFresh,
+  writeConfigWithResult
+} from "./chunk-NYEXNSHM.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import "./chunk-ISN5GRYI.js";
+import {
+  c
+} from "./chunk-VORQIH64.js";
+import {
+  failCommand
+} from "./chunk-JVBRJMOP.js";
+import "./chunk-T2EUWCJE.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/telemetry.ts
+var examples = [
+  ["Check current telemetry status", "framey telemetry status"],
+  ["Disable telemetry", "framey telemetry disable"],
+  ["Enable telemetry", "framey telemetry enable"]
+];
+function describeOverride(source) {
+  switch (source) {
+    case "HYPERFRAMES_NO_TELEMETRY":
+    case "DO_NOT_TRACK":
+      return `${source} is set`;
+    case "dev_mode":
+      return "this is a development build";
+    case "not_opted_in":
+      return "it is off unless FRAMEY_TELEMETRY=1 and FRAMEY_POSTHOG_KEY are set";
+    case "telemetry_disabled_build":
+      return "this build has no telemetry key";
+  }
+}
+function setTelemetryEnabled(enabled) {
+  const config = readConfigFresh();
+  config.telemetryEnabled = enabled;
+  const result = writeConfigWithResult(config);
+  if (!result.ok) {
+    console.error(
+      `
+  ${c.error("\u2717")}  Could not persist telemetry preference to ${c.accent(CONFIG_PATH)}
+  ${c.dim("Reason:")} ${result.error}
+`
+    );
+    failCommand();
+  }
+  const effective = effectiveTelemetryStatus(enabled);
+  const preference = enabled ? c.success("enabled") : c.bold("disabled");
+  const noun = enabled && !effective.enabled ? "Telemetry preference" : "Telemetry";
+  console.log(`
+  ${c.success("\u2713")}  ${noun} ${preference}`);
+  if (effective.source !== "config") {
+    console.log(
+      `  ${c.dim("Note:")} Telemetry remains disabled because ${describeOverride(effective.source)}.`
+    );
+  }
+  console.log();
+}
+function runStatus() {
+  const config = readConfigFresh();
+  const effective = effectiveTelemetryStatus(config.telemetryEnabled);
+  const status = effective.enabled ? c.success("enabled") : c.dim("disabled");
+  console.log();
+  console.log(`  ${c.dim("Status:")}     ${status}`);
+  console.log(`  ${c.dim("Source:")}     ${effective.source}`);
+  console.log(`  ${c.dim("Config:")}     ${c.accent(CONFIG_PATH)}`);
+  console.log(`  ${c.dim("State:")}      ${c.accent(STATE_PATH)}`);
+  console.log(`  ${c.dim("Tracked commands:")} ${c.bold(String(config.commandCount))}`);
+  console.log();
+  console.log(`  ${c.dim("Disable:")}    ${c.accent("framey telemetry disable")}`);
+  console.log(
+    `  ${c.dim("Env var:")}    ${c.accent("HYPERFRAMES_NO_TELEMETRY=1")} ${c.dim("or")} ${c.accent("DO_NOT_TRACK=1")}`
+  );
+  console.log();
+}
+var telemetry_default = defineCommand({
+  meta: { name: "telemetry", description: "Manage anonymous usage telemetry" },
+  args: {
+    subcommand: {
+      type: "positional",
+      description: "Subcommand: enable, disable, status",
+      required: false
+    }
+  },
+  async run({ args }) {
+    const subcommand = args.subcommand;
+    if (!subcommand || subcommand === "") {
+      console.log(`
+${c.bold("framey telemetry")} ${c.dim("<subcommand>")}
+
+Manage anonymous usage data collection.
+
+${c.bold("SUBCOMMANDS:")}
+  ${c.accent("status")}    ${c.dim("Show current telemetry status")}
+  ${c.accent("enable")}    ${c.dim("Enable anonymous telemetry")}
+  ${c.accent("disable")}   ${c.dim("Disable anonymous telemetry")}
+
+${c.bold("WHAT WE COLLECT:")}
+  ${c.dim("\u2022")} Command names (init, render, preview, etc.)
+  ${c.dim("\u2022")} Render performance (duration, fps, quality)
+  ${c.dim("\u2022")} Template choices
+  ${c.dim("\u2022")} OS, architecture, Node.js version, CLI version
+
+${c.bold("WHAT WE DON'T COLLECT:")}
+  ${c.dim("\u2022")} File paths, project names, or video content
+  ${c.dim("\u2022")} IP addresses (discarded by our analytics provider)
+  ${c.dim("\u2022")} Any personally identifiable information
+
+${c.dim("You can also set")} ${c.accent("HYPERFRAMES_NO_TELEMETRY=1")} ${c.dim("or")} ${c.accent("DO_NOT_TRACK=1")} ${c.dim("to disable.")}
+`);
+      return;
+    }
+    switch (subcommand) {
+      case "enable":
+        return setTelemetryEnabled(true);
+      case "disable":
+        return setTelemetryEnabled(false);
+      case "status":
+        return runStatus();
+      default:
+        console.error(
+          `${c.error("Unknown subcommand:")} ${subcommand}
+
+Run ${c.accent("framey telemetry --help")} for usage.`
+        );
+        failCommand();
+    }
+  }
+});
+export {
+  telemetry_default as default,
+  examples
+};

package/vendor/framey/dist/telemetry-UN55N6U6.js

@@ -0,0 +1,77 @@
+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 {
+  identifyUser,
+  trackAuthLoginCompleted,
+  trackAuthLoginFailed,
+  trackAuthLoginStarted,
+  trackBrowserInstall,
+  trackCliError,
+  trackCommand,
+  trackCommandResult,
+  trackFigmaImport,
+  trackInitTemplate,
+  trackRenderComplete,
+  trackRenderError
+} from "./chunk-GNEFDLFB.js";
+import {
+  flush,
+  flushSync,
+  shouldTrack,
+  showTelemetryNotice,
+  trackEvent
+} from "./chunk-2UZQHDM7.js";
+import {
+  CONFIG_PATH,
+  incrementCommandCount,
+  readConfig,
+  writeConfig
+} from "./chunk-NYEXNSHM.js";
+import "./chunk-54HJ63Q2.js";
+import "./chunk-ISN5GRYI.js";
+import "./chunk-VORQIH64.js";
+import "./chunk-JVBRJMOP.js";
+import "./chunk-634HSJ3J.js";
+import "./chunk-FXMKHHPO.js";
+import "./chunk-AHX34EFP.js";
+import "./chunk-T2EUWCJE.js";
+import {
+  bytesToMb,
+  getFreeDiskMb,
+  getShmSizeMb,
+  getSystemMeta
+} from "./chunk-T6AGUTZJ.js";
+import "./chunk-XT6MXC7A.js";
+import "./chunk-W2LGJSEN.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  CONFIG_PATH,
+  bytesToMb,
+  flush,
+  flushSync,
+  getFreeDiskMb,
+  getShmSizeMb,
+  getSystemMeta,
+  identifyUser,
+  incrementCommandCount,
+  readConfig,
+  shouldTrack,
+  showTelemetryNotice,
+  trackAuthLoginCompleted,
+  trackAuthLoginFailed,
+  trackAuthLoginStarted,
+  trackBrowserInstall,
+  trackCliError,
+  trackCommand,
+  trackCommandResult,
+  trackEvent,
+  trackFigmaImport,
+  trackInitTemplate,
+  trackRenderComplete,
+  trackRenderError,
+  writeConfig
+};