@cjhyy/code-shell-chat 0.9.44 → 0.9.47

package/README.md

@@ -331,8 +331,9 @@ Desktop 的「编辑配置」会生成包含所有渠道的模板；在模板里
 系统只接受 `0600` 权限。
 
 可序列化的文字入站会先原子写入 `~/.code-shell/im-gateway/inbox.json`，webhook 平台随后才会
-收到确认；相同平台 message ID 会持久去重。处理采用有界队列、全局并发和 per-target 串行，
-暂时失败按指数退避重试。含惰性媒体 loader 的消息保留在内存队列，媒体仍受平台重投策略约束。
+收到确认；同一账号的相同平台 message ID 会持久去重。处理采用有界队列、全局并发和 per-target
+串行，暂时失败按指数退避重试。附件字节先写入 inbox 旁的 spool 再确认；spool 本地写入失败时
+拒绝确认，交由平台重投。超出 spool 上限或下载失败的媒体保留在内存队列，仍受平台重投策略约束。
 `notifications.targets` 最多 32 个，只能引用已启用渠道且必须同时位于该渠道 target 白名单。Desktop 主动
 通知游标会按事件流实例原子写入 `~/.code-shell/im-gateway/desktop-events.json`（可用
 `runtime.eventCursorPath` 覆盖）；Gateway 和 Desktop 正常重启后都会续传。只有 Desktop 初始化了全新的

package/dist/adapter-factory.js

@@ -173,9 +173,9 @@ class LazyChannelAdapter {
         const adapter = await this.load();
         return adapter.run(handler, signal);
     }
-    async send(target, message) {
+    async send(target, message, options) {
         const adapter = await this.load();
-        return adapter.send(target, message);
+        return options ? adapter.send(target, message, options) : adapter.send(target, message);
     }
     load() {
         this.adapterPromise ??= this.loader();

package/dist/channel.d.ts

@@ -86,9 +86,21 @@ export interface OutgoingAttachment {
     mimeType: string;
     data: Uint8Array;
 }
+/** Placement of a reply within the target conversation, copied from the inbound message. */
+export interface ChannelSendOptions {
+    /** Platform thread to reply in; adapters without threads ignore it. */
+    threadId?: string;
+}
 export type ChannelMessageHandler = (message: ChannelMessage) => Promise<void>;
 export interface ChannelAdapter {
     readonly channel: string;
+    /**
+     * Stable account identity among adapters sharing this channel. A durable
+     * gateway binds accepted messages to it, so reordering the adapter list can
+     * never replay one account's input through another. Required when a durable
+     * gateway runs several adapters for the same channel.
+     */
+    readonly accountId?: string;
     readonly capabilities?: ChannelCapabilities;
     /**
      * True only when one visible platform request atomically publishes both the
@@ -99,7 +111,7 @@ export interface ChannelAdapter {
     /** @deprecated Use capabilities.outbound.attachments or supportsOutgoingAttachment(). */
     readonly supportsOutgoingAttachments?: boolean;
     run(handler: ChannelMessageHandler, signal: AbortSignal): Promise<void>;
-    send(target: string, message: OutgoingMessage): Promise<void>;
+    send(target: string, message: OutgoingMessage, options?: ChannelSendOptions): Promise<void>;
 }
 export declare function channelCapabilities(adapter: ChannelAdapter): ChannelCapabilities;
 export declare function supportsOutgoingAttachment(adapter: ChannelAdapter, kind: ChatAttachmentKind): boolean;

package/dist/chat-gateway.js

@@ -59,7 +59,9 @@ export class ChatGateway {
         const context = {
             message,
             adapter,
-            reply: (outgoing) => adapter.send(message.target, outgoing),
+            reply: (outgoing) => message.threadId
+                ? adapter.send(message.target, outgoing, { threadId: message.threadId })
+                : adapter.send(message.target, outgoing),
         };
         let index = -1;
         const next = async (position) => {
@@ -75,6 +77,7 @@ export class ChatGateway {
     async run(signal) {
         if (this.startedAt)
             throw new Error("ChatGateway is already running");
+        const adapterById = routableAdapterIds(this.adapters, Boolean(this.delivery.path));
         this.startedAt = Date.now();
         const ownedAbort = new AbortController();
         const stopOwned = () => ownedAbort.abort();
@@ -83,26 +86,8 @@ export class ChatGateway {
         else
             signal.addEventListener("abort", stopOwned, { once: true });
         const webhooks = [];
-        const adapterById = new Map();
-        // Key adapters by a per-channel ordinal (channel:0, channel:1, …) rather
-        // than the global array index. Delivery-queue records persist this id and
-        // are replayed on the next run; a global index would shift when an
-        // unrelated channel is removed from config, orphaning durable messages
-        // against an id that no longer maps to their adapter.
-        const perChannelCount = new Map();
-        for (const adapter of this.adapters) {
-            const ordinal = perChannelCount.get(adapter.channel) ?? 0;
-            perChannelCount.set(adapter.channel, ordinal + 1);
-            adapterById.set(`${adapter.channel}:${ordinal}`, adapter);
-        }
         const queue = new DeliveryQueue(this.delivery, async (adapterId, message) => {
-            const adapter = adapterById.get(adapterId);
-            if (!adapter) {
-                // A durable record survived a config change that removed its adapter.
-                // Signal unroutable so the queue drops it instead of retrying forever.
-                throw new UnroutableDeliveryError(`Chat adapter no longer exists: ${adapterId}`);
-            }
-            await this.dispatch(adapter, message);
+            await this.dispatch(resolveDurableAdapter(adapterById, adapterId), message);
         }, this.onError);
         this.queue = queue;
         await queue.start();
@@ -125,7 +110,10 @@ export class ChatGateway {
         }
         finally {
             ownedAbort.abort();
-            queue.stop();
+            // Settle inbox writes before run() resolves: callers release the
+            // single-instance lease afterwards, and a late write from this queue
+            // would overwrite the next owner's accepted messages.
+            await queue.stop();
             this.queue = undefined;
             this.startedAt = undefined;
             signal.removeEventListener("abort", stopOwned);
@@ -173,6 +161,64 @@ export class ChatGateway {
         this.onAdapterState?.({ ...state });
     }
 }
+const MAX_ACCOUNT_ID_LENGTH = 128;
+/**
+ * Delivery-queue records persist the adapter id and are replayed on the next
+ * run, so the id must keep naming the same account across config edits.
+ * Adapters with an `accountId` use `channel@account`. Others keep the historic
+ * per-channel ordinal (`channel:0`), which is stable only while the channel has
+ * one adapter — a durable gateway therefore requires account identities for a
+ * multi-account channel instead of letting a reorder swap accounts.
+ */
+function routableAdapterIds(adapters, durable) {
+    const perChannel = new Map();
+    for (const adapter of adapters) {
+        const accountId = adapter.accountId;
+        if (accountId !== undefined &&
+            (typeof accountId !== "string" ||
+                !accountId ||
+                accountId.length > MAX_ACCOUNT_ID_LENGTH ||
+                /[\u0000-\u001f\u007f]/u.test(accountId))) {
+            throw new Error(`Chat adapter ${adapter.channel} has an invalid accountId`);
+        }
+        perChannel.set(adapter.channel, [...(perChannel.get(adapter.channel) ?? []), adapter]);
+    }
+    const byId = new Map();
+    for (const [channel, members] of perChannel) {
+        if (durable && members.length > 1 && members.some(({ accountId }) => !accountId)) {
+            throw new Error(`Durable chat delivery needs a unique accountId for every ${channel} adapter`);
+        }
+        for (const [ordinal, adapter] of members.entries()) {
+            const id = adapter.accountId ? `${channel}@${adapter.accountId}` : `${channel}:${ordinal}`;
+            if (byId.has(id)) {
+                throw new Error(`Duplicate ${channel} adapter accountId: ${adapter.accountId}`);
+            }
+            byId.set(id, adapter);
+        }
+    }
+    return byId;
+}
+/** Resolve a persisted adapter id without ever falling back to another account. */
+function resolveDurableAdapter(adapterById, adapterId) {
+    const exact = adapterById.get(adapterId);
+    if (exact)
+        return exact;
+    const legacy = /^(.+):(\d+)$/u.exec(adapterId);
+    const channel = legacy?.[1] ?? adapterId.slice(0, Math.max(0, adapterId.indexOf("@")));
+    const members = [...adapterById.values()].filter((adapter) => adapter.channel === channel);
+    // A legacy ordinal record written while this channel had a single adapter
+    // still belongs to that adapter after it gains an accountId.
+    if (legacy?.[2] === "0" && members.length === 1)
+        return members[0];
+    if (legacy && members.length > 0) {
+        // The ordinal no longer identifies an account. Keep the durable record for
+        // the operator rather than dropping it or delivering through a guess.
+        throw new Error(`Chat adapter ${adapterId} is ambiguous; configure account identities`);
+    }
+    // A durable record survived a config change that removed its adapter.
+    // Signal unroutable so the queue drops it instead of retrying forever.
+    throw new UnroutableDeliveryError(`Chat adapter no longer exists: ${adapterId}`);
+}
 /** Deny-by-default allowlist middleware for multi-channel gateways. */
 export function createAllowlistMiddleware(rules) {
     const normalized = new Map(Object.entries(rules).map(([channel, rule]) => [

package/dist/cli.js

@@ -54,6 +54,7 @@ async function main(args = process.argv.slice(2)) {
     const stop = () => shutdown.abort();
     process.once("SIGINT", stop);
     process.once("SIGTERM", stop);
+    let gatewayTask;
     try {
         const desktop = new DesktopControlClient(config.desktop);
         const adapters = await Promise.all(config.channels.map((channel) => createChannelAdapterAsync(channel, { discordCommands: CODE_SHELL_REMOTE_COMMANDS })));
@@ -80,7 +81,7 @@ async function main(args = process.argv.slice(2)) {
         gateway.use(createBoundSessionChat({ desktop }));
         gateway.use(createMimiPetChat({ desktop, channels: adapters }));
         console.log(`[code-shell-chat] gateway 已启动：${config.channels.map(({ channel }) => channel).join(", ")}`);
-        const gatewayTask = gateway.run(shutdown.signal);
+        gatewayTask = gateway.run(shutdown.signal);
         const notificationTask = desktop.watchEvents(shutdown.signal, createDesktopNotificationHandler(adapters, config.notifications, {
             progressStore: new FileNotificationDeliveryProgressStore(notificationDeliveryProgressPath(config.runtime.eventCursorPath)),
             authorizeTarget: ({ channel, target }) => {
@@ -97,6 +98,9 @@ async function main(args = process.argv.slice(2)) {
         shutdown.abort();
         process.off("SIGINT", stop);
         process.off("SIGTERM", stop);
+        // The inbox belongs to this lease until the gateway has settled its writes,
+        // even when the notification watcher failed first.
+        await gatewayTask?.catch(() => undefined);
         lease.release();
     }
 }

package/dist/delivery-queue.d.ts

@@ -7,6 +7,13 @@ export interface DeliveryQueueConfig {
     retryBaseMs: number;
     retryMaxMs: number;
     completedTtlMs: number;
+    /**
+     * Failed attempts during which a retrying record keeps later same-target
+     * messages waiting. Past this, it keeps retrying without holding its target,
+     * so one message that always fails cannot block a conversation forever.
+     * Defaults to {@link DEFAULT_RETRY_HOLD_ATTEMPTS}.
+     */
+    retryHoldAttempts?: number;
     /**
      * Directory for spooled attachment bytes. Defaults to `<path>.attachments`.
      *
@@ -21,6 +28,8 @@ export interface DeliveryQueueConfig {
     /** Largest single attachment to spool. Bigger ones fall back to memory-only. */
     maxSpooledAttachmentBytes?: number;
 }
+/** With default backoff (1s doubling to 30s) this holds a target for about two minutes. */
+export declare const DEFAULT_RETRY_HOLD_ATTEMPTS = 8;
 export interface DeliveryQueueStatus {
     pending: number;
     inFlight: number;
@@ -62,7 +71,13 @@ export declare class DeliveryQueue {
     private stopped;
     constructor(config: DeliveryQueueConfig, deliver: (adapterId: string, message: ChannelMessage) => Promise<void>, onError: (error: unknown, message: ChannelMessage) => void);
     start(): Promise<void>;
-    stop(): void;
+    /**
+     * Stop accepting and scheduling work. Resolves once no state write is in
+     * progress; afterwards this instance never writes the inbox again, so the
+     * caller may release its single-instance lease to a new owner. Deliveries
+     * still running keep their durable record and are replayed by that owner.
+     */
+    stop(): Promise<void>;
     status(): DeliveryQueueStatus;
     enqueue(adapterId: string, message: ChannelMessage): Promise<"queued" | "duplicate">;
     private pump;
@@ -73,9 +88,11 @@ export declare class DeliveryQueue {
     /**
      * Materialize a message's attachments to disk so the record can be persisted.
      *
-     * Returns undefined when there is nothing to spool, or when spooling fails —
-     * in which case the caller falls back to the old memory-only behaviour rather
-     * than dropping the message.
+     * Returns undefined when there is nothing to spool, or when the attachments
+     * cannot be materialized within the spool policy (too many, too large, or the
+     * platform download failed) — the caller then keeps the message memory-only.
+     * A local spool I/O failure throws instead: the durable inbox cannot record
+     * an ordinary attachment, so the platform must not be told it was accepted.
      */
     private spoolAttachments;
     /** Rebuild attachments whose bytes live in the spool. */

package/dist/delivery-queue.js

@@ -2,6 +2,8 @@ import { randomUUID } from "node:crypto";
 import { constants } from "node:fs";
 import { chmod, lstat, mkdir, open, readdir, rename, rm, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
+/** With default backoff (1s doubling to 30s) this holds a target for about two minutes. */
+export const DEFAULT_RETRY_HOLD_ATTEMPTS = 8;
 const MAX_DELIVERY_STATE_BYTES = 64 * 1024 * 1024;
 const MAX_COMPLETED_KEYS = 100_000;
 const MAX_SPOOLED_ATTACHMENTS = 32;
@@ -61,14 +63,30 @@ export class DeliveryQueue {
         }
         this.pump();
     }
-    stop() {
+    /**
+     * Stop accepting and scheduling work. Resolves once no state write is in
+     * progress; afterwards this instance never writes the inbox again, so the
+     * caller may release its single-instance lease to a new owner. Deliveries
+     * still running keep their durable record and are replayed by that owner.
+     */
+    async stop() {
         this.stopped = true;
+        // A duplicate must not be acknowledged while the original is still loading
+        // attachments. Wake those waiters without waiting on unbounded media I/O.
+        for (const preparation of this.preparing.values()) {
+            preparation.reject(new Error("Chat Gateway inbox is stopped"));
+        }
         if (this.retryTimer)
             clearTimeout(this.retryTimer);
         this.retryTimer = undefined;
         if (this.persistRetryTimer)
             clearTimeout(this.persistRetryTimer);
         this.persistRetryTimer = undefined;
+        let tail;
+        do {
+            tail = this.mutation;
+            await tail;
+        } while (tail !== this.mutation);
     }
     status() {
         const now = Date.now();
@@ -81,26 +99,47 @@ export class DeliveryQueue {
     async enqueue(adapterId, message) {
         if (this.stopped)
             throw new Error("Chat Gateway inbox is stopped");
-        const dedupeKey = deliveryDedupeKey(message);
+        const dedupeKey = deliveryDedupeKey(adapterId, message);
+        const legacyDedupeKey = legacyDeliveryDedupeKey(message);
         const id = randomUUID();
         const target = targetKey(message);
         let previousPreparation;
         let preparation;
         let releasePreparation;
+        let acceptance;
+        let duplicateAcceptance;
         const reserved = await this.withMutation(async () => {
             if (this.stopped)
                 throw new Error("Chat Gateway inbox is stopped");
             this.pruneCompleted();
             if (dedupeKey &&
                 (this.completed.has(dedupeKey) ||
-                    this.pending.some((entry) => entry.dedupeKey === dedupeKey) ||
-                    [...this.preparing.values()].some((candidate) => candidate === dedupeKey))) {
+                    // Completed keys persisted before keys named the account cannot say
+                    // which account accepted them; stay conservative until they expire.
+                    (legacyDedupeKey !== undefined && this.completed.has(legacyDedupeKey)) ||
+                    this.pending.some((entry) => entry.dedupeKey === dedupeKey))) {
                 return false;
             }
+            if (dedupeKey) {
+                const duplicate = [...this.preparing.values()].find((candidate) => candidate.dedupeKey === dedupeKey);
+                if (duplicate) {
+                    duplicateAcceptance = duplicate.accepted;
+                    return false;
+                }
+            }
             if (this.pending.length + this.preparing.size >= this.config.maxPending) {
                 throw new DeliveryBackpressureError(this.config.maxPending);
             }
-            this.preparing.set(id, dedupeKey);
+            let resolve;
+            let reject;
+            const accepted = new Promise((yes, no) => {
+                resolve = yes;
+                reject = no;
+            });
+            // The original enqueue may have no duplicate waiting on this promise.
+            void accepted.catch(() => undefined);
+            acceptance = { dedupeKey, accepted, resolve, reject };
+            this.preparing.set(id, acceptance);
             previousPreparation = this.preparationByTarget.get(target);
             preparation = new Promise((resolve) => {
                 releasePreparation = resolve;
@@ -108,15 +147,19 @@ export class DeliveryQueue {
             this.preparationByTarget.set(target, preparation);
             return true;
         });
-        if (!reserved)
+        if (!reserved) {
+            // Never hold the mutation lock while waiting for the original to persist.
+            await duplicateAcceptance;
             return "duplicate";
-        // attachment.load() may perform an unbounded network read. The reservation
-        // above preserves dedupe/backpressure, while doing the I/O here prevents one
-        // slow attachment from blocking every enqueue and terminal state write.
-        const spooled = await this.spoolAttachments(id, message);
-        await previousPreparation;
+        }
+        let spooled;
         let record;
         try {
+            // attachment.load() may perform an unbounded network read. The reservation
+            // above preserves dedupe/backpressure, while doing the I/O here prevents one
+            // slow attachment from blocking every enqueue and terminal state write.
+            spooled = await this.spoolAttachments(id, message);
+            await previousPreparation;
             await this.withMutation(async () => {
                 try {
                     if (this.stopped)
@@ -138,6 +181,7 @@ export class DeliveryQueue {
                     this.pending.push(record);
                     if (persistent)
                         await this.persist();
+                    acceptance.resolve();
                 }
                 catch (error) {
                     if (record) {
@@ -153,6 +197,8 @@ export class DeliveryQueue {
             });
         }
         catch (error) {
+            acceptance.reject(error);
+            this.preparing.delete(id);
             await this.discardSpool(record ?? {
                 id,
                 adapterId,
@@ -165,6 +211,9 @@ export class DeliveryQueue {
             throw error;
         }
         finally {
+            // Same-target successors wait on this preparation. Even on failure,
+            // release it only after every earlier one so nothing overtakes them.
+            await previousPreparation;
             releasePreparation?.();
             if (this.preparationByTarget.get(target) === preparation) {
                 this.preparationByTarget.delete(target);
@@ -180,11 +229,25 @@ export class DeliveryQueue {
             clearTimeout(this.retryTimer);
         this.retryTimer = undefined;
         const now = Date.now();
+        const holdAttempts = this.config.retryHoldAttempts ?? DEFAULT_RETRY_HOLD_ATTEMPTS;
         while (this.inFlight.size < this.config.maxConcurrent) {
+            const delayedTargets = new Set();
             const entry = this.pending.find((candidate) => {
-                if (this.inFlight.has(candidate.id) || candidate.nextAttemptAt > now)
+                if (this.inFlight.has(candidate.id))
+                    return false;
+                const key = targetKey(candidate.message);
+                if (delayedTargets.has(key))
                     return false;
-                return ((this.targetInFlight.get(targetKey(candidate.message)) ?? 0) < this.config.maxPerTarget);
+                if (candidate.nextAttemptAt > now) {
+                    // Bounded hold: a record that keeps failing stops blocking its
+                    // conversation but stays queued for its own retries.
+                    if (candidate.attempts < holdAttempts)
+                        delayedTargets.add(key);
+                    return false;
+                }
+                // Already-running peers may share a target when configured, but a
+                // queued retry must not be overtaken by later messages for that target.
+                return (this.targetInFlight.get(key) ?? 0) < this.config.maxPerTarget;
             });
             if (!entry)
                 break;
@@ -220,6 +283,11 @@ export class DeliveryQueue {
                     this.targetInFlight.delete(key);
                 else
                     this.targetInFlight.set(key, targetCount);
+                // A stopped queue may already have handed the inbox to a new owner.
+                // Writing this instance's snapshot would erase that owner's accepted
+                // messages; leave the record (and its spool) for the owner to replay.
+                if (this.stopped)
+                    return;
                 if (terminal) {
                     // Success, or a permanently unroutable record: drop it so a message
                     // that can never be delivered does not retry (and re-log) forever.
@@ -262,6 +330,8 @@ export class DeliveryQueue {
             if (this.stopped)
                 return;
             void this.withMutation(async () => {
+                if (this.stopped)
+                    return;
                 await this.persist();
                 for (const [id, pendingCleanup] of this.persistRetryCleanups) {
                     await this.discardSpool(pendingCleanup.entry);
@@ -284,9 +354,11 @@ export class DeliveryQueue {
     /**
      * Materialize a message's attachments to disk so the record can be persisted.
      *
-     * Returns undefined when there is nothing to spool, or when spooling fails —
-     * in which case the caller falls back to the old memory-only behaviour rather
-     * than dropping the message.
+     * Returns undefined when there is nothing to spool, or when the attachments
+     * cannot be materialized within the spool policy (too many, too large, or the
+     * platform download failed) — the caller then keeps the message memory-only.
+     * A local spool I/O failure throws instead: the durable inbox cannot record
+     * an ordinary attachment, so the platform must not be told it was accepted.
      */
     async spoolAttachments(recordId, message) {
         const attachments = message.attachments;
@@ -294,18 +366,30 @@ export class DeliveryQueue {
         if (!attachments?.length || !dir)
             return undefined;
         const limit = this.config.maxSpooledAttachmentBytes ?? 16 * 1024 * 1024;
+        if (attachments.length > MAX_SPOOLED_ATTACHMENTS)
+            return undefined;
         const written = [];
+        const discardWritten = () => Promise.all(written.map((target) => rm(target, { force: true }).catch(() => undefined)));
         try {
-            if (attachments.length > MAX_SPOOLED_ATTACHMENTS)
-                return undefined;
             await ensureRealDirectory(dir);
             const spooled = [];
             for (const [index, attachment] of attachments.entries()) {
-                const bytes = await attachment.load();
+                let bytes;
+                try {
+                    bytes = await attachment.load();
+                }
+                catch {
+                    // A failed platform download keeps the memory-only path; delivery
+                    // retries the original load().
+                    await discardWritten();
+                    return undefined;
+                }
                 // Oversized payloads stay in memory: spooling them would trade a lost
                 // message for unbounded disk use.
-                if (bytes.byteLength > limit)
-                    throw new Error("attachment exceeds spool limit");
+                if (bytes.byteLength > limit) {
+                    await discardWritten();
+                    return undefined;
+                }
                 const file = `${recordId}.${index}`;
                 const target = `${dir}/${file}`;
                 await writeFile(target, bytes, { mode: 0o600, flag: "wx" });
@@ -321,10 +405,9 @@ export class DeliveryQueue {
             }
             return spooled;
         }
-        catch {
-            // Spooling is an availability improvement, never a new failure mode.
-            await Promise.all(written.map((target) => rm(target, { force: true }).catch(() => undefined)));
-            return undefined;
+        catch (error) {
+            await discardWritten();
+            throw error;
         }
     }
     /** Rebuild attachments whose bytes live in the spool. */
@@ -429,6 +512,12 @@ export class DeliveryQueue {
                 const restored = this.rehydrateAttachments(entry.spooled);
                 this.pending.push({
                     ...entry,
+                    // Records persisted before dedupe keys named the account carry the
+                    // legacy key; the stored adapterId lets them join the new namespace.
+                    ...(entry.dedupeKey !== undefined &&
+                        entry.dedupeKey === legacyDeliveryDedupeKey(entry.message)
+                        ? { dedupeKey: deliveryDedupeKey(entry.adapterId, entry.message) }
+                        : {}),
                     message: restored ? { ...entry.message, attachments: restored } : entry.message,
                     persistent: true,
                     nextAttemptAt: Date.now(),
@@ -513,7 +602,17 @@ export class DeliveryQueue {
         }
     }
 }
-function deliveryDedupeKey(message) {
+/**
+ * Platform message ids are only unique within one account: two accounts on the
+ * same channel can legitimately receive the same id, so the adapter is part of
+ * the key.
+ */
+function deliveryDedupeKey(adapterId, message) {
+    const legacy = legacyDeliveryDedupeKey(message);
+    return legacy === undefined ? undefined : `${adapterId}\0${legacy}`;
+}
+/** Account-less key written by earlier versions; read-only compatibility. */
+function legacyDeliveryDedupeKey(message) {
     return message.messageId
         ? `${message.channel}\0${message.target}\0${message.senderId}\0${message.messageId}`
         : undefined;

package/dist/ingress.js

@@ -48,8 +48,11 @@ function validateHost(value) {
 }
 function validateUpstream(value) {
     const url = new URL(`http://${value}`);
+    // URL drops an explicit default port (`:80` becomes ""), so a missing port
+    // must be judged from the authority the operator actually wrote.
+    const authority = value.split(/[/?#]/u, 1)[0] ?? "";
     if (!["127.0.0.1", "localhost", "[::1]", "::1"].includes(url.hostname) ||
-        !url.port ||
+        (!url.port && !/:\d+$/u.test(authority)) ||
         url.pathname !== "/" ||
         url.username ||
         url.password ||

package/dist/line.js

@@ -3,6 +3,9 @@ import { BUILTIN_CHANNEL_CAPABILITIES } from "./channel.js";
 import { waitForAbort } from "./lifecycle.js";
 import { remoteAttachment, safeAttachmentName } from "./media.js";
 import { readRequestBody, sendResponse } from "./webhook.js";
+/** Messaging API limits for a buttons-template URI action. */
+const LINE_ACTION_LABEL_MAX = 20;
+const LINE_URI_ACTION_MAX = 1_000;
 export class LineAdapter {
     config;
     fetchFn;
@@ -85,7 +88,14 @@ export class LineAdapter {
     }
     async send(target, message) {
         const messages = [{ type: "text", text: message.text }];
-        if (message.button) {
+        if (message.button &&
+            (message.button.text.length > LINE_ACTION_LABEL_MAX ||
+                message.button.url.length > LINE_URI_ACTION_MAX)) {
+            // LINE rejects the whole push when an action exceeds its field limits,
+            // which would also lose the reply text. Deliver the link as text instead.
+            messages.push({ type: "text", text: `${message.button.text}\n${message.button.url}` });
+        }
+        else if (message.button) {
             messages.push({
                 type: "template",
                 altText: message.button.text,

package/dist/matrix.d.ts

@@ -10,6 +10,8 @@ export declare class MatrixAdapter implements ChannelAdapter {
     readonly channel = "matrix";
     readonly capabilities: import("./channel.js").ChannelCapabilities;
     private readonly delivery;
+    /** The access token's own user; its room messages must never become input. */
+    private selfUserId?;
     constructor(config: MatrixAdapterConfig, fetchFn?: typeof fetch);
     run(handler: ChannelMessageHandler, signal: AbortSignal): Promise<void>;
     send(target: string, message: OutgoingMessage): Promise<void>;
@@ -17,5 +19,6 @@ export declare class MatrixAdapter implements ChannelAdapter {
     private uploadAttachment;
     private toMessages;
     private matrixAttachment;
+    private whoami;
     private call;
 }

package/dist/matrix.js

@@ -6,6 +6,8 @@ export class MatrixAdapter {
     channel = "matrix";
     capabilities = BUILTIN_CHANNEL_CAPABILITIES.matrix;
     delivery = new OutgoingDeliveryTracker();
+    /** The access token's own user; its room messages must never become input. */
+    selfUserId;
     constructor(config, fetchFn = fetch) {
         this.config = config;
         this.fetchFn = fetchFn;
@@ -15,6 +17,10 @@ export class MatrixAdapter {
         let retryMs = 1_000;
         while (!signal.aborted) {
             try {
+                // Every sync returns this bot's own replies. Without the token's real
+                // identity they would re-enter as input and answer themselves, so the
+                // optional botUserId falls back to an authenticated whoami lookup.
+                this.selfUserId ??= this.config.botUserId ?? (await this.whoami(signal));
                 const query = new URLSearchParams({ timeout: "30000" });
                 if (since)
                     query.set("since", since);
@@ -106,7 +112,7 @@ export class MatrixAdapter {
                 if (event.type !== "m.room.message" ||
                     !content?.msgtype ||
                     !event.sender ||
-                    event.sender === this.config.botUserId ||
+                    event.sender === this.selfUserId ||
                     (event.origin_server_ts !== undefined && now - event.origin_server_ts > 5 * 60_000)) {
                     continue;
                 }
@@ -155,6 +161,12 @@ export class MatrixAdapter {
             }),
         };
     }
+    async whoami(signal) {
+        const { user_id: userId } = await this.call("/_matrix/client/v3/account/whoami", { method: "GET", signal });
+        if (typeof userId !== "string" || !userId)
+            throw new Error("Matrix whoami 未返回 user_id");
+        return userId;
+    }
     async call(path, init) {
         const response = await this.fetchFn(`${this.config.homeserverUrl}${path}`, {
             ...init,

package/dist/media.js

@@ -184,14 +184,20 @@ export function outgoingAttachments(message, supported) {
     return attachments;
 }
 export function safeAttachmentName(value, fallback = "attachment") {
-    const normalized = (value ?? "")
+    const normalized = truncateLabel((value ?? "")
         .replaceAll("\\", "/")
         .split("/")
         .at(-1)
         ?.replace(/[\u0000-\u001f\u007f]/gu, "")
-        .trim()
-        .slice(0, 255);
-    return (normalized || fallback.replace(/[\u0000-\u001f\u007f]/gu, "").slice(0, 255) || "attachment");
+        .trim() ?? "");
+    return (normalized || truncateLabel(fallback.replace(/[\u0000-\u001f\u007f]/gu, "")) || "attachment");
+}
+/** Cap at 255 UTF-16 units without leaving half of a surrogate pair behind. */
+function truncateLabel(value, maximum = 255) {
+    if (value.length <= maximum)
+        return value;
+    const last = value.charCodeAt(maximum - 1);
+    return value.slice(0, last >= 0xd800 && last <= 0xdbff ? maximum - 1 : maximum);
 }
 /**
  * Resume a multi-request adapter send at the first unfinished visible step.

package/dist/notification-progress.js

@@ -160,10 +160,19 @@ export class NotificationDeliveryProgress {
         await operation;
     }
     ensureLoaded() {
-        this.loadTask ??= (async () => {
-            const loaded = await this.store?.load();
-            this.state = loaded ? cloneProgress(loaded) : undefined;
-        })();
+        if (!this.loadTask) {
+            const task = (async () => {
+                const loaded = await this.store?.load();
+                this.state = loaded ? cloneProgress(loaded) : undefined;
+            })();
+            // Forget a failed load so the watcher's next retry reads the store again
+            // instead of replaying the cached rejection forever.
+            task.catch(() => {
+                if (this.loadTask === task)
+                    this.loadTask = undefined;
+            });
+            this.loadTask = task;
+        }
         return this.loadTask;
     }
     async persistCurrent() {

package/dist/slack.d.ts

@@ -1,4 +1,4 @@
-import type { ChannelAdapter, ChannelMessageHandler, OutgoingMessage } from "./channel.js";
+import type { ChannelAdapter, ChannelMessageHandler, ChannelSendOptions, OutgoingMessage } from "./channel.js";
 export interface SlackAdapterConfig {
     botToken: string;
     appToken: string;
@@ -13,5 +13,5 @@ export declare class SlackAdapter implements ChannelAdapter {
     private readonly fetchFn;
     constructor(config: SlackAdapterConfig, fetchFn?: typeof fetch);
     run(handler: ChannelMessageHandler, signal: AbortSignal): Promise<void>;
-    send(target: string, message: OutgoingMessage): Promise<void>;
+    send(target: string, message: OutgoingMessage, options?: ChannelSendOptions): Promise<void>;
 }

package/dist/slack.js

@@ -63,6 +63,11 @@ export class SlackAdapter {
                 ...(event.client_msg_id || event.ts
                     ? { messageId: String(event.client_msg_id ?? event.ts) }
                     : {}),
+                // Replies must carry the parent thread_ts, or Slack posts them at the
+                // channel top level instead of in the thread the user is using.
+                ...(typeof event.thread_ts === "string" && event.thread_ts
+                    ? { threadId: event.thread_ts }
+                    : {}),
                 ...(attachments.length > 0 ? { attachments } : {}),
             });
             await ack();
@@ -104,13 +109,15 @@ export class SlackAdapter {
             await this.socket.disconnect();
         }
     }
-    async send(target, message) {
+    async send(target, message, options = {}) {
         const attachments = outgoingAttachments(message, this.capabilities.outbound.attachments);
+        const thread = options.threadId ? { thread_ts: options.threadId } : {};
         if (attachments.length > 0) {
             // Slack's v2 upload can publish all files and the comment atomically,
             // avoiding a text-first partial send that would duplicate on retry.
             await this.web.filesUploadV2({
                 channel_id: target,
+                ...thread,
                 initial_comment: formatOutgoingMarkdown(message.text, message.button),
                 file_uploads: attachments.map((attachment) => ({
                     file: Buffer.from(attachment.data),
@@ -122,6 +129,7 @@ export class SlackAdapter {
         await this.web.chat.postMessage({
             channel: target,
             text: message.text,
+            ...thread,
             ...(message.button
                 ? {
                     blocks: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-chat",
-  "version": "0.9.44",
+  "version": "0.9.47",
   "description": "A standalone, transport-agnostic multi-channel chat gateway for Node.js and Bun.",
   "type": "module",
   "main": "./dist/index.js",