fix: activate managed dependencies after network install

Author: chubes4

packages/cli/src/commands/recipe-runtime-setup.ts

@@ -217,7 +217,11 @@ export async function applyRecipeRuntimeSetup(args: {
     executions.push(withRecipeExecutionPhase(await runtime.execute({ command: "wordpress.run-php", args: setupPhpArgs(composerAutoloaderInstallCode) }), "setup", -2, "extra-plugin.install-composer-autoloaders"))
   }
 
-  const activatedPlugins = extraPlugins.filter((plugin) => plugin.loadAs === "plugin" && plugin.activate !== false)
+  const deferPluginActivation = recipe.workflow.steps.some((step) => step.command === "wordpress.phpunit"
+    && step.args?.includes("bootstrap-mode=managed")
+    && step.args?.includes("database-type=mysql")
+    && step.args?.includes("multisite=1"))
+  const activatedPlugins = deferPluginActivation ? [] : extraPlugins.filter((plugin) => plugin.loadAs === "plugin" && plugin.activate !== false)
   if (activatedPlugins.length > 0) {
     const activePluginsAfterActivation = await phaseTracker.run("activate_plugins", phasePluginActivationData(activatedPlugins), async () => {
       for (const plugin of activatedPlugins) {

packages/runtime-core/src/recipe-builders.ts

@@ -116,6 +116,7 @@ export function buildWordPressPhpunitRecipe(options: WordPressPhpunitRecipeOptio
           commandArg("phpunit-xml", options.phpunitXml ?? `${pluginTarget}/phpunit.xml.dist`),
           commandArg("phpunit-xml-default", options.phpunitXml === undefined ? "1" : ""),
           commandStringListArg("dependency-mounts", options.dependencyMounts ?? []),
+          commandJsonArg("dependency-plugins-json", phpunitDependencyPlugins(options.dependencyMounts ?? [], options.extra_plugins ?? [])),
           commandJsonArg("bootstrap-files-json", options.bootstrapFiles ?? []),
           commandJsonArg("preload-files-json", options.preloadFiles ?? []),
           commandJsonArg("phpunit-args-json", options.phpunitArgs ?? []),
@@ -129,6 +130,15 @@ export function buildWordPressPhpunitRecipe(options: WordPressPhpunitRecipeOptio
   }
 }
 
+function phpunitDependencyPlugins(mounts: readonly string[], plugins: readonly WorkspaceRecipeExtraPlugin[]): Array<{ path: string; activate: boolean }> {
+  return mounts.map((path) => {
+    const normalized = path.replace(/\/+$/g, "")
+    const slug = normalized.slice(normalized.lastIndexOf("/") + 1)
+    const plugin = plugins.find((candidate) => candidate.slug === slug || candidate.mountSlug === slug)
+    return { path, activate: plugin?.activate !== false }
+  })
+}
+
 function phpunitRuntimeServices(databaseType: WordPressPhpunitRecipeOptions["databaseType"], services: WorkspaceRecipeRuntimeService[] = []): WorkspaceRecipeRuntimeService[] {
   if (databaseType !== undefined && databaseType !== "sqlite" && databaseType !== "mysql") {
     throw new Error(`Unsupported PHPUnit database type: ${databaseType}`)

packages/runtime-playground/src/phpunit-command-handlers.ts

@@ -16,6 +16,7 @@ export interface PhpunitRunCodeOptions {
   env: Record<string, unknown>
   wpConfigDefines: Record<string, unknown>
   dependencyMounts: string[]
+  dependencyPlugins?: Array<{ path: string; activate: boolean }>
   bootstrapFiles: string[]
   preloadFiles?: string[]
   bootstrapMode: string
@@ -454,6 +455,7 @@ $phpunit_args_raw = json_decode(${JSON.stringify(JSON.stringify(options.phpunitA
 $bench_env = json_decode(${JSON.stringify(JSON.stringify(options.env))}, true);
 $wp_config_defines = json_decode(${JSON.stringify(JSON.stringify(options.wpConfigDefines))}, true);
 $dep_mounts = ${JSON.stringify(options.dependencyMounts.join("\n"))};
+$dependency_plugins = json_decode(${JSON.stringify(JSON.stringify(options.dependencyPlugins ?? []))}, true);
 $bootstrap_files = json_decode(${JSON.stringify(JSON.stringify(options.bootstrapFiles))}, true);
 $preload_files = json_decode(${JSON.stringify(JSON.stringify(options.preloadFiles ?? []))}, true);
 $bootstrap_mode = ${JSON.stringify(options.bootstrapMode || "managed")};
@@ -1029,25 +1031,52 @@ function pg_run_install_stage(array $cfg) {
 function pg_run_load_deps_stage(array $cfg): array {
     pg_stage_begin('load_deps');
     try {
-        $loaded = array();
-        foreach (explode("\n", (string) ($cfg['dep_mounts'] ?? '')) as $dep_mount) {
-            $dep_mount = trim($dep_mount);
-            if ($dep_mount === '') {
-                continue;
+        $result = array('loaded' => array(), 'activate' => array());
+        $plugins = is_array($cfg['plugins'] ?? null) ? $cfg['plugins'] : array();
+        if (empty($plugins)) {
+            foreach (explode("\n", (string) ($cfg['dep_mounts'] ?? '')) as $path) {
+                if (trim($path) !== '') {
+                    $plugins[] = array('path' => $path, 'activate' => true);
+                }
+            }
+        }
+        $plugin_root = realpath(WP_PLUGIN_DIR);
+        if ($plugin_root === false || !is_dir($plugin_root)) {
+            throw new RuntimeException('WordPress plugin directory is unavailable while loading managed PHPUnit dependencies');
+        }
+        foreach ($plugins as $plugin) {
+            if (!is_array($plugin) || !is_string($plugin['path'] ?? null)) {
+                throw new RuntimeException('managed PHPUnit dependency metadata must contain a plugin path');
             }
-            foreach (glob($dep_mount . '/*.php') ?: array() as $dep_file) {
+            $dep_mount = rtrim(str_replace('\\\\', '/', trim($plugin['path'])), '/');
+            $dep_real = realpath($dep_mount);
+            if ($dep_real === false || !is_dir($dep_real) || dirname($dep_real) !== $plugin_root) {
+                throw new RuntimeException('managed PHPUnit dependency must be a direct child directory of WP_PLUGIN_DIR: ' . $dep_mount);
+            }
+            if ($dep_mount !== WP_PLUGIN_DIR . '/' . basename($dep_mount)) {
+                throw new RuntimeException('managed PHPUnit dependency path is not canonical: ' . $dep_mount);
+            }
+            $loaded_file = null;
+            foreach (glob($dep_real . '/*.php') ?: array() as $dep_file) {
                 if (basename($dep_file) === 'db.php') {
                     continue;
                 }
                 if (strpos(file_get_contents($dep_file), 'Plugin Name:') !== false) {
                     require_once $dep_file;
-                    $loaded[] = $dep_file;
+                    $loaded_file = $dep_file;
                     break;
                 }
             }
+            if ($loaded_file === null) {
+                throw new RuntimeException('managed PHPUnit dependency has no readable plugin entrypoint: ' . $dep_mount);
+            }
+            $result['loaded'][] = $loaded_file;
+            if (!empty($plugin['activate'])) {
+                $result['activate'][] = $loaded_file;
+            }
         }
         pg_stage_ok('load_deps');
-        return $loaded;
+        return $result;
     } catch (Throwable $e) {
         pg_stage_fail('load_deps', $e);
         exit(1);
@@ -1226,10 +1255,11 @@ pg_run_install_stage(array('config_path' => $config_path, 'tests_dir' => $tests_
 pg_remove_new_wordpress_hook_callbacks('shutdown', $pre_component_shutdown_callbacks);
 $pre_dependency_plugins_loaded_callbacks = pg_snapshot_wordpress_hook_callbacks('plugins_loaded');
 $pre_dependency_init_callbacks = pg_snapshot_wordpress_hook_callbacks('init');
-$loaded_dep_files = pg_run_load_deps_stage(array('dep_mounts' => $dep_mounts));
+$dependency_load = pg_run_load_deps_stage(array('dep_mounts' => $dep_mounts, 'plugins' => $dependency_plugins));
+$loaded_dep_files = $dependency_load['loaded'];
 $deferred_dependency_plugins_loaded_callbacks = pg_defer_new_wordpress_hook_callbacks('plugins_loaded', $pre_dependency_plugins_loaded_callbacks);
 $deferred_dependency_init_callbacks = pg_defer_new_wordpress_hook_callbacks('init', $pre_dependency_init_callbacks);
-$activation_files = $loaded_dep_files;
+$activation_files = $dependency_load['activate'];
 if ($loaded_component_file !== null) {
     $activation_files[] = $loaded_component_file;
 }
@@ -1436,7 +1466,8 @@ try {
     $runner = new PHPUnit\\TextUI\\TestRunner();
     $result = $runner->run($suite, $phpunit_args);
     pg_log($result->wasSuccessful() ? 'ALL TESTS PASSED' : 'SOME TESTS FAILED');
-    pg_log('TESTS: ' . $result->count() . ' FAILURES: ' . count($result->failures()) . ' ERRORS: ' . count($result->errors()));
+    $assertions = class_exists('PHPUnit\\Framework\\Assert') && method_exists('PHPUnit\\Framework\\Assert', 'getCount') ? PHPUnit\\Framework\\Assert::getCount() : 0;
+    pg_log('TESTS: ' . $result->count() . ' ASSERTIONS: ' . $assertions . ' FAILURES: ' . count($result->failures()) . ' ERRORS: ' . count($result->errors()));
     pg_stage_ok('run_tests');
     exit($result->wasSuccessful() ? 0 : 1);
 } catch (Throwable $e) {

packages/runtime-playground/src/wordpress-command-runners.ts

@@ -948,6 +948,13 @@ export async function runPhpunitCommand({
     env: jsonObjectArg(args, "env-json"),
     wpConfigDefines: jsonObjectArg(args, "wp-config-defines-json"),
     dependencyMounts: commaListArg(args, "dependency-mounts"),
+    dependencyPlugins: jsonArrayArg(args, "dependency-plugins-json").map((plugin) => {
+      if (!plugin || typeof plugin !== "object" || Array.isArray(plugin)) throw new Error("dependency-plugins-json entries must be objects")
+      const metadata = plugin as Record<string, unknown>
+      const path = typeof metadata.path === "string" ? metadata.path : ""
+      if (!path) throw new Error("dependency-plugins-json entries require path")
+      return { path, activate: metadata.activate !== false }
+    }),
     bootstrapFiles: jsonArrayArg(args, "bootstrap-files-json").filter((value): value is string => typeof value === "string"),
     preloadFiles: jsonArrayArg(args, "preload-files-json").filter((value): value is string => typeof value === "string"),
     bootstrapMode,

tests/disposable-mysql-mysqli.integration.test.ts

@@ -154,7 +154,7 @@ require_once ABSPATH . 'wp-settings.php';
     const multisiteArtifacts = join(directory, "managed-multisite-artifacts")
     await mkdir(join(multisitePlugin, "tests"), { recursive: true })
     await mkdir(multisiteDependency, { recursive: true })
-    await writeFile(join(multisiteDependency, "managed-multisite-dependency.php"), "<?php\n/** Plugin Name: Managed Multisite Dependency */\n")
+    await writeFile(join(multisiteDependency, "managed-multisite-dependency.php"), "<?php\n/** Plugin Name: Managed Multisite Dependency */\nregister_activation_hook(__FILE__, static function (): void { update_network_option(1, 'wp_codebox_dependency_activated', 1); });\n")
     await writeFile(join(multisitePlugin, "managed-multisite-fixture.php"), `<?php
 /** Plugin Name: Managed Multisite Fixture */
 add_action('init', static function (): void {
@@ -195,9 +195,19 @@ final class ManagedMultisiteTest extends WP_UnitTestCase {
 
     public function test_network_schema_seed_and_dependency_are_materialized(): void {
         global $wpdb;
+        foreach (array($wpdb->blogs, $wpdb->blogmeta, $wpdb->site, $wpdb->sitemeta, $wpdb->registration_log, $wpdb->signups) as $table) {
+            $this->assertSame($table, $wpdb->get_var($wpdb->prepare('SHOW TABLES LIKE %s', $wpdb->esc_like($table))));
+        }
         $this->assertGreaterThanOrEqual(1, (int) $wpdb->get_var("SELECT COUNT(*) FROM {$wpdb->blogs} WHERE blog_id = 1"));
         $this->assertGreaterThan(0, (int) $wpdb->get_var("SELECT COUNT(*) FROM {$wpdb->sitemeta} WHERE site_id = 1"));
-        $this->assertFileExists('/wordpress/wp-content/plugins/managed-multisite-dependency/managed-multisite-dependency.php');
+        $this->assertTrue(update_network_option(1, 'wp_codebox_network_write', 'round-trip'));
+        $this->assertSame('round-trip', get_network_option(1, 'wp_codebox_network_write'));
+        $dependency = WP_PLUGIN_DIR . '/managed-multisite-dependency/managed-multisite-dependency.php';
+        $this->assertDirectoryExists(dirname($dependency));
+        $this->assertFileExists($dependency);
+        require_once ABSPATH . 'wp-admin/includes/plugin.php';
+        $this->assertTrue(is_plugin_active_for_network('managed-multisite-dependency/managed-multisite-dependency.php'));
+        $this->assertSame(1, (int) get_network_option(1, 'wp_codebox_dependency_activated'));
     }
 }
 `)
@@ -207,14 +217,17 @@ final class ManagedMultisiteTest extends WP_UnitTestCase {
       databaseType: "mysql",
       multisite: true,
       pluginSource: multisitePlugin,
-      extra_plugins: [{ source: multisiteDependency, slug: "managed-multisite-dependency", activate: false }],
-      dependencyMounts: ["/wordpress/wp-content/plugins/managed-multisite-fixture", "/wordpress/wp-content/plugins/managed-multisite-dependency"],
+      extra_plugins: [{ source: multisiteDependency, slug: "managed-multisite-dependency", activate: true }],
+      dependencyMounts: ["/wordpress/wp-content/plugins/managed-multisite-dependency"],
       mounts: [{ source: join(harness, "vendor"), target: "/wp-codebox-vendor", mode: "readonly" }],
     })
     await writeFile(multisiteRecipePath, `${JSON.stringify(multisiteRecipe)}\n`)
     const multisiteResult = await runRecipe({ recipePath: multisiteRecipePath, artifactsDirectory: multisiteArtifacts, previewHoldBlocking: false, previewLeaseRequested: false, previewLeaseChild: false, timeoutMs: 300_000, json: true, summary: false, dryRun: false })
     const multisiteFailure = multisiteResult as typeof multisiteResult & { error?: unknown }
     assert.equal(multisiteResult.success, true, JSON.stringify({ error: multisiteFailure.error, executions: multisiteResult.executions }))
+    const latest = JSON.parse(await readFile(join(multisiteArtifacts, "latest-runtime.json"), "utf8")) as { paths?: { runtimeDirectory?: string } }
+    const diagnostic = await readFile(join(multisiteArtifacts, latest.paths?.runtimeDirectory ?? "", "files/phpunit/.pg-test-result.txt"), "utf8")
+    assert.match(diagnostic, /TESTS: [1-9][0-9]* ASSERTIONS: [1-9][0-9]* FAILURES: 0 ERRORS: 0/, "managed multisite regression must execute nonzero tests and assertions")
     console.log("disposable MySQL and MariaDB mysqli E2E passed")
   } finally {
     await rm(directory, { recursive: true, force: true })

tests/phpunit-project-autoload.test.ts

@@ -793,10 +793,10 @@ assert.ok(managedModeCode.includes("configured PHPUnit harness autoload file is
 assert.ok(managedModeCode.includes("define('DB_NAME', ':memory:');"), "default managed PHPUnit remains on SQLite")
 assert.ok(managedModeCode.includes("'cacheResult' => false"))
 assert.ok(managedModeCode.includes("global $argv, $pg_stage_output_buffering, $wp_rewrite;"), "managed WordPress installation must expose the rewrite global required by multisite setup")
-assert.ok(managedModeCode.includes("foreach ($multisite_defines as $name => $value)"), "managed multisite must establish network constants before the WordPress test installer runs")
+assert.ok(managedModeCode.includes("foreach ($multisite_defines as $name => $value)"), "managed multisite establishes network constants for the post-install test bootstrap")
 assert.ok(managedModeCode.includes('$dep_mounts = "/wordpress/wp-content/plugins/demo-plugin\\n/wordpress/wp-content/plugins/dependency";'), "dependency mounts must be newline-delimited for the generated PHP runner")
 const installStageIndex = managedModeCode.indexOf("pg_run_install_stage(array(")
-const dependencyLoadStageIndex = managedModeCode.indexOf("$loaded_dep_files = pg_run_load_deps_stage", installStageIndex)
+const dependencyLoadStageIndex = managedModeCode.indexOf("$dependency_load = pg_run_load_deps_stage", installStageIndex)
 const activationStageIndex = managedModeCode.indexOf("pg_run_activation_stage", dependencyLoadStageIndex)
 const dependencyPluginsLoadedSnapshotIndex = managedModeCode.indexOf("$pre_dependency_plugins_loaded_callbacks = pg_snapshot_wordpress_hook_callbacks('plugins_loaded');", installStageIndex)
 const dependencyPluginsLoadedDeferIndex = managedModeCode.indexOf("$deferred_dependency_plugins_loaded_callbacks = pg_defer_new_wordpress_hook_callbacks('plugins_loaded', $pre_dependency_plugins_loaded_callbacks);", dependencyLoadStageIndex)
@@ -825,6 +825,9 @@ assert.deepEqual(dependencyRecipe.inputs.extra_plugins, [{
   activate: false,
 }])
 assert.ok(dependencyRecipe.workflow.steps[0].args.includes("dependency-mounts=/wordpress/wp-content/plugins/dependency"))
+assert.ok(dependencyRecipe.workflow.steps[0].args.includes('dependency-plugins-json=[{"path":"/wordpress/wp-content/plugins/dependency","activate":false}]'), "dependency activation intent is carried into managed PHPUnit")
+assert.ok(managedModeCode.includes("dirname($dep_real) !== $plugin_root"), "dependency loading rejects paths outside a direct WP_PLUGIN_DIR child")
+assert.ok(managedModeCode.includes("managed PHPUnit dependency path is not canonical"), "dependency loading rejects non-canonical sandbox paths")
 
 const multisiteRecipe = buildWordPressPhpunitRecipe({
   pluginSlug: "network-plugin",

tests/recipe-runtime-setup-staged-materialization.test.ts

@@ -21,7 +21,7 @@ const recipe: WorkspaceRecipe = {
       mode: "readonly",
     }],
   },
-  workflow: { steps: [] },
+  workflow: { steps: [{ command: "wordpress.phpunit", args: ["bootstrap-mode=managed", "database-type=mysql", "multisite=1"] }] },
 }
 const prepared: PreparedRecipeRuntimeSetup = {
   workspaceMounts: [],
@@ -30,7 +30,7 @@ const prepared: PreparedRecipeRuntimeSetup = {
     slug: "fixture-dependency",
     target: "/wordpress/wp-content/plugins/fixture-dependency",
     pluginFile: "fixture-dependency/fixture-dependency.php",
-    activate: false,
+    activate: true,
     loadAs: "plugin",
     cleanupPaths: [],
     provenance: { kind: "local", original: "/tmp/host-extra-plugin" },
@@ -96,7 +96,10 @@ const runtime = {
     ])
   },
   async materializeMounts() { throw new Error("setup should use materializeStagedInputs when available") },
-  async execute(spec) { calls.push(`execute:${spec.command}`); throw new Error("setup should not execute commands in this fixture") },
+  async execute(spec) {
+    calls.push(`execute:${spec.command}:${(spec.args ?? []).join(" ")}`)
+    return { id: "setup", command: spec.command, args: spec.args ?? [], exitCode: 0, stdout: "", stderr: "", startedAt: new Date().toISOString(), finishedAt: new Date().toISOString() }
+  },
   async observe() { throw new Error("unused") },
   async snapshot() { throw new Error("unused") },
   async collectArtifacts() { throw new Error("unused") },
@@ -135,7 +138,7 @@ assert.ok(materializeOperationIndex > inputMountIndex, "materialization is sched
 assert.ok(materializeOperationIndex > mountIndex, "materialization is scheduled after staged mount")
 assert.ok(materializeOperationIndex > extraPluginMountIndex, "materialization is scheduled after extra-plugin mount")
 assert.ok(materializeIndex > materializeOperationIndex, "materialization runs inside the setup phase before commands")
-assert.equal(calls.some((call) => call.startsWith("execute:")), false)
+assert.equal(calls.some((call) => call.includes("activation-recipe-plugin")), false, "managed MySQL multisite defers requested dependency activation until after network installation")
 
 const executedWorkflowSpecs: ExecutionSpec[] = []
 const workflowRuntime = {