opencode-telegram-mirror 0.4.0 → 0.4.2

package/README.md

@@ -44,7 +44,7 @@ npm install -g opencode-telegram-mirror
    opencode-telegram-mirror .
    ```
 
-That's it! Your OpenCode sessions will now be mirrored to Telegram.
+That's it! Your OpenCode session will now be mirrored to Telegram.
 
 ## How it works
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-telegram-mirror",
-	"version": "0.4.0",
+	"version": "0.4.2",
 	"description": "Standalone bot that mirrors OpenCode sessions to Telegram topics",
 	"type": "module",
 	"main": "src/main.ts",

package/src/main.ts

@@ -98,6 +98,10 @@ interface BotState {
 	assistantMessageIds: Set<string>;
 	pendingParts: Map<string, Part[]>;
 	sentPartIds: Set<string>;
+	typingIndicators: Map<
+		string,
+		{ stop: () => void; timeout: ReturnType<typeof setTimeout> | null; mode: "idle" | "tool" }
+	>;
 }
 
 async function main() {
@@ -259,6 +263,7 @@ async function main() {
 		assistantMessageIds: new Set(),
 		pendingParts: new Map(),
 		sentPartIds: new Set(),
+		typingIndicators: new Map(),
 	}
 
 	if (initialThreadTitle && config.threadId) {
@@ -644,7 +649,7 @@ async function handleTelegramMessage(
 				directory: state.directory,
 			})
 			if (abortResult.data) {
-				await state.telegram.sendMessage("Interrupted.")
+				log("info", "Abort request sent", { sessionId: state.sessionId })
 			} else {
 				log("error", "Failed to abort session", {
 					sessionId: state.sessionId,
@@ -690,7 +695,7 @@ async function handleTelegramMessage(
 				directory: state.directory,
 			})
 			if (abortResult.data) {
-				await state.telegram.sendMessage("Interrupted.")
+				log("info", "Abort request sent", { sessionId: state.sessionId })
 			} else {
 				log("error", "Failed to abort session", {
 					sessionId: state.sessionId,
@@ -1014,16 +1019,36 @@ async function handleOpenCodeEvent(state: BotState, ev: OpenCodeEvent) {
 	const sessionId =
 		ev.properties?.sessionID ??
 		ev.properties?.info?.sessionID ??
-		ev.properties?.part?.sessionID
+		ev.properties?.part?.sessionID ??
+		ev.properties?.session?.id
 	const sessionTitle = ev.properties?.session?.title
 
 	// Log errors in full and send to Telegram
 	if (ev.type === "session.error") {
 		const errorMsg = JSON.stringify(ev.properties, null, 2)
+		const error = ev.properties?.error as
+			| { name?: string; data?: { message?: string } }
+			| undefined
+		const errorName = error?.name
+		const errorText = error?.data?.message
+		const isInterrupted =
+			errorName === "MessageAbortedError" || errorText === "The operation was aborted."
+
 		log("error", "OpenCode session error", {
 			sessionId,
 			error: ev.properties,
 		})
+
+		if (isInterrupted) {
+			const sendResult = await state.telegram.sendMessage("Interrupted.")
+			if (sendResult.status === "error") {
+				log("error", "Failed to send interrupt message", {
+					error: sendResult.error.message,
+				})
+			}
+			return
+		}
+
 		// Send error to Telegram for visibility
 		const sendResult = await state.telegram.sendMessage(
 			`OpenCode Error:\n${errorMsg.slice(0, 3500)}`
@@ -1076,6 +1101,12 @@ async function handleOpenCodeEvent(state: BotState, ev: OpenCodeEvent) {
 			const key = `${info.sessionID}:${info.id}`
 			state.assistantMessageIds.add(key)
 			log("debug", "Registered assistant message", { key })
+			const entry = state.typingIndicators.get(key)
+			if (entry && entry.mode === "tool") {
+				if (entry.timeout) clearTimeout(entry.timeout)
+				entry.stop()
+				state.typingIndicators.delete(key)
+			}
 		}
 	}
 
@@ -1093,6 +1124,39 @@ async function handleOpenCodeEvent(state: BotState, ev: OpenCodeEvent) {
 			return
 		}
 
+		const stopTypingIndicator = (targetKey: string) => {
+			const entry = state.typingIndicators.get(targetKey)
+			if (!entry) return
+			if (entry.timeout) clearTimeout(entry.timeout)
+			entry.stop()
+			state.typingIndicators.delete(targetKey)
+		}
+
+		const startTypingIndicator = (targetKey: string, mode: "idle" | "tool") => {
+			const existing = state.typingIndicators.get(targetKey)
+			if (existing && existing.mode === mode) return
+			if (existing) {
+				if (existing.timeout) clearTimeout(existing.timeout)
+				existing.stop()
+			}
+
+			const stop = state.telegram.startTyping(mode === "tool" ? 2000 : 4000)
+			state.typingIndicators.set(targetKey, { stop, timeout: null, mode })
+		}
+
+		const bumpTypingIndicator = (targetKey: string, mode: "idle" | "tool") => {
+			const existing = state.typingIndicators.get(targetKey)
+			if (!existing || existing.mode !== mode) {
+				startTypingIndicator(targetKey, mode)
+				return
+			}
+
+			if (existing.timeout) clearTimeout(existing.timeout)
+			existing.timeout = setTimeout(() => {
+				stopTypingIndicator(targetKey)
+			}, 12000)
+		}
+
 		log("debug", "Processing message part", {
 			key,
 			partType: part.type,
@@ -1106,12 +1170,11 @@ async function handleOpenCodeEvent(state: BotState, ev: OpenCodeEvent) {
 		state.pendingParts.set(key, existing)
 
 		if (part.type !== "step-finish") {
-			const typingResult = await state.telegram.sendTypingAction()
-			if (typingResult.status === "error") {
-				log("debug", "Typing action failed", {
-					error: typingResult.error.message,
-				})
-			}
+			const typingMode =
+				part.type === "tool" && (part.tool === "edit" || part.tool === "write")
+					? "tool"
+					: "idle"
+			bumpTypingIndicator(key, typingMode)
 		}
 
 		// Send tools/reasoning immediately (except edit/write tools - wait for completion to get diff data)
@@ -1139,6 +1202,7 @@ async function handleOpenCodeEvent(state: BotState, ev: OpenCodeEvent) {
 
 		// On step-finish, send remaining parts
 		if (part.type === "step-finish") {
+			stopTypingIndicator(key)
 			for (const p of existing) {
 				if (p.type === "step-start" || p.type === "step-finish") continue
 				if (state.sentPartIds.has(p.id)) continue
@@ -1241,6 +1305,24 @@ async function handleOpenCodeEvent(state: BotState, ev: OpenCodeEvent) {
 		}
 	}
 
+	if (ev.type === "message.updated") {
+		const info = ev.properties.info
+		if (info?.role === "assistant") {
+			const key = `${info.sessionID}:${info.id}`
+			const entry = state.typingIndicators.get(key)
+			if (entry && entry.mode === "tool") {
+				const stopTypingIndicator = (targetKey: string) => {
+					const existing = state.typingIndicators.get(targetKey)
+					if (!existing) return
+					if (existing.timeout) clearTimeout(existing.timeout)
+					existing.stop()
+					state.typingIndicators.delete(targetKey)
+				}
+				stopTypingIndicator(key)
+			}
+		}
+	}
+
 	const threadId = state.threadId ?? 0
 
 	if (ev.type === "question.asked") {