@gavin-hu/my-pi-agent 0.17.0 → 0.19.0

package/extensions/wechat/{interaction.ts → dialog/interaction.ts}

@@ -1,11 +1,13 @@
 /**
  * The WeChat implementation of {@link InteractionChannel}: it forwards a dialog
- * prompt to the peer that owns the current turn and resolves when that peer
- * replies.
+ * prompt to one peer and resolves when that peer replies.
  *
- * It depends only on injected `send`/`sendFile`/`activePeer` accessors and a
- * timer seam, never on the bridge or HTTP client, so it is unit-tested without
- * I/O. The bridge owns the poll loop and hands each inbound message to
+ * One channel serves one peer. That is what lets two peers' turns run at once
+ * without a dialog becoming ambiguous: the channel knows who it is asking, so a
+ * reply can only answer its own peer's prompt. It depends only on injected
+ * `send`/`sendFile`/`active` accessors and a timer seam, never on the bridge or
+ * HTTP client, so it is unit-tested without I/O. The bridge owns the poll loop,
+ * keeps one channel per peer (`channels.ts`), and hands each inbound message to
  * {@link WechatInteractionChannel.handleInbound}.
  *
  * A prompt is bounded: a peer who never answers cannot hold the session open, so
@@ -18,23 +20,25 @@ import {
 	type InteractionAnswer,
 	type InteractionChannel,
 	type InteractionRequest,
-} from "../../lib/interaction.ts";
-import { type PeerLanguage } from "./format.ts";
-import { notice } from "./notices.ts";
+} from "../../../lib/interaction.ts";
+import { type PeerLanguage } from "../text/format.ts";
+import { notice } from "../text/notices.ts";
 import { formatPrompt, parsePromptAnswer } from "./prompt.ts";
-import { defaultTimer, type ArmTimer } from "./timer.ts";
+import { defaultTimer, type ArmTimer } from "../timer.ts";
 
 /** How long a forwarded prompt waits before it is cancelled. */
 export const PROMPT_TIMEOUT_MS = 180_000;
 
 export interface WechatInteractionDeps {
-	/** Send one text message to the owning peer; resolves false when it fails. */
-	send: (text: string, signal?: AbortSignal) => Promise<boolean>;
-	/** Send a local file to the owning peer; resolves false when it fails. */
-	sendFile: (path: string, name: string, signal?: AbortSignal) => Promise<boolean>;
-	/** The peer that owns the in-flight turn, or undefined when there is none. */
-	activePeer: () => string | undefined;
-	/** The language the owning peer writes in, for the timeout notices. */
+	/** The one peer this channel asks. */
+	peer: string;
+	/** Send one text message to the peer; `force` bypasses the prompt-active gate. */
+	send: (text: string, signal?: AbortSignal, options?: { force?: boolean }) => Promise<boolean>;
+	/** Send a local file to the peer; `force` bypasses the prompt-active gate. */
+	sendFile: (path: string, name: string, signal?: AbortSignal, options?: { force?: boolean }) => Promise<boolean>;
+	/** Whether the peer owns a turn right now, so a prompt has somewhere to land. */
+	active: () => boolean;
+	/** The language the peer writes in, for the timeout notices. */
 	language: () => PeerLanguage;
 	/** Arm a cancellable one-shot timer. Defaults to a real, unref'd `setTimeout`. */
 	armTimer?: ArmTimer;
@@ -48,14 +52,16 @@ export interface WechatInteractionChannel extends InteractionChannel {
 	 * previous one when it ends: the optional channel member, made concrete here.
 	 */
 	setPromptTimeout(ms: number): () => void;
-	/** Consume an inbound message as a reply; true when it was one. */
-	handleInbound(peer: string, text: string): boolean;
+	/** Consume an inbound message as a reply to this peer's prompt. */
+	handleInbound(text: string): boolean;
 	/** Whether a prompt is currently waiting for a reply. */
 	hasPending(): boolean;
 	/** The waiting prompt, for the control screen; undefined when none waits. */
 	pendingInfo(): PendingPromptInfo | undefined;
 	/** Withdraw the waiting prompt: tell the peer and resolve it cancelled. */
-	cancel(): void;
+	cancel(): Promise<void>;
+	/** The language prompts are rendered in. */
+	language(): PeerLanguage;
 	/** Drop any pending prompt (turn settled or the bridge stopped). */
 	reset(): void;
 }
@@ -71,7 +77,6 @@ export interface PendingPromptInfo {
 
 interface Pending {
 	request: InteractionRequest;
-	peer: string;
 	startedAt: number;
 	resolve: (answer: InteractionAnswer) => void;
 	signal?: AbortSignal;
@@ -90,11 +95,11 @@ export function createWechatInteractionChannel(deps: WechatInteractionDeps): Wec
 	 */
 	let scopedTimeoutMs: number | undefined;
 	/**
-	 * Free text captured from a `select` "Other" reply, per peer: the immediately
-	 * following `input` for that peer returns it. Keyed so one peer's free text can
-	 * never become another peer's answer.
+	 * Free text captured from a `select` "Other" reply: the immediately following
+	 * `input` for this peer returns it. One value, because one channel asks one peer
+	 * — another peer's free text cannot reach this channel at all.
 	 */
-	const other = new Map<string, string>();
+	let other: string | undefined;
 
 	function settle(answer: InteractionAnswer): void {
 		const current = pending;
@@ -108,7 +113,11 @@ export function createWechatInteractionChannel(deps: WechatInteractionDeps): Wec
 
 	return {
 		isActive(): boolean {
-			return deps.activePeer() !== undefined;
+			return deps.active();
+		},
+
+		language(): PeerLanguage {
+			return deps.language();
 		},
 
 		hasPending(): boolean {
@@ -120,28 +129,33 @@ export function createWechatInteractionChannel(deps: WechatInteractionDeps): Wec
 			return current === undefined
 				? undefined
 				: {
-						peer: current.peer,
+						peer: deps.peer,
 						kind: current.request.kind,
 						title: current.request.title,
 						startedAt: current.startedAt,
 					};
 		},
 
-		cancel(): void {
-			if (!pending) return;
+		async cancel(): Promise<void> {
+			const current = pending;
+			if (!current) return;
 			// The peer saw the prompt; one line says it was withdrawn, which is not the
 			// same as expiry — they were not slow, the question went away. `reset` is the
-			// silent cleanup path and deliberately does not send this.
-			void deps.send(notice("withdrawn", deps.language()));
-			settle({ kind: "cancelled" });
+			// silent cleanup path and deliberately does not send this. Settle after the
+			// notice is on the wire, so a caller awaiting the answer knows it was sent.
+			try {
+				await deps.send(notice("withdrawn", deps.language()), undefined, { force: true });
+			} finally {
+				if (pending === current) settle({ kind: "cancelled" });
+			}
 		},
 
 		async post(text: string, signal?: AbortSignal): Promise<void> {
-			await deps.send(text, signal);
+			await deps.send(text, signal, { force: true });
 		},
 
 		async postFile(path: string, name: string, signal?: AbortSignal): Promise<boolean> {
-			return deps.sendFile(path, name, signal);
+			return deps.sendFile(path, name, signal, { force: true });
 		},
 
 		setPromptTimeout(ms: number): () => void {
@@ -153,54 +167,55 @@ export function createWechatInteractionChannel(deps: WechatInteractionDeps): Wec
 		},
 
 		async request(request: InteractionRequest, signal?: AbortSignal): Promise<InteractionAnswer> {
-			// A `select` that resolved to "Other" stashes its text for that peer; the
-			// immediately following `input` from the same peer returns it without
-			// another round-trip.
-			const asking = deps.activePeer();
-			const stashed = asking === undefined ? undefined : other.get(asking);
-			if (request.kind === "input" && asking !== undefined && stashed !== undefined) {
-				other.delete(asking);
+			// A `select` that resolved to "Other" stashes its text; the immediately
+			// following `input` returns it without another round-trip.
+			const stashed = other;
+			if (request.kind === "input" && stashed !== undefined) {
+				other = undefined;
 				return { kind: "value", value: stashed };
 			}
-			if (request.kind !== "input" && asking !== undefined) other.delete(asking);
+			if (request.kind !== "input") other = undefined;
 
 			if (signal?.aborted || !this.isActive()) return { kind: "cancelled" };
 			if (pending) return { kind: "cancelled" };
 
 			// Register the pending prompt before the send await so a fast reply is
 			// never lost to the round-trip, then send and fail closed.
-			const peer = deps.activePeer() as string;
 			const cancelTimers: Array<() => void> = [];
 			const answer = new Promise<InteractionAnswer>((resolve) => {
 				const onAbort = () => settle({ kind: "cancelled" });
-				pending = { request, peer, startedAt: now(), resolve, signal, onAbort, cancelTimers };
+				pending = { request, startedAt: now(), resolve, signal, onAbort, cancelTimers };
 				signal?.addEventListener("abort", onAbort, { once: true });
 				// An ignored question must not freeze the session: nudge once, then
 				// cancel so the model gets a clean answer instead of a hang.
 				const bound = scopedTimeoutMs ?? PROMPT_TIMEOUT_MS;
-				cancelTimers.push(arm(bound / 2, () => void deps.send(notice("promptWaiting", deps.language()))));
+				cancelTimers.push(
+					arm(bound / 2, () => void deps.send(notice("promptWaiting", deps.language()), undefined, { force: true })),
+				);
 				cancelTimers.push(
 					arm(bound, () => {
-						void deps.send(notice("timeout", deps.language()));
+						void deps.send(notice("timeout", deps.language()), undefined, { force: true });
 						settle({ kind: "cancelled" });
 					}),
 				);
 			});
-			const sent = await deps.send(formatPrompt(request), signal);
+			const sent = await deps.send(formatPrompt(request, { language: deps.language() }), signal);
 			if (!sent) settle({ kind: "cancelled" });
 			return await answer;
 		},
 
-		handleInbound(peer: string, text: string): boolean {
+		handleInbound(text: string): boolean {
 			const current = pending;
-			if (!current || current.peer !== peer) return false;
+			if (!current) return false;
 			const parsed = parsePromptAnswer(current.request, text);
 			switch (parsed.kind) {
 				case "retry":
-					void deps.send(formatPrompt(current.request, { retry: true }));
+					void deps.send(formatPrompt(current.request, { retry: true, language: deps.language() }), undefined, {
+						force: true,
+					});
 					return true;
 				case "other":
-					other.set(peer, parsed.text);
+					other = parsed.text;
 					settle({ kind: "value", value: INTERACTION_OTHER_LABEL });
 					return true;
 				case "value":
@@ -216,7 +231,7 @@ export function createWechatInteractionChannel(deps: WechatInteractionDeps): Wec
 		},
 
 		reset(): void {
-			other.clear();
+			other = undefined;
 			scopedTimeoutMs = undefined;
 			settle({ kind: "cancelled" });
 		},

package/extensions/wechat/{prompt.ts → dialog/prompt.ts}

@@ -2,15 +2,15 @@
  * Pure rendering and parsing of remote dialog prompts (no I/O).
  *
  * A prompt is rendered to a WeChat message by {@link formatPrompt}; the reply is
- * interpreted by {@link parsePromptAnswer}. Hints are bilingual (Chinese and
- * English) so either reader can answer, and {@link formatPrompt} can prepend a
- * short notice when a reply was not understood. The parser is deliberately total:
+ * interpreted by {@link parsePromptAnswer}. Hints are rendered in the peer's
+ * language, and {@link formatPrompt} can prepend a short notice when a reply was
+ * not understood. The parser is deliberately total:
  * anything it cannot resolve reports `retry`, and free text on a `select` becomes
  * the {@link INTERACTION_OTHER_LABEL} option so the caller can collect it once.
  */
 
-import { INTERACTION_OTHER_LABEL, type InteractionRequest } from "../../lib/interaction.ts";
-import { sanitizeInbound } from "./format.ts";
+import { INTERACTION_OTHER_LABEL, type InteractionRequest } from "../../../lib/interaction.ts";
+import { sanitizeInbound, type PeerLanguage } from "../text/format.ts";
 
 /** A parsed reply: a resolved answer, the "other" choice, or a retry. */
 export type PromptParse =
@@ -20,20 +20,30 @@ export type PromptParse =
 	| { kind: "cancelled" }
 	| { kind: "retry" };
 
-const SELECT_OTHER_HINT =
-	"回复编号或选项文字；其它内容作为自定义回答；回复「取消」或 cancel 跳过。\n" +
-	"Reply with a number or the option text; anything else becomes your own answer; reply cancel to dismiss.";
-const SELECT_CHOICE_HINT =
-	"回复编号或选项文字；回复「取消」或 cancel 跳过。\n" +
-	"Reply with a number or the option text; reply cancel to dismiss.";
-const CONFIRM_HINT = "回复「是」或「否」。\nReply yes or no.";
-const INPUT_HINT = "直接回复内容；回复「取消」或 cancel 跳过。\nReply with the text; reply cancel to skip.";
-const EDITOR_HINT =
-	"把内容作为一条消息发回；回复「取消」或 cancel 取消。\nSend the text as one message; reply cancel to cancel.";
+const SELECT_OTHER_HINT: Record<PeerLanguage, string> = {
+	zh: "回复编号或选项文字；其它内容作为自定义回答；回复「取消」跳过。",
+	en: "Reply with a number or the option text; anything else is your own answer; reply cancel to dismiss.",
+};
+const SELECT_CHOICE_HINT: Record<PeerLanguage, string> = {
+	zh: "回复编号或选项文字；回复「取消」跳过。",
+	en: "Reply with a number or the option text; reply cancel to dismiss.",
+};
+const CONFIRM_HINT: Record<PeerLanguage, string> = {
+	zh: "回复「是」或「否」。",
+	en: "Reply yes or no.",
+};
+const INPUT_HINT: Record<PeerLanguage, string> = {
+	zh: "直接回复内容；回复「取消」跳过。",
+	en: "Reply with the text; reply cancel to skip.",
+};
+const EDITOR_HINT: Record<PeerLanguage, string> = {
+	zh: "把内容作为一条消息发回；回复「取消」取消。",
+	en: "Send the text as one message; reply cancel to cancel.",
+};
 
 /** Sent ahead of a re-prompt when a reply could not be interpreted. */
-export const RETRY_NOTICE =
-	"没有识别到有效回复，请重新回答。\nSorry, I didn't recognize that reply — please answer again.";
+export const RETRY_NOTICE = "Sorry, I didn't recognize that reply — please answer again.";
+const RETRY_ZH = "没有识别到有效回复，请重新回答。";
 
 const CANCEL_WORDS = new Set(["取消", "退出", "cancel", "quit", "exit"]);
 const YES_WORDS = new Set(["是", "y", "yes", "1", "确认", "确定", "行", "ok", "好", "对"]);
@@ -44,24 +54,29 @@ function lines(parts: Array<string | undefined>): string {
 }
 
 /** Render a dialog prompt as a WeChat message body, optionally after a retry. */
-export function formatPrompt(request: InteractionRequest, options: { retry?: boolean } = {}): string {
-	const body = promptBody(request);
-	return options.retry ? `${RETRY_NOTICE}\n\n${body}` : body;
+export function formatPrompt(
+	request: InteractionRequest,
+	options: { retry?: boolean; language?: PeerLanguage } = {},
+): string {
+	const language = options.language ?? "en";
+	const body = promptBody(request, language);
+	const retry = language === "zh" ? RETRY_ZH : RETRY_NOTICE;
+	return options.retry ? `${retry}\n\n${body}` : body;
 }
 
-function promptBody(request: InteractionRequest): string {
+function promptBody(request: InteractionRequest, language: PeerLanguage): string {
 	switch (request.kind) {
 		case "select": {
 			const options = (request.options ?? []).map((label, index) => `${index + 1}. ${label}`);
 			const hasOther = (request.options ?? []).includes(INTERACTION_OTHER_LABEL);
-			return lines([request.title, ...options, hasOther ? SELECT_OTHER_HINT : SELECT_CHOICE_HINT]);
+			return lines([request.title, ...options, hasOther ? SELECT_OTHER_HINT[language] : SELECT_CHOICE_HINT[language]]);
 		}
 		case "confirm":
-			return lines([request.title, request.message, CONFIRM_HINT]);
+			return lines([request.title, request.message, CONFIRM_HINT[language]]);
 		case "input":
-			return lines([request.title, request.placeholder, INPUT_HINT]);
+			return lines([request.title, request.placeholder, INPUT_HINT[language]]);
 		case "editor":
-			return lines([request.title, request.prefill, EDITOR_HINT]);
+			return lines([request.title, request.prefill, EDITOR_HINT[language]]);
 	}
 }
 

package/extensions/wechat/{remote-ui.ts → dialog/remote-ui.ts}

@@ -24,7 +24,7 @@ import {
 	type InteractionAnswer,
 	type InteractionChannel,
 	type InteractionRequest,
-} from "../../lib/interaction.ts";
+} from "../../../lib/interaction.ts";
 
 function valueOf(answer: InteractionAnswer): string | undefined {
 	return answer.kind === "value" ? answer.value : undefined;

package/extensions/wechat/index.ts

@@ -19,18 +19,18 @@ 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";
-import { createFetchRunner, WechatClient, type WechatClientOptions } from "./client.ts";
-import { registerCommands, type CommandDeps } from "./commands.ts";
+import { createFetchRunner, WechatClient, type WechatClientOptions } from "./transport/client.ts";
+import { registerCommands, type CommandDeps } from "./commands/commands.ts";
 import { messageOf } from "./errors.ts";
 import { loadWechatConfig } from "./config.ts";
-import { clearCredentials, primaryAccount, saveAccount, wechatDir } from "./credentials.ts";
-import { acquireLock, lockPath, readLock, refreshLock, releaseLock } from "./lock.ts";
-import { openPeerSession, type PeerSession, type PeerSessionOptions } from "./peer-session.ts";
-import { createPeerUIContext } from "./remote-ui.ts";
-import { peerKey } from "./format.ts";
-import { readPeerHistory } from "./history.ts";
-import { SLASH_COMMANDS } from "./slash.ts";
-import { readState, statePath, writeState } from "./state.ts";
+import { clearCredentials, primaryAccount, saveAccount, wechatDir } from "./state/credentials.ts";
+import { acquireLock, lockPath, readLock, refreshLock, releaseLock } from "./state/lock.ts";
+import { openPeerSession, type PeerSession, type PeerSessionOptions } from "./peer/peer-session.ts";
+import { createPeerUIContext } from "./dialog/remote-ui.ts";
+import { peerKey } from "./text/format.ts";
+import { readPeerHistory } from "./commands/history.ts";
+import { SLASH_COMMANDS } from "./commands/slash.ts";
+import { readState, statePath, writeState } from "./state/state.ts";
 import { registerTools } from "./tools.ts";
 
 /**

package/extensions/wechat/{admission.ts → peer/admission.ts}

@@ -8,8 +8,8 @@
  * budget is in memory; a reload starts a fresh hour.
  */
 
-import type { InboundItem } from "./types.ts";
-import { peerKey } from "./format.ts";
+import type { InboundItem } from "../types.ts";
+import { peerKey } from "../text/format.ts";
 
 /** A rolling-hour turn budget per peer. */
 export interface TurnBudget {

package/extensions/wechat/{peer-session.ts → peer/peer-session.ts}

@@ -32,8 +32,8 @@ import {
 	SessionManager,
 } from "@earendil-works/pi-coding-agent";
 import { join } from "node:path";
-import { WECHAT_CHANNEL_PROMPT } from "./channel.ts";
-import { peerKey } from "./format.ts";
+import { WECHAT_CHANNEL_PROMPT } from "../text/channel.ts";
+import { peerKey } from "../text/format.ts";
 
 /** The SDK pieces a peer session needs; injected so tests never load resources. */
 export interface PeerSessionSeams {