agl 41.0.0 → 41.0.1

package/ts/classes.workercallers.ts

@@ -75,6 +75,8 @@ type TReproof = { kind: 'rebound' } | { kind: 'refused'; reason: string } | { ki
 
 export interface IControllerWorkerCallerOptions {
   controllerGeneration: string;
+  /** The port this controller is configured to serve: a bridge an upgrade re-executed in place names it (`aglMcpReexecArguments`). */
+  controllerPort: number;
   registry: ControllerMcpCallerRegistry;
   readMaster(): Promise<IConfigurationMaster>;
   captureCodexOrigin(launch: Extract<TFleetWorkerCallerLaunch, { harnessId: 'codex' }>): Promise<IWorkerCodexCallerOrigin>;
@@ -103,8 +105,10 @@ const pending = (): IWorkerCallerEnrollmentResponse => ({ callerPending: true, b
 const transientRefusalMs = 5_000;
 const maximumRefusals = 64;
 const maximumLoggedReasons = 4096;
+/** A message as a clause of a pending reason, without its final period: the log line ends the sentence. */
+const clause = (messageArg: string): string => messageArg.replace(/\.+$/u, '');
 const proofReason = (errorArg: unknown): string => errorArg instanceof WorkerCallerProofError
-  ? errorArg.message : `a process could not be read (${(errorArg as NodeJS.ErrnoException).code ?? 'unknown'})`;
+  ? clause(errorArg.message) : `a process could not be read (${(errorArg as NodeJS.ErrnoException).code ?? 'unknown'})`;
 const assertIdentifier = (valueArg: string): void => {
   if (typeof valueArg !== 'string' || !/^[A-Za-z0-9_.:-]{1,256}$/u.test(valueArg)) throw new Error('Invalid worker launch identifier.');
 };
@@ -377,19 +381,20 @@ export class ControllerWorkerCallers implements IFleetWorkerCallerHooks {
   private async reprove(recordArg: IWorkerLaunch, bridgePidArg: number, connectionArg?: IWorkerCallerConnection): Promise<TReproof> {
     const observe = this.options.observeClaudeJob;
     if (!observe) return { kind: 'refused', reason: 'the process its launch is bound to is gone, and no fleet proves the job\'s next process' };
+    const port = this.options.controllerPort;
     let bridge: IWorkerProcessSnapshot, command = recordArg.command!;
-    try { bridge = await this.proof.readBridge(connectionArg, bridgePidArg, command); } catch (errorArg) {
+    try { bridge = await this.proof.readBridge(connectionArg, bridgePidArg, command, port); } catch (errorArg) {
       if (!isWorkerCallerProofRefusal(errorArg)) throw errorArg;
       // An upgrade re-executes a bridge in place onto the build the controller runs now: it runs the command this
       // controller resolves from its own configured `agl` entry, never one the bridge names.
       let current: IWorkerBridgeCommand;
       try { current = await this.currentCommand(); } catch (resolveArg) {
-        return { kind: 'refused', reason: `${proofReason(errorArg)} (the approved bridge command cannot be resolved now: ${resolveArg instanceof Error ? resolveArg.message : 'unknown failure'})` };
+        return { kind: 'refused', reason: `${proofReason(errorArg)} (the approved bridge command cannot be resolved now: ${resolveArg instanceof Error ? clause(resolveArg.message) : 'unknown failure'})` };
       }
       if (plugins.util.isDeepStrictEqual(current, command)) return { kind: 'refused', reason: proofReason(errorArg) };
-      try { bridge = await this.proof.readBridge(connectionArg, bridgePidArg, current); } catch (currentArg) {
+      try { bridge = await this.proof.readBridge(connectionArg, bridgePidArg, current, port); } catch (currentArg) {
         if (!isWorkerCallerProofRefusal(currentArg)) throw currentArg;
-        return { kind: 'refused', reason: proofReason(errorArg) };
+        return { kind: 'refused', reason: `recorded bridge command: ${proofReason(errorArg)}; current bridge command: ${proofReason(currentArg)}` };
       }
       command = current;
     }
@@ -433,7 +438,7 @@ export class ControllerWorkerCallers implements IFleetWorkerCallerHooks {
         if (!isWorkerCallerProofRefusal(errorArg)) throw errorArg;
         return refuse('the process of its Claude job is not the approved Claude Code executable', false);
       }
-      try { await this.proof.verifyBridge(connectionArg, bridge.pid, command, parent); } catch (errorArg) {
+      try { await this.proof.verifyBridge(connectionArg, bridge.pid, command, parent, port); } catch (errorArg) {
         if (!isWorkerCallerProofRefusal(errorArg)) throw errorArg;
         return refuse('its bridge is not proved to be a direct child of the process of its Claude job', true);
       }
@@ -678,7 +683,7 @@ export class ControllerWorkerCallers implements IFleetWorkerCallerHooks {
   private async safeSnapshot(recordArg: IWorkerLaunch, bridgePidArg: number, connectionArg?: IWorkerCallerConnection): Promise<IWorkerProcessSnapshot> {
     if (recordArg.state !== 'bound' || !recordArg.command || !recordArg.parent || this.closed
       || (recordArg.codex && !await recordArg.codex.isCurrent())) throw new WorkerCallerProofError('Worker caller proof is unavailable.');
-    return this.proof.verifyBridge(connectionArg, bridgePidArg, recordArg.command, recordArg.parent);
+    return this.proof.verifyBridge(connectionArg, bridgePidArg, recordArg.command, recordArg.parent, this.options.controllerPort);
   }
 
   private async prove(recordArg: IWorkerLaunch, bridgePidArg: number, connectionArg?: IWorkerCallerConnection,

package/ts/functions.workerprocessproof.ts

@@ -142,15 +142,26 @@ const processOwnsLoopbackConnection = async (connectionArg: IWorkerCallerConnect
   return matches.length === 1 && await processOwnsInode(pidArg, matches[0][9]);
 };
 
+/**
+ * The arguments after its `cli.js` entry that an upgrade re-executes an `agl mcp` bridge of the controller on
+ * `controllerPortArg` with (`AglMcpReexecCoordinator`): the port pins the next image to its handover record's.
+ * A bridge proof accepts exactly these besides the approved command's own.
+ */
+export const aglMcpReexecArguments = (controllerPortArg: number): string[] => ['mcp', '--port', String(controllerPortArg)];
+
 /**
  * The bridge process `bridgePidArg`, proved to hold the caller's end of the direct loopback connection and to run the
  * approved command, whatever its parent. The command is the one recorded when the launch was prepared: an upgrade
- * installs AGL under another path, and a command whose files are gone is refused as such.
+ * installs AGL under another path, and a command whose files are gone is refused as such. Its arguments are the
+ * approved ones or, once an upgrade re-executed the bridge in place, `aglMcpReexecArguments` for `controllerPortArg`,
+ * the port this controller is configured with, never one the bridge names: the connection proof already shows that
+ * the bridge talks to this controller.
  */
 export const readWorkerBridge = async (
   connectionArg: IWorkerCallerConnection | undefined,
   bridgePidArg: number,
   commandArg: IWorkerBridgeCommand,
+  controllerPortArg: number,
 ): Promise<IWorkerProcessSnapshot> => {
   for (const file of [commandArg.executable, commandArg.entry]) {
     let resolved: string;
@@ -165,8 +176,10 @@ export const readWorkerBridge = async (
   }
   const bridge = await readWorkerProcessSnapshot(bridgePidArg);
   const entry = await plugins.fs.promises.realpath(bridge.arguments[1] ?? '');
+  const argumentsTail = bridge.arguments.slice(2);
   if (bridge.executable !== commandArg.executable || entry !== commandArg.entry
-    || !plugins.util.isDeepStrictEqual(bridge.arguments.slice(2), commandArg.arguments)) {
+    || (!plugins.util.isDeepStrictEqual(argumentsTail, commandArg.arguments)
+      && !plugins.util.isDeepStrictEqual(argumentsTail, aglMcpReexecArguments(controllerPortArg)))) {
     throw new WorkerCallerProofError('Worker bridge does not match the approved launch.');
   }
   return bridge;
@@ -177,8 +190,9 @@ export const verifyWorkerBridge = async (
   bridgePidArg: number,
   commandArg: IWorkerBridgeCommand,
   parentArg: IWorkerProcessSnapshot,
+  controllerPortArg: number,
 ): Promise<IWorkerProcessSnapshot> => {
-  const bridge = await readWorkerBridge(connectionArg, bridgePidArg, commandArg);
+  const bridge = await readWorkerBridge(connectionArg, bridgePidArg, commandArg, controllerPortArg);
   if (bridge.parentPid !== parentArg.pid) throw new WorkerCallerProofError('Worker bridge does not match the approved launch.');
   if (!workerSnapshotsEqual(parentArg, await readWorkerProcessSnapshot(parentArg.pid))
     || !workerSnapshotsEqual(bridge, await readWorkerProcessSnapshot(bridge.pid))) {

package/ts_web/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: 'agl',
-  version: '41.0.0',
+  version: '41.0.1',
   description: 'Agent Gateway Layer for OpenCode, FlexHarness, and Codex sessions'
 }