@oh-my-pi/pi-mom 0.1.0

package/src/download.ts

@@ -0,0 +1,117 @@
+import { LogLevel, WebClient } from "@slack/web-api";
+
+interface Message {
+	ts: string;
+	user?: string;
+	text?: string;
+	thread_ts?: string;
+	reply_count?: number;
+	files?: Array<{ name: string; url_private?: string }>;
+}
+
+function formatTs(ts: string): string {
+	const date = new Date(parseFloat(ts) * 1000);
+	return date
+		.toISOString()
+		.replace("T", " ")
+		.replace(/\.\d+Z$/, "");
+}
+
+function formatMessage(ts: string, user: string, text: string, indent = ""): string {
+	const prefix = `[${formatTs(ts)}] ${user}: `;
+	const lines = text.split("\n");
+	const firstLine = `${indent}${prefix}${lines[0]}`;
+	if (lines.length === 1) return firstLine;
+	// All continuation lines get same indent as content start
+	const contentIndent = indent + " ".repeat(prefix.length);
+	return [firstLine, ...lines.slice(1).map((l) => contentIndent + l)].join("\n");
+}
+
+export async function downloadChannel(channelId: string, botToken: string): Promise<void> {
+	const client = new WebClient(botToken, { logLevel: LogLevel.ERROR });
+
+	console.error(`Fetching channel info for ${channelId}...`);
+
+	// Get channel info
+	let channelName = channelId;
+	try {
+		const info = await client.conversations.info({ channel: channelId });
+		channelName = (info.channel as any)?.name || channelId;
+	} catch {
+		// DM channels don't have names, that's fine
+	}
+
+	console.error(`Downloading history for #${channelName} (${channelId})...`);
+
+	// Fetch all messages
+	const messages: Message[] = [];
+	let cursor: string | undefined;
+
+	do {
+		const response = await client.conversations.history({
+			channel: channelId,
+			limit: 200,
+			cursor,
+		});
+
+		if (response.messages) {
+			messages.push(...(response.messages as Message[]));
+		}
+
+		cursor = response.response_metadata?.next_cursor;
+		console.error(`  Fetched ${messages.length} messages...`);
+	} while (cursor);
+
+	// Reverse to chronological order
+	messages.reverse();
+
+	// Build map of thread replies
+	const threadReplies = new Map<string, Message[]>();
+	const threadsToFetch = messages.filter((m) => m.reply_count && m.reply_count > 0);
+
+	console.error(`Fetching ${threadsToFetch.length} threads...`);
+
+	for (let i = 0; i < threadsToFetch.length; i++) {
+		const parent = threadsToFetch[i];
+		console.error(`  Thread ${i + 1}/${threadsToFetch.length} (${parent.reply_count} replies)...`);
+
+		const replies: Message[] = [];
+		let threadCursor: string | undefined;
+
+		do {
+			const response = await client.conversations.replies({
+				channel: channelId,
+				ts: parent.ts,
+				limit: 200,
+				cursor: threadCursor,
+			});
+
+			if (response.messages) {
+				// Skip the first message (it's the parent)
+				replies.push(...(response.messages as Message[]).slice(1));
+			}
+
+			threadCursor = response.response_metadata?.next_cursor;
+		} while (threadCursor);
+
+		threadReplies.set(parent.ts, replies);
+	}
+
+	// Output messages with thread replies interleaved
+	let totalReplies = 0;
+	for (const msg of messages) {
+		// Output the message
+		console.log(formatMessage(msg.ts, msg.user || "unknown", msg.text || ""));
+
+		// Output thread replies right after parent (indented)
+		const replies = threadReplies.get(msg.ts);
+		if (replies) {
+			for (const reply of replies) {
+				console.log(formatMessage(reply.ts, reply.user || "unknown", reply.text || "", "  "));
+				totalReplies++;
+			}
+		}
+	}
+
+	console.error(`Done! ${messages.length} messages, ${totalReplies} thread replies`);
+}

package/src/events.ts

@@ -0,0 +1,385 @@
+import { existsSync, type FSWatcher, mkdirSync, readdirSync, statSync, unlinkSync, watch } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { logger } from "@oh-my-pi/pi-coding-agent";
+import { Cron } from "croner";
+import * as log from "./log";
+import type { SlackBot, SlackEvent } from "./slack";
+
+// ============================================================================
+// Event Types
+// ============================================================================
+
+export interface ImmediateEvent {
+	type: "immediate";
+	channelId: string;
+	text: string;
+}
+
+export interface OneShotEvent {
+	type: "one-shot";
+	channelId: string;
+	text: string;
+	at: string; // ISO 8601 with timezone offset
+}
+
+export interface PeriodicEvent {
+	type: "periodic";
+	channelId: string;
+	text: string;
+	schedule: string; // cron syntax
+	timezone: string; // IANA timezone
+}
+
+export type MomEvent = ImmediateEvent | OneShotEvent | PeriodicEvent;
+
+// ============================================================================
+// EventsWatcher
+// ============================================================================
+
+const DEBOUNCE_MS = 100;
+const MAX_RETRIES = 3;
+const RETRY_BASE_MS = 100;
+
+export class EventsWatcher {
+	private timers: Map<string, NodeJS.Timeout> = new Map();
+	private crons: Map<string, Cron> = new Map();
+	private debounceTimers: Map<string, NodeJS.Timeout> = new Map();
+	private startTime: number;
+	private watcher: FSWatcher | null = null;
+	private knownFiles: Set<string> = new Set();
+
+	constructor(
+		private eventsDir: string,
+		private slack: SlackBot,
+	) {
+		this.startTime = Date.now();
+	}
+
+	/**
+	 * Start watching for events. Call this after SlackBot is ready.
+	 */
+	start(): void {
+		// Ensure events directory exists
+		if (!existsSync(this.eventsDir)) {
+			mkdirSync(this.eventsDir, { recursive: true });
+		}
+
+		log.logInfo(`Events watcher starting, dir: ${this.eventsDir}`);
+
+		// Scan existing files
+		this.scanExisting();
+
+		// Watch for changes
+		this.watcher = watch(this.eventsDir, (_eventType, filename) => {
+			if (!filename || !filename.endsWith(".json")) return;
+			this.debounce(filename, () => this.handleFileChange(filename));
+		});
+
+		log.logInfo(`Events watcher started, tracking ${this.knownFiles.size} files`);
+	}
+
+	/**
+	 * Stop watching and cancel all scheduled events.
+	 */
+	stop(): void {
+		// Stop fs watcher
+		if (this.watcher) {
+			this.watcher.close();
+			this.watcher = null;
+		}
+
+		// Cancel all debounce timers
+		for (const timer of this.debounceTimers.values()) {
+			clearTimeout(timer);
+		}
+		this.debounceTimers.clear();
+
+		// Cancel all scheduled timers
+		for (const timer of this.timers.values()) {
+			clearTimeout(timer);
+		}
+		this.timers.clear();
+
+		// Cancel all cron jobs
+		for (const cron of this.crons.values()) {
+			cron.stop();
+		}
+		this.crons.clear();
+
+		this.knownFiles.clear();
+		log.logInfo("Events watcher stopped");
+	}
+
+	private debounce(filename: string, fn: () => void): void {
+		const existing = this.debounceTimers.get(filename);
+		if (existing) {
+			clearTimeout(existing);
+		}
+		this.debounceTimers.set(
+			filename,
+			setTimeout(() => {
+				this.debounceTimers.delete(filename);
+				fn();
+			}, DEBOUNCE_MS),
+		);
+	}
+
+	private scanExisting(): void {
+		let files: string[];
+		try {
+			files = readdirSync(this.eventsDir).filter((f) => f.endsWith(".json"));
+		} catch (err) {
+			log.logWarning("Failed to read events directory", String(err));
+			return;
+		}
+
+		for (const filename of files) {
+			this.handleFile(filename);
+		}
+	}
+
+	private handleFileChange(filename: string): void {
+		const filePath = join(this.eventsDir, filename);
+
+		if (!existsSync(filePath)) {
+			// File was deleted
+			this.handleDelete(filename);
+		} else if (this.knownFiles.has(filename)) {
+			// File was modified - cancel existing and re-schedule
+			this.cancelScheduled(filename);
+			this.handleFile(filename);
+		} else {
+			// New file
+			this.handleFile(filename);
+		}
+	}
+
+	private handleDelete(filename: string): void {
+		if (!this.knownFiles.has(filename)) return;
+
+		log.logInfo(`Event file deleted: ${filename}`);
+		this.cancelScheduled(filename);
+		this.knownFiles.delete(filename);
+	}
+
+	private cancelScheduled(filename: string): void {
+		const timer = this.timers.get(filename);
+		if (timer) {
+			clearTimeout(timer);
+			this.timers.delete(filename);
+		}
+
+		const cron = this.crons.get(filename);
+		if (cron) {
+			cron.stop();
+			this.crons.delete(filename);
+		}
+	}
+
+	private async handleFile(filename: string): Promise<void> {
+		const filePath = join(this.eventsDir, filename);
+
+		// Mark as known immediately to prevent duplicate processing
+		this.knownFiles.add(filename);
+
+		// Parse with retries
+		let event: MomEvent | null = null;
+		let lastError: Error | null = null;
+
+		for (let i = 0; i < MAX_RETRIES; i++) {
+			try {
+				const content = await readFile(filePath, "utf-8");
+				event = this.parseEvent(content, filename);
+				break;
+			} catch (err) {
+				lastError = err instanceof Error ? err : new Error(String(err));
+				if (i < MAX_RETRIES - 1) {
+					await this.sleep(RETRY_BASE_MS * 2 ** i);
+				}
+			}
+		}
+
+		if (!event) {
+			log.logWarning(`Failed to parse event file after ${MAX_RETRIES} retries: ${filename}`, lastError?.message);
+			this.deleteFile(filename);
+			return;
+		}
+
+		// Schedule based on type
+		switch (event.type) {
+			case "immediate":
+				this.handleImmediate(filename, event);
+				break;
+			case "one-shot":
+				this.handleOneShot(filename, event);
+				break;
+			case "periodic":
+				this.handlePeriodic(filename, event);
+				break;
+		}
+	}
+
+	private parseEvent(content: string, filename: string): MomEvent | null {
+		const data = JSON.parse(content);
+
+		if (!data.type || !data.channelId || !data.text) {
+			throw new Error(`Missing required fields (type, channelId, text) in ${filename}`);
+		}
+
+		switch (data.type) {
+			case "immediate":
+				return { type: "immediate", channelId: data.channelId, text: data.text };
+
+			case "one-shot":
+				if (!data.at) {
+					throw new Error(`Missing 'at' field for one-shot event in ${filename}`);
+				}
+				return { type: "one-shot", channelId: data.channelId, text: data.text, at: data.at };
+
+			case "periodic":
+				if (!data.schedule) {
+					throw new Error(`Missing 'schedule' field for periodic event in ${filename}`);
+				}
+				if (!data.timezone) {
+					throw new Error(`Missing 'timezone' field for periodic event in ${filename}`);
+				}
+				return {
+					type: "periodic",
+					channelId: data.channelId,
+					text: data.text,
+					schedule: data.schedule,
+					timezone: data.timezone,
+				};
+
+			default:
+				throw new Error(`Unknown event type '${data.type}' in ${filename}`);
+		}
+	}
+
+	private handleImmediate(filename: string, event: ImmediateEvent): void {
+		const filePath = join(this.eventsDir, filename);
+
+		// Check if stale (created before harness started)
+		try {
+			const stat = statSync(filePath);
+			if (stat.mtimeMs < this.startTime) {
+				log.logInfo(`Stale immediate event, deleting: ${filename}`);
+				this.deleteFile(filename);
+				return;
+			}
+		} catch (err) {
+			logger.debug("File stat failed", { filename, error: String(err) });
+			return;
+		}
+
+		log.logInfo(`Executing immediate event: ${filename}`);
+		this.execute(filename, event);
+	}
+
+	private handleOneShot(filename: string, event: OneShotEvent): void {
+		const atTime = new Date(event.at).getTime();
+		const now = Date.now();
+
+		if (atTime <= now) {
+			// Past - delete without executing
+			log.logInfo(`One-shot event in the past, deleting: ${filename}`);
+			this.deleteFile(filename);
+			return;
+		}
+
+		const delay = atTime - now;
+		log.logInfo(`Scheduling one-shot event: ${filename} in ${Math.round(delay / 1000)}s`);
+
+		const timer = setTimeout(() => {
+			this.timers.delete(filename);
+			log.logInfo(`Executing one-shot event: ${filename}`);
+			this.execute(filename, event);
+		}, delay);
+
+		this.timers.set(filename, timer);
+	}
+
+	private handlePeriodic(filename: string, event: PeriodicEvent): void {
+		try {
+			const cron = new Cron(event.schedule, { timezone: event.timezone }, () => {
+				log.logInfo(`Executing periodic event: ${filename}`);
+				this.execute(filename, event, false); // Don't delete periodic events
+			});
+
+			this.crons.set(filename, cron);
+
+			const next = cron.nextRun();
+			log.logInfo(`Scheduled periodic event: ${filename}, next run: ${next?.toISOString() ?? "unknown"}`);
+		} catch (err) {
+			log.logWarning(`Invalid cron schedule for ${filename}: ${event.schedule}`, String(err));
+			this.deleteFile(filename);
+		}
+	}
+
+	private execute(filename: string, event: MomEvent, deleteAfter: boolean = true): void {
+		// Format the message
+		let scheduleInfo: string;
+		switch (event.type) {
+			case "immediate":
+				scheduleInfo = "immediate";
+				break;
+			case "one-shot":
+				scheduleInfo = event.at;
+				break;
+			case "periodic":
+				scheduleInfo = event.schedule;
+				break;
+		}
+
+		const message = `[EVENT:${filename}:${event.type}:${scheduleInfo}] ${event.text}`;
+
+		// Create synthetic SlackEvent
+		const syntheticEvent: SlackEvent = {
+			type: "mention",
+			channel: event.channelId,
+			user: "EVENT",
+			text: message,
+			ts: Date.now().toString(),
+		};
+
+		// Enqueue for processing
+		const enqueued = this.slack.enqueueEvent(syntheticEvent);
+
+		if (enqueued && deleteAfter) {
+			// Delete file after successful enqueue (immediate and one-shot)
+			this.deleteFile(filename);
+		} else if (!enqueued) {
+			log.logWarning(`Event queue full, discarded: ${filename}`);
+			// Still delete immediate/one-shot even if discarded
+			if (deleteAfter) {
+				this.deleteFile(filename);
+			}
+		}
+	}
+
+	private deleteFile(filename: string): void {
+		const filePath = join(this.eventsDir, filename);
+		try {
+			unlinkSync(filePath);
+		} catch (err) {
+			// ENOENT is fine (file already deleted), other errors are warnings
+			if (err instanceof Error && "code" in err && err.code !== "ENOENT") {
+				log.logWarning(`Failed to delete event file: ${filename}`, String(err));
+			}
+		}
+		this.knownFiles.delete(filename);
+	}
+
+	private sleep(ms: number): Promise<void> {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+}
+
+/**
+ * Create and start an events watcher.
+ */
+export function createEventsWatcher(workspaceDir: string, slack: SlackBot): EventsWatcher {
+	const eventsDir = join(workspaceDir, "events");
+	return new EventsWatcher(eventsDir, slack);
+}