/**

* LoopStore: persistent task store backed by JSON file.

*

* Layout: {storageDir}/tasks.json

* - Atomic writes (write to .tmp, rename)

* - Auto-expire tasks older than ttlMs

* - Per-session isolation (each task is bound to its owning sessionID)

* - On load, legacy tasks without sessionID are dropped

*

* Implementation note: opencode's plugin loader invokes `new X(...)` as `X(...)`

* (without `new`) when loading npm-resolved plugins, which makes `this`

* undefined inside function constructors. So we use a factory pattern that

* does NOT depend on `this`: every method reads from a closed-over `inst`.

*/

import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs"

import { join, dirname } from "node:path"

import type { LoopTask, CreateTaskInput } from "./types.js"

import { errorMessage, type LoopLogger } from "./runtime-feedback.js"

export interface LoopStoreOptions {

storageDir: string

maxTasks?: number

taskTtlMs?: number

logger?: LoopLogger

}

interface PersistedState {

version: 1

tasks: LoopTask[]

}

interface LoopStoreInstance {

state: PersistedState

filePath: string

maxTasks: number

taskTtlMs: number

load(): Promise<void>

persist(): Promise<void>

generateId(): string

create(input: CreateTaskInput): Promise<LoopTask>

cancel(id: string): Promise<LoopTask | null>

cancelByPromptPrefix(prefix: string): Promise<LoopTask | null>

cancelAll(): Promise<number>

cancelBySession(sessionID: string): Promise<number>

list(): LoopTask[]

listBySession(sessionID: string): LoopTask[]

get(id: string): LoopTask | null

getDueTasks(now?: number): Promise<LoopTask[]>

getDueTasksForSession(sessionID: string, now?: number): Promise<LoopTask[]>

getOrphanedTasks(): LoopTask[]

markFired(id: string, nextDueAt?: number): Promise<LoopTask | null>

reschedule(id: string, nextDueAt: number): Promise<LoopTask | null>

setPaused(id: string, paused: boolean): Promise<LoopTask | null>

logFire(task: LoopTask, success: boolean): Promise<void>

}

export type { LoopStoreInstance }

// Factory function — does NOT depend on `this`. Returns a plain object that

// holds all state and methods. Callers can use it as `new LoopStore(opts)`

// (returns the object directly when called with `new`) or `LoopStore(opts)`

// (also returns the object directly).

export function LoopStore(this: unknown, options?: LoopStoreOptions): LoopStoreInstance {

// IMPORTANT: do not access `this` here — opencode may call us without `new`,

// in which case `this` is undefined in strict mode.

void this

let logger: LoopLogger = async () => {}

const inst: LoopStoreInstance = {

state: { version: 1, tasks: [] },

filePath: "",

maxTasks: 50,

taskTtlMs: 7 * 24 * 60 * 60 * 1000,

load: async () => {

if (!existsSync(inst.filePath)) {

inst.state = { version: 1, tasks: [] }

return

}

try {

const raw = readFileSync(inst.filePath, "utf-8")

const parsed = JSON.parse(raw) as PersistedState

if (parsed.version !== 1) {

throw new Error(`Unsupported state version: ${parsed.version}`)

}

const cutoff = Date.now() - inst.taskTtlMs

const filtered = parsed.tasks.filter((t) => t.createdAt > cutoff && !!t.sessionID)

inst.state = { version: 1, tasks: filtered }

if (inst.state.tasks.length !== parsed.tasks.length) {

await inst.persist()

const dropped = parsed.tasks.length - inst.state.tasks.length

await logger("info", `cleaned ${dropped} task(s) on load (orphan/expired)`, {

count: dropped,

})

}

} catch (err) {

const backup = `${inst.filePath}.corrupted.${Date.now()}`

try {

renameSync(inst.filePath, backup)

} catch {

// ignore

}

inst.state = { version: 1, tasks: [] }

await logger("warn", "tasks.json was corrupted and archived", {

backup,

error: errorMessage(err),

})

}

},

persist: async () => {

const tmp = `${inst.filePath}.tmp`

mkdirSync(dirname(tmp), { recursive: true })

writeFileSync(tmp, JSON.stringify(inst.state, null, 2), "utf-8")

renameSync(tmp, inst.filePath)

},

generateId: () => {

const alphabet = "abcdefghijklmnopqrstuvwxyz0123456789"

let id = ""

for (let i = 0; i < 8; i++) {

id += alphabet[Math.floor(Math.random() * alphabet.length)]

}

return id

},

create: async (input) => {

if (inst.state.tasks.length >= inst.maxTasks) {

throw new Error(`Max tasks (${inst.maxTasks}) reached. Cancel some before adding more.`)

}

if (!input.prompt?.trim()) {

throw new Error("prompt must be non-empty")

}

if (!input.sessionID) {

throw new Error("sessionID is required for loop tasks (per-session scoping)")

}

const now = Date.now()

const task: LoopTask = {

id: inst.generateId(),

prompt: input.prompt,

mode: input.mode,

intervalMs: input.intervalMs,

adaptiveMinMs: input.adaptiveMinMs,

adaptiveMaxMs: input.adaptiveMaxMs,

createdAt: now,

lastFiredAt: 0,

nextDueAt: now + (input.intervalMs ?? input.adaptiveMaxMs ?? 60_000),

source: input.source ?? "user",

directory: input.directory,

sessionID: input.sessionID,

paused: false,

}

inst.state.tasks.push(task)

await inst.persist()

return task

},

cancel: async (id) => {

const idx = inst.state.tasks.findIndex((t) => t.id === id)

if (idx < 0) return null

const [removed] = inst.state.tasks.splice(idx, 1)

await inst.persist()

return removed

},

cancelByPromptPrefix: async (prefix) => {

const task = inst.state.tasks.find((t) => t.prompt.startsWith(prefix))

if (!task) return null

return inst.cancel(task.id)

},

cancelAll: async () => {

const n = inst.state.tasks.length

inst.state.tasks = []

await inst.persist()

return n

},

cancelBySession: async (sessionID) => {

if (!sessionID) return 0

const before = inst.state.tasks.length

inst.state.tasks = inst.state.tasks.filter((t) => t.sessionID !== sessionID)

const removed = before - inst.state.tasks.length

if (removed > 0) await inst.persist()

return removed

},

list: () => [...inst.state.tasks],

listBySession: (sessionID) => {

if (!sessionID) return []

return inst.state.tasks.filter((t) => t.sessionID === sessionID)

},

get: (id) => inst.state.tasks.find((t) => t.id === id) ?? null,

getDueTasks: async (now: number = Date.now()) => {

return inst.state.tasks.filter((t) => !t.paused && t.nextDueAt <= now)

},

getDueTasksForSession: async (sessionID: string, now: number = Date.now()) => {

if (!sessionID) return []

return inst.state.tasks.filter(

(t) => !t.paused && t.sessionID === sessionID && t.nextDueAt <= now

)

},

getOrphanedTasks: () => inst.state.tasks.filter((t) => !t.sessionID),

markFired: async (id, nextDueAt) => {

const task = inst.get(id)

if (!task) return null

task.lastFiredAt = Date.now()

if (nextDueAt !== undefined) {

task.nextDueAt = nextDueAt

} else if (task.mode === "fixed" && task.intervalMs) {

task.nextDueAt = task.lastFiredAt + task.intervalMs

} else if (task.mode === "maintenance" && task.adaptiveMaxMs) {

task.nextDueAt = task.lastFiredAt + task.adaptiveMaxMs

}

await inst.persist()

return task

},

reschedule: async (id, nextDueAt) => {

const task = inst.get(id)

if (!task) return null

task.nextDueAt = nextDueAt

await inst.persist()

return task

},

setPaused: async (id, paused) => {

const task = inst.get(id)

if (!task) return null

task.paused = paused

await inst.persist()

return task

},

logFire: async (task, success) => {

const logFile = join(dirname(inst.filePath), "history.log")

const line = JSON.stringify({

ts: Date.now(),

taskId: task.id,

mode: task.mode,

sessionID: task.sessionID,

prompt: task.prompt.slice(0, 200),

success,

})

try {

mkdirSync(dirname(logFile), { recursive: true })

const existing = existsSync(logFile) ? readFileSync(logFile, "utf-8") : ""

writeFileSync(logFile, existing + line + "\n", "utf-8")

} catch (err) {

await logger("warn", "failed to write fire history", {

error: errorMessage(err),

taskId: task.id,

})

}

},

}

if (options) {

logger = options.logger ?? logger

inst.filePath = join(options.storageDir, "tasks.json")

inst.maxTasks = options.maxTasks ?? 50

inst.taskTtlMs = options.taskTtlMs ?? 7 * 24 * 60 * 60 * 1000

if (!existsSync(options.storageDir)) {

mkdirSync(options.storageDir, { recursive: true })

}

}

return inst

}