@shakudo/opencode-mattermost-control 0.3.45

package/.opencode/plugin/mattermost-control/event-handlers/permission.ts

@@ -0,0 +1,34 @@
+/**
+ * Permission event handler
+ */
+
+import { PluginState } from "../state.js";
+import { handleMonitorAlert } from "../../../../src/monitor-service.js";
+import { log } from "../../../../src/logger.js";
+
+function isScheduledTaskSession(sessionId: string): boolean {
+  const scheduler = PluginState.schedulerService;
+  return scheduler?.isRunningScheduledTask(sessionId) ?? false;
+}
+
+export async function handlePermissionAsked(event: any): Promise<void> {
+  const eventSessionId = event.properties?.sessionID;
+  
+  // Skip permission handling for scheduled task sessions - they can't ask for permissions via DM
+  if (eventSessionId && isScheduledTaskSession(eventSessionId)) {
+    log.debug(`[ScheduledTask] Suppressing permission.asked for scheduled task session ${eventSessionId.substring(0, 8)}`);
+    return;
+  }
+  
+  log.debug(`[Monitor] permission.asked event: sessionId=${eventSessionId}`);
+  const description = event.properties?.description || "Permission requested";
+  const activeSessionIds = Array.from(PluginState.activeResponseContexts.keys());
+  await handleMonitorAlert(eventSessionId, "permission.asked", description, activeSessionIds[0]);
+  
+  if (eventSessionId && PluginState.isConnected) {
+    const ctx = PluginState.activeResponseContexts.get(eventSessionId);
+    if (ctx?.streamCtx.statusIndicator) {
+      await ctx.streamCtx.statusIndicator.setWaiting("permission", description);
+    }
+  }
+}

package/.opencode/plugin/mattermost-control/event-handlers/question.ts

@@ -0,0 +1,92 @@
+/**
+ * Question event handler - handles question.asked events from OpenCode
+ */
+
+import { PluginState } from "../state.js";
+import { formatFullResponse } from "../formatters.js";
+import type { QuestionRequest } from "../../../../src/question-handler.js";
+import { log } from "../../../../src/logger.js";
+
+function isScheduledTaskSession(sessionId: string): boolean {
+  const scheduler = PluginState.schedulerService;
+  return scheduler?.isRunningScheduledTask(sessionId) ?? false;
+}
+
+export async function handleQuestionAsked(event: any): Promise<void> {
+  const { questionHandler, threadMappingStore, streamer, isConnected } = PluginState;
+  
+  if (!questionHandler || !isConnected) return;
+  
+  const props = event.properties;
+  const eventSessionId = props?.sessionID;
+  
+  // Skip question handling for scheduled task sessions - they can't ask questions via DM
+  if (eventSessionId && isScheduledTaskSession(eventSessionId)) {
+    log.debug(`[ScheduledTask] Suppressing question.asked for scheduled task session ${eventSessionId.substring(0, 8)}`);
+    return;
+  }
+  
+  log.info(`[QuestionHandler] question.asked event: sessionId=${eventSessionId}, requestId=${props?.id}`);
+  
+  if (!eventSessionId || !props?.id || !props?.questions) return;
+  
+  // First try thread mapping (per-session thread mode)
+  const mapping = threadMappingStore?.getBySessionId(eventSessionId);
+  let targetChannelId: string | undefined;
+  let targetThreadId: string | undefined;
+  
+  if (mapping && mapping.status === "active") {
+    targetChannelId = mapping.channelId || mapping.dmChannelId;
+    targetThreadId = mapping.threadRootPostId;
+    log.debug(`[QuestionHandler] Using thread mapping: channel=${targetChannelId}, thread=${targetThreadId}`);
+  } else {
+    // Fall back to active response context (main DM thread mode)
+    const ctx = PluginState.activeResponseContexts.get(eventSessionId);
+    if (ctx && ctx.threadRootPostId) {
+      targetChannelId = ctx.streamCtx?.channelId || ctx.mmSession?.dmChannelId;
+      targetThreadId = ctx.threadRootPostId;
+      log.debug(`[QuestionHandler] Using active response context: channel=${targetChannelId}, thread=${targetThreadId}`);
+    }
+  }
+  
+  if (!targetChannelId || !targetThreadId) {
+    log.debug(`[QuestionHandler] No active thread context for session ${eventSessionId}`);
+    return;
+  }
+  
+  const questionRequest: QuestionRequest = {
+    id: props.id,
+    sessionID: eventSessionId,
+    questions: props.questions,
+  };
+  
+  try {
+    const ctx = PluginState.activeResponseContexts.get(eventSessionId);
+    if (ctx && streamer) {
+      const oldContent = formatFullResponse(ctx);
+      const newStreamCtx = await streamer.recreateStreamAtBottom(ctx.streamCtx, oldContent);
+      ctx.streamCtx = newStreamCtx;
+      log.debug(`[QuestionHandler] Recreated stream before question, new postId=${newStreamCtx.postId}`);
+    }
+    
+    await questionHandler.handleQuestionAsked(
+      questionRequest,
+      targetChannelId,
+      targetThreadId
+    );
+    log.info(`[QuestionHandler] Posted question ${props.id} to thread ${targetThreadId}`);
+    
+    // Don't recreate stream after question - let the question be the last visible post
+    // The user needs to see and answer the question without it being buried
+    // The stream will resume when the question is answered
+    if (ctx && ctx.streamCtx.statusIndicator) {
+      const firstQuestion = props.questions[0];
+      await ctx.streamCtx.statusIndicator.setWaiting(
+        "question", 
+        firstQuestion?.question || "Waiting for your answer..."
+      );
+    }
+  } catch (e) {
+    log.error(`[QuestionHandler] Failed to post question:`, e);
+  }
+}

package/.opencode/plugin/mattermost-control/event-handlers/session.ts

@@ -0,0 +1,100 @@
+/**
+ * Session event handlers - handles session.idle and session.status events
+ */
+
+import { PluginState } from "../state.js";
+import { formatFullResponse } from "../formatters.js";
+import { stopActiveToolTimer, stopResponseTimer } from "../timers.js";
+import { handleMonitorAlert } from "../../../../src/monitor-service.js";
+import { log } from "../../../../src/logger.js";
+
+function isScheduledTaskSession(sessionId: string): boolean {
+  const scheduler = PluginState.schedulerService;
+  return scheduler?.isRunningScheduledTask(sessionId) ?? false;
+}
+
+export async function handleSessionIdle(event: any): Promise<void> {
+  const eventSessionId = event.properties?.sessionID;
+  
+  // Handle monitor alerts (skip for scheduled tasks - they don't need idle alerts)
+  log.debug(`[Monitor] session.idle event: sessionId=${eventSessionId}`);
+  if (eventSessionId && !isScheduledTaskSession(eventSessionId)) {
+    const activeSessionIds = Array.from(PluginState.activeResponseContexts.keys());
+    await handleMonitorAlert(eventSessionId, "session.idle", undefined, activeSessionIds[0]);
+  }
+  
+  // Handle stream finalization
+  const { streamer, notifications, isConnected } = PluginState;
+  if (!isConnected || !streamer || !notifications) return;
+  
+  if (!eventSessionId) return;
+  
+  // Skip stream finalization for scheduled task sessions
+  if (isScheduledTaskSession(eventSessionId)) {
+    log.debug(`[ScheduledTask] Suppressing session.idle finalization for scheduled task session ${eventSessionId.substring(0, 8)}`);
+    return;
+  }
+  
+  const ctx = PluginState.activeResponseContexts.get(eventSessionId);
+  if (!ctx) return;
+  
+  // v0.2.70 fix: Don't finalize if we're awaiting continuation after compaction
+  if (ctx.awaitingContinuation) {
+    log.info(`[Compaction] Session ${eventSessionId.substring(0, 8)} idle but awaitingContinuation=true, skipping finalization`);
+    return;
+  }
+  if (ctx.inCompactionSummary) {
+    log.info(`[Compaction] Session ${eventSessionId.substring(0, 8)} idle but inCompactionSummary=true, skipping finalization`);
+    return;
+  }
+  
+  log.info(`[MessageParts] Session ${eventSessionId.substring(0, 8)} completed: textParts=${ctx.textPartCount || 0}, reasoningParts=${ctx.reasoningPartCount || 0}, responseLen=${ctx.responseBuffer.length}, thinkingLen=${ctx.thinkingBuffer.length}, tools=${ctx.toolCalls.length}, compactions=${ctx.compactionCount}, todos=${ctx.todos.length}, cost=$${(ctx.cost.sessionTotal + ctx.cost.currentMessage).toFixed(4)}`);
+  
+  try {
+    stopActiveToolTimer(eventSessionId);
+    stopResponseTimer(eventSessionId);
+    
+    ctx.streamCtx.buffer = formatFullResponse(ctx);
+    await streamer.endStream(ctx.streamCtx);
+    await notifications.notifyCompletion(ctx.mmSession, "Response complete", ctx.streamCtx.threadRootPostId);
+    ctx.mmSession.isProcessing = false;
+  } catch (e) {
+    log.error("Error finalizing stream:", e);
+  }
+  PluginState.activeResponseContexts.delete(eventSessionId);
+}
+
+export async function handleSessionStatus(event: any): Promise<void> {
+  const eventSessionId = event.properties?.sessionID;
+  if (!eventSessionId || !PluginState.isConnected) return;
+  
+  // Skip status updates for scheduled task sessions
+  if (isScheduledTaskSession(eventSessionId)) {
+    log.debug(`[ScheduledTask] Suppressing session.status for scheduled task session ${eventSessionId.substring(0, 8)}`);
+    return;
+  }
+  
+  const status = event.properties?.status as { type: string; attempt?: number; maxAttempts?: number; error?: string } | undefined;
+  const ctx = PluginState.activeResponseContexts.get(eventSessionId);
+  
+  if (!ctx?.streamCtx.statusIndicator || !status) return;
+  
+  log.debug(`[StatusEvent] Session ${eventSessionId.substring(0, 8)} status: ${status.type}`);
+  
+  switch (status.type) {
+    case "busy":
+      await ctx.streamCtx.statusIndicator.setProcessing();
+      break;
+    case "retry":
+      await ctx.streamCtx.statusIndicator.setRetrying(
+        status.attempt || 1,
+        status.maxAttempts || 3,
+        status.error || "Transient error",
+        5000
+      );
+      break;
+    case "idle":
+      // No action needed
+      break;
+  }
+}

package/.opencode/plugin/mattermost-control/event-handlers/todo.ts

@@ -0,0 +1,33 @@
+/**
+ * Todo event handler - handles todo.updated events
+ */
+
+import { PluginState } from "../state.js";
+import { updateResponseStream } from "../timers.js";
+import { log } from "../../../../src/logger.js";
+
+function isScheduledTaskSession(sessionId: string): boolean {
+  const scheduler = PluginState.schedulerService;
+  return scheduler?.isRunningScheduledTask(sessionId) ?? false;
+}
+
+export async function handleTodoUpdated(event: any): Promise<void> {
+  const sessionId = event.properties?.sessionID;
+  const todos = event.properties?.todos;
+  
+  if (!sessionId || !todos) return;
+  
+  if (isScheduledTaskSession(sessionId)) {
+    log.debug(`[ScheduledTask] Suppressing todo.updated for scheduled task session ${sessionId.substring(0, 8)}`);
+    return;
+  }
+  
+  const completed = todos.filter((t: any) => t.status === "completed").length;
+  log.info(`[TodoEvent] Session ${sessionId.substring(0, 8)}: ${completed}/${todos.length} complete`);
+  
+  const ctx = PluginState.activeResponseContexts.get(sessionId);
+  if (ctx) {
+    ctx.todos = todos;
+    await updateResponseStream(sessionId);
+  }
+}

package/.opencode/plugin/mattermost-control/event-handlers/tool.ts

@@ -0,0 +1,76 @@
+/**
+ * Tool execution event handlers - handles tool.execute.before and tool.execute.after
+ */
+
+import { PluginState } from "../state.js";
+import { startActiveToolTimer, stopActiveToolTimer, updateResponseStream } from "../timers.js";
+import { handleMonitorAlert } from "../../../../src/monitor-service.js";
+import { log } from "../../../../src/logger.js";
+
+function isScheduledTaskSession(sessionId: string): boolean {
+  const scheduler = PluginState.schedulerService;
+  return scheduler?.isRunningScheduledTask(sessionId) ?? false;
+}
+
+export async function handleToolExecuteBefore(input: any): Promise<void> {
+  if (!PluginState.isConnected) return;
+  
+  const toolSessionId = input.sessionID || input.session?.id;
+  if (!toolSessionId) return;
+  
+  if (isScheduledTaskSession(toolSessionId)) {
+    log.debug(`[ScheduledTask] Suppressing tool.execute.before for scheduled task session ${toolSessionId.substring(0, 8)}`);
+    return;
+  }
+  
+  const ctx = PluginState.activeResponseContexts.get(toolSessionId);
+  if (!ctx) return;
+  
+  ctx.activeTool = {
+    name: input.tool,
+    startTime: Date.now(),
+  };
+  
+  startActiveToolTimer(toolSessionId);
+  await updateResponseStream(toolSessionId);
+}
+
+export async function handleToolExecuteAfter(input: any): Promise<void> {
+  const toolSessionId = input.sessionID || input.session?.id;
+
+  // Skip all tool.execute.after processing for scheduled task sessions
+  if (toolSessionId && isScheduledTaskSession(toolSessionId)) {
+    log.debug(`[ScheduledTask] Suppressing tool.execute.after for scheduled task session ${toolSessionId.substring(0, 8)}`);
+    return;
+  }
+
+  // Handle question tool specially for monitoring
+  if (input.tool === "question" && toolSessionId) {
+    const questionText = input.args?.questions?.[0]?.question || "Question awaiting answer";
+    const activeSessionIds = Array.from(PluginState.activeResponseContexts.keys());
+    await handleMonitorAlert(toolSessionId, "question", questionText, activeSessionIds[0]);
+    
+    if (PluginState.isConnected) {
+      const ctx = PluginState.activeResponseContexts.get(toolSessionId);
+      if (ctx?.streamCtx.statusIndicator) {
+        await ctx.streamCtx.statusIndicator.setWaiting("question", questionText);
+      }
+    }
+  }
+
+  if (!PluginState.isConnected || !toolSessionId) return;
+  
+  const ctx = PluginState.activeResponseContexts.get(toolSessionId);
+  if (ctx) {
+    if (ctx.activeTool) {
+      ctx.toolCalls.push(ctx.activeTool.name);
+      if (ctx.activeTool.name === "bash") {
+        ctx.shellOutput = "";
+        ctx.shellOutputLastUpdate = 0;
+      }
+      ctx.activeTool = null;
+      stopActiveToolTimer(toolSessionId);
+    }
+    await updateResponseStream(toolSessionId);
+  }
+}

package/.opencode/plugin/mattermost-control/formatters.ts

@@ -0,0 +1,202 @@
+import type { ResponseContext, TodoItem, ActiveTool, CostInfo } from "./types.js";
+
+export const RESPONSE_UPDATE_INTERVAL_MS = 1000;
+export const MAX_SHELL_OUTPUT_LINES = 15;
+export const BASH_HEARTBEAT_THRESHOLD_MS = 10_000;
+export const THINKING_LINE_LIMIT = 500;
+
+const TODO_STATUS_ICONS: Record<string, string> = {
+  completed: "✅",
+  in_progress: "🔄",
+  pending: "⏳",
+  cancelled: "❌",
+};
+
+export function formatElapsedTime(ms: number): string {
+  const seconds = Math.floor(ms / 1000);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  return `${minutes}m ${remainingSeconds}s`;
+}
+
+export function formatTokenCount(tokens: number): string {
+  if (tokens >= 1_000_000) return `${(tokens / 1_000_000).toFixed(1)}M`;
+  if (tokens >= 1_000) return `${(tokens / 1_000).toFixed(0)}K`;
+  return `${tokens}`;
+}
+
+export function formatCost(cost: number): string {
+  if (cost >= 1) return `$${cost.toFixed(2)}`;
+  if (cost >= 0.01) return `$${cost.toFixed(2)}`;
+  if (cost >= 0.001) return `$${cost.toFixed(3)}`;
+  return `$${cost.toFixed(4)}`;
+}
+
+export function formatCostStatus(cost: CostInfo): string {
+  const totalTokens = cost.tokens.input + cost.tokens.output + cost.tokens.reasoning;
+  if (cost.sessionTotal === 0 && cost.currentMessage === 0 && totalTokens === 0) return "";
+  
+  const sessionCost = formatCost(cost.sessionTotal + cost.currentMessage);
+  const msgCost = cost.currentMessage > 0 ? ` (+${formatCost(cost.currentMessage)})` : "";
+  const tokenStr = totalTokens > 0 ? ` | ${formatTokenCount(totalTokens)} tok` : "";
+  
+  return `💰 ${sessionCost}${msgCost}${tokenStr}`;
+}
+
+export function formatToolStatus(
+  toolCalls: string[],
+  activeTool: ActiveTool | null,
+  compactionCount: number = 0,
+  cost?: CostInfo,
+  responseStartTime?: number,
+  awaitingContinuation?: boolean
+): string {
+  const parts: string[] = [];
+  
+  if (responseStartTime) {
+    const elapsed = formatElapsedTime(Date.now() - responseStartTime);
+    parts.push(`💻 Processing (${elapsed})`);
+  }
+  
+  if (toolCalls.length > 0) {
+    const toolCounts = toolCalls.reduce((acc, tool) => {
+      acc[tool] = (acc[tool] || 0) + 1;
+      return acc;
+    }, {} as Record<string, number>);
+    
+    const summary = Object.entries(toolCounts)
+      .map(([tool, count]) => count > 1 ? `\`${tool}\` ×${count}` : `\`${tool}\``)
+      .join(", ");
+    parts.push(`✅ ${summary}`);
+  }
+  
+  if (compactionCount > 0) {
+    parts.push(compactionCount > 1 ? `📦 Compacted ×${compactionCount}` : `📦 Compacted`);
+  }
+  
+  if (awaitingContinuation) {
+    parts.push(`⏳ Continuing...`);
+  }
+  
+  if (cost && (cost.sessionTotal > 0 || cost.currentMessage > 0 || cost.tokens.input > 0)) {
+    parts.push(formatCostStatus(cost));
+  }
+  
+  if (activeTool) {
+    const elapsed = formatElapsedTime(Date.now() - activeTool.startTime);
+    parts.push(`🔧 \`${activeTool.name}\` (${elapsed})...`);
+  }
+  
+  return parts.join(" | ");
+}
+
+export function formatShellOutput(
+  shellOutput: string,
+  lastOutputTime?: number,
+  toolStartTime?: number
+): string {
+  if (!shellOutput) return "";
+  
+  const lines = shellOutput.trim().split('\n');
+  const totalLines = lines.length;
+  
+  let output: string;
+  if (totalLines <= MAX_SHELL_OUTPUT_LINES) {
+    output = shellOutput.trim();
+  } else {
+    const tailLines = lines.slice(-MAX_SHELL_OUTPUT_LINES);
+    output = `... (${totalLines - MAX_SHELL_OUTPUT_LINES} lines hidden)\n${tailLines.join('\n')}`;
+  }
+  
+  if (lastOutputTime && toolStartTime) {
+    const timeSinceLastOutput = Date.now() - lastOutputTime;
+    const totalRunTime = Date.now() - toolStartTime;
+    
+    if (timeSinceLastOutput >= BASH_HEARTBEAT_THRESHOLD_MS) {
+      const lastOutputAgo = formatElapsedTime(timeSinceLastOutput);
+      const runningFor = formatElapsedTime(totalRunTime);
+      output += `\n\n⏳ Still running (${runningFor} total, last output ${lastOutputAgo} ago)`;
+    }
+  }
+  
+  return output;
+}
+
+export function formatTodoStatus(todos: TodoItem[]): string {
+  if (!todos || todos.length === 0) return "";
+  
+  const completed = todos.filter(t => t.status === "completed").length;
+  const total = todos.length;
+  
+  const sortedTodos = [...todos].sort((a, b) => {
+    const statusOrder: Record<string, number> = {
+      in_progress: 0,
+      pending: 1,
+      completed: 2,
+      cancelled: 3,
+    };
+    return (statusOrder[a.status] ?? 99) - (statusOrder[b.status] ?? 99);
+  });
+  
+  let output = `📋 **Tasks** (${completed}/${total})\n`;
+  
+  for (const todo of sortedTodos) {
+    const icon = TODO_STATUS_ICONS[todo.status] || "❓";
+    if (todo.status === "completed" || todo.status === "cancelled") {
+      output += `${icon} ~~${todo.content}~~\n`;
+    } else {
+      output += `${icon} ${todo.content}\n`;
+    }
+  }
+  
+  return output;
+}
+
+export function formatFullResponse(ctx: ResponseContext): string {
+  const toolStatus = formatToolStatus(
+    ctx.toolCalls,
+    ctx.activeTool,
+    ctx.compactionCount,
+    ctx.cost,
+    ctx.responseStartTime,
+    ctx.awaitingContinuation
+  );
+  const todoStatus = formatTodoStatus(ctx.todos);
+  const thinkingPreview = ctx.thinkingBuffer.length > THINKING_LINE_LIMIT 
+    ? ctx.thinkingBuffer.slice(-THINKING_LINE_LIMIT) + "..." 
+    : ctx.thinkingBuffer;
+  
+  let output = "";
+  
+  if (toolStatus) {
+    output += toolStatus + "\n\n";
+  }
+  
+  if (todoStatus) {
+    output += todoStatus + "\n";
+  }
+  
+  if (ctx.shellOutput && ctx.activeTool?.name === "bash") {
+    const formattedShell = formatShellOutput(
+      ctx.shellOutput, 
+      ctx.shellOutputLastUpdate,
+      ctx.activeTool.startTime
+    );
+    output += "```\n" + formattedShell + "\n```\n\n";
+  }
+  
+  if (ctx.responseBuffer) {
+    const needsSeparator = toolStatus || todoStatus || ctx.shellOutput;
+    if (needsSeparator) {
+      output += "---\n\n";
+    }
+    output += ctx.responseBuffer;
+  }
+  
+  if (ctx.thinkingBuffer) {
+    output += `\n\n---\n:brain: **Thinking:**\n> ${thinkingPreview.split('\n').join('\n> ')}`;
+  }
+  
+  return output;
+}