import { emptyCursor, normalizeNames, type NotifyTarget, type Watch, } from './watch-config.ts' import type { Storage } from './shared.ts' const LEGACY_KEY = 'inboundWatch' const LEGACY_MIGRATED_KEY = 'inboundWatchMigratedAt' export const LEGACY_ARMED_AT = '1970-01-01T00:00:00.000Z' export async function ensureWatchSchema(bucket: Storage) { await bucket.sql(` CREATE TABLE IF NOT EXISTS watches ( thread_id TEXT PRIMARY KEY, watch_json TEXT NOT NULL, version INTEGER NOT NULL DEFAULT 0, updated_at TEXT NOT NULL ) `) await bucket.sql(` CREATE TABLE IF NOT EXISTS self_agents ( thread_id TEXT NOT NULL, agent_id TEXT NOT NULL, added_at TEXT NOT NULL, PRIMARY KEY (thread_id, agent_id) ) `) await migrateLegacyWatch(bucket) } function str(value: unknown) { return typeof value === 'string' && value.trim() ? value.trim() : null } /** * 1.x kept one watch in kv `inboundWatch`. Copy it into `watches` once, as a * one-shot watch with its fired state, so a live watch keeps working exactly as * before. The kv row is left in place so a rollback to 1.x still sees it. */ export function legacyToWatch(value: string): Watch | null { let parsed: Record try { parsed = JSON.parse(value) as Record } catch { return null } const threadId = str(parsed.threadId) const viewUrl = str(parsed.viewUrl) if (!threadId || !viewUrl) return null const notifiedAt = str(parsed.notifiedAt) const cursorAgentId = str(parsed.cursorAgentId) const targets: NotifyTarget[] = [{ type: 'discord' }] if (cursorAgentId) targets.push({ type: 'cursor', agentId: cursorAgentId }) const skip = Array.isArray(parsed.skipFromNames) ? normalizeNames(parsed.skipFromNames) : ['cursor'] const now = new Date().toISOString() return { threadId, viewUrl, skipFromNames: skip, fire: 'once', minIntervalSeconds: 0, rewakeAfterSeconds: 300, includeSystem: true, note: null, targets, armedAt: LEGACY_ARMED_AT, updatedAt: now, cursor: emptyCursor(), batchOpenSince: null, pendingSinceWake: 0, lastFiredAt: notifiedAt, fireCount: notifiedAt ? 1 : 0, spent: Boolean(notifiedAt), lastResults: [], legacy: true, } } async function kvGet(bucket: Storage, key: string) { const result = await bucket.sql('SELECT value FROM kv WHERE key = ?', [key]) const value = result.rows[0]?.value return typeof value === 'string' ? value : null } async function migrateLegacyWatch(bucket: Storage) { if (await kvGet(bucket, LEGACY_MIGRATED_KEY)) return const legacy = await kvGet(bucket, LEGACY_KEY) const watch = legacy ? legacyToWatch(legacy) : null if (watch) { await bucket.sql( `INSERT INTO watches (thread_id, watch_json, version, updated_at) VALUES (?, ?, 0, ?) ON CONFLICT(thread_id) DO NOTHING`, [watch.threadId, JSON.stringify(watch), watch.updatedAt], ) } await bucket.sql( 'INSERT INTO kv (key, value) VALUES (?, ?) ON CONFLICT(key) DO NOTHING', [LEGACY_MIGRATED_KEY, new Date().toISOString()], ) } export type StoredWatch = { watch: Watch; version: number } function parseRow(row: Record | undefined): StoredWatch | null { if (!row || typeof row.watch_json !== 'string') return null try { return { watch: JSON.parse(row.watch_json) as Watch, version: Number(row.version ?? 0) } } catch { return null } } export async function getWatch(bucket: Storage, threadId: string) { const result = await bucket.sql( 'SELECT watch_json, version FROM watches WHERE thread_id = ?', [threadId], ) return parseRow(result.rows[0]) } export async function listWatches(bucket: Storage) { const result = await bucket.sql( 'SELECT watch_json, version FROM watches ORDER BY updated_at DESC LIMIT 100', ) return result.rows .map((row) => parseRow(row)) .filter((row): row is StoredWatch => row !== null) .map((row) => row.watch) } export async function putWatch(bucket: Storage, watch: Watch) { await bucket.sql( `INSERT INTO watches (thread_id, watch_json, version, updated_at) VALUES (?, ?, 0, ?) ON CONFLICT(thread_id) DO UPDATE SET watch_json = excluded.watch_json, version = watches.version + 1, updated_at = excluded.updated_at`, [watch.threadId, JSON.stringify(watch), watch.updatedAt], ) } /** Optimistic write: true only if nobody changed the row since `version`. */ export async function casWatch(bucket: Storage, watch: Watch, version: number) { const result = await bucket.sql( `UPDATE watches SET watch_json = ?, version = version + 1, updated_at = ? WHERE thread_id = ? AND version = ? RETURNING thread_id`, [JSON.stringify(watch), watch.updatedAt, watch.threadId, version], ) return result.rows.length > 0 } export async function deleteWatch(bucket: Storage, threadId: string) { const result = await bucket.sql( 'DELETE FROM watches WHERE thread_id = ? RETURNING thread_id', [threadId], ) return result.rows.length > 0 } export async function addSelfAgent(bucket: Storage, threadId: string, agentId: string) { await bucket.sql( `INSERT INTO self_agents (thread_id, agent_id, added_at) VALUES (?, ?, ?) ON CONFLICT(thread_id, agent_id) DO NOTHING`, [threadId, agentId, new Date().toISOString()], ) } export async function getSelfAgents(bucket: Storage, threadId: string) { const result = await bucket.sql( 'SELECT agent_id FROM self_agents WHERE thread_id = ?', [threadId], ) return result.rows.map((row) => String(row.agent_id)) }