feat: add subcommand extract to slim (#716)

* feat: add subcommand extract to slim

* add download logic when extract

* Update pkg/slim/extract.go

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

* build and upload slim binrary when release

---------

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

Author: 41tair

.github/workflows/publish-cli.yaml

@@ -37,6 +37,7 @@ jobs:
           CGO_ENABLED=0 GOOS=windows GOARCH=${{ env.GOARCH }} go build -ldflags "-X 'main.VersionX=v${{ github.event.release.tag_name }}'" -o dify-plugin-windows-${{ env.GOARCH }}.exe ./cmd/commandline
           CGO_ENABLED=0 GOOS=darwin GOARCH=${{ env.GOARCH }} go build -ldflags "-X 'main.VersionX=v${{ github.event.release.tag_name }}'" -o dify-plugin-darwin-${{ env.GOARCH }} ./cmd/commandline
           CGO_ENABLED=0 GOOS=linux GOARCH=${{ env.GOARCH }} go build -ldflags "-X 'main.VersionX=v${{ github.event.release.tag_name }}'" -o dify-plugin-linux-${{ env.GOARCH }} ./cmd/commandline
+          CGO_ENABLED=0 GOOS=linux GOARCH=${{ env.GOARCH }} go build -o dify-plugin-slim-linux-${{ env.GOARCH }} ./cmd/slim
 
       - name: Upload Artifacts
         uses: actions/upload-artifact@v4
@@ -50,6 +51,7 @@ jobs:
         run: |
           gh release upload ${{ github.event.release.tag_name }} dify-plugin-windows-${{ env.GOARCH }}.exe --clobber
           gh release upload ${{ github.event.release.tag_name }} dify-plugin-linux-${{ env.GOARCH }} --clobber
+          gh release upload ${{ github.event.release.tag_name }} dify-plugin-slim-linux-${{ env.GOARCH }} --clobber
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 

cmd/slim/main.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"encoding/json"
 	"flag"
+	"fmt"
 	"io"
 	"log/slog"
 	"os"
@@ -13,10 +14,16 @@ import (
 
 func main() {
 	slog.SetDefault(slog.New(slog.NewTextHandler(io.Discard, nil)))
+	if len(os.Args) > 1 && os.Args[1] == "extract" {
+		runExtractCommand(os.Args[2:])
+		return
+	}
+
 	id := flag.String("id", "", "plugin unique identifier")
 	action := flag.String("action", "", "plugin access action")
 	args := flag.String("args", "", "plugin invocation parameters (JSON); if omitted, read from stdin")
 	configFile := flag.String("config", "", "path to JSON config file (replaces env vars)")
+	flag.Usage = rootUsage
 	flag.Parse()
 
 	if *id == "" || *action == "" {
@@ -66,6 +73,70 @@ func main() {
 	}
 }
 
+func runExtractCommand(args []string) {
+	fs := flag.NewFlagSet("extract", flag.ContinueOnError)
+	fs.SetOutput(os.Stderr)
+	id := fs.String("id", "", "plugin unique identifier")
+	action := fs.String("action", "", "generate -args data for this Slim action")
+	path := fs.String("path", "", "local plugin directory or .difypkg path")
+	output := fs.String("output", slim.OutputJSON, "output format")
+	configFile := fs.String("config", "", "path to JSON config file (replaces env vars)")
+	fs.Usage = func() {
+		extractUsage(fs)
+	}
+	if err := fs.Parse(args); err != nil {
+		if err == flag.ErrHelp {
+			os.Exit(slim.ExitOK)
+		}
+		fatal(slim.NewError(slim.ErrInvalidInput, err.Error()))
+	}
+	if fs.NArg() != 0 {
+		fatal(slim.NewError(slim.ErrInvalidInput, "unexpected positional arguments"))
+	}
+
+	cfg, err := slim.LoadExtractConfig(*configFile, *path != "")
+	if err != nil {
+		fatal(err)
+	}
+
+	if err := slim.RunExtract(cfg, slim.ExtractOptions{
+		PluginID: *id,
+		Action:   *action,
+		Path:     *path,
+		Output:   *output,
+	}, os.Stdout); err != nil {
+		fatal(err)
+	}
+}
+
+func rootUsage() {
+	w := flag.CommandLine.Output()
+	fmt.Fprintln(w, "Usage:")
+	fmt.Fprintln(w, "  slim -id <plugin_unique_identifier> -action <action> [-args '<json>'] [-config <path>]")
+	fmt.Fprintln(w, "  slim extract -id <plugin_unique_identifier> [-config <path>] [-output json]")
+	fmt.Fprintln(w, "  slim extract -id <plugin_unique_identifier> -action <action> [-config <path>] [-output json]")
+	fmt.Fprintln(w, "  slim extract -path <plugin-dir-or-difypkg> [-config <path>] [-output json]")
+	fmt.Fprintln(w, "  slim extract -path <plugin-dir-or-difypkg> -action <action> [-config <path>] [-output json]")
+	fmt.Fprintln(w)
+	fmt.Fprintln(w, "Commands:")
+	fmt.Fprintln(w, "  extract    Parse plugin schema/declaration from daemon or local files")
+	fmt.Fprintln(w)
+	fmt.Fprintln(w, "Invocation flags:")
+	flag.PrintDefaults()
+}
+
+func extractUsage(fs *flag.FlagSet) {
+	w := fs.Output()
+	fmt.Fprintln(w, "Usage:")
+	fmt.Fprintln(w, "  slim extract -id <plugin_unique_identifier> [-config <path>] [-output json]")
+	fmt.Fprintln(w, "  slim extract -id <plugin_unique_identifier> -action <action> [-config <path>] [-output json]")
+	fmt.Fprintln(w, "  slim extract -path <plugin-dir-or-difypkg> [-config <path>] [-output json]")
+	fmt.Fprintln(w, "  slim extract -path <plugin-dir-or-difypkg> -action <action> [-config <path>] [-output json]")
+	fmt.Fprintln(w)
+	fmt.Fprintln(w, "Extract flags:")
+	fs.PrintDefaults()
+}
+
 func fatal(err error) {
 	exitCode := slim.ExitPluginError
 	var errorToMarshal *slim.SlimError

internal/server/controllers/plugins.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/gin-gonic/gin"
 	"github.com/langgenius/dify-plugin-daemon/internal/core/plugin_manager"
+	"github.com/langgenius/dify-plugin-daemon/internal/server/constants"
 	"github.com/langgenius/dify-plugin-daemon/internal/service"
 	"github.com/langgenius/dify-plugin-daemon/internal/types/app"
 	"github.com/langgenius/dify-plugin-daemon/internal/types/exception"
@@ -235,6 +236,26 @@ func FetchPluginManifest(c *gin.Context) {
 	})
 }
 
+func ExtractPluginSchema(config *app.Config) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		identityAny, ok := c.Get(constants.CONTEXT_KEY_PLUGIN_UNIQUE_IDENTIFIER)
+		if !ok {
+			c.JSON(http.StatusInternalServerError,
+				exception.InternalServerError(errors.New("plugin unique identifier not found")).ToResponse())
+			return
+		}
+
+		identity, ok := identityAny.(plugin_entities.PluginUniqueIdentifier)
+		if !ok {
+			c.JSON(http.StatusInternalServerError,
+				exception.InternalServerError(errors.New("failed to parse plugin unique identifier")).ToResponse())
+			return
+		}
+
+		c.JSON(http.StatusOK, service.ExtractPluginSchema(config, identity))
+	}
+}
+
 func FetchPluginReadme(c *gin.Context) {
 	BindRequest(c, func(request struct {
 		PluginUniqueIdentifier plugin_entities.PluginUniqueIdentifier `form:"plugin_unique_identifier" validate:"required,plugin_unique_identifier"`

internal/server/http_server.go

@@ -226,6 +226,12 @@ func (app *App) pprofGroup(group *gin.RouterGroup, config *app.Config) {
 
 func (app *App) invokeGroup(group *gin.RouterGroup, config *app.Config) {
 	group.Use(CheckingKey(config.ServerKey))
+
+	extractGroup := group.Group("/extract")
+	extractGroup.Use(app.FetchPluginDirect())
+	extractGroup.Use(app.InitClusterID())
+	extractGroup.GET("", controllers.ExtractPluginSchema(config))
+
 	dispatchGroup := group.Group("/dispatch")
 	dispatchGroup.Use(controllers.CollectActiveDispatchRequests())
 	dispatchGroup.Use(app.FetchPluginDirect())

internal/service/extract.go

@@ -0,0 +1,49 @@
+package service
+
+import (
+	"github.com/langgenius/dify-plugin-daemon/internal/core/plugin_manager"
+	"github.com/langgenius/dify-plugin-daemon/internal/types/app"
+	"github.com/langgenius/dify-plugin-daemon/internal/types/exception"
+	"github.com/langgenius/dify-plugin-daemon/pkg/entities"
+	"github.com/langgenius/dify-plugin-daemon/pkg/entities/plugin_entities"
+	"github.com/langgenius/dify-plugin-daemon/pkg/plugin_packager/decoder"
+)
+
+func ExtractPluginSchema(
+	config *app.Config,
+	pluginUniqueIdentifier plugin_entities.PluginUniqueIdentifier,
+) *entities.Response {
+	manager := plugin_manager.Manager()
+	pkgFile, err := manager.GetPackage(pluginUniqueIdentifier)
+	if err != nil {
+		return exception.BadRequestError(err).ToResponse()
+	}
+
+	zipDecoder, err := decoder.NewZipPluginDecoderWithThirdPartySignatureVerificationConfig(
+		pkgFile,
+		&decoder.ThirdPartySignatureVerificationConfig{
+			Enabled:        config.ThirdPartySignatureVerificationEnabled,
+			PublicKeyPaths: config.ThirdPartySignatureVerificationPublicKeys,
+		},
+	)
+	if err != nil {
+		return exception.BadRequestError(err).ToResponse()
+	}
+	defer zipDecoder.Close()
+
+	verification, _ := zipDecoder.Verification()
+	if verification == nil && zipDecoder.Verified() {
+		verification = decoder.DefaultVerification()
+	}
+
+	declaration, err := zipDecoder.Manifest()
+	if err != nil {
+		return exception.BadRequestError(err).ToResponse()
+	}
+
+	return entities.NewSuccessResponse(map[string]any{
+		"unique_identifier": pluginUniqueIdentifier,
+		"manifest":          declaration,
+		"verification":      verification,
+	})
+}

pkg/slim/config.go

@@ -59,6 +59,18 @@ func NewInvokeContext(id, action, argsJSON string) (*InvokeContext, error) {
 }
 
 func LoadConfigFromFile(path string) (*SlimConfig, error) {
+	cfg, err := loadConfigFromFile(path)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := fillDefaults(cfg); err != nil {
+		return nil, err
+	}
+	return cfg, nil
+}
+
+func loadConfigFromFile(path string) (*SlimConfig, error) {
 	data, err := os.ReadFile(path)
 	if err != nil {
 		return nil, NewError(ErrConfigLoad, err.Error())
@@ -69,13 +81,18 @@ func LoadConfigFromFile(path string) (*SlimConfig, error) {
 		return nil, NewError(ErrConfigLoad, err.Error())
 	}
 
-	if err := fillDefaults(&cfg); err != nil {
-		return nil, err
-	}
 	return &cfg, nil
 }
 
 func LoadConfig() (*SlimConfig, error) {
+	cfg := loadConfigFromEnv()
+	if err := fillDefaults(cfg); err != nil {
+		return nil, err
+	}
+	return cfg, nil
+}
+
+func loadConfigFromEnv() *SlimConfig {
 	cfg := &SlimConfig{
 		Mode: env("SLIM_MODE", ModeRemote),
 	}
@@ -88,10 +105,10 @@ func LoadConfig() (*SlimConfig, error) {
 			UvPath:               env("SLIM_UV_PATH", ""),
 			PythonEnvInitTimeout: envInt("SLIM_PYTHON_ENV_INIT_TIMEOUT", 0),
 			MaxExecutionTimeout:  envInt("SLIM_MAX_EXECUTION_TIMEOUT", 0),
-		PipMirrorURL:         env("SLIM_PIP_MIRROR_URL", ""),
-		PipExtraArgs:         env("SLIM_PIP_EXTRA_ARGS", ""),
-		MarketplaceURL:       env("SLIM_MARKETPLACE_URL", ""),
-		IgnoreUvLock:         envBool("SLIM_IGNORE_UV_LOCK", false),
+			PipMirrorURL:         env("SLIM_PIP_MIRROR_URL", ""),
+			PipExtraArgs:         env("SLIM_PIP_EXTRA_ARGS", ""),
+			MarketplaceURL:       env("SLIM_MARKETPLACE_URL", ""),
+			IgnoreUvLock:         envBool("SLIM_IGNORE_UV_LOCK", false),
 		}
 	case ModeRemote:
 		cfg.Remote = RemoteConfig{
@@ -100,7 +117,22 @@ func LoadConfig() (*SlimConfig, error) {
 		}
 	}
 
-	if err := fillDefaults(cfg); err != nil {
+	return cfg
+}
+
+func LoadExtractConfig(configFile string, hasLocalPath bool) (*SlimConfig, error) {
+	var cfg *SlimConfig
+	var err error
+	if configFile != "" {
+		cfg, err = loadConfigFromFile(configFile)
+	} else {
+		cfg = loadConfigFromEnv()
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	if err := fillExtractDefaults(cfg, hasLocalPath); err != nil {
 		return nil, err
 	}
 	return cfg, nil
@@ -160,3 +192,30 @@ func fillDefaults(cfg *SlimConfig) error {
 
 	return nil
 }
+
+func fillExtractDefaults(cfg *SlimConfig, hasLocalPath bool) error {
+	if cfg.Mode == "" {
+		cfg.Mode = ModeRemote
+	}
+
+	switch cfg.Mode {
+	case ModeLocal:
+		if cfg.Local.Folder == "" && !hasLocalPath {
+			return NewError(ErrConfigInvalid, "local.folder is required when extract uses -id")
+		}
+		if cfg.Local.MarketplaceURL == "" {
+			cfg.Local.MarketplaceURL = "https://marketplace.dify.ai"
+		}
+	case ModeRemote:
+		if cfg.Remote.DaemonAddr == "" {
+			return NewError(ErrConfigInvalid, "remote.daemon_addr is required")
+		}
+		if cfg.Remote.DaemonKey == "" {
+			return NewError(ErrConfigInvalid, "remote.daemon_key is required")
+		}
+	default:
+		return NewError(ErrUnknownMode, cfg.Mode)
+	}
+
+	return nil
+}

pkg/slim/config_test.go

@@ -215,3 +215,41 @@ func TestLoadConfigFromFile_ValidationFails(t *testing.T) {
 		t.Fatal("LoadConfigFromFile() should fail when remote config is incomplete")
 	}
 }
+
+func TestLoadExtractConfig_LocalPathDoesNotRequireFolder(t *testing.T) {
+	dir := t.TempDir()
+	cfgPath := filepath.Join(dir, "config.json")
+	content := `{"mode": "local"}`
+	if err := os.WriteFile(cfgPath, []byte(content), 0644); err != nil {
+		t.Fatalf("WriteFile() error: %v", err)
+	}
+
+	cfg, err := LoadExtractConfig(cfgPath, true)
+	if err != nil {
+		t.Fatalf("LoadExtractConfig() error: %v", err)
+	}
+	if cfg.Mode != ModeLocal {
+		t.Fatalf("Mode = %q; want %q", cfg.Mode, ModeLocal)
+	}
+}
+
+func TestLoadExtractConfig_LocalIDRequiresFolder(t *testing.T) {
+	dir := t.TempDir()
+	cfgPath := filepath.Join(dir, "config.json")
+	content := `{"mode": "local"}`
+	if err := os.WriteFile(cfgPath, []byte(content), 0644); err != nil {
+		t.Fatalf("WriteFile() error: %v", err)
+	}
+
+	_, err := LoadExtractConfig(cfgPath, false)
+	if err == nil {
+		t.Fatal("LoadExtractConfig() should fail when local extract uses -id without folder")
+	}
+	se, ok := err.(*SlimError)
+	if !ok {
+		t.Fatalf("expected *SlimError, got %T", err)
+	}
+	if se.Code != ErrConfigInvalid {
+		t.Fatalf("Code = %q; want %q", se.Code, ErrConfigInvalid)
+	}
+}