dsh-connect 0.5.2 → 0.6.3

package/lib/runner.js

@@ -276,6 +276,17 @@ export function summarizeTurn(events, firstSeq) {
 function truncate(text, max = 500) {
     return text.length <= max ? text : `${text.slice(0, max)}…`;
 }
+/** Classify an error message into an advice bucket (keyword-based, best-effort). */
+export function classifyError(detail) {
+    const d = detail.toLowerCase();
+    if (/(permission|forbidden|denied|not have access|no access|unauthorized|403|sandbox|acl |isn't permitted|not permitted|access denied)/.test(d))
+        return "permission";
+    if (/(timeout|econnrefused|econnreset|enotfound|enetunreach|etimedout|socket|network|proxy|tls|certificate|fetch failed|connect |unreachable|dns)/.test(d))
+        return "network";
+    if (/(model|quota|rate ?limit|429|insufficient|balance|token(s)? (limit|length)|max_tokens|context length|credit)/.test(d))
+        return "model";
+    return "generic";
+}
 /** Thousands-separated token count for display. */
 function fmtTokens(n) {
     return n.toLocaleString("en-US");
@@ -355,8 +366,6 @@ export class AgentRunner {
     handle;
     turn;
     workDir;
-    streamEnabled = true;
-    summaryEnabled = true;
     language;
     notifyLevel;
     progressTimeoutMs;
@@ -435,7 +444,12 @@ export class AgentRunner {
     enqueue(msg) {
         const command = parseCommand(msg.text);
         if (command.kind !== "message") {
-            void this.handleCommand(command, msg);
+            // Command handlers touch the adapter directly (no per-call catch) — a
+            // transient channel error here must never become an unhandled rejection
+            // (Node ≥ 15 crashes the process on those by default).
+            void this.handleCommand(command, msg).catch((error) => {
+                this.log(`connect: command ${command.kind} failed: ${error instanceof Error ? error.message : String(error)}`);
+            });
             return;
         }
         this.queue.push(msg);
@@ -464,6 +478,7 @@ export class AgentRunner {
             if (typeof name !== "string" || name === "")
                 return;
             const summary = toolCallSummary(event.data.arguments);
+            turn.toolCount += 1;
             // The proactive progress notice reports the latest milestone even when
             // `result` mode hides the streaming details.
             if (name === "ask_user_question") {
@@ -474,14 +489,15 @@ export class AgentRunner {
                 turn.milestone = this.t.toolCalling(name, undefined);
             }
             // `result` mode shows nothing until the final answer; `important` shows
-            // the tool name only, `full` also carries the one-line summary.
+            // the tool name with a step counter, `full` also carries the summary.
             if (this.notifyLevel === "result")
                 return;
-            const label = name === "ask_user_question"
+            const base = name === "ask_user_question"
                 ? this.t.questionToolCall(questionTextOf(event.data.arguments))
-                : this.notifyLevel === "full"
-                    ? this.t.toolCalling(name, summary)
-                    : this.t.toolCalling(name, undefined);
+                : this.t.toolStepLabel(turn.toolCount, name);
+            const label = name === "ask_user_question" || this.notifyLevel !== "full" || summary === undefined
+                ? base
+                : `${base} — ${summary}`;
             applyToolCall(turn, label);
         }
     }
@@ -492,6 +508,57 @@ export class AgentRunner {
             ...(msg.replyRef === undefined ? {} : { replyRef: msg.replyRef }),
         };
     }
+    /** Completion-card target: in groups, @ the requester so they notice the result. */
+    taskTarget(msg) {
+        return this.chatType === "group"
+            ? { ...this.target(msg), atUsers: [msg.senderKey] }
+            : this.target(msg);
+    }
+    /** Send the one-time welcome card on a chat's first message (persisted marker). */
+    async maybeSendWelcome(msg) {
+        const binding = this.bindings.get(this.channel, this.chatKey);
+        if (binding !== undefined && binding.welcomedAt !== undefined)
+            return;
+        const base = binding ?? {
+            channel: this.channel,
+            chatKey: this.chatKey,
+            chatType: this.chatType,
+            sessionId: "",
+            ownerKey: msg.senderKey,
+            createdAt: Date.now(),
+            lastActiveAt: Date.now(),
+            sessions: [],
+        };
+        this.bindings.put({ ...base, welcomedAt: Date.now(), lastActiveAt: Date.now() });
+        await this.adapter
+            .sendCard(this.target(msg), { markdown: `${this.t.welcomeTitle}\n\n${this.t.welcomeBody(this.workDir)}` })
+            .catch(() => undefined);
+    }
+    /** Pick the localized advice text for a failed turn. */
+    errorAdvice(detail) {
+        switch (classifyError(detail)) {
+            case "permission":
+                return this.t.errorAdvicePermission;
+            case "network":
+                return this.t.errorAdviceNetwork;
+            case "model":
+                return this.t.errorAdviceModel;
+            default:
+                return this.t.errorAdviceGeneric;
+        }
+    }
+    /** Present a destructive-action confirmation; true only when the user confirms. */
+    async confirmAction(target, promptText) {
+        const { choice } = await this.adapter.promptChoice(target, {
+            title: this.t.confirmTitle,
+            description: promptText,
+            options: [
+                { id: "confirm:yes", label: this.t.confirmYes },
+                { id: "confirm:no", label: this.t.confirmNo },
+            ],
+        });
+        return choice === "confirm:yes";
+    }
     async drain() {
         if (this.running)
             return;
@@ -509,11 +576,16 @@ export class AgentRunner {
         }
     }
     async runTurn(msg) {
-        // Check session lock - only allow if this channel owns the lock or no lock exists
+        // The mutual-exclusion lock arbitrates between the Feishu side and the Web
+        // mirror of the *same* session. Channels without a mirror (Telegram /
+        // DingTalk) must not be classified as "web" and must not take part in the
+        // lock at all.
+        const usesLock = this.channel === "feishu" || this.channel === "web";
         const currentChannel = this.channel === "feishu" ? "feishu" : "web";
         // Check timeout before attempting to acquire
-        this.checkAndReleaseTimeoutLock();
-        if (!this.acquireLock(currentChannel)) {
+        if (usesLock)
+            this.checkAndReleaseTimeoutLock();
+        if (usesLock && !this.acquireLock(currentChannel)) {
             const binding = this.bindings.get(this.channel, this.chatKey);
             const lockedBy = binding?.lockOwner ?? "unknown";
             // If from Web channel, queue the message instead of rejecting
@@ -533,27 +605,33 @@ export class AgentRunner {
         }
         try {
             // Acknowledge receipt before the (possibly slow) agent spin-up so the
-            // user knows processing started.
+            // user knows processing started. When more messages are queued, say so.
+            const ack = this.t.processingStarted(truncate(msg.text, 60));
+            const ackText = this.queue.length > 0 ? `${ack}\n${this.t.queuedHint(this.queue.length)}` : ack;
             await this.adapter
-                .sendText(this.target(msg), this.t.processingStarted(truncate(msg.text, 60)))
+                .sendText(this.target(msg), ackText)
                 .catch(() => undefined);
+            // First message in this chat: one-time welcome card.
+            await this.maybeSendWelcome(msg);
             const agent = await this.ensureAgent(msg);
             const outcome = await this.driveAgent(agent, msg);
             this.touchBinding(msg);
             // Task-end stats: model, tokens, elapsed, and a compaction suggestion.
             await this.sendTurnStats(msg, outcome);
             // Release lock after task completion
-            this.releaseLock();
-            if (outcome.reason !== "completed" && this.summaryEnabled) {
+            if (usesLock)
+                this.releaseLock();
+            if (outcome.reason !== "completed") {
                 await this.sendSummary(msg, outcome);
             }
         }
         catch (error) {
             // Release lock even on error
-            this.releaseLock();
+            if (usesLock)
+                this.releaseLock();
             const detail = error instanceof Error ? error.message : String(error);
             await this.adapter
-                .sendText(this.target(msg), this.t.processingFailed(truncate(detail)))
+                .sendText(this.target(msg), this.t.processingFailedAdvice(truncate(detail, 400), this.errorAdvice(detail)))
                 .catch(() => undefined);
         }
     }
@@ -690,22 +768,12 @@ export class AgentRunner {
             const content = await this.buildUserContent(msg);
             return createUserMessage({ content, source: { kind: "user" } });
         };
-        if (!this.streamEnabled) {
-            agent.followup(await userMessage());
-            await agent.whenIdle();
-            await this.sessions.flush(agent.session);
-            const outcome = summarizeTurn(agent.session.events, firstSeq);
-            if (outcome.text !== "") {
-                await this.adapter.sendText(this.target(msg), outcome.text).catch(() => undefined);
-            }
-            return outcome;
-        }
         const chunks = createAsyncQueue();
         const now = Date.now();
         this.turn = {
             firstSeq, chunks, lastText: "",
             reasoning: false, hintPushed: false, lastIndex: undefined, pushedAny: false,
-            startedAt: now, lastPushAt: now,
+            startedAt: now, lastPushAt: now, toolCount: 0,
         };
         // Liveness heartbeat: while the agent is working, keep the streaming card
         // visibly alive even through long reasoning or tool-execution stretches
@@ -748,13 +816,31 @@ export class AgentRunner {
                     .catch(() => undefined);
             }, PROGRESS_WATCHDOG_CHECK_MS)
             : undefined;
+        // End the chunk stream unconditionally: if `followup` / `whenIdle` /
+        // `flush` throws, the adapter's `for await` over `chunks` must still be
+        // released, otherwise the streaming card hangs in "streaming" forever and
+        // the chunk queue / adapter promise leak. On the error path we also await
+        // (and swallow) the stream promise so its rejection can't escape as an
+        // unhandled rejection while the original error propagates.
+        const endChunks = () => {
+            try {
+                chunks.end();
+            }
+            catch {
+                // no-op
+            }
+        };
+        let streamPromise;
         try {
-            const streamPromise = this.adapter.streamText(this.target(msg), chunks);
+            streamPromise = this.adapter.streamText(this.target(msg), chunks);
             agent.followup(await userMessage());
             await agent.whenIdle();
             await this.sessions.flush(agent.session);
-            chunks.end();
-            await streamPromise;
+        }
+        catch (error) {
+            endChunks();
+            await streamPromise?.catch(() => undefined);
+            throw error;
         }
         finally {
             if (heartbeat !== undefined)
@@ -762,6 +848,8 @@ export class AgentRunner {
             if (progressWatchdog !== undefined)
                 clearInterval(progressWatchdog);
         }
+        endChunks();
+        await streamPromise;
         const outcome = summarizeTurn(agent.session.events, firstSeq);
         const text = outcome.text !== "" ? outcome.text : this.turn.lastText;
         this.turn = undefined;
@@ -776,30 +864,35 @@ export class AgentRunner {
     async buildUserContent(msg) {
         const content = [{ type: "text", text: msg.text }];
         const rawImages = msg.images;
-        if (rawImages === undefined || rawImages.length === 0) {
-            if (msg.imageError !== undefined) {
-                content.push({ type: "text", text: this.t.imageDownloadFailed(msg.imageError) });
-            }
-            return content;
-        }
-        // Copy images into the agent's work directory so its tools can access them.
-        const paths = await this.stageImages(rawImages);
-        const locationText = paths.map((p) => `- ${p}`).join("\n");
-        const mainVision = await this.modelSupportsVision(this.agent?.options.provider, this.agent?.options.model);
-        if (mainVision) {
-            const imageBlocks = await this.imageBlocks(paths);
-            if (imageBlocks.length > 0) {
-                this.log(`connect: main model supports vision — passing ${imageBlocks.length} image block(s) directly`);
-                return [{ type: "text", text: msg.text }, ...imageBlocks];
-            }
-            this.log("connect: main model supports vision but image blocks failed to attach — falling back to paths");
-            return content;
-        }
-        const description = await this.describeImages(paths);
-        const note = this.t.imagesStaged(locationText, description);
-        content.push({ type: "text", text: note });
-        // Non-image attachments (files / audio / video): stage them into the work
-        // directory and hand the agent the paths — it can open them with its tools.
+        // Images: pass directly to the main model when it supports vision,
+        // otherwise run a vision sub-task and inject its description as text —
+        // a text-only main model never stalls on images.
+        if (rawImages !== undefined && rawImages.length > 0) {
+            const paths = await this.stageImages(rawImages);
+            const locationText = paths.map((p) => `- ${p}`).join("\n");
+            const mainVision = await this.modelSupportsVision(this.agent?.options.provider, this.agent?.options.model);
+            if (mainVision) {
+                const imageBlocks = await this.imageBlocks(paths);
+                if (imageBlocks.length > 0) {
+                    this.log(`connect: main model supports vision — passing ${imageBlocks.length} image block(s) directly`);
+                    content.push(...imageBlocks);
+                }
+                else {
+                    this.log("connect: main model supports vision but image blocks failed to attach — falling back to paths");
+                    content.push({ type: "text", text: this.t.imagesStaged(locationText, "") });
+                }
+            }
+            else {
+                const description = await this.describeImages(paths);
+                content.push({ type: "text", text: this.t.imagesStaged(locationText, description) });
+            }
+        }
+        else if (msg.imageError !== undefined) {
+            content.push({ type: "text", text: this.t.imageDownloadFailed(msg.imageError) });
+        }
+        // Non-image attachments (files / audio / video) are staged independently of
+        // images: a pure-file message, or a vision-capable main model, must never
+        // silently drop them.
         const rawFiles = msg.files;
         if (rawFiles !== undefined && rawFiles.length > 0) {
             const stagedFiles = await this.stageFiles(rawFiles);
@@ -1010,7 +1103,7 @@ export class AgentRunner {
         if (outcome.text !== "")
             lines.push(this.t.produced(truncate(outcome.text, 300)));
         const card = { markdown: lines.join("\n") };
-        await this.adapter.sendCard(this.target(msg), card).catch(() => undefined);
+        await this.adapter.sendCard(this.taskTarget(msg), card).catch(() => undefined);
     }
     /** Context-window usage at or above this percentage suggests compaction. */
     static COMPACT_THRESHOLD_PCT = 75;
@@ -1039,17 +1132,25 @@ export class AgentRunner {
             lines.push(pct >= AgentRunner.COMPACT_THRESHOLD_PCT ? this.t.taskStatsCompactSuggest : this.t.taskStatsCompactOk);
         }
         const card = { markdown: lines.join("\n") };
-        await this.adapter.sendCard(this.target(msg), card).catch(() => undefined);
+        await this.adapter.sendCard(this.taskTarget(msg), card).catch(() => undefined);
     }
     async handleCommand(command, msg) {
         const target = this.target(msg);
         switch (command.kind) {
             case "new": {
+                if (!(await this.confirmAction(target, this.t.confirmNewText))) {
+                    await this.adapter.sendText(target, this.t.actionCancelled);
+                    break;
+                }
                 await this.newChat(msg);
                 await this.adapter.sendText(target, this.t.newChatDone);
                 break;
             }
             case "clear": {
+                if (!(await this.confirmAction(target, this.t.confirmClearText))) {
+                    await this.adapter.sendText(target, this.t.actionCancelled);
+                    break;
+                }
                 await this.clearChat(msg);
                 await this.adapter.sendText(target, this.t.chatCleared);
                 break;
@@ -1191,10 +1292,10 @@ export class AgentRunner {
             { sessionId, title, createdAt: Date.now(), lastActiveAt: Date.now(), workDir: this.workDir },
             ...others,
         ].slice(0, 50);
+        // Spread the existing binding so per-chat settings (language, notify
+        // level, progress interval, welcomedAt…) survive the first session record.
         this.bindings.put({
-            channel: this.channel,
-            chatKey: this.chatKey,
-            chatType: this.chatType,
+            ...(binding ?? { channel: this.channel, chatKey: this.chatKey, chatType: this.chatType }),
             sessionId,
             ownerKey,
             createdAt: binding?.createdAt ?? Date.now(),
@@ -1237,7 +1338,18 @@ export class AgentRunner {
         await this.disposeAgent();
         const binding = this.bindings.get(this.channel, this.chatKey);
         if (binding !== undefined) {
-            this.bindings.put({ ...binding, sessionId: "", ownerKey: msg.senderKey, lastActiveAt: Date.now() });
+            // A new chat gets a brand-new session; the previous mirror points at the
+            // abandoned session and must be cleared so the next session re-mirrors.
+            this.bindings.put({
+                ...binding,
+                sessionId: "",
+                webMirrorSessionId: undefined,
+                lockOwner: undefined,
+                lockAcquiredAt: undefined,
+                queuedMessages: [],
+                ownerKey: msg.senderKey,
+                lastActiveAt: Date.now(),
+            });
         }
     }
     async clearChat(msg) {
@@ -1246,7 +1358,17 @@ export class AgentRunner {
         await this.disposeAgent();
         if (binding !== undefined && current !== undefined && current !== "") {
             const sessions = binding.sessions.filter((s) => s.sessionId !== current);
-            this.bindings.put({ ...binding, sessionId: "", sessions, ownerKey: msg.senderKey, lastActiveAt: Date.now() });
+            this.bindings.put({
+                ...binding,
+                sessionId: "",
+                sessions,
+                webMirrorSessionId: undefined,
+                lockOwner: undefined,
+                lockAcquiredAt: undefined,
+                queuedMessages: [],
+                ownerKey: msg.senderKey,
+                lastActiveAt: Date.now(),
+            });
         }
     }
     async switchTo(sessionId, ownerKey) {
@@ -1254,7 +1376,19 @@ export class AgentRunner {
         if (binding === undefined)
             return;
         const sessions = binding.sessions.map((s) => (s.sessionId === sessionId ? { ...s, lastActiveAt: Date.now() } : s));
-        this.bindings.put({ ...binding, sessionId, sessions, ownerKey, lastActiveAt: Date.now() });
+        // The mirror follows the active session: clear the stale mapping and let
+        // `autoCreateWebMirror` re-create it for the newly selected session.
+        this.bindings.put({
+            ...binding,
+            sessionId,
+            sessions,
+            webMirrorSessionId: undefined,
+            lockOwner: undefined,
+            lockAcquiredAt: undefined,
+            queuedMessages: [],
+            ownerKey,
+            lastActiveAt: Date.now(),
+        });
         await this.disposeAgent();
     }
     listWorkspaces() {
@@ -1363,7 +1497,12 @@ export class AgentRunner {
                     label: this.t.menuNewChat,
                     leaf: true,
                     onSelect: async (t, m) => {
-                        await this.newChat(m);
+                        if (await this.confirmAction(t, this.t.confirmNewText)) {
+                            await this.newChat(m);
+                        }
+                        else {
+                            await this.adapter.sendText(t, this.t.actionCancelled);
+                        }
                     },
                 });
                 return items;
@@ -1488,7 +1627,7 @@ export class AgentRunner {
             if (event.type === "turn/end") {
                 const reason = mapReason(event.data.reason.kind);
                 // Use the event's timestamp if available, otherwise approximate
-                const completedAt = new Date().toLocaleTimeString("zh-CN", { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+                const completedAt = new Date().toLocaleTimeString(this.language === "en" ? "en-US" : "zh-CN", { hour: "2-digit", minute: "2-digit", second: "2-digit" });
                 return { reason, completedAt };
             }
         }
@@ -1522,8 +1661,6 @@ export class AgentRunner {
         for (const w of this.config.workspaces)
             lines.push(`  - ${w}`);
         lines.push(this.t.chatCountField(binding?.sessions.length ?? 0));
-        lines.push(this.t.streamLabel(this.streamEnabled));
-        lines.push(this.t.summaryLabel(this.summaryEnabled));
         lines.push(this.t.progressSetting(this.progressTimeoutMs === 0 ? this.t.progressOff : this.t.progressMinutes(Math.round(this.progressTimeoutMs / 60_000))));
         lines.push(this.t.allowUsersField(this.config.allowUsers.length, this.config.allowUsers.length === 0));
         lines.push(this.t.allowChatsField(this.config.allowChats.length, this.config.allowChats.length === 0));
@@ -1876,7 +2013,7 @@ export class AgentRunner {
             return;
         }
         const now = Date.now();
-        const locale = this.config.language === "en" ? "en-US" : "zh-CN";
+        const locale = this.language === "en" ? "en-US" : "zh-CN";
         const lines = reminders.map((r) => {
             const due = Date.parse(r.scheduledAt) <= now;
             const state = due ? this.t.reminderDue : this.t.reminderClock;