slidge-whatsapp 0.2.2__cp311-cp311-manylinux_2_36_aarch64.whl → 0.2.5__cp311-cp311-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/types/presence.go

@@ -0,0 +1,78 @@
+// Copyright (c) 2021 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package types
+
+import (
+	"fmt"
+)
+
+type Presence string
+
+const (
+	PresenceAvailable   Presence = "available"
+	PresenceUnavailable Presence = "unavailable"
+)
+
+type ChatPresence string
+
+const (
+	ChatPresenceComposing ChatPresence = "composing"
+	ChatPresencePaused    ChatPresence = "paused"
+)
+
+type ChatPresenceMedia string
+
+const (
+	ChatPresenceMediaText  ChatPresenceMedia = ""
+	ChatPresenceMediaAudio ChatPresenceMedia = "audio"
+)
+
+// ReceiptType represents the type of a Receipt event.
+type ReceiptType string
+
+const (
+	// ReceiptTypeDelivered means the message was delivered to the device (but the user might not have noticed).
+	ReceiptTypeDelivered ReceiptType = ""
+	// ReceiptTypeSender is sent by your other devices when a message you sent is delivered to them.
+	ReceiptTypeSender ReceiptType = "sender"
+	// ReceiptTypeRetry means the message was delivered to the device, but decrypting the message failed.
+	ReceiptTypeRetry ReceiptType = "retry"
+	// ReceiptTypeRead means the user opened the chat and saw the message.
+	ReceiptTypeRead ReceiptType = "read"
+	// ReceiptTypeReadSelf means the current user read a message from a different device, and has read receipts disabled in privacy settings.
+	ReceiptTypeReadSelf ReceiptType = "read-self"
+	// ReceiptTypePlayed means the user opened a view-once media message.
+	//
+	// This is dispatched for both incoming and outgoing messages when played. If the current user opened the media,
+	// it means the media should be removed from all devices. If a recipient opened the media, it's just a notification
+	// for the sender that the media was viewed.
+	ReceiptTypePlayed ReceiptType = "played"
+	// ReceiptTypePlayedSelf probably means the current user opened a view-once media message from a different device,
+	// and has read receipts disabled in privacy settings.
+	ReceiptTypePlayedSelf ReceiptType = "played-self"
+
+	ReceiptTypeServerError ReceiptType = "server-error"
+	ReceiptTypeInactive    ReceiptType = "inactive"
+	ReceiptTypePeerMsg     ReceiptType = "peer_msg"
+	ReceiptTypeHistorySync ReceiptType = "hist_sync"
+)
+
+// GoString returns the name of the Go constant for the ReceiptType value.
+func (rt ReceiptType) GoString() string {
+	switch rt {
+	case ReceiptTypeRead:
+		return "types.ReceiptTypeRead"
+	case ReceiptTypeReadSelf:
+		return "types.ReceiptTypeReadSelf"
+	case ReceiptTypeDelivered:
+		return "types.ReceiptTypeDelivered"
+	case ReceiptTypePlayed:
+		return "types.ReceiptTypePlayed"
+	default:
+		return fmt.Sprintf("types.ReceiptType(%#v)", string(rt))
+	}
+}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/types/user.go

@@ -0,0 +1,195 @@
+// Copyright (c) 2022 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package types
+
+import (
+	"time"
+
+	"go.mau.fi/whatsmeow/proto/waVnameCert"
+)
+
+// VerifiedName contains verified WhatsApp business details.
+type VerifiedName struct {
+	Certificate *waVnameCert.VerifiedNameCertificate
+	Details     *waVnameCert.VerifiedNameCertificate_Details
+}
+
+// UserInfo contains info about a WhatsApp user.
+type UserInfo struct {
+	VerifiedName *VerifiedName
+	Status       string
+	PictureID    string
+	Devices      []JID
+}
+
+type BotListInfo struct {
+	BotJID    JID
+	PersonaID string
+}
+
+type BotProfileInfo struct {
+	JID                 JID
+	Name                string
+	Attributes          string
+	Description         string
+	Category            string
+	IsDefault           bool
+	Prompts             []string
+	PersonaID           string
+	Commands            []BotProfileCommand
+	CommandsDescription string
+}
+
+type BotProfileCommand struct {
+	Name        string
+	Description string
+}
+
+// ProfilePictureInfo contains the ID and URL for a WhatsApp user's profile picture or group's photo.
+type ProfilePictureInfo struct {
+	URL  string `json:"url"`  // The full URL for the image, can be downloaded with a simple HTTP request.
+	ID   string `json:"id"`   // The ID of the image. This is the same as UserInfo.PictureID.
+	Type string `json:"type"` // The type of image. Known types include "image" (full res) and "preview" (thumbnail).
+
+	DirectPath string `json:"direct_path"` // The path to the image, probably not very useful
+}
+
+// ContactInfo contains the cached names of a WhatsApp user.
+type ContactInfo struct {
+	Found bool
+
+	FirstName    string
+	FullName     string
+	PushName     string
+	BusinessName string
+}
+
+// LocalChatSettings contains the cached local settings for a chat.
+type LocalChatSettings struct {
+	Found bool
+
+	MutedUntil time.Time
+	Pinned     bool
+	Archived   bool
+}
+
+// IsOnWhatsAppResponse contains information received in response to checking if a phone number is on WhatsApp.
+type IsOnWhatsAppResponse struct {
+	Query string // The query string used
+	JID   JID    // The canonical user ID
+	IsIn  bool   // Whether the phone is registered or not.
+
+	VerifiedName *VerifiedName // If the phone is a business, the verified business details.
+}
+
+// BusinessMessageLinkTarget contains the info that is found using a business message link (see Client.ResolveBusinessMessageLink)
+type BusinessMessageLinkTarget struct {
+	JID JID // The JID of the business.
+
+	PushName      string // The notify / push name of the business.
+	VerifiedName  string // The verified business name.
+	IsSigned      bool   // Some boolean, seems to be true?
+	VerifiedLevel string // I guess the level of verification, starting from "unknown".
+
+	Message string // The message that WhatsApp clients will pre-fill in the input box when clicking the link.
+}
+
+// ContactQRLinkTarget contains the info that is found using a contact QR link (see Client.ResolveContactQRLink)
+type ContactQRLinkTarget struct {
+	JID      JID    // The JID of the user.
+	Type     string // Might always be "contact".
+	PushName string // The notify / push name of the user.
+}
+
+// PrivacySetting is an individual setting value in the user's privacy settings.
+type PrivacySetting string
+
+// Possible privacy setting values.
+const (
+	PrivacySettingUndefined        PrivacySetting = ""
+	PrivacySettingAll              PrivacySetting = "all"
+	PrivacySettingContacts         PrivacySetting = "contacts"
+	PrivacySettingContactBlacklist PrivacySetting = "contact_blacklist"
+	PrivacySettingMatchLastSeen    PrivacySetting = "match_last_seen"
+	PrivacySettingKnown            PrivacySetting = "known"
+	PrivacySettingNone             PrivacySetting = "none"
+)
+
+// PrivacySettingType is the type of privacy setting.
+type PrivacySettingType string
+
+const (
+	PrivacySettingTypeGroupAdd     PrivacySettingType = "groupadd"     // Valid values: PrivacySettingAll, PrivacySettingContacts, PrivacySettingContactBlacklist, PrivacySettingNone
+	PrivacySettingTypeLastSeen     PrivacySettingType = "last"         // Valid values: PrivacySettingAll, PrivacySettingContacts, PrivacySettingContactBlacklist, PrivacySettingNone
+	PrivacySettingTypeStatus       PrivacySettingType = "status"       // Valid values: PrivacySettingAll, PrivacySettingContacts, PrivacySettingContactBlacklist, PrivacySettingNone
+	PrivacySettingTypeProfile      PrivacySettingType = "profile"      // Valid values: PrivacySettingAll, PrivacySettingContacts, PrivacySettingContactBlacklist, PrivacySettingNone
+	PrivacySettingTypeReadReceipts PrivacySettingType = "readreceipts" // Valid values: PrivacySettingAll, PrivacySettingNone
+	PrivacySettingTypeOnline       PrivacySettingType = "online"       // Valid values: PrivacySettingAll, PrivacySettingMatchLastSeen
+	PrivacySettingTypeCallAdd      PrivacySettingType = "calladd"      // Valid values: PrivacySettingAll, PrivacySettingKnown
+)
+
+// PrivacySettings contains the user's privacy settings.
+type PrivacySettings struct {
+	GroupAdd     PrivacySetting // Valid values: PrivacySettingAll, PrivacySettingContacts, PrivacySettingContactBlacklist, PrivacySettingNone
+	LastSeen     PrivacySetting // Valid values: PrivacySettingAll, PrivacySettingContacts, PrivacySettingContactBlacklist, PrivacySettingNone
+	Status       PrivacySetting // Valid values: PrivacySettingAll, PrivacySettingContacts, PrivacySettingContactBlacklist, PrivacySettingNone
+	Profile      PrivacySetting // Valid values: PrivacySettingAll, PrivacySettingContacts, PrivacySettingContactBlacklist, PrivacySettingNone
+	ReadReceipts PrivacySetting // Valid values: PrivacySettingAll, PrivacySettingNone
+	CallAdd      PrivacySetting // Valid values: PrivacySettingAll, PrivacySettingKnown
+	Online       PrivacySetting // Valid values: PrivacySettingAll, PrivacySettingMatchLastSeen
+}
+
+// StatusPrivacyType is the type of list in StatusPrivacy.
+type StatusPrivacyType string
+
+const (
+	// StatusPrivacyTypeContacts means statuses are sent to all contacts.
+	StatusPrivacyTypeContacts StatusPrivacyType = "contacts"
+	// StatusPrivacyTypeBlacklist means statuses are sent to all contacts, except the ones on the list.
+	StatusPrivacyTypeBlacklist StatusPrivacyType = "blacklist"
+	// StatusPrivacyTypeWhitelist means statuses are only sent to users on the list.
+	StatusPrivacyTypeWhitelist StatusPrivacyType = "whitelist"
+)
+
+// StatusPrivacy contains the settings for who to send status messages to by default.
+type StatusPrivacy struct {
+	Type StatusPrivacyType
+	List []JID
+
+	IsDefault bool
+}
+
+// Blocklist contains the user's current list of blocked users.
+type Blocklist struct {
+	DHash string // TODO is this just a timestamp?
+	JIDs  []JID
+}
+
+// BusinessHoursConfig contains business operating hours of a WhatsApp business.
+type BusinessHoursConfig struct {
+	DayOfWeek string
+	Mode      string
+	OpenTime  string
+	CloseTime string
+}
+
+// Category contains a WhatsApp business category.
+type Category struct {
+	ID   string
+	Name string
+}
+
+// BusinessProfile contains the profile information of a WhatsApp business.
+type BusinessProfile struct {
+	JID                   JID
+	Address               string
+	Email                 string
+	Categories            []Category
+	ProfileOptions        map[string]string
+	BusinessHoursTimeZone string
+	BusinessHours         []BusinessHoursConfig
+}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/update.go

@@ -0,0 +1,63 @@
+// Copyright (c) 2024 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package whatsmeow
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"regexp"
+	"strconv"
+
+	"go.mau.fi/whatsmeow/socket"
+	"go.mau.fi/whatsmeow/store"
+)
+
+var clientVersionRegex = regexp.MustCompile(`"client_revision":(\d+),`)
+
+// GetLatestVersion returns the latest version number from web.whatsapp.com.
+//
+// After fetching, you can update the version to use using store.SetWAVersion, e.g.
+//
+//	latestVer, err := GetLatestVersion(nil)
+//	if err != nil {
+//		return err
+//	}
+//	store.SetWAVersion(*latestVer)
+func GetLatestVersion(httpClient *http.Client) (*store.WAVersionContainer, error) {
+	req, err := http.NewRequest(http.MethodGet, socket.Origin, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to prepare request: %w", err)
+	}
+	req.Header.Set("User-Agent", "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36")
+	req.Header.Set("Sec-Fetch-Dest", "document")
+	req.Header.Set("Sec-Fetch-Mode", "navigate")
+	req.Header.Set("Sec-Fetch-Site", "none")
+	req.Header.Set("Sec-Fetch-User", "?1")
+	req.Header.Set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7")
+	req.Header.Set("Accept-Language", "en-US,en;q=0.9")
+	if httpClient == nil {
+		httpClient = http.DefaultClient
+	}
+	resp, err := httpClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to send request: %w", err)
+	}
+	data, err := io.ReadAll(resp.Body)
+	_ = resp.Body.Close()
+	if err != nil {
+		return nil, fmt.Errorf("failed to read response: %w", err)
+	} else if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("unexpected response with status %d: %s", resp.StatusCode, data)
+	} else if match := clientVersionRegex.FindSubmatch(data); len(match) == 0 {
+		return nil, fmt.Errorf("version number not found")
+	} else if parsedVer, err := strconv.ParseInt(string(match[1]), 10, 64); err != nil {
+		return nil, fmt.Errorf("failed to parse version number: %w", err)
+	} else {
+		return &store.WAVersionContainer{2, 3000, uint32(parsedVer)}, nil
+	}
+}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/upload.go

@@ -0,0 +1,251 @@
+// Copyright (c) 2024 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package whatsmeow
+
+import (
+	"bytes"
+	"context"
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+
+	"go.mau.fi/util/random"
+
+	"go.mau.fi/whatsmeow/socket"
+	"go.mau.fi/whatsmeow/util/cbcutil"
+)
+
+// UploadResponse contains the data from the attachment upload, which can be put into a message to send the attachment.
+type UploadResponse struct {
+	URL        string `json:"url"`
+	DirectPath string `json:"direct_path"`
+	Handle     string `json:"handle"`
+	ObjectID   string `json:"object_id"`
+
+	MediaKey      []byte `json:"-"`
+	FileEncSHA256 []byte `json:"-"`
+	FileSHA256    []byte `json:"-"`
+	FileLength    uint64 `json:"-"`
+}
+
+// Upload uploads the given attachment to WhatsApp servers.
+//
+// You should copy the fields in the response to the corresponding fields in a protobuf message.
+//
+// For example, to send an image:
+//
+//	resp, err := cli.Upload(context.Background(), yourImageBytes, whatsmeow.MediaImage)
+//	// handle error
+//
+//	imageMsg := &waE2E.ImageMessage{
+//		Caption:  proto.String("Hello, world!"),
+//		Mimetype: proto.String("image/png"), // replace this with the actual mime type
+//		// you can also optionally add other fields like ContextInfo and JpegThumbnail here
+//
+//		URL:           &resp.URL,
+//		DirectPath:    &resp.DirectPath,
+//		MediaKey:      resp.MediaKey,
+//		FileEncSHA256: resp.FileEncSHA256,
+//		FileSHA256:    resp.FileSHA256,
+//		FileLength:    &resp.FileLength,
+//	}
+//	_, err = cli.SendMessage(context.Background(), targetJID, &waE2E.Message{
+//		ImageMessage: imageMsg,
+//	})
+//	// handle error again
+//
+// The same applies to the other message types like DocumentMessage, just replace the struct type and Message field name.
+func (cli *Client) Upload(ctx context.Context, plaintext []byte, appInfo MediaType) (resp UploadResponse, err error) {
+	resp.FileLength = uint64(len(plaintext))
+	resp.MediaKey = random.Bytes(32)
+
+	plaintextSHA256 := sha256.Sum256(plaintext)
+	resp.FileSHA256 = plaintextSHA256[:]
+
+	iv, cipherKey, macKey, _ := getMediaKeys(resp.MediaKey, appInfo)
+
+	var ciphertext []byte
+	ciphertext, err = cbcutil.Encrypt(cipherKey, iv, plaintext)
+	if err != nil {
+		err = fmt.Errorf("failed to encrypt file: %w", err)
+		return
+	}
+
+	h := hmac.New(sha256.New, macKey)
+	h.Write(iv)
+	h.Write(ciphertext)
+	dataToUpload := append(ciphertext, h.Sum(nil)[:10]...)
+
+	dataHash := sha256.Sum256(dataToUpload)
+	resp.FileEncSHA256 = dataHash[:]
+
+	err = cli.rawUpload(ctx, bytes.NewReader(dataToUpload), uint64(len(dataToUpload)), resp.FileEncSHA256, appInfo, false, &resp)
+	return
+}
+
+// UploadReader uploads the given attachment to WhatsApp servers.
+//
+// This is otherwise identical to [Upload], but it reads the plaintext from an [io.Reader] instead of a byte slice.
+// A temporary file is required for the encryption process. If tempFile is nil, a temporary file will be created
+// and deleted after the upload.
+//
+// To use only one file, pass the same file as both plaintext and tempFile. This will cause the file to be overwritten with encrypted data.
+func (cli *Client) UploadReader(ctx context.Context, plaintext io.Reader, tempFile io.ReadWriteSeeker, appInfo MediaType) (resp UploadResponse, err error) {
+	resp.MediaKey = random.Bytes(32)
+	iv, cipherKey, macKey, _ := getMediaKeys(resp.MediaKey, appInfo)
+	if tempFile == nil {
+		tempFile, err = os.CreateTemp("", "whatsmeow-upload-*")
+		if err != nil {
+			err = fmt.Errorf("failed to create temporary file: %w", err)
+			return
+		}
+		defer func() {
+			tempFileFile := tempFile.(*os.File)
+			_ = tempFileFile.Close()
+			_ = os.Remove(tempFileFile.Name())
+		}()
+	}
+	var uploadSize uint64
+	resp.FileSHA256, resp.FileEncSHA256, resp.FileLength, uploadSize, err = cbcutil.EncryptStream(cipherKey, iv, macKey, plaintext, tempFile)
+	if err != nil {
+		err = fmt.Errorf("failed to encrypt file: %w", err)
+		return
+	}
+	_, err = tempFile.Seek(0, io.SeekStart)
+	if err != nil {
+		err = fmt.Errorf("failed to seek to start of temporary file: %w", err)
+		return
+	}
+	err = cli.rawUpload(ctx, tempFile, uploadSize, resp.FileEncSHA256, appInfo, false, &resp)
+	return
+}
+
+// UploadNewsletter uploads the given attachment to WhatsApp servers without encrypting it first.
+//
+// Newsletter media works mostly the same way as normal media, with a few differences:
+// * Since it's unencrypted, there's no MediaKey or FileEncSHA256 fields.
+// * There's a "media handle" that needs to be passed in SendRequestExtra.
+//
+// Example:
+//
+//	resp, err := cli.UploadNewsletter(context.Background(), yourImageBytes, whatsmeow.MediaImage)
+//	// handle error
+//
+//	imageMsg := &waE2E.ImageMessage{
+//		// Caption, mime type and other such fields work like normal
+//		Caption:  proto.String("Hello, world!"),
+//		Mimetype: proto.String("image/png"),
+//
+//		// URL and direct path are also there like normal media
+//		URL:        &resp.URL,
+//		DirectPath: &resp.DirectPath,
+//		FileSHA256: resp.FileSHA256,
+//		FileLength: &resp.FileLength,
+//		// Newsletter media isn't encrypted, so the media key and file enc sha fields are not applicable
+//	}
+//	_, err = cli.SendMessage(context.Background(), newsletterJID, &waE2E.Message{
+//		ImageMessage: imageMsg,
+//	}, whatsmeow.SendRequestExtra{
+//		// Unlike normal media, newsletters also include a "media handle" in the send request.
+//		MediaHandle: resp.Handle,
+//	})
+//	// handle error again
+func (cli *Client) UploadNewsletter(ctx context.Context, data []byte, appInfo MediaType) (resp UploadResponse, err error) {
+	resp.FileLength = uint64(len(data))
+	hash := sha256.Sum256(data)
+	resp.FileSHA256 = hash[:]
+	err = cli.rawUpload(ctx, bytes.NewReader(data), resp.FileLength, resp.FileSHA256, appInfo, true, &resp)
+	return
+}
+
+// UploadNewsletterReader uploads the given attachment to WhatsApp servers without encrypting it first.
+//
+// This is otherwise identical to [UploadNewsletter], but it reads the plaintext from an [io.Reader] instead of a byte slice.
+// Unlike [UploadReader], this does not require a temporary file. However, the data needs to be hashed first,
+// so an [io.ReadSeeker] is required to be able to read the data twice.
+func (cli *Client) UploadNewsletterReader(ctx context.Context, data io.ReadSeeker, appInfo MediaType) (resp UploadResponse, err error) {
+	hasher := sha256.New()
+	var fileLength int64
+	fileLength, err = io.Copy(hasher, data)
+	resp.FileLength = uint64(fileLength)
+	resp.FileSHA256 = hasher.Sum(nil)
+	_, err = data.Seek(0, io.SeekStart)
+	if err != nil {
+		err = fmt.Errorf("failed to seek to start of data: %w", err)
+		return
+	}
+	err = cli.rawUpload(ctx, data, resp.FileLength, resp.FileSHA256, appInfo, true, &resp)
+	return
+}
+
+func (cli *Client) rawUpload(ctx context.Context, dataToUpload io.Reader, uploadSize uint64, fileHash []byte, appInfo MediaType, newsletter bool, resp *UploadResponse) error {
+	mediaConn, err := cli.refreshMediaConn(false)
+	if err != nil {
+		return fmt.Errorf("failed to refresh media connections: %w", err)
+	}
+
+	token := base64.URLEncoding.EncodeToString(fileHash)
+	q := url.Values{
+		"auth":  []string{mediaConn.Auth},
+		"token": []string{token},
+	}
+	mmsType := mediaTypeToMMSType[appInfo]
+	uploadPrefix := "mms"
+	if cli.MessengerConfig != nil {
+		uploadPrefix = "wa-msgr/mms"
+		// Messenger upload only allows voice messages, not audio files
+		if mmsType == "audio" {
+			mmsType = "ptt"
+		}
+	}
+	if newsletter {
+		mmsType = fmt.Sprintf("newsletter-%s", mmsType)
+		uploadPrefix = "newsletter"
+	}
+	var host string
+	// Hacky hack to prefer last option (rupload.facebook.com) for messenger uploads.
+	// For some reason, the primary host doesn't work, even though it has the <upload/> tag.
+	if cli.MessengerConfig != nil {
+		host = mediaConn.Hosts[len(mediaConn.Hosts)-1].Hostname
+	} else {
+		host = mediaConn.Hosts[0].Hostname
+	}
+	uploadURL := url.URL{
+		Scheme:   "https",
+		Host:     host,
+		Path:     fmt.Sprintf("/%s/%s/%s", uploadPrefix, mmsType, token),
+		RawQuery: q.Encode(),
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL.String(), dataToUpload)
+	if err != nil {
+		return fmt.Errorf("failed to prepare request: %w", err)
+	}
+
+	req.ContentLength = int64(uploadSize)
+	req.Header.Set("Origin", socket.Origin)
+	req.Header.Set("Referer", socket.Origin+"/")
+
+	httpResp, err := cli.http.Do(req)
+	if err != nil {
+		err = fmt.Errorf("failed to execute request: %w", err)
+	} else if httpResp.StatusCode != http.StatusOK {
+		err = fmt.Errorf("upload failed with status code %d", httpResp.StatusCode)
+	} else if err = json.NewDecoder(httpResp.Body).Decode(&resp); err != nil {
+		err = fmt.Errorf("failed to parse upload response: %w", err)
+	}
+	if httpResp != nil {
+		_ = httpResp.Body.Close()
+	}
+	return err
+}