@shakudo/opencode-mattermost-control 0.3.45

package/src/session-ownership-handler.ts

@@ -0,0 +1,253 @@
+import { log } from "./logger.js";
+import type { Post } from "./models/index.js";
+
+export type ConfirmationStep = "confirm_create" | "select_approval";
+
+export type ApprovalPolicy = "none" | "approve_next" | "approve_all";
+
+export interface PendingOwnershipConfirmation {
+  requestPostId: string;
+  userId: string;
+  username: string;
+  originalPost: Post;
+  threadRootPostId: string;
+  channelId: string;
+  createdAt: Date;
+  step: ConfirmationStep;
+}
+
+export interface ExistingSessionOwner {
+  username: string;
+  found: boolean;
+}
+
+export class SessionOwnershipHandler {
+  private mmClient: any;
+  private botUserId: string | null = null;
+  private pendingConfirmations: Map<string, PendingOwnershipConfirmation> = new Map();
+  private readonly CONFIRMATION_TIMEOUT_MS = 5 * 60 * 1000;
+
+  constructor(mmClient: any) {
+    this.mmClient = mmClient;
+  }
+
+  setBotUserId(botUserId: string): void {
+    this.botUserId = botUserId;
+  }
+
+  private getKey(channelId: string, threadRootPostId: string): string {
+    return `${channelId}:${threadRootPostId}`;
+  }
+
+  async checkExistingSessionOwner(
+    threadRootPostId: string,
+    currentUsername: string
+  ): Promise<ExistingSessionOwner> {
+    try {
+      const thread = await this.mmClient.getPostThread(threadRootPostId);
+      if (!thread || !thread.posts) {
+        return { found: false, username: "" };
+      }
+
+      const posts = Object.values(thread.posts) as Post[];
+      const SESSION_ANNOUNCEMENT_MARKER = "OpenCode Session Started";
+      const OWNER_FIELD_MARKER = "**Owner**:";
+      const OWNER_PATTERN = /\*\*Owner\*\*:\s*@(\w+)/;
+      
+      for (const post of posts) {
+        const isBotMessage = this.botUserId && post.user_id === this.botUserId;
+        if (!isBotMessage) continue;
+        
+        const message = post.message || "";
+        const isSessionAnnouncement = message.includes(SESSION_ANNOUNCEMENT_MARKER) && message.includes(OWNER_FIELD_MARKER);
+        if (!isSessionAnnouncement) continue;
+
+        const ownerMatch = message.match(OWNER_PATTERN);
+        if (ownerMatch) {
+          const existingOwner = ownerMatch[1];
+          if (existingOwner.toLowerCase() !== currentUsername.toLowerCase()) {
+            log.info(`[SessionOwnership] Found existing session owner @${existingOwner} (current user: @${currentUsername})`);
+            return { found: true, username: existingOwner };
+          }
+        }
+      }
+      
+      return { found: false, username: "" };
+    } catch (error) {
+      log.warn(`[SessionOwnership] Failed to check existing session owner: ${error}`);
+      return { found: false, username: "" };
+    }
+  }
+
+  async requestOwnershipConfirmation(
+    post: Post,
+    username: string,
+    threadRootPostId: string,
+    channelId: string
+  ): Promise<string | null> {
+    const key = this.getKey(channelId, threadRootPostId);
+    
+    const existingOwner = await this.checkExistingSessionOwner(threadRootPostId, username);
+    if (existingOwner.found) {
+      log.info(`[SessionOwnership] Skipping ownership confirmation - thread already owned by @${existingOwner.username}`);
+      return null;
+    }
+
+    const confirmationMessage = `No session exists for this thread yet.
+
+**Do you want to create a session with your OpenCode instance?**
+- Reply \`yes\` to create a session now
+- Reply \`no\` if you want someone else to be the session owner
+
+_Request expires in 5 minutes_`;
+
+    const requestPost = await this.mmClient.createPost(
+      channelId,
+      confirmationMessage,
+      threadRootPostId
+    );
+
+    const pending: PendingOwnershipConfirmation = {
+      requestPostId: requestPost.id,
+      userId: post.user_id,
+      username,
+      originalPost: post,
+      threadRootPostId,
+      channelId,
+      createdAt: new Date(),
+      step: "confirm_create",
+    };
+
+    this.pendingConfirmations.set(key, pending);
+    log.info(`[SessionOwnership] Requested confirmation from @${username} for thread ${threadRootPostId.substring(0, 8)}`);
+
+    return requestPost.id;
+  }
+
+  hasPendingConfirmation(channelId: string, threadRootPostId: string, userId: string): boolean {
+    const key = this.getKey(channelId, threadRootPostId);
+    const pending = this.pendingConfirmations.get(key);
+    if (!pending) return false;
+
+    if (pending.userId !== userId) return false;
+
+    const elapsed = Date.now() - pending.createdAt.getTime();
+    if (elapsed > this.CONFIRMATION_TIMEOUT_MS) {
+      this.pendingConfirmations.delete(key);
+      log.info(`[SessionOwnership] Confirmation request expired for thread ${threadRootPostId.substring(0, 8)}`);
+      return false;
+    }
+
+    return true;
+  }
+
+  getPendingConfirmation(channelId: string, threadRootPostId: string): PendingOwnershipConfirmation | undefined {
+    const key = this.getKey(channelId, threadRootPostId);
+    const pending = this.pendingConfirmations.get(key);
+    if (!pending) return undefined;
+
+    const elapsed = Date.now() - pending.createdAt.getTime();
+    if (elapsed > this.CONFIRMATION_TIMEOUT_MS) {
+      this.pendingConfirmations.delete(key);
+      return undefined;
+    }
+
+    return pending;
+  }
+
+  async handleReply(
+    channelId: string,
+    threadRootPostId: string,
+    replyText: string
+  ): Promise<{ confirmed: boolean; post?: Post; message: string; approvalPolicy?: ApprovalPolicy }> {
+    const key = this.getKey(channelId, threadRootPostId);
+    const pending = this.pendingConfirmations.get(key);
+    if (!pending) {
+      return { confirmed: false, message: "No pending confirmation request found." };
+    }
+
+    const trimmed = replyText.trim().toLowerCase();
+
+    // Step 1: Confirm session creation
+    if (pending.step === "confirm_create") {
+      if (trimmed === "yes" || trimmed === "y") {
+        // Transition to step 2: ask about pre-approving users
+        pending.step = "select_approval";
+        pending.createdAt = new Date(); // Reset timeout
+        this.pendingConfirmations.set(key, pending);
+
+        const approvalMessage = `Great! **Do you want to pre-approve other people to use this session?**
+
+\`1\` - No pre-approval (only you can use this session initially)
+\`2\` - Pre-approve the next message (one-time approval for the next person)
+\`3\` - Approve all subsequent messages (anyone can send prompts)
+
+_Reply with a number (1, 2, or 3)_`;
+
+        await this.mmClient.createPost(
+          channelId,
+          approvalMessage,
+          threadRootPostId
+        );
+        log.info(`[SessionOwnership] @${pending.username} confirmed session creation, now asking for approval policy`);
+        return { confirmed: false, message: "Waiting for approval policy selection." };
+      }
+
+      if (trimmed === "no" || trimmed === "n") {
+        this.pendingConfirmations.delete(key);
+        await this.mmClient.createPost(
+          channelId,
+          `Got it. Ask someone else to @mention me to create a session for this thread.`,
+          threadRootPostId
+        );
+        log.info(`[SessionOwnership] @${pending.username} declined session creation for thread ${threadRootPostId.substring(0, 8)}`);
+        return { confirmed: false, message: "Session creation declined." };
+      }
+
+      return { confirmed: false, message: "Invalid response. Reply with yes or no." };
+    }
+
+    // Step 2: Select approval policy
+    if (pending.step === "select_approval") {
+      let approvalPolicy: ApprovalPolicy;
+
+      if (trimmed === "1") {
+        approvalPolicy = "none";
+        log.info(`[SessionOwnership] @${pending.username} selected approval policy: none`);
+      } else if (trimmed === "2") {
+        approvalPolicy = "approve_next";
+        log.info(`[SessionOwnership] @${pending.username} selected approval policy: approve_next`);
+      } else if (trimmed === "3") {
+        approvalPolicy = "approve_all";
+        log.info(`[SessionOwnership] @${pending.username} selected approval policy: approve_all`);
+      } else {
+        return { confirmed: false, message: "Invalid response. Reply with 1, 2, or 3." };
+      }
+
+      this.pendingConfirmations.delete(key);
+      log.info(`[SessionOwnership] @${pending.username} confirmed session creation with policy '${approvalPolicy}' for thread ${threadRootPostId.substring(0, 8)}`);
+      return { confirmed: true, post: pending.originalPost, message: "Session will be created.", approvalPolicy };
+    }
+
+    return { confirmed: false, message: "Invalid state." };
+  }
+
+  clearPendingConfirmation(channelId: string, threadRootPostId: string): void {
+    const key = this.getKey(channelId, threadRootPostId);
+    this.pendingConfirmations.delete(key);
+  }
+
+  cleanupExpired(): number {
+    let cleaned = 0;
+    const now = Date.now();
+    
+    for (const [key, pending] of this.pendingConfirmations.entries()) {
+      if (now - pending.createdAt.getTime() > this.CONFIRMATION_TIMEOUT_MS) {
+        this.pendingConfirmations.delete(key);
+        cleaned++;
+      }
+    }
+    
+    return cleaned;
+  }
+}

package/src/status-indicator.ts

@@ -0,0 +1,279 @@
+import type { MattermostClient } from "./clients/mattermost-client.js";
+import { log } from "./logger.js";
+
+export type PromptState =
+  | { state: "queued"; reason: string; position?: number }
+  | { state: "connecting"; sessionId: string; shortId: string }
+  | { state: "processing"; startedAt: number }
+  | { state: "tool_running"; tool: string; startedAt: number }
+  | { state: "waiting"; reason: "permission" | "question"; details?: string }
+  | { state: "retrying"; attempt: number; maxAttempts: number; nextRetryAt: number; error: string }
+  | { state: "error"; error: string; recoverable: boolean }
+  | { state: "complete"; duration: number };
+
+const STATUS_EMOJI: Record<PromptState["state"], string> = {
+  queued: "⏳",
+  connecting: "🔗",
+  processing: "💻",
+  tool_running: "🔧",
+  waiting: "⏸️",
+  retrying: "🔄",
+  error: "❌",
+  complete: "✅",
+};
+
+const STATUS_LABELS: Record<PromptState["state"], string> = {
+  queued: "Queued",
+  connecting: "Connecting",
+  processing: "Processing",
+  tool_running: "Running Tool",
+  waiting: "Waiting",
+  retrying: "Retrying",
+  error: "Error",
+  complete: "Complete",
+};
+
+export interface StatusIndicatorConfig {
+  postId: string;
+  channelId: string;
+  threadRootPostId?: string;
+  sessionShortId?: string;
+  projectName?: string;
+}
+
+export class StatusIndicator {
+  private mmClient: MattermostClient;
+  private config: StatusIndicatorConfig;
+  private currentState: PromptState;
+  private startTime: number;
+  private lastUpdateTime: number;
+  private updateThrottleMs: number = 500;
+  private contentStarted: boolean = false;
+  private processingStartedAt: number | null = null;
+
+  constructor(mmClient: MattermostClient, config: StatusIndicatorConfig) {
+    this.mmClient = mmClient;
+    this.config = config;
+    this.startTime = Date.now();
+    this.lastUpdateTime = 0;
+    this.currentState = { state: "queued", reason: "Initializing..." };
+  }
+
+  hasContentStarted(): boolean {
+    return this.contentStarted;
+  }
+
+  markContentStarted(): void {
+    this.contentStarted = true;
+  }
+
+  getState(): PromptState {
+    return this.currentState;
+  }
+
+  getPostId(): string {
+    return this.config.postId;
+  }
+
+  updatePostId(newPostId: string): void {
+    this.config.postId = newPostId;
+  }
+
+  formatStatusMessage(includeContent: boolean = false, content?: string): string {
+    const emoji = STATUS_EMOJI[this.currentState.state];
+    const label = STATUS_LABELS[this.currentState.state];
+    
+    let statusLine = `${emoji} **${label}**`;
+    let details = "";
+
+    switch (this.currentState.state) {
+      case "queued":
+        details = this.currentState.reason;
+        if (this.currentState.position !== undefined) {
+          details += ` (position ${this.currentState.position})`;
+        }
+        break;
+
+      case "connecting":
+        details = `Session: ${this.currentState.shortId}`;
+        break;
+
+      case "processing":
+        const elapsed = Math.round((Date.now() - this.currentState.startedAt) / 1000);
+        details = `${elapsed}s elapsed`;
+        break;
+
+      case "tool_running":
+        const toolElapsed = Math.round((Date.now() - this.currentState.startedAt) / 1000);
+        details = `\`${this.currentState.tool}\` (${toolElapsed}s)`;
+        break;
+
+      case "waiting":
+        if (this.currentState.reason === "permission") {
+          details = "Awaiting permission approval";
+        } else {
+          details = "Awaiting your response";
+        }
+        if (this.currentState.details) {
+          details += `\n> ${this.currentState.details}`;
+        }
+        break;
+
+      case "retrying":
+        const retryIn = Math.max(0, Math.round((this.currentState.nextRetryAt - Date.now()) / 1000));
+        details = `Attempt ${this.currentState.attempt}/${this.currentState.maxAttempts}`;
+        if (retryIn > 0) {
+          details += ` - retry in ${retryIn}s`;
+        }
+        details += `\n> ${this.currentState.error}`;
+        break;
+
+      case "error":
+        details = this.currentState.error;
+        if (this.currentState.recoverable) {
+          details += "\n\n_React with 🔁 to retry_";
+        }
+        break;
+
+      case "complete":
+        const duration = Math.round(this.currentState.duration / 1000);
+        details = `Completed in ${duration}s`;
+        break;
+    }
+
+    let message = statusLine;
+    if (details) {
+      message += `\n${details}`;
+    }
+
+    if (includeContent && content) {
+      message += `\n\n---\n\n${content}`;
+    }
+
+    if (["processing", "tool_running", "connecting"].includes(this.currentState.state)) {
+      if (!includeContent) {
+        message += " ...";
+      }
+    }
+
+    return message;
+  }
+
+  private async updatePost(content?: string): Promise<void> {
+    const now = Date.now();
+    
+    if (now - this.lastUpdateTime < this.updateThrottleMs) {
+      return;
+    }
+
+    try {
+      const message = this.formatStatusMessage(!!content, content);
+      await this.mmClient.updatePost(this.config.postId, message);
+      this.lastUpdateTime = now;
+    } catch (e) {
+      log.error("[StatusIndicator] Failed to update post:", e);
+    }
+  }
+
+  async setQueued(reason: string, position?: number): Promise<void> {
+    this.currentState = { state: "queued", reason, position };
+    log.debug(`[StatusIndicator] State -> queued: ${reason}`);
+    await this.updatePost();
+  }
+
+  async setConnecting(sessionId: string, shortId: string): Promise<void> {
+    if (this.processingStartedAt === null) {
+      this.processingStartedAt = Date.now();
+    }
+    this.currentState = { state: "connecting", sessionId, shortId };
+    log.debug(`[StatusIndicator] State -> connecting: ${shortId}`);
+    await this.updatePost();
+  }
+
+  async setProcessing(): Promise<void> {
+    if (this.processingStartedAt === null) {
+      this.processingStartedAt = Date.now();
+    }
+    this.currentState = { state: "processing", startedAt: this.processingStartedAt };
+    log.debug("[StatusIndicator] State -> processing");
+    if (!this.contentStarted) {
+      await this.updatePost();
+    }
+  }
+
+  async setToolRunning(tool: string): Promise<void> {
+    const startedAt = this.processingStartedAt || Date.now();
+    this.currentState = { state: "tool_running", tool, startedAt };
+    log.debug(`[StatusIndicator] State -> tool_running: ${tool}`);
+    if (!this.contentStarted) {
+      await this.updatePost();
+    }
+  }
+
+  async setWaiting(reason: "permission" | "question", details?: string): Promise<void> {
+    this.currentState = { state: "waiting", reason, details };
+    log.debug(`[StatusIndicator] State -> waiting: ${reason}`);
+    await this.updatePost();
+  }
+
+  async setRetrying(attempt: number, maxAttempts: number, error: string, nextRetryMs: number): Promise<void> {
+    this.currentState = {
+      state: "retrying",
+      attempt,
+      maxAttempts,
+      error,
+      nextRetryAt: Date.now() + nextRetryMs,
+    };
+    log.debug(`[StatusIndicator] State -> retrying: attempt ${attempt}/${maxAttempts}`);
+    await this.updatePost();
+  }
+
+  async setError(error: string, recoverable: boolean = true): Promise<void> {
+    this.currentState = { state: "error", error, recoverable };
+    log.debug(`[StatusIndicator] State -> error: ${error}`);
+    await this.updatePost();
+  }
+
+  async setComplete(): Promise<void> {
+    const duration = Date.now() - this.startTime;
+    this.currentState = { state: "complete", duration };
+    log.debug(`[StatusIndicator] State -> complete: ${duration}ms`);
+  }
+
+  async updateWithContent(content: string): Promise<void> {
+    if (this.currentState.state !== "processing" && this.currentState.state !== "tool_running") {
+      this.currentState = { state: "processing", startedAt: Date.now() };
+    }
+    await this.updatePost(content);
+  }
+
+  getElapsedTime(): number {
+    return Date.now() - this.startTime;
+  }
+
+  isTerminal(): boolean {
+    return this.currentState.state === "complete" || this.currentState.state === "error";
+  }
+
+  isActive(): boolean {
+    return ["connecting", "processing", "tool_running"].includes(this.currentState.state);
+  }
+}
+
+export async function createStatusIndicator(
+  mmClient: MattermostClient,
+  channelId: string,
+  threadRootPostId?: string,
+  initialReason: string = "Received message..."
+): Promise<StatusIndicator> {
+  const initialMessage = `⏳ **Queued**\n${initialReason} ...`;
+  const post = await mmClient.createPost(channelId, initialMessage, threadRootPostId);
+
+  const indicator = new StatusIndicator(mmClient, {
+    postId: post.id,
+    channelId,
+    threadRootPostId,
+  });
+
+  return indicator;
+}