@shakudo/opencode-mattermost-control 0.3.45

package/src/models/routing.ts

@@ -0,0 +1,50 @@
+import type { ParsedCommand } from "../message-router.js";
+
+export interface ThreadPromptRoute {
+  type: "thread_prompt";
+  sessionId: string;
+  threadRootPostId: string;
+  promptText: string;
+  fileIds?: string[];
+}
+
+export interface MainDmCommandRoute {
+  type: "main_dm_command";
+  command: ParsedCommand;
+}
+
+export interface MainDmPromptRoute {
+  type: "main_dm_prompt";
+  errorMessage: string;
+  suggestedAction: string;
+}
+
+export interface UnknownThreadRoute {
+  type: "unknown_thread";
+  threadRootPostId: string;
+  errorMessage: string;
+}
+
+export interface EndedSessionRoute {
+  type: "ended_session";
+  sessionId: string;
+  threadRootPostId: string;
+  errorMessage: string;
+}
+
+export interface MergedSessionRoute {
+  type: "merged_session";
+  sessionId: string;
+  threadRootPostId: string;
+  mergedInto: string;
+  errorMessage: string;
+  redirectLink?: string;
+}
+
+export type InboundRouteResult =
+  | ThreadPromptRoute
+  | MainDmCommandRoute
+  | MainDmPromptRoute
+  | UnknownThreadRoute
+  | EndedSessionRoute
+  | MergedSessionRoute;

package/src/models/thread-mapping.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+
+export const ModelSelectionSchema = z.object({
+  providerID: z.string().min(1),
+  modelID: z.string().min(1),
+  displayName: z.string().optional(),
+});
+
+export type ModelSelection = z.infer<typeof ModelSelectionSchema>;
+
+export const ThreadSessionMappingSchema = z.object({
+  sessionId: z.string().min(1),
+  threadRootPostId: z.string().min(1),
+  shortId: z.string().min(6).max(10),
+  mattermostUserId: z.string().min(1),
+  dmChannelId: z.string().min(1),
+  channelId: z.string().min(1).optional(),
+  projectName: z.string().min(1),
+  directory: z.string().min(1),
+  sessionTitle: z.string().optional(),
+  status: z.enum(["active", "ended", "disconnected", "orphaned", "merged"]),
+  createdAt: z.string().datetime(),
+  lastActivityAt: z.string().datetime(),
+  endedAt: z.string().datetime().optional(),
+  model: ModelSelectionSchema.optional(),
+  pendingModelSelection: z.boolean().optional(),
+  approvedUsers: z.array(z.string()).optional(),
+  approveAllUsers: z.boolean().optional(),
+  approveNextMessage: z.boolean().optional(),
+  mergedInto: z.string().optional(),
+  mergedAt: z.string().datetime().optional(),
+});
+
+export const ThreadMappingFileSchema = z.object({
+  version: z.literal(1),
+  mappings: z.array(ThreadSessionMappingSchema),
+  lastModified: z.string().datetime(),
+});
+
+export type ThreadMappingFileV1 = z.infer<typeof ThreadMappingFileSchema>;

package/src/monitor-service.ts

@@ -0,0 +1,222 @@
+/**
+ * Monitor Service for Mattermost Alerts
+ * 
+ * Enables ephemeral monitoring of OpenCode sessions. When a monitored session
+ * triggers an event (permission request, idle, question), sends a one-time
+ * DM alert to the specified Mattermost user.
+ */
+import { MattermostClient } from "./clients/mattermost-client.js";
+import { loadConfig, type MattermostConfig } from "./config.js";
+import { log } from "./logger.js";
+
+export interface MonitoredSession {
+  sessionId: string;
+  shortId: string;
+  mattermostUserId: string;
+  mattermostUsername: string;
+  projectName: string;
+  sessionTitle?: string;
+  directory: string;
+  registeredAt: Date;
+  persistent: boolean;
+}
+
+/**
+ * Alert types that trigger notifications
+ */
+export type AlertType = "permission.asked" | "session.idle" | "question";
+
+/**
+ * Alert context passed to formatAlertMessage
+ */
+export interface AlertContext {
+  type: AlertType;
+  session: MonitoredSession;
+  /** Additional details about what's waiting (e.g., permission description) */
+  details?: string;
+}
+
+/**
+ * In-memory registry of monitored sessions.
+ * Key: sessionId (full), Value: MonitoredSession
+ */
+class MonitorServiceImpl {
+  private monitoredSessions: Map<string, MonitoredSession> = new Map();
+
+  /**
+   * Register a session for monitoring
+   */
+  register(session: MonitoredSession): void {
+    this.monitoredSessions.set(session.sessionId, session);
+    log.info(`[Monitor] Registered session ${session.shortId} (${session.projectName}) for user @${session.mattermostUsername} [fullId=${session.sessionId}]`);
+  }
+
+  /**
+   * Unregister a session from monitoring
+   */
+  unregister(sessionId: string): boolean {
+    const session = this.monitoredSessions.get(sessionId);
+    if (session) {
+      this.monitoredSessions.delete(sessionId);
+      log.info(`[Monitor] Unregistered session ${session.shortId}`);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Check if a session is being monitored
+   */
+  isMonitored(sessionId: string): boolean {
+    return this.monitoredSessions.has(sessionId);
+  }
+
+  /**
+   * Get a monitored session by ID
+   */
+  get(sessionId: string): MonitoredSession | undefined {
+    return this.monitoredSessions.get(sessionId);
+  }
+
+  /**
+   * Get all monitored sessions
+   */
+  getAll(): MonitoredSession[] {
+    return Array.from(this.monitoredSessions.values());
+  }
+
+  /**
+   * Clear all monitored sessions
+   */
+  clear(): void {
+    this.monitoredSessions.clear();
+    log.info("[Monitor] Cleared all monitored sessions");
+  }
+
+  /**
+   * Get count of monitored sessions
+   */
+  count(): number {
+    return this.monitoredSessions.size;
+  }
+}
+
+export const MonitorService = new MonitorServiceImpl();
+
+/**
+ * Format an alert message for Mattermost
+ */
+export function formatAlertMessage(context: AlertContext): string {
+  const { type, session, details } = context;
+
+  const header = `:bell: **OpenCode Session Alert**`;
+  const projectLine = `**Project:** ${session.projectName}`;
+  const sessionLine = session.sessionTitle 
+    ? `**Session:** \`${session.shortId}\` - ${session.sessionTitle}`
+    : `**Session:** \`${session.shortId}\``;
+  const directoryLine = `**Directory:** \`${session.directory}\``;
+
+  let alertTypeText: string;
+  let icon: string;
+
+  switch (type) {
+    case "permission.asked":
+      icon = ":lock:";
+      alertTypeText = "Permission requested";
+      break;
+    case "session.idle":
+      icon = ":hourglass:";
+      alertTypeText = "Session is idle (waiting for input)";
+      break;
+    case "question":
+      icon = ":question:";
+      alertTypeText = "Question awaiting answer";
+      break;
+    default:
+      icon = ":bell:";
+      alertTypeText = "Session needs attention";
+  }
+
+  const alertLine = `${icon} **Alert:** ${alertTypeText}`;
+  const detailsLine = details ? `**Details:** ${details}` : "";
+  const actionLine = `\n_Use \`!use ${session.shortId}\` in DM to connect to this session._`;
+
+  const parts = [header, "", projectLine, sessionLine, directoryLine, "", alertLine];
+  if (detailsLine) parts.push(detailsLine);
+  parts.push(actionLine);
+
+  return parts.join("\n");
+}
+
+/**
+ * Send an ephemeral alert to a Mattermost user.
+ * Creates a new MattermostClient, sends the DM, then discards the client.
+ * 
+ * @param mattermostUserId - The Mattermost user ID to send the alert to
+ * @param message - The formatted message to send
+ * @returns true if sent successfully, false otherwise
+ */
+export async function sendEphemeralAlert(
+  mattermostUserId: string,
+  message: string
+): Promise<boolean> {
+  const config = loadConfig();
+
+  if (!config.mattermost.token) {
+    log.error("[Monitor] Cannot send alert: MATTERMOST_TOKEN not configured");
+    return false;
+  }
+
+  if (config.mattermost.baseUrl.includes("your-mattermost-instance.example.com")) {
+    log.error("[Monitor] Cannot send alert: MATTERMOST_URL not configured");
+    return false;
+  }
+
+  let client: MattermostClient | null = null;
+
+  try {
+    client = new MattermostClient(config.mattermost);
+    const dmChannel = await client.createDirectChannel(mattermostUserId);
+    await client.createPost(dmChannel.id, message);
+
+    log.info(`[Monitor] Sent ephemeral alert to user ${mattermostUserId}`);
+    return true;
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    log.error(`[Monitor] Failed to send ephemeral alert: ${errorMsg}`);
+    return false;
+  }
+}
+
+export async function handleMonitorAlert(
+  sessionId: string,
+  alertType: AlertType,
+  details?: string,
+  connectedSessionId?: string
+): Promise<boolean> {
+  if (connectedSessionId && sessionId === connectedSessionId) {
+    log.debug(`[Monitor] Skipping alert for connected session ${sessionId.slice(0, 6)}`);
+    return false;
+  }
+
+  const monitoredSession = MonitorService.get(sessionId);
+  if (!monitoredSession) {
+    return false;
+  }
+
+  log.info(`[Monitor] Handling ${alertType} alert for session ${monitoredSession.shortId} (persistent: ${monitoredSession.persistent})`);
+
+  const message = formatAlertMessage({
+    type: alertType,
+    session: monitoredSession,
+    details,
+  });
+
+  const sent = await sendEphemeralAlert(monitoredSession.mattermostUserId, message);
+
+  if (sent && !monitoredSession.persistent) {
+    MonitorService.unregister(sessionId);
+  }
+
+  return sent;
+}

package/src/notification-service.ts

@@ -0,0 +1,118 @@
+import type { MattermostClient } from "./clients/mattermost-client.js";
+import type { NotificationsConfig } from "./config.js";
+import type { UserSession, PermissionRequest } from "./session-manager.js";
+import { log } from "./logger.js";
+
+export type StatusType = "thinking" | "tool_execution" | "waiting" | "idle";
+
+export interface StatusUpdate {
+  type: StatusType;
+  details?: string;
+}
+
+export class NotificationService {
+  private mmClient: MattermostClient;
+  private config: NotificationsConfig;
+
+  constructor(mmClient: MattermostClient, config: NotificationsConfig) {
+    this.mmClient = mmClient;
+    this.config = config;
+  }
+
+  async notifyCompletion(session: UserSession, summary: string, threadRootPostId?: string): Promise<void> {
+    if (!this.config.onCompletion) return;
+
+    const message = `:white_check_mark: **Task Completed**\n\n> ${summary}`;
+
+    try {
+      await this.mmClient.createPost(session.dmChannelId, message, threadRootPostId);
+    } catch (error) {
+      log.error("[NotificationService] Failed to send completion notification:", error);
+    }
+  }
+
+  async notifyPermissionRequest(session: UserSession, request: PermissionRequest): Promise<void> {
+    if (!this.config.onPermissionRequest) return;
+
+    const riskEmoji = {
+      low: ":large_blue_circle:",
+      medium: ":warning:",
+      high: ":red_circle:",
+    }[request.risk];
+
+    const argsDisplay = JSON.stringify(request.args, null, 2);
+    const message = `:warning: **Permission Required**
+
+OpenCode wants to execute:
+\`\`\`
+${request.tool}(${argsDisplay})
+\`\`\`
+
+**Risk Level**: ${request.risk} ${riskEmoji}
+**Description**: ${request.description}
+
+React to respond:
+- :white_check_mark: Approve
+- :x: Deny`;
+
+    try {
+      const post = await this.mmClient.createPost(session.dmChannelId, message);
+      session.pendingPermission = request;
+      session.currentResponsePostId = post.id;
+    } catch (error) {
+      log.error("[NotificationService] Failed to send permission request:", error);
+    }
+  }
+
+  async notifyError(session: UserSession, error: Error): Promise<void> {
+    if (!this.config.onError) return;
+
+    const message = `:x: **Error Occurred**
+
+\`\`\`
+${error.message}
+\`\`\`
+
+React :arrows_counterclockwise: to retry or send a new message.`;
+
+    try {
+      await this.mmClient.createPost(session.dmChannelId, message);
+    } catch (err) {
+      log.error("[NotificationService] Failed to send error notification:", err);
+    }
+  }
+
+  async notifyStatus(session: UserSession, status: StatusUpdate): Promise<void> {
+    if (!this.config.onStatusUpdate) return;
+
+    const statusEmoji = {
+      thinking: ":thought_balloon:",
+      tool_execution: ":hammer_and_wrench:",
+      waiting: ":hourglass_flowing_sand:",
+      idle: ":zzz:",
+    }[status.type];
+
+    const message = `${statusEmoji} **${status.type.replace("_", " ")}**${status.details ? `\n${status.details}` : ""}`;
+
+    try {
+      await this.mmClient.createPost(session.dmChannelId, message);
+    } catch (error) {
+      log.error("[NotificationService] Failed to send status notification:", error);
+    }
+  }
+
+  async notifySessionTakeover(session: UserSession, newProject: string): Promise<void> {
+    const message = `:information_source: **Session Transferred**
+
+Mattermost control has been transferred to another OpenCode instance.
+New project: \`${newProject}\`
+
+DMs will now be handled by the new session.`;
+
+    try {
+      await this.mmClient.createPost(session.dmChannelId, message);
+    } catch (error) {
+      log.error("[NotificationService] Failed to send takeover notification:", error);
+    }
+  }
+}