Add support for parsing outgoing requests in lscli

cmd/lscli/lscli.go

@@ -1,41 +1,69 @@
 package main
 
 import (
+	"bytes"
+	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"io"
 	"os"
+	"time"
 
+	"github.com/rs/zerolog"
+	badGlobalLog "github.com/rs/zerolog/log"
 	"github.com/tidwall/gjson"
 	"github.com/zyedidia/clipboard"
 	"go.mau.fi/util/exerrors"
 
 	"go.mau.fi/mautrix-meta/messagix"
 	"go.mau.fi/mautrix-meta/messagix/lightspeed"
+	"go.mau.fi/mautrix-meta/messagix/socket"
 	"go.mau.fi/mautrix-meta/messagix/table"
 )
 
+var taskNames = make(map[string]string)
+
+func init() {
+	for name, id := range socket.TaskLabels {
+		taskNames[id] = name
+	}
+}
+
 func main() {
+	badGlobalLog.Logger = zerolog.New(zerolog.NewConsoleWriter(func(w *zerolog.ConsoleWriter) {
+		w.Out = os.Stderr
+		w.TimeFormat = time.RFC3339
+	})).With().Timestamp().Logger()
+
 	var data []byte
 	if exerrors.Must(os.Stdin.Stat()).Mode()&os.ModeNamedPipe != 0 {
 		data = exerrors.Must(io.ReadAll(os.Stdin))
 	} else {
-		exerrors.Must(0, clipboard.Initialize())
+		exerrors.PanicIfNotNil(clipboard.Initialize())
 		data = []byte(exerrors.Must(clipboard.ReadAll("clipboard")))
 	}
-	fmt.Println(len(data))
 	if !json.Valid(data) {
-		_, _ = fmt.Fprintln(os.Stderr, "invalid json")
-		return
+		data, _ = base64.StdEncoding.DecodeString(string(data))
+		if bytes.Contains(data[:20], []byte("/ls_req")) || bytes.Contains(data[:20], []byte("/ls_resp")) {
+			data = data[bytes.Index(data, []byte(`{"`)):]
+		}
+		if !json.Valid(data) {
+			_, _ = fmt.Fprintln(os.Stderr, "invalid json")
+			return
+		}
 	}
 
 	var lsData *lightspeed.LightSpeedData
 	var dependencies map[string]string
 	if gjson.GetBytes(data, "payload").Exists() {
+		if gjson.GetBytes(data, "app_id").Exists() {
+			handleOutgoingRequest(data)
+			return
+		}
 		var pbd *messagix.PublishResponseData
-		exerrors.Must(0, json.Unmarshal(data, &pbd))
+		exerrors.PanicIfNotNil(json.Unmarshal(data, &pbd))
 		dependencies = table.SPToDepMap(pbd.Sp)
-		exerrors.Must(0, json.Unmarshal([]byte(pbd.Payload), &lsData))
+		exerrors.PanicIfNotNil(json.Unmarshal([]byte(pbd.Payload), &lsData))
 	} else if gjson.GetBytes(data, "data.lightspeed_web_request_for_igd").Exists() {
 
 	} else {
@@ -45,5 +73,51 @@ func main() {
 	tbl := table.LSTable{}
 	decoder := lightspeed.NewLightSpeedDecoder(dependencies, &tbl)
 	decoder.Decode(lsData.Steps)
-	exerrors.Must(0, json.NewEncoder(os.Stdout).Encode(&tbl))
+	exerrors.PanicIfNotNil(json.NewEncoder(os.Stdout).Encode(&tbl))
+}
+
+type formattedOutgoingRequest struct {
+	AppID       string          `json:"app_id"`
+	RequestID   int             `json:"request_id"`
+	Type        int             `json:"type"`
+	EpochID     int64           `json:"epoch_id"`
+	DataTraceID string          `json:"data_trace_id"`
+	VersionID   string          `json:"version_id"`
+	Tasks       []formattedTask `json:"tasks"`
+}
+
+type formattedTask struct {
+	FailureCount *int64          `json:"failure_count"`
+	Label        string          `json:"label"`
+	LabelName    string          `json:"label_name"`
+	QueueName    any             `json:"queue_name"`
+	TaskID       int64           `json:"task_id"`
+	Payload      json.RawMessage `json:"payload"`
+}
+
+func handleOutgoingRequest(data json.RawMessage) {
+	var payload messagix.SocketLSRequestPayload
+	exerrors.PanicIfNotNil(json.Unmarshal(data, &payload))
+	var taskPayload socket.TaskPayload
+	exerrors.PanicIfNotNil(json.Unmarshal([]byte(payload.Payload), &taskPayload))
+	formattedTasks := make([]formattedTask, len(taskPayload.Tasks))
+	for i, task := range taskPayload.Tasks {
+		formattedTasks[i] = formattedTask{
+			FailureCount: task.FailureCount,
+			Label:        task.Label,
+			LabelName:    taskNames[task.Label],
+			QueueName:    task.QueueName,
+			TaskID:       task.TaskId,
+			Payload:      json.RawMessage(task.Payload.(string)),
+		}
+	}
+	exerrors.PanicIfNotNil(json.NewEncoder(os.Stdout).Encode(&formattedOutgoingRequest{
+		AppID:       payload.AppId,
+		RequestID:   payload.RequestId,
+		Type:        payload.Type,
+		EpochID:     taskPayload.EpochId,
+		DataTraceID: taskPayload.DataTraceId,
+		VersionID:   taskPayload.VersionId,
+		Tasks:       formattedTasks,
+	}))
 }

messagix/socket/task.go

@@ -37,7 +37,7 @@ type Task interface {
 }
 
 type TaskData struct {
-	FailureCount interface{} `json:"failure_count"`
+	FailureCount *int64      `json:"failure_count"`
 	Label        string      `json:"label,omitempty"`
 	Payload      interface{} `json:"payload,omitempty"`
 	QueueName    interface{} `json:"queue_name,omitempty"`