@codexhost/cli-darwin-arm64 0.17.0 → 0.17.1

package/app/plugins/antigravity/plugin.mjs

@@ -19804,17 +19804,20 @@ ${line}`).slice(-8e3);
       else if (unshown.trim() !== "")
         this.#appendAgentText(active, unshown);
     }
+    if (!convId) {
+      this.#completeIdentitylessTurn(active, event);
+      return;
+    }
     const safeTurnId = event.result.num_turns !== void 0 && event.result.num_turns !== null ? `turn:${event.result.num_turns}` : `turn:${this.#history.snapshot().length + 1}`;
-    const safeSessionId = convId || this.#nativeRef?.nativeSessionId || "unknown-session";
     const nativeTurnRef = nativeTurnRefSchema.parse({
       harnessId: this.harnessId,
-      nativeSessionId: safeSessionId,
+      nativeSessionId: convId,
       nativeTurnKey: safeTurnId,
       formatVersion: 1
     });
     const checkpoint = nativeCheckpointRefSchema.parse({
       harnessId: this.harnessId,
-      nativeSessionId: safeSessionId,
+      nativeSessionId: convId,
       checkpointId: safeTurnId,
       formatVersion: 1
     });
@@ -19831,16 +19834,33 @@ ${line}`).slice(-8e3);
         this.#completeTurn(active, { status: "succeeded", checkpoint }, nativeTurnRef);
       }
     } else {
-      const nativeError = event.result.error?.trim();
-      const errorDetail = nativeError || active.stderr;
-      const error51 = normalizedProcessError(errorDetail, `Antigravity Turn ended with status ${event.result.status}`, nativeError !== void 0);
-      if (repliedThisTurn && nativeError && this.#reportedEarlier(error51)) {
+      const error51 = this.#resultError(active, event);
+      if (repliedThisTurn && event.result.error?.trim() && this.#reportedEarlier(error51)) {
         this.#completeTurn(active, { status: "succeeded", checkpoint }, nativeTurnRef);
       } else {
         this.#completeTurn(active, { status: "failed", error: error51, checkpoint }, nativeTurnRef);
       }
     }
   }
+  /** A Turn agy ended without a Conversation keeps its native outcome but no native identity. */
+  #completeIdentitylessTurn(active, event) {
+    if (active.cancellationRequested) {
+      this.#completeTurn(active, { status: "cancelled", reason: "Cancelled by user" });
+      return;
+    }
+    this.#completeTurn(active, {
+      status: "failed",
+      error: event.result.status === "SUCCESS" ? {
+        code: "protocolError",
+        message: "Antigravity finished the Turn without a Conversation identity",
+        retryable: true
+      } : this.#resultError(active, event)
+    });
+  }
+  #resultError(active, event) {
+    const nativeError = event.result.error?.trim();
+    return normalizedProcessError(nativeError || active.stderr, `Antigravity Turn ended with status ${event.result.status}`, nativeError !== void 0);
+  }
   #reportedEarlier(error51) {
     return this.#history.snapshot().some(({ outcome }) => outcome.status === "failed" && outcome.error.code === error51.code && outcome.error.message === error51.message);
   }

package/app/plugins/cursor-cli/plugin.mjs

@@ -17042,6 +17042,16 @@ function cursorConfigDirectory(environment) {
   const home = environment.HOME ?? environment.USERPROFILE ?? os2.homedir();
   return environment.CURSOR_CONFIG_DIR?.trim() ? path6.resolve(environment.CURSOR_CONFIG_DIR) : environment.XDG_CONFIG_HOME?.trim() ? path6.resolve(environment.XDG_CONFIG_HOME, "cursor") : path6.join(home, ".cursor");
 }
+function cursorCliApprovalModeIsUnrestricted(environment, cwd = process.cwd()) {
+  try {
+    const home = (process.platform === "win32" ? environment.USERPROFILE : environment.HOME) ?? os2.userInfo().homedir;
+    const directory = environment.CURSOR_CONFIG_DIR?.trim() ? environment.CURSOR_CONFIG_DIR : environment.XDG_CONFIG_HOME?.trim() ? path6.join(environment.XDG_CONFIG_HOME, "cursor") : path6.join(home, ".cursor");
+    const raw = JSON.parse(readFileSync(path6.resolve(cwd, directory, "cli-config.json"), "utf8"));
+    return !!raw && typeof raw === "object" && !Array.isArray(raw) && raw.approvalMode === "unrestricted";
+  } catch {
+    return false;
+  }
+}
 function cursorSessionDirectory(sessionId, environment) {
   if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu.test(sessionId))
     throw new Error("Unsupported Cursor native session ID");
@@ -17413,12 +17423,17 @@ function cursorCatalog(info) {
   const native = cursorModels(info);
   const thinking = /* @__PURE__ */ new Map();
   const models = native.models.map((model2) => {
-    const config2 = model2.value === native.current ? info.configOptions : info.nativeModels?.find((entry) => entry.value === model2.value)?.configOptions;
+    const live = model2.value === native.current;
+    const config2 = live ? info.configOptions : info.nativeModels?.find((entry) => entry.value === model2.value)?.configOptions;
     const options = cursorThinking(config2);
     for (const { id, label } of options)
       thinking.set(id, { id, label });
     return {
-      ref: cursorConfiguredModelRef(model2.value, config2),
+      // Only the live model's parameters reflect the user's Cursor settings. The parameterized
+      // catalog reports Cursor's built-in defaults for every other model (for example
+      // `fast=true`), so pinning them would override the user's remembered per-model parameters.
+      // A bare Ref selects only the model and lets Cursor apply those parameters itself.
+      ref: live ? cursorConfiguredModelRef(model2.value, config2) : cursorModelRef(model2.value),
       label: model2.name,
       supportedThinkingOptionIds: options.map(({ id }) => id)
     };
@@ -21717,7 +21732,8 @@ var CursorTransport = class {
     return this.#preparation ??= this.#prepare();
   }
   async #prepare() {
-    const invocation = cursorInvocation(this.options.environment, this.options.command, this.options.executionPolicy === "unattended-full-access" ? ["--force", "acp"] : ["acp"]);
+    const useForce = this.options.executionPolicy === "unattended-full-access" || cursorCliApprovalModeIsUnrestricted(this.options.environment, this.options.cwd);
+    const invocation = cursorInvocation(this.options.environment, this.options.command, useForce ? ["--force", "acp"] : ["acp"]);
     const child = spawn(invocation.command, invocation.arguments, {
       cwd: this.options.cwd,
       env: this.options.environment,

package/app/plugins/kimi-code/plugin.mjs

@@ -24385,6 +24385,38 @@ function formatKimiCommandOutput(text) {
   return cleaned;
 }
 
+// dist/plan-approval.js
+import { randomUUID as randomUUID3 } from "node:crypto";
+function projectKimiPlanApprovalRequest(turnId, request) {
+  const { options } = request;
+  if (request.toolCall.title !== "ExitPlanMode" || !options.some(({ optionId, kind }) => optionId === "plan_revise" && kind === "reject_once") || !options.some(({ optionId, kind }) => optionId === "plan_reject_and_exit" && kind === "reject_once") || !options.some(({ kind }) => kind === "allow_once") || new Set(options.map(({ optionId }) => optionId)).size !== options.length || new Set(options.map(({ name }) => name)).size !== options.length || !options.every(({ optionId, kind, name }) => name.trim().length > 0 && (kind === "allow_once" ? optionId === "plan_approve" || /^plan_opt_\d+$/.test(optionId) : kind === "reject_once" && (optionId === "plan_revise" || optionId === "plan_reject_and_exit"))))
+    return null;
+  return {
+    interaction: {
+      type: "question",
+      interactionId: hostInteractionIdSchema.parse(randomUUID3()),
+      turnId,
+      title: "Kimi Code 计划审批",
+      questions: [
+        {
+          id: "planApproval",
+          type: "choice",
+          prompt: readAcpToolContentText(request.toolCall.content) || "ExitPlanMode",
+          options: options.map(({ optionId, name }) => ({ value: optionId, label: name })),
+          multiple: false,
+          allowOther: false,
+          optional: false
+        }
+      ]
+    },
+    schemaProperties: { planApproval: { type: "string" } },
+    parseResponse(response) {
+      const selected = response.action === "accept" ? response.content?.planApproval : void 0;
+      return typeof selected === "string" && options.some(({ optionId }) => optionId === selected) ? { outcome: { outcome: "selected", optionId: selected } } : { outcome: { outcome: "cancelled" } };
+    }
+  };
+}
+
 // dist/kimi-session.js
 var kimiHarnessId2 = harnessIdSchema.parse("kimi-code");
 var defaultNativeTurnFlushTimeoutMs = 6e3;
@@ -24921,6 +24953,19 @@ var KimiSession = class {
         if (currentAgentMessage) {
           completeAgentMessage("commentary");
         }
+        const plan = projectKimiPlanApprovalRequest(turnId, request);
+        if (plan) {
+          return new Promise((resolve) => {
+            this.#activeInteractions.set(plan.interaction.interactionId, {
+              id: plan.interaction.interactionId,
+              type: "question",
+              interaction: plan.interaction,
+              metadata: plan.schemaProperties,
+              resolve: (value) => resolve(plan.parseResponse(value))
+            });
+            this.#channel.emit({ kind: "interaction", interaction: plan.interaction });
+          });
+        }
         const projected = projectKimiApprovalRequest(turnId, request);
         return new Promise((resolve) => {
           this.#activeInteractions.set(projected.interaction.interactionId, {
@@ -25536,8 +25581,9 @@ var KimiAdapter = class {
     if (this.#closed) {
       return err2("invalidState", "Adapter is closed");
     }
-    if (input.kind === "create" && input.executionPolicy === "unattended-full-access") {
-      return err2("unsupported", "Kimi Code cannot guarantee unattended-full-access");
+    const unattended = input.kind === "create" && input.executionPolicy === "unattended-full-access";
+    if (unattended && input.permissionModeId && input.permissionModeId !== "yolo") {
+      return err2("invalidRequest", "Kimi Code unattended execution requires the yolo Permission Mode");
     }
     if (input.kind === "resume" && input.nativeRef.harnessId !== this.harnessId || input.kind === "rollbackLastTurn" && input.sourceRef.harnessId !== this.harnessId) {
       return err2("invalidRequest", "Native Session belongs to a different Harness");
@@ -25597,10 +25643,11 @@ var KimiAdapter = class {
         if (input.permissionModeId && !isKimiModeId(input.permissionModeId)) {
           throw new Error(`Unsupported permission mode: ${input.permissionModeId}`);
         }
+        const permissionModeId = input.permissionModeId ?? (unattended ? "yolo" : void 0);
         const requested = [
           ...input.model ? [{ id: "model", value: decodeKimiModelRefId(input.model.id) }] : [],
           ...input.thinkingOptionId ? [{ id: "thinking", value: input.thinkingOptionId }] : [],
-          ...input.permissionModeId ? [{ id: "mode", value: input.permissionModeId }] : []
+          ...permissionModeId ? [{ id: "mode", value: permissionModeId }] : []
         ];
         const configOptions = await applyRequestedConfig(transport, sessionInfo.configOptions, requested);
         const state = stateFromConfig(sessionInfo.sessionId, cwd, configOptions);