@shakudo/opencode-mattermost-control 0.3.45

package/src/response-streamer.ts

@@ -0,0 +1,364 @@
+import type { MattermostClient } from "./clients/mattermost-client.js";
+import type { StreamingConfig } from "./config.js";
+import type { UserSession } from "./session-manager.js";
+import { StatusIndicator, createStatusIndicator } from "./status-indicator.js";
+import { log } from "./logger.js";
+
+export interface StreamContext {
+  postId: string;
+  channelId: string;
+  threadRootPostId?: string;
+  buffer: string;
+  lastUpdateTime: number;
+  totalChunks: number;
+  isCancelled: boolean;
+  continuationPostIds: string[];
+  currentPostContent: string;
+  statusIndicator?: StatusIndicator;
+}
+
+export class ResponseStreamer {
+  private mmClient: MattermostClient;
+  private config: StreamingConfig;
+  private activeStreams: Map<string, StreamContext> = new Map();
+
+  constructor(mmClient: MattermostClient, config: StreamingConfig) {
+    this.mmClient = mmClient;
+    this.config = config;
+  }
+
+  async startStream(session: UserSession, threadRootPostId?: string, initialText: string = ""): Promise<StreamContext> {
+    const statusIndicator = await createStatusIndicator(
+      this.mmClient,
+      session.dmChannelId,
+      threadRootPostId,
+      "Checking session status..."
+    );
+
+    const ctx: StreamContext = {
+      postId: statusIndicator.getPostId(),
+      channelId: session.dmChannelId,
+      threadRootPostId,
+      buffer: initialText,
+      lastUpdateTime: Date.now(),
+      totalChunks: 0,
+      isCancelled: false,
+      continuationPostIds: [],
+      currentPostContent: initialText,
+      statusIndicator,
+    };
+
+    this.activeStreams.set(ctx.postId, ctx);
+    return ctx;
+  }
+
+  async startStreamWithStatus(
+    session: UserSession, 
+    threadRootPostId?: string,
+    initialReason: string = "Checking session status...",
+    overrideChannelId?: string
+  ): Promise<{ streamCtx: StreamContext; statusIndicator: StatusIndicator }> {
+    const targetChannelId = overrideChannelId || session.dmChannelId;
+    const statusIndicator = await createStatusIndicator(
+      this.mmClient,
+      targetChannelId,
+      threadRootPostId,
+      initialReason
+    );
+
+    const ctx: StreamContext = {
+      postId: statusIndicator.getPostId(),
+      channelId: targetChannelId,
+      threadRootPostId,
+      buffer: "",
+      lastUpdateTime: Date.now(),
+      totalChunks: 0,
+      isCancelled: false,
+      continuationPostIds: [],
+      currentPostContent: "",
+      statusIndicator,
+    };
+
+    this.activeStreams.set(ctx.postId, ctx);
+    return { streamCtx: ctx, statusIndicator };
+  }
+
+  async appendChunk(ctx: StreamContext, chunk: string): Promise<void> {
+    if (ctx.isCancelled) return;
+
+    ctx.buffer += chunk;
+    ctx.totalChunks++;
+
+    const now = Date.now();
+    const timeSinceLastUpdate = now - ctx.lastUpdateTime;
+    const shouldUpdate =
+      ctx.buffer.length >= this.config.bufferSize || timeSinceLastUpdate >= this.config.maxDelay;
+
+    if (shouldUpdate) {
+      await this.flushBuffer(ctx);
+    }
+  }
+
+  private async flushBuffer(ctx: StreamContext): Promise<void> {
+    if (ctx.isCancelled) return;
+
+    const timeSinceLastUpdate = Date.now() - ctx.lastUpdateTime;
+    const minInterval = 1000 / this.config.editRateLimit;
+
+    if (timeSinceLastUpdate < minInterval) {
+      await this.sleep(minInterval - timeSinceLastUpdate);
+    }
+
+    try {
+      await this.retryOperation(
+        () => this.updateWithSplitting(ctx, ctx.buffer + " ..."),
+        1,
+        200
+      );
+      ctx.lastUpdateTime = Date.now();
+    } catch (error) {
+      log.warn("[ResponseStreamer] Failed to update post (non-critical):", error);
+    }
+  }
+
+  async updateStream(ctx: StreamContext, fullText: string): Promise<void> {
+    if (ctx.isCancelled) return;
+
+    ctx.buffer = fullText;
+
+    if (ctx.statusIndicator && !ctx.statusIndicator.hasContentStarted()) {
+      ctx.statusIndicator.markContentStarted();
+    }
+
+    const now = Date.now();
+    const timeSinceLastUpdate = now - ctx.lastUpdateTime;
+    const minInterval = 1000 / this.config.editRateLimit;
+
+    if (timeSinceLastUpdate >= minInterval) {
+      try {
+        await this.retryOperation(
+          () => this.updateWithSplitting(ctx, ctx.buffer + " ..."),
+          1,
+          200
+        );
+        ctx.lastUpdateTime = Date.now();
+      } catch (error) {
+        log.warn("[ResponseStreamer] Failed to update post (non-critical):", error);
+      }
+    }
+  }
+
+  async endStream(ctx: StreamContext): Promise<void> {
+    if (ctx.isCancelled) return;
+
+    this.activeStreams.delete(ctx.postId);
+
+    try {
+      if (ctx.statusIndicator) {
+        await ctx.statusIndicator.setComplete();
+      }
+      const finalContent = ctx.buffer || "(No response)";
+      await this.retryOperation(
+        () => this.updateWithSplitting(ctx, finalContent),
+        3,
+        500
+      );
+    } catch (error) {
+      log.error("[ResponseStreamer] Failed to update post after retries, attempting fallback:", error);
+      try {
+        const finalContent = ctx.buffer || "(No response)";
+        await this.mmClient.createPost(
+          ctx.channelId,
+          `*(Response recovered)*\n\n${finalContent}`,
+          ctx.threadRootPostId
+        );
+        log.info("[ResponseStreamer] Successfully posted final content via fallback");
+      } catch (fallbackError) {
+        log.error("[ResponseStreamer] Fallback also failed - response may be incomplete:", fallbackError);
+      }
+    }
+  }
+
+  async cancelStream(ctx: StreamContext): Promise<void> {
+    ctx.isCancelled = true;
+    this.activeStreams.delete(ctx.postId);
+
+    try {
+      const cancelledContent = ctx.buffer + "\n\n*(Cancelled)*";
+      await this.updateWithSplitting(ctx, cancelledContent);
+    } catch (error) {
+      log.error("[ResponseStreamer] Failed to mark post as cancelled:", error);
+    }
+  }
+
+  async recreateStreamAtBottom(ctx: StreamContext, finalizeOldContent?: string): Promise<StreamContext> {
+    this.activeStreams.delete(ctx.postId);
+
+    try {
+      if (finalizeOldContent !== undefined) {
+        await this.mmClient.updatePost(ctx.postId, finalizeOldContent);
+      } else {
+        await this.mmClient.deletePost(ctx.postId);
+      }
+      
+      for (const contPostId of ctx.continuationPostIds) {
+        try {
+          await this.mmClient.deletePost(contPostId);
+        } catch (e) {
+          log.debug(`[ResponseStreamer] Could not delete continuation post ${contPostId}`);
+        }
+      }
+    } catch (error) {
+      log.error("[ResponseStreamer] Failed to delete old stream post:", error);
+    }
+
+    const newPost = await this.mmClient.createPost(
+      ctx.channelId,
+      ctx.buffer || "...",
+      ctx.threadRootPostId
+    );
+
+    const newCtx: StreamContext = {
+      postId: newPost.id,
+      channelId: ctx.channelId,
+      threadRootPostId: ctx.threadRootPostId,
+      buffer: ctx.buffer,
+      lastUpdateTime: Date.now(),
+      totalChunks: ctx.totalChunks,
+      isCancelled: false,
+      continuationPostIds: [],
+      currentPostContent: ctx.buffer,
+      statusIndicator: ctx.statusIndicator,
+    };
+
+    if (newCtx.statusIndicator) {
+      newCtx.statusIndicator.updatePostId(newPost.id);
+    }
+
+    this.activeStreams.set(newCtx.postId, newCtx);
+    return newCtx;
+  }
+
+  private async updateWithSplitting(ctx: StreamContext, content: string): Promise<void> {
+    const maxLen = this.config.maxPostLength;
+    
+    if (content.length <= maxLen) {
+      await this.mmClient.updatePost(ctx.postId, content);
+      ctx.currentPostContent = content;
+      return;
+    }
+
+    const parts = this.splitMessage(content, maxLen);
+    
+    const firstPartWithContinuation = parts.length > 1 
+      ? parts[0] + "\n\n*(continued below...)*"
+      : parts[0];
+    
+    await this.mmClient.updatePost(ctx.postId, firstPartWithContinuation);
+    ctx.currentPostContent = firstPartWithContinuation;
+
+    for (let i = 1; i < parts.length; i++) {
+      const isLast = i === parts.length - 1;
+      const partContent = isLast 
+        ? `*(continued ${i + 1}/${parts.length})*\n\n${parts[i]}`
+        : `*(continued ${i + 1}/${parts.length})*\n\n${parts[i]}\n\n*(continued below...)*`;
+
+      if (ctx.continuationPostIds[i - 1]) {
+        await this.mmClient.updatePost(ctx.continuationPostIds[i - 1], partContent);
+      } else {
+        const post = await this.mmClient.createPost(
+          ctx.channelId, 
+          partContent, 
+          ctx.threadRootPostId
+        );
+        ctx.continuationPostIds.push(post.id);
+      }
+    }
+
+    const extraPosts = ctx.continuationPostIds.length - (parts.length - 1);
+    if (extraPosts > 0) {
+      for (let i = 0; i < extraPosts; i++) {
+        const postIdToRemove = ctx.continuationPostIds.pop();
+        if (postIdToRemove) {
+          try {
+            await this.mmClient.updatePost(postIdToRemove, "*(message consolidated above)*");
+          } catch (e) {
+            log.debug("[ResponseStreamer] Could not update orphaned continuation post");
+          }
+        }
+      }
+    }
+  }
+
+  private splitMessage(content: string, maxLen: number): string[] {
+    if (content.length <= maxLen) {
+      return [content];
+    }
+
+    const parts: string[] = [];
+    let remaining = content;
+    const reservedSpace = 50;
+    const effectiveMax = maxLen - reservedSpace;
+
+    while (remaining.length > 0) {
+      if (remaining.length <= effectiveMax) {
+        parts.push(remaining);
+        break;
+      }
+
+      let splitPoint = this.findSplitPoint(remaining, effectiveMax);
+      parts.push(remaining.substring(0, splitPoint).trimEnd());
+      remaining = remaining.substring(splitPoint).trimStart();
+    }
+
+    return parts;
+  }
+
+  private findSplitPoint(text: string, maxLen: number): number {
+    const doubleNewline = text.lastIndexOf("\n\n", maxLen);
+    if (doubleNewline > maxLen * 0.5) {
+      return doubleNewline + 2;
+    }
+
+    const singleNewline = text.lastIndexOf("\n", maxLen);
+    if (singleNewline > maxLen * 0.5) {
+      return singleNewline + 1;
+    }
+
+    const space = text.lastIndexOf(" ", maxLen);
+    if (space > maxLen * 0.7) {
+      return space + 1;
+    }
+
+    return maxLen;
+  }
+
+  isStreaming(postId: string): boolean {
+    return this.activeStreams.has(postId);
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  private async retryOperation<T>(
+    operation: () => Promise<T>,
+    maxRetries: number = 3,
+    baseDelayMs: number = 500
+  ): Promise<T> {
+    let lastError: unknown;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error;
+        if (attempt < maxRetries) {
+          const delay = baseDelayMs * Math.pow(2, attempt);
+          log.debug(`[ResponseStreamer] Retry ${attempt + 1}/${maxRetries} after ${delay}ms`);
+          await this.sleep(delay);
+        }
+      }
+    }
+    throw lastError;
+  }
+}

package/src/scheduler/schedule-store.ts

@@ -0,0 +1,261 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from "fs";
+import { homedir } from "os";
+import { join, dirname } from "path";
+import { z } from "zod";
+import { log } from "../logger.js";
+
+export const ScheduleConfigSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  cron: z.string(),
+  timezone: z.string().default("UTC"),
+  prompt: z.string(),
+  sessionId: z.string(),
+  targetUserId: z.string(),
+  targetUsername: z.string(),
+  enabled: z.boolean().default(true),
+  createdAt: z.string(),
+  lastRunAt: z.string().optional(),
+  lastRunSuccess: z.boolean().optional(),
+  lastRunError: z.string().optional(),
+});
+export type ScheduleConfig = z.infer<typeof ScheduleConfigSchema>;
+
+export const ScheduleFileSchema = z.object({
+  version: z.literal(1),
+  schedules: z.array(ScheduleConfigSchema),
+  lastModified: z.string(),
+});
+export type ScheduleFileV1 = z.infer<typeof ScheduleFileSchema>;
+
+const PRIMARY_DIR = join(homedir(), ".config", "opencode");
+const FALLBACK_DIR = join(homedir(), ".opencode");
+const FILENAME = "mattermost-schedules.json";
+
+export class ScheduleStore {
+  private schedules: Map<string, ScheduleConfig> = new Map();
+  private byUserId: Map<string, ScheduleConfig[]> = new Map();
+  private bySessionId: Map<string, ScheduleConfig[]> = new Map();
+  private filePath: string;
+  private saveDebounceTimer: ReturnType<typeof setTimeout> | null = null;
+  private saveDebounceMs: number = 2000;
+
+  constructor() {
+    this.filePath = this.resolveFilePath();
+  }
+
+  private resolveFilePath(): string {
+    if (existsSync(PRIMARY_DIR)) {
+      return join(PRIMARY_DIR, FILENAME);
+    }
+    if (existsSync(FALLBACK_DIR)) {
+      return join(FALLBACK_DIR, FILENAME);
+    }
+    mkdirSync(PRIMARY_DIR, { recursive: true });
+    return join(PRIMARY_DIR, FILENAME);
+  }
+
+  async load(): Promise<ScheduleConfig[]> {
+    try {
+      if (!existsSync(this.filePath)) {
+        log.debug("[ScheduleStore] No existing file, starting fresh");
+        return [];
+      }
+
+      const raw = readFileSync(this.filePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      const validated = ScheduleFileSchema.safeParse(parsed);
+
+      if (!validated.success) {
+        log.warn("[ScheduleStore] Invalid file format, filtering valid entries");
+        const schedules: ScheduleConfig[] = [];
+        if (Array.isArray(parsed?.schedules)) {
+          for (const s of parsed.schedules) {
+            const result = ScheduleConfigSchema.safeParse(s);
+            if (result.success) {
+              schedules.push(result.data);
+            }
+          }
+        }
+        this.setSchedules(schedules);
+        return schedules;
+      }
+
+      this.setSchedules(validated.data.schedules);
+      log.info(`[ScheduleStore] Loaded ${validated.data.schedules.length} schedules`);
+      return validated.data.schedules;
+    } catch (e) {
+      log.error("[ScheduleStore] Failed to load:", e);
+      return [];
+    }
+  }
+
+  async save(): Promise<void> {
+    try {
+      const data: ScheduleFileV1 = {
+        version: 1,
+        schedules: Array.from(this.schedules.values()),
+        lastModified: new Date().toISOString(),
+      };
+
+      const dir = dirname(this.filePath);
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+
+      const tempPath = `${this.filePath}.tmp.${Date.now()}`;
+      writeFileSync(tempPath, JSON.stringify(data, null, 2));
+      renameSync(tempPath, this.filePath);
+      log.debug(`[ScheduleStore] Saved ${this.schedules.size} schedules`);
+    } catch (e) {
+      log.error("[ScheduleStore] Failed to save:", e);
+    }
+  }
+
+  scheduleSave(): void {
+    if (this.saveDebounceTimer) {
+      clearTimeout(this.saveDebounceTimer);
+    }
+    this.saveDebounceTimer = setTimeout(() => {
+      this.saveDebounceTimer = null;
+      this.save().catch((e) => log.error("[ScheduleStore] Debounced save failed:", e));
+    }, this.saveDebounceMs);
+  }
+
+  private setSchedules(schedules: ScheduleConfig[]): void {
+    this.schedules.clear();
+    this.byUserId.clear();
+    this.bySessionId.clear();
+
+    for (const s of schedules) {
+      this.addToIndexes(s);
+    }
+  }
+
+  private addToIndexes(schedule: ScheduleConfig): void {
+    this.schedules.set(schedule.id, schedule);
+
+    const userSchedules = this.byUserId.get(schedule.targetUserId) || [];
+    userSchedules.push(schedule);
+    this.byUserId.set(schedule.targetUserId, userSchedules);
+
+    const sessionSchedules = this.bySessionId.get(schedule.sessionId) || [];
+    sessionSchedules.push(schedule);
+    this.bySessionId.set(schedule.sessionId, sessionSchedules);
+  }
+
+  private removeFromIndexes(schedule: ScheduleConfig): void {
+    this.schedules.delete(schedule.id);
+
+    const userSchedules = this.byUserId.get(schedule.targetUserId);
+    if (userSchedules) {
+      const filtered = userSchedules.filter((s) => s.id !== schedule.id);
+      if (filtered.length > 0) {
+        this.byUserId.set(schedule.targetUserId, filtered);
+      } else {
+        this.byUserId.delete(schedule.targetUserId);
+      }
+    }
+
+    const sessionSchedules = this.bySessionId.get(schedule.sessionId);
+    if (sessionSchedules) {
+      const filtered = sessionSchedules.filter((s) => s.id !== schedule.id);
+      if (filtered.length > 0) {
+        this.bySessionId.set(schedule.sessionId, filtered);
+      } else {
+        this.bySessionId.delete(schedule.sessionId);
+      }
+    }
+  }
+
+  add(schedule: ScheduleConfig): void {
+    this.addToIndexes(schedule);
+    this.scheduleSave();
+  }
+
+  update(schedule: ScheduleConfig): void {
+    const existing = this.schedules.get(schedule.id);
+    if (existing) {
+      this.removeFromIndexes(existing);
+    }
+    this.addToIndexes(schedule);
+    this.scheduleSave();
+  }
+
+  remove(scheduleId: string): boolean {
+    const existing = this.schedules.get(scheduleId);
+    if (existing) {
+      this.removeFromIndexes(existing);
+      this.scheduleSave();
+      return true;
+    }
+    return false;
+  }
+
+  getById(scheduleId: string): ScheduleConfig | null {
+    return this.schedules.get(scheduleId) || null;
+  }
+
+  getByName(name: string): ScheduleConfig | null {
+    for (const schedule of this.schedules.values()) {
+      if (schedule.name === name) {
+        return schedule;
+      }
+    }
+    return null;
+  }
+
+  getByUserId(userId: string): ScheduleConfig[] {
+    return this.byUserId.get(userId) || [];
+  }
+
+  getBySessionId(sessionId: string): ScheduleConfig[] {
+    return this.bySessionId.get(sessionId) || [];
+  }
+
+  listAll(): ScheduleConfig[] {
+    return Array.from(this.schedules.values());
+  }
+
+  listEnabled(): ScheduleConfig[] {
+    return this.listAll().filter((s) => s.enabled);
+  }
+
+  count(): number {
+    return this.schedules.size;
+  }
+
+  updateLastRun(scheduleId: string, success: boolean, error?: string): void {
+    const schedule = this.schedules.get(scheduleId);
+    if (schedule) {
+      schedule.lastRunAt = new Date().toISOString();
+      schedule.lastRunSuccess = success;
+      schedule.lastRunError = error;
+      this.scheduleSave();
+    }
+  }
+
+  setEnabled(scheduleId: string, enabled: boolean): boolean {
+    const schedule = this.schedules.get(scheduleId);
+    if (schedule) {
+      schedule.enabled = enabled;
+      this.scheduleSave();
+      return true;
+    }
+    return false;
+  }
+
+  shutdown(): void {
+    if (this.saveDebounceTimer) {
+      clearTimeout(this.saveDebounceTimer);
+      this.saveDebounceTimer = null;
+    }
+    this.save().catch((e) => log.error("[ScheduleStore] Shutdown save failed:", e));
+  }
+}
+
+export function generateScheduleId(): string {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `sched_${timestamp}_${random}`;
+}