agl 41.0.1 → 41.2.0

package/ts/classes.controller.ts

@@ -17,6 +17,7 @@ import { ControllerBrowserPaintTransport } from './classes.browserpainttransport
 import { ControllerBrowserAudioTransport } from './classes.browseraudiotransport.js';
 import { createBrowserDevToolsAssets, createBrowserDevToolsSurface } from './functions.browserdevtools.js';
 import { createControllerSecurityHeaders } from './functions.controllersecurityheaders.js';
+import { createControllerManagementSurface } from './functions.controllermanagementsurface.js';
 import { createMonacoAssetsSurface } from './functions.monacoassets.js';
 import * as devToolsProtocol from '../ts_interfaces/devtools.js';
 import type {
@@ -120,6 +121,7 @@ import {
   controllerLiveToolExecutionIsCovered,
   controllerProtocolVersion,
   controllerUpgradeManagementVersion,
+  controllerManagementProtocolVersion,
   controllerLayoutItemRefKey,
   controllerRuntimeIdKey,
   controllerAgentMessageMaxTextBytes,
@@ -4169,6 +4171,7 @@ export class OpenCodeController {
       packageVersion: commitinfo.version,
       protocolVersion: controllerProtocolVersion,
       upgradeManagementVersion: controllerUpgradeManagementVersion,
+      managementProtocolVersion: controllerManagementProtocolVersion,
       controllerPid: process.pid,
       processGroupId: this.processGroupId,
       processFingerprint: this.processFingerprint,
@@ -10151,6 +10154,11 @@ export class OpenCodeController {
         ),
       },
       surfaces: [
+        // The CLI's and the upgrade worker's management calls: loopback HTTP, independent of the browser's socket.
+        createControllerManagementSurface({
+          port: runtimeConfig.controllerPort,
+          router: this.createManagementRouter(),
+        }),
         createBrowserDevToolsSurface(hostnames, browserDevToolsAssets),
         createMonacoAssetsSurface(hostnames, securityHeaders),
         ...browserViewerAssets.surfaces(hostnames, securityHeaders),
@@ -13590,13 +13598,7 @@ export class OpenCodeController {
 
   /** Public scope: a browser reads the status before it holds a passkey session. */
   private registerStatusHandlers(publicRouterArg: plugins.typedrequest.TypedRouter): void {
-    publicRouterArg.addTypedHandler(new plugins.typedrequest.TypedHandler<IReq_ControllerStatus>(
-      'controller.status',
-      async (requestArg) => {
-        validateRequest(() => assertEmptyRequest(requestArg));
-        return this.statusForPrincipal('browser');
-      },
-    ));
+    publicRouterArg.addTypedHandler(this.createStatusHandler());
   }
 
   /**
@@ -13604,7 +13606,39 @@ export class OpenCodeController {
    * Every handler here authorises itself against the upgrade token it is handed.
    */
   private registerUpgradeHandlers(publicRouterArg: plugins.typedrequest.TypedRouter): void {
-    publicRouterArg.addTypedHandler(new plugins.typedrequest.TypedHandler<IReq_ControllerUpgradeLaunch>(
+    publicRouterArg.addTypedHandler(this.createUpgradeLaunchHandler());
+    publicRouterArg.addTypedHandler(this.createUpgradePrepareHandler());
+    publicRouterArg.addTypedHandler(this.createUpgradePrepareBeginHandler());
+    publicRouterArg.addTypedHandler(this.createUpgradeFinalizeHandler());
+  }
+
+  /**
+   * The router of the loopback management endpoint (`controllerManagementMethods`): the status read and the upgrade
+   * methods the CLI and an upgrade worker of this or another release call. Each handler comes from the factory its
+   * controller socket handler comes from, so it authorises itself exactly as it does there; the endpoint's admission
+   * grants a request only its own peer. No other method is reachable through it.
+   */
+  private createManagementRouter(): plugins.typedrequest.TypedRouter {
+    const router = new plugins.typedrequest.TypedRouter();
+    router.addTypedHandler(this.createStatusHandler());
+    router.addTypedHandler(this.createUpgradeLaunchHandler());
+    router.addTypedHandler(this.createUpgradePrepareBeginHandler());
+    router.addTypedHandler(this.createUpgradeFinalizeHandler());
+    return router;
+  }
+
+  private createStatusHandler(): plugins.typedrequest.TypedHandler<IReq_ControllerStatus> {
+    return new plugins.typedrequest.TypedHandler<IReq_ControllerStatus>(
+      'controller.status',
+      async (requestArg) => {
+        validateRequest(() => assertEmptyRequest(requestArg));
+        return this.statusForPrincipal('browser');
+      },
+    );
+  }
+
+  private createUpgradeLaunchHandler(): plugins.typedrequest.TypedHandler<IReq_ControllerUpgradeLaunch> {
+    return new plugins.typedrequest.TypedHandler<IReq_ControllerUpgradeLaunch>(
       'controller.upgrade.launch',
       async (requestArg, toolsArg) => {
         const peer = peerFromLocalData(toolsArg?.localData);
@@ -13690,9 +13724,12 @@ export class OpenCodeController {
           }
         });
       },
-    ));
+    );
+  }
 
-    publicRouterArg.addTypedHandler(new plugins.typedrequest.TypedHandler<IReq_ControllerUpgradePrepare>(
+  /** The synchronous preparation an upgrade worker of an earlier release asks for; served on the socket only. */
+  private createUpgradePrepareHandler(): plugins.typedrequest.TypedHandler<IReq_ControllerUpgradePrepare> {
+    return new plugins.typedrequest.TypedHandler<IReq_ControllerUpgradePrepare>(
       'controller.upgrade.prepare',
       async (requestArg, toolsArg) => {
         const peer = peerFromLocalData(toolsArg?.localData);
@@ -13733,59 +13770,61 @@ export class OpenCodeController {
           })
         ));
       },
-    ));
+    );
+  }
 
-    publicRouterArg.addTypedHandler(
-      new plugins.typedrequest.TypedHandler<IReq_ControllerUpgradePrepareBegin>(
-        'controller.upgrade.prepare.begin',
-        async (requestArg, toolsArg) => {
-          const peer = peerFromLocalData(toolsArg?.localData);
-          this.recordUnauthenticatedPreflightOperation(peer.id);
-          assertControllerUpgradePreparationRequest(requestArg);
-          return this.runOperation(peer, async () => (
-            this.runUpgradePreparationAdmission(async () => {
-              const installation = await resolveCurrentPnpmGlobalInstallation();
-              const coordinator = this.coordinatorForUpgradeToken(
-                requestArg.token,
-                installation.globalRoot,
-              );
-              if (await this.upgradePreparationReplayIsAccepted(
-                coordinator,
-                requestArg.token,
-                requestArg.targetVersion,
-                requestArg.gracePeriodMs,
-              )) return { accepted: true as const };
-              const status = this.getStatus();
-              await coordinator.consumeControllerActionGrant({
-                token: requestArg.token,
-                action: 'prepare',
-                packageVersion: commitinfo.version,
-                controller: {
-                  pid: status.controllerPid,
-                  processGroupId: status.processGroupId,
-                  processFingerprint: status.processFingerprint,
-                },
-              });
-              await coordinator.recordController(requestArg.token, {
+  private createUpgradePrepareBeginHandler(): plugins.typedrequest.TypedHandler<IReq_ControllerUpgradePrepareBegin> {
+    return new plugins.typedrequest.TypedHandler<IReq_ControllerUpgradePrepareBegin>(
+      'controller.upgrade.prepare.begin',
+      async (requestArg, toolsArg) => {
+        const peer = peerFromLocalData(toolsArg?.localData);
+        this.recordUnauthenticatedPreflightOperation(peer.id);
+        assertControllerUpgradePreparationRequest(requestArg);
+        return this.runOperation(peer, async () => (
+          this.runUpgradePreparationAdmission(async () => {
+            const installation = await resolveCurrentPnpmGlobalInstallation();
+            const coordinator = this.coordinatorForUpgradeToken(
+              requestArg.token,
+              installation.globalRoot,
+            );
+            if (await this.upgradePreparationReplayIsAccepted(
+              coordinator,
+              requestArg.token,
+              requestArg.targetVersion,
+              requestArg.gracePeriodMs,
+            )) return { accepted: true as const };
+            const status = this.getStatus();
+            await coordinator.consumeControllerActionGrant({
+              token: requestArg.token,
+              action: 'prepare',
+              packageVersion: commitinfo.version,
+              controller: {
                 pid: status.controllerPid,
                 processGroupId: status.processGroupId,
-                fingerprint: status.processFingerprint,
-                cliPath: installation.cliPath,
-                command: this.options.processMode === 'detached' ? '__serve' : 'foreground',
-              });
-              return await this.beginUpgradePreparation(
-                coordinator,
-                requestArg.token,
-                requestArg.targetVersion,
-                requestArg.gracePeriodMs,
-              );
-            })
-          ));
-        },
-      ),
+                processFingerprint: status.processFingerprint,
+              },
+            });
+            await coordinator.recordController(requestArg.token, {
+              pid: status.controllerPid,
+              processGroupId: status.processGroupId,
+              fingerprint: status.processFingerprint,
+              cliPath: installation.cliPath,
+              command: this.options.processMode === 'detached' ? '__serve' : 'foreground',
+            });
+            return await this.beginUpgradePreparation(
+              coordinator,
+              requestArg.token,
+              requestArg.targetVersion,
+              requestArg.gracePeriodMs,
+            );
+          })
+        ));
+      },
     );
+  }
 
-    publicRouterArg.addTypedHandler(new plugins.typedrequest.TypedHandler<IReq_ControllerUpgradeFinalize>(
+  private createUpgradeFinalizeHandler(): plugins.typedrequest.TypedHandler<IReq_ControllerUpgradeFinalize> {
+    return new plugins.typedrequest.TypedHandler<IReq_ControllerUpgradeFinalize>(
       'controller.upgrade.finalize',
       async (requestArg, toolsArg) => {
         const peer = peerFromLocalData(toolsArg?.localData);
@@ -13826,7 +13865,7 @@ export class OpenCodeController {
           return await this.finalizeUpgrade(coordinator, requestArg.token, requestArg.mode);
         });
       },
-    ));
+    );
   }
 
   /**