@qwen-code/qwen-code 0.21.3 → 0.21.4

package/chunks/{dist-4KAX7CCL.js → dist-IKGVITP3.js}

@@ -3841,6 +3841,27 @@ function normalizeReasonFilter(config, channelName) {
   return reasons.length > 0 ? new Set(reasons) : null;
 }
 __name(normalizeReasonFilter, "normalizeReasonFilter");
+var MAX_INBOUND_TASK_ATTEMPTS = 3;
+function isOptionalStringArray(value) {
+  return value === void 0 || Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+__name(isOptionalStringArray, "isOptionalStringArray");
+function isInboundEnvelope(value) {
+  if (value === void 0)
+    return true;
+  if (value === null || typeof value !== "object")
+    return false;
+  const envelope = value;
+  return typeof envelope.channelName === "string" && typeof envelope.senderId === "string" && typeof envelope.senderName === "string" && typeof envelope.chatId === "string" && typeof envelope.text === "string" && typeof envelope.isGroup === "boolean" && typeof envelope.isMentioned === "boolean" && typeof envelope.isReplyToBot === "boolean" && (envelope.chatName === void 0 || typeof envelope.chatName === "string") && (envelope.threadId === void 0 || typeof envelope.threadId === "string") && (envelope.messageId === void 0 || typeof envelope.messageId === "string") && (envelope.referencedText === void 0 || typeof envelope.referencedText === "string") && (envelope.imageBase64 === void 0 || typeof envelope.imageBase64 === "string") && (envelope.imageMimeType === void 0 || typeof envelope.imageMimeType === "string") && (envelope.attachments === void 0 || Array.isArray(envelope.attachments)) && (envelope.metadata === void 0 || typeof envelope.metadata === "string") && (envelope.alreadyPrefixed === void 0 || envelope.alreadyPrefixed === true);
+}
+__name(isInboundEnvelope, "isInboundEnvelope");
+function isInboundTaskRecord(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const record = value;
+  return record.version === 1 && typeof record.id === "string" && typeof record.createdAt === "string" && typeof record.updatedAt === "string" && ["accepted", "running", "reply_pending", "failed", "cancelled"].includes(record.state) && Number.isSafeInteger(record.issueNumber) && record.source !== null && typeof record.source === "object" && typeof record.source.chatId === "string" && (record.source.threadId === void 0 || typeof record.source.threadId === "string") && (record.source.messageId === void 0 || typeof record.source.messageId === "string") && isInboundEnvelope(record.envelope) && record.dedupe !== null && typeof record.dedupe === "object" && isOptionalStringArray(record.dedupe.dispatchedBodies) && isOptionalStringArray(record.dedupe.dispatchedComments) && isOptionalStringArray(record.dedupe.dispatchedEvents) && (record.attempts === void 0 || Number.isSafeInteger(record.attempts) && record.attempts >= 0) && (record.errorCommentPosted === void 0 || typeof record.errorCommentPosted === "boolean") && (record.error === void 0 || typeof record.error === "string");
+}
+__name(isInboundTaskRecord, "isInboundTaskRecord");
 var FinalPublicationError = class extends Error {
   static {
     __name(this, "FinalPublicationError");
@@ -3900,6 +3921,12 @@ var GithubChannel = class extends PollingChannelBase {
   pendingFinalDeliveryRequestsActive = 0;
   pendingFinalDeliveryRetryStopRequested = false;
   reasonFilter = null;
+  inboundRecoveryPending = true;
+  recoverableInboundTasks = 0;
+  activeInboundTaskIdsByMessage = /* @__PURE__ */ new Map();
+  cancelledInboundTaskIds = /* @__PURE__ */ new Set();
+  pendingCursorUpdatedAt;
+  inboundPersistenceBlocked = false;
   constructor(name, config, bridge, options) {
     config.blockStreaming = "off";
     config.instructions = [
@@ -3959,6 +3986,13 @@ var GithubChannel = class extends PollingChannelBase {
     }
     this.gate.replaceAllowedUsers(allowed);
     this.migrateLegacyPublicationState();
+    this.inboundPersistenceBlocked = false;
+    this.inboundRecoveryPending = true;
+    try {
+      this.recoverableInboundTasks = this.readInboundTasks().filter((record) => this.isRecoverableInboundTask(record)).length;
+    } catch {
+      this.recoverableInboundTasks = 0;
+    }
     this.pendingFinalDeliveryRetryStopRequested = false;
     this.startPollLoop();
     if (this.pendingFinalDeliveryRetry) {
@@ -4022,6 +4056,12 @@ var GithubChannel = class extends PollingChannelBase {
     if (!threadMatch) {
       throw new Error(`[Channel:${this.name}] invalid threadId format: ${threadId}`);
     }
+    this.recordPublicationAudit({
+      ...auditBase,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      type: "github_publication",
+      outcome: "posting"
+    });
     try {
       const comment = await this.createIssueComment(chatId, threadId, fullText, 3, isDefiniteNoWriteGithubError);
       this.recordPublicationAudit({
@@ -4042,12 +4082,16 @@ var GithubChannel = class extends PollingChannelBase {
         failureError: sanitizeLogText(err instanceof Error ? err.message : String(err), 200)
       });
       if (threadId && isDefiniteNoWriteGithubError(err)) {
-        this.enqueuePendingFinalDelivery({
-          ...auditBase,
-          chatId,
-          threadId,
-          fullText
-        });
+        try {
+          this.enqueuePendingFinalDelivery({
+            ...auditBase,
+            chatId,
+            threadId,
+            fullText
+          });
+        } catch (persistError) {
+          throw new Error(`[Channel:${this.name}] failed to persist pending GitHub delivery: ${sanitizeLogText(persistError instanceof Error ? persistError.message : String(persistError), 200)}`, { cause: persistError });
+        }
       }
       throw new FinalPublicationError(err instanceof Error ? err.message : String(err), { cause: err });
     }
@@ -4085,13 +4129,8 @@ var GithubChannel = class extends PollingChannelBase {
       actor: input.actor,
       triggerKind: input.triggerKind
     };
-    try {
-      const pending = this.readPendingFinalDeliveries().filter((item) => item.id !== record.id);
-      this.writePendingFinalDeliveries([...pending, record]);
-    } catch (err) {
-      process2.stderr.write(`[Channel:${this.name}] failed to persist pending GitHub delivery: ${sanitizeLogText(err instanceof Error ? err.message : String(err), 200)}
-`);
-    }
+    const pending = this.readPendingFinalDeliveries(true).filter((item) => item.id !== record.id);
+    this.writePendingFinalDeliveries([...pending, record]);
   }
   async retryPendingFinalDeliveries(signal) {
     const pending = this.readPendingFinalDeliveries();
@@ -4110,7 +4149,9 @@ var GithubChannel = class extends PollingChannelBase {
       if (this.hasPostedPublicationAudit(record.id)) {
         process2.stderr.write(`[Channel:${this.name}] dropping pending GitHub delivery already recorded as posted: ${sanitizeLogText(record.id, 80)}
 `);
-        this.updatePendingFinalDeliveries((current) => current.filter((item) => item.id !== record.id));
+        if (this.updatePendingFinalDeliveries((current) => current.filter((item) => item.id !== record.id))) {
+          this.removeReplyPendingInboundTask(record);
+        }
         continue;
       }
       try {
@@ -4127,6 +4168,7 @@ var GithubChannel = class extends PollingChannelBase {
         if (!this.updatePendingFinalDeliveries((current) => current.filter((item) => item.id !== record.id))) {
           continue;
         }
+        this.removeReplyPendingInboundTask(record);
       } catch (err) {
         if (signal?.aborted)
           return;
@@ -4144,6 +4186,7 @@ var GithubChannel = class extends PollingChannelBase {
         if (!this.updatePendingFinalDeliveries((current) => current.filter((item) => item.id !== record.id))) {
           continue;
         }
+        this.removeReplyPendingInboundTask(record);
       }
     }
   }
@@ -4174,6 +4217,18 @@ var GithubChannel = class extends PollingChannelBase {
       return false;
     }
   }
+  removeReplyPendingInboundTask(delivery) {
+    try {
+      const tasks = this.readInboundTasks();
+      const matching = tasks.filter((task) => task.state === "reply_pending" && task.source.chatId === delivery.chatId && task.source.threadId === delivery.threadId && task.source.messageId === delivery.sourceMessageId);
+      for (const task of matching) {
+        this.removeInboundTask(task.id);
+      }
+    } catch (cleanupErr) {
+      process2.stderr.write(`[Channel:${this.name}] failed to clean up inbound task: ${sanitizeLogText(cleanupErr instanceof Error ? cleanupErr.message : String(cleanupErr), 200)}
+`);
+    }
+  }
   pendingFinalDeliveriesPath() {
     return this.channelFilePath("github-pending-deliveries.json");
   }
@@ -4310,15 +4365,25 @@ var GithubChannel = class extends PollingChannelBase {
     });
   }
   async pollOnce() {
+    this.inboundPersistenceBlocked = false;
+    if (this.inboundRecoveryPending) {
+      try {
+        await this.recoverInboundTasks();
+      } catch (err) {
+        process2.stderr.write(`[Channel:${this.name}] inbound task recovery failed, will retry next poll: ${err}
+`);
+      } finally {
+        this.inboundRecoveryPending = false;
+      }
+    }
     this.cursor.metaFloor ??= this.cursor.lastProcessedAt;
     const since = new Date(new Date(this.cursor.lastProcessedAt).getTime() - 1e3).toISOString();
     const notifications = await this.githubApi(() => this.octokit.paginate(this.octokit.rest.activity.listNotificationsForAuthenticatedUser, { since, per_page: 100 }), "listNotifications");
     notifications.sort((a, b) => a.updated_at.localeCompare(b.updated_at));
     const maxUpdatedAt = notifications.length > 0 ? notifications[notifications.length - 1].updated_at : this.cursor.lastProcessedAt;
     const windowSince = this.cursor.lastProcessedAt;
-    await this.markNotificationsAsRead(maxUpdatedAt);
     if (maxUpdatedAt > this.cursor.lastProcessedAt) {
-      this.cursor.lastProcessedAt = maxUpdatedAt;
+      this.pendingCursorUpdatedAt = !this.pendingCursorUpdatedAt || maxUpdatedAt > this.pendingCursorUpdatedAt ? maxUpdatedAt : this.pendingCursorUpdatedAt;
     }
     for (const notification of notifications) {
       if (!notification.subject.url)
@@ -4382,6 +4447,17 @@ var GithubChannel = class extends PollingChannelBase {
         continue;
       }
     }
+    if (this.hasRecoverableInboundTasks()) {
+      this.inboundRecoveryPending = true;
+    }
+    if (!this.inboundPersistenceBlocked && !this.hasRecoverableInboundTasks() && this.pendingCursorUpdatedAt) {
+      const committedAt = this.pendingCursorUpdatedAt;
+      await this.markNotificationsAsRead(committedAt);
+      if (committedAt > this.cursor.lastProcessedAt) {
+        this.cursor.lastProcessedAt = committedAt;
+      }
+      this.pendingCursorUpdatedAt = void 0;
+    }
   }
   async processCommentLane(ctx, onlyMentioned, directed = false) {
     const comments = await this.fetchNewComments(ctx);
@@ -4409,7 +4485,9 @@ var GithubChannel = class extends PollingChannelBase {
         isReplyToBot: false,
         metadata: this.buildRouteMetadata(ctx)
       };
-      if (!await this.dispatchEnvelope(envelope, ctx.issueNumber)) {
+      if (!await this.dispatchEnvelope(envelope, ctx.issueNumber, {
+        dispatchedComments: [key]
+      })) {
         dispatched = true;
         continue;
       }
@@ -4449,7 +4527,9 @@ Trigger: ${reason}.
 ${buildTriggerGuidance(reason)}
 ${details}`
     };
-    await this.dispatchEnvelope(envelope, ctx.issueNumber);
+    await this.dispatchEnvelope(envelope, ctx.issueNumber, {
+      dispatchedEvents: [trigger.key]
+    });
     this.recordDispatched("dispatchedEvents", trigger.key);
   }
   async processAggregateLane(ctx) {
@@ -4484,7 +4564,9 @@ ${summary}`,
       isReplyToBot: false,
       metadata: this.buildRouteMetadata(ctx)
     };
-    await this.dispatchEnvelope(envelope, ctx.issueNumber);
+    await this.dispatchEnvelope(envelope, ctx.issueNumber, {
+      dispatchedComments: allComments.map((comment) => comment.node_id || String(comment.id))
+    });
   }
   async findDirectTrigger(ctx, reason) {
     const [owner, repo] = ctx.chatId.split("/");
@@ -4566,7 +4648,9 @@ ${summary}`,
         isReplyToBot: false,
         metadata: this.buildRouteMetadata(ctx)
       };
-      await this.dispatchEnvelope(envelope, issueNumber);
+      await this.dispatchEnvelope(envelope, issueNumber, {
+        dispatchedBodies: [bodyKey]
+      });
       this.recordDispatchedBody(bodyKey);
     } catch (err) {
       process2.stderr.write(`[Channel:${this.name}] failed to fetch issue for first contact: ${err}
@@ -4585,17 +4669,229 @@ ${summary}`,
       list.push(key);
     this.cursor[field] = list.slice(-MAX_DISPATCHED);
   }
-  async dispatchEnvelope(envelope, issueNumber) {
+  async dispatchEnvelope(envelope, issueNumber, dedupe = {}) {
+    const task = this.claimInboundTask(envelope, issueNumber, dedupe);
+    return this.runInboundTask(task);
+  }
+  claimInboundTask(envelope, issueNumber, dedupe) {
+    const existing = this.readInboundTasks().find((record) => record.source.chatId === envelope.chatId && record.source.threadId === envelope.threadId && record.source.messageId === envelope.messageId);
+    if (existing) {
+      this.applyTaskDedupe(existing);
+      return existing;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const task = {
+      version: 1,
+      id: randomUUID(),
+      createdAt: now,
+      updatedAt: now,
+      state: "accepted",
+      issueNumber,
+      source: {
+        chatId: envelope.chatId,
+        threadId: envelope.threadId,
+        messageId: envelope.messageId
+      },
+      envelope,
+      dedupe,
+      attempts: 0
+    };
+    this.updateInboundTasks((records) => [...records, task]);
+    this.applyTaskDedupe(task);
+    return task;
+  }
+  async runInboundTask(task) {
+    if (!this.isRecoverableInboundTask(task))
+      return true;
+    const envelope = task.envelope;
+    if (!envelope)
+      return true;
+    const attempts = (task.attempts ?? 0) + 1;
+    this.activeInboundTaskIdsByMessage.set(this.inboundMessageKey(envelope.chatId, envelope.messageId), task.id);
+    this.transitionInboundTask(task.id, "running", { attempts });
+    let cancelled = false;
     try {
       await this.handleInbound(envelope);
-      return true;
+      cancelled = this.cancelledInboundTaskIds.has(task.id);
     } catch (err) {
+      const error = sanitizeLogText(err instanceof Error ? err.message : String(err), 200);
       process2.stderr.write(`[Channel:${this.name}] handleInbound failed for ${envelope.messageId}: ${err}
 `);
-      if (!(err instanceof FinalPublicationError)) {
-        await this.postErrorComment(envelope.chatId, issueNumber);
+      if (err instanceof FinalPublicationError) {
+        if (this.cancelledInboundTaskIds.has(task.id)) {
+        } else if (this.hasPendingFinalDeliveryForTask(task)) {
+          this.transitionInboundTask(task.id, "reply_pending", {
+            envelope: void 0,
+            error
+          });
+        } else {
+          this.removeInboundTask(task.id);
+        }
+      } else if (!this.cancelledInboundTaskIds.has(task.id)) {
+        let posted = task.errorCommentPosted === true;
+        if (!posted) {
+          posted = await this.postErrorComment(envelope.chatId, task.issueNumber);
+        }
+        this.transitionInboundTask(task.id, "failed", {
+          error,
+          attempts,
+          errorCommentPosted: posted
+        });
       }
       return false;
+    } finally {
+      this.activeInboundTaskIdsByMessage.delete(this.inboundMessageKey(envelope.chatId, envelope.messageId));
+      this.cancelledInboundTaskIds.delete(task.id);
+    }
+    if (cancelled)
+      return true;
+    if (this.hasPendingFinalDeliveryForTask(task)) {
+      this.transitionInboundTask(task.id, "reply_pending", {
+        envelope: void 0
+      });
+    } else {
+      this.removeInboundTask(task.id);
+    }
+    return true;
+  }
+  async recoverInboundTasks() {
+    const tasks = this.readInboundTasks().filter((task) => this.isRecoverableInboundTask(task));
+    const pendingDeliveries = tasks.length ? this.readPendingFinalDeliveries(true) : [];
+    const publicationAuditKeys = tasks.length ? this.readPublicationAuditKeys(true) : /* @__PURE__ */ new Set();
+    for (const task of tasks) {
+      if (!task.envelope)
+        continue;
+      this.applyTaskDedupe(task);
+      if (pendingDeliveries.some((record) => record.chatId === task.source.chatId && record.threadId === task.source.threadId && record.sourceMessageId === task.source.messageId)) {
+        this.transitionInboundTask(task.id, "reply_pending", {
+          envelope: void 0
+        });
+        continue;
+      }
+      if (publicationAuditKeys.has(this.inboundTaskSourceKey(task))) {
+        this.removeInboundTask(task.id);
+        continue;
+      }
+      await this.runInboundTask(task);
+    }
+  }
+  isRecoverableInboundTask(task) {
+    return task.state === "accepted" || task.state === "running" || task.state === "failed" && (task.attempts ?? 0) < MAX_INBOUND_TASK_ATTEMPTS;
+  }
+  hasRecoverableInboundTasks() {
+    return this.recoverableInboundTasks > 0;
+  }
+  hasPendingFinalDeliveryForTask(task) {
+    return this.readPendingFinalDeliveries(true).some((record) => record.chatId === task.source.chatId && record.threadId === task.source.threadId && record.sourceMessageId === task.source.messageId);
+  }
+  inboundTaskSourceKey(task) {
+    return `${task.source.chatId}|${task.source.threadId ?? ""}|${task.source.messageId ?? ""}`;
+  }
+  readPublicationAuditKeys(strict = false) {
+    try {
+      const keys = /* @__PURE__ */ new Set();
+      for (const line of readFileSync(this.channelFilePath("github-audit.jsonl"), "utf-8").split("\n")) {
+        if (!line)
+          continue;
+        try {
+          const record = JSON.parse(line);
+          if (record.outcome === "posted" || record.outcome === "suppressed" || record.outcome === "posting") {
+            keys.add(`${record.repository}|${record.threadId ?? ""}|${record.sourceMessageId ?? ""}`);
+          }
+        } catch {
+          continue;
+        }
+      }
+      return keys;
+    } catch (err) {
+      if (err.code === "ENOENT")
+        return /* @__PURE__ */ new Set();
+      if (strict)
+        throw err;
+      return /* @__PURE__ */ new Set();
+    }
+  }
+  applyTaskDedupe(task) {
+    for (const [field, keys] of Object.entries(task.dedupe)) {
+      for (const key of keys ?? []) {
+        this.recordDispatched(field, key);
+      }
+    }
+  }
+  transitionInboundTask(taskId, state, updates = {}) {
+    this.updateInboundTasks((records) => records.map((record) => record.id === taskId ? {
+      ...record,
+      ...updates,
+      state,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    } : record));
+  }
+  removeInboundTask(taskId) {
+    this.updateInboundTasks((records) => records.filter((record) => record.id !== taskId));
+  }
+  updateInboundTasks(update) {
+    try {
+      const records = update(this.readInboundTasks());
+      this.writeInboundTasks(records);
+      this.recoverableInboundTasks = records.filter((record) => this.isRecoverableInboundTask(record)).length;
+    } catch (err) {
+      this.inboundPersistenceBlocked = true;
+      throw err;
+    }
+  }
+  inboundTasksPath() {
+    return this.channelFilePath("github-inbound-tasks.json");
+  }
+  readInboundTasks() {
+    try {
+      const parsed = JSON.parse(readFileSync(this.inboundTasksPath(), "utf-8"));
+      if (!Array.isArray(parsed) || !parsed.every(isInboundTaskRecord)) {
+        throw new Error("invalid GitHub inbound task state");
+      }
+      return parsed;
+    } catch (err) {
+      if (err.code === "ENOENT")
+        return [];
+      this.inboundPersistenceBlocked = true;
+      process2.stderr.write(`[Channel:${this.name}] failed to read GitHub inbound tasks: ${sanitizeLogText(err instanceof Error ? err.message : String(err), 200)}
+`);
+      throw err;
+    }
+  }
+  writeInboundTasks(records) {
+    const path = this.inboundTasksPath();
+    if (records.length === 0) {
+      try {
+        unlinkSync(path);
+      } catch (err) {
+        if (err.code !== "ENOENT")
+          throw err;
+      }
+      return;
+    }
+    const dir = dirname(path);
+    mkdirSync(dir, { recursive: true, mode: 448 });
+    chmodSync(dir, 448);
+    const tmpPath = `${path}.${process2.pid}.${randomUUID()}.tmp`;
+    writeFileSync(tmpPath, `${JSON.stringify(records)}
+`, {
+      encoding: "utf-8",
+      mode: 384
+    });
+    chmodSync(tmpPath, 384);
+    renameSync(tmpPath, path);
+    chmodSync(path, 384);
+  }
+  inboundMessageKey(chatId, messageId) {
+    return `${chatId}|${messageId ?? ""}`;
+  }
+  onTaskLifecycle(event) {
+    const taskId = this.activeInboundTaskIdsByMessage.get(this.inboundMessageKey(event.chatId, event.messageId));
+    if (!taskId)
+      return;
+    if (event.type === "cancelled") {
+      this.cancelledInboundTaskIds.add(taskId);
+      this.transitionInboundTask(taskId, "cancelled");
     }
   }
   recordPublicationAudit(record) {
@@ -4727,9 +5023,11 @@ ${buildTriggerGuidance(ctx.reason)}`;
         issue_number: issueNumber,
         body: "\u26A0\uFE0F Failed to process this request. Please re-mention the bot to retry."
       }), `postErrorComment(${chatId}#${issueNumber})`);
+      return true;
     } catch (err) {
       process2.stderr.write(`[Channel:${this.name}] postErrorComment also failed for ${chatId}#${issueNumber}, user must re-mention manually: ${err}
 `);
+      return false;
     }
   }
 };
@@ -4741,6 +5039,85 @@ var plugin = {
   requiredConfigFields: ["token"],
   envResolvableConfigFields: ["baseUrl"],
   defaultSessionScope: "chat_thread",
+  management: {
+    fields: [
+      {
+        key: "token",
+        label: "Personal Access Token",
+        kind: "secret",
+        required: true,
+        envResolvable: true,
+        description: 'Classic PAT with "notifications" scope'
+      },
+      {
+        key: "baseUrl",
+        label: "Base URL",
+        kind: "string",
+        envResolvable: true,
+        description: "GitHub Enterprise API root (e.g. https://ghe.example.com/api/v3). Leave empty for github.com"
+      },
+      {
+        key: "groupPolicy",
+        label: "Group Policy",
+        kind: "enum",
+        required: true,
+        description: 'Must be "Open" for notifications to flow',
+        default: "open",
+        options: [
+          { value: "open", label: "Open" },
+          { value: "allowlist", label: "Allowlist" },
+          { value: "disabled", label: "Disabled" }
+        ]
+      },
+      {
+        key: "senderPolicy",
+        label: "Sender Policy",
+        kind: "enum",
+        required: true,
+        description: 'Use "Allowlist" with allowed users on public repos',
+        options: [
+          { value: "allowlist", label: "Allowlist" },
+          { value: "pairing", label: "Pairing" },
+          { value: "open", label: "Open" }
+        ]
+      },
+      {
+        key: "allowedUsers",
+        label: "Allowed Users",
+        kind: "string-list",
+        description: "GitHub usernames, used by Allowlist and Pairing policies"
+      },
+      {
+        key: "reasonFilter",
+        label: "Reason Filter",
+        kind: "string-list",
+        description: "Optional. Comma-separated notification reasons to process. Leave empty to process all.",
+        options: [
+          { value: "mention", label: "mention" },
+          { value: "review_requested", label: "review_requested" },
+          { value: "assign", label: "assign" },
+          { value: "author", label: "author" },
+          { value: "comment", label: "comment" },
+          { value: "ci_activity", label: "ci_activity" },
+          { value: "manual", label: "manual" },
+          { value: "state_change", label: "state_change" },
+          { value: "subscribed", label: "subscribed" },
+          { value: "team_mention", label: "team_mention" },
+          { value: "security_alert", label: "security_alert" },
+          { value: "approval_requested", label: "approval_requested" },
+          { value: "invitation", label: "invitation" },
+          {
+            value: "member_feature_requested",
+            label: "member_feature_requested"
+          },
+          {
+            value: "security_advisory_credit",
+            label: "security_advisory_credit"
+          }
+        ]
+      }
+    ]
+  },
   createChannel: /* @__PURE__ */ __name((name, config, bridge, options) => new GithubChannel(name, config, bridge, options), "createChannel")
 };
 export {

package/chunks/{earlyInputCapture-5ZWDH3SB.js → earlyInputCapture-GPRUNXTP.js}

@@ -8,7 +8,7 @@ import {
   stopAndGetCapturedInput,
   stopEarlyInputCapture
 } from "./chunk-KVUBYJDM.js";
-import "./chunk-UQDFEU47.js";
+import "./chunk-E2SYUEIA.js";
 import "./chunk-GOFAQQZA.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-TWPJO254.js";
@@ -18,7 +18,7 @@ import "./chunk-I7JDGNG6.js";
 import "./chunk-A6SX5TAH.js";
 import "./chunk-33FNCQSY.js";
 import "./chunk-6PVPNMXU.js";
-import "./chunk-XUMAD5IT.js";
+import "./chunk-DZPOYHBT.js";
 import "./chunk-IRH27ZC2.js";
 import "./chunk-QHWCP53L.js";
 import "./chunk-MOHAWIAW.js";
@@ -33,12 +33,13 @@ import "./chunk-A5YZ3FA2.js";
 import "./chunk-YAVY33G4.js";
 import "./chunk-2UISUFHQ.js";
 import "./chunk-HFVW54NL.js";
-import "./chunk-TZTBZ25J.js";
+import "./chunk-LLMGP5IC.js";
 import "./chunk-S6LOFUVP.js";
-import "./chunk-SRY26X4H.js";
+import "./chunk-7UXI6P72.js";
 import "./chunk-K623ENWT.js";
 import "./chunk-AQ37AY7B.js";
 import "./chunk-432XCUHF.js";
+import "./chunk-YXEVDA66.js";
 import "./chunk-XC656O42.js";
 import "./chunk-NAVJD2PQ.js";
 import "./chunk-QYPT3QUD.js";
@@ -47,19 +48,19 @@ import "./chunk-DGEIYUC3.js";
 import "./chunk-MPHPFVKK.js";
 import "./chunk-GLNBDYUX.js";
 import "./chunk-DJ2GSRLV.js";
-import "./chunk-EIMKVOSF.js";
+import "./chunk-SBBHZ3YT.js";
 import "./chunk-RPYYTL7E.js";
 import "./chunk-2J3OJGTL.js";
 import "./chunk-P3QQPMQA.js";
 import "./chunk-6O5DVH27.js";
 import "./chunk-GLCZKT5V.js";
 import "./chunk-2DNKEBXY.js";
-import "./chunk-4K3RV3OA.js";
+import "./chunk-JDJ7SC4E.js";
 import "./chunk-VGC4I5JJ.js";
 import "./chunk-E4WHKETF.js";
 import "./chunk-UEJESCS7.js";
 import "./chunk-CFDR3GNL.js";
-import "./chunk-H35Q5CEG.js";
+import "./chunk-TXZDRD36.js";
 import "./chunk-46UV252V.js";
 import "./chunk-ZBVS26BY.js";
 import "./chunk-BFHXDAR7.js";

package/chunks/{edit-J7SW6UP6.js → edit-YK3UP6D2.js}

@@ -11,7 +11,7 @@ import {
   getDiffStat,
   needsUtf8Bom,
   safeLiteralReplace
-} from "./chunk-UQDFEU47.js";
+} from "./chunk-E2SYUEIA.js";
 import "./chunk-GOFAQQZA.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-TWPJO254.js";
@@ -21,7 +21,7 @@ import "./chunk-I7JDGNG6.js";
 import "./chunk-A6SX5TAH.js";
 import "./chunk-33FNCQSY.js";
 import "./chunk-6PVPNMXU.js";
-import "./chunk-XUMAD5IT.js";
+import "./chunk-DZPOYHBT.js";
 import "./chunk-IRH27ZC2.js";
 import "./chunk-QHWCP53L.js";
 import "./chunk-MOHAWIAW.js";
@@ -36,12 +36,13 @@ import "./chunk-A5YZ3FA2.js";
 import "./chunk-YAVY33G4.js";
 import "./chunk-2UISUFHQ.js";
 import "./chunk-HFVW54NL.js";
-import "./chunk-TZTBZ25J.js";
+import "./chunk-LLMGP5IC.js";
 import "./chunk-S6LOFUVP.js";
-import "./chunk-SRY26X4H.js";
+import "./chunk-7UXI6P72.js";
 import "./chunk-K623ENWT.js";
 import "./chunk-AQ37AY7B.js";
 import "./chunk-432XCUHF.js";
+import "./chunk-YXEVDA66.js";
 import "./chunk-XC656O42.js";
 import "./chunk-NAVJD2PQ.js";
 import "./chunk-QYPT3QUD.js";
@@ -50,7 +51,7 @@ import "./chunk-DGEIYUC3.js";
 import "./chunk-MPHPFVKK.js";
 import "./chunk-GLNBDYUX.js";
 import "./chunk-DJ2GSRLV.js";
-import "./chunk-EIMKVOSF.js";
+import "./chunk-SBBHZ3YT.js";
 import "./chunk-RPYYTL7E.js";
 import "./chunk-2J3OJGTL.js";
 import "./chunk-P3QQPMQA.js";
@@ -64,7 +65,7 @@ import {
   getLanguageFromFilePath,
   getSpecificMimeType,
   logFileOperation
-} from "./chunk-4K3RV3OA.js";
+} from "./chunk-JDJ7SC4E.js";
 import "./chunk-VGC4I5JJ.js";
 import {
   isAnyAutoMemPath,
@@ -76,7 +77,7 @@ import {
   ToolDisplayNames,
   ToolNames
 } from "./chunk-CFDR3GNL.js";
-import "./chunk-H35Q5CEG.js";
+import "./chunk-TXZDRD36.js";
 import "./chunk-46UV252V.js";
 import "./chunk-ZBVS26BY.js";
 import "./chunk-BFHXDAR7.js";