dsh-connect 0.6.6 → 0.7.0

package/lib/runner.js

@@ -13,6 +13,8 @@ import { createUserMessage, ReasoningEffortId } from "@deepseek-ai/dsh-llm";
 import { createAsyncQueue } from "./stream.js";
 import { helpText, parseCommand } from "./commands.js";
 import { messages } from "./i18n.js";
+import { DEFAULT_LOCK_TIMEOUT_MS, acquire as lockAcquire, canWrite as lockCanWrite, isLockTimedOut as lockIsTimedOut, release as lockRelease, } from "./mirror-lock.js";
+import { formatRemindAt, parseRemindTime } from "./scheduler.js";
 export function resolveConnectConfig(config) {
     return {
         agentPreset: config.agentPreset,
@@ -364,6 +366,8 @@ export class AgentRunner {
     adapter;
     bindings;
     adapters;
+    requeue;
+    reminders;
     queue = [];
     running = false;
     agent;
@@ -374,7 +378,15 @@ export class AgentRunner {
     notifyLevel;
     progressTimeoutMs;
     t;
-    constructor(ctx, config, channel, chatKey, chatType, adapter, bindings, adapters) {
+    constructor(ctx, config, channel, chatKey, chatType, adapter, bindings, adapters, 
+    /**
+     * Route a replayed queued message back into the runner of its own channel
+     * (wired by ConnectService). Without it, replayed messages would run in
+     * whichever runner happened to release the lock.
+     */
+    requeue, 
+    /** Persistent chat-level reminders (`/remind`), wired by ConnectService. */
+    reminders) {
         this.ctx = ctx;
         this.config = config;
         this.channel = channel;
@@ -383,6 +395,8 @@ export class AgentRunner {
         this.adapter = adapter;
         this.bindings = bindings;
         this.adapters = adapters;
+        this.requeue = requeue;
+        this.reminders = reminders;
         this.workDir = config.workDir ?? this.resolveDefaultWorkDir();
         // A per-chat language override (set via the settings menu) wins over config.
         const stored = this.bindings.get(channel, chatKey);
@@ -456,6 +470,13 @@ export class AgentRunner {
             });
             return;
         }
+        // A task is already running (or queued): tell the user they can append a
+        // note to the in-flight task with /ps instead of queueing a brand-new turn
+        // behind it. The message still queues as before.
+        if (this.running) {
+            const hint = this.t.busyHint(truncate(msg.text, 20));
+            void this.adapter.sendText(this.target(msg), hint).catch(() => undefined);
+        }
         this.queue.push(msg);
         void this.drain();
     }
@@ -468,6 +489,21 @@ export class AgentRunner {
             return;
         if (event.seq < turn.firstSeq)
             return;
+        // Track context usage while the turn runs so we can nudge the user to
+        // compact before the window fills up (deduped to one nudge per turn).
+        if (event.type === "request/context") {
+            if (typeof event.data.contextWindow === "number")
+                turn.contextWindow = event.data.contextWindow;
+            this.maybeNudgeContext(turn);
+            return;
+        }
+        if (event.type === "assistant/message") {
+            const usage = event.data.usage;
+            if (usage !== undefined && typeof usage.inputTokens === "number") {
+                turn.contextSize = usage.inputTokens;
+                this.maybeNudgeContext(turn);
+            }
+        }
         if (event.type === "assistant/chunk") {
             const chunk = event.data.chunk;
             // First reasoning delta = the milestone the proactive progress notice reports.
@@ -505,6 +541,45 @@ export class AgentRunner {
             applyToolCall(turn, label);
         }
     }
+    /**
+     * Proactive context-high nudge: when the turn's observed context usage
+     * crosses the compaction threshold, ask the user (once per turn) whether to
+     * compact now, instead of waiting until the turn ends to report it.
+     */
+    maybeNudgeContext(turn) {
+        if (turn.contextNudged)
+            return;
+        const size = turn.contextSize;
+        const window = turn.contextWindow;
+        if (size === undefined || window === undefined || window <= 0)
+            return;
+        const pct = Math.round((size / window) * 100);
+        if (pct < AgentRunner.COMPACT_THRESHOLD_PCT)
+            return;
+        turn.contextNudged = true;
+        void (async () => {
+            const target = { chatKey: this.chatKey, chatType: this.chatType };
+            const nudge = this.t.contextHighPrompt(pct);
+            try {
+                if (await this.confirmAction(target, nudge)) {
+                    if (this.agent?.status === "running" || this.running) {
+                        // Compaction needs an idle agent; run it right after this turn ends.
+                        turn.compactAfterTurn = true;
+                        await this.adapter.sendText(target, this.t.compactQueued);
+                    }
+                    else {
+                        await this.compact(target);
+                    }
+                }
+                else {
+                    await this.adapter.sendText(target, this.t.actionCancelled);
+                }
+            }
+            catch (error) {
+                this.log(`connect: context nudge failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        })();
+    }
     target(msg) {
         return {
             chatKey: this.chatKey,
@@ -624,7 +699,7 @@ export class AgentRunner {
             await this.sendTurnStats(msg, outcome);
             // Release lock after task completion
             if (usesLock)
-                this.releaseLock();
+                await this.releaseLock();
             if (outcome.reason !== "completed") {
                 await this.sendSummary(msg, outcome);
             }
@@ -632,7 +707,7 @@ export class AgentRunner {
         catch (error) {
             // Release lock even on error
             if (usesLock)
-                this.releaseLock();
+                await this.releaseLock();
             const detail = error instanceof Error ? error.message : String(error);
             await this.adapter
                 .sendText(this.target(msg), this.t.processingFailedAdvice(truncate(detail, 400), this.errorAdvice(detail)))
@@ -840,7 +915,7 @@ export class AgentRunner {
         this.turn = {
             firstSeq, chunks, lastText: "",
             reasoning: false, hintPushed: false, lastIndex: undefined, pushedAny: false,
-            startedAt: now, lastPushAt: now, toolCount: 0,
+            startedAt: now, lastPushAt: now, toolCount: 0, contextNudged: false, compactAfterTurn: false,
         };
         // Liveness heartbeat: while the agent is working, keep the streaming card
         // visibly alive even through long reasoning or tool-execution stretches
@@ -917,6 +992,14 @@ export class AgentRunner {
         }
         endChunks();
         await streamPromise;
+        // The user confirmed a compaction nudge while this turn was still running:
+        // the agent is idle now, so compact before summarizing.
+        const compactAfterTurn = this.turn.compactAfterTurn;
+        if (compactAfterTurn) {
+            await this.compact(this.target(msg)).catch((error) => {
+                this.log(`connect: deferred compaction failed: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        }
         const outcome = summarizeTurn(agent.session.events, firstSeq);
         const text = outcome.text !== "" ? outcome.text : this.turn.lastText;
         this.turn = undefined;
@@ -1332,6 +1415,22 @@ export class AgentRunner {
                 await this.handleExport(target, command.format);
                 break;
             }
+            case "ps": {
+                await this.handleAppend(command.text, target, msg);
+                break;
+            }
+            case "remind": {
+                await this.handleRemind(command.text, target, msg);
+                break;
+            }
+            case "send": {
+                await this.handleSend(command.path, target);
+                break;
+            }
+            case "broadcast": {
+                await this.handleBroadcast(command.text, target, msg);
+                break;
+            }
             case "help": {
                 await this.adapter.sendText(target, helpText(this.t));
                 break;
@@ -1352,6 +1451,124 @@ export class AgentRunner {
         }
         await handle?.dispose().catch(() => undefined);
     }
+    /**
+     * `/ps <note>` — append a note to the running task. Uses the agent's `steer`
+     * inbox: a running driver consumes the note at its next step boundary (so it
+     * steers the in-flight task), and an idle driver starts a new turn with it.
+     */
+    async handleAppend(text, target, msg) {
+        if (text === "") {
+            await this.adapter.sendText(target, this.t.psUsage);
+            return;
+        }
+        const agent = this.agent;
+        if (agent === undefined) {
+            await this.adapter.sendText(target, this.t.psNoActiveSession);
+            return;
+        }
+        const note = this.t.psAppendLabel(text);
+        const content = await this.buildUserContent({ ...msg, text: note });
+        agent.steer(createUserMessage({ content, source: { kind: "user" } }));
+        this.touchBinding(msg);
+        await this.adapter.sendText(target, this.t.psReceived(text));
+    }
+    /**
+     * `/remind <time> <text>` — persist a chat-level reminder that fires
+     * without waking the agent (see src/scheduler.ts).
+     */
+    async handleRemind(argText, target, msg) {
+        if (this.reminders === undefined) {
+            await this.adapter.sendText(target, this.t.reminderNoText);
+            return;
+        }
+        const arg = argText.trim();
+        if (arg === "") {
+            await this.adapter.sendText(target, this.t.reminderNoText);
+            return;
+        }
+        const space = arg.indexOf(" ");
+        const time = space === -1 ? arg : arg.slice(0, space);
+        const body = space === -1 ? "" : arg.slice(space + 1).trim();
+        const dueAt = parseRemindTime(time);
+        if (dueAt === undefined) {
+            await this.adapter.sendText(target, this.t.reminderParseFailed(time));
+            return;
+        }
+        if (body === "") {
+            await this.adapter.sendText(target, this.t.reminderNoText);
+            return;
+        }
+        this.reminders.add({
+            channel: this.channel,
+            chatKey: this.chatKey,
+            chatType: this.chatType,
+            text: body,
+            dueAt,
+            ownerKey: msg.senderKey,
+        });
+        await this.adapter.sendText(target, this.t.reminderSet(formatRemindAt(dueAt, this.language), body));
+    }
+    /**
+     * `/send <path>` — deliver a file from the workspace through the channel's
+     * `sendFile` capability; falls back to sending the path as text.
+     */
+    async handleSend(pathArg, target) {
+        if (pathArg === "") {
+            await this.adapter.sendText(target, this.t.sendUsage);
+            return;
+        }
+        const path = isAbsolute(pathArg) ? pathArg : join(this.workDir, pathArg);
+        let size;
+        try {
+            if (!existsSync(path)) {
+                await this.adapter.sendText(target, this.t.sendNotFound(path));
+                return;
+            }
+            const stat = statSync(path);
+            if (stat.isDirectory()) {
+                await this.adapter.sendText(target, this.t.sendIsDir(path));
+                return;
+            }
+            size = stat.size;
+        }
+        catch {
+            await this.adapter.sendText(target, this.t.sendNotFound(path));
+            return;
+        }
+        if (size > 20 * 1024 * 1024) {
+            await this.adapter.sendText(target, this.t.sendTooLarge(path));
+            return;
+        }
+        if (this.adapter.sendFile === undefined) {
+            await this.adapter.sendText(target, `${this.t.sendUnsupported}\n${path}`);
+            return;
+        }
+        try {
+            await this.adapter.sendFile(target, path);
+            await this.adapter.sendText(target, this.t.sendSent(path));
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            await this.adapter.sendText(target, this.t.sendFailed(truncate(detail)));
+        }
+    }
+    /**
+     * `/broadcast <text>` — admins push a message to every bound chat.
+     * Admin gating lives in the connect service (allowUsers).
+     */
+    async handleBroadcast(text, target, msg) {
+        const service = this.ctx.get("connect");
+        if (service?.broadcast === undefined) {
+            await this.adapter.sendText(target, this.t.broadcastUnsupported);
+            return;
+        }
+        const result = await service.broadcast(msg.senderKey, text);
+        if (!result.ok) {
+            await this.adapter.sendText(target, result.reason === "disabled" ? this.t.broadcastDisabled : this.t.broadcastNotAdmin);
+            return;
+        }
+        await this.adapter.sendText(target, this.t.broadcastSent(result.count ?? 0));
+    }
     recordSession(sessionId, title, ownerKey) {
         const binding = this.bindings.get(this.channel, this.chatKey);
         const others = (binding?.sessions ?? []).filter((s) => s.sessionId !== sessionId);
@@ -2101,26 +2318,38 @@ export class AgentRunner {
         }
     }
     async showSchedule(target) {
-        const agent = this.agent;
-        if (agent === undefined) {
-            await this.adapter.sendText(target, this.t.noActiveSession);
-            return;
-        }
-        const reminders = foldReminders(agent.session.events);
-        if (reminders.length === 0) {
-            await this.adapter.sendText(target, this.t.noReminders);
-            return;
-        }
+        // Agent-level reminders (session `schedule` tool) + persistent chat-level
+        // reminders (`/remind`), merged into one list.
+        const agentReminders = this.agent === undefined ? [] : foldReminders(this.agent.session.events);
+        const persisted = this.reminders?.listFor(this.channel, this.chatKey) ?? [];
         const now = Date.now();
         const locale = this.language === "en" ? "en-US" : "zh-CN";
-        const lines = reminders.map((r) => {
+        const agentLines = agentReminders.map((r) => {
             const due = Date.parse(r.scheduledAt) <= now;
             const state = due ? this.t.reminderDue : this.t.reminderClock;
             const kind = r.kind === "every" ? this.t.reminderEvery(Math.round((r.everySeconds ?? 0) / 60)) : this.t.reminderOnce;
             const when = new Date(Date.parse(r.scheduledAt)).toLocaleString(locale);
             return this.t.reminderLine(state, r.id, r.prompt, kind, when);
         });
-        await this.adapter.sendText(target, this.t.remindersCount(reminders.length, lines.join("\n")));
+        const persistedLines = persisted.map((r) => {
+            const due = r.dueAt <= now;
+            const state = due ? this.t.reminderDue : this.t.reminderClock;
+            const when = new Date(r.dueAt).toLocaleString(locale);
+            return this.t.reminderLine(state, r.id, r.text, this.t.reminderOnce, when);
+        });
+        const total = agentLines.length + persistedLines.length;
+        if (total === 0) {
+            await this.adapter.sendText(target, this.t.noReminders);
+            return;
+        }
+        const parts = [];
+        if (agentLines.length > 0)
+            parts.push(...agentLines);
+        if (persistedLines.length > 0) {
+            parts.push(this.t.reminderPersistedHeader);
+            parts.push(...persistedLines);
+        }
+        await this.adapter.sendText(target, this.t.remindersCount(total, parts.join("\n")));
     }
     async showAllWorkspaces(target) {
         const registry = this.ctx.get("workspaceRegistry");
@@ -2205,7 +2434,7 @@ export class AgentRunner {
         }
         // Process any queued messages before releasing
         const queuedCount = binding.queuedMessages?.length ?? 0;
-        this.releaseLock();
+        await this.releaseLock();
         let message = this.t.unlockSuccess;
         if (queuedCount > 0) {
             message += `\n${this.t.queueProcessed(queuedCount)}`;
@@ -2238,7 +2467,8 @@ export class AgentRunner {
         await this.adapter.sendText(target, this.t.lockRenewed(timeoutMin));
     }
     /**
-     * Export conversation history to Markdown or PDF.
+     * Export conversation history as Markdown (a future PDF pipeline can be
+     * added here; `/export pdf` currently falls back to Markdown).
      */
     async handleExport(target, format) {
         const agent = this.agent;
@@ -2246,12 +2476,6 @@ export class AgentRunner {
             await this.adapter.sendText(target, this.t.exportNoSession);
             return;
         }
-        // Default to markdown if not specified
-        const exportFormat = format ?? "markdown";
-        if (exportFormat === "pdf") {
-            await this.adapter.sendText(target, this.t.exportPdfNotSupported);
-            return;
-        }
         try {
             const markdown = this.generateMarkdown(agent);
             const fileName = `conversation-${agent.id}-${Date.now()}.md`;
@@ -2320,54 +2544,35 @@ export class AgentRunner {
      */
     canWrite(channel) {
         const binding = this.bindings.get(this.channel, this.chatKey);
-        if (binding?.lockOwner === undefined)
-            return true; // No lock, free access
-        // Check timeout
-        if (this.isLockTimedOut(binding)) {
-            this.releaseTimeoutLock(binding);
+        if (binding === undefined)
+            return true; // No binding, free access
+        if (lockCanWrite(binding, channel)) {
+            // A timed-out lock counts as free; release it so the next acquire sees a clean state.
+            if (lockIsTimedOut(binding))
+                this.releaseTimeoutLock(binding);
             return true;
         }
-        return binding.lockOwner === channel;
+        return false;
     }
     /**
      * Acquire session lock for the given channel.
      * Returns true if lock acquired, false if already locked by another channel.
      */
     acquireLock(channel) {
-        const binding = this.bindings.get(this.channel, this.chatKey);
+        let binding = this.bindings.get(this.channel, this.chatKey);
         if (binding === undefined)
             return true;
-        // Check timeout before acquiring
-        if (this.isLockTimedOut(binding)) {
+        // A timed-out lock is treated as free: release it (with the user notice)
+        // before acquiring so the next state is clean.
+        if (lockIsTimedOut(binding)) {
             this.releaseTimeoutLock(binding);
-            // After timeout release, try to acquire again
-            const refreshed = this.bindings.get(this.channel, this.chatKey);
-            if (refreshed !== undefined && (refreshed.lockOwner === undefined || refreshed.lockOwner === channel)) {
-                const defaultTimeoutMs = refreshed.lockTimeoutMs ?? 5 * 60 * 1000;
-                this.bindings.put({
-                    ...refreshed,
-                    lockOwner: channel,
-                    lockAcquiredAt: Date.now(),
-                    lockTimeoutMs: defaultTimeoutMs,
-                    lastActiveAt: Date.now()
-                });
-                return true;
-            }
-        }
-        if (binding.lockOwner === undefined || binding.lockOwner === channel) {
-            // Lock is free or already owned by this channel
-            const timeoutMs = binding.lockTimeoutMs ?? 5 * 60 * 1000;
-            this.bindings.put({
-                ...binding,
-                lockOwner: channel,
-                lockAcquiredAt: Date.now(),
-                lockTimeoutMs: timeoutMs,
-                lastActiveAt: Date.now()
-            });
-            return true;
+            binding = this.bindings.get(this.channel, this.chatKey) ?? binding;
         }
-        // Locked by other channel - queue the message if from Web
-        return false;
+        const next = lockAcquire(binding, channel);
+        if (next === undefined)
+            return false; // Locked by another channel
+        this.bindings.put({ ...next, lastActiveAt: Date.now() });
+        return true;
     }
     /**
      * Queue a message for later execution when lock is released.
@@ -2385,6 +2590,8 @@ export class AgentRunner {
             replyRef: msg.replyRef,
             images: msg.images,
             files: msg.files,
+            // Keep the true source channel so replay routes to the right runner.
+            channel: msg.channel,
         });
         this.bindings.put({ ...binding, queuedMessages: queued });
         return queued.length;
@@ -2402,69 +2609,64 @@ export class AgentRunner {
         const count = messages.length;
         // Clear queue immediately to prevent duplicate processing
         this.bindings.put({ ...binding, queuedMessages: [] });
-        // Notify about queued messages being processed
-        if (count > 0) {
-            const adapter = this.adapters?.get(this.channel);
-            if (adapter) {
-                await adapter.sendText({ chatKey: this.chatKey, chatType: this.chatType }, this.t.queueProcessed(count)).catch(() => undefined);
-            }
-            // Re-enqueue messages into the runner's processing queue
-            // Construct minimal InboundMessage objects from queued data
-            for (const queued of messages) {
-                const inboundMsg = {
-                    channel: "web", // Queued messages are from Web channel
-                    chatKey: this.chatKey,
-                    chatType: this.chatType,
-                    senderKey: queued.senderKey,
-                    text: queued.text,
-                    replyRef: queued.replyRef,
-                    images: queued.images,
-                    files: queued.files,
-                };
-                // Add to the runner's internal queue for processing
+        // Notify about queued messages being processed.
+        await this.adapter
+            .sendText({ chatKey: this.chatKey, chatType: this.chatType }, this.t.queueProcessed(count))
+            .catch(() => undefined);
+        // Replay each queued message through the service routing so it lands in
+        // the runner of its own channel (a web message goes to the web runner,
+        // never the releasing feishu runner). Without a router we fall back to
+        // the local queue so behavior stays functional in isolation.
+        for (const queued of messages) {
+            const inboundMsg = {
+                channel: queued.channel ?? "web",
+                chatKey: this.chatKey,
+                chatType: this.chatType,
+                senderKey: queued.senderKey,
+                text: queued.text,
+                replyRef: queued.replyRef,
+                images: queued.images,
+                files: queued.files,
+            };
+            if (this.requeue !== undefined) {
+                this.requeue(inboundMsg);
+            }
+            else {
                 this.queue.push(inboundMsg);
             }
-            // Trigger processing if not already running
-            void this.drain();
         }
+        if (this.requeue === undefined)
+            void this.drain();
     }
-    /** Release session lock. */
-    releaseLock() {
+    /**
+     * Release session lock. Awaits the queued-message drain, then clears the
+     * lock from a FRESH read: the drain's queue-clearing put must not be
+     * overwritten by a stale binding object (which would resurrect the queue
+     * and cause duplicate processing on the next release).
+     */
+    async releaseLock() {
         const binding = this.bindings.get(this.channel, this.chatKey);
-        if (binding !== undefined && binding.lockOwner !== undefined) {
-            // Process queued messages before releasing
-            void this.processQueuedMessages();
-            this.bindings.put({ ...binding, lockOwner: undefined, lockAcquiredAt: undefined });
-        }
-    }
-    /** Check if lock has timed out. */
-    isLockTimedOut(binding) {
-        if (binding.lockOwner === undefined || binding.lockAcquiredAt === undefined) {
-            return false;
-        }
-        const timeoutMs = binding.lockTimeoutMs ?? 5 * 60 * 1000; // Default 5 minutes
-        const elapsed = Date.now() - binding.lockAcquiredAt;
-        return elapsed > timeoutMs;
+        if (binding === undefined || binding.lockOwner === undefined)
+            return;
+        await this.processQueuedMessages();
+        const fresh = this.bindings.get(this.channel, this.chatKey) ?? binding;
+        this.bindings.put(lockRelease(fresh));
     }
-    /** Check and release timed-out locks. */
+    /** Check and release timed-out locks (delegates to the pure lock module). */
     checkAndReleaseTimeoutLock() {
         const binding = this.bindings.get(this.channel, this.chatKey);
-        if (binding && this.isLockTimedOut(binding)) {
+        if (binding !== undefined && lockIsTimedOut(binding)) {
             this.releaseTimeoutLock(binding);
         }
     }
     /** Release a timed-out lock and notify. */
     releaseTimeoutLock(binding) {
-        const timeoutMin = Math.round((binding.lockTimeoutMs ?? 5 * 60 * 1000) / 60000);
+        const timeoutMin = Math.round((binding.lockTimeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS) / 60000);
         const lockedBy = binding.lockOwner;
-        this.bindings.put({
-            ...binding,
-            lockOwner: undefined,
-            lockAcquiredAt: undefined
-        });
+        this.bindings.put(lockRelease(binding));
         // Notify users about timeout release
         const adapter = this.adapters?.get(this.channel);
-        if (adapter && lockedBy) {
+        if (adapter !== undefined && lockedBy !== undefined) {
             void adapter.sendText({ chatKey: this.chatKey, chatType: this.chatType }, this.t.lockTimeoutReleased(timeoutMin)).catch(() => undefined);
         }
     }