@agentclientprotocol/codex-acp 1.1.7 → 1.1.8

package/dist/index.js

@@ -23585,7 +23585,9 @@ function sameThreadGoalSnapshot(left, right) {
 var CodexEventHandler = class {
   connection;
   sessionState;
+  supportsPlanUpdates;
   failure = null;
+  completedPlan = null;
   activeFuzzyFileSearchSessions = /* @__PURE__ */ new Set();
   activeGuardianApprovalReviews = /* @__PURE__ */ new Set();
   activeImageGenerationItems = /* @__PURE__ */ new Set();
@@ -23596,13 +23598,19 @@ var CodexEventHandler = class {
   terminalCommandOutputIds = /* @__PURE__ */ new Set();
   agentMessagePhases = /* @__PURE__ */ new Map();
   activeSubAgentActivities = /* @__PURE__ */ new Set();
-  constructor(connection, sessionState) {
+  constructor(connection, sessionState, supportsPlanUpdates = false) {
     this.connection = connection;
     this.sessionState = sessionState;
+    this.supportsPlanUpdates = supportsPlanUpdates;
   }
   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);
@@ -23796,8 +23804,9 @@ ${event.details}` : "";
       return null;
     }
     const text = this.planDeltaTextByItemId.get(event.itemId) ?? "";
-    this.planDeltaTextByItemId.set(event.itemId, text + event.delta);
-    return null;
+    const updatedText = text + event.delta;
+    this.planDeltaTextByItemId.set(event.itemId, updatedText);
+    return this.supportsPlanUpdates ? this.createPlanUpdateEvent(updatedText, event.itemId) : null;
   }
   createReasoningSectionBreakEvent(event) {
     this.seenReasoningDeltaItemIds.add(event.itemId);
@@ -23929,7 +23938,18 @@ ${event.details}` : "";
     if (text.length === 0) {
       return null;
     }
-    return this.createPlanTextEvent(text, item.id);
+    this.completedPlan = { itemId: item.id, text };
+    return this.supportsPlanUpdates ? this.createPlanUpdateEvent(text, item.id) : this.createPlanTextEvent(text, item.id);
+  }
+  createPlanUpdateEvent(text, planId) {
+    return {
+      sessionUpdate: "plan_update",
+      plan: {
+        type: "markdown",
+        planId,
+        content: text
+      }
+    };
   }
   createPlanTextEvent(text, messageId) {
     return createAgentTextMessageChunk(
@@ -24182,12 +24202,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 +24319,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 +24389,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 +24420,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 +24454,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 +24496,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 +24533,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 +26065,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.1.7",
+  version: "1.1.8",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -28413,7 +28565,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 +29691,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 +29732,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,
@@ -29867,7 +30036,11 @@ Check ${configPath} and project .codex directories, especially their config.toml
     };
     const disposePromptRequestCancellation = this.observePromptRequestCancellation(signal, sessionState, activePrompt);
     try {
-      const eventHandler = new CodexEventHandler(this.connection, sessionState);
+      const eventHandler = new CodexEventHandler(
+        this.connection,
+        sessionState,
+        clientSupportsPlanUpdates(this.clientCapabilities)
+      );
       const approvalHandler = new CodexApprovalHandler(this.connection, sessionState, activePrompt.signal);
       const elicitationHandler = new CodexElicitationHandler(
         this.connection,
@@ -29994,7 +30167,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)
@@ -30011,6 +30184,73 @@ Check ${configPath} and project .codex directories, especially their config.toml
       if (error51) {
         throw error51;
       }
+      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 this.notifyConversationInterrupted(params.sessionId);
+            return this.cancelledPromptResponse(sessionState);
+          }
+          const implementationError = eventHandler.getFailure();
+          if (implementationError) {
+            throw implementationError;
+          }
+        }
+      }
       await this.publishFallbackSessionTitle(
         sessionState,
         this.createPromptFallbackTitle(params.prompt)
@@ -30035,6 +30275,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.8",
   "description": "",
   "main": "dist/index.js",
   "bin": {