@gavin-hu/my-pi-agent 0.14.0 → 0.15.0

package/extensions/wechat/commands.ts

@@ -25,6 +25,7 @@ import { isAllowedPeer, type Bridge } from "./bridge.ts";
 import type { WechatClient } from "./client.ts";
 import type { WechatConfig } from "./config.ts";
 import { doctorReport } from "./doctor.ts";
+import { messageOf } from "./errors.ts";
 import { peerLabel, peerKey } from "./format.ts";
 import { waitForLogin, type LoginOutcome } from "./login.ts";
 import { defaultSleep } from "./timer.ts";
@@ -91,7 +92,6 @@ export function isWechatVerb(value: string): value is WechatVerb {
 	return (WECHAT_VERBS as readonly string[]).includes(value);
 }
 
-import { messageOf } from "./errors.ts";
 /**
  * Whether a peer turn is running anywhere on the bridge.
  *
@@ -126,6 +126,54 @@ async function runDoctor(ctx: ExtensionContext, deps: CommandDeps): Promise<void
 	);
 }
 
+/** One user-facing outcome: what to say, and how a non-screen caller says it. */
+interface VerbOutcome {
+	message: string;
+	/** The notice kind the subcommand path posts; the control screen shows the text. */
+	kind: "info" | "warning";
+}
+
+/**
+ * The control verbs, in the one place both callers read them: the control
+ * screen's keys and the `/wechat <verb>` subcommands. A peer label carries text
+ * the peer chose, so it is sanitized here rather than at each call site.
+ */
+function stopMessage(bridge: Bridge, peer: string): VerbOutcome {
+	const label = sanitizeLine(peerLabel(peer));
+	return bridge.stop(peer)
+		? { message: `Stopping ${label}'s turn.`, kind: "info" }
+		: { message: `${label} has no running turn.`, kind: "info" };
+}
+
+function resetMessage(bridge: Bridge, peer: string): VerbOutcome {
+	const label = sanitizeLine(peerLabel(peer));
+	return bridge.reset(peer)
+		? { message: `Started a fresh conversation for ${label}.`, kind: "info" }
+		: { message: `${label} is running; stop it before starting a new conversation.`, kind: "info" };
+}
+
+function cancelPromptMessage(bridge: Bridge): VerbOutcome {
+	if (!bridge.status().promptPending) return { message: "No prompt is waiting.", kind: "info" };
+	bridge.channel().cancel();
+	return { message: "Cancelled the waiting prompt.", kind: "info" };
+}
+
+/** Resume polling, unless it is not paused or the bridge will not start it. */
+async function resumeMessage(bridge: Bridge): Promise<VerbOutcome> {
+	if (!bridge.status().paused) return { message: "WeChat is not paused.", kind: "info" };
+	return (await bridge.resume())
+		? { message: "WeChat polling resumed.", kind: "info" }
+		: { message: "WeChat could not resume; check the terminal notice.", kind: "warning" };
+}
+
+/** Pause polling, unless it is already paused or the bridge is not running. */
+async function pauseMessage(bridge: Bridge): Promise<VerbOutcome> {
+	if (bridge.status().paused) return { message: "WeChat is already paused.", kind: "warning" };
+	return (await bridge.pause())
+		? { message: "WeChat polling paused. Running turns may finish; no new messages will arrive.", kind: "info" }
+		: { message: "WeChat is not running.", kind: "warning" };
+}
+
 /** Pause or resume polling; the account and peer sessions stay in place. */
 async function runPauseToggle(ctx: ExtensionContext, deps: CommandDeps, resume: boolean): Promise<void> {
 	const bridge = deps.getBridge();
@@ -133,27 +181,8 @@ async function runPauseToggle(ctx: ExtensionContext, deps: CommandDeps, resume:
 		ctx.ui.notify("WeChat is not running.", "warning");
 		return;
 	}
-	if (resume) {
-		if (!bridge.status().paused) {
-			ctx.ui.notify("WeChat is not paused.");
-			return;
-		}
-		const ok = await bridge.resume();
-		ctx.ui.notify(
-			ok ? "WeChat polling resumed." : "WeChat could not resume; check the terminal notice.",
-			ok ? "info" : "warning",
-		);
-		return;
-	}
-	const ok = await bridge.pause();
-	ctx.ui.notify(
-		ok
-			? "WeChat polling paused. Running turns may finish; no new messages will arrive."
-			: bridge.status().paused
-				? "WeChat is already paused."
-				: "WeChat is not running.",
-		ok ? "info" : "warning",
-	);
+	const outcome = await (resume ? resumeMessage(bridge) : pauseMessage(bridge));
+	ctx.ui.notify(outcome.message, outcome.kind);
 }
 
 /** Add a refused sender to the project config after the operator confirms. */
@@ -329,29 +358,20 @@ async function runPanel(ctx: ExtensionCommandContext, deps: CommandDeps): Promis
 				actions: {
 					stop: (peer) => {
 						const bridge = deps.getBridge();
-						if (!bridge) return "WeChat bridge is not running.";
-						return bridge.stop(peer) ? `Stopping ${peerLabel(peer)}.` : `${peerLabel(peer)} has no running turn.`;
+						return bridge ? stopMessage(bridge, peer).message : "WeChat bridge is not running.";
 					},
 					reset: (peer) => {
 						const bridge = deps.getBridge();
-						if (!bridge) return "WeChat bridge is not running.";
-						return bridge.reset(peer)
-							? `Started a fresh conversation for ${peerLabel(peer)}.`
-							: `${peerLabel(peer)} is running; stop it before starting fresh.`;
+						return bridge ? resetMessage(bridge, peer).message : "WeChat bridge is not running.";
 					},
 					cancelPrompt: () => {
 						const bridge = deps.getBridge();
-						if (!bridge?.status().promptPending) return "No prompt is waiting.";
-						bridge.channel().cancel();
-						return "Cancelled the waiting prompt.";
+						return bridge ? cancelPromptMessage(bridge).message : "No prompt is waiting.";
 					},
 					togglePause: async () => {
 						const bridge = deps.getBridge();
 						if (!bridge) return "WeChat bridge is not running.";
-						if (bridge.status().paused) {
-							return (await bridge.resume()) ? "Resumed polling." : "Could not resume; see the notice.";
-						}
-						return (await bridge.pause()) ? "Paused polling. Running turns may finish." : "WeChat is not running.";
+						return (await (bridge.status().paused ? resumeMessage(bridge) : pauseMessage(bridge))).message;
 					},
 				},
 				requestRender: () => tui.requestRender(),
@@ -418,16 +438,11 @@ async function runPeerAction(
 		);
 		return;
 	}
-	const label = peerLabel(entry.peer);
 	if (verb === "stop") {
-		ctx.ui.notify(bridge.stop(entry.peer) ? `Stopping ${label}'s turn.` : `${label} has no running turn.`);
+		ctx.ui.notify(stopMessage(bridge, entry.peer).message);
 		return;
 	}
-	ctx.ui.notify(
-		bridge.reset(entry.peer)
-			? `Started a fresh conversation for ${label}.`
-			: `${label} is running; stop it before starting a new conversation.`,
-	);
+	ctx.ui.notify(resetMessage(bridge, entry.peer).message);
 }
 
 /** Run one verb. The control screen reuses this so a key and a subcommand agree. */

package/extensions/wechat/deliver.ts

@@ -9,7 +9,7 @@
  */
 
 import type { BotCredentials } from "./types.ts";
-import { isSessionExpired, WechatError, type WechatClient } from "./client.ts";
+import { isSessionExpired, rejectionOf, WechatError, type WechatClient } from "./client.ts";
 import { messageOf } from "./errors.ts";
 import { chunkText, toWechatText } from "./format.ts";
 import { sendLocalFile } from "./outbound.ts";
@@ -105,14 +105,10 @@ export function createDeliverer(deps: DeliveryDeps): Deliverer {
 				}
 				// A body-level rejection is not a delivery: report it with the part count
 				// instead of letting the answer vanish.
-				if ((response.ret ?? 0) !== 0 || (response.errcode ?? 0) !== 0) {
-					// Prefer the non-zero value: the body may carry `ret: 0` plus a real
-					// `errcode`, and reporting `ret 0` hides the actual reason.
-					const code = (response.ret ?? 0) !== 0 ? response.ret : (response.errcode ?? 0);
-					// The server's own description is the only way to tell a bad token
-					// from a rate limit, so it is part of the error.
-					const detail = response.errmsg ? `: ${response.errmsg}` : "";
-					onFailure(new WechatError(`Weixin rejected the message (ret ${code}${detail}).`), {
+				const rejection = rejectionOf(response);
+				if (rejection) {
+					const detail = rejection.detail ? `: ${rejection.detail}` : "";
+					onFailure(new WechatError(`Weixin rejected the message (ret ${rejection.code}${detail}).`), {
 						sent: index,
 						total: chunks.length,
 					});

package/extensions/wechat/errors.ts

@@ -1,11 +1,8 @@
 /**
  * The one place an unknown thrown value becomes a user-facing line.
  *
- * Every terminal notice and tool error in the extension reports the same way, so
- * an `Error` yields its message and anything else is stringified.
+ * The definition is shared in `lib/errors.ts`; this module keeps the
+ * extension-local import path every WeChat notice and tool error uses.
  */
 
-/** A user-facing message for an unknown thrown value. */
-export function messageOf(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}
+export { messageOf } from "../../lib/errors.ts";

package/extensions/wechat/inbound.ts

@@ -112,6 +112,8 @@ export function createInboundAdmission(deps: InboundDeps): InboundAdmission {
 			if (item.media.length > 0) {
 				const resolved = await resolveMedia(item);
 				if (!deps.isRunning()) return;
+				// The bridge has already refused a message with no text and no media, so
+				// this is the other case: media arrived but nothing in it could be read.
 				if (!text && resolved.images.length === 0 && resolved.files.length === 0) {
 					if (resolved.dropped > 0) prefix = notice("media", item.language, resolved.dropped);
 					await deps.reply(item, prefix ?? notice("unsupported", item.language));
@@ -125,11 +127,6 @@ export function createInboundAdmission(deps: InboundDeps): InboundAdmission {
 				if (resolved.files.length > 0) text = [text, ...resolved.files].filter(Boolean).join("\n");
 				images = resolved.images.length > 0 ? resolved.images : undefined;
 			}
-			if (!text && !images) {
-				await deps.reply(item, notice("unsupported", item.language));
-				deps.pruneTyping();
-				return;
-			}
 			const queued: PeerItem = {
 				peer: item.peer,
 				text,

package/extensions/wechat/index.ts

@@ -15,6 +15,7 @@
 import { getAgentDir, type ExtensionAPI, type ExtensionContext, type Theme } from "@earendil-works/pi-coding-agent";
 import { join } from "node:path";
 import { isExtensionEnabled } from "../../lib/env.ts";
+import { isPidAlive } from "../../lib/spawn.ts";
 import { GLYPHS, STATUS_KEYS } from "../../lib/tui/glyphs.ts";
 import { paint } from "../../lib/tui/tokens.ts";
 import { createBridge, type Bridge, type BridgeState } from "./bridge.ts";
@@ -74,14 +75,7 @@ export default function wechat(pi: ExtensionAPI, deps: WechatDeps = {}): void {
 	const lockDeps = () => ({
 		now: () => Date.now(),
 		pid: process.pid,
-		isAlive: (pid: number) => {
-			try {
-				process.kill(pid, 0);
-				return true;
-			} catch {
-				return false;
-			}
-		},
+		isAlive: isPidAlive,
 	});
 
 	const build = (ctx: ExtensionContext): Bridge => {

package/extensions/wechat/outbound.ts

@@ -13,7 +13,7 @@
 import { createHash, randomBytes } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { basename } from "node:path";
-import type { WechatClient } from "./client.ts";
+import { rejectionOf, type WechatClient } from "./client.ts";
 import { aesEcbPaddedSize, encryptEcb, sanitizeFileName, uploadUrlOf } from "./media.ts";
 import type { BotCredentials, CDNMedia } from "./types.ts";
 
@@ -93,9 +93,7 @@ export async function sendLocalFile(args: SendLocalFileArgs): Promise<boolean> {
 			args.signal,
 		);
 
-		const retBad = response.ret !== undefined && response.ret !== 0;
-		const codeBad = response.errcode !== undefined && response.errcode !== 0;
-		return !retBad && !codeBad;
+		return rejectionOf(response) === undefined;
 	} catch {
 		return false;
 	}

package/extensions/wechat/peer-worker.ts

@@ -27,6 +27,7 @@ import type { ImageContent } from "@earendil-works/pi-ai";
 import { messageOf } from "./errors.ts";
 import type { PeerSession } from "./peer-session.ts";
 import { createReplyPipeline } from "./reply-pipeline.ts";
+import { defaultTimer, type ArmTimer } from "./timer.ts";
 
 /** One admitted, media-resolved inbound message. */
 export interface PeerItem {
@@ -66,7 +67,7 @@ export interface PeerWorkerDeps {
 	partChars?: number;
 	quietMs?: number;
 	now?: () => number;
-	armTimer?: (ms: number, fn: () => void) => () => void;
+	armTimer?: ArmTimer;
 }
 
 /** What a peer is doing right now, for the control screen. */
@@ -134,13 +135,7 @@ function mergeItems(first: PeerItem, next: PeerItem): PeerItem {
 
 export function createPeerWorker(deps: PeerWorkerDeps): PeerWorker {
 	const now = deps.now ?? Date.now;
-	const armTimer =
-		deps.armTimer ??
-		((ms, fn) => {
-			const timer = setTimeout(fn, ms);
-			(timer as { unref?: () => void }).unref?.();
-			return () => clearTimeout(timer);
-		});
+	const armTimer = deps.armTimer ?? defaultTimer;
 	const idleTimeoutMs = deps.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
 	const concurrency = Math.max(1, deps.concurrency ?? 1);
 	const peers = new Map<string, PeerEntry>();

package/extensions/wechat/poll.ts

@@ -9,8 +9,9 @@
  */
 
 import type { BotCredentials, WeixinMessage } from "./types.ts";
-import { isSessionExpired, type WechatClient } from "./client.ts";
+import { isSessionExpired, rejectionOf, type WechatClient } from "./client.ts";
 import { messageOf } from "./errors.ts";
+import { defaultTimer } from "./timer.ts";
 
 const BACKOFF_MS = 2000;
 /** Poll watchdog when the server has not told us its long-poll hold yet. */
@@ -73,10 +74,10 @@ export function createPollLoop(deps: PollDeps): PollLoop {
 				const watchdogMs = deps.pollTimeout(serverHint ?? deps.holdMs());
 				// A cancellable watchdog: `AbortSignal.timeout` cannot be cleared, and a
 				// pending timer per poll would keep the process awake long after the request
-				// settled. Unref'd, so a wedged poll never holds a shutdown open either.
+				// settled. The shared seam unrefs it, so a wedged poll never holds a
+				// shutdown open either.
 				const watchdog = new AbortController();
-				const watchdogTimer = setTimeout(() => watchdog.abort(), watchdogMs);
-				(watchdogTimer as { unref?: () => void }).unref?.();
+				const cancelWatchdog = defaultTimer(watchdogMs, () => watchdog.abort());
 				let response;
 				try {
 					response = await client.getUpdates(account, deps.cursor(), AbortSignal.any([signal, watchdog.signal]), {
@@ -106,7 +107,7 @@ export function createPollLoop(deps: PollDeps): PollLoop {
 					}
 					continue;
 				} finally {
-					clearTimeout(watchdogTimer);
+					cancelWatchdog();
 				}
 				if (!response) break;
 				if (response.timeoutMs !== undefined && response.timeoutMs > 0) serverHint = response.timeoutMs;
@@ -114,14 +115,14 @@ export function createPollLoop(deps: PollDeps): PollLoop {
 					deps.onExpired();
 					return;
 				}
-				if ((response.ret ?? 0) !== 0 || (response.errcode ?? 0) !== 0) {
+				const rejection = rejectionOf(response);
+				if (rejection) {
 					// A body-level rejection (bad cursor, rate limit, revoked token) is not an
 					// empty poll: report it once and back off instead of hammering the API.
 					if (!rejectedNotified) {
 						rejectedNotified = true;
-						const code = (response.ret ?? 0) !== 0 ? response.ret : (response.errcode ?? 0);
-						deps.onPoll?.({ at: deps.now(), error: `rejected ret ${code}` });
-						deps.notify(`WeChat poll rejected (ret ${code}); retrying.`, "warning");
+						deps.onPoll?.({ at: deps.now(), error: `rejected ret ${rejection.code}` });
+						deps.notify(`WeChat poll rejected (ret ${rejection.code}); retrying.`, "warning");
 					}
 					try {
 						await deps.sleep(BACKOFF_MS, signal);

package/extensions/wechat/presence.ts

@@ -14,7 +14,7 @@ import type { WechatClient } from "./client.ts";
 import type { PeerState } from "./peer-worker.ts";
 import type { PeerLanguage } from "./format.ts";
 import { notice } from "./notices.ts";
-import type { ArmTimer } from "./timer.ts";
+import { createTimerMap, type ArmTimer } from "./timer.ts";
 
 /** How long a fetched typing ticket is reused. */
 const TYPING_TTL_MS = 5 * 60 * 1000;
@@ -78,16 +78,16 @@ export interface Presence {
 export function createPresence(deps: PresenceDeps): Presence {
 	const typingCache = new Map<string, { ticket?: string; checkedAt: number }>();
 	/** Per-peer keep-alive cancellers for the typing indicator. */
-	const typing = new Map<string, () => void>();
-	/** Per-peer pending acknowledgement cancellers. */
-	const acks = new Map<string, () => void>();
+	const typing = createTimerMap(deps.armTimer);
+	/** Per-peer pending acknowledgement timers. */
+	const acks = createTimerMap(deps.armTimer);
 	/** When each peer was last acknowledged, so a chatty peer is not spammed. */
 	const ackedAt = new Map<string, number>();
 	/** Peers told that a turn is still running, until that turn ends. */
 	const busyNotified = new Set<string>();
-	/** Per-peer `busy` and `stillWorking` cancellers. */
-	const busyTimers = new Map<string, () => void>();
-	const slowTimers = new Map<string, () => void>();
+	/** Per-peer `busy` and `stillWorking` timers. */
+	const busyTimers = createTimerMap(deps.armTimer);
+	const slowTimers = createTimerMap(deps.armTimer);
 
 	const hasWork = (peer: string): boolean => deps.statusOf(peer) !== "idle";
 	const isRunning = (peer: string): boolean => deps.statusOf(peer) === "running";
@@ -142,10 +142,7 @@ export function createPresence(deps: PresenceDeps): Presence {
 	}
 
 	function stopTyping(peer: string): void {
-		const cancel = typing.get(peer);
-		if (!cancel) return;
-		typing.delete(peer);
-		cancel();
+		typing.stop(peer);
 	}
 
 	/**
@@ -160,61 +157,45 @@ export function createPresence(deps: PresenceDeps): Presence {
 		const started = deps.now();
 		const refresh = (): void => {
 			if (!hasWork(peer) || deps.now() - started >= TYPING_LIMIT_MS) {
-				typing.delete(peer);
+				typing.stop(peer);
 				return;
 			}
 			void typingOn(peer, contextToken);
-			typing.set(peer, deps.armTimer(TYPING_KEEPALIVE_MS, refresh));
+			typing.arm(peer, TYPING_KEEPALIVE_MS, refresh);
 		};
-		typing.set(peer, deps.armTimer(TYPING_KEEPALIVE_MS, refresh));
+		typing.arm(peer, TYPING_KEEPALIVE_MS, refresh);
 	}
 
 	function stopSlowNotice(peer: string): void {
-		const cancel = slowTimers.get(peer);
-		if (cancel) cancel();
-		slowTimers.delete(peer);
+		slowTimers.stop(peer);
 	}
 
 	function stopBusyNotice(peer: string): void {
-		const cancel = busyTimers.get(peer);
-		if (cancel) cancel();
-		busyTimers.delete(peer);
+		busyTimers.stop(peer);
 		busyNotified.delete(peer);
 	}
 
 	function armSlowNotice(peer: string, contextToken: string | undefined): void {
-		stopSlowNotice(peer);
-		slowTimers.set(
-			peer,
-			deps.armTimer(TURN_NOTICE_MS, () => {
-				slowTimers.delete(peer);
-				if (!isRunning(peer)) return;
-				// A turn waiting on an unanswered dialog is not "still working": the
-				// prompt itself nudges, and saying both reads as noise.
-				if (deps.promptPending()) return;
-				void deps.send(peer, contextToken, notice("stillWorking", deps.languageOf(peer)));
-			}),
-		);
+		slowTimers.arm(peer, TURN_NOTICE_MS, () => {
+			if (!isRunning(peer)) return;
+			// A turn waiting on an unanswered dialog is not "still working": the
+			// prompt itself nudges, and saying both reads as noise.
+			if (deps.promptPending()) return;
+			void deps.send(peer, contextToken, notice("stillWorking", deps.languageOf(peer)));
+		});
 	}
 
 	function armBusyNotice(peer: string, contextToken: string | undefined): void {
 		if (busyNotified.has(peer) || busyTimers.has(peer)) return;
-		busyTimers.set(
-			peer,
-			deps.armTimer(BUSY_NOTICE_MS, () => {
-				busyTimers.delete(peer);
-				if (!hasWork(peer) || busyNotified.has(peer)) return;
-				busyNotified.add(peer);
-				void deps.send(peer, contextToken, notice("busy", deps.languageOf(peer)));
-			}),
-		);
+		busyTimers.arm(peer, BUSY_NOTICE_MS, () => {
+			if (!hasWork(peer) || busyNotified.has(peer)) return;
+			busyNotified.add(peer);
+			void deps.send(peer, contextToken, notice("busy", deps.languageOf(peer)));
+		});
 	}
 
 	function cancelAck(peer: string): void {
-		const cancel = acks.get(peer);
-		if (!cancel) return;
-		acks.delete(peer);
-		cancel();
+		acks.stop(peer);
 	}
 
 	/**
@@ -229,25 +210,21 @@ export function createPresence(deps: PresenceDeps): Presence {
 		if (acks.has(target.peer)) return;
 		const last = ackedAt.get(target.peer);
 		if (last !== undefined && deps.now() - last < ACK_REPEAT_MS) return;
-		acks.set(
-			target.peer,
-			deps.armTimer(ACK_DELAY_MS, () => {
-				acks.delete(target.peer);
-				if (!hasWork(target.peer) || isRunning(target.peer)) return;
-				ackedAt.set(target.peer, deps.now());
-				void deps.send(target.peer, target.contextToken, notice("ack", deps.languageOf(target.peer)));
-				// Still waiting after a minute behind another turn: say why.
-				armBusyNotice(target.peer, target.contextToken);
-			}),
-		);
+		acks.arm(target.peer, ACK_DELAY_MS, () => {
+			if (!hasWork(target.peer) || isRunning(target.peer)) return;
+			ackedAt.set(target.peer, deps.now());
+			void deps.send(target.peer, target.contextToken, notice("ack", deps.languageOf(target.peer)));
+			// Still waiting after a minute behind another turn: say why.
+			armBusyNotice(target.peer, target.contextToken);
+		});
 	}
 
 	return {
 		keepTyping,
 		typingOff,
 		pruneTyping() {
-			for (const peer of [...typing.keys()]) {
-				if (!hasWork(peer)) stopTyping(peer);
+			for (const peer of typing.keys()) {
+				if (!hasWork(peer)) typing.stop(peer);
 			}
 		},
 		armAck,
@@ -258,13 +235,9 @@ export function createPresence(deps: PresenceDeps): Presence {
 		stopBusyNotice,
 		stopTyping,
 		reset() {
-			for (const cancel of typing.values()) cancel();
 			typing.clear();
-			for (const cancel of acks.values()) cancel();
 			acks.clear();
-			for (const cancel of busyTimers.values()) cancel();
 			busyTimers.clear();
-			for (const cancel of slowTimers.values()) cancel();
 			slowTimers.clear();
 			typingCache.clear();
 			ackedAt.clear();

package/extensions/wechat/reply-pipeline.ts

@@ -11,11 +11,13 @@
  * drive it.
  */
 
+import type { ArmTimer } from "./timer.ts";
+
 export interface ReplyPipelineDeps {
 	/** Send one part to the peer. Parts arrive strictly in order. */
 	sendPart: (text: string) => Promise<void>;
 	/** Arm a one-shot timer; the returned function cancels it. */
-	armTimer: (ms: number, fn: () => void) => () => void;
+	armTimer: ArmTimer;
 	/** Flush a part that reaches this many characters. Default 400. */
 	partChars?: number;
 	/** Flush a part that has been quiet this long. Default 2000 ms. */

package/extensions/wechat/status-screen.ts

@@ -300,7 +300,7 @@ export class StatusScreenComponent implements Component {
 	private hints(view: StatusView): ScreenHint[] {
 		const hints: ScreenHint[] = ["Esc close"];
 		if (view.peerRows.length > 0) {
-			hints.push("j/k move", { text: "s stop", color: "accent" }, { text: "d reset", color: "warning" }, "h history");
+			hints.push("j/k move", { text: "s stop", color: "warning" }, { text: "d reset", color: "warning" }, "h history");
 		}
 		hints.push(
 			{ text: "l login", color: "accent" },

package/extensions/wechat/timer.ts

@@ -18,6 +18,63 @@ export const defaultTimer: ArmTimer = (ms, fn) => {
 	return () => clearTimeout(timer);
 };
 
+/**
+ * A set of one-shot timers keyed by a caller's id (a peer, a watcher).
+ *
+ * Every per-key timer in this extension follows the same protocol: cancel any
+ * pending entry, delete it, then act — and re-arming must replace, or a refresh
+ * loop would stack timers. Both rules live here so they are one implementation.
+ */
+export interface TimerMap {
+	/** Arm a timer for `key`, replacing a pending one. */
+	arm(key: string, ms: number, fn: () => void): void;
+	/** Whether a timer is pending for `key`. */
+	has(key: string): boolean;
+	/** Cancel and forget `key`'s timer. */
+	stop(key: string): void;
+	/** The keys with a pending timer. */
+	keys(): string[];
+	/** Cancel every pending timer and forget them. */
+	clear(): void;
+}
+
+/** A {@link TimerMap} over the injected seam; the entries live in this closure. */
+export function createTimerMap(arm: ArmTimer): TimerMap {
+	const pending = new Map<string, () => void>();
+	const map: TimerMap = {
+		arm(key, ms, fn) {
+			map.stop(key);
+			// The entry is gone before the callback runs, so a callback that re-arms
+			// itself (a keep-alive) or asks `has(key)` sees the truth rather than itself.
+			pending.set(
+				key,
+				arm(ms, () => {
+					pending.delete(key);
+					fn();
+				}),
+			);
+		},
+		has(key) {
+			return pending.has(key);
+		},
+		stop(key) {
+			const cancel = pending.get(key);
+			if (cancel === undefined) return;
+			pending.delete(key);
+			cancel();
+		},
+		keys() {
+			return [...pending.keys()];
+		},
+		clear() {
+			// A copy: a canceller is free to touch the map it came from.
+			for (const cancel of [...pending.values()]) cancel();
+			pending.clear();
+		},
+	};
+	return map;
+}
+
 /** An abortable sleep: resolves after `ms`, rejects when `signal` aborts. */
 export function defaultSleep(ms: number, signal?: AbortSignal): Promise<void> {
 	return new Promise((resolve, reject) => {