@vikrant82/opencode-cache-keepalive 0.1.5 → 0.2.0

package/lib/control.ts

@@ -1,35 +1,84 @@
+import { randomUUID } from "node:crypto"
 import { readFileSync } from "node:fs"
 import { mkdir, rename, writeFile } from "node:fs/promises"
 import { dirname } from "node:path"
 import { controlFilePath } from "./paths"
 
-export type KeepaliveControl = {
-    version: 1
-    enabled: boolean
-    updatedAt: number
-}
+const VERSION = 2
+const MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000
+
+export type SessionControl = { enabled: boolean; updatedAt: number }
+export type SessionControlFile = { version: 2; sessions: Record<string, SessionControl> }
 
-export function readControl(directory: string): KeepaliveControl | undefined {
+/** Read current session overrides; old folder-level controls are intentionally ignored. */
+export function readSessionControls(directory: string, now = Date.now()): SessionControlFile {
     try {
-        const value = JSON.parse(
-            readFileSync(controlFilePath(directory), "utf8"),
-        ) as Partial<KeepaliveControl>
-        if (value.version !== 1 || typeof value.enabled !== "boolean") return undefined
-        if (typeof value.updatedAt !== "number") return undefined
-        return value as KeepaliveControl
+        const value = JSON.parse(readFileSync(controlFilePath(directory), "utf8")) as Record<
+            string,
+            unknown
+        >
+        if (value.version !== VERSION || !value.sessions || typeof value.sessions !== "object")
+            return { version: VERSION, sessions: {} }
+        const sessions: Record<string, SessionControl> = {}
+        for (const [id, raw] of Object.entries(value.sessions)) {
+            if (
+                !raw ||
+                typeof raw !== "object" ||
+                typeof (raw as SessionControl).enabled !== "boolean" ||
+                typeof (raw as SessionControl).updatedAt !== "number" ||
+                (raw as SessionControl).updatedAt < now - MAX_AGE_MS
+            )
+                continue
+            sessions[id] = {
+                enabled: (raw as SessionControl).enabled,
+                updatedAt: (raw as SessionControl).updatedAt,
+            }
+        }
+        return { version: VERSION, sessions }
     } catch {
-        return undefined
+        return { version: VERSION, sessions: {} }
     }
 }
 
-export async function writeControl(enabled: boolean, directory: string): Promise<KeepaliveControl> {
-    const value: KeepaliveControl = {
-        version: 1,
-        enabled,
-        updatedAt: Date.now(),
-    }
+export function readSessionControl(
+    directory: string,
+    sessionID: string,
+): SessionControl | undefined {
+    return readSessionControls(directory).sessions[sessionID]
+}
+
+/** Atomically update only this session key and prune expired overrides. */
+export async function setSessionEnabled(
+    directory: string,
+    sessionID: string,
+    enabled: boolean,
+    now = Date.now(),
+): Promise<SessionControlFile> {
+    const run = updateQueue.then(() => writeSessionControl(directory, sessionID, enabled, now))
+    updateQueue = run.then(
+        () => undefined,
+        () => undefined,
+    )
+    return run
+}
+
+let updateQueue: Promise<void> = Promise.resolve()
+
+async function writeSessionControl(
+    directory: string,
+    sessionID: string,
+    enabled: boolean,
+    now: number,
+): Promise<SessionControlFile> {
+    const current = readSessionControls(directory, now)
+    const cutoff = now - MAX_AGE_MS
+    const sessions = Object.fromEntries(
+        Object.entries(current.sessions).filter(([, value]) => value.updatedAt >= cutoff),
+    )
+    sessions[sessionID] = { enabled, updatedAt: now }
+    const value: SessionControlFile = { version: VERSION, sessions }
     const path = controlFilePath(directory)
-    const tmp = `${path}.${process.pid}.${value.updatedAt}.tmp`
+    const tmp = `${path}.${process.pid}.${randomUUID()}.tmp`
     await mkdir(dirname(path), { recursive: true })
     await writeFile(tmp, `${JSON.stringify(value)}\n`, "utf8")
     await rename(tmp, path)

package/lib/paths.ts

@@ -2,17 +2,17 @@ import { createHash } from "node:crypto"
 import { homedir } from "node:os"
 import { join } from "node:path"
 
-/**
- * Absolute path to the JSON state file shared between the server plugin (writer)
- * and the TUI plugin (reader). Both processes run on the same machine, so a file
- * under opencode's plugin storage dir is the simplest cross-process channel.
- *
- * Mirrors the storage layout used by other opencode plugins:
- *   <XDG_DATA_HOME | ~/.local/share>/opencode/storage/plugin/keepalive/state.json
- */
-export function stateFilePath(directory: string): string {
-    const key = createHash("sha256").update(directory).digest("hex").slice(0, 16)
-    return join(stateDirectoryPath(), `state-${key}.json`)
+/** Stable short directory key shared by that directory's state-file readers/writers. */
+export function stateDirectoryKey(directory: string): string {
+    return createHash("sha256").update(directory).digest("hex").slice(0, 16)
+}
+
+/** Filename for one process/plugin-instance state snapshot. */
+export function instanceStateFilePath(directory: string, pid: number, instanceId: string): string {
+    return join(
+        stateDirectoryPath(),
+        `state-v2-${stateDirectoryKey(directory)}-${pid}-${instanceId}.json`,
+    )
 }
 
 export function stateDirectoryPath(): string {
@@ -26,9 +26,7 @@ export function stateDirectoryPath(): string {
 }
 
 /**
- * Runtime on/off control written by the TUI and read by the server plugin.
- * Scoped per directory (like the state file) so toggling keepalive in one
- * project does not affect every other open opencode session.
+ * Session runtime controls are stored by directory, with entries keyed by session ID.
  */
 export function controlFilePath(directory: string): string {
     const key = createHash("sha256").update(directory).digest("hex").slice(0, 16)