From df7d5f4135a1dfd49cf0c2f92fd660ca117dec8e Mon Sep 17 00:00:00 2001 From: OpenWaygate <27287694+OpenWaygate@users.noreply.github.com> Date: Sun, 17 Aug 2025 19:33:31 +0800 Subject: [PATCH] :loud_sound: Add logger to mcp issue #64 --- cmd/caption/delete.go | 15 ++++++++++++++- cmd/caption/download.go | 15 ++++++++++++++- cmd/caption/insert.go | 15 ++++++++++++++- cmd/caption/list.go | 15 ++++++++++++++- cmd/caption/update.go | 15 ++++++++++++++- cmd/channel/list.go | 15 ++++++++++++++- cmd/channel/update.go | 15 ++++++++++++++- cmd/channelBanner/insert.go | 15 ++++++++++++++- cmd/channelSection/delete.go | 15 ++++++++++++++- cmd/channelSection/list.go | 15 ++++++++++++++- cmd/comment/delete.go | 15 ++++++++++++++- cmd/comment/insert.go | 15 ++++++++++++++- cmd/comment/list.go | 15 ++++++++++++++- cmd/comment/markAsSpam.go | 15 ++++++++++++++- cmd/comment/setModerationStatus.go | 15 ++++++++++++++- cmd/comment/update.go | 15 ++++++++++++++- cmd/commentThread/insert.go | 15 ++++++++++++++- cmd/commentThread/list.go | 15 ++++++++++++++- cmd/i18nLanguage/list.go | 27 +++++++++++++++++++++++++++ cmd/i18nRegion/list.go | 14 ++++++++++++++ cmd/member/list.go | 15 ++++++++++++++- cmd/membershipsLevel/list.go | 15 ++++++++++++++- cmd/playlist/delete.go | 15 ++++++++++++++- cmd/playlist/insert.go | 15 ++++++++++++++- cmd/playlist/list.go | 15 ++++++++++++++- cmd/playlist/update.go | 15 ++++++++++++++- cmd/playlistImage/delete.go | 15 ++++++++++++++- cmd/playlistImage/insert.go | 15 ++++++++++++++- cmd/playlistImage/list.go | 15 ++++++++++++++- cmd/playlistImage/update.go | 15 ++++++++++++++- cmd/playlistItem/delete.go | 15 ++++++++++++++- cmd/playlistItem/insert.go | 15 ++++++++++++++- cmd/playlistItem/list.go | 15 ++++++++++++++- cmd/playlistItem/update.go | 15 ++++++++++++++- cmd/search/list.go | 15 ++++++++++++++- cmd/subscription/delete.go | 15 ++++++++++++++- cmd/subscription/insert.go | 15 ++++++++++++++- cmd/subscription/list.go | 15 ++++++++++++++- cmd/superChatEvent/list.go | 15 ++++++++++++++- cmd/thumbnail/set.go | 15 ++++++++++++++- cmd/video/delete.go | 15 ++++++++++++++- cmd/video/getRating.go | 15 ++++++++++++++- cmd/video/insert.go | 15 ++++++++++++++- cmd/video/list.go | 15 ++++++++++++++- cmd/video/rate.go | 15 ++++++++++++++- cmd/video/reportAbuse.go | 15 ++++++++++++++- cmd/video/update.go | 15 ++++++++++++++- cmd/videoAbuseReportReason/list.go | 15 ++++++++++++++- cmd/videoCategory/list.go | 15 ++++++++++++++- cmd/watermark/set.go | 15 ++++++++++++++- cmd/watermark/unset.go | 15 ++++++++++++++- 51 files changed, 727 insertions(+), 49 deletions(-) diff --git a/cmd/caption/delete.go b/cmd/caption/delete.go index 54ab22f..248f31e 100644 --- a/cmd/caption/delete.go +++ b/cmd/caption/delete.go @@ -3,11 +3,13 @@ package caption import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/caption" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -76,11 +78,22 @@ func deleteHandler( onBehalfOf, _ = args["onBehalfOf"].(string) onBehalfOfContentOwner, _ = args["onBehalfOfContentOwner"].(string) + slog.InfoContext(ctx, "caption delete started") + var writer bytes.Buffer err := del(&writer) if err != nil { + slog.ErrorContext( + ctx, "caption delete failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "caption delete completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/caption/download.go b/cmd/caption/download.go index 0489447..305af26 100644 --- a/cmd/caption/download.go +++ b/cmd/caption/download.go @@ -3,11 +3,13 @@ package caption import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/caption" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -97,11 +99,22 @@ func downloadHandler( onBehalfOf, _ = args["onBehalfOf"].(string) onBehalfOfContentOwner, _ = args["onBehalfOfContentOwner"].(string) + slog.InfoContext(ctx, "caption download started") + var writer bytes.Buffer err := download(&writer) if err != nil { + slog.ErrorContext( + ctx, "caption download failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "caption download completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/caption/insert.go b/cmd/caption/insert.go index 7e0668c..51a03b3 100644 --- a/cmd/caption/insert.go +++ b/cmd/caption/insert.go @@ -3,12 +3,14 @@ package caption import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/caption" "github.com/eat-pray-ai/yutu/pkg/utils" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -158,11 +160,22 @@ func insertHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "caption insert started") + var writer bytes.Buffer err := insert(&writer) if err != nil { + slog.ErrorContext( + ctx, "caption insert failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "caption insert completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/caption/list.go b/cmd/caption/list.go index de91f52..3083af9 100644 --- a/cmd/caption/list.go +++ b/cmd/caption/list.go @@ -3,11 +3,13 @@ package caption import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/caption" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -105,11 +107,22 @@ func listHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "caption list started") + var writer bytes.Buffer err := list(&writer) if err != nil { + slog.ErrorContext( + ctx, "caption list failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "caption list completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/caption/update.go b/cmd/caption/update.go index 3089b08..5565836 100644 --- a/cmd/caption/update.go +++ b/cmd/caption/update.go @@ -3,12 +3,14 @@ package caption import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/caption" "github.com/eat-pray-ai/yutu/pkg/utils" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -156,11 +158,22 @@ func updateHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "caption update started") + var writer bytes.Buffer err := update(&writer) if err != nil { + slog.ErrorContext( + ctx, "caption update failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "caption update completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/channel/list.go b/cmd/channel/list.go index 7559e17..a0c5952 100644 --- a/cmd/channel/list.go +++ b/cmd/channel/list.go @@ -3,12 +3,14 @@ package channel import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/channel" "github.com/eat-pray-ai/yutu/pkg/utils" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -161,11 +163,22 @@ func listHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "channel list started") + var writer bytes.Buffer err := list(&writer) if err != nil { + slog.ErrorContext( + ctx, "channel list failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "channel list completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/channel/update.go b/cmd/channel/update.go index 9a90b6c..88bc9de 100644 --- a/cmd/channel/update.go +++ b/cmd/channel/update.go @@ -3,11 +3,13 @@ package channel import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/channel" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -113,11 +115,22 @@ func updateHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "channel update started") + var writer bytes.Buffer err := update(&writer) if err != nil { + slog.ErrorContext( + ctx, "channel update failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "channel update completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/channelBanner/insert.go b/cmd/channelBanner/insert.go index 5683355..705dbff 100644 --- a/cmd/channelBanner/insert.go +++ b/cmd/channelBanner/insert.go @@ -3,11 +3,13 @@ package channelBanner import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/channelBanner" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) func init() { @@ -86,11 +88,22 @@ func insertHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "channelBanner insert started") + var writer bytes.Buffer err := insert(&writer) if err != nil { + slog.ErrorContext( + ctx, "channelBanner insert failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "channelBanner insert completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/channelSection/delete.go b/cmd/channelSection/delete.go index 479c952..b698a3a 100644 --- a/cmd/channelSection/delete.go +++ b/cmd/channelSection/delete.go @@ -3,11 +3,13 @@ package channelSection import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/channelSection" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -70,11 +72,22 @@ func deleteHandler( } onBehalfOfContentOwner, _ = args["onBehalfOfContentOwner"].(string) + slog.InfoContext(ctx, "channelSection delete started") + var writer bytes.Buffer err := del(&writer) if err != nil { + slog.ErrorContext( + ctx, "channelSection delete failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "channelSection delete completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/channelSection/list.go b/cmd/channelSection/list.go index cbb928f..2bcaa4b 100644 --- a/cmd/channelSection/list.go +++ b/cmd/channelSection/list.go @@ -3,12 +3,14 @@ package channelSection import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/channelSection" "github.com/eat-pray-ai/yutu/pkg/utils" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -113,11 +115,22 @@ func listHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "channelSection list started") + var writer bytes.Buffer err := list(&writer) if err != nil { + slog.ErrorContext( + ctx, "channelSection list failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "channelSection list completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/comment/delete.go b/cmd/comment/delete.go index 77a0d9d..a8390ca 100644 --- a/cmd/comment/delete.go +++ b/cmd/comment/delete.go @@ -3,11 +3,13 @@ package comment import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/comment" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -60,11 +62,22 @@ func deleteHandler( ids[i] = id.(string) } + slog.InfoContext(ctx, "comment delete started") + var writer bytes.Buffer err := del(&writer) if err != nil { + slog.ErrorContext( + ctx, "comment delete failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "comment delete completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/comment/insert.go b/cmd/comment/insert.go index c5bf2b6..ca0e2fa 100644 --- a/cmd/comment/insert.go +++ b/cmd/comment/insert.go @@ -3,12 +3,14 @@ package comment import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/comment" "github.com/eat-pray-ai/yutu/pkg/utils" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -113,11 +115,22 @@ func insertHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "comment insert started") + var writer bytes.Buffer err := insert(&writer) if err != nil { + slog.ErrorContext( + ctx, "comment insert failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "comment insert completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/comment/list.go b/cmd/comment/list.go index e37a64d..9924b8d 100644 --- a/cmd/comment/list.go +++ b/cmd/comment/list.go @@ -3,11 +3,13 @@ package comment import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/comment" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -109,11 +111,22 @@ func listHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "comment list started") + var writer bytes.Buffer err := list(&writer) if err != nil { + slog.ErrorContext( + ctx, "comment list failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "comment list completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/comment/markAsSpam.go b/cmd/comment/markAsSpam.go index c7880c0..d304488 100644 --- a/cmd/comment/markAsSpam.go +++ b/cmd/comment/markAsSpam.go @@ -3,11 +3,13 @@ package comment import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/comment" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -73,11 +75,22 @@ func markAsSpamHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "comment markAsSpam started") + var writer bytes.Buffer err := markAsSpam(&writer) if err != nil { + slog.ErrorContext( + ctx, "comment markAsSpam failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "comment markAsSpam completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/comment/setModerationStatus.go b/cmd/comment/setModerationStatus.go index 777d693..eea3a67 100644 --- a/cmd/comment/setModerationStatus.go +++ b/cmd/comment/setModerationStatus.go @@ -3,12 +3,14 @@ package comment import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/comment" "github.com/eat-pray-ai/yutu/pkg/utils" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -98,11 +100,22 @@ func setModerationStatusHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "comment setModerationStatus started") + var writer bytes.Buffer err := setModerationStatus(&writer) if err != nil { + slog.ErrorContext( + ctx, "comment setModerationStatus failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "comment setModerationStatus completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/comment/update.go b/cmd/comment/update.go index eb7a57e..ec046ff 100644 --- a/cmd/comment/update.go +++ b/cmd/comment/update.go @@ -3,12 +3,14 @@ package comment import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/comment" "github.com/eat-pray-ai/yutu/pkg/utils" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -98,11 +100,22 @@ func updateHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "comment update started") + var writer bytes.Buffer err := update(&writer) if err != nil { + slog.ErrorContext( + ctx, "comment update failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "comment update completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/commentThread/insert.go b/cmd/commentThread/insert.go index 059d8ec..283d2fa 100644 --- a/cmd/commentThread/insert.go +++ b/cmd/commentThread/insert.go @@ -3,11 +3,13 @@ package commentThread import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/commentThread" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -91,11 +93,22 @@ func insertHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "commentThread insert started") + var writer bytes.Buffer err := insert(&writer) if err != nil { + slog.ErrorContext( + ctx, "commentThread insert failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "commentThread insert completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/commentThread/list.go b/cmd/commentThread/list.go index 2e99377..ec79f0e 100644 --- a/cmd/commentThread/list.go +++ b/cmd/commentThread/list.go @@ -3,11 +3,13 @@ package commentThread import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/commentThread" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -140,11 +142,22 @@ func listHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "commentThread list started") + var writer bytes.Buffer err := list(&writer) if err != nil { + slog.ErrorContext( + ctx, "commentThread list failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "commentThread list completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/i18nLanguage/list.go b/cmd/i18nLanguage/list.go index 35af31d..ce831a9 100644 --- a/cmd/i18nLanguage/list.go +++ b/cmd/i18nLanguage/list.go @@ -4,6 +4,7 @@ import ( "bytes" "context" "io" + "log/slog" "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/i18nLanguage" @@ -50,12 +51,25 @@ func hlHandler( parts = defaultParts output = "json" jpath = "$.*.snippet.hl" + + slog.InfoContext(ctx, "i18nLanguage hl list started") + var writer bytes.Buffer err := list(&writer) if err != nil { + slog.ErrorContext( + ctx, "i18nLanguage hl list failed", + "error", err, + "uri", request.Params.URI, + ) return nil, err } + slog.InfoContext( + ctx, "i18nLanguage hl list completed successfully", + "resultSize", writer.Len(), + ) + contents := []mcp.ResourceContents{ mcp.TextResourceContents{ URI: hlURI, @@ -79,12 +93,25 @@ func langsHandler( parts = defaultParts hl = utils.ExtractHl(request.Params.URI) output = "json" + + slog.InfoContext(ctx, "i18nLanguage list started") + var writer bytes.Buffer err := list(&writer) if err != nil { + slog.ErrorContext( + ctx, "i18nLanguage list failed", + "error", err, + "uri", request.Params.URI, + ) return nil, err } + slog.InfoContext( + ctx, "i18nLanguage list completed successfully", + "resultSize", writer.Len(), + ) + contents := []mcp.ResourceContents{ mcp.TextResourceContents{ URI: request.Params.URI, diff --git a/cmd/i18nRegion/list.go b/cmd/i18nRegion/list.go index da61519..6f3fcb5 100644 --- a/cmd/i18nRegion/list.go +++ b/cmd/i18nRegion/list.go @@ -4,6 +4,7 @@ import ( "bytes" "context" "io" + "log/slog" "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/i18nRegion" @@ -49,12 +50,25 @@ func regionsHandler( parts = defaultParts hl = utils.ExtractHl(request.Params.URI) output = "json" + + slog.InfoContext(ctx, "i18nRegion list started") + var writer bytes.Buffer err := list(&writer) if err != nil { + slog.ErrorContext( + ctx, "i18nRegion list failed", + "error", err, + "uri", request.Params.URI, + ) return nil, err } + slog.InfoContext( + ctx, "i18nRegion list completed successfully", + "resultSize", writer.Len(), + ) + contents := []mcp.ResourceContents{ mcp.TextResourceContents{ URI: request.Params.URI, diff --git a/cmd/member/list.go b/cmd/member/list.go index 34a38ad..4a770b0 100644 --- a/cmd/member/list.go +++ b/cmd/member/list.go @@ -3,11 +3,13 @@ package member import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/member" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) func init() { @@ -97,11 +99,22 @@ func listHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "member list started") + var writer bytes.Buffer err := list(&writer) if err != nil { + slog.ErrorContext( + ctx, "member list failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "member list completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/membershipsLevel/list.go b/cmd/membershipsLevel/list.go index c2be6ea..2d3c993 100644 --- a/cmd/membershipsLevel/list.go +++ b/cmd/membershipsLevel/list.go @@ -3,11 +3,13 @@ package membershipsLevel import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/membershipsLevel" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) func init() { @@ -68,11 +70,22 @@ func listHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "membershipsLevel list started") + var writer bytes.Buffer err := list(&writer) if err != nil { + slog.ErrorContext( + ctx, "membershipsLevel list failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "membershipsLevel list completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/playlist/delete.go b/cmd/playlist/delete.go index 3b3c371..3e242cf 100644 --- a/cmd/playlist/delete.go +++ b/cmd/playlist/delete.go @@ -3,11 +3,13 @@ package playlist import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/playlist" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -70,11 +72,22 @@ func deleteHandler( } onBehalfOfContentOwner, _ = args["onBehalfOfContentOwner"].(string) + slog.InfoContext(ctx, "playlist delete started") + var writer bytes.Buffer err := del(&writer) if err != nil { + slog.ErrorContext( + ctx, "playlist delete failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "playlist delete completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/playlist/insert.go b/cmd/playlist/insert.go index e089aa8..4cbc8d0 100644 --- a/cmd/playlist/insert.go +++ b/cmd/playlist/insert.go @@ -3,11 +3,13 @@ package playlist import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/playlist" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -106,11 +108,22 @@ func insertHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "playlist insert started") + var writer bytes.Buffer err := insert(&writer) if err != nil { + slog.ErrorContext( + ctx, "playlist insert failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "playlist insert completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/playlist/list.go b/cmd/playlist/list.go index e8d1351..74057df 100644 --- a/cmd/playlist/list.go +++ b/cmd/playlist/list.go @@ -3,12 +3,14 @@ package playlist import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/playlist" "github.com/eat-pray-ai/yutu/pkg/utils" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -132,11 +134,22 @@ func listHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "playlist list started") + var writer bytes.Buffer err := list(&writer) if err != nil { + slog.ErrorContext( + ctx, "playlist list failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "playlist list completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/playlist/update.go b/cmd/playlist/update.go index f208542..8079fe9 100644 --- a/cmd/playlist/update.go +++ b/cmd/playlist/update.go @@ -3,11 +3,13 @@ package playlist import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/playlist" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -109,11 +111,22 @@ func updateHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "playlist update started") + var writer bytes.Buffer err := update(&writer) if err != nil { + slog.ErrorContext( + ctx, "playlist update failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "playlist update completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/playlistImage/delete.go b/cmd/playlistImage/delete.go index f28a215..0bba10d 100644 --- a/cmd/playlistImage/delete.go +++ b/cmd/playlistImage/delete.go @@ -3,11 +3,13 @@ package playlistImage import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/playlistImage" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -69,11 +71,22 @@ func deleteHandler( } onBehalfOfContentOwner, _ = args["onBehalfOfContentOwner"].(string) + slog.InfoContext(ctx, "playlistImage delete started") + var writer bytes.Buffer err := del(&writer) if err != nil { + slog.ErrorContext( + ctx, "playlistImage delete failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "playlistImage delete completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/playlistImage/insert.go b/cmd/playlistImage/insert.go index a283215..0f5a2ae 100644 --- a/cmd/playlistImage/insert.go +++ b/cmd/playlistImage/insert.go @@ -3,11 +3,13 @@ package playlistImage import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/playlistImage" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -95,11 +97,22 @@ func insertHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "playlistImage insert started") + var writer bytes.Buffer err := insert(&writer) if err != nil { + slog.ErrorContext( + ctx, "playlistImage insert failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "playlistImage insert completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/playlistImage/list.go b/cmd/playlistImage/list.go index c184f91..d3ecc55 100644 --- a/cmd/playlistImage/list.go +++ b/cmd/playlistImage/list.go @@ -3,11 +3,13 @@ package playlistImage import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/playlistImage" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -102,11 +104,22 @@ func listHandler( onBehalfOfContentOwner, _ = args["onBehalfOfContentOwner"].(string) onBehalfOfContentOwnerChannel, _ = args["onBehalfOfContentOwnerChannel"].(string) + slog.InfoContext(ctx, "playlistImage list started") + var writer bytes.Buffer err := list(&writer) if err != nil { + slog.ErrorContext( + ctx, "playlistImage list failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "playlistImage list completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/playlistImage/update.go b/cmd/playlistImage/update.go index 38c41ac..e99647c 100644 --- a/cmd/playlistImage/update.go +++ b/cmd/playlistImage/update.go @@ -3,11 +3,13 @@ package playlistImage import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/playlistImage" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -88,11 +90,22 @@ func updateHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "playlistImage update started") + var writer bytes.Buffer err := update(&writer) if err != nil { + slog.ErrorContext( + ctx, "playlistImage update failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "playlistImage update completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/playlistItem/delete.go b/cmd/playlistItem/delete.go index 80bdb37..f3810b1 100644 --- a/cmd/playlistItem/delete.go +++ b/cmd/playlistItem/delete.go @@ -3,11 +3,13 @@ package playlistItem import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/playlistItem" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -70,11 +72,22 @@ func deleteHandler( } onBehalfOfContentOwner, _ = args["onBehalfOfContentOwner"].(string) + slog.InfoContext(ctx, "playlistItem delete started") + var writer bytes.Buffer err := del(&writer) if err != nil { + slog.ErrorContext( + ctx, "playlistItem delete failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "playlistItem delete completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/playlistItem/insert.go b/cmd/playlistItem/insert.go index 59171ba..38fd238 100644 --- a/cmd/playlistItem/insert.go +++ b/cmd/playlistItem/insert.go @@ -3,11 +3,13 @@ package playlistItem import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/playlistItem" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -129,11 +131,22 @@ func insertHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "playlistItem insert started") + var writer bytes.Buffer err := insert(&writer) if err != nil { + slog.ErrorContext( + ctx, "playlistItem insert failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "playlistItem insert completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/playlistItem/list.go b/cmd/playlistItem/list.go index d6d6818..3a3e6b6 100644 --- a/cmd/playlistItem/list.go +++ b/cmd/playlistItem/list.go @@ -3,11 +3,13 @@ package playlistItem import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/playlistItem" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -113,11 +115,22 @@ func listHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "playlistItem list started") + var writer bytes.Buffer err := list(&writer) if err != nil { + slog.ErrorContext( + ctx, "playlistItem list failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "playlistItem list completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/playlistItem/update.go b/cmd/playlistItem/update.go index 545f56f..062b03b 100644 --- a/cmd/playlistItem/update.go +++ b/cmd/playlistItem/update.go @@ -3,11 +3,13 @@ package playlistItem import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/playlistItem" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -100,11 +102,22 @@ func updateHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "playlistItem update started") + var writer bytes.Buffer err := update(&writer) if err != nil { + slog.ErrorContext( + ctx, "playlistItem update failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "playlistItem update completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/search/list.go b/cmd/search/list.go index 54ab443..442a770 100644 --- a/cmd/search/list.go +++ b/cmd/search/list.go @@ -3,12 +3,14 @@ package search import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/search" "github.com/eat-pray-ai/yutu/pkg/utils" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) func init() { @@ -266,11 +268,22 @@ func listHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "search list started") + var writer bytes.Buffer err := list(&writer) if err != nil { + slog.ErrorContext( + ctx, "search list failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "search list completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/subscription/delete.go b/cmd/subscription/delete.go index 0313366..0deec77 100644 --- a/cmd/subscription/delete.go +++ b/cmd/subscription/delete.go @@ -3,11 +3,13 @@ package subscription import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/subscription" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -61,11 +63,22 @@ func deleteHandler( ids[i] = id.(string) } + slog.InfoContext(ctx, "subscription delete started") + var writer bytes.Buffer err := del(&writer) if err != nil { + slog.ErrorContext( + ctx, "subscription delete failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "subscription delete completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/subscription/insert.go b/cmd/subscription/insert.go index 78b37c5..021ed21 100644 --- a/cmd/subscription/insert.go +++ b/cmd/subscription/insert.go @@ -3,11 +3,13 @@ package subscription import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/subscription" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -90,11 +92,22 @@ func insertHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "subscription insert started") + var writer bytes.Buffer err := insert(&writer) if err != nil { + slog.ErrorContext( + ctx, "subscription insert failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "subscription insert completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/subscription/list.go b/cmd/subscription/list.go index e512fe9..38c2227 100644 --- a/cmd/subscription/list.go +++ b/cmd/subscription/list.go @@ -3,12 +3,14 @@ package subscription import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/subscription" "github.com/eat-pray-ai/yutu/pkg/utils" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -156,11 +158,22 @@ func listHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "subscription list started") + var writer bytes.Buffer err := list(&writer) if err != nil { + slog.ErrorContext( + ctx, "subscription list failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "subscription list completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/superChatEvent/list.go b/cmd/superChatEvent/list.go index e932fb1..b9a4cae 100644 --- a/cmd/superChatEvent/list.go +++ b/cmd/superChatEvent/list.go @@ -3,11 +3,13 @@ package superChatEvent import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/superChatEvent" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) func init() { @@ -81,11 +83,22 @@ func listHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "superChatEvent list started") + var writer bytes.Buffer err := list(&writer) if err != nil { + slog.ErrorContext( + ctx, "superChatEvent list failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "superChatEvent list completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/thumbnail/set.go b/cmd/thumbnail/set.go index ed6d6e4..38a29ba 100644 --- a/cmd/thumbnail/set.go +++ b/cmd/thumbnail/set.go @@ -3,11 +3,13 @@ package thumbnail import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/thumbnail" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) func init() { @@ -70,11 +72,22 @@ func setHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "thumbnail set started") + var writer bytes.Buffer err := set(&writer) if err != nil { + slog.ErrorContext( + ctx, "thumbnail set failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "thumbnail set completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/video/delete.go b/cmd/video/delete.go index 4010504..09303d0 100644 --- a/cmd/video/delete.go +++ b/cmd/video/delete.go @@ -3,11 +3,13 @@ package video import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/video" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -61,11 +63,22 @@ func deleteHandler( ids[i] = id.(string) } + slog.InfoContext(ctx, "video delete started") + var writer bytes.Buffer err := del(&writer) if err != nil { + slog.ErrorContext( + ctx, "video delete failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "video delete completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/video/getRating.go b/cmd/video/getRating.go index a7a9889..9be6f67 100644 --- a/cmd/video/getRating.go +++ b/cmd/video/getRating.go @@ -3,11 +3,13 @@ package video import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/video" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -82,11 +84,22 @@ func getRatingHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "video getRating started") + var writer bytes.Buffer err := getRating(&writer) if err != nil { + slog.ErrorContext( + ctx, "video getRating failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "video getRating completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/video/insert.go b/cmd/video/insert.go index 200929c..dc9bcda 100644 --- a/cmd/video/insert.go +++ b/cmd/video/insert.go @@ -3,12 +3,14 @@ package video import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/utils" "github.com/eat-pray-ai/yutu/pkg/video" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -209,11 +211,22 @@ func insertHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "video insert started") + var writer bytes.Buffer err := insert(&writer) if err != nil { + slog.ErrorContext( + ctx, "video insert failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "video insert completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/video/list.go b/cmd/video/list.go index 163a21b..d9dcb1c 100644 --- a/cmd/video/list.go +++ b/cmd/video/list.go @@ -3,11 +3,13 @@ package video import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/video" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -151,11 +153,22 @@ func listHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "video list started") + var writer bytes.Buffer err := list(&writer) if err != nil { + slog.ErrorContext( + ctx, "video list failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "video list completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/video/rate.go b/cmd/video/rate.go index 31748f3..55db77d 100644 --- a/cmd/video/rate.go +++ b/cmd/video/rate.go @@ -3,11 +3,13 @@ package video import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/video" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -70,11 +72,22 @@ func rateHandler( } rating, _ = args["rating"].(string) + slog.InfoContext(ctx, "video rate started") + var writer bytes.Buffer err := rate(&writer) if err != nil { + slog.ErrorContext( + ctx, "video rate failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "video rate completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/video/reportAbuse.go b/cmd/video/reportAbuse.go index b70d93f..bfd7fcf 100644 --- a/cmd/video/reportAbuse.go +++ b/cmd/video/reportAbuse.go @@ -3,11 +3,13 @@ package video import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/video" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -101,11 +103,22 @@ func reportAbuseHandler( language, _ = args["language"].(string) onBehalfOfContentOwner, _ = args["onBehalfOfContentOwner"].(string) + slog.InfoContext(ctx, "video reportAbuse started") + var writer bytes.Buffer err := reportAbuse(&writer) if err != nil { + slog.ErrorContext( + ctx, "video reportAbuse failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "video reportAbuse completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/video/update.go b/cmd/video/update.go index d4bd6ee..36019a7 100644 --- a/cmd/video/update.go +++ b/cmd/video/update.go @@ -3,12 +3,14 @@ package video import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/utils" "github.com/eat-pray-ai/yutu/pkg/video" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -144,11 +146,22 @@ func updateHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "video update started") + var writer bytes.Buffer err := update(&writer) if err != nil { + slog.ErrorContext( + ctx, "video update failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "video update completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/videoAbuseReportReason/list.go b/cmd/videoAbuseReportReason/list.go index 86e2f41..8e942b3 100644 --- a/cmd/videoAbuseReportReason/list.go +++ b/cmd/videoAbuseReportReason/list.go @@ -3,11 +3,13 @@ package videoAbuseReportReason import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/videoAbuseReportReason" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) func init() { @@ -74,11 +76,22 @@ func listHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "videoAbuseReportReason list started") + var writer bytes.Buffer err := list(&writer) if err != nil { + slog.ErrorContext( + ctx, "videoAbuseReportReason list failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "videoAbuseReportReason list completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/videoCategory/list.go b/cmd/videoCategory/list.go index 51e8893..9a84ff9 100644 --- a/cmd/videoCategory/list.go +++ b/cmd/videoCategory/list.go @@ -3,11 +3,13 @@ package videoCategory import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/videoCategory" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) func init() { @@ -91,11 +93,22 @@ func listHandler( output, _ = args["output"].(string) jpath, _ = args["jsonpath"].(string) + slog.InfoContext(ctx, "videoCategory list started") + var writer bytes.Buffer err := list(&writer) if err != nil { + slog.ErrorContext( + ctx, "videoCategory list failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "videoCategory list completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/watermark/set.go b/cmd/watermark/set.go index 0f60ee3..62977cd 100644 --- a/cmd/watermark/set.go +++ b/cmd/watermark/set.go @@ -3,11 +3,13 @@ package watermark import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/watermark" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -100,11 +102,22 @@ func setHandler( offsetType, _ = args["offsetType"].(string) onBehalfOfContentOwner, _ = args["onBehalfOfContentOwner"].(string) + slog.InfoContext(ctx, "watermark set started") + var writer bytes.Buffer err := set(&writer) if err != nil { + slog.ErrorContext( + ctx, "watermark set failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "watermark set completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil } diff --git a/cmd/watermark/unset.go b/cmd/watermark/unset.go index 9ba51d8..7db8561 100644 --- a/cmd/watermark/unset.go +++ b/cmd/watermark/unset.go @@ -3,11 +3,13 @@ package watermark import ( "bytes" "context" + "io" + "log/slog" + "github.com/eat-pray-ai/yutu/cmd" "github.com/eat-pray-ai/yutu/pkg/watermark" "github.com/mark3labs/mcp-go/mcp" "github.com/spf13/cobra" - "io" ) const ( @@ -55,11 +57,22 @@ func unsetHandler( args := request.GetArguments() channelId, _ = args["channelId"].(string) + slog.InfoContext(ctx, "watermark unset started") + var writer bytes.Buffer err := unset(&writer) if err != nil { + slog.ErrorContext( + ctx, "watermark unset failed", + "error", err, + "args", args, + ) return mcp.NewToolResultError(err.Error()), err } + slog.InfoContext( + ctx, "watermark unset completed successfully", + "resultSize", writer.Len(), + ) return mcp.NewToolResultText(writer.String()), nil }