fix(ci): fix plugin workspace duplicate module and E2E pnpm dependency chain

Reuse official plugin root module as the lina-plugins aggregate bridge
instead of generating a duplicate fallback module. Improve linactl go
list error output to preserve stderr diagnostics for CI debugging.
Switch E2E workflow from npm ci/npx to pnpm install/exec to align
Playwright browser revision with pnpm-lock.yaml.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: gqcn

.github/workflows/reusable-e2e-tests.yml

@@ -151,13 +151,13 @@ jobs:
       # 为共享 E2E 工作区安装 Playwright 测试运行依赖。
       - name: Install E2E Dependencies
         working-directory: hack/tests
-        run: npm ci
+        run: pnpm install --frozen-lockfile
 
       # Install Chromium and required OS packages for Playwright.
       # 安装 Playwright 使用的 Chromium 和所需系统包。
       - name: Install Playwright Browsers
         working-directory: hack/tests
-        run: npx playwright install --with-deps chromium
+        run: pnpm exec playwright install --with-deps chromium
 
       # Rebuild the database and seed mock data for browser workflows.
       # 重建数据库并为浏览器工作流加载 mock 数据。

apps/lina-core/internal/service/plugin/internal/testutil/testutil_build.go

@@ -205,12 +205,26 @@ func ensureBuildWasmPluginWorkspace(repoRoot string, pluginDir string) error {
 	for _, use := range parseBuildWasmGoWorkUses(string(rootContent)) {
 		addUse(use)
 	}
+	if aggregateUse, aggregateErr := ensureBuildWasmAggregateModule(repoRoot, officialRoot); aggregateErr != nil {
+		return aggregateErr
+	} else if aggregateUse != "" {
+		normalized := normalizeBuildWasmGoWorkUse(aggregateUse)
+		if normalized != "" {
+			if _, ok := seen[normalized]; !ok {
+				seen[normalized] = struct{}{}
+				uses = append(uses, normalized)
+			}
+		}
+	}
 	pluginUses, err := buildWasmPluginGoWorkUses(repoRoot, officialRoot)
 	if err != nil {
 		return err
 	}
 	for _, use := range pluginUses {
 		normalized := normalizeBuildWasmGoWorkUse(use)
+		if normalized == "" || normalized == "apps/lina-plugins" {
+			continue
+		}
 		if _, ok := seen[normalized]; ok {
 			continue
 		}
@@ -231,6 +245,49 @@ func ensureBuildWasmPluginWorkspace(repoRoot string, pluginDir string) error {
 	return nil
 }
 
+// ensureBuildWasmAggregateModule resolves the module that satisfies the
+// host's official source-plugin import bridge for plugin test builds.
+func ensureBuildWasmAggregateModule(repoRoot string, officialRoot string) (string, error) {
+	if moduleName, err := readBuildWasmGoModuleName(filepath.Join(officialRoot, "go.mod")); err == nil && moduleName == "lina-plugins" {
+		if err = os.RemoveAll(filepath.Join(repoRoot, "temp", "official-plugins")); err != nil {
+			return "", fmt.Errorf("clean stale test aggregate module: %w", err)
+		}
+		return filepath.ToSlash(filepath.Join("apps", "lina-plugins")), nil
+	} else if err != nil && !os.IsNotExist(err) {
+		return "", err
+	}
+
+	moduleDir := filepath.Join(repoRoot, "temp", "official-plugins")
+	if err := os.RemoveAll(moduleDir); err != nil {
+		return "", fmt.Errorf("clean test aggregate module: %w", err)
+	}
+	if err := os.MkdirAll(moduleDir, 0o755); err != nil {
+		return "", fmt.Errorf("create test aggregate module: %w", err)
+	}
+	if err := os.WriteFile(filepath.Join(moduleDir, "go.mod"), []byte("module lina-plugins\n\ngo 1.25.0\n"), 0o644); err != nil {
+		return "", fmt.Errorf("write test aggregate go.mod: %w", err)
+	}
+	if err := os.WriteFile(filepath.Join(moduleDir, "plugins.go"), []byte("package linaplugins\n"), 0o644); err != nil {
+		return "", fmt.Errorf("write test aggregate package: %w", err)
+	}
+	return filepath.ToSlash(filepath.Join("temp", "official-plugins")), nil
+}
+
+// readBuildWasmGoModuleName reads the module directive from a go.mod file.
+func readBuildWasmGoModuleName(path string) (string, error) {
+	content, err := os.ReadFile(path)
+	if err != nil {
+		return "", err
+	}
+	for _, line := range strings.Split(string(content), "\n") {
+		fields := strings.Fields(stripBuildWasmGoWorkComment(line))
+		if len(fields) >= 2 && fields[0] == "module" {
+			return fields[1], nil
+		}
+	}
+	return "", fmt.Errorf("%s is missing a module directive", path)
+}
+
 // buildWasmPluginGoWorkUses discovers Go modules under the official plugin workspace.
 func buildWasmPluginGoWorkUses(repoRoot string, officialRoot string) ([]string, error) {
 	var uses []string

apps/lina-core/internal/service/plugin/internal/testutil/testutil_build_test.go

@@ -0,0 +1,56 @@
+// This file verifies dynamic plugin build workspace helpers.
+
+package testutil
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// TestEnsureBuildWasmPluginWorkspaceReusesOfficialPluginRootModule verifies
+// test helpers keep the official plugin root module as the lina-plugins bridge.
+func TestEnsureBuildWasmPluginWorkspaceReusesOfficialPluginRootModule(t *testing.T) {
+	repoRoot := t.TempDir()
+	writeBuildWorkspaceTestFile(t, filepath.Join(repoRoot, "go.work"), `go 1.25.0
+
+use (
+	./apps/lina-core
+)
+`)
+	pluginRoot := filepath.Join(repoRoot, "apps", "lina-plugins")
+	writeBuildWorkspaceTestFile(t, filepath.Join(pluginRoot, "go.mod"), "module lina-plugins\n")
+	writeBuildWorkspaceTestFile(t, filepath.Join(pluginRoot, "plugin-demo-dynamic", "go.mod"), "module plugin-demo-dynamic\n")
+	writeBuildWorkspaceTestFile(t, filepath.Join(pluginRoot, "plugin-demo-dynamic", "plugin.yaml"), "id: plugin-demo-dynamic\n")
+
+	if err := ensureBuildWasmPluginWorkspace(repoRoot, filepath.Join(pluginRoot, "plugin-demo-dynamic")); err != nil {
+		t.Fatalf("ensureBuildWasmPluginWorkspace returned error: %v", err)
+	}
+
+	content, err := os.ReadFile(filepath.Join(repoRoot, "temp", "go.work.plugins"))
+	if err != nil {
+		t.Fatalf("read generated plugin workspace: %v", err)
+	}
+	text := string(content)
+	if strings.Contains(text, "./official-plugins") {
+		t.Fatalf("expected official plugin root module to replace fallback aggregate, got:\n%s", text)
+	}
+	if !strings.Contains(text, "../apps/lina-plugins\n") {
+		t.Fatalf("expected generated workspace to include official plugin root module, got:\n%s", text)
+	}
+	if !strings.Contains(text, "../apps/lina-plugins/plugin-demo-dynamic\n") {
+		t.Fatalf("expected generated workspace to include dynamic plugin module, got:\n%s", text)
+	}
+}
+
+// writeBuildWorkspaceTestFile writes one fixture file for workspace helper tests.
+func writeBuildWorkspaceTestFile(t *testing.T, path string, content string) {
+	t.Helper()
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		t.Fatalf("mkdir %s: %v", filepath.Dir(path), err)
+	}
+	if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
+		t.Fatalf("write %s: %v", path, err)
+	}
+}

hack/tools/linactl/command_ops.go

@@ -232,8 +232,12 @@ func goWorkspaceModules(ctx context.Context, a *app) ([]string, error) {
 	cmd := a.execCommand(ctx, "go", "list", "-m", "-f", "{{.Dir}}")
 	cmd.Dir = a.root
 	cmd.Env = a.env
-	output, err := cmd.Output()
+	output, err := cmd.CombinedOutput()
 	if err != nil {
+		message := strings.TrimSpace(string(output))
+		if message != "" {
+			return nil, fmt.Errorf("list Go workspace modules: %w: %s", err, message)
+		}
 		return nil, fmt.Errorf("list Go workspace modules: %w", err)
 	}
 	lines := strings.Split(strings.TrimSpace(string(output)), "\n")

hack/tools/linactl/command_plugin_gowork.go

@@ -102,7 +102,13 @@ func writeOfficialPluginWorkspace(root string, workspace officialPluginWorkspace
 		addUse(use.Raw)
 	}
 	if aggregateUse != "" {
-		addUse(aggregateUse)
+		normalized := normalizeGoWorkUse(root, aggregateUse)
+		if normalized != "" {
+			if _, ok := seen[normalized]; !ok {
+				seen[normalized] = struct{}{}
+				normalizedUses = append(normalizedUses, normalized)
+			}
+		}
 	}
 	for _, use := range pluginUses {
 		normalized := normalizeGoWorkUse(root, use)
@@ -129,10 +135,22 @@ func writeOfficialPluginWorkspace(root string, workspace officialPluginWorkspace
 	return workspacePath, nil
 }
 
-// writeOfficialPluginAggregateModule generates a tiny module that satisfies the
-// host's `import _ "lina-plugins"` bridge and imports official source-plugin
-// backend packages for their init registrations.
+// writeOfficialPluginAggregateModule resolves the module that satisfies the
+// host's `import _ "lina-plugins"` bridge. Official plugin workspaces can
+// provide this aggregate module at their root; older local fixtures without a
+// root module still receive an ignored generated fallback module.
 func writeOfficialPluginAggregateModule(root string, workspace officialPluginWorkspace) (string, error) {
+	existingUse, err := existingOfficialPluginAggregateModule(root, workspace)
+	if err != nil {
+		return "", err
+	}
+	if existingUse != "" {
+		if err = os.RemoveAll(officialPluginAggregateModuleDir(root)); err != nil {
+			return "", fmt.Errorf("clean stale official plugin aggregate module: %w", err)
+		}
+		return existingUse, nil
+	}
+
 	imports, err := officialPluginBackendImports(workspace)
 	if err != nil {
 		return "", err
@@ -157,6 +175,27 @@ func writeOfficialPluginAggregateModule(root string, workspace officialPluginWor
 	return "./" + filepath.ToSlash(relativePath), nil
 }
 
+// existingOfficialPluginAggregateModule returns the official plugin root module
+// when it already owns the host bridge import path.
+func existingOfficialPluginAggregateModule(root string, workspace officialPluginWorkspace) (string, error) {
+	goModPath := filepath.Join(workspace.Root, "go.mod")
+	if !fileExists(goModPath) {
+		return "", nil
+	}
+	moduleName, err := readGoModuleName(goModPath)
+	if err != nil {
+		return "", err
+	}
+	if moduleName != officialPluginAggregateModuleName {
+		return "", nil
+	}
+	relativePath, err := filepath.Rel(root, workspace.Root)
+	if err != nil {
+		return "", fmt.Errorf("resolve existing official plugin aggregate module path: %w", err)
+	}
+	return "./" + filepath.ToSlash(relativePath), nil
+}
+
 // officialPluginBackendImports discovers source-plugin backend packages that
 // must be imported by the generated aggregate module.
 func officialPluginBackendImports(workspace officialPluginWorkspace) ([]officialPluginBackendImport, error) {

hack/tools/linactl/main_test.go

@@ -773,6 +773,27 @@ func TestGoWorkspaceModulesSkipsGeneratedOfficialPluginAggregate(t *testing.T) {
 	}
 }
 
+// TestGoWorkspaceModulesIncludesGoListOutputInErrors verifies CI failures keep
+// the Go command's actionable workspace diagnostic instead of only exit status.
+func TestGoWorkspaceModulesIncludesGoListOutputInErrors(t *testing.T) {
+	application := newApp(ioDiscard{}, ioDiscard{}, strings.NewReader(""))
+	application.root = t.TempDir()
+	application.execCommand = func(_ context.Context, name string, args ...string) *exec.Cmd {
+		if name != "go" || strings.Join(args, " ") != "list -m -f {{.Dir}}" {
+			t.Fatalf("unexpected module list command: %s %s", name, strings.Join(args, " "))
+		}
+		return exec.Command(os.Args[0], "-test.run=TestHelperPrintAndFail", "--")
+	}
+
+	_, err := goWorkspaceModules(context.Background(), application)
+	if err == nil {
+		t.Fatalf("expected goWorkspaceModules to return an error")
+	}
+	if !strings.Contains(err.Error(), "workspace diagnostic from go list") {
+		t.Fatalf("expected go list output in error, got %v", err)
+	}
+}
+
 // TestDiscoverGoModuleDirsSkipsGeneratedAndDependencyDirs verifies tidy scans
 // maintained source modules without entering generated or dependency trees.
 func TestDiscoverGoModuleDirsSkipsGeneratedAndDependencyDirs(t *testing.T) {
@@ -892,7 +913,6 @@ use (
 use (
 	../apps/lina-core
 	../hack/tools/build-wasm
-	./official-plugins
 	../apps/lina-plugins
 	../apps/lina-plugins/plugin-a
 	../apps/lina-plugins/plugin-b
@@ -901,6 +921,52 @@ use (
 	if string(pluginContent) != expected {
 		t.Fatalf("unexpected temporary plugin go.work:\n%s", string(pluginContent))
 	}
+	if dirExists(filepath.Join(root, "temp", "official-plugins")) {
+		t.Fatalf("expected existing official plugin root module to be reused without generated fallback")
+	}
+}
+
+func TestPrepareOfficialPluginWorkspaceGeneratesFallbackAggregateModule(t *testing.T) {
+	root := t.TempDir()
+	content := `go 1.25.0
+
+use (
+	./apps/lina-core
+	./hack/tools/build-wasm
+)
+`
+	writeFile(t, filepath.Join(root, "go.work"), content)
+	pluginRoot := filepath.Join(root, "apps", "lina-plugins")
+	writeFile(t, filepath.Join(pluginRoot, "plugin-b", "go.mod"), "module plugin-b\n")
+	writeFile(t, filepath.Join(pluginRoot, "plugin-b", "plugin.yaml"), "id: plugin-b\n")
+	writeFile(t, filepath.Join(pluginRoot, "plugin-a", "go.mod"), "module plugin-a\n")
+	writeFile(t, filepath.Join(pluginRoot, "plugin-a", "plugin.yaml"), "id: plugin-a\n")
+
+	workspace, err := inspectOfficialPluginWorkspace(root)
+	if err != nil {
+		t.Fatalf("inspectOfficialPluginWorkspace returned error: %v", err)
+	}
+	workspacePath, err := prepareOfficialPluginWorkspace(root, true, workspace)
+	if err != nil {
+		t.Fatalf("prepareOfficialPluginWorkspace returned error: %v", err)
+	}
+	pluginContent, err := os.ReadFile(workspacePath)
+	if err != nil {
+		t.Fatalf("read temporary plugin go.work: %v", err)
+	}
+	expected := `go 1.25.0
+
+use (
+	../apps/lina-core
+	../hack/tools/build-wasm
+	./official-plugins
+	../apps/lina-plugins/plugin-a
+	../apps/lina-plugins/plugin-b
+)
+`
+	if string(pluginContent) != expected {
+		t.Fatalf("unexpected fallback temporary plugin go.work:\n%s", string(pluginContent))
+	}
 	aggregateGoMod, err := os.ReadFile(filepath.Join(root, "temp", "official-plugins", "go.mod"))
 	if err != nil {
 		t.Fatalf("read aggregate go.mod: %v", err)
@@ -965,6 +1031,16 @@ func TestHelperCommandFailure(t *testing.T) {
 	os.Exit(1)
 }
 
+// TestHelperPrintAndFail prints a deterministic diagnostic and exits with
+// failure for command-output error tests.
+func TestHelperPrintAndFail(t *testing.T) {
+	if len(os.Args) < 2 || os.Args[len(os.Args)-1] != "--" {
+		return
+	}
+	fmt.Fprintln(os.Stderr, "workspace diagnostic from go list")
+	os.Exit(1)
+}
+
 // TestHelperRecordWorkingDirectory records the child process working directory
 // for command execution tests.
 func TestHelperRecordWorkingDirectory(t *testing.T) {