@ignix-social/editor 0.1.0

package/vendor/hyperframes/dist/login-NTX4OWXL.js

@@ -0,0 +1,377 @@
+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 {
+  clearUserInfo,
+  isUserInfoEmpty,
+  saveUserInfo,
+  userDisplayName
+} from "./chunk-ZTZ7NCJT.js";
+import {
+  AuthClient,
+  assertOAuthConfiguredOrExit,
+  deleteStore,
+  hasPreservedUnknownData,
+  isAuthError,
+  isHeaderSafe,
+  persistVerifiedOAuthSession,
+  readStore,
+  refreshTokens,
+  revokeTokens,
+  startAuthorizationCodeFlow,
+  startDeviceAuthorizationFlow,
+  tryResolveCredential,
+  writeStore
+} from "./chunk-I465DBM6.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import {
+  failCommand,
+  failUsage
+} from "./chunk-PBN6GBJE.js";
+import {
+  envFlagEnabled,
+  isAttendedTerminal
+} from "./chunk-WERLJGIC.js";
+import "./chunk-KNU5COPB.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/auth/login.ts
+import { stdin as input } from "process";
+var STDIN_TIMEOUT_MS = 3e4;
+var MIN_KEY_LENGTH = 8;
+var login_default = defineCommand({
+  meta: {
+    name: "login",
+    description: "Sign in to HeyGen (OAuth by default; --api-key for long-lived keys)"
+  },
+  args: {
+    "api-key": {
+      type: "string",
+      description: "API key value, or pass `--api-key` with no value to read from stdin / prompt."
+    },
+    device: {
+      type: "boolean",
+      description: "Use an attended device code (for SSH/headless terminals; never for CI)."
+    }
+  },
+  // fallow-ignore-next-line complexity
+  async run({ args }) {
+    const inlineKey = args["api-key"];
+    if (inlineKey !== void 0 && args.device) {
+      console.error(c.error("Choose either --device or --api-key, not both."));
+      failUsage();
+    }
+    if (inlineKey !== void 0) {
+      await runApiKeyLogin(inlineKey);
+      return;
+    }
+    if (args.device) {
+      await runDeviceLogin();
+      return;
+    }
+    if (isRemoteOrHeadless()) {
+      console.error(
+        c.error(
+          "Browser callback login is unavailable in this remote/headless terminal. Run `hyperframes auth login --device`."
+        )
+      );
+      failUsage();
+    }
+    await runOAuthLogin();
+  }
+});
+function isRemoteOrHeadless() {
+  const remoteEnvironment = [
+    "CODESPACES",
+    "GITHUB_CODESPACES",
+    "REMOTE_CONTAINERS",
+    "GITPOD_WORKSPACE_ID",
+    "container"
+  ].some(envFlagEnabled);
+  return Boolean(
+    process.env["SSH_CONNECTION"] || process.env["SSH_CLIENT"] || process.env["SSH_TTY"] || process.env["BROWSER"] === "none" || process.env["HF_NO_BROWSER"] === "1" || remoteEnvironment || process.stdout.isTTY !== true
+  );
+}
+function assertAttendedDeviceFlow() {
+  if (!isAttendedTerminal()) {
+    console.error(
+      c.error(
+        "`--device` requires an attended terminal and is disabled in CI. Use an API key or workload credential for automation."
+      )
+    );
+    failUsage();
+  }
+}
+async function runDeviceLogin() {
+  assertAttendedDeviceFlow();
+  assertOAuthConfiguredOrExit();
+  const { trackAuthLoginStarted, trackAuthLoginCompleted, trackAuthLoginFailed, identifyUser } = await import("./telemetry-QMYM4WME.js");
+  trackAuthLoginStarted("device");
+  let tokens;
+  try {
+    tokens = await startDeviceAuthorizationFlow({
+      onChallenge: ({ verificationUri, verificationUriComplete, userCode }) => {
+        console.log(`Open ${c.accent(verificationUriComplete ?? verificationUri)} in a browser.`);
+        if (!verificationUriComplete) console.log(`Enter code ${c.bold(userCode)}.`);
+        console.log(c.dim("Waiting for approval\u2026"));
+      }
+    });
+  } catch (err) {
+    const message = err.message || "Device authorization failed.";
+    trackAuthLoginFailed("device", /expired/i.test(message) ? "flow_timeout" : "flow_error");
+    console.error(c.error(message));
+    failCommand();
+  }
+  const credential = {
+    type: "oauth",
+    access_token: tokens.access_token,
+    ...tokens.refresh_token ? { refresh_token: tokens.refresh_token } : {},
+    source: "file_json",
+    refreshable: false
+  };
+  let user;
+  try {
+    user = await new AuthClient().getCurrentUser(credential);
+  } catch (err) {
+    await revokeDeviceTokens(tokens);
+    trackAuthLoginFailed("device", "rejected");
+    console.error(
+      c.error(
+        `HeyGen could not verify the approved device session; no credential was saved. ${err.message}`
+      )
+    );
+    failCommand();
+  }
+  try {
+    await persistVerifiedOAuthSession(tokens, toStoredUserInfo(user));
+  } catch (err) {
+    await revokeDeviceTokens(tokens);
+    trackAuthLoginFailed("device", "flow_error");
+    console.error(
+      c.error(
+        `Could not save the verified device session; it was revoked. ${err.message}`
+      )
+    );
+    failCommand();
+  }
+  const id = identityKey(user);
+  if (id) identifyUser(id);
+  trackAuthLoginCompleted("device", id);
+  const identity = userDisplayName(toStoredUserInfo(user)) ?? "(unknown user)";
+  console.log(c.success(`\u2713 Signed in as ${identity}.`));
+}
+async function revokeDeviceTokens(tokens) {
+  await revokeTokens(tokens.access_token, { token_type_hint: "access_token" });
+  if (tokens.refresh_token) {
+    await revokeTokens(tokens.refresh_token, {
+      token_type_hint: "refresh_token"
+    });
+  }
+}
+async function runOAuthLogin() {
+  assertOAuthConfiguredOrExit();
+  const { trackAuthLoginStarted, trackAuthLoginFailed } = await import("./telemetry-QMYM4WME.js");
+  trackAuthLoginStarted("oauth");
+  try {
+    await startAuthorizationCodeFlow();
+  } catch (err) {
+    const message = err.message ?? "";
+    trackAuthLoginFailed("oauth", /timed out/i.test(message) ? "flow_timeout" : "flow_error");
+    console.error(c.error(`Sign-in failed: ${message}`));
+    failCommand();
+  }
+  await reportIdentity();
+}
+async function reportIdentity() {
+  const { trackAuthLoginCompleted, trackAuthLoginFailed, identifyUser } = await import("./telemetry-QMYM4WME.js");
+  const credential = await tryResolveCredential();
+  if (!credential) {
+    trackAuthLoginFailed("oauth", "no_credential");
+    console.error(c.warn("Sign-in completed but no credential was persisted."));
+    failCommand();
+  }
+  const client = new AuthClient({
+    onUnauthenticatedRefresh: async (rt) => await refreshTokens(rt)
+  });
+  try {
+    const user = await client.getCurrentUser(credential);
+    await persistUserInfo(user);
+    const id = identityKey(user);
+    if (id) identifyUser(id);
+    trackAuthLoginCompleted("oauth", id);
+    const identity = userDisplayName(toStoredUserInfo(user)) ?? "(unknown user)";
+    console.log(c.success(`\u2713 Signed in as ${identity}.`));
+  } catch (err) {
+    await clearUserInfoBestEffort();
+    trackAuthLoginCompleted("oauth");
+    console.error(
+      c.warn(`Signed in. Identity check failed (transient): ${err.message}`)
+    );
+  }
+}
+function identityKey(user) {
+  return user.email ?? user.username;
+}
+function toStoredUserInfo(user) {
+  const out = {};
+  if (user.email) out.email = user.email;
+  if (user.first_name) out.first_name = user.first_name;
+  if (user.last_name) out.last_name = user.last_name;
+  if (user.username) out.username = user.username;
+  return out;
+}
+async function persistUserInfo(user) {
+  const stored = toStoredUserInfo(user);
+  try {
+    if (isUserInfoEmpty(stored)) {
+      await clearUserInfo();
+    } else {
+      await saveUserInfo(stored);
+    }
+  } catch (err) {
+    console.error(c.dim(`(warning: could not persist user info: ${err.message})`));
+  }
+}
+async function clearUserInfoBestEffort() {
+  try {
+    await clearUserInfo();
+  } catch (err) {
+    console.error(c.dim(`(warning: could not clear stale user info: ${err.message})`));
+  }
+}
+async function runApiKeyLogin(inlineKey) {
+  const { trackAuthLoginStarted, trackAuthLoginCompleted, trackAuthLoginFailed, identifyUser } = await import("./telemetry-QMYM4WME.js");
+  trackAuthLoginStarted("api_key");
+  let key;
+  try {
+    key = await collectApiKey(inlineKey);
+  } catch (err) {
+    trackAuthLoginFailed("api_key", "aborted");
+    console.error(c.error(err.message || "Sign-in aborted."));
+    failCommand();
+  }
+  if (!key) {
+    trackAuthLoginFailed("api_key", "invalid_input");
+    console.error(c.error("No API key provided."));
+    failCommand();
+  }
+  if (!isHeaderSafe(key)) {
+    trackAuthLoginFailed("api_key", "invalid_input");
+    console.error(c.error("API key must not contain newline or control characters."));
+    failCommand();
+  }
+  if (key.length < MIN_KEY_LENGTH) {
+    trackAuthLoginFailed("api_key", "invalid_input");
+    console.error(c.error(`API key looks too short (got ${key.length} chars).`));
+    failCommand();
+  }
+  const previous = await snapshotStore();
+  const next = { ...previous, api_key: key };
+  await writeStore(next);
+  const user = await verifyAndReport(key);
+  if (!user) {
+    trackAuthLoginFailed("api_key", "rejected");
+    await rollback(previous);
+    failCommand();
+  }
+  const id = identityKey(user);
+  if (id) identifyUser(id);
+  trackAuthLoginCompleted("api_key", id);
+}
+async function snapshotStore() {
+  try {
+    const { credentials } = await readStore();
+    return { ...credentials };
+  } catch {
+    return {};
+  }
+}
+async function rollback(previous) {
+  try {
+    if (previous.api_key || previous.oauth || hasPreservedUnknownData(previous)) {
+      await writeStore(previous);
+      console.error(c.dim("Rolled back to the previous credential."));
+    } else {
+      await deleteStore();
+      console.error(c.dim("Removed the rejected credential."));
+    }
+  } catch (err) {
+    console.error(c.error(`Failed to roll back: ${err.message}`));
+  }
+}
+async function verifyAndReport(key) {
+  const client = new AuthClient();
+  try {
+    const user = await client.getCurrentUser({
+      type: "api_key",
+      key,
+      source: "file_json"
+    });
+    await persistUserInfo(user);
+    const identity = userDisplayName(toStoredUserInfo(user)) ?? "(unknown user)";
+    console.log(c.success(`\u2713 API key saved. Authenticated as ${identity}.`));
+    return user;
+  } catch (err) {
+    if (isAuthError(err) && err.code === "UNAUTHENTICATED") {
+      console.error(
+        `${c.warn("HeyGen rejected the API key.")}
+  ${c.dim(err.message)}
+Run ${c.accent("hyperframes auth login --api-key")} again with a valid key.`
+      );
+      return null;
+    }
+    throw err;
+  }
+}
+async function collectApiKey(inline) {
+  if (inline.length > 0) return inline.trim();
+  if (!input.isTTY) {
+    return (await readAllWithTimeout(input, STDIN_TIMEOUT_MS)).trim();
+  }
+  return await promptForKey();
+}
+async function readAllWithTimeout(stream, timeoutMs) {
+  return await new Promise((resolve, reject) => {
+    const chunks = [];
+    const timer = setTimeout(() => {
+      reject(new Error(`Timed out waiting for stdin (${timeoutMs}ms). Pipe the key explicitly.`));
+    }, timeoutMs);
+    stream.on("data", (chunk) => {
+      chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    });
+    stream.on("end", () => {
+      clearTimeout(timer);
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    });
+    stream.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+async function promptForKey() {
+  const clack = await import("./dist-EWXJGN63.js");
+  const value = await clack.password({
+    message: "Enter HeyGen API key",
+    validate: (v) => {
+      if (!v || v.length < MIN_KEY_LENGTH) return "API key looks too short";
+      if (!isHeaderSafe(v)) return "API key must not contain newline or control characters";
+      return void 0;
+    }
+  });
+  if (clack.isCancel(value)) {
+    throw new Error("Aborted.");
+  }
+  return value.trim();
+}
+export {
+  login_default as default
+};

package/vendor/hyperframes/dist/logout-Q654A3SI.js

@@ -0,0 +1,100 @@
+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 "./chunk-ZTZ7NCJT.js";
+import {
+  clearOAuth,
+  configDir,
+  credentialPath,
+  deleteStore,
+  readStore,
+  revokeTokens
+} from "./chunk-I465DBM6.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import {
+  failCommand
+} from "./chunk-PBN6GBJE.js";
+import "./chunk-KNU5COPB.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/auth/logout.ts
+var logout_default = defineCommand({
+  meta: { name: "logout", description: "Remove the stored HeyGen credential" },
+  args: {
+    "keep-api-key": {
+      type: "boolean",
+      description: "Only clear the OAuth session; preserve the API key.",
+      default: false
+    },
+    yes: {
+      type: "boolean",
+      description: "Skip the confirmation prompt.",
+      default: false
+    }
+  },
+  async run({ args }) {
+    warnIfEnvCredentialActive();
+    const keepApiKey = Boolean(args["keep-api-key"]);
+    if (!await ensureConfirmed(Boolean(args.yes), keepApiKey)) {
+      console.log("Aborted.");
+      failCommand();
+    }
+    await bestEffortRevoke();
+    if (keepApiKey) {
+      await clearOAuth();
+      console.log(c.success("\u2713 OAuth session removed. API key retained."));
+      return;
+    }
+    await deleteStore();
+    console.log(c.success(`\u2713 Signed out. Removed ${credentialPath()}.`));
+  }
+});
+function warnIfEnvCredentialActive() {
+  if (process.env["HEYGEN_API_KEY"] || process.env["HYPERFRAMES_API_KEY"]) {
+    console.log(
+      c.warn(
+        "An env-var credential is active. Unset HEYGEN_API_KEY / HYPERFRAMES_API_KEY to remove it."
+      )
+    );
+  }
+}
+async function ensureConfirmed(yes, keepApiKey) {
+  if (yes) return true;
+  const prompt = keepApiKey ? `This will sign out of any active OAuth session on this machine (~/.heygen lives at ${configDir()}). Continue? [y/N] ` : `This will sign out of HeyGen on this machine (~/.heygen lives at ${configDir()}). Continue? [y/N] `;
+  return confirmInteractive(prompt);
+}
+async function bestEffortRevoke() {
+  try {
+    const { credentials, source } = await readStore();
+    if (source === "absent" || !credentials.oauth) return;
+    const { access_token, refresh_token } = credentials.oauth;
+    if (refresh_token) {
+      await revokeTokens(refresh_token, { token_type_hint: "refresh_token" });
+    }
+    if (access_token) {
+      await revokeTokens(access_token, { token_type_hint: "access_token" });
+    }
+  } catch {
+  }
+}
+async function confirmInteractive(prompt) {
+  if (!process.stdin.isTTY) return false;
+  const { createInterface } = await import("readline");
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise((resolve) => {
+    rl.question(prompt, (line) => resolve(line));
+  });
+  rl.close();
+  return /^y(es)?$/i.test(answer.trim());
+}
+export {
+  logout_default as default
+};

package/vendor/hyperframes/dist/manager-67P2XFXQ.js

@@ -0,0 +1,34 @@
+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_MODEL,
+  MODELS_DIR,
+  WhisperUnavailableError,
+  ensureModel,
+  ensureWhisper,
+  findWhisper,
+  getInstallInstructions,
+  hasFFmpeg,
+  isWhisperUnavailable
+} from "./chunk-OAF4XJOW.js";
+import "./chunk-X5HWXQPU.js";
+import "./chunk-TVCRUG2S.js";
+import "./chunk-AMKC3AXA.js";
+import "./chunk-LCSMOLGX.js";
+import "./chunk-PJ3HDUCY.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  DEFAULT_MODEL,
+  MODELS_DIR,
+  WhisperUnavailableError,
+  ensureModel,
+  ensureWhisper,
+  findWhisper,
+  getInstallInstructions,
+  hasFFmpeg,
+  isWhisperUnavailable
+};

package/vendor/hyperframes/dist/manager-CT3D67CG.js

@@ -0,0 +1,38 @@
+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 {
+  CACHE_DIR,
+  _resetSystemFallbackWarnForTests,
+  clearBrowser,
+  ensureBrowser,
+  findBrowser,
+  findSystemBrowser,
+  installWithCorruptArchiveRecovery,
+  isCorruptArchiveError,
+  isLinuxArm,
+  managedChromeVersion,
+  releaseOwnedBrowserInstallLock,
+  withInstallLock
+} from "./chunk-4PFZPP2N.js";
+import "./chunk-LCSMOLGX.js";
+import "./chunk-TWWSYAKJ.js";
+import "./chunk-KNU5COPB.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  CACHE_DIR,
+  _resetSystemFallbackWarnForTests,
+  clearBrowser,
+  ensureBrowser,
+  findBrowser,
+  findSystemBrowser,
+  installWithCorruptArchiveRecovery,
+  isCorruptArchiveError,
+  isLinuxArm,
+  managedChromeVersion,
+  releaseOwnedBrowserInstallLock,
+  withInstallLock
+};

package/vendor/hyperframes/dist/manager-GFN75DM4.js

@@ -0,0 +1,30 @@
+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_MODEL,
+  DEVICES,
+  MODELS_DIR,
+  MODEL_MEMORY_MB,
+  ensureModel,
+  isDevice,
+  listAvailableProviders,
+  modelPath,
+  selectProviders
+} from "./chunk-2EAXUCCE.js";
+import "./chunk-X5HWXQPU.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  DEFAULT_MODEL,
+  DEVICES,
+  MODELS_DIR,
+  MODEL_MEMORY_MB,
+  ensureModel,
+  isDevice,
+  listAvailableProviders,
+  modelPath,
+  selectProviders
+};