@juspay/shooter 1.0.0

package/src/lib/modules/server/terminal/opencode-watcher.ts

@@ -0,0 +1,661 @@
+/**
+ * OpenCode Session Watcher
+ *
+ * Polls the OpenCode SQLite database for new messages in a session and
+ * streams them as ConversationMessage objects that the session handler
+ * can consume directly for both history and live updates.
+ *
+ * Unlike the JSONL-based SessionWatcher (which uses chokidar for file
+ * change detection), this module polls SQLite because OpenCode holds a
+ * write lock on the database and we must open/close quickly in read-only
+ * mode to avoid contention.
+ */
+
+import Database from 'better-sqlite3';
+import * as fs from 'fs';
+import * as path from 'path';
+
+import type { ConversationMessage, MessagePart } from '../sessions/types';
+
+// ── Constants ────────────────────────────────────────────────────────
+
+const OPENCODE_DB_PATH = (() => {
+	if (process.platform === 'darwin') {
+		return path.join(process.env.HOME || '', 'Library', 'Application Support', 'opencode', 'opencode.db');
+	}
+	const xdgData = process.env.XDG_DATA_HOME || path.join(process.env.HOME || '', '.local', 'share');
+	return path.join(xdgData, 'opencode', 'opencode.db');
+})();
+
+/** Poll interval in milliseconds. */
+const POLL_INTERVAL_MS = 2000;
+
+/** Maximum parameters per SQLite IN clause (SQLite limit is 999). */
+const SQLITE_MAX_PARAMS = 500;
+
+/**
+ * Normalise a timestamp from OpenCode's SQLite database to milliseconds.
+ *
+ * OpenCode currently stores `time_created` / `time_updated` as Unix
+ * **milliseconds**, but this is not formally documented and could change.
+ * A simple heuristic distinguishes seconds from milliseconds:
+ *   - Values < 1e12 (~2001-09-09 in ms, ~33658 AD in seconds) are seconds.
+ *   - Values >= 1e12 are already milliseconds.
+ */
+function toMillis(timestamp: number): number {
+	return timestamp < 1e12 ? timestamp * 1000 : timestamp;
+}
+
+// ── SQLite Row Types ─────────────────────────────────────────────────
+
+interface OpenCodeMessage {
+	data: string; // JSON
+	id: string;
+	session_id: string;
+	time_created: number;
+	time_updated: number;
+}
+
+interface OpenCodePart {
+	data: string; // JSON
+	id: string;
+	message_id: string;
+	session_id: string;
+	time_created: number;
+	time_updated: number;
+}
+
+/** Raw part data as stored in OpenCode's SQLite `part.data` JSON column. */
+interface OpenCodePartData {
+	callID?: string;
+	id?: string;
+	state?: { input?: Record<string, unknown> };
+	text?: string;
+	tool?: string;
+	type: string;
+}
+
+// ── Per-session Watcher State ────────────────────────────────────────
+
+interface OpenCodeSession {
+	directory: string;
+	id: string;
+	time_created: number;
+	time_updated: number;
+}
+
+interface WatchState {
+	callbacks: Set<(messages: ConversationMessage[]) => void>;
+	/** Set of message IDs we have already emitted, to avoid duplicates. */
+	emittedMessageIds: Set<string>;
+	/** Set of part IDs we have already emitted, to avoid duplicates on update. */
+	emittedPartIds: Set<string>;
+	intervalHandle: ReturnType<typeof setInterval>;
+	/** Highest time_created we have seen for messages (milliseconds). */
+	lastMessageTime: number;
+	/** Highest time_updated we have seen for parts (milliseconds). */
+	lastPartTime: number;
+	sessionId: string;
+}
+
+// ── OpenCodeWatcher Class ────────────────────────────────────────────
+
+class OpenCodeWatcher {
+	private watchers = new Map<string, WatchState>();
+
+	/**
+	 * Find the most recent non-archived OpenCode session that matches
+	 * the given working directory. Checks session.directory equals or
+	 * starts with `cwd`.
+	 *
+	 * Returns the session ID or null if none found.
+	 */
+	findSessionId(cwd: string, createdAfter?: number): null | string {
+		const db = openDb();
+		if (!db) {
+			return null;
+		}
+
+		try {
+			// Match sessions that were active (updated) after the terminal was launched.
+			// OpenCode resumes existing sessions rather than always creating new ones,
+			// so we filter on time_updated (not time_created) to find the session
+			// that's being actively used by this terminal instance.
+			//
+			// createdAfter is JS milliseconds (Date.getTime()), but OpenCode may
+			// store time_updated in seconds.  Use the smaller of the two
+			// representations so the filter works regardless of DB unit.
+			const timeFilter = createdAfter
+				? Math.min(createdAfter, Math.floor(createdAfter / 1000))
+				: 0;
+			const row = db
+				.prepare(
+					`
+				SELECT id
+				FROM session
+				WHERE (time_archived IS NULL OR time_archived = 0)
+				  AND (directory = ? OR directory LIKE ? || '/%')
+				  AND time_updated > ?
+				ORDER BY time_updated DESC
+				LIMIT 1
+			`
+				)
+				.get(cwd, cwd, timeFilter) as OpenCodeSession | undefined;
+
+			return row?.id ?? null;
+		} catch (error) {
+			console.error('[opencode-watcher] Failed to find session:', error);
+			return null;
+		} finally {
+			db.close();
+		}
+	}
+
+	/**
+	 * Read all messages and parts for a session from SQLite, converting
+	 * them to ConversationMessage format.
+	 */
+	getHistory(sessionId: string): ConversationMessage[] {
+		const db = openDb();
+		if (!db) {
+			return [];
+		}
+
+		try {
+			// Fetch all messages for this session, ordered chronologically.
+			const messages = db
+				.prepare(
+					`
+				SELECT id, session_id, time_created, time_updated, data
+				FROM message
+				WHERE session_id = ?
+				ORDER BY time_created ASC
+			`
+				)
+				.all(sessionId) as OpenCodeMessage[];
+
+			if (messages.length === 0) {
+				return [];
+			}
+
+			// Fetch all parts for these messages (batched to avoid SQLite param limit).
+			const messageIds = messages.map((m) => m.id);
+			const parts = batchInQuery<OpenCodePart>(
+				db,
+				`SELECT id, message_id, session_id, time_created, time_updated, data
+				FROM part
+				WHERE message_id IN (__PLACEHOLDERS__)
+				ORDER BY time_created ASC`,
+				messageIds
+			);
+
+			// Group parts by message ID.
+			const partsByMessage = new Map<string, OpenCodePart[]>();
+			for (const part of parts) {
+				if (!partsByMessage.has(part.message_id)) {
+					partsByMessage.set(part.message_id, []);
+				}
+				partsByMessage.get(part.message_id)!.push(part);
+			}
+
+			return this.buildMessages(messages, partsByMessage);
+		} catch (error) {
+			console.error('[opencode-watcher] Failed to read history:', error);
+			return [];
+		} finally {
+			db.close();
+		}
+	}
+
+	/**
+	 * Stop watching a specific session. If a callback is provided, only that
+	 * subscriber is removed — the interval keeps running while other subscribers
+	 * remain. If no callback is provided, all subscribers and the interval are
+	 * cleared (backward compat).
+	 */
+	stop(sessionId: string, callback?: (messages: ConversationMessage[]) => void): void {
+		const state = this.watchers.get(sessionId);
+		if (!state) {
+			return;
+		}
+
+		if (callback) {
+			state.callbacks.delete(callback);
+			console.log(
+				`[opencode-watcher] Removed subscriber from session: ${sessionId} ` +
+					`(remaining=${state.callbacks.size})`
+			);
+
+			// Only tear down the interval when no subscribers remain.
+			if (state.callbacks.size > 0) {
+				return;
+			}
+		}
+
+		clearInterval(state.intervalHandle);
+		this.watchers.delete(sessionId);
+		console.log(`[opencode-watcher] Stopped watching session: ${sessionId}`);
+	}
+
+	/**
+	 * Stop all active watchers.
+	 */
+	stopAll(): void {
+		for (const [sessionId] of this.watchers) {
+			this.stop(sessionId);
+		}
+	}
+
+	/**
+	 * Start polling the SQLite DB every 2 seconds for new messages/parts
+	 * in the given session. Converts new data to ConversationMessage
+	 * format and invokes the callback.
+	 */
+	watch(sessionId: string, callback: (messages: ConversationMessage[]) => void): void {
+		const existing = this.watchers.get(sessionId);
+		if (existing) {
+			// Already watching — just add the new callback, don't create a new interval.
+			existing.callbacks.add(callback);
+			console.log(
+				`[opencode-watcher] Added subscriber to session: ${sessionId} ` +
+					`(total=${existing.callbacks.size})`
+			);
+			return;
+		}
+
+		// Determine the initial high-water marks by scanning existing data.
+		const { emittedMessageIds, emittedPartIds, lastMessageTime, lastPartTime } =
+			this.getHighWaterMarks(sessionId);
+
+		const intervalHandle = setInterval(() => {
+			this.poll(sessionId);
+		}, POLL_INTERVAL_MS);
+
+		const state: WatchState = {
+			callbacks: new Set([callback]),
+			emittedMessageIds,
+			emittedPartIds,
+			intervalHandle,
+			lastMessageTime,
+			lastPartTime,
+			sessionId
+		};
+
+		this.watchers.set(sessionId, state);
+		console.log(
+			`[opencode-watcher] Watching session: ${sessionId} ` +
+				`(lastMsg=${lastMessageTime}, lastPart=${lastPartTime})`
+		);
+	}
+
+	// ── Private Helpers ────────────────────────────────────────────────
+
+	/**
+	 * Convert OpenCode messages + their parts into ConversationMessage
+	 * objects for consumption by the session handler.
+	 */
+	private buildMessages(
+		messages: OpenCodeMessage[],
+		partsByMessage: Map<string, OpenCodePart[]>
+	): ConversationMessage[] {
+		const result: ConversationMessage[] = [];
+
+		for (const msg of messages) {
+			// Parse message data to determine role.
+			let msgData: { agent?: string; role?: string } = {};
+			try {
+				msgData = JSON.parse(msg.data) as typeof msgData;
+			} catch {
+				// Skip unparseable message data.
+				continue;
+			}
+
+			const role = msgData.role === 'user' ? 'user' : 'assistant';
+			const msgParts = partsByMessage.get(msg.id) || [];
+
+			// Convert each part to a MessagePart.
+			const parts: MessagePart[] = [];
+
+			for (const part of msgParts) {
+				let partData: OpenCodePartData;
+				try {
+					partData = JSON.parse(part.data) as OpenCodePartData;
+				} catch {
+					continue;
+				}
+
+				const converted = convertPartToMessagePart(partData);
+				if (converted) {
+					parts.push(converted);
+				}
+			}
+
+			// Skip messages with no usable content.
+			if (parts.length === 0) {
+				console.debug(`[opencode-watcher] Skipping message ${msg.id} (no usable parts)`);
+				continue;
+			}
+
+			result.push({
+				id: msg.id,
+				parts,
+				role,
+				timestamp: new Date(toMillis(msg.time_created)).toISOString(),
+			});
+		}
+
+		return result;
+	}
+
+	/**
+	 * Scan existing messages/parts to determine the starting high-water
+	 * marks for time-based polling. Also collects the set of already-seen
+	 * message IDs so we do not re-emit them.
+	 */
+	private getHighWaterMarks(sessionId: string): {
+		emittedMessageIds: Set<string>;
+		emittedPartIds: Set<string>;
+		lastMessageTime: number;
+		lastPartTime: number;
+	} {
+		const db = openDb();
+		if (!db) {
+			return { emittedMessageIds: new Set(), emittedPartIds: new Set(), lastMessageTime: 0, lastPartTime: 0 };
+		}
+
+		try {
+			const msgRow = db
+				.prepare(
+					`
+				SELECT MAX(time_created) as maxTime
+				FROM message
+				WHERE session_id = ?
+			`
+				)
+				.get(sessionId) as undefined | { maxTime: null | number };
+
+			const partRow = db
+				.prepare(
+					`
+				SELECT MAX(time_updated) as maxTime
+				FROM part
+				WHERE session_id = ?
+			`
+				)
+				.get(sessionId) as undefined | { maxTime: null | number };
+
+			// Collect all existing message IDs.
+			const existingIds = db
+				.prepare(
+					`
+				SELECT id FROM message WHERE session_id = ?
+			`
+				)
+				.all(sessionId) as { id: string }[];
+
+			const emittedMessageIds = new Set(existingIds.map((r) => r.id));
+
+			// Collect all existing part IDs.
+			const existingPartIds = db
+				.prepare(
+					`
+				SELECT id FROM part WHERE session_id = ?
+			`
+				)
+				.all(sessionId) as { id: string }[];
+
+			const emittedPartIds = new Set(existingPartIds.map((r) => r.id));
+
+			return {
+				emittedMessageIds,
+				emittedPartIds,
+				lastMessageTime: msgRow?.maxTime ?? 0,
+				lastPartTime: partRow?.maxTime ?? 0
+			};
+		} catch (error) {
+			console.error('[opencode-watcher] Failed to get high-water marks:', error);
+			return { emittedMessageIds: new Set(), emittedPartIds: new Set(), lastMessageTime: 0, lastPartTime: 0 };
+		} finally {
+			db.close();
+		}
+	}
+
+	/**
+	 * Single poll iteration. Opens the DB, queries for new messages and
+	 * updated parts, converts them to ConversationMessage[], and invokes
+	 * the watcher callbacks.
+	 */
+	private poll(sessionId: string): void {
+		const state = this.watchers.get(sessionId);
+		if (!state) {
+			return;
+		}
+
+		const db = openDb();
+		if (!db) {
+			return;
+		}
+
+		try {
+			const results: ConversationMessage[] = [];
+
+			// ── 1. Check for brand-new messages ──────────────────────────
+			const newMessages = db
+				.prepare(
+					`
+				SELECT id, session_id, time_created, time_updated, data
+				FROM message
+				WHERE session_id = ? AND time_created > ?
+				ORDER BY time_created ASC
+			`
+				)
+				.all(sessionId, state.lastMessageTime) as OpenCodeMessage[];
+
+			if (newMessages.length > 0) {
+				// Deduplicate: skip messages we have already emitted (guards
+				// against clock-tie edge cases where time_created equals the
+				// high-water mark and the row slips through the > filter again).
+				const dedupedMessages = newMessages.filter(
+					(m) => !state.emittedMessageIds.has(m.id)
+				);
+
+				if (dedupedMessages.length > 0) {
+					// Fetch parts for these new messages (batched to avoid SQLite param limit).
+					const newMsgIds = dedupedMessages.map((m) => m.id);
+					const newParts = batchInQuery<OpenCodePart>(
+						db,
+						`SELECT id, message_id, session_id, time_created, time_updated, data
+						FROM part
+						WHERE message_id IN (__PLACEHOLDERS__)
+						ORDER BY time_created ASC`,
+						newMsgIds
+					);
+
+					// Group parts by message.
+					const partsByMessage = new Map<string, OpenCodePart[]>();
+					for (const part of newParts) {
+						if (!partsByMessage.has(part.message_id)) {
+							partsByMessage.set(part.message_id, []);
+						}
+						partsByMessage.get(part.message_id)!.push(part);
+					}
+
+					const newEntries = this.buildMessages(dedupedMessages, partsByMessage);
+					results.push(...newEntries);
+
+					// Track emitted part IDs and update part high-water mark.
+					for (const part of newParts) {
+						if (part.time_updated > state.lastPartTime) {
+							state.lastPartTime = part.time_updated;
+						}
+						state.emittedPartIds.add(part.id);
+					}
+				}
+
+				// Always update message high-water marks (even for already-emitted messages).
+				for (const msg of newMessages) {
+					if (msg.time_created > state.lastMessageTime) {
+						state.lastMessageTime = msg.time_created;
+					}
+					state.emittedMessageIds.add(msg.id);
+				}
+			}
+
+			// ── 2. Check for updated parts on existing messages ──────────
+			// Parts may be added or updated after the initial message row is
+			// created (e.g., streaming assistant response). Look for parts
+			// whose time_updated exceeds our last-seen mark, but whose parent
+			// message is NOT in the new-messages set (those were handled above).
+			const updatedParts = db
+				.prepare(
+					`
+				SELECT id, message_id, session_id, time_created, time_updated, data
+				FROM part
+				WHERE session_id = ? AND time_updated > ?
+				ORDER BY time_created ASC
+			`
+				)
+				.all(sessionId, state.lastPartTime) as OpenCodePart[];
+
+			if (updatedParts.length > 0) {
+				// Filter out parts that belong to messages we just processed,
+				// AND parts we have already emitted (avoid duplicates).
+				const newMsgIdSet = new Set(newMessages.map((m) => m.id));
+				const newParts = updatedParts.filter(
+					(p) => !newMsgIdSet.has(p.message_id) && !state.emittedPartIds.has(p.id)
+				);
+
+				if (newParts.length > 0) {
+					// Group the NEW parts by message ID.
+					const partsByMessage = new Map<string, OpenCodePart[]>();
+					for (const part of newParts) {
+						if (!partsByMessage.has(part.message_id)) {
+							partsByMessage.set(part.message_id, []);
+						}
+						partsByMessage.get(part.message_id)!.push(part);
+					}
+
+					// Fetch the parent messages for context (batched to avoid SQLite param limit).
+					const affectedMsgIds = [...partsByMessage.keys()];
+					const affectedMessages = batchInQuery<OpenCodeMessage>(
+						db,
+						`SELECT id, session_id, time_created, time_updated, data
+						FROM message
+						WHERE id IN (__PLACEHOLDERS__)
+						ORDER BY time_created ASC`,
+						affectedMsgIds
+					);
+
+					// Build entries from ONLY the new parts (delta), not all
+					// parts for the message. This prevents re-emitting content
+					// the session handler has already seen.
+					const updatedEntries = this.buildMessages(affectedMessages, partsByMessage);
+					results.push(...updatedEntries);
+
+					// Track emitted part IDs.
+					for (const part of newParts) {
+						state.emittedPartIds.add(part.id);
+					}
+				}
+
+				// Update part high-water mark.
+				for (const part of updatedParts) {
+					if (part.time_updated > state.lastPartTime) {
+						state.lastPartTime = part.time_updated;
+					}
+				}
+			}
+
+			// ── 3. Invoke all callbacks if there are new entries ─────────
+			if (results.length > 0) {
+				for (const cb of state.callbacks) {
+					try {
+						cb(results);
+					} catch (cbError) {
+						console.error('[opencode-watcher] Callback error:', cbError);
+					}
+				}
+			}
+		} catch (error) {
+			// Log but do not crash — the next poll will retry.
+			console.error('[opencode-watcher] Poll error:', error);
+		} finally {
+			db.close();
+		}
+	}
+}
+
+// ── Database Helpers ─────────────────────────────────────────────────
+
+/**
+ * Execute a SELECT query with an IN clause, batching in chunks of
+ * SQLITE_MAX_PARAMS to stay within SQLite's 999-parameter limit.
+ */
+function batchInQuery<T>(
+	db: Database.Database,
+	sql: string,
+	ids: string[]
+): T[] {
+	if (ids.length === 0) return [];
+
+	const results: T[] = [];
+	for (let i = 0; i < ids.length; i += SQLITE_MAX_PARAMS) {
+		const chunk = ids.slice(i, i + SQLITE_MAX_PARAMS);
+		const placeholders = chunk.map(() => '?').join(',');
+		const query = sql.replace('__PLACEHOLDERS__', placeholders);
+		const rows = db.prepare(query).all(...chunk) as T[];
+		results.push(...rows);
+	}
+	return results;
+}
+
+// ── Part Conversion ──────────────────────────────────────────────────
+// Maps OpenCode part types to MessagePart directly, skipping the
+// intermediate Record<string, unknown> stage.
+
+function convertPartToMessagePart(data: OpenCodePartData): MessagePart | null {
+	switch (data.type) {
+		case 'reasoning':
+			return { content: data.text || '', type: 'thinking' };
+
+		case 'text':
+			return { content: data.text || '', type: 'text' };
+
+		case 'tool':
+			return {
+				id: data.callID || data.id || '',
+				input: data.state?.input || {},
+				toolName: data.tool || 'Unknown',
+				type: 'tool_use'
+			};
+
+		default:
+			// Skip snapshot, patch, step-start, step-finish, subtask, retry, compaction
+			return null;
+	}
+}
+
+/**
+ * Open the OpenCode SQLite database in read-only mode.
+ * Returns null if the file does not exist or cannot be opened.
+ */
+function openDb(): Database.Database | null {
+	if (!fs.existsSync(OPENCODE_DB_PATH)) {
+		return null;
+	}
+	try {
+		return new Database(OPENCODE_DB_PATH, { readonly: true });
+	} catch {
+		return null;
+	}
+}
+
+// ── Singleton ────────────────────────────────────────────────────────
+// Use globalThis to ensure a single shared instance across module
+// loaders (same pattern as pty-manager and session-watcher).
+
+const OW_GLOBAL_KEY = '__shooter_opencode_watcher';
+export const openCodeWatcher: OpenCodeWatcher =
+	((globalThis as Record<string, unknown>)[OW_GLOBAL_KEY] as OpenCodeWatcher) ||
+	new OpenCodeWatcher();
+(globalThis as Record<string, unknown>)[OW_GLOBAL_KEY] = openCodeWatcher;