@qwen-code/qwen-code 0.19.7-nightly.20260708.394c1a289 → 0.19.8

package/chunks/{chunk-2NPS2UDH.js → chunk-IBY3Q3HG.js}

@@ -77,6 +77,7 @@ __name(getGlobalQwenDir, "getGlobalQwenDir");
 // packages/channels/base/dist/AcpBridge.js
 init_esbuild_shims();
 import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { Readable, Writable } from "node:stream";
 import { EventEmitter } from "node:events";
 
@@ -240,6 +241,7 @@ __name(readId, "readId");
 // packages/channels/base/dist/AcpBridge.js
 var MID_TURN_QUEUE_DRAIN_METHOD = "craft/drainMidTurnQueue";
 var ACP_EVENT_LOOP_STALL_RESTART_MS = 5 * 60 * 1e3;
+var ACP_PERMISSION_RESPONSE_TIMEOUT_MS = 5 * 60 * 1e3;
 var ACP_EVENT_LOOP_STALL_RE = /^\[perf\] acp agent event loop stall: max=(\d+(?:\.\d+)?)ms/m;
 function readAvailableCommandAltNames(raw) {
   if (typeof raw !== "object" || raw === null)
@@ -266,6 +268,7 @@ var AcpBridge = class extends EventEmitter {
   channelLoopToolHandlers = [];
   channelLoopMcpRegistered = false;
   channelLoopMcpRegistration = null;
+  pendingPermissions = /* @__PURE__ */ new Map();
   constructor(options) {
     super();
     this.options = options;
@@ -292,7 +295,7 @@ var AcpBridge = class extends EventEmitter {
     this.child.stderr?.on("data", (data) => {
       const msg = data.toString().trim();
       if (msg) {
-        process.stderr.write(`[AcpBridge] ${msg}
+        process.stderr.write(`[AcpBridge] ${sanitizeLogText(msg, 4096)}
 `);
         this.maybeKillOnEventLoopStall(msg);
       }
@@ -300,6 +303,7 @@ var AcpBridge = class extends EventEmitter {
     this.child.on("exit", (code, signal) => {
       process.stderr.write(`[AcpBridge] Process exited (code=${code}, signal=${signal})
 `);
+      this.resolvePendingPermissions();
       this.connection = null;
       this.child = null;
       this.emit("disconnected", code, signal);
@@ -316,11 +320,7 @@ var AcpBridge = class extends EventEmitter {
         this.handleSessionUpdate(params);
         return Promise.resolve();
       }, "sessionUpdate"),
-      requestPermission: /* @__PURE__ */ __name(async (params) => {
-        const options = Array.isArray(params.options) ? params.options : [];
-        const optionId = options.find((o) => o.optionId === "proceed_once")?.optionId || options[0]?.optionId || "proceed_once";
-        return { outcome: { outcome: "selected", optionId } };
-      }, "requestPermission"),
+      requestPermission: /* @__PURE__ */ __name(async (params) => this.requestPermission(params), "requestPermission"),
       extMethod: /* @__PURE__ */ __name(async (method, params) => this.handleExtMethod(method, params), "extMethod"),
       extNotification: /* @__PURE__ */ __name(async () => {
       }, "extNotification")
@@ -387,9 +387,28 @@ var AcpBridge = class extends EventEmitter {
   }
   async cancelSession(sessionId) {
     const conn = this.ensureConnection();
-    await conn.cancel({ sessionId });
+    try {
+      await conn.cancel({ sessionId });
+    } finally {
+      this.resolvePendingPermissions(sessionId);
+    }
+  }
+  async respondToPermission(requestId, response) {
+    const pending = this.pendingPermissions.get(requestId);
+    if (!pending) {
+      return false;
+    }
+    clearTimeout(pending.timeout);
+    this.pendingPermissions.delete(requestId);
+    pending.resolve(response);
+    this.emit("permissionResolved", {
+      requestId,
+      outcome: response.outcome
+    });
+    return true;
   }
   stop() {
+    this.resolvePendingPermissions();
     if (this.child) {
       this.child.kill();
       this.child = null;
@@ -445,6 +464,53 @@ var AcpBridge = class extends EventEmitter {
     }
     return this.connection;
   }
+  requestPermission(request) {
+    const requestId = `acp-permission-${randomUUID()}`;
+    const sessionId = typeof request.sessionId === "string" && request.sessionId.length > 0 ? request.sessionId : request.toolCall.toolCallId;
+    return new Promise((resolve2) => {
+      const timeout = setTimeout(() => {
+        const pending = this.pendingPermissions.get(requestId);
+        if (!pending) {
+          return;
+        }
+        process.stderr.write(`[AcpBridge] permission request ${sanitizeLogText(requestId, 128)} timed out after ${ACP_PERMISSION_RESPONSE_TIMEOUT_MS}ms (session=${sanitizeLogText(pending.sessionId, 128)})
+`);
+        this.pendingPermissions.delete(requestId);
+        const response = {
+          outcome: { outcome: "cancelled" }
+        };
+        pending.resolve(response);
+        this.emit("permissionResolved", {
+          requestId,
+          outcome: response.outcome
+        });
+      }, ACP_PERMISSION_RESPONSE_TIMEOUT_MS);
+      timeout.unref?.();
+      this.pendingPermissions.set(requestId, { sessionId, resolve: resolve2, timeout });
+      this.emit("permissionRequest", {
+        requestId,
+        sessionId,
+        request
+      });
+    });
+  }
+  resolvePendingPermissions(sessionId) {
+    const response = {
+      outcome: { outcome: "cancelled" }
+    };
+    for (const [requestId, pending] of this.pendingPermissions) {
+      if (sessionId !== void 0 && pending.sessionId !== sessionId) {
+        continue;
+      }
+      clearTimeout(pending.timeout);
+      this.pendingPermissions.delete(requestId);
+      pending.resolve(response);
+      this.emit("permissionResolved", {
+        requestId,
+        outcome: response.outcome
+      });
+    }
+  }
   maybeKillOnEventLoopStall(stderr) {
     const match = ACP_EVENT_LOOP_STALL_RE.exec(stderr);
     if (!match)
@@ -1237,6 +1303,36 @@ var GroupGate = class {
   }
 };
 
+// packages/channels/base/dist/DmGate.js
+init_esbuild_shims();
+var DmGate = class {
+  static {
+    __name(this, "DmGate");
+  }
+  policy;
+  constructor(policy = "open") {
+    this.policy = policy;
+  }
+  /**
+   * DM check: policy gating for private/non-group messages.
+   * Evaluation order:
+   *   1. Group messages bypass this gate (handled by GroupGate)
+   *   2. dmPolicy (disabled → drop)
+   *
+   * Symmetric with GroupGate — GroupGate owns group messages,
+   * DmGate owns DM messages.
+   */
+  check(envelope) {
+    if (envelope.isGroup) {
+      return { allowed: true };
+    }
+    if (this.policy === "disabled") {
+      return { allowed: false, reason: "disabled" };
+    }
+    return { allowed: true };
+  }
+};
+
 // packages/channels/base/dist/group-history-store.js
 init_esbuild_shims();
 import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
@@ -2359,6 +2455,7 @@ var ChannelBase = class {
   config;
   bridge;
   groupGate;
+  dmGate;
   gate;
   router;
   name;
@@ -2394,6 +2491,17 @@ var ChannelBase = class {
   bridgeSessionDiedListener = /* @__PURE__ */ __name((event) => {
     this.onSessionDied(event.sessionId);
   }, "bridgeSessionDiedListener");
+  bridgePermissionRequestListener = /* @__PURE__ */ __name((event) => {
+    void this.dispatchPermissionRequest(event).catch((err) => {
+      process.stderr.write(`[${this.name}] permission relay failed for request ${sanitizeLogText(event.requestId, 128)}: ${this.lifecycleError(err)}
+`);
+    });
+  }, "bridgePermissionRequestListener");
+  bridgePermissionResolvedListener = /* @__PURE__ */ __name((event) => {
+    this.dispatchPermissionResolved(event);
+  }, "bridgePermissionResolvedListener");
+  pendingPermissions = /* @__PURE__ */ new Map();
+  pendingPermissionsByChat = /* @__PURE__ */ new Map();
   channelLoopToolHandler = {
     canHandle: /* @__PURE__ */ __name((sessionId) => this.router.getTarget(sessionId)?.channelName === this.name, "canHandle"),
     create: /* @__PURE__ */ __name((sessionId, input) => this.createLoopFromTool(sessionId, input), "create"),
@@ -2423,6 +2531,78 @@ var ChannelBase = class {
     }
     this.onToolCall(chatId, event);
   }
+  async dispatchPermissionRequest(event) {
+    const target = this.permissionTargetForEvent(event);
+    if (!target) {
+      try {
+        await this.bridge.respondToPermission?.(event.requestId, {
+          outcome: { outcome: "cancelled" }
+        });
+      } catch (respondErr) {
+        process.stderr.write(`[${this.name}] permission cancellation failed for request ${sanitizeLogText(event.requestId, 128)}: ${this.lifecycleError(respondErr)}
+`);
+      }
+      return;
+    }
+    this.removePendingPermission(event.requestId);
+    const pending = {
+      requestId: event.requestId,
+      sessionId: event.sessionId,
+      target,
+      request: event.request
+    };
+    this.pendingPermissions.set(event.requestId, pending);
+    const chatKey = this.permissionChatKey(target);
+    const requestIds = this.pendingPermissionsByChat.get(chatKey) ?? [];
+    requestIds.push(event.requestId);
+    this.pendingPermissionsByChat.set(chatKey, requestIds);
+    try {
+      const text = this.formatPermissionRequest(pending);
+      if (target.threadId !== void 0 && this.supportsProactiveSend() && this.supportsProactiveTarget(target)) {
+        await this.pushProactive(target, text);
+      } else {
+        await this.sendMessage(target.chatId, text);
+      }
+    } catch (err) {
+      this.removePendingPermission(event.requestId);
+      try {
+        await this.bridge.respondToPermission?.(event.requestId, {
+          outcome: { outcome: "cancelled" }
+        });
+      } catch (respondErr) {
+        process.stderr.write(`[${this.name}] permission cancellation failed for request ${sanitizeLogText(event.requestId, 128)}: ${this.lifecycleError(respondErr)}
+`);
+      }
+      throw err;
+    }
+  }
+  permissionTargetForEvent(event) {
+    const routeTarget = this.router.getTarget(event.sessionId);
+    if (!routeTarget || routeTarget.channelName !== this.name) {
+      return void 0;
+    }
+    const active = this.activePrompts.get(event.sessionId);
+    if (!active) {
+      return routeTarget;
+    }
+    const target = {
+      channelName: routeTarget.channelName,
+      senderId: active.senderId ?? routeTarget.senderId,
+      chatId: active.chatId
+    };
+    if (active.threadId !== void 0) {
+      target.threadId = active.threadId;
+    }
+    if (active.isGroup !== void 0) {
+      target.isGroup = active.isGroup;
+    } else if (routeTarget.isGroup !== void 0) {
+      target.isGroup = routeTarget.isGroup;
+    }
+    return target;
+  }
+  dispatchPermissionResolved(event) {
+    this.removePendingPermission(event.requestId);
+  }
   constructor(name, config, bridge, options) {
     this.name = name;
     this.config = config;
@@ -2435,6 +2615,7 @@ var ChannelBase = class {
     this.groupHistory = new GroupHistoryStore(options?.groupHistoryPath ?? join4(getGlobalQwenDir(), "channels", `${encodeURIComponent(name)}-group-history.jsonl`));
     this.loopController = options?.loopController;
     this.groupGate = new GroupGate(config.groupPolicy, config.groups);
+    this.dmGate = new DmGate(config.dmPolicy);
     const pairingStore = config.senderPolicy === "pairing" ? new PairingStore(name) : void 0;
     this.gate = new SenderGate(config.senderPolicy, config.allowedUsers, pairingStore);
     this.router = options?.router || new SessionRouter(bridge, config.cwd, config.sessionScope);
@@ -2554,6 +2735,7 @@ var ChannelBase = class {
     if (this.registerBridgeEvents) {
       this.detachBridgeEvents(this.bridge);
     }
+    this.clearPendingPermissions();
     this.router.setBridge(bridge);
     this.bridge = bridge;
     if (this.loopController) {
@@ -2654,6 +2836,8 @@ ${promptText}`;
         done,
         resolve: doneResolve,
         chatId: job.target.chatId,
+        threadId: job.target.threadId,
+        isGroup: job.target.isGroup,
         messageId: job.id,
         senderId: job.target.senderId,
         senderName: job.createdBy,
@@ -2930,14 +3114,19 @@ ${promptText}`;
   onSessionDied(sessionId) {
     this.router.removeSessionId(sessionId);
     this.instructedSessions.delete(sessionId);
+    this.removePendingPermissionsForSession(sessionId);
   }
   attachBridgeEvents(bridge) {
     bridge.on("toolCall", this.bridgeToolCallListener);
     bridge.on("sessionDied", this.bridgeSessionDiedListener);
+    bridge.on("permissionRequest", this.bridgePermissionRequestListener);
+    bridge.on("permissionResolved", this.bridgePermissionResolvedListener);
   }
   detachBridgeEvents(bridge) {
     bridge.off("toolCall", this.bridgeToolCallListener);
     bridge.off("sessionDied", this.bridgeSessionDiedListener);
+    bridge.off("permissionRequest", this.bridgePermissionRequestListener);
+    bridge.off("permissionResolved", this.bridgePermissionResolvedListener);
   }
   /**
    * Called when a prompt actually begins processing (inside the session queue).
@@ -3002,6 +3191,182 @@ ${promptText}`;
       return true;
     });
   }
+  permissionChatKey(target) {
+    return `${target.chatId}\0${target.threadId ?? ""}`;
+  }
+  pendingPermissionIdsForChatKey(chatKey) {
+    const requestIds = this.pendingPermissionsByChat.get(chatKey);
+    if (!requestIds) {
+      return [];
+    }
+    const live = requestIds.filter((id) => this.pendingPermissions.has(id));
+    if (live.length === 0) {
+      this.pendingPermissionsByChat.delete(chatKey);
+    } else if (live.length !== requestIds.length) {
+      this.pendingPermissionsByChat.set(chatKey, live);
+    }
+    return live;
+  }
+  removePendingPermission(requestId) {
+    const pending = this.pendingPermissions.get(requestId);
+    if (!pending) {
+      return;
+    }
+    this.pendingPermissions.delete(requestId);
+    const chatKey = this.permissionChatKey(pending.target);
+    const requestIds = this.pendingPermissionsByChat.get(chatKey);
+    if (!requestIds) {
+      return;
+    }
+    const remaining = requestIds.filter((id) => id !== requestId);
+    if (remaining.length === 0) {
+      this.pendingPermissionsByChat.delete(chatKey);
+    } else {
+      this.pendingPermissionsByChat.set(chatKey, remaining);
+    }
+  }
+  removePendingPermissionsForSession(sessionId) {
+    const requestIds = Array.from(this.pendingPermissions).filter(([, pending]) => pending.sessionId === sessionId).map(([requestId]) => requestId);
+    for (const requestId of requestIds) {
+      this.removePendingPermission(requestId);
+    }
+  }
+  clearPendingPermissions() {
+    this.pendingPermissions.clear();
+    this.pendingPermissionsByChat.clear();
+  }
+  pendingPermissionForEnvelope(envelope, args) {
+    const trimmed = args.trim();
+    if (trimmed) {
+      const explicit = this.pendingPermissions.get(trimmed);
+      if (explicit && this.canEnvelopeAnswerPendingPermission(envelope, explicit)) {
+        return { kind: "found", pending: explicit };
+      }
+      return { kind: "none", explicit: true };
+    }
+    const requestIds = this.pendingPermissionIdsForChatKey(this.permissionChatKey(envelope));
+    if (requestIds.length === 0) {
+      return { kind: "none", explicit: false };
+    }
+    const matching = requestIds.map((id) => this.pendingPermissions.get(id)).filter((pending) => pending !== void 0 && this.canEnvelopeAnswerPendingPermission(envelope, pending));
+    if (matching.length === 0) {
+      return { kind: "none", explicit: false };
+    }
+    if (matching.length > 1) {
+      return {
+        kind: "ambiguous",
+        requestIds: matching.map((pending) => pending.requestId)
+      };
+    }
+    return { kind: "found", pending: matching[0] };
+  }
+  canEnvelopeAnswerPendingPermission(envelope, pending) {
+    return pending.target.chatId === envelope.chatId && pending.target.threadId === envelope.threadId && (this.isSharedSessionTarget(pending.target) || pending.target.senderId === envelope.senderId);
+  }
+  formatPermissionRequest(pending) {
+    const { toolCall } = pending.request;
+    const title = sanitizeQuotedText(toolCall.title || "Tool use", 160);
+    const alwaysOption = this.approvalAlwaysOption(pending);
+    const replies = [
+      "/approve        allow once",
+      ...alwaysOption ? [`/approve-always ${alwaysOption.label}`] : [],
+      "/deny           deny"
+    ];
+    const lines = [
+      "Permission required to run a tool",
+      "",
+      "Command:",
+      title,
+      "",
+      "Reply with:",
+      ...replies
+    ];
+    return lines.join("\n");
+  }
+  approvalOptionId(pending) {
+    const options = pending.request.options;
+    return options.find((option) => option.kind === "allow_once")?.optionId ?? options.find((option) => option.optionId === "proceed_once" && option.kind === void 0)?.optionId;
+  }
+  approvalAlwaysOption(pending) {
+    const options = pending.request.options.filter((option2) => option2.kind === "allow_always");
+    const option = this.findScopedAlwaysOption(options, "project") ?? this.findScopedAlwaysOption(options, "user") ?? options[0];
+    if (!option) {
+      return void 0;
+    }
+    return {
+      optionId: option.optionId,
+      label: this.approvalAlwaysLabel(option)
+    };
+  }
+  findScopedAlwaysOption(options, scope) {
+    return options.find((option) => option.optionId === `proceed_always_${scope}`);
+  }
+  approvalAlwaysLabel(option) {
+    if (option.optionId === "proceed_always_project") {
+      return "always allow for this project";
+    }
+    if (option.optionId === "proceed_always_user") {
+      return "always allow for this user";
+    }
+    return "always allow";
+  }
+  denialResponse(pending) {
+    const option = pending.request.options.find((candidate) => candidate.kind === "reject_once") ?? pending.request.options.find((candidate) => candidate.optionId === "cancel" && candidate.kind === void 0);
+    if (option) {
+      return { outcome: { outcome: "selected", optionId: option.optionId } };
+    }
+    return { outcome: { outcome: "cancelled" } };
+  }
+  async handlePermissionResponseCommand(envelope, args, decision) {
+    if (!this.isAuthorizedForSharedSession(envelope)) {
+      await this.sendMessage(envelope.chatId, "Only authorized members can answer permission requests in this shared session.");
+      return true;
+    }
+    const lookup = this.pendingPermissionForEnvelope(envelope, args);
+    if (lookup.kind === "ambiguous") {
+      const requestList = lookup.requestIds.slice(0, 6).map((id) => {
+        const pending2 = this.pendingPermissions.get(id);
+        const title = pending2 ? `: ${sanitizeQuotedText(pending2.request.toolCall.title || "Tool use", 160)}` : "";
+        return `- ${sanitizeQuotedText(id, 128)}${title}`;
+      }).join("\n");
+      await this.sendMessage(envelope.chatId, `Multiple permission requests are pending for this chat. Reply with /${decision} <request-id>.
+${requestList}`);
+      return true;
+    }
+    if (lookup.kind === "none") {
+      await this.sendMessage(envelope.chatId, lookup.explicit ? "No pending permission request with that id for this chat." : "No pending permission request for this chat.");
+      return true;
+    }
+    if (!this.bridge.respondToPermission) {
+      await this.sendMessage(envelope.chatId, "Permission relay is not available for this session.");
+      return true;
+    }
+    const { pending } = lookup;
+    const response = (() => {
+      if (decision === "deny") {
+        return this.denialResponse(pending);
+      }
+      const optionId = decision === "approve" ? this.approvalOptionId(pending) : this.approvalAlwaysOption(pending)?.optionId;
+      return optionId ? { outcome: { outcome: "selected", optionId } } : void 0;
+    })();
+    if (!response) {
+      await this.sendMessage(envelope.chatId, decision === "approve-always" ? "This permission request has no always-allow option." : "This permission request has no approvable option.");
+      return true;
+    }
+    let accepted;
+    try {
+      accepted = await this.bridge.respondToPermission(pending.requestId, response);
+    } catch (err) {
+      this.removePendingPermission(pending.requestId);
+      process.stderr.write(`[${this.name}] permission response failed for request ${sanitizeLogText(pending.requestId, 128)}: ${this.lifecycleError(err)}
+`);
+      await this.sendMessage(envelope.chatId, "Failed to answer the permission request.");
+      return true;
+    }
+    this.removePendingPermission(pending.requestId);
+    await this.sendMessage(envelope.chatId, accepted ? decision === "approve" ? "Permission approved." : decision === "approve-always" ? "Permission approved always." : "Permission denied." : "Permission request is no longer pending.");
+    return true;
+  }
   /** Register shared slash commands. Called from constructor. */
   registerSharedCommands() {
     const doClear = /* @__PURE__ */ __name(async (envelope) => {
@@ -3015,6 +3380,7 @@ ${promptText}`;
 `);
           }
           this.sessionGenerations.set(id, (this.sessionGenerations.get(id) ?? 0) + 1);
+          this.removePendingPermissionsForSession(id);
           const active = this.activePrompts.get(id);
           this.dropCollectBuffer(id);
           if (active) {
@@ -3068,6 +3434,9 @@ ${promptText}`;
     this.registerCommand("clear", clearHandler);
     this.registerCommand("reset", clearHandler);
     this.registerCommand("new", clearHandler);
+    this.registerCommand("approve", (envelope, args) => this.handlePermissionResponseCommand(envelope, args, "approve"));
+    this.registerCommand("approve-always", (envelope, args) => this.handlePermissionResponseCommand(envelope, args, "approve-always"));
+    this.registerCommand("deny", (envelope, args) => this.handlePermissionResponseCommand(envelope, args, "deny"));
     this.registerCommand("remember-channel", async (envelope, args) => {
       const text = args.trim();
       if (text === "") {
@@ -3126,13 +3495,19 @@ ${promptText}`;
         "/help \u2014 Show this help",
         this.isSharedSession(envelope) ? "/clear confirm \u2014 Clear the shared session (aliases: /reset, /new)" : "/clear \u2014 Clear your session (aliases: /reset, /new)",
         "/who \u2014 Show current session & workspace",
-        "/status \u2014 Show session info"
+        "/status \u2014 Show session info",
+        "/approve [request-id] \u2014 Approve a pending permission request",
+        "/approve-always [request-id] \u2014 Always approve a pending permission request",
+        "/deny [request-id] \u2014 Deny a pending permission request"
       ];
       const sharedCmds = /* @__PURE__ */ new Set([
         "help",
         "clear",
         "reset",
         "new",
+        "approve",
+        "approve-always",
+        "deny",
         "remember-channel",
         "channel-memory",
         "forget-channel",
@@ -3482,7 +3857,7 @@ ${promptText}`;
       isMentioned: true,
       isReplyToBot: true
     };
-    return this.groupGate.check(envelope).allowed && this.gate.isAllowed(normalizedTarget.senderId) && this.isAuthorizedForSharedSession(envelope);
+    return this.groupGate.check(envelope).allowed && this.dmGate.check(envelope).allowed && this.gate.isAllowed(normalizedTarget.senderId) && this.isAuthorizedForSharedSession(envelope);
   }
   /** Check if a message text matches a registered local command. */
   isLocalCommand(text) {
@@ -3915,6 +4290,10 @@ ${promptText}`;
       }
       return false;
     }
+    const dmResult = this.dmGate.check(envelope);
+    if (!dmResult.allowed) {
+      return false;
+    }
     const result = this.gate.check(envelope.senderId, envelope.senderName);
     if (!result.allowed) {
       if (result.pairingCode !== void 0) {
@@ -4153,6 +4532,8 @@ ${promptToSend}`;
         done,
         resolve: doneResolve,
         chatId: envelope.chatId,
+        threadId: envelope.threadId,
+        isGroup: envelope.isGroup,
         messageId: envelope.messageId,
         senderId: envelope.senderId,
         senderName: envelope.senderName

package/chunks/{chunk-AXTPFMRS.js → chunk-J7RCB6N5.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   runExitCleanup
-} from "./chunk-QCSLZO6J.js";
+} from "./chunk-JCH35JB3.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-QCSLZO6J.js → chunk-JCH35JB3.js}

@@ -60,7 +60,7 @@ async function runExitCleanup(options = {}) {
 }
 __name(runExitCleanup, "runExitCleanup");
 async function cleanupCheckpoints() {
-  const { Storage } = await import("./src-NLEX4CUC.js");
+  const { Storage } = await import("./src-BBQSM46M.js");
   const storage = new Storage(process.cwd());
   const tempDir = storage.getProjectTempDir();
   const checkpointsDir = join(tempDir, "checkpoints");

package/chunks/{chunk-JYOWO2F7.js → chunk-JPALE3PA.js}

@@ -8,16 +8,16 @@ import {
   initializeI18n,
   resolveLanguageSetting,
   t
-} from "./chunk-TBLJNMI7.js";
+} from "./chunk-O33TBKDC.js";
 import {
   IdeClient
-} from "./chunk-E7HM76PR.js";
+} from "./chunk-3GNOQZDC.js";
 import {
   AuthEvent,
   IdeConnectionEvent,
   logAuth,
   logIdeConnection
-} from "./chunk-7I4MGFBN.js";
+} from "./chunk-BUZ6HGL4.js";
 import {
   getErrorMessage
 } from "./chunk-22MNNNXE.js";

package/chunks/{chunk-5FL2K3ZB.js → chunk-JRQ7EVGE.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   parseRule
-} from "./chunk-E7HM76PR.js";
+} from "./chunk-3GNOQZDC.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-BHRU4SDF.js → chunk-JZHIQJOE.js}

@@ -5,10 +5,10 @@ import {
 } from "./chunk-KHDZHZMH.js";
 import {
   getCliVersion
-} from "./chunk-XUSONNJ4.js";
+} from "./chunk-UXEW557D.js";
 import {
   IdeClient
-} from "./chunk-E7HM76PR.js";
+} from "./chunk-3GNOQZDC.js";
 import {
   createDebugLogger
 } from "./chunk-22MNNNXE.js";
@@ -27,7 +27,7 @@ import { execFile } from "node:child_process";
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO = "1b72d7063";
+var GIT_COMMIT_INFO = "34b1a8324";
 
 // packages/cli/src/utils/systemInfo.ts
 var debugLogger = createDebugLogger("STATUS");