@shakudo/opencode-mattermost-control 0.3.45

package/src/scheduler/scheduler-service.ts

@@ -0,0 +1,349 @@
+import * as cron from "node-cron";
+import { log } from "../logger.js";
+import { sendEphemeralAlert } from "../monitor-service.js";
+import { ScheduleStore, type ScheduleConfig, generateScheduleId } from "./schedule-store.js";
+
+export interface PromptExecutor {
+  (sessionId: string, prompt: string): Promise<string>;
+}
+
+export interface SessionChecker {
+  (sessionId: string): Promise<boolean>;
+}
+
+export interface SchedulerServiceConfig {
+  promptExecutor?: PromptExecutor;
+  sessionChecker?: SessionChecker;
+}
+
+export class SchedulerService {
+  private store: ScheduleStore;
+  private jobs: Map<string, cron.ScheduledTask> = new Map();
+  private promptExecutor: PromptExecutor | null = null;
+  private sessionChecker: SessionChecker | null = null;
+  private started: boolean = false;
+  
+  /**
+   * Track sessions currently running scheduled tasks.
+   * Event handlers should skip streaming updates for these sessions
+   * to prevent responses from being routed to wrong threads.
+   */
+  private runningScheduledSessions: Set<string> = new Set();
+
+  constructor(config: SchedulerServiceConfig = {}) {
+    this.store = new ScheduleStore();
+    this.promptExecutor = config.promptExecutor || null;
+    this.sessionChecker = config.sessionChecker || null;
+  }
+
+  setPromptExecutor(executor: PromptExecutor): void {
+    this.promptExecutor = executor;
+  }
+
+  setSessionChecker(checker: SessionChecker): void {
+    this.sessionChecker = checker;
+  }
+
+  isRunningScheduledTask(sessionId: string): boolean {
+    return this.runningScheduledSessions.has(sessionId);
+  }
+
+  async start(): Promise<void> {
+    if (this.started) {
+      log.warn("[SchedulerService] Already started");
+      return;
+    }
+
+    await this.store.load();
+    const schedules = this.store.listEnabled();
+
+    for (const schedule of schedules) {
+      this.startJob(schedule);
+    }
+
+    this.started = true;
+    log.info(`[SchedulerService] Started with ${schedules.length} active schedules`);
+  }
+
+  async stop(): Promise<void> {
+    if (!this.started) {
+      return;
+    }
+
+    for (const [id, job] of this.jobs) {
+      job.stop();
+      log.debug(`[SchedulerService] Stopped job: ${id}`);
+    }
+    this.jobs.clear();
+
+    this.store.shutdown();
+    this.started = false;
+    log.info("[SchedulerService] Stopped");
+  }
+
+  private startJob(schedule: ScheduleConfig): boolean {
+    if (this.jobs.has(schedule.id)) {
+      log.warn(`[SchedulerService] Job already running: ${schedule.id}`);
+      return false;
+    }
+
+    if (!cron.validate(schedule.cron)) {
+      log.error(`[SchedulerService] Invalid cron expression for ${schedule.name}: ${schedule.cron}`);
+      return false;
+    }
+
+    const job = cron.schedule(
+      schedule.cron,
+      async () => {
+        await this.runTask(schedule);
+      },
+      {
+        timezone: schedule.timezone,
+      }
+    );
+
+    this.jobs.set(schedule.id, job);
+    log.info(`[SchedulerService] Started job: ${schedule.name} (${schedule.cron} ${schedule.timezone})`);
+    return true;
+  }
+
+  private stopJob(scheduleId: string): boolean {
+    const job = this.jobs.get(scheduleId);
+    if (job) {
+      job.stop();
+      this.jobs.delete(scheduleId);
+      log.debug(`[SchedulerService] Stopped job: ${scheduleId}`);
+      return true;
+    }
+    return false;
+  }
+
+  private async runTask(schedule: ScheduleConfig): Promise<void> {
+    log.info(`[SchedulerService] Running scheduled task: ${schedule.name}`);
+
+    if (!this.promptExecutor) {
+      log.error(`[SchedulerService] No prompt executor configured`);
+      await this.sendErrorDm(
+        schedule,
+        `Schedule "${schedule.name}" could not run: Plugin not fully initialized.`
+      );
+      this.store.updateLastRun(schedule.id, false, "No prompt executor configured");
+      return;
+    }
+
+    if (this.sessionChecker) {
+      const sessionExists = await this.sessionChecker(schedule.sessionId);
+      if (!sessionExists) {
+        log.warn(`[SchedulerService] Session ${schedule.sessionId} not available for schedule ${schedule.name}`);
+        await this.sendErrorDm(
+          schedule,
+          `Schedule "${schedule.name}" could not run: Session \`${schedule.sessionId.slice(0, 8)}\` is no longer available.\n\nYou may need to recreate this schedule in an active session.`
+        );
+        this.store.updateLastRun(schedule.id, false, "Session not available");
+        return;
+      }
+    }
+
+    this.runningScheduledSessions.add(schedule.sessionId);
+    log.debug(`[SchedulerService] Marked session ${schedule.sessionId.slice(0, 8)} as running scheduled task`);
+    
+    try {
+      const prefixedPrompt = `[Scheduled Task: ${schedule.name}]\n${schedule.prompt}\n\n[Important: Format your response for a Mattermost DM. Keep it concise and actionable.]`;
+      
+      log.debug(`[SchedulerService] Injecting prompt into session ${schedule.sessionId.slice(0, 8)}`);
+      const response = await this.promptExecutor(schedule.sessionId, prefixedPrompt);
+
+      if (response) {
+        const message = `:bell: **Scheduled: ${schedule.name}**\n\n${response}`;
+        await sendEphemeralAlert(schedule.targetUserId, message);
+        log.info(`[SchedulerService] Sent scheduled response to @${schedule.targetUsername}`);
+        this.store.updateLastRun(schedule.id, true);
+      } else {
+        log.warn(`[SchedulerService] Empty response from LLM for schedule ${schedule.name}`);
+        this.store.updateLastRun(schedule.id, false, "Empty response from LLM");
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      log.error(`[SchedulerService] Task failed for ${schedule.name}:`, error);
+      
+      await this.sendErrorDm(
+        schedule,
+        `Schedule "${schedule.name}" failed: ${errorMsg}`
+      );
+      this.store.updateLastRun(schedule.id, false, errorMsg);
+    } finally {
+      this.runningScheduledSessions.delete(schedule.sessionId);
+      log.debug(`[SchedulerService] Unmarked session ${schedule.sessionId.slice(0, 8)} from running scheduled task`);
+    }
+  }
+
+  private async sendErrorDm(schedule: ScheduleConfig, message: string): Promise<void> {
+    const errorMessage = `:warning: **Scheduled Task Error**\n\n${message}`;
+    await sendEphemeralAlert(schedule.targetUserId, errorMessage);
+  }
+
+  async addSchedule(params: {
+    name: string;
+    cron: string;
+    timezone?: string;
+    prompt: string;
+    sessionId: string;
+    targetUserId: string;
+    targetUsername: string;
+    enabled?: boolean;
+  }): Promise<ScheduleConfig> {
+    if (!cron.validate(params.cron)) {
+      throw new Error(`Invalid cron expression: ${params.cron}`);
+    }
+
+    const existing = this.store.getByName(params.name);
+    if (existing) {
+      throw new Error(`Schedule with name "${params.name}" already exists`);
+    }
+
+    const schedule: ScheduleConfig = {
+      id: generateScheduleId(),
+      name: params.name,
+      cron: params.cron,
+      timezone: params.timezone || "UTC",
+      prompt: params.prompt,
+      sessionId: params.sessionId,
+      targetUserId: params.targetUserId,
+      targetUsername: params.targetUsername,
+      enabled: params.enabled ?? true,
+      createdAt: new Date().toISOString(),
+    };
+
+    this.store.add(schedule);
+
+    if (schedule.enabled && this.started) {
+      this.startJob(schedule);
+    }
+
+    log.info(`[SchedulerService] Added schedule: ${schedule.name} (${schedule.cron})`);
+    return schedule;
+  }
+
+  removeSchedule(scheduleId: string): boolean {
+    this.stopJob(scheduleId);
+    const removed = this.store.remove(scheduleId);
+    if (removed) {
+      log.info(`[SchedulerService] Removed schedule: ${scheduleId}`);
+    }
+    return removed;
+  }
+
+  removeScheduleByName(name: string): boolean {
+    const schedule = this.store.getByName(name);
+    if (schedule) {
+      return this.removeSchedule(schedule.id);
+    }
+    return false;
+  }
+
+  enableSchedule(scheduleId: string): boolean {
+    const schedule = this.store.getById(scheduleId);
+    if (!schedule) {
+      return false;
+    }
+
+    if (schedule.enabled) {
+      return true;
+    }
+
+    this.store.setEnabled(scheduleId, true);
+    if (this.started) {
+      this.startJob(schedule);
+    }
+    log.info(`[SchedulerService] Enabled schedule: ${schedule.name}`);
+    return true;
+  }
+
+  disableSchedule(scheduleId: string): boolean {
+    const schedule = this.store.getById(scheduleId);
+    if (!schedule) {
+      return false;
+    }
+
+    if (!schedule.enabled) {
+      return true;
+    }
+
+    this.stopJob(scheduleId);
+    this.store.setEnabled(scheduleId, false);
+    log.info(`[SchedulerService] Disabled schedule: ${schedule.name}`);
+    return true;
+  }
+
+  listSchedules(): ScheduleConfig[] {
+    return this.store.listAll();
+  }
+
+  getSchedule(scheduleId: string): ScheduleConfig | null {
+    return this.store.getById(scheduleId);
+  }
+
+  getScheduleByName(name: string): ScheduleConfig | null {
+    return this.store.getByName(name);
+  }
+
+  getSchedulesForUser(userId: string): ScheduleConfig[] {
+    return this.store.getByUserId(userId);
+  }
+
+  getSchedulesForSession(sessionId: string): ScheduleConfig[] {
+    return this.store.getBySessionId(sessionId);
+  }
+
+  isRunning(scheduleId: string): boolean {
+    return this.jobs.has(scheduleId);
+  }
+
+  async runNow(scheduleId: string): Promise<boolean> {
+    const schedule = this.store.getById(scheduleId);
+    if (!schedule) {
+      return false;
+    }
+
+    await this.runTask(schedule);
+    return true;
+  }
+
+  async runNowByName(name: string): Promise<boolean> {
+    const schedule = this.store.getByName(name);
+    if (!schedule) {
+      return false;
+    }
+
+    await this.runTask(schedule);
+    return true;
+  }
+
+  getStats(): {
+    total: number;
+    enabled: number;
+    running: number;
+  } {
+    return {
+      total: this.store.count(),
+      enabled: this.store.listEnabled().length,
+      running: this.jobs.size,
+    };
+  }
+}
+
+let schedulerInstance: SchedulerService | null = null;
+
+export function getSchedulerService(): SchedulerService {
+  if (!schedulerInstance) {
+    schedulerInstance = new SchedulerService();
+  }
+  return schedulerInstance;
+}
+
+export function resetSchedulerService(): void {
+  if (schedulerInstance) {
+    schedulerInstance.stop();
+    schedulerInstance = null;
+  }
+}

package/src/session-manager.ts

@@ -0,0 +1,142 @@
+import type { MattermostClient } from "./clients/mattermost-client.js";
+import type { SessionsConfig } from "./config.js";
+import type { Post } from "./models/index.js";
+import { log } from "./logger.js";
+
+export interface PermissionRequest {
+  id: string;
+  tool: string;
+  args: Record<string, any>;
+  risk: "low" | "medium" | "high";
+  description: string;
+}
+
+export interface UserSession {
+  id: string;
+  mattermostUserId: string;
+  mattermostUsername: string;
+  dmChannelId: string;
+  createdAt: Date;
+  lastActivityAt: Date;
+  isProcessing: boolean;
+  currentPromptPostId: string | null;
+  currentResponsePostId: string | null;
+  pendingPermission: PermissionRequest | null;
+  lastPrompt: Post | null;
+  targetOpenCodeSessionId: string | null;
+}
+
+export class SessionManager {
+  private sessions: Map<string, UserSession> = new Map();
+  private mmClient: MattermostClient;
+  private config: SessionsConfig;
+  private cleanupInterval: NodeJS.Timeout | null = null;
+  private botUserId: string | null = null;
+
+  constructor(mmClient: MattermostClient, config: SessionsConfig) {
+    this.mmClient = mmClient;
+    this.config = config;
+    this.startCleanupTimer();
+  }
+
+  private startCleanupTimer(): void {
+    this.cleanupInterval = setInterval(() => {
+      this.cleanupExpiredSessions();
+    }, 60000);
+  }
+
+  private cleanupExpiredSessions(): void {
+    const now = Date.now();
+    for (const [userId, session] of this.sessions.entries()) {
+      if (now - session.lastActivityAt.getTime() > this.config.timeout) {
+        log.debug(`[SessionManager] Cleaning up expired session for user ${session.mattermostUsername}`);
+        this.sessions.delete(userId);
+      }
+    }
+  }
+
+  async setBotUserId(botUserId: string): Promise<void> {
+    this.botUserId = botUserId;
+  }
+
+  async getOrCreateSession(mattermostUserId: string): Promise<UserSession> {
+    let session = this.sessions.get(mattermostUserId);
+    
+    if (session) {
+      session.lastActivityAt = new Date();
+      return session;
+    }
+
+    if (this.config.allowedUsers.length > 0 && !this.config.allowedUsers.includes(mattermostUserId)) {
+      throw new Error("User not authorized to use this plugin");
+    }
+
+    if (this.sessions.size >= this.config.maxSessions) {
+      throw new Error("Maximum number of sessions reached");
+    }
+
+    const user = await this.mmClient.getUserById(mattermostUserId);
+    const dmChannel = await this.mmClient.createDirectChannel(mattermostUserId);
+
+    session = {
+      id: mattermostUserId,
+      mattermostUserId,
+      mattermostUsername: user.username,
+      dmChannelId: dmChannel.id,
+      createdAt: new Date(),
+      lastActivityAt: new Date(),
+      isProcessing: false,
+      currentPromptPostId: null,
+      currentResponsePostId: null,
+      pendingPermission: null,
+      lastPrompt: null,
+      targetOpenCodeSessionId: null,
+    };
+
+    this.sessions.set(mattermostUserId, session);
+    log.info(`[SessionManager] Created session for user ${user.username}`);
+
+    return session;
+  }
+
+  getSession(mattermostUserId: string): UserSession | null {
+    const session = this.sessions.get(mattermostUserId);
+    if (session) {
+      session.lastActivityAt = new Date();
+    }
+    return session || null;
+  }
+
+  destroySession(mattermostUserId: string): void {
+    const session = this.sessions.get(mattermostUserId);
+    if (session) {
+      log.debug(`[SessionManager] Destroying session for user ${session.mattermostUsername}`);
+      this.sessions.delete(mattermostUserId);
+    }
+  }
+
+  listSessions(): UserSession[] {
+    return Array.from(this.sessions.values());
+  }
+
+  getSessionById(sessionId: string): UserSession | null {
+    return this.sessions.get(sessionId) || null;
+  }
+
+  getSessionByDmChannel(channelId: string): UserSession | null {
+    for (const session of this.sessions.values()) {
+      if (session.dmChannelId === channelId) {
+        return session;
+      }
+    }
+    return null;
+  }
+
+  shutdown(): void {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    this.sessions.clear();
+  }
+}