opencode-telegram-mirror 0.4.0 → 0.4.3

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.3",
 	"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,
@@ -831,11 +836,13 @@ async function handleTelegramMessage(
 	> = []
 
 	if (msg.photo && msg.photo.length > 0) {
+		const stopTyping = state.telegram.startTyping()
 		const bestPhoto = msg.photo[msg.photo.length - 1]
 		const dataUrlResult = await state.telegram.downloadFileAsDataUrl(
 			bestPhoto.file_id,
 			"image/jpeg"
 		)
+		stopTyping()
 		if (dataUrlResult.status === "ok") {
 			parts.push({
 				type: "file",
@@ -857,6 +864,8 @@ async function handleTelegramMessage(
 			return
 		}
 
+		const stopTyping = state.telegram.startTyping()
+
 		log("info", "Processing voice message", {
 			duration: msg.voice.duration,
 			fileId: msg.voice.file_id,
@@ -864,6 +873,7 @@ async function handleTelegramMessage(
 
 		const fileUrlResult = await state.telegram.getFileUrl(msg.voice.file_id)
 		if (fileUrlResult.status === "error") {
+			stopTyping()
 			log("error", "Failed to get voice file URL", {
 				error: fileUrlResult.error.message,
 			})
@@ -873,6 +883,7 @@ async function handleTelegramMessage(
 
 		const audioResponse = await fetch(fileUrlResult.value)
 		if (!audioResponse.ok) {
+			stopTyping()
 			log("error", "Failed to download voice file", { status: audioResponse.status })
 			await state.telegram.sendMessage("Failed to download voice message.")
 			return
@@ -880,6 +891,7 @@ async function handleTelegramMessage(
 
 		const audioBuffer = await audioResponse.arrayBuffer()
 		const transcriptionResult = await transcribeVoice(audioBuffer, log)
+		stopTyping()
 
 		if (transcriptionResult.status === "error") {
 			log("error", "Voice transcription failed", {
@@ -1014,16 +1026,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)}`
@@ -1046,6 +1078,23 @@ async function handleOpenCodeEvent(state: BotState, ev: OpenCodeEvent) {
 
 	if (!sessionId || sessionId !== state.sessionId) return
 
+	// Stop typing when session becomes idle
+	if (ev.type === "session.idle") {
+		for (const [key, entry] of state.typingIndicators) {
+			if (key.startsWith(`${sessionId}:`)) {
+				if (entry.timeout) clearTimeout(entry.timeout)
+				entry.stop()
+				state.typingIndicators.delete(key)
+			}
+		}
+		return
+	}
+
+	// Send typing action on every session event to keep indicator active during long operations
+	if (ev.type !== "session.error") {
+		state.telegram.sendTypingAction()
+	}
+
 	if (sessionTitle && state.threadId) {
 		const trimmedTitle = sessionTitle.trim()
 		const shouldUpdate = trimmedTitle && trimmedTitle !== state.threadTitle
@@ -1076,6 +1125,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 +1148,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" ? 1500 : 2500)
+			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 +1194,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 +1226,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 +1329,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") {

package/src/telegram.ts

@@ -505,11 +505,12 @@ export class TelegramClient {
    * Send typing indicator to show the bot is working
    * Returns a stop function to cancel the typing indicator
    */
-  startTyping(intervalMs = 4000): () => void {
+  startTyping(intervalMs = 2500): () => void {
     // Send immediately
     this.sendTypingAction()
 
-    // Telegram typing indicator lasts ~5 seconds, so refresh every 4 seconds
+    // Telegram typing indicator lasts ~5 seconds, so refresh every 2.5 seconds by default
+    // to ensure continuous typing even with network delays
     const interval = setInterval(() => {
       this.sendTypingAction()
     }, intervalMs)