@prismshadow/penguin-server 0.2.5 → 0.2.7

package/dist/api/types.d.ts

@@ -1397,9 +1397,10 @@ interface SubagentMessageResponse {
  * DELETE /api/sessions/:id/follow-ups/:followUpId: the withdrawn message's original content,
  * for the composer to restore into the input box for editing and resending (#287). File
  * attachments are read back from the Session scratchpad (then deleted from it); one that
- * disappeared meanwhile is omitted rather than failing the recall. 409 `not_pending` when
- * the entry is no longer queued — steering already delivered to the model, or a follow-up
- * already auto-started (or unknown id either way).
+ * disappeared meanwhile is omitted rather than failing the recall. 409 when the entry is no
+ * longer queued, with a code per endpoint because the reasons read differently to the user:
+ * `not_pending` — the steering message already reached the model; `follow_up_started` — the
+ * follow-up already auto-started as a task of its own (unknown ids land on the same code).
  */
 interface RecalledMessageResponse {
     text: string;

package/dist/index.js

@@ -2271,11 +2271,22 @@ function agentKey(projectId, agentId) {
 function followUpInfo(f) {
   return {
     id: f.id,
-    text: f.recall?.text ?? "",
-    images: f.recall?.images.length ?? 0,
-    files: f.recall?.files.length ?? 0
+    text: f.recall.text,
+    images: f.recall.images.length,
+    files: f.recall.files.length
   };
 }
+function recallStoreOf(input) {
+  const text = input.filter(isPlainText("user")).map((m) => m.payload.text).join("\n");
+  const images = [];
+  for (const msg of input) {
+    const payload = msg.payload;
+    if (msg.type === "model_msg" && payload.type === "image_url" && typeof payload.image_url === "string") {
+      images.push(payload.image_url);
+    }
+  }
+  return { text, images, files: [] };
+}
 function isDeliveredSteering(msg) {
   const p = msg.payload;
   if (msg.type !== "model_msg" || p.type !== "text" || p.role !== "user") return false;
@@ -2574,7 +2585,11 @@ var SessionManager = class {
    * With `queueIfBusy`, a busy session (running/compacting) enqueues the input as a
    * follow-up instead of 409: it auto-starts as an ordinary next task once the session
    * returns to idle (`queued: true` in the result; see startQueuedFollowUp), keeping its
-   * thinkingLevel for that auto-start.
+   * thinkingLevel for that auto-start. `opts.recall` is that queued message's original
+   * content — optional, because only the HTTP route knows the parts of it the input does
+   * not carry (the pre-attachment text and where each file landed on disk); every other
+   * caller's store is read off the input, so a queued follow-up is recallable and shows
+   * its content whichever path queued it.
    */
   async startTask(sessionId, input, opts) {
     return this.withLock(sessionId, async () => {
@@ -2587,8 +2602,10 @@ var SessionManager = class {
           id: randomUUID2(),
           input,
           ...opts.thinkingLevel !== void 0 ? { thinkingLevel: opts.thinkingLevel } : {},
-          // The original content rides the queue so a recall can hand it back (see recallFollowUp).
-          ...opts.recall !== void 0 ? { recall: opts.recall } : {}
+          // The original content rides the queue so a recall can hand it back, and so the
+          // queued line shows what is waiting (see recallFollowUp). Callers that know more
+          // than the input carries pass their own; the rest get it read off the input.
+          recall: opts.recall ?? recallStoreOf(input)
         });
         entry.lastActivityMs = Date.now();
         this.publishState(entry, entry.status);
@@ -2865,18 +2882,21 @@ var SessionManager = class {
   /**
    * Recall a queued follow-up task (#287): remove it from the queue before it auto-starts,
    * re-broadcast state, and hand back its original content (plus the thinking level it was
-   * queued with). 409 `not_pending` when the id is not in the queue — it already
-   * auto-started (or the runtime was evicted/restarted, which empties the queue) — or the
-   * entry has no recall store to give back.
+   * queued with). Being in the queue is the whole condition — every queued entry carries a
+   * recall store (see QueuedFollowUp.recall), so no queued message is ever refused. 409
+   * `follow_up_started` when the id is not in the queue: it already auto-started, or the
+   * runtime was released and took the queue with it. Its own code, distinct from steering's
+   * `not_pending`, because the two mean different things to the user — a follow-up became a
+   * task of its own, a steering message reached the model mid-run.
    */
   recallFollowUp(sessionId, followUpId) {
     const entry = this.entries.get(sessionId);
     const i = entry?.followUps.findIndex((f) => f.id === followUpId) ?? -1;
     const queued = i >= 0 ? entry.followUps[i] : void 0;
-    if (!entry || !queued?.recall) {
+    if (!entry || !queued) {
       throw new HttpError(
         409,
-        "not_pending",
+        "follow_up_started",
         "This follow-up message already started and can no longer be recalled."
       );
     }
@@ -4085,6 +4105,26 @@ var MESSAGING_TEXT_CHUNK_CHARS = 4e3;
 var MESSAGING_TEXT_ONLY_NOTICE = "Only text messages are supported for now. \u76EE\u524D\u4EC5\u652F\u6301\u6587\u672C\u6D88\u606F\u3002";
 var MESSAGING_APPROVAL_NOTICE = "A tool call is waiting for your approval in the PenguinHarness web UI. \u6709\u5DE5\u5177\u8C03\u7528\u6B63\u5728\u7B49\u5F85\u4F60\u5728\u7F51\u9875\u7AEF\u5BA1\u6279\u3002";
 var MESSAGING_TEST_MESSAGE = "PenguinHarness test message: this Session's messaging binding works. \u6D4B\u8BD5\u6D88\u606F\uFF1A\u8BE5\u4F1A\u8BDD\u7684\u6D88\u606F\u7ED1\u5B9A\u5DE5\u4F5C\u6B63\u5E38\u3002";
+var MESSAGING_INBOUND_DEDUPE_SIZE = 64;
+var MESSAGING_INBOUND_DEDUPE_WINDOW_MS = 10 * 6e4;
+var RecentInboundIds = class {
+  seen = /* @__PURE__ */ new Map();
+  /** True when this id was already processed inside the window; records it otherwise. */
+  check(messageId, now) {
+    const firstSeen = this.seen.get(messageId);
+    if (firstSeen !== void 0 && now - firstSeen <= MESSAGING_INBOUND_DEDUPE_WINDOW_MS) {
+      return true;
+    }
+    this.seen.delete(messageId);
+    this.seen.set(messageId, now);
+    while (this.seen.size > MESSAGING_INBOUND_DEDUPE_SIZE) {
+      const oldest = this.seen.keys().next();
+      if (oldest.done === true) break;
+      this.seen.delete(oldest.value);
+    }
+    return false;
+  }
+};
 function chunkMessagingText(text, max = MESSAGING_TEXT_CHUNK_CHARS) {
   const out = [];
   let rest = text;
@@ -4098,6 +4138,9 @@ function chunkMessagingText(text, max = MESSAGING_TEXT_CHUNK_CHARS) {
   if (rest.length > 0) out.push(rest);
   return out;
 }
+function inboundKey(sessionId, channel) {
+  return `${sessionId}:${channel}`;
+}
 var MessagingBridge = class {
   constructor(deps) {
     this.deps = deps;
@@ -4108,6 +4151,16 @@ var MessagingBridge = class {
   }
   deps;
   entries = /* @__PURE__ */ new Map();
+  /**
+   * Processed inbound ids per BINDING (`sessionId:channel`), deliberately not per
+   * connection: re-saving an enabled binding restarts its connector, and a message
+   * already turned into a Task must not run again because the connector is new. In memory
+   * only — a server restart forgets, so a redelivery that survives a restart still
+   * duplicates. Accepted: a channel replays within seconds of its own reconnect, and
+   * persisting this would put a write on every inbound message to close a window the
+   * restart itself has almost always already closed.
+   */
+  recentInbound = /* @__PURE__ */ new Map();
   connectors;
   now;
   log;
@@ -4147,11 +4200,15 @@ var MessagingBridge = class {
   /** Route DELETE: disconnect (when this channel holds the connection) and drop the row. No-op when unbound. */
   unbind(sessionId, channel) {
     if (this.entries.get(sessionId)?.channel === channel) this.disconnect(sessionId);
+    this.recentInbound.delete(inboundKey(sessionId, channel));
     this.deps.repo.delete(sessionId, channel);
   }
   /** Session-delete cascade: disconnect and drop every channel's config. */
   unbindSession(sessionId) {
     this.disconnect(sessionId);
+    for (const key of [...this.recentInbound.keys()]) {
+      if (key.startsWith(`${sessionId}:`)) this.recentInbound.delete(key);
+    }
     this.deps.repo.deleteSession(sessionId);
   }
   /** One channel's runtime status (only the connected channel is ever anything but disconnected). */
@@ -4272,8 +4329,32 @@ var MessagingBridge = class {
     return client;
   }
   // —— Inbound ——————————————————————————————————————————————————————————————
+  /**
+   * Has this binding already processed this message? A duplicate is a complete no-op —
+   * ahead of the chat record and the text-only reply, not just the Task start, because a
+   * replayed sticker would otherwise answer with the notice twice.
+   *
+   * Nothing downstream is idempotent: `startTask` with `queueIfBusy` appends to the
+   * follow-up queue unconditionally, and a queued input is published to the Session
+   * channel, so one redelivery becomes two runs in the chat AND two messages in the Web
+   * App. A connector that mints no id opts out rather than having every message after the
+   * first read as a duplicate.
+   */
+  isRedelivery(entry, msg) {
+    if (msg.messageId === "") return false;
+    const key = inboundKey(entry.sessionId, entry.channel);
+    let recent = this.recentInbound.get(key);
+    if (recent === void 0) {
+      recent = new RecentInboundIds();
+      this.recentInbound.set(key, recent);
+    }
+    if (!recent.check(msg.messageId, this.now())) return false;
+    this.log(`[messaging] ${entry.channel} redelivered message ${msg.messageId}, ignored`);
+    return true;
+  }
   async onInbound(entry, msg) {
     if (this.entries.get(entry.sessionId) !== entry) return;
+    if (this.isRedelivery(entry, msg)) return;
     try {
       const isDirect = msg.chatKind === "direct";
       this.deps.repo.recordChat(entry.sessionId, entry.channel, msg.chatId, isDirect);
@@ -4632,6 +4713,7 @@ var TelegramConnector = class {
   }
   async poll(bot, handlers, signal, isClosed) {
     let ready = false;
+    let webhookChecked = false;
     let drained = false;
     let failures = 0;
     let offset;
@@ -4640,6 +4722,16 @@ var TelegramConnector = class {
         if (!ready) {
           await bot.getMe();
           if (isClosed()) return;
+          if (!webhookChecked) {
+            const { url } = await bot.getWebhookInfo();
+            if (isClosed()) return;
+            if (url !== "") {
+              throw new Error(
+                `a webhook is registered on this bot at ${url}, which blocks polling \u2014 remove it there and the connection recovers on its own`
+              );
+            }
+            webhookChecked = true;
+          }
           if (!drained) {
             const backlog = await bot.getUpdates({ offset: -1, timeoutSec: 0, signal });
             if (isClosed()) return;
@@ -4647,18 +4739,21 @@ var TelegramConnector = class {
             if (newest !== void 0) offset = newest.update_id + 1;
             drained = true;
           }
-          ready = true;
-          failures = 0;
-          handlers.onReady?.();
-          continue;
         }
         const updates = await bot.getUpdates({
           ...offset !== void 0 ? { offset } : {},
-          timeoutSec: POLL_TIMEOUT_SEC,
+          // Recovery polls must answer immediately — the outage is only over once a
+          // `getUpdates` comes back, and parking for the long-poll window would hide that
+          // for another 30s. Steady state parks as usual.
+          timeoutSec: ready ? POLL_TIMEOUT_SEC : 0,
           signal
         });
         if (isClosed()) return;
         failures = 0;
+        if (!ready) {
+          ready = true;
+          handlers.onReady?.();
+        }
         for (const update of updates) {
           offset = update.update_id + 1;
           const msg = normalizeUpdate(update);
@@ -4678,6 +4773,15 @@ var TelegramConnector = class {
 // src/runtime/messaging/telegram-api.ts
 var TELEGRAM_API_BASE = "https://api.telegram.org";
 var CALL_TIMEOUT_MS = 15e3;
+function conflictText(description) {
+  if (/terminated by other getUpdates/i.test(description)) {
+    return "another program is already polling this bot \u2014 one bot token can serve only one PenguinHarness server at a time";
+  }
+  if (/webhook is active/i.test(description)) {
+    return "a webhook is set on this bot, which blocks polling \u2014 remove it and the connection recovers on its own";
+  }
+  return null;
+}
 function fetchErrorText(err) {
   if (err instanceof Error) {
     if (err.name === "TimeoutError" || err.name === "AbortError") return "request timed out";
@@ -4706,7 +4810,8 @@ function createTelegramTransport() {
         }
         const body = await res.json().catch(() => null);
         if (body === null || body.ok !== true) {
-          const detail = body?.description ?? `HTTP ${res.status}`;
+          const described = body?.description;
+          const detail = (described !== void 0 ? conflictText(described) : null) ?? described ?? `HTTP ${res.status}`;
           const code = body?.error_code !== void 0 ? ` (code ${body.error_code})` : "";
           throw new Error(`${method} failed: ${detail}${code}`);
         }
@@ -4718,6 +4823,7 @@ function createTelegramTransport() {
       };
       return {
         getMe: () => call("getMe", {}),
+        getWebhookInfo: () => call("getWebhookInfo", {}),
         async sendMessage({ chatId, text, replyToMessageId }) {
           await call("sendMessage", {
             chat_id: wireChatId(chatId),