@tokentop/ttop 0.3.0 → 0.5.0

package/src/plugins/registry.ts

@@ -1,11 +1,3 @@
-import type { PluginsConfig } from "@/config/schema.ts";
-import {
-  discoverLocalPlugins,
-  loadLocalPlugin,
-  loadNpmPlugin,
-  resolvePluginPath,
-} from "./loader.ts";
-import { installAllNpmPlugins, resolveNpmPluginPath } from "./npm-installer.ts";
 import type {
   AgentPlugin,
   AnyPlugin,
@@ -14,7 +6,15 @@ import type {
   PluginType,
   ProviderPlugin,
   ThemePlugin,
-} from "./types/index.ts";
+} from "@tokentop/plugin-sdk";
+import type { PluginsConfig } from "@/config/schema.ts";
+import {
+  discoverLocalPlugins,
+  loadLocalPlugin,
+  loadNpmPlugin,
+  resolvePluginPath,
+} from "./loader.ts";
+import { installAllNpmPlugins, resolveNpmPluginPath } from "./npm-installer.ts";
 
 export type PluginSource = "builtin" | "local" | "npm";
 
@@ -35,6 +35,7 @@ class PluginRegistryImpl {
 
   private sources = new Map<string, PluginSource>();
   private initialized = false;
+  private officialIds = new Set<string>();
 
   private sourceKey(type: string, id: string): string {
     return `${type}-${id}`;
@@ -44,37 +45,20 @@ class PluginRegistryImpl {
     const key = this.sourceKey(plugin.type, plugin.id);
     const existingSource = this.sources.get(key);
 
-    if (existingSource === "builtin" && source !== "builtin") {
+    // Priority: local > npm > builtin
+    // If a higher-priority source already registered this plugin, skip.
+    const priority: Record<PluginSource, number> = { local: 2, npm: 1, builtin: 0 };
+    if (existingSource && priority[existingSource] > priority[source]) {
       return;
     }
 
-    this.sources.set(key, source);
-    switch (plugin.type) {
-      case "provider":
-        if (this.plugins.provider.has(plugin.id)) {
-          console.warn(`Plugin "${plugin.id}" already registered, overwriting`);
-        }
-        this.plugins.provider.set(plugin.id, plugin);
-        break;
-      case "agent":
-        if (this.plugins.agent.has(plugin.id)) {
-          console.warn(`Plugin "${plugin.id}" already registered, overwriting`);
-        }
-        this.plugins.agent.set(plugin.id, plugin);
-        break;
-      case "theme":
-        if (this.plugins.theme.has(plugin.id)) {
-          console.warn(`Plugin "${plugin.id}" already registered, overwriting`);
-        }
-        this.plugins.theme.set(plugin.id, plugin);
-        break;
-      case "notification":
-        if (this.plugins.notification.has(plugin.id)) {
-          console.warn(`Plugin "${plugin.id}" already registered, overwriting`);
-        }
-        this.plugins.notification.set(plugin.id, plugin);
-        break;
+    if (existingSource && existingSource !== source) {
+      console.info(`Plugin "${plugin.id}" overridden by ${source} (was ${existingSource})`);
     }
+
+    this.sources.set(key, source);
+    const map = this.plugins[plugin.type] as Map<string, AnyPlugin>;
+    map.set(plugin.id, plugin);
   }
 
   unregister(type: PluginType, id: string): boolean {
@@ -118,6 +102,10 @@ class PluginRegistryImpl {
     return this.sources.get(this.sourceKey(type, id));
   }
 
+  isOfficial(type: PluginType, id: string): boolean {
+    return this.officialIds.has(this.sourceKey(type, id));
+  }
+
   async loadBuiltinPlugins(): Promise<void> {
     const [providers, agents, themes, notifications] = await Promise.all([
       import("./providers/index.ts"),
@@ -127,19 +115,31 @@ class PluginRegistryImpl {
     ]);
 
     for (const plugin of Object.values(providers)) {
-      if (isProviderPlugin(plugin)) this.register(plugin, "builtin");
+      if (isProviderPlugin(plugin)) {
+        this.register(plugin, "builtin");
+        this.officialIds.add(this.sourceKey(plugin.type, plugin.id));
+      }
     }
 
     for (const plugin of Object.values(agents)) {
-      if (isAgentPlugin(plugin)) this.register(plugin, "builtin");
+      if (isAgentPlugin(plugin)) {
+        this.register(plugin, "builtin");
+        this.officialIds.add(this.sourceKey(plugin.type, plugin.id));
+      }
     }
 
     for (const plugin of Object.values(themes)) {
-      if (isThemePlugin(plugin)) this.register(plugin, "builtin");
+      if (isThemePlugin(plugin)) {
+        this.register(plugin, "builtin");
+        this.officialIds.add(this.sourceKey(plugin.type, plugin.id));
+      }
     }
 
     for (const plugin of Object.values(notifications)) {
-      if (isNotificationPlugin(plugin)) this.register(plugin, "builtin");
+      if (isNotificationPlugin(plugin)) {
+        this.register(plugin, "builtin");
+        this.officialIds.add(this.sourceKey(plugin.type, plugin.id));
+      }
     }
   }
 
@@ -148,13 +148,13 @@ class PluginRegistryImpl {
     const resolvedExtraPaths = extraPaths.map((p) => resolvePluginPath(p));
     const allPaths = [...discoveredPaths, ...resolvedExtraPaths];
 
-    for (const pluginPath of allPaths) {
-      const result = await loadLocalPlugin(pluginPath);
+    const results = await Promise.all(allPaths.map((p) => loadLocalPlugin(p)));
+    for (const [i, result] of results.entries()) {
       if (result.success && result.plugin) {
         this.register(result.plugin, "local");
         console.info(`Loaded local plugin: ${result.plugin.name} (${result.plugin.id})`);
       } else {
-        console.warn(`Failed to load plugin from ${pluginPath}: ${result.error}`);
+        console.warn(`Failed to load plugin from ${allPaths[i]}: ${result.error}`);
       }
     }
   }
@@ -171,9 +171,14 @@ class PluginRegistryImpl {
       }
     }
 
-    for (const packageName of packages) {
-      const resolvedPath = resolveNpmPluginPath(packageName);
-      const result = await loadNpmPlugin(packageName, resolvedPath);
+    const loadResults = await Promise.all(
+      packages.map(async (packageName) => {
+        const resolvedPath = resolveNpmPluginPath(packageName);
+        const result = await loadNpmPlugin(packageName, resolvedPath);
+        return { packageName, result };
+      }),
+    );
+    for (const { packageName, result } of loadResults) {
       if (result.success && result.plugin) {
         this.register(result.plugin, "npm");
         console.info(`Loaded npm plugin: ${result.plugin.name} (${packageName})`);

package/src/plugins/sandbox-guard.test.ts

@@ -1,11 +1,11 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { PluginPermissionError } from "@tokentop/plugin-sdk";
 import {
   deepFreeze,
   getActivePluginGuard,
   installGlobalFetchGuard,
   runInPluginGuard,
 } from "./sandbox-guard.ts";
-import { PluginPermissionError } from "./types/base.ts";
 
 const originalFetch = globalThis.fetch;
 const fetchCalls: string[] = [];

package/src/plugins/sandbox-guard.ts

@@ -11,9 +11,9 @@
  * 2. **Deep-freeze** — prevents plugins from mutating the PluginContext.
  */
 
+import { PluginPermissionError, type PluginPermissions } from "@tokentop/plugin-sdk";
 import { AsyncLocalStorage } from "async_hooks";
 import { createPluginLogger } from "./sandbox.ts";
-import { PluginPermissionError, type PluginPermissions } from "./types/base.ts";
 
 // ---------------------------------------------------------------------------
 // Plugin execution context (AsyncLocalStorage)

package/src/plugins/sandbox.ts

@@ -3,7 +3,7 @@ import {
   type PluginLogger,
   PluginPermissionError,
   type PluginPermissions,
-} from "./types/index.ts";
+} from "@tokentop/plugin-sdk";
 
 export function createSandboxedHttpClient(
   pluginId: string,

package/src/plugins/themes/catppuccin-latte.ts

@@ -1,4 +1,4 @@
-import type { ThemePlugin } from "../types/theme.ts";
+import type { ThemePlugin } from "@tokentop/plugin-sdk";
 
 export const catppuccinLatteTheme: ThemePlugin = {
   apiVersion: 2,

package/src/plugins/themes/catppuccin-mocha.ts

@@ -1,4 +1,4 @@
-import type { ThemePlugin } from "../types/theme.ts";
+import type { ThemePlugin } from "@tokentop/plugin-sdk";
 
 export const catppuccinMochaTheme: ThemePlugin = {
   apiVersion: 2,

package/src/plugins/themes/claude-code.ts

@@ -1,4 +1,4 @@
-import type { ThemePlugin } from "../types/theme.ts";
+import type { ThemePlugin } from "@tokentop/plugin-sdk";
 
 export const claudeCodeTheme: ThemePlugin = {
   apiVersion: 2,

package/src/plugins/themes/dracula.ts

@@ -1,4 +1,4 @@
-import type { ThemePlugin } from "../types/theme.ts";
+import type { ThemePlugin } from "@tokentop/plugin-sdk";
 
 export const draculaTheme: ThemePlugin = {
   apiVersion: 2,

package/src/plugins/themes/github-light.ts

@@ -1,4 +1,4 @@
-import type { ThemePlugin } from "../types/theme.ts";
+import type { ThemePlugin } from "@tokentop/plugin-sdk";
 
 export const githubLightTheme: ThemePlugin = {
   apiVersion: 2,

package/src/plugins/themes/gruvbox-dark.ts

@@ -1,4 +1,4 @@
-import type { ThemePlugin } from "../types/theme.ts";
+import type { ThemePlugin } from "@tokentop/plugin-sdk";
 
 export const gruvboxDarkTheme: ThemePlugin = {
   apiVersion: 2,

package/src/plugins/themes/gruvbox-light.ts

@@ -1,4 +1,4 @@
-import type { ThemePlugin } from "../types/theme.ts";
+import type { ThemePlugin } from "@tokentop/plugin-sdk";
 
 export const gruvboxLightTheme: ThemePlugin = {
   apiVersion: 2,

package/src/plugins/themes/kanagawa.ts

@@ -1,4 +1,4 @@
-import type { ThemePlugin } from "../types/theme.ts";
+import type { ThemePlugin } from "@tokentop/plugin-sdk";
 
 export const kanagawaTheme: ThemePlugin = {
   apiVersion: 2,

package/src/plugins/themes/nord.ts

@@ -1,4 +1,4 @@
-import type { ThemePlugin } from "../types/theme.ts";
+import type { ThemePlugin } from "@tokentop/plugin-sdk";
 
 export const nordTheme: ThemePlugin = {
   apiVersion: 2,

package/src/plugins/themes/one-dark.ts

@@ -1,4 +1,4 @@
-import type { ThemePlugin } from "../types/theme.ts";
+import type { ThemePlugin } from "@tokentop/plugin-sdk";
 
 export const oneDarkTheme: ThemePlugin = {
   apiVersion: 2,

package/src/plugins/themes/opencode.ts

@@ -1,4 +1,4 @@
-import type { ThemePlugin } from "../types/theme.ts";
+import type { ThemePlugin } from "@tokentop/plugin-sdk";
 
 export const opencodeTheme: ThemePlugin = {
   apiVersion: 2,

package/src/plugins/themes/rose-pine-dawn.ts

@@ -1,4 +1,4 @@
-import type { ThemePlugin } from "../types/theme.ts";
+import type { ThemePlugin } from "@tokentop/plugin-sdk";
 
 export const rosePineDawnTheme: ThemePlugin = {
   apiVersion: 2,

package/src/plugins/themes/rose-pine.ts

@@ -1,4 +1,4 @@
-import type { ThemePlugin } from "../types/theme.ts";
+import type { ThemePlugin } from "@tokentop/plugin-sdk";
 
 export const rosePineTheme: ThemePlugin = {
   apiVersion: 2,

package/src/plugins/themes/solarized-light.ts

@@ -1,4 +1,4 @@
-import type { ThemePlugin } from "../types/theme.ts";
+import type { ThemePlugin } from "@tokentop/plugin-sdk";
 
 export const solarizedLightTheme: ThemePlugin = {
   apiVersion: 2,

package/src/plugins/themes/tokyo-night.ts

@@ -1,4 +1,4 @@
-import type { ThemePlugin } from "../types/theme.ts";
+import type { ThemePlugin } from "@tokentop/plugin-sdk";
 
 export const tokyoNightTheme: ThemePlugin = {
   apiVersion: 2,

package/src/plugins/update-checker.ts

@@ -9,7 +9,7 @@
  * skipped because they have no registry entry to compare against.
  */
 
-import type { PluginType } from "./types/base.ts";
+import type { PluginType } from "@tokentop/plugin-sdk";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -60,7 +60,7 @@ function isNewer(current: string, latest: string): boolean {
  * Uses the abbreviated metadata endpoint for minimal payload.
  */
 async function fetchLatestVersion(packageName: string): Promise<string> {
-  const url = `https://registry.npmjs.org/${encodeURIComponent(packageName).replace("%40", "@")}`;
+  const url = `https://registry.npmjs.org/${encodeURIComponent(packageName).replaceAll("%40", "@")}`;
   const res = await fetch(url, {
     headers: { Accept: "application/vnd.npm.install-v1+json" },
     signal: AbortSignal.timeout(8_000),

package/src/pricing/estimator.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import type { ModelPricing } from "@/plugins/types/provider.ts";
+import type { ModelPricing } from "@tokentop/plugin-sdk";
 import { estimateCost, estimateSessionCost, formatCost, formatTokenCount } from "./estimator.ts";
 
 describe("estimateCost()", () => {

package/src/pricing/estimator.ts

@@ -1,4 +1,4 @@
-import type { CostBreakdown, ModelPricing } from "@/plugins/types/provider.ts";
+import type { CostBreakdown, ModelPricing } from "@tokentop/plugin-sdk";
 
 export interface TokenUsage {
   input: number;

package/src/pricing/fallback.ts

@@ -1,4 +1,4 @@
-import type { ModelPricing } from "@/plugins/types/provider.ts";
+import type { ModelPricing } from "@tokentop/plugin-sdk";
 
 //TODO: get more up to date fallback pricing
 export const FALLBACK_PRICING: Record<string, Record<string, ModelPricing>> = {

package/src/pricing/index.ts

@@ -1,4 +1,4 @@
-import type { ModelPricing, ProviderPlugin, ProviderPricing } from "@/plugins/types/provider.ts";
+import type { ModelPricing, ProviderPlugin, ProviderPricing } from "@tokentop/plugin-sdk";
 import { getFallbackPricing, getFallbackProviderPricing } from "./fallback.ts";
 import {
   clearCache as clearModelsDevCache,

package/src/pricing/models-dev.ts

@@ -1,4 +1,4 @@
-import type { ModelPricing } from "@/plugins/types/provider.ts";
+import type { ModelPricing } from "@tokentop/plugin-sdk";
 
 const MODELS_DEV_API = "https://models.dev/api.json";
 const CACHE_TTL_MS = 3600000;

package/src/storage/index.ts

@@ -15,6 +15,12 @@ export {
   insertAgentSessionSnapshot,
   upsertAgentSession,
 } from "./repos/agentSessions.ts";
+export {
+  pluginStorageDelete,
+  pluginStorageGet,
+  pluginStorageHas,
+  pluginStorageSet,
+} from "./repos/pluginStorage.ts";
 export {
   getLatestProviderSnapshot,
   insertProviderSnapshot,

package/src/storage/migrations/index.ts

@@ -164,6 +164,23 @@ export const migrations: Migration[] = [
       `);
     },
   },
+  {
+    version: 2,
+    up: (db: Database) => {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS plugin_storage (
+          plugin_id TEXT NOT NULL,
+          key TEXT NOT NULL,
+          value TEXT NOT NULL,
+          updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now')),
+          PRIMARY KEY (plugin_id, key)
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_plugin_storage_plugin
+          ON plugin_storage(plugin_id);
+      `);
+    },
+  },
 ];
 
 export function getCurrentVersion(db: Database): number {

package/src/storage/persistence-service.ts

@@ -0,0 +1,206 @@
+/**
+ * Module-level session persistence service.
+ *
+ * All mutable state is stored on globalThis to survive bun --hot HMR
+ * reloads and React component remounts. This decouples persistence
+ * from React's lifecycle entirely.
+ *
+ * Call persistSessions() on every poll tick (1s). The service internally:
+ *   Gate 1: Skips sessions whose usage data hasn't changed (fingerprint)
+ *   Gate 2: Throttles writes to at most once per SNAPSHOT_INTERVAL_MS
+ *
+ * Both gates update their state only on successful writes, ensuring
+ * deferred writes when the throttle expires.
+ */
+
+import { isDatabaseInitialized } from "./db.ts";
+import {
+  getLatestStreamTotalsForAllSessions,
+  insertAgentSessionSnapshot,
+  upsertAgentSession,
+} from "./repos/agentSessions.ts";
+import { insertUsageEventBatch } from "./repos/usageEvents.ts";
+import type {
+  AgentSessionSnapshotInsert,
+  AgentSessionStreamSnapshotRow,
+  AgentSessionUpsert,
+  StreamTotals,
+  UsageEventInsert,
+} from "./types.ts";
+import { computeStreamDelta } from "./types.ts";
+
+// ---------------------------------------------------------------------------
+// Configuration
+// ---------------------------------------------------------------------------
+
+/** Minimum interval between DB writes for the same session */
+const SNAPSHOT_INTERVAL_MS = 300_000; // 5 minutes
+
+// ---------------------------------------------------------------------------
+// Global state (survives bun --hot HMR and React remounts)
+// ---------------------------------------------------------------------------
+
+interface PersistenceState {
+  /** Timestamp of last successful DB write per session key */
+  lastWriteTimestamps: Map<string, number>;
+  /** Usage-based fingerprint per session key (updated only on successful write) */
+  sessionFingerprints: Map<string, string>;
+  /** Previous stream totals for delta computation */
+  previousStreamTotals: Map<string, StreamTotals>;
+  /** Whether startup seeding has completed */
+  seeded: boolean;
+}
+
+declare global {
+  // eslint-disable-next-line no-var
+  var __tokentopPersistence: PersistenceState | undefined;
+}
+
+function getState(): PersistenceState {
+  if (!globalThis.__tokentopPersistence) {
+    globalThis.__tokentopPersistence = {
+      lastWriteTimestamps: new Map(),
+      sessionFingerprints: new Map(),
+      previousStreamTotals: new Map(),
+      seeded: false,
+    };
+  }
+  return globalThis.__tokentopPersistence;
+}
+
+// ---------------------------------------------------------------------------
+// Fingerprinting
+// ---------------------------------------------------------------------------
+
+/**
+ * Compute a fingerprint based on usage data only (not lastActivityAt).
+ * This ensures inactive sessions with stable usage don't trigger writes,
+ * while active sessions that consume tokens do.
+ */
+function computeFingerprint(snapshot: Omit<AgentSessionSnapshotInsert, "agentSessionId">): string {
+  return `${snapshot.totalCostUsd}:${snapshot.requestCount}:${snapshot.totalInputTokens}:${snapshot.totalOutputTokens}`;
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export interface SessionPersistData {
+  session: AgentSessionUpsert;
+  snapshot: Omit<AgentSessionSnapshotInsert, "agentSessionId">;
+  streams: Omit<AgentSessionStreamSnapshotRow, "agentSessionSnapshotId">[];
+}
+
+/**
+ * Persist session data to the database with per-session throttling.
+ *
+ * Safe to call on every poll tick (every 1s). The service internally:
+ *   1. Skips sessions whose usage data hasn't changed (fingerprint gate)
+ *   2. Throttles writes to at most once per SNAPSHOT_INTERVAL_MS per session
+ *
+ * @returns Number of sessions actually written to DB
+ */
+export function persistSessions(sessions: SessionPersistData[]): number {
+  if (!isDatabaseInitialized()) return 0;
+
+  const state = getState();
+  const now = Date.now();
+  let persistedCount = 0;
+
+  for (const { session, snapshot, streams } of sessions) {
+    const sessionKey = `${session.agentId}:${session.sessionId}`;
+
+    // Gate 1: Skip sessions whose usage data hasn't changed since last write
+    const fp = computeFingerprint(snapshot);
+    if (state.sessionFingerprints.get(sessionKey) === fp) continue;
+
+    // Gate 2: Throttle writes to once per interval per session
+    const lastTs = state.lastWriteTimestamps.get(sessionKey) ?? 0;
+    if (now - lastTs < SNAPSHOT_INTERVAL_MS) continue;
+
+    // Both gates passed — write to DB
+    try {
+      const agentSessionId = upsertAgentSession(session);
+      insertAgentSessionSnapshot({ ...snapshot, agentSessionId }, streams);
+
+      // Compute and emit usage event deltas
+      const usageEvents: UsageEventInsert[] = [];
+      for (const stream of streams) {
+        const streamKey = `${sessionKey}:${stream.provider}:${stream.model}`;
+        const current: StreamTotals = {
+          inputTokens: stream.inputTokens,
+          outputTokens: stream.outputTokens,
+          cacheReadTokens: stream.cacheReadTokens,
+          cacheWriteTokens: stream.cacheWriteTokens,
+          costUsd: stream.costUsd,
+          requestCount: stream.requestCount,
+        };
+
+        const previous = state.previousStreamTotals.get(streamKey);
+        const delta = computeStreamDelta(current, previous);
+
+        if (delta) {
+          usageEvents.push({
+            timestamp: now,
+            source: "agent",
+            provider: stream.provider,
+            model: stream.model,
+            agentId: session.agentId,
+            sessionId: session.sessionId,
+            projectPath: session.projectPath ?? null,
+            inputTokens: delta.inputTokens,
+            outputTokens: delta.outputTokens,
+            cacheReadTokens: delta.cacheReadTokens,
+            cacheWriteTokens: delta.cacheWriteTokens,
+            costUsd: delta.costUsd,
+            requestCount: delta.requestCount,
+            pricingSource: stream.pricingSource ?? null,
+          });
+        }
+
+        state.previousStreamTotals.set(streamKey, current);
+      }
+
+      if (usageEvents.length > 0) {
+        insertUsageEventBatch(usageEvents);
+      }
+
+      // Update tracking state ONLY on successful write
+      state.lastWriteTimestamps.set(sessionKey, now);
+      state.sessionFingerprints.set(sessionKey, fp);
+      persistedCount++;
+    } catch (err) {
+      console.error("Failed to persist session:", err);
+    }
+  }
+
+  return persistedCount;
+}
+
+/**
+ * Seed previous stream totals from the database.
+ * Called once at startup after DB initialization to ensure
+ * accurate delta computation from the first persistence call.
+ */
+export function seedPreviousTotals(): void {
+  const state = getState();
+  if (state.seeded) return;
+
+  try {
+    const latestTotals = getLatestStreamTotalsForAllSessions();
+    for (const row of latestTotals) {
+      const streamKey = `${row.agentId}:${row.sessionId}:${row.provider}:${row.model}`;
+      state.previousStreamTotals.set(streamKey, {
+        inputTokens: row.inputTokens,
+        outputTokens: row.outputTokens,
+        cacheReadTokens: row.cacheReadTokens,
+        cacheWriteTokens: row.cacheWriteTokens,
+        costUsd: row.costUsd,
+        requestCount: row.requestCount,
+      });
+    }
+    state.seeded = true;
+  } catch (err) {
+    console.error("Failed to seed previous totals from DB:", err);
+  }
+}

package/src/storage/repos/pluginStorage.ts

@@ -0,0 +1,35 @@
+import { getDatabase } from "../db.ts";
+
+// ---------------------------------------------------------------------------
+// Plugin KV storage
+// ---------------------------------------------------------------------------
+
+export function pluginStorageGet(pluginId: string, key: string): string | null {
+  const db = getDatabase();
+  const row = db
+    .prepare("SELECT value FROM plugin_storage WHERE plugin_id = ? AND key = ?")
+    .get(pluginId, key) as { value: string } | null;
+  return row?.value ?? null;
+}
+
+export function pluginStorageSet(pluginId: string, key: string, value: string): void {
+  const db = getDatabase();
+  db.prepare(
+    `INSERT INTO plugin_storage (plugin_id, key, value, updated_at)
+     VALUES (?, ?, ?, ?)
+     ON CONFLICT(plugin_id, key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`,
+  ).run(pluginId, key, value, Math.floor(Date.now() / 1000));
+}
+
+export function pluginStorageDelete(pluginId: string, key: string): void {
+  const db = getDatabase();
+  db.prepare("DELETE FROM plugin_storage WHERE plugin_id = ? AND key = ?").run(pluginId, key);
+}
+
+export function pluginStorageHas(pluginId: string, key: string): boolean {
+  const db = getDatabase();
+  const row = db
+    .prepare("SELECT 1 FROM plugin_storage WHERE plugin_id = ? AND key = ?")
+    .get(pluginId, key);
+  return row !== null && row !== undefined;
+}