agl 41.0.0 → 41.1.0

package/ts/classes.authstore.ts

@@ -44,6 +44,7 @@ import {
 import {
   ControllerAuditEventModel,
   ControllerAuthModel,
+  ControllerRuntimeConfigFromLaterReleaseError,
   ControllerPendingPromptModel,
   ControllerProjectModel,
   ControllerResourceModel,
@@ -202,6 +203,24 @@ const auditPruneMaxBatchesPerSweep = 50;
 const auditCountPruneMaxBatchesPerSweep = 250;
 const auditPruneIntervalMs = 30 * 60 * 1000;
 
+/**
+ * The stored authentication document of `controllerIdArg`. A runtime configuration only a later release writes is
+ * refused with its own reason (`ControllerRuntimeConfigFromLaterReleaseError`), not the client's generic assertion
+ * failure, so the operator reads the remedy.
+ */
+const findStoredAuthDocument = async (
+  controllerIdArg: string,
+): Promise<plugins.nosqldb.TStoredDocument<IControllerAuthDocument> | null> => {
+  try {
+    return await ControllerAuthModel.exact.findStoredOne({ id: controllerIdArg });
+  } catch (errorArg) {
+    if (errorArg instanceof Error && errorArg.cause instanceof ControllerRuntimeConfigFromLaterReleaseError) {
+      throw errorArg.cause;
+    }
+    throw errorArg;
+  }
+};
+
 /** A concurrent prune that removed an event first leaves nothing to do for it. */
 const deleteStoredAuditEvents = async (
   eventsArg: Array<plugins.nosqldb.TStoredDocument<IControllerAuditEvent>>,
@@ -1306,7 +1325,7 @@ export class SmartDataAuthStore implements IAuthStore, IAuthStoreSessionIdentity
       throw new Error('controllerPort must be an integer between 1 and 65535.');
     }
     this.controllerId = `controller:${controllerPortArg}`;
-    const stored = await ControllerAuthModel.exact.findStoredOne({ id: this.controllerId });
+    const stored = await findStoredAuthDocument(this.controllerId);
     if (!stored) return undefined;
     return cloneRuntimeConfig(ControllerAuthModel.exact.toPersisted(stored).config);
   }
@@ -1336,7 +1355,7 @@ export class SmartDataAuthStore implements IAuthStore, IAuthStoreSessionIdentity
     }
     const controllerId = `controller:${runtimeConfigArg.controllerPort}`;
     this.controllerId = controllerId;
-    const existing = await ControllerAuthModel.exact.findStoredOne({ id: controllerId });
+    const existing = await findStoredAuthDocument(controllerId);
     if (existing) {
       const document = ControllerAuthModel.exact.toPersisted(existing);
       return this.finalizeRuntimeConfigDocument(document, runtimeConfigArg);
@@ -1356,7 +1375,7 @@ export class SmartDataAuthStore implements IAuthStore, IAuthStoreSessionIdentity
       return this.finalizeRuntimeConfigDocument(document, runtimeConfigArg);
     } catch (errorArg) {
       if (!isAmbiguousWrite(errorArg)) throw errorArg;
-      const reconciled = await ControllerAuthModel.exact.findStoredOne({ id: controllerId });
+      const reconciled = await findStoredAuthDocument(controllerId);
       if (!reconciled) {
         throw new AuthError(
           'ambiguous_write',
@@ -2326,7 +2345,7 @@ export class SmartDataAuthStore implements IAuthStore, IAuthStoreSessionIdentity
     if (!this.controllerId) {
       throw new AuthError('not_initialized', 'The controller runtime configuration is unresolved.');
     }
-    const stored = await ControllerAuthModel.exact.findStoredOne({ id: this.controllerId });
+    const stored = await findStoredAuthDocument(this.controllerId);
     if (!stored) {
       throw new AuthError('not_initialized', 'The controller authentication document is missing.');
     }
@@ -5297,6 +5316,7 @@ export class SmartDataAuthStore implements IAuthStore, IAuthStoreSessionIdentity
       && leftArg.credentialId === rightArg.credentialId
       && leftArg.senderLabel === rightArg.senderLabel
       && JSON.stringify(leftArg.localCli) === JSON.stringify(rightArg.localCli)
+      && JSON.stringify(leftArg.details) === JSON.stringify(rightArg.details)
       && (
         leftArg.sessionId === undefined
           ? rightArg.sessionId === undefined

package/ts/classes.cli.ts

@@ -6,6 +6,7 @@ import {
   controllerProtocolVersion,
   controllerServiceUnitName,
   controllerUpgradeManagementVersion,
+  controllerManagementProtocolVersion,
   configurationOwnerTokenEnvironmentVariable,
   describeBrowserPaintAvailability,
   type IControllerStatus,
@@ -39,6 +40,7 @@ import {
   stopRunningController,
   tryQueryControllerStatus as tryQueryManagedControllerStatus,
   waitUntilControllerExited,
+  type IControllerStatusQuery,
 } from './classes.controllermanagement.js';
 import {
   inspectControllerProcess,
@@ -409,11 +411,16 @@ export const parseRuntimeOverrides = (
   };
 };
 
-const currentStatusExpectation = {
+/**
+ * The CLI manages the controller of its own package, so it reads that controller's status over the transport its own
+ * `package.json` declares (`controllerManagementProtocolVersion`, which this build's constant equals).
+ */
+const currentStatusExpectation: IControllerStatusQuery = {
   packageName: controllerPackageName,
   packageVersion: commitinfo.version,
   protocolVersion: controllerProtocolVersion,
   upgradeManagementVersion: controllerUpgradeManagementVersion,
+  managementProtocolVersion: controllerManagementProtocolVersion,
 };
 
 const assertStatus = (statusArg: unknown): IControllerStatus => assertControllerStatus(
@@ -1780,7 +1787,7 @@ const upgradeController = async (argvArg: TParsedArguments): Promise<void> => {
             controller: payload.expectedController!,
           });
           try {
-            const launched = await requestControllerUpgradeLaunch(port, payload.token);
+            const launched = await requestControllerUpgradeLaunch(port, status, payload.token);
             worker = {
               pid: launched.workerPid,
               cliPath: installation.cliPath,

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),
@@ -10624,7 +10632,7 @@ export class OpenCodeController {
       }
       const lifecycleGeneration = plugins.crypto.randomBytes(24).toString('base64url');
       const workerCallers = new ControllerWorkerCallers({ controllerGeneration: lifecycleGeneration,
-        registry: this.mcpCallerRegistry,
+        controllerPort: runtimeConfig.controllerPort, registry: this.mcpCallerRegistry,
         readMaster: async () => {
           const resource = await configurationAuthority.getResource();
           return (await configurationAuthority.getMaster({ resourceId: resource.resourceId })).master;
@@ -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);
         });
       },
-    ));
+    );
   }
 
   /**