@vikrant82/opencode-cache-keepalive 0.1.0

package/lib/tui/footer.tsx

@@ -0,0 +1,156 @@
+/** @jsxImportSource @opentui/solid */
+
+import { TextAttributes } from "@opentui/core"
+import { createSignal, onCleanup, Show } from "solid-js"
+import { readdirSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+import { stateDirectoryPath, stateFilePath } from "../paths"
+import type { PersistedSession, PersistedState, PingRecord } from "../state"
+import { kfmt, mmss } from "./format"
+
+type Theme = Record<string, any>
+type Status = "waiting" | "off" | "warming" | "busy" | "armed" | "cold"
+type Derived = {
+    idleMs: number
+    sent: number
+    left: number
+    status: Status
+    lastPing?: PingRecord
+}
+
+/**
+ * Persistent readout mounted in the `sidebar_footer` slot. Shows time since the
+ * last real agent response plus keepalive pings sent / left. Data comes from the
+ * server plugin's state file; the idle timer ticks locally every second.
+ */
+export function KeepaliveFooter(props: { theme: Theme; directory: string; sessionID?: string }) {
+    const [now, setNow] = createSignal(Date.now())
+    const [state, setState] = createSignal<PersistedState | undefined>(undefined)
+
+    const load = () => {
+        const sessionID = props.sessionID
+        if (!sessionID) return setState(undefined)
+
+        const expected = readState(stateFilePath(props.directory))
+        if (expected?.sessions?.[sessionID]) return setState(expected)
+
+        try {
+            const match = readdirSync(stateDirectoryPath())
+                .filter((name) => name.startsWith("state-") && name.endsWith(".json"))
+                .map((name) => readState(join(stateDirectoryPath(), name)))
+                .find((snapshot) => snapshot?.sessions?.[sessionID])
+            setState(match)
+        } catch {
+            setState(undefined)
+        }
+    }
+
+    load()
+    const timer = setInterval(() => {
+        setNow(Date.now())
+        load()
+    }, 1000)
+    onCleanup(() => clearInterval(timer))
+
+    const derived = (): Derived | undefined => {
+        const snapshot = state()
+        const sessionID = props.sessionID
+        if (!snapshot || !sessionID) {
+            return { idleMs: 0, sent: 0, left: 0, status: "waiting" }
+        }
+        const session: PersistedSession | undefined = snapshot.sessions?.[sessionID]
+        if (!session) return { idleMs: 0, sent: 0, left: 0, status: "waiting" }
+
+        const interval = session.intervalMs || snapshot.intervalMs || 270_000
+        const idleMs = Math.max(0, now() - (session.lastResponseAt || now()))
+        const left = session.active
+            ? Math.max(0, Math.floor((session.windowEndsAt - now()) / interval))
+            : 0
+        const status: Status =
+            !snapshot.enabled || !session.eligible
+                ? "off"
+                : session.warming
+                  ? "warming"
+                  : session.busy
+                    ? "busy"
+                    : session.active
+                      ? "armed"
+                      : "cold"
+
+        return { idleMs, sent: session.pingsSent || 0, left, status, lastPing: session.lastPing }
+    }
+
+    const theme = props.theme
+
+    return (
+        <Show when={derived()}>
+            {(data: () => Derived) => (
+                <box flexDirection="column" paddingLeft={1} paddingRight={1} paddingTop={1} gap={0}>
+                    <box flexDirection="row" gap={1}>
+                        <text fg={theme.primary} attributes={TextAttributes.BOLD}>
+                            keepalive
+                        </text>
+                        <text fg={statusColor(theme, data().status)}>
+                            {statusLabel(data().status)}
+                        </text>
+                    </box>
+
+                    <box flexDirection="row" gap={1}>
+                        <text fg={theme.textMuted}>idle</text>
+                        <text fg={theme.text} attributes={TextAttributes.BOLD}>
+                            {mmss(data().idleMs)}
+                        </text>
+                        <text fg={theme.textMuted}>· sent</text>
+                        <text fg={theme.text} attributes={TextAttributes.BOLD}>
+                            {String(data().sent)}
+                        </text>
+                        <text fg={theme.textMuted}>· left</text>
+                        <text fg={theme.text} attributes={TextAttributes.BOLD}>
+                            {String(data().left)}
+                        </text>
+                    </box>
+
+                    <Show when={data().lastPing}>
+                        {(ping: () => PingRecord) => (
+                            <box flexDirection="row" gap={1}>
+                                <text fg={ping().hit ? theme.success : theme.warning}>
+                                    {ping().hit ? "✓ hit" : "✗ miss"}
+                                </text>
+                                <text fg={theme.textMuted}>
+                                    input {kfmt(ping().input)} · read {kfmt(ping().cacheRead)} ·
+                                    write {kfmt(ping().cacheWrite)}
+                                </text>
+                            </box>
+                        )}
+                    </Show>
+                </box>
+            )}
+        </Show>
+    )
+}
+
+function statusLabel(status: Status): string {
+    if (status === "waiting") return "waiting"
+    if (status === "warming") return "warming…"
+    if (status === "busy") return "busy"
+    if (status === "armed") return "armed"
+    if (status === "cold") return "cold"
+    return "off"
+}
+
+function statusColor(theme: Theme, status: Status): any {
+    if (status === "waiting") return theme.textMuted
+    if (status === "warming") return theme.accent
+    if (status === "busy") return theme.info
+    if (status === "armed") return theme.success
+    if (status === "cold") return theme.warning
+    return theme.textMuted
+}
+
+function readState(path: string): PersistedState | undefined {
+    try {
+        return JSON.parse(readFileSync(path, "utf8")) as PersistedState
+    } catch {
+        return undefined
+    }
+}

package/lib/tui/format.ts

@@ -0,0 +1,13 @@
+export function mmss(ms: number): string {
+    const total = Math.max(0, Math.floor(ms / 1000))
+    const minutes = Math.floor(total / 60)
+    const seconds = total % 60
+    return `${minutes}:${seconds.toString().padStart(2, "0")}`
+}
+
+export function kfmt(n: number): string {
+    if (!Number.isFinite(n) || n <= 0) return "0"
+    if (n < 1000) return `${Math.round(n)}`
+    const k = n / 1000
+    return `${k >= 10 ? Math.round(k) : k.toFixed(1)}k`
+}

package/package.json

@@ -0,0 +1,71 @@
+{
+    "$schema": "https://json.schemastore.org/package.json",
+    "name": "@vikrant82/opencode-cache-keepalive",
+    "version": "0.1.0",
+    "type": "module",
+    "description": "OpenCode plugin that keeps provider prompt caches warm by sending invisible keepalive pings, with a live TUI readout",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        },
+        "./server": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        },
+        "./tui": {
+            "types": "./dist/tui.d.ts",
+            "import": "./tui.tsx"
+        }
+    },
+    "scripts": {
+        "clean": "rm -rf dist",
+        "build": "npm run clean && tsup && tsc --emitDeclarationOnly",
+        "dev": "opencode plugin dev",
+        "typecheck": "tsc --noEmit",
+        "format": "prettier --write .",
+        "format:check": "prettier --check ."
+    },
+    "keywords": [
+        "opencode",
+        "opencode-plugin",
+        "plugin",
+        "prompt-cache",
+        "cache",
+        "keepalive",
+        "github-copilot",
+        "anthropic",
+        "claude",
+        "gpt"
+    ],
+    "author": "vikrant82",
+    "license": "AGPL-3.0-or-later",
+    "peerDependencies": {
+        "@opencode-ai/plugin": ">=1.4.3",
+        "@opentui/core": "^0.4.2",
+        "@opentui/solid": "^0.4.2",
+        "solid-js": "^1.9.12"
+    },
+    "dependencies": {
+        "@opencode-ai/sdk": "^1.4.3"
+    },
+    "devDependencies": {
+        "@opencode-ai/plugin": "^1.4.3",
+        "@opentui/core": "^0.4.2",
+        "@opentui/solid": "^0.4.2",
+        "@types/node": "^22.0.0",
+        "prettier": "^3.4.0",
+        "solid-js": "^1.9.12",
+        "tsup": "^8.5.1",
+        "typescript": "^5.7.0"
+    },
+    "files": [
+        "dist/",
+        "lib/",
+        "tui.tsx",
+        "README.md",
+        "LICENSE"
+    ]
+}

package/tui.tsx

@@ -0,0 +1,25 @@
+/** @jsxImportSource @opentui/solid */
+
+import type { TuiPluginModule } from "@opencode-ai/plugin/tui"
+import { registerKeepaliveCommands } from "./lib/tui/commands"
+import { KeepaliveFooter } from "./lib/tui/footer"
+
+const tui: TuiPluginModule["tui"] = async (api) => {
+    registerKeepaliveCommands(api)
+    api.slots.register({
+        // The built-in sidebar footer uses order 100. This slot is single-winner,
+        // so a lower order makes the keepalive readout the visible footer.
+        order: 0,
+        slots: {
+            sidebar_footer: (ctx, props) => (
+                <KeepaliveFooter
+                    theme={ctx.theme.current}
+                    directory={api.state.path.directory}
+                    sessionID={props.session_id}
+                />
+            ),
+        },
+    })
+}
+
+export default { id: "opencode-cache-keepalive", tui } satisfies TuiPluginModule