@vfrey/vfrey 0.0.1 → 1.0.0-beta.1

package/vendor/framey/dist/deploy-6FJPWKF2.js

@@ -0,0 +1,299 @@
+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 {
+  isMissingPackageError
+} from "./chunk-RVZHGOGR.js";
+import {
+  repoRoot
+} from "./chunk-2X4PQEYM.js";
+import {
+  fetchStackOutputs,
+  locateSamTemplate,
+  samDeploy
+} from "./chunk-HEFQCIXR.js";
+import {
+  DEFAULT_STACK_NAME,
+  readStackOutputs,
+  writeStackOutputs
+} from "./chunk-3FYD4YEK.js";
+import {
+  downloadFile
+} from "./chunk-WQ6ZXHFQ.js";
+import {
+  c
+} from "./chunk-VORQIH64.js";
+import "./chunk-JVBRJMOP.js";
+import {
+  VERSION
+} from "./chunk-AHX34EFP.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/lambda/deploy.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { dirname as dirname2, join as join3, resolve } from "path";
+
+// src/commands/lambda/prebuiltHandler.ts
+import { createHash } from "crypto";
+import {
+  copyFileSync,
+  createReadStream,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  renameSync,
+  unlinkSync
+} from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var DOCS_URL = "https://hyperframes.heygen.com/deploy/aws-lambda";
+var HANDLER_CACHE_DIR = join(homedir(), ".cache", "hyperframes", "lambda-handler");
+var defaultDeps = {
+  loadAdapter: () => import("@framey/aws-lambda/sdk"),
+  download: downloadFile,
+  cacheDir: HANDLER_CACHE_DIR,
+  log: (line) => console.log(line)
+};
+function noHandlerMessage(adapterInstalled) {
+  const adapter = adapterInstalled ? "  - The installed @framey/aws-lambda has no prebuilt handler for its version. Install one that does:\n" : "  - Install the Lambda adapter; its release pins the prebuilt handler:\n";
+  return "[lambda deploy] This is not a Framey checkout, and no prebuilt Lambda handler is available.\n" + adapter + `      npm install -g @framey/aws-lambda@${VERSION}
+  - Or run from a hyperframes checkout, or set HYPERFRAMES_REPO_ROOT to one.
+Docs: ${DOCS_URL}`;
+}
+async function sha256File(path) {
+  const hash = createHash("sha256");
+  for await (const chunk of createReadStream(path)) hash.update(chunk);
+  return hash.digest("hex");
+}
+async function fetchPinned(pinned, asset, deps) {
+  const dir = join(deps.cacheDir, `${pinned.version}-${pinned.sha256}`);
+  const file = join(dir, asset.fileName);
+  if (existsSync(file) && await sha256File(file) === pinned.sha256) {
+    deps.log(`\u2192 Using verified ${asset.label} ${pinned.version} from ${dir}`);
+    return file;
+  }
+  const url = asset.urlOverride ?? pinned.url;
+  deps.log(`\u2192 Downloading ${asset.label} ${pinned.version} (${pinned.bytes} bytes)`);
+  mkdirSync(dir, { recursive: true });
+  const partial = `${file}.download`;
+  await deps.download(url, partial, { maxBytes: pinned.bytes });
+  const actual = await sha256File(partial);
+  if (actual !== pinned.sha256) {
+    unlinkSync(partial);
+    const urlWithoutCredentials = url.split("?")[0];
+    throw new Error(
+      `[lambda deploy] Refusing the ${asset.label} from ${urlWithoutCredentials}: sha256 ${actual} does not match the ${pinned.sha256} pinned by @framey/aws-lambda@${pinned.version}.`
+    );
+  }
+  renameSync(partial, file);
+  deps.log(`\u2192 Verified sha256 ${pinned.sha256}`);
+  return file;
+}
+async function stagePrebuiltHandler(deps = defaultDeps) {
+  let sdk;
+  try {
+    sdk = await deps.loadAdapter();
+  } catch (err) {
+    if (isMissingPackageError(err, "@framey/aws-lambda")) throw new Error(noHandlerMessage(false));
+    throw err;
+  }
+  const pinned = sdk.prebuiltHandler?.();
+  if (!pinned) throw new Error(noHandlerMessage(true));
+  const zip = await fetchPinned(
+    pinned,
+    {
+      fileName: "handler.zip",
+      label: "handler ZIP",
+      urlOverride: process.env.HYPERFRAMES_LAMBDA_HANDLER_URL
+    },
+    deps
+  );
+  const dir = dirname(zip);
+  const templateDir = dirname(pinned.templatePath);
+  for (const file of readdirSync(templateDir).filter((name) => name.endsWith(".yaml"))) {
+    copyFileSync(join(templateDir, file), join(dir, file));
+  }
+  return dir;
+}
+
+// src/commands/lambda/videoImage.ts
+import { spawnSync } from "child_process";
+import { mkdtempSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+function videoRepositoryName(stackName) {
+  return `${stackName.toLowerCase()}-video`;
+}
+async function pushVideoImage(opts, deps = defaultDeps) {
+  const sdk = await deps.loadAdapter();
+  const tarball = await videoImageTarball(sdk, opts.inCheckout, deps);
+  if (!sdk.ensureEcrRepository || !sdk.pushImageToEcr) {
+    throw new Error(noVideoImageMessage(opts.inCheckout));
+  }
+  const layoutDir = mkdtempSync(join2(tmpdir(), "hf-video-image-"));
+  try {
+    const untar = spawnSync("tar", ["-xf", tarball, "-C", layoutDir], { stdio: "inherit" });
+    if (untar.status !== 0) {
+      throw new Error(
+        `[lambda deploy] tar could not extract ${tarball} (exit ${untar.status ?? "unknown"})`
+      );
+    }
+    const repositoryName = videoRepositoryName(opts.stackName);
+    const { repositoryUri } = await sdk.ensureEcrRepository({
+      region: opts.region,
+      repositoryName,
+      tags: [{ Key: "hyperframes:stack", Value: opts.stackName }]
+    });
+    deps.log(`\u2192 Pushing the arm64 video image to ${repositoryUri}`);
+    const pushed = await sdk.pushImageToEcr({
+      region: opts.region,
+      layoutDir,
+      repositoryName,
+      repositoryUri,
+      tag: "video",
+      log: deps.log
+    });
+    if (pushed.os !== "linux" || pushed.architecture !== "arm64") {
+      throw new Error(
+        `[lambda deploy] ${tarball} is a ${pushed.os}/${pushed.architecture} image; the video function needs linux/arm64.`
+      );
+    }
+    return { imageUri: pushed.imageUri, repositoryName };
+  } finally {
+    rmSync(layoutDir, { recursive: true, force: true });
+  }
+}
+async function videoImageTarball(sdk, inCheckout, deps) {
+  const local = process.env.HYPERFRAMES_LAMBDA_VIDEO_IMAGE;
+  if (local) return local;
+  const pinned = inCheckout ? void 0 : sdk.prebuiltVideoImage?.();
+  if (!pinned) throw new Error(noVideoImageMessage(inCheckout));
+  return fetchPinned(pinned, { fileName: "video-arm64.oci.tar", label: "arm64 video image" }, deps);
+}
+function noVideoImageMessage(inCheckout) {
+  return inCheckout ? "[lambda deploy] An arm64 deploy from a checkout needs an image built from that checkout: build packages/aws-lambda/image's `video` target as an OCI tarball and set HYPERFRAMES_LAMBDA_VIDEO_IMAGE to it, or pass --video-arch x86_64." : "[lambda deploy] The installed @framey/aws-lambda pins no arm64 video image. Install a newer one, or pass --video-arch x86_64.";
+}
+
+// src/commands/lambda/deploy.ts
+var DEFAULT_REGION = "us-east-1";
+var DEFAULT_MEMORY_MB = 10240;
+async function runDeploy(args = {}) {
+  const resolved = {
+    stackName: args.stackName ?? DEFAULT_STACK_NAME,
+    region: args.region ?? process.env.AWS_REGION ?? DEFAULT_REGION,
+    awsProfile: args.awsProfile ?? process.env.AWS_PROFILE,
+    reservedConcurrency: args.reservedConcurrency,
+    chromeSource: args.chromeSource ?? "sparticuz",
+    lambdaMemoryMb: args.lambdaMemoryMb ?? DEFAULT_MEMORY_MB,
+    videoArch: args.videoArch ?? "arm64",
+    skipBuild: args.skipBuild ?? false
+  };
+  if (resolved.videoArch === "arm64" && resolved.chromeSource !== "sparticuz") {
+    throw new Error(
+      "[lambda deploy] The arm64 video image bundles sparticuz Chrome only. Pass --video-arch x86_64 to deploy with --chrome-source chrome-headless-shell."
+    );
+  }
+  const root = repoRoot();
+  const samDir = await prepareSamDir(root, resolved);
+  const video = resolved.videoArch === "arm64" ? await pushVideoImage({
+    stackName: resolved.stackName,
+    region: resolved.region,
+    inCheckout: root !== void 0
+  }) : void 0;
+  console.log(c.dim(`\u2192 sam deploy (stack=${resolved.stackName} region=${resolved.region})`));
+  samDeploy({
+    samDir,
+    stackName: resolved.stackName,
+    region: resolved.region,
+    awsProfile: resolved.awsProfile,
+    reservedConcurrency: resolved.reservedConcurrency,
+    lambdaMemoryMb: resolved.lambdaMemoryMb,
+    chromeSource: resolved.chromeSource,
+    videoImageUri: video?.imageUri
+  });
+  console.log(c.dim("\u2192 Reading stack outputs"));
+  const outputs = fetchStackOutputs({
+    stackName: resolved.stackName,
+    region: resolved.region,
+    awsProfile: resolved.awsProfile
+  });
+  const statePath = writeStackOutputs({
+    stackName: resolved.stackName,
+    region: resolved.region,
+    bucketName: outputs.bucketName,
+    stateMachineArn: outputs.stateMachineArn,
+    functionName: outputs.functionName,
+    lambdaMemoryMb: resolved.lambdaMemoryMb,
+    reservedConcurrency: outputs.reservedConcurrency,
+    videoFunctionName: outputs.videoFunctionName,
+    // Back on x86 the repository outlives the video function, so destroy still needs its name.
+    videoRepository: video?.repositoryName ?? readStackOutputs(resolved.stackName)?.videoRepository,
+    deployedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  if (resolved.reservedConcurrency === -1) {
+    console.log(
+      c.warn(
+        "Removed the stack's reserved concurrency; each render now sizes itself to the account."
+      )
+    );
+  } else if (resolved.reservedConcurrency === void 0 && outputs.reservedConcurrency !== void 0) {
+    console.log(
+      c.warn(
+        `Kept the stack's reserved concurrency of ${outputs.reservedConcurrency}. Pass --concurrency=N to change it.`
+      )
+    );
+  }
+  console.log();
+  console.log(c.success("Stack deployed."));
+  console.log(`  ${c.dim("Bucket:")}         ${outputs.bucketName}`);
+  console.log(`  ${c.dim("State machine:")}  ${outputs.stateMachineArn}`);
+  console.log(`  ${c.dim("Function:")}       ${outputs.functionName}`);
+  if (outputs.videoFunctionName) {
+    console.log(`  ${c.dim("Video function:")} ${outputs.videoFunctionName} (arm64)`);
+  }
+  console.log(`  ${c.dim("State file:")}     ${resolve(statePath)}`);
+  console.log();
+  console.log(c.dim(`Render with: framey lambda render <project-dir>`));
+}
+async function prepareSamDir(root, args) {
+  if (!root) {
+    if (args.chromeSource !== "sparticuz") {
+      throw new Error(
+        "[lambda deploy] The prebuilt handler bundles sparticuz Chrome; --chrome-source=chrome-headless-shell needs a hyperframes checkout."
+      );
+    }
+    return stagePrebuiltHandler();
+  }
+  const samDir = dirname2(locateSamTemplate(root));
+  if (!args.skipBuild) {
+    console.log(c.dim("\u2192 Building handler ZIP"));
+    buildHandlerZip(root);
+  } else {
+    const zip = join3(root, "packages", "aws-lambda", "dist", "handler.zip");
+    if (!existsSync2(zip)) {
+      throw new Error(
+        `--skip-build set but ${zip} does not exist. Run \`bun run --cwd packages/aws-lambda build:zip\` first or drop --skip-build.`
+      );
+    }
+  }
+  return samDir;
+}
+function buildHandlerZip(root) {
+  const result = spawnSync2(
+    "bun",
+    ["run", "--cwd", join3(root, "packages", "aws-lambda"), "build:zip"],
+    { stdio: "inherit" }
+  );
+  if (result.status !== 0) {
+    throw new Error(
+      `[lambda deploy] handler ZIP build exited with code ${result.status ?? "unknown"}`
+    );
+  }
+}
+export {
+  runDeploy
+};

package/vendor/framey/dist/destroy-HE2RIPKZ.js

@@ -0,0 +1,57 @@
+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 {
+  repoRoot
+} from "./chunk-2X4PQEYM.js";
+import {
+  deleteEcrRepository,
+  samDelete
+} from "./chunk-HEFQCIXR.js";
+import {
+  deleteStackOutputs,
+  requireStack
+} from "./chunk-3FYD4YEK.js";
+import {
+  c
+} from "./chunk-VORQIH64.js";
+import "./chunk-JVBRJMOP.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/lambda/destroy.ts
+import { tmpdir } from "os";
+import { join } from "path";
+async function runDestroy(args) {
+  const stack = requireStack(args.stackName);
+  console.log(c.dim(`\u2192 sam delete (stack=${stack.stackName} region=${stack.region})`));
+  const root = repoRoot();
+  const awsProfile = args.awsProfile ?? process.env.AWS_PROFILE;
+  samDelete({
+    samDir: root ? join(root, "examples", "aws-lambda") : tmpdir(),
+    stackName: stack.stackName,
+    region: stack.region,
+    awsProfile
+  });
+  if (stack.videoRepository) {
+    console.log(c.dim(`\u2192 Deleting ECR repository ${stack.videoRepository}`));
+    deleteEcrRepository({
+      repositoryName: stack.videoRepository,
+      region: stack.region,
+      awsProfile
+    });
+  }
+  deleteStackOutputs(args.stackName);
+  console.log();
+  console.log(c.success("Stack torn down."));
+  console.log(
+    c.dim(
+      `Note: the render bucket "${stack.bucketName}" was deployed with Retain \u2014 empty + delete it via the AWS console or CLI if you want to fully reclaim storage.`
+    )
+  );
+}
+export {
+  runDestroy
+};

package/vendor/framey/dist/deterministicFonts-RADD3BSX.js

@@ -0,0 +1,50 @@
+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 {
+  FONT_ALIASES,
+  FONT_FETCH_FAILED,
+  FONT_FETCH_UNAVAILABLE,
+  FontFetchError,
+  FontFetchUnavailableError,
+  GENERIC_FAMILIES,
+  _clearGoogleFontCssCacheForTests,
+  collectFontFamilyCustomProperties,
+  fontFormatHint,
+  fontToDataUri,
+  injectDeterministicFontFaces,
+  iterateFontFamilyDeclarations,
+  normalizeSystemFontPrimaryFamilies,
+  parseFontFamilyValue,
+  resolveFontFamilyDeclarationFamilies
+} from "./chunk-ROEW726S.js";
+import "./chunk-FI4I7CME.js";
+import "./chunk-7FMUTGOH.js";
+import {
+  FONT_ALIAS_KEYS
+} from "./chunk-B7RJV74O.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-SDYDNHEE.js";
+import "./chunk-RXATE6FZ.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  FONT_ALIASES,
+  FONT_ALIAS_KEYS,
+  FONT_FETCH_FAILED,
+  FONT_FETCH_UNAVAILABLE,
+  FontFetchError,
+  FontFetchUnavailableError,
+  GENERIC_FAMILIES,
+  _clearGoogleFontCssCacheForTests,
+  collectFontFamilyCustomProperties,
+  fontFormatHint,
+  fontToDataUri,
+  injectDeterministicFontFaces,
+  iterateFontFamilyDeclarations,
+  normalizeSystemFontPrimaryFamilies,
+  parseFontFamilyValue,
+  resolveFontFamilyDeclarationFamilies
+};