From a02fc7d728a9973a3275a0f47604081c4439b424 Mon Sep 17 00:00:00 2001
From: nsfisis <nsfisis@gmail.com>
Date: Tue, 4 Aug 2026 02:25:28 +0900
Subject: feat(plugin): activate plugins through the PHP RPC worker

Implement the remainder of PluginManager::registerPackage: the plugin
autoload map is built by the ported createLoader/parseAutoloads and
served to the worker over the existing reverse-RPC autoloader, files
entries go through a composerRequire-equivalent glue call, and
already-defined classes take the upstream _composer_tmp rename/eval
path. Instantiation uses the new NewObject/CallPhpMethod lanes backed
by a P table in the worker; PhpPluginProxy adapts the resulting handle
to PluginInterface, with $composer/$io exposed to plugin callbacks via
an R table (unsupported methods stay explicit errors). Hand-written
proxy stubs cover Composer, PartialComposer and the IO hierarchy, and
the stub autoloader is re-prepended after loading the Composer PHP
runtime so its vendor autoloader cannot shadow proxied FQCNs.

FilesystemRepository::write now mirrors InstalledVersions::reload into
a running worker (class_exists-guarded, so an unloaded class keeps its
upstream lazy-load behavior), removing the previously undefined
observation window.

The installer pipeline passes the installed repository as a shared
handle instead of a long-lived `&mut dyn`: plugin registration runs
inside InstallationManager::execute and re-enters the same local
repository through the RepositoryManager, which would panic on the
RefCell re-borrow under the old shape.

PluginInterface lifecycle methods now take an owned ComposerHandle
(plugins retain $composer past the call) and return anyhow::Result
(PHP plugin code may throw); the plugin list uses shared ownership so
the identity comparison of removePlugin survives the dual storage in
registeredPlugins, matching PHP reference semantics.

Ports the activate/upgrade/uninstall tests of PluginInstallerTest,
serialized across the shared worker process whose persistent class
table is exactly what exercises the rename path.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../php/stubs/Composer/Composer.php                | 88 ++++++++++++++++++++++
 1 file changed, 88 insertions(+)
 create mode 100644 crates/shirabe-php-rpc/php/stubs/Composer/Composer.php

(limited to 'crates/shirabe-php-rpc/php/stubs/Composer/Composer.php')

diff --git a/crates/shirabe-php-rpc/php/stubs/Composer/Composer.php b/crates/shirabe-php-rpc/php/stubs/Composer/Composer.php
new file mode 100644
index 00000000..1bb9f64c
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/stubs/Composer/Composer.php
@@ -0,0 +1,88 @@
+<?php
+
+// Hand-written proxy stub for Composer\Composer, kept in the shape the future stub generator
+// will output. Class constants and static methods are materialized (they read no instance
+// state); instance methods forward to the Rust-side entity.
+
+namespace Composer;
+
+use Composer\Autoload\AutoloadGenerator;
+use Composer\Package\Archiver\ArchiveManager;
+use Composer\Package\Locker;
+use Composer\Downloader\DownloadManager;
+use Composer\Pcre\Preg;
+use Composer\Plugin\PluginManager;
+
+class Composer extends PartialComposer
+{
+    public const VERSION = '2.9.7';
+    public const BRANCH_ALIAS_VERSION = '';
+    public const RELEASE_DATE = '2026-04-14 13:31:52';
+    public const SOURCE_VERSION = '';
+    public const RUNTIME_API_VERSION = '2.2.2';
+
+    public static function getVersion(): string
+    {
+        // no replacement done, this must be a source checkout
+        if (self::VERSION === '@package_version'.'@') {
+            return self::SOURCE_VERSION;
+        }
+
+        // we have a branch alias and version is a commit id, this must be a snapshot build
+        if (self::BRANCH_ALIAS_VERSION !== '' && Preg::isMatch('{^[a-f0-9]{40}$}', self::VERSION)) {
+            return self::BRANCH_ALIAS_VERSION.'+'.self::VERSION;
+        }
+
+        return self::VERSION;
+    }
+
+    public function setLocker(Locker $locker): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setLocker', [$locker]);
+    }
+
+    public function getLocker(): Locker
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getLocker', []);
+    }
+
+    public function setDownloadManager(DownloadManager $manager): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setDownloadManager', [$manager]);
+    }
+
+    public function getDownloadManager(): DownloadManager
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getDownloadManager', []);
+    }
+
+    public function setArchiveManager(ArchiveManager $manager): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setArchiveManager', [$manager]);
+    }
+
+    public function getArchiveManager(): ArchiveManager
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getArchiveManager', []);
+    }
+
+    public function setPluginManager(PluginManager $manager): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setPluginManager', [$manager]);
+    }
+
+    public function getPluginManager(): PluginManager
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getPluginManager', []);
+    }
+
+    public function setAutoloadGenerator(AutoloadGenerator $autoloadGenerator): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setAutoloadGenerator', [$autoloadGenerator]);
+    }
+
+    public function getAutoloadGenerator(): AutoloadGenerator
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getAutoloadGenerator', []);
+    }
+}
-- 
cgit v1.3.1