dsh-connect 0.6.7 → 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);
@@ -685,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);
             }
@@ -693,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)))
@@ -1405,6 +1419,18 @@ export class AgentRunner {
                 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;
@@ -1446,6 +1472,103 @@ export class AgentRunner {
         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);
@@ -2195,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");
@@ -2299,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)}`;
@@ -2332,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;
@@ -2340,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`;
@@ -2414,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;
-            }
+            binding = this.bindings.get(this.channel, this.chatKey) ?? binding;
         }
-        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;
-        }
-        // 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.
@@ -2479,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;
@@ -2496,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);
         }
     }