Skip to content

Open-source AI podcast clipper. Generate vertical clips with face tracking and burned-in captions. CLI, MCP server, web app.

9.2 KB
Raw Blame
package provision

import (
	"archive/tar"
	"archive/zip"
	"compress/gzip"
	"fmt"
	"io"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"strings"

	"podcli/internal/paths"
)

// nodeVersion is the hermetic Node.js used to serve the studio web UI. Node only
// runs the bundled server (rendering is delegated to the Python backend), so any
// recent LTS works; pin for reproducibility.
const nodeVersion = "20.18.1"

var nodeTriples = map[string]string{
	"darwin/amd64":  "darwin-x64",
	"darwin/arm64":  "darwin-arm64",
	"linux/amd64":   "linux-x64",
	"linux/arm64":   "linux-arm64",
	"windows/amd64": "win-x64",
}

func NodeDir() string { return filepath.Join(paths.RuntimeDir(), "node") }

func NodeBin() string {
	if runtime.GOOS == "windows" {
		return filepath.Join(NodeDir(), "node.exe")
	}
	return filepath.Join(NodeDir(), "bin", "node")
}

func StudioDir() string    { return filepath.Join(paths.RuntimeDir(), "studio") }
func StudioServer() string { return filepath.Join(StudioDir(), "web-server.mjs") }

func bundleStamp(dir string) string { return filepath.Join(dir, ".podcli-version") }

func bundleAt(dir, version string) bool {
	b, err := os.ReadFile(bundleStamp(dir))
	return err == nil && strings.TrimSpace(string(b)) == version
}

func writeBundleStamp(dir, version string) {
	os.WriteFile(bundleStamp(dir), []byte(version), 0o644)
}

func EnsureNode() (string, error) {
	bin := NodeBin()
	if !VerifyRemote && nativeBin(bin) && artifactReady(NodeDir(), bin) {
		return bin, nil
	}
	triple, ok := nodeTriples[runtime.GOOS+"/"+runtime.GOARCH]
	if !ok {
		return "", fmt.Errorf("no node build for %s/%s", runtime.GOOS, runtime.GOARCH)
	}
	ext := "tar.gz"
	if runtime.GOOS == "windows" {
		ext = "zip"
	}
	base := fmt.Sprintf("node-v%s-%s", nodeVersion, triple)
	url := fmt.Sprintf("https://nodejs.org/dist/v%s/%s.%s", nodeVersion, base, ext)
	sumsURL := fmt.Sprintf("https://nodejs.org/dist/v%s/SHASUMS256.txt", nodeVersion)
	want, err := downloadChecksum(sumsURL, base+"."+ext)
	if err != nil {
		return "", err
	}
	key := base + "|" + want
	if nativeBin(bin) && artifactAt(NodeDir(), key, bin) {
		return bin, nil
	}
	archive, err := downloadPath(url, base+"."+ext)
	if err != nil {
		return "", err
	}
	defer removeArchive(archive)
	if err := download(url, archive, want, "node"); err != nil {
		return "", err
	}
	if err := os.RemoveAll(NodeDir()); err != nil {
		return "", err
	}
	if ext == "zip" {
		err = extractZipStrip1(archive, NodeDir())
	} else {
		err = extractTarGzStrip1(archive, NodeDir())
	}
	if err != nil {
		return "", err
	}
	if runtime.GOOS != "windows" {
		os.Chmod(bin, 0o755)
	}
	if !have(bin) {
		return "", fmt.Errorf("node missing after extraction in %s", NodeDir())
	}
	if err := writeArtifactState(NodeDir(), key, bin); err != nil {
		return "", err
	}
	return bin, nil
}

func RemotionDir() string    { return filepath.Join(paths.RuntimeDir(), "remotion") }
func RemotionScript() string { return filepath.Join(RemotionDir(), "render.mjs") }

// EnsureRemotion fetches the per-platform Remotion render bundle (remotion/ +
// a production node_modules with native bindings) and extracts it into the
// runtime dir so remotion/ and node_modules/ sit beside backend/. Per-platform
// because @rspack and the Remotion compositor ship native binaries.
func EnsureRemotion(version string) (string, error) {
	if have(RemotionScript()) && bundleAt(RemotionDir(), version) {
		return RemotionDir(), nil
	}
	name := fmt.Sprintf("remotion-bundle-%s-%s.tar.gz", runtime.GOOS, runtime.GOARCH)
	assets, err := latestReleaseAssets()
	if err != nil {
		return "", err
	}
	url, ok := assets[name]
	if !ok {
		return "", fmt.Errorf("asset %s not in latest release", name)
	}
	archive, err := downloadPath(url, name)
	if err != nil {
		return "", err
	}
	if err := fetch(url, archive, "remotion", downloadHTTPClient()); err != nil {
		return "", err
	}
	defer removeArchive(archive)
	if err := verifyReleaseAsset(assets, name, archive); err != nil {
		return "", err
	}
	if err := os.RemoveAll(RemotionDir()); err != nil {
		return "", err
	}
	if err := os.RemoveAll(filepath.Join(paths.RuntimeDir(), "node_modules")); err != nil {
		return "", err
	}
	if err := extractTarGz(archive, paths.RuntimeDir()); err != nil {
		return "", err
	}
	if !have(RemotionScript()) {
		return "", fmt.Errorf("remotion render.mjs missing after extraction")
	}
	writeBundleStamp(RemotionDir(), version)
	return RemotionDir(), nil
}

// PrewarmRemotion compiles the project-independent composition bundle once into
// the managed dir so the first caption render skips the ~20s bundling step.
func PrewarmRemotion() error {
	node := NodeBin()
	if !have(node) || !have(RemotionScript()) {
		return fmt.Errorf("node/remotion not provisioned")
	}
	cmd := exec.Command(node, RemotionScript(), "--prebundle")
	cmd.Dir = RemotionDir()
	cmd.Env = append(os.Environ(), "PODCLI_CACHE_DIR="+filepath.Join(RemotionDir(), ".bundle-cache"))
	cmd.Stderr = os.Stderr
	return cmd.Run()
}

// EnsureRemotionBrowser pre-downloads the Chrome Headless Shell the Remotion
// renderer needs, so the first caption render works offline. Best-effort: if it
// fails, the renderer downloads the browser on first use.
func EnsureRemotionBrowser() error {
	node := NodeBin()
	if !have(node) || !have(RemotionScript()) {
		return fmt.Errorf("node/remotion not provisioned")
	}
	cmd := exec.Command(node, "-e",
		"import('@remotion/renderer').then(r=>r.ensureBrowser()).then(()=>process.exit(0)).catch(e=>{console.error(String(e));process.exit(1)})")
	cmd.Dir = RemotionDir()
	cmd.Stderr = os.Stderr
	return cmd.Run()
}

// EnsureStudio fetches the prebuilt, platform-independent studio bundle (server +
// SPA) from the latest release into StudioDir.
func EnsureStudio(version string) (string, error) {
	server := StudioServer()
	if have(server) && bundleAt(StudioDir(), version) {
		return StudioDir(), nil
	}
	assets, err := latestReleaseAssets()
	if err != nil {
		return "", err
	}
	url, ok := assets["studio-bundle.tar.gz"]
	if !ok {
		return "", fmt.Errorf("asset studio-bundle.tar.gz not in latest release")
	}
	archive, err := downloadPath(url, "studio-bundle.tar.gz")
	if err != nil {
		return "", err
	}
	if err := fetch(url, archive, "studio", downloadHTTPClient()); err != nil {
		return "", err
	}
	defer removeArchive(archive)
	if err := verifyReleaseAsset(assets, "studio-bundle.tar.gz", archive); err != nil {
		return "", err
	}
	if err := os.RemoveAll(StudioDir()); err != nil {
		return "", err
	}
	if err := os.MkdirAll(StudioDir(), 0o755); err != nil {
		return "", err
	}
	if err := extractTarGz(archive, StudioDir()); err != nil {
		return "", err
	}
	if !have(server) {
		return "", fmt.Errorf("studio server missing after extraction in %s", StudioDir())
	}
	writeBundleStamp(StudioDir(), version)
	return StudioDir(), nil
}

// strip1 drops the leading path component (node tarballs/zips nest everything
// under node-vX-os-arch/).
func strip1(name string) string {
	name = filepath.ToSlash(name)
	if i := strings.IndexByte(name, '/'); i >= 0 {
		return name[i+1:]
	}
	return ""
}

func extractTarGzStrip1(archive, dest string) error {
	f, err := os.Open(archive)
	if err != nil {
		return err
	}
	defer f.Close()
	gz, err := gzip.NewReader(f)
	if err != nil {
		return err
	}
	defer gz.Close()
	tr := tar.NewReader(gz)
	root := filepath.Clean(dest) + string(os.PathSeparator)
	for {
		h, err := tr.Next()
		if err == io.EOF {
			break
		}
		if err != nil {
			return err
		}
		rel := strip1(h.Name)
		if rel == "" {
			continue
		}
		target := filepath.Join(dest, rel)
		if !strings.HasPrefix(target, root) {
			return fmt.Errorf("unsafe path in archive: %s", h.Name)
		}
		switch h.Typeflag {
		case tar.TypeDir:
			if err := os.MkdirAll(target, 0o755); err != nil {
				return err
			}
		case tar.TypeReg:
			if err := os.MkdirAll(filepath.Dir(target), 0o755); err != nil {
				return err
			}
			out, err := os.OpenFile(target, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, os.FileMode(h.Mode))
			if err != nil {
				return err
			}
			_, err = io.Copy(out, tr)
			out.Close()
			if err != nil {
				return err
			}
		case tar.TypeSymlink:
			if !symlinkTargetInside(target, h.Linkname, root) {
				return fmt.Errorf("unsafe symlink %s -> %s in archive", h.Name, h.Linkname)
			}
			if err := os.MkdirAll(filepath.Dir(target), 0o755); err != nil {
				return err
			}
			os.Remove(target)
			if err := os.Symlink(h.Linkname, target); err != nil {
				return err
			}
		}
	}
	return nil
}

func extractZipStrip1(archive, dest string) error {
	zr, err := zip.OpenReader(archive)
	if err != nil {
		return err
	}
	defer zr.Close()
	root := filepath.Clean(dest) + string(os.PathSeparator)
	for _, zf := range zr.File {
		rel := strip1(zf.Name)
		if rel == "" {
			continue
		}
		target := filepath.Join(dest, rel)
		if !strings.HasPrefix(target, root) {
			return fmt.Errorf("unsafe path in archive: %s", zf.Name)
		}
		if zf.FileInfo().IsDir() {
			if err := os.MkdirAll(target, 0o755); err != nil {
				return err
			}
			continue
		}
		if err := os.MkdirAll(filepath.Dir(target), 0o755); err != nil {
			return err
		}
		rc, err := zf.Open()
		if err != nil {
			return err
		}
		out, err := os.OpenFile(target, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, zf.Mode())
		if err != nil {
			rc.Close()
			return err
		}
		_, err = io.Copy(out, rc)
		out.Close()
		rc.Close()
		if err != nil {
			return err
		}
	}
	return nil
}