Files
zapret-autotune/cmd/zapret-autotune/discover.go
T
ZeusinaandGPT-6 Bot e270810f33 refactor: execute adapter plans through shared core
Execute the private YouTube qualification plan through core-owned scheduling while retaining worker cleanup, proof sealing and legacy policy boundaries. Preserve unsafe collector failures alongside concurrent cancellation or deadlines.

Send bounded Player JSON through stdin instead of argv and update all shared runner callers. Generic controller cutover and remote runtime acceptance remain pending.

Co-authored-by: GPT-6 <gpt-6@openai.com>
2026-10-15 17:25:12 +03:00

183 lines
5.9 KiB
Go

package main
import (
"bytes"
"context"
"encoding/json"
"errors"
"flag"
"fmt"
"io"
"net"
"net/url"
"os/exec"
"regexp"
"strconv"
"strings"
"time"
)
const playerURL = "https://www.youtube.com/youtubei/v1/player"
const playerUserAgent = "com.google.youtube/21.02.35(Linux;U;Android11)gzip"
const playerResponseLimit = 1 << 20
var videoIDPattern = regexp.MustCompile(`^[A-Za-z0-9_-]{11}$`)
var discoveryDNSLabel = regexp.MustCompile(`^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$`)
type playerRunner func(context.Context, []string, io.Reader, io.Writer, io.Writer) error
// Keep request diagnostics private while retaining typed causes for supervision.
type playerRequestError struct{ cause error }
func (e *playerRequestError) Error() string { return "player request failed or exceeded output limit" }
func (e *playerRequestError) Unwrap() error { return e.cause }
func runPlayerCurl(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) error {
cmd := exec.CommandContext(ctx, "curl", args...)
cmd.Stdin = stdin
cmd.Stdout, cmd.Stderr = stdout, stderr
return cmd.Run()
}
// A failed write stops collection rather than retaining a truncated response.
type playerBoundedWriter struct {
dst io.Writer
n int
limit int
exceeded bool
}
func (w *playerBoundedWriter) Write(p []byte) (int, error) {
if len(p) > w.limit-w.n {
w.exceeded = true
return 0, errors.New("player output limit exceeded")
}
w.n += len(p)
return w.dst.Write(p)
}
func discoveryHostname(host string) bool {
if len(host) > 253 || host == "" {
return false
}
for _, label := range strings.Split(strings.ToLower(host), ".") {
if !discoveryDNSLabel.MatchString(label) {
return false
}
}
return true
}
func validDiscoveryProxy(raw string) bool {
u, err := url.Parse(raw)
if err != nil || u.Scheme != "socks5" || u.User != nil || u.Opaque != "" ||
u.Path != "" || u.RawQuery != "" || u.ForceQuery || u.Fragment != "" ||
strings.ContainsAny(raw, " \t\r\n#") {
return false
}
host, port, err := net.SplitHostPort(u.Host)
if err != nil || (net.ParseIP(host) == nil && !discoveryHostname(host)) {
return false
}
n, err := strconv.Atoi(port)
return err == nil && n > 0 && n <= 65535
}
func playerHostname(body []byte) (string, error) {
var response struct {
PlayabilityStatus struct {
Status string `json:"status"`
} `json:"playabilityStatus"`
StreamingData struct {
ServerAbrStreamingURL string `json:"serverAbrStreamingUrl"`
} `json:"streamingData"`
}
if len(body) > playerResponseLimit || json.Unmarshal(body, &response) != nil {
return "", errors.New("invalid player response")
}
if response.PlayabilityStatus.Status != "OK" {
return "", errors.New("player response is not playable")
}
u, err := url.Parse(response.StreamingData.ServerAbrStreamingURL)
if err != nil || u.Scheme != "https" || u.User != nil || u.Opaque != "" {
return "", errors.New("missing or invalid streaming URL")
}
host := strings.ToLower(u.Hostname())
if !discoveryHostname(host) || !strings.HasSuffix(host, ".googlevideo.com") ||
(u.Port() != "" && u.Port() != "443") || strings.HasSuffix(u.Host, ":") {
return "", errors.New("invalid cache hostname")
}
return host, nil
}
func discoveryFlags(args []string) (string, string, error) {
flags := flag.NewFlagSet("discover youtube", flag.ContinueOnError)
flags.SetOutput(io.Discard) // flag errors can contain untrusted arguments.
videoID := flags.String("video-id", "", "")
proxy := flags.String("proxy", "", "")
if flags.Parse(args) != nil || flags.NArg() != 0 || !videoIDPattern.MatchString(*videoID) || !validDiscoveryProxy(*proxy) {
return "", "", errors.New("requires --video-id (11 characters) and --proxy socks5://HOST:PORT without credentials")
}
return *videoID, *proxy, nil
}
func discoverYoutube(args []string, stdout, stderr io.Writer, runner playerRunner) int {
videoID, proxy, err := discoveryFlags(args)
if err != nil {
fmt.Fprintln(stderr, "error: discover youtube", err)
return 2
}
body, err := requestPlayer(videoID, proxy, runner)
if err != nil {
fmt.Fprintln(stderr, "error:", err)
return 1
}
host, err := playerHostname(body)
if err != nil {
fmt.Fprintln(stderr, "error:", err)
return 1
}
result := struct {
VideoID string `json:"videoId"`
Hostnames []string `json:"hostnames"`
}{videoID, []string{host}}
if json.NewEncoder(stdout).Encode(result) != nil {
fmt.Fprintln(stderr, "error: cannot write discovery result")
return 1
}
return 0
}
func requestPlayer(videoID, proxy string, runner playerRunner) ([]byte, error) {
if _, err := requiredYoutubeAdapter(); err != nil {
return nil, err
}
if !videoIDPattern.MatchString(videoID) {
return nil, errors.New("invalid player video ID")
}
payload, _ := json.Marshal(map[string]interface{}{
"videoId": videoID,
"context": map[string]interface{}{"client": map[string]interface{}{
"clientName": "ANDROID", "clientVersion": "21.02.35", "androidSdkVersion": 30,
"userAgent": playerUserAgent, "osName": "Android", "osVersion": "11",
}},
})
ctx, cancel := context.WithTimeout(context.Background(), 35*time.Second)
defer cancel()
var body bytes.Buffer
output := &playerBoundedWriter{dst: &body, limit: playerResponseLimit}
diagnostics := &playerBoundedWriter{dst: io.Discard, limit: 64 << 10}
// Disable curlrc and NO_PROXY bypasses: the explicit proxy must be used.
// Keep the bounded JSON body off argv; curl retains its JSON POST headers.
err := runner(ctx, []string{"--disable", "--silent", "--show-error", "--fail", "--max-time", "30",
"--noproxy", "", "--proxy", proxy, "--user-agent", playerUserAgent, "--json", "@-", playerURL}, bytes.NewReader(payload), output, diagnostics)
if err != nil || output.exceeded || diagnostics.exceeded {
if output.exceeded || diagnostics.exceeded {
// An output failure remains unsafe even if the child was also canceled.
err = errors.Join(err, errors.New("player output limit exceeded"))
}
return nil, &playerRequestError{cause: err}
}
return body.Bytes(), nil
}