@agentclientprotocol/codex-acp 1.1.7 → 1.1.9

package/dist/index.js

@@ -23582,34 +23582,68 @@ function sameThreadGoalSnapshot(left, right) {
 }
 
 // src/CodexEventHandler.ts
-var CodexEventHandler = class {
-  connection;
+var CodexEventHandler = class _CodexEventHandler {
+  static PLAN_UPDATE_INTERVAL_MS = 150;
   sessionState;
+  supportsPlanUpdates;
   failure = null;
+  completedPlan = null;
   activeFuzzyFileSearchSessions = /* @__PURE__ */ new Set();
   activeGuardianApprovalReviews = /* @__PURE__ */ new Set();
   activeImageGenerationItems = /* @__PURE__ */ new Set();
   emittedImageViewItems = /* @__PURE__ */ new Set();
   planDeltaTextByItemId = /* @__PURE__ */ new Map();
+  pendingPlanItemIds = /* @__PURE__ */ new Set();
+  lastEmittedPlanTextByItemId = /* @__PURE__ */ new Map();
+  session;
+  planUpdateTimer = null;
+  planUpdateChain = Promise.resolve();
+  disposed = false;
   seenReasoningDeltaItemIds = /* @__PURE__ */ new Set();
   terminalCommandIds = /* @__PURE__ */ new Set();
   terminalCommandOutputIds = /* @__PURE__ */ new Set();
   agentMessagePhases = /* @__PURE__ */ new Map();
   activeSubAgentActivities = /* @__PURE__ */ new Set();
-  constructor(connection, sessionState) {
-    this.connection = connection;
+  constructor(connection, sessionState, supportsPlanUpdates = false) {
     this.sessionState = sessionState;
+    this.supportsPlanUpdates = supportsPlanUpdates;
+    this.session = new ACPSessionConnection(connection, sessionState.sessionId);
   }
   getFailure() {
     return this.failure;
   }
+  takeCompletedPlan() {
+    const plan = this.completedPlan;
+    this.completedPlan = null;
+    return plan;
+  }
   async handleNotification(notification) {
-    const session = new ACPSessionConnection(this.connection, this.sessionState.sessionId);
     const updateEvent = await this.createUpdateEvent(notification);
     if (updateEvent) {
-      await session.update(updateEvent);
+      await this.session.update(updateEvent);
     }
   }
+  async flushPendingPlanUpdates() {
+    this.cancelPlanUpdateTimer();
+    do {
+      const itemIds = [...this.pendingPlanItemIds];
+      this.pendingPlanItemIds.clear();
+      await Promise.all(itemIds.map((itemId) => {
+        const text = this.planDeltaTextByItemId.get(itemId) ?? "";
+        return text.length > 0 ? this.enqueuePlanSnapshot(itemId, text) : Promise.resolve();
+      }));
+      await this.planUpdateChain;
+    } while (this.pendingPlanItemIds.size > 0);
+  }
+  async dispose() {
+    if (this.disposed) return;
+    await this.flushPendingPlanUpdates();
+    this.disposed = true;
+    this.cancelPlanUpdateTimer();
+    this.pendingPlanItemIds.clear();
+    this.planDeltaTextByItemId.clear();
+    this.lastEmittedPlanTextByItemId.clear();
+  }
   async createUpdateEvent(notification) {
     switch (notification.method) {
       case "item/agentMessage/delta":
@@ -23628,6 +23662,8 @@ var CodexEventHandler = class {
         this.sessionState.currentTurnId = notification.params.turn.id;
         return null;
       case "turn/completed":
+        await this.flushPendingPlanUpdates();
+        this.clearPlanTurnState();
         this.sessionState.currentTurnId = null;
         return null;
       case "thread/tokenUsage/updated":
@@ -23796,7 +23832,12 @@ ${event.details}` : "";
       return null;
     }
     const text = this.planDeltaTextByItemId.get(event.itemId) ?? "";
-    this.planDeltaTextByItemId.set(event.itemId, text + event.delta);
+    const updatedText = text + event.delta;
+    this.planDeltaTextByItemId.set(event.itemId, updatedText);
+    if (this.supportsPlanUpdates) {
+      this.pendingPlanItemIds.add(event.itemId);
+      this.schedulePlanUpdate();
+    }
     return null;
   }
   createReasoningSectionBreakEvent(event) {
@@ -23894,8 +23935,7 @@ ${event.details}` : "";
         return null;
       case "plan": {
         const deltaText = this.planDeltaTextByItemId.get(event.item.id) ?? "";
-        this.planDeltaTextByItemId.delete(event.item.id);
-        return this.createCompletedPlanEvent(event.item, deltaText);
+        return await this.createCompletedPlanEvent(event.item, deltaText);
       }
       case "exitedReviewMode":
         return this.createExitedReviewModeEvent(event.item);
@@ -23924,13 +23964,64 @@ ${event.details}` : "";
     }
     return this.createAgentThoughtEvent(text, item.id);
   }
-  createCompletedPlanEvent(item, deltaText) {
+  async createCompletedPlanEvent(item, deltaText) {
     const text = item.text.length > 0 ? item.text : deltaText;
+    this.pendingPlanItemIds.delete(item.id);
+    if (this.pendingPlanItemIds.size === 0) {
+      this.cancelPlanUpdateTimer();
+    }
+    this.planDeltaTextByItemId.delete(item.id);
     if (text.length === 0) {
       return null;
     }
+    this.completedPlan = { itemId: item.id, text };
+    if (this.supportsPlanUpdates) {
+      await this.enqueuePlanSnapshot(item.id, text);
+      return null;
+    }
     return this.createPlanTextEvent(text, item.id);
   }
+  schedulePlanUpdate() {
+    if (this.disposed || this.planUpdateTimer !== null) return;
+    this.planUpdateTimer = setTimeout(() => {
+      this.planUpdateTimer = null;
+      void this.flushPendingPlanUpdates().catch((error51) => {
+        logger.error("Failed to flush throttled plan updates", error51);
+      });
+    }, _CodexEventHandler.PLAN_UPDATE_INTERVAL_MS);
+  }
+  cancelPlanUpdateTimer() {
+    if (this.planUpdateTimer === null) return;
+    clearTimeout(this.planUpdateTimer);
+    this.planUpdateTimer = null;
+  }
+  enqueuePlanSnapshot(itemId, text) {
+    const send = async () => {
+      if (this.lastEmittedPlanTextByItemId.get(itemId) === text) return;
+      await this.session.update(this.createPlanUpdateEvent(text, itemId));
+      this.lastEmittedPlanTextByItemId.set(itemId, text);
+    };
+    const result = this.planUpdateChain.then(send);
+    this.planUpdateChain = result.catch(() => {
+    });
+    return result;
+  }
+  clearPlanTurnState() {
+    this.cancelPlanUpdateTimer();
+    this.pendingPlanItemIds.clear();
+    this.planDeltaTextByItemId.clear();
+    this.lastEmittedPlanTextByItemId.clear();
+  }
+  createPlanUpdateEvent(text, planId) {
+    return {
+      sessionUpdate: "plan_update",
+      plan: {
+        type: "markdown",
+        planId,
+        content: text
+      }
+    };
+  }
   createPlanTextEvent(text, messageId) {
     return createAgentTextMessageChunk(
       text,
@@ -24182,12 +24273,17 @@ var ApprovalOptionId = {
 };
 
 // src/CodexApprovalHandler.ts
-function permissionOption(optionId, name, kind, codexMeta) {
+function permissionOption(optionId, name, kind, codexMeta, permission) {
   return {
     optionId,
     name,
     kind,
-    ...codexMeta ? { _meta: { codex: codexMeta } } : {}
+    ...codexMeta || permission ? {
+      _meta: {
+        ...permission ? { permission } : {},
+        ...codexMeta ? { codex: codexMeta } : {}
+      }
+    } : {}
   };
 }
 var CodexApprovalHandler = class {
@@ -24294,13 +24390,15 @@ var CodexApprovalHandler = class {
           ApprovalOptionId.AllowPermissionsForSession,
           "Allow for Session",
           "allow_always",
-          { decision: "allowPermissionsForSession", permissions: params.permissions }
+          { decision: "allowPermissionsForSession", permissions: params.permissions },
+          this.permissionGrantMetadata(params.permissions, "session")
         ),
         permissionOption(
           ApprovalOptionId.AllowPermissionsForTurn,
           "Allow Once",
           "allow_once",
-          { decision: "allowPermissionsForTurn", permissions: params.permissions }
+          { decision: "allowPermissionsForTurn", permissions: params.permissions },
+          this.permissionGrantMetadata(params.permissions, "turn")
         ),
         permissionOption(
           ApprovalOptionId.RejectPermissions,
@@ -24362,7 +24460,24 @@ var CodexApprovalHandler = class {
           ApprovalOptionId.AllowAlways,
           params.networkApprovalContext ? "Allow Host for Session" : "Allow for Session",
           "allow_always",
-          { decision: "acceptForSession" }
+          { decision: "acceptForSession" },
+          params.networkApprovalContext ? {
+            version: 1,
+            changes: [{
+              type: "grant",
+              operation: "grant",
+              description: `Allow access to ${params.networkApprovalContext.host} for this session`,
+              lifetime: { scope: "session" },
+              targets: [{
+                type: "network",
+                matcher: {
+                  type: "host",
+                  host: params.networkApprovalContext.host,
+                  protocol: params.networkApprovalContext.protocol
+                }
+              }]
+            }]
+          } : void 0
         ),
         decision: "acceptForSession"
       }
@@ -24376,6 +24491,22 @@ var CodexApprovalHandler = class {
           {
             decision: "acceptWithExecpolicyAmendment",
             execpolicyAmendment: params.proposedExecpolicyAmendment
+          },
+          {
+            version: 1,
+            changes: [{
+              type: "policy_rule",
+              operation: "add",
+              ruleBehavior: "allow",
+              description: `Allow commands starting with ${params.proposedExecpolicyAmendment.join(" ")}`,
+              targets: [{
+                type: "command",
+                matcher: {
+                  type: "argv_prefix",
+                  argv: params.proposedExecpolicyAmendment
+                }
+              }]
+            }]
           }
         ),
         decision: {
@@ -24394,6 +24525,22 @@ var CodexApprovalHandler = class {
           {
             decision: "applyNetworkPolicyAmendment",
             networkPolicyAmendment: amendment
+          },
+          {
+            version: 1,
+            changes: [{
+              type: "policy_rule",
+              operation: "add",
+              ruleBehavior: amendment.action,
+              description: amendment.action === "allow" ? `Allow access to ${amendment.host}` : `Block access to ${amendment.host}`,
+              targets: [{
+                type: "network",
+                matcher: {
+                  type: "host",
+                  host: amendment.host
+                }
+              }]
+            }]
           }
         ),
         decision: {
@@ -24420,7 +24567,21 @@ var CodexApprovalHandler = class {
           ApprovalOptionId.AllowAlways,
           params.grantRoot ? "Allow Root for Session" : "Allow for Session",
           "allow_always",
-          { decision: "acceptForSession", grantRoot: params.grantRoot ?? null }
+          { decision: "acceptForSession", grantRoot: params.grantRoot ?? null },
+          params.grantRoot ? {
+            version: 1,
+            changes: [{
+              type: "grant",
+              operation: "grant",
+              description: `Allow writes under ${params.grantRoot} for this session`,
+              lifetime: { scope: "session" },
+              targets: [{
+                type: "filesystem",
+                access: ["write"],
+                matcher: { type: "directory", path: params.grantRoot }
+              }]
+            }]
+          } : void 0
         ),
         decision: "acceptForSession"
       },
@@ -24443,6 +24604,68 @@ var CodexApprovalHandler = class {
       ...permissions.fileSystem ? { fileSystem: permissions.fileSystem } : {}
     };
   }
+  permissionGrantMetadata(permissions, scope) {
+    const changes = [];
+    const lifetime = { scope };
+    const suffix = scope === "session" ? " for this session" : " for this turn";
+    if (permissions.network?.enabled !== null && permissions.network?.enabled !== void 0) {
+      const allowed = permissions.network.enabled;
+      changes.push({
+        type: allowed ? "grant" : "policy_rule",
+        operation: allowed ? "grant" : "add",
+        ...allowed ? {} : { ruleBehavior: "deny" },
+        description: `${allowed ? "Allow" : "Deny"} network access${suffix}`,
+        lifetime,
+        targets: [{ type: "network", matcher: { type: "any" } }]
+      });
+    }
+    const fileSystem = permissions.fileSystem;
+    for (const path6 of fileSystem?.read ?? []) {
+      changes.push(this.fileSystemGrantChange(path6, "read", lifetime, suffix));
+    }
+    for (const path6 of fileSystem?.write ?? []) {
+      changes.push(this.fileSystemGrantChange(path6, "write", lifetime, suffix));
+    }
+    for (const entry of fileSystem?.entries ?? []) {
+      const matcher = (() => {
+        switch (entry.path.type) {
+          case "path":
+            return { type: "exact_path", path: entry.path.path };
+          case "glob_pattern":
+            return { type: "glob", pattern: entry.path.pattern };
+          case "special":
+            return { type: "special", provider: "codex", value: entry.path.value };
+        }
+      })();
+      const pathDescription = entry.path.type === "path" ? entry.path.path : entry.path.type === "glob_pattern" ? entry.path.pattern : JSON.stringify(entry.path.value);
+      changes.push({
+        type: entry.access === "deny" ? "policy_rule" : "grant",
+        operation: entry.access === "deny" ? "add" : "grant",
+        ...entry.access === "deny" ? { ruleBehavior: "deny" } : {},
+        description: entry.access === "deny" ? `Deny filesystem access to ${pathDescription}${suffix}` : `Allow ${entry.access} access to ${pathDescription}${suffix}`,
+        lifetime,
+        targets: [{
+          type: "filesystem",
+          ...entry.access === "deny" ? {} : { access: [entry.access] },
+          matcher
+        }]
+      });
+    }
+    return changes.length > 0 ? { version: 1, changes } : void 0;
+  }
+  fileSystemGrantChange(path6, access, lifetime, suffix) {
+    return {
+      type: "grant",
+      operation: "grant",
+      description: `Allow ${access} access to ${path6}${suffix}`,
+      lifetime,
+      targets: [{
+        type: "filesystem",
+        access: [access],
+        matcher: { type: "exact_path", path: path6 }
+      }]
+    };
+  }
   networkPolicyAmendmentOptionId(index) {
     return `${ApprovalOptionId.ApplyNetworkPolicyAmendment}:${index}`;
   }
@@ -25913,7 +26136,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.1.7",
+  version: "1.1.9",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -28413,7 +28636,14 @@ function isJetBrains2026_1Client(clientInfo) {
   return (isIntelliJPlatform || isJetBrainsClient) && clientInfo.version.startsWith("2026.1");
 }
 
+// src/PlanCapabilities.ts
+function clientSupportsPlanUpdates(clientCapabilities) {
+  return clientCapabilities?.plan != null;
+}
+
 // src/CodexAcpServer.ts
+var IMPLEMENT_PLAN_OPTION_ID = "implement_plan";
+var REVISE_PLAN_OPTION_ID = "revise_plan";
 var CodexAcpServer = class _CodexAcpServer {
   static MODEL_NAME_TOKEN_OVERRIDES = {
     gpt: "GPT",
@@ -29532,7 +29762,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       case "contextCompaction":
         return [createCompletedContextCompactionUpdate(item)];
       case "plan":
-        return [this.createPlanMessageUpdate(item)];
+        return item.text.length > 0 ? [this.createPlanHistoryUpdate(item)] : [];
     }
   }
   createUserMessageUpdates(item) {
@@ -29573,7 +29803,17 @@ Check ${configPath} and project .codex directories, especially their config.toml
       }
     };
   }
-  createPlanMessageUpdate(item) {
+  createPlanHistoryUpdate(item) {
+    if (clientSupportsPlanUpdates(this.clientCapabilities)) {
+      return {
+        sessionUpdate: "plan_update",
+        plan: {
+          type: "markdown",
+          planId: item.id,
+          content: item.text
+        }
+      };
+    }
     return createAgentTextMessageChunk(
       item.text,
       item.id,
@@ -29866,8 +30106,14 @@ Check ${configPath} and project .codex directories, especially their config.toml
       return pendingTurnStart;
     };
     const disposePromptRequestCancellation = this.observePromptRequestCancellation(signal, sessionState, activePrompt);
+    let eventHandler = null;
     try {
-      const eventHandler = new CodexEventHandler(this.connection, sessionState);
+      const promptEventHandler = new CodexEventHandler(
+        this.connection,
+        sessionState,
+        clientSupportsPlanUpdates(this.clientCapabilities)
+      );
+      eventHandler = promptEventHandler;
       const approvalHandler = new CodexApprovalHandler(this.connection, sessionState, activePrompt.signal);
       const elicitationHandler = new CodexElicitationHandler(
         this.connection,
@@ -29879,7 +30125,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
         params.sessionId,
         async (event) => {
           await elicitationHandler.handleNotification(event);
-          return eventHandler.handleNotification(event);
+          return promptEventHandler.handleNotification(event);
         },
         approvalHandler,
         elicitationHandler
@@ -29994,7 +30240,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
           logger.error(`Prompt for cancelled session ${params.sessionId} failed after prompt returned`, err);
         }
       });
-      const turnCompleted = await Promise.race([
+      let turnCompleted = await Promise.race([
         sendPromptPromise,
         activePrompt.closeSignal,
         this.cancelBeforeTurnStarted(activePrompt)
@@ -30004,6 +30250,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       }
       await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
       if (turnCompleted.turn.status === "interrupted") {
+        await eventHandler.flushPendingPlanUpdates();
         await this.notifyConversationInterrupted(params.sessionId);
         return this.cancelledPromptResponse(sessionState);
       }
@@ -30011,6 +30258,75 @@ Check ${configPath} and project .codex directories, especially their config.toml
       if (error51) {
         throw error51;
       }
+      await eventHandler.flushPendingPlanUpdates();
+      const completedPlan = eventHandler.takeCompletedPlan();
+      if (completedPlan !== null && sessionState.collaborationMode === PLAN_COLLABORATION_MODE && !this.promptShouldStop(params.sessionId, activePrompt)) {
+        const approved = await this.requestPlanImplementationPermission(
+          sessionState,
+          completedPlan,
+          activePrompt.signal
+        );
+        if (this.promptShouldStop(params.sessionId, activePrompt)) {
+          return this.cancelledPromptResponse(sessionState);
+        }
+        if (approved && !this.promptShouldStop(params.sessionId, activePrompt)) {
+          await this.applyCollaborationModeChange(sessionState, DEFAULT_COLLABORATION_MODE);
+          const session = new ACPSessionConnection(this.connection, sessionState.sessionId);
+          await session.update({
+            sessionUpdate: "config_option_update",
+            configOptions: this.createSessionConfigOptions(sessionState)
+          });
+          const implementationRequest = {
+            sessionId: params.sessionId,
+            prompt: [{ type: "text", text: "Implement the approved plan." }]
+          };
+          activePrompt.currentTurn = null;
+          const implementationPromise = this.runWithProcessCheck(
+            () => this.codexAcpClient.sendPrompt(
+              implementationRequest,
+              agentMode,
+              modelId,
+              serviceTier,
+              disableSummary,
+              sessionState.cwd,
+              sessionState.additionalDirectories,
+              (turnId) => {
+                const turn = { threadId: params.sessionId, turnId };
+                activePrompt.currentTurn = turn;
+                if (this.promptShouldStop(params.sessionId, activePrompt)) {
+                  this.interruptLateStartedTurn(turn);
+                  return;
+                }
+                sessionState.currentTurnId = turnId;
+              },
+              () => this.promptShouldStop(params.sessionId, activePrompt)
+            )
+          );
+          void implementationPromise.catch((err) => {
+            if (this.activePrompts.get(params.sessionId) !== activePrompt) {
+              logger.error(`Implementation turn for cancelled prompt ${params.sessionId} failed after prompt returned`, err);
+            }
+          });
+          turnCompleted = await Promise.race([
+            implementationPromise,
+            activePrompt.closeSignal,
+            this.cancelBeforeTurnStarted(activePrompt)
+          ]);
+          if (turnCompleted === null) {
+            return this.cancelledPromptResponse(sessionState);
+          }
+          await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
+          if (turnCompleted.turn.status === "interrupted") {
+            await eventHandler.flushPendingPlanUpdates();
+            await this.notifyConversationInterrupted(params.sessionId);
+            return this.cancelledPromptResponse(sessionState);
+          }
+          const implementationError = eventHandler.getFailure();
+          if (implementationError) {
+            throw implementationError;
+          }
+        }
+      }
       await this.publishFallbackSessionTitle(
         sessionState,
         this.createPromptFallbackTitle(params.prompt)
@@ -30025,6 +30341,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       throw err;
     } finally {
       logger.log("Prompt completed", { sessionId: params.sessionId });
+      await eventHandler?.dispose();
       disposePromptRequestCancellation();
       sessionState.currentTurnId = null;
       const registeredPendingTurnStart = this.pendingTurnStarts.get(params.sessionId);
@@ -30035,6 +30352,57 @@ Check ${configPath} and project .codex directories, especially their config.toml
       activePrompt.complete();
     }
   }
+  async requestPlanImplementationPermission(sessionState, plan, cancellationSignal) {
+    const toolCallId = `plan-review:${plan.itemId}`;
+    try {
+      const response = await this.connection.request(
+        methods.client.session.requestPermission,
+        {
+          sessionId: sessionState.sessionId,
+          toolCall: {
+            toolCallId,
+            title: "Implement this plan?",
+            kind: "switch_mode",
+            status: "pending",
+            rawInput: { plan: plan.text }
+          },
+          options: [
+            {
+              optionId: IMPLEMENT_PLAN_OPTION_ID,
+              name: "Yes, implement this plan",
+              kind: "allow_once"
+            },
+            {
+              optionId: REVISE_PLAN_OPTION_ID,
+              name: "No, and tell Codex what to do differently",
+              kind: "reject_once"
+            }
+          ],
+          _meta: {
+            codex: {
+              kind: "plan_review",
+              planItemId: plan.itemId
+            }
+          }
+        },
+        { cancellationSignal }
+      );
+      const approved = response.outcome.outcome === "selected" && response.outcome.optionId === IMPLEMENT_PLAN_OPTION_ID;
+      await this.connection.notify(methods.client.session.update, {
+        sessionId: sessionState.sessionId,
+        update: {
+          sessionUpdate: "tool_call_update",
+          toolCallId,
+          status: "completed",
+          rawOutput: approved ? "User approved the plan." : "User kept the session in plan mode."
+        }
+      });
+      return approved;
+    } catch (error51) {
+      logger.error("Error requesting plan implementation permission", error51);
+      return false;
+    }
+  }
   cancelledPromptResponse(sessionState) {
     return {
       stopReason: "cancelled",

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.1.7",
+  "version": "1.1.9",
   "description": "",
   "main": "dist/index.js",
   "bin": {