@useorgx/openclaw-plugin 0.7.20 → 0.7.24

package/dist/runtime-instance-store.js

@@ -1,10 +1,12 @@
 import { existsSync, readFileSync, writeFileSync, } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { getOrgxPluginConfigDir, getOrgxPluginConfigPath } from "./paths.js";
-import { backupCorruptFileSync, writeJsonFileAtomicSync } from "./fs-utils.js";
+import { backupCorruptFileSync } from "./fs-utils.js";
 import { clearStoreFileSync, ensureStoreDirSync, parseJsonSafe, } from "./stores/json-store.js";
+import { getStateDb, readStateMeta, writeStateMeta, } from "./stores/sqlite-state.js";
 const MAX_INSTANCES = 600;
 export const DEFAULT_RUNTIME_HEARTBEAT_TIMEOUT_MS = 90_000;
+const RUNTIME_IMPORT_META_KEY = "runtime_instances_imported_v1";
 function runtimeDir() {
     return getOrgxPluginConfigDir();
 }
@@ -19,8 +21,7 @@ function ensureRuntimeDir() {
 }
 function writeHookTokenFile(token) {
     ensureRuntimeDir();
-    const file = hookTokenFile();
-    writeFileSync(file, `${token}\n`, { encoding: "utf8", mode: 0o600 });
+    writeFileSync(hookTokenFile(), `${token}\n`, { encoding: "utf8", mode: 0o600 });
 }
 function normalizeNullableString(value) {
     if (typeof value !== "string")
@@ -174,7 +175,7 @@ function normalizeRecord(input) {
         updatedAt: input.updatedAt,
     };
 }
-export function readRuntimeInstances() {
+function legacyReadRuntimeInstances() {
     const file = runtimeFile();
     try {
         if (!existsSync(file)) {
@@ -200,24 +201,171 @@ export function readRuntimeInstances() {
         return { updatedAt: new Date().toISOString(), instances: {} };
     }
 }
-function pruneStore(store) {
-    const values = Object.values(store.instances);
-    if (values.length <= MAX_INSTANCES)
+function rowToRecord(row) {
+    return normalizeRecord({
+        id: row.id,
+        sourceClient: normalizeSourceClient(row.source_client),
+        displayName: row.display_name,
+        providerLogo: normalizeProviderLogo(row.provider_logo, normalizeSourceClient(row.source_client)),
+        state: normalizeState(row.state),
+        event: normalizeHookEvent(row.event),
+        runId: row.run_id,
+        correlationId: row.correlation_id,
+        initiativeId: row.initiative_id,
+        workstreamId: row.workstream_id,
+        taskId: row.task_id,
+        agentId: row.agent_id,
+        agentName: row.agent_name,
+        phase: row.phase,
+        progressPct: typeof row.progress_pct === "number" ? row.progress_pct : null,
+        currentTask: row.current_task,
+        lastHeartbeatAt: row.last_heartbeat_at,
+        lastEventAt: row.last_event_at,
+        lastMessage: row.last_message,
+        metadata: typeof row.metadata_json === "string"
+            ? normalizeObject(parseJsonSafe(row.metadata_json))
+            : null,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    });
+}
+function writeRuntimeRecord(record) {
+    const normalized = normalizeRecord(record);
+    getStateDb()
+        .prepare(`INSERT INTO runtime_instances (
+         id,
+         source_client,
+         display_name,
+         provider_logo,
+         state,
+         event,
+         run_id,
+         correlation_id,
+         initiative_id,
+         workstream_id,
+         task_id,
+         agent_id,
+         agent_name,
+         phase,
+         progress_pct,
+         current_task,
+         last_heartbeat_at,
+         last_event_at,
+         last_message,
+         metadata_json,
+         created_at,
+         updated_at
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         source_client = excluded.source_client,
+         display_name = excluded.display_name,
+         provider_logo = excluded.provider_logo,
+         state = excluded.state,
+         event = excluded.event,
+         run_id = excluded.run_id,
+         correlation_id = excluded.correlation_id,
+         initiative_id = excluded.initiative_id,
+         workstream_id = excluded.workstream_id,
+         task_id = excluded.task_id,
+         agent_id = excluded.agent_id,
+         agent_name = excluded.agent_name,
+         phase = excluded.phase,
+         progress_pct = excluded.progress_pct,
+         current_task = excluded.current_task,
+         last_heartbeat_at = excluded.last_heartbeat_at,
+         last_event_at = excluded.last_event_at,
+         last_message = excluded.last_message,
+         metadata_json = excluded.metadata_json,
+         created_at = excluded.created_at,
+         updated_at = excluded.updated_at`)
+        .run(normalized.id, normalized.sourceClient, normalized.displayName, normalized.providerLogo, normalized.state, normalized.event, normalized.runId, normalized.correlationId, normalized.initiativeId, normalized.workstreamId, normalized.taskId, normalized.agentId, normalized.agentName, normalized.phase, normalized.progressPct, normalized.currentTask, normalized.lastHeartbeatAt, normalized.lastEventAt, normalized.lastMessage, normalized.metadata ? JSON.stringify(normalized.metadata) : null, normalized.createdAt, normalized.updatedAt);
+}
+function pruneRuntimeStore() {
+    getStateDb()
+        .prepare(`DELETE FROM runtime_instances
+       WHERE id NOT IN (
+         SELECT id
+         FROM runtime_instances
+         ORDER BY last_event_at DESC, updated_at DESC
+         LIMIT ?
+       )`)
+        .run(MAX_INSTANCES);
+}
+function readRuntimeRows(limit) {
+    ensureRuntimeStoreMigrated();
+    const max = Math.max(1, limit ?? MAX_INSTANCES);
+    return getStateDb()
+        .prepare(`SELECT
+         id,
+         source_client,
+         display_name,
+         provider_logo,
+         state,
+         event,
+         run_id,
+         correlation_id,
+         initiative_id,
+         workstream_id,
+         task_id,
+         agent_id,
+         agent_name,
+         phase,
+         progress_pct,
+         current_task,
+         last_heartbeat_at,
+         last_event_at,
+         last_message,
+         metadata_json,
+         created_at,
+         updated_at
+       FROM runtime_instances
+       ORDER BY last_event_at DESC, updated_at DESC
+       LIMIT ?`)
+        .all(max);
+}
+function ensureRuntimeStoreMigrated() {
+    const migrated = readStateMeta(RUNTIME_IMPORT_META_KEY);
+    if (migrated)
+        return;
+    const db = getStateDb();
+    const countRow = db
+        .prepare("SELECT COUNT(*) AS count FROM runtime_instances")
+        .get();
+    if ((countRow?.count ?? 0) > 0) {
+        writeStateMeta(RUNTIME_IMPORT_META_KEY, true);
         return;
-    values.sort((a, b) => Date.parse(b.lastEventAt) - Date.parse(a.lastEventAt));
-    const keep = new Set(values.slice(0, MAX_INSTANCES).map((record) => record.id));
-    for (const key of Object.keys(store.instances)) {
-        if (!keep.has(key)) {
-            delete store.instances[key];
-        }
     }
+    const legacy = legacyReadRuntimeInstances();
+    const records = Object.values(legacy.instances)
+        .map((record) => normalizeRecord(record))
+        .filter((record) => Boolean(record.id));
+    const transaction = db.transaction((items) => {
+        for (const item of items) {
+            writeRuntimeRecord(item);
+        }
+        pruneRuntimeStore();
+        writeStateMeta(RUNTIME_IMPORT_META_KEY, true);
+    });
+    transaction(records);
 }
-function writeRuntimeInstances(next) {
-    ensureRuntimeDir();
-    const file = runtimeFile();
-    writeJsonFileAtomicSync(file, next, 0o600);
+export function readRuntimeInstances() {
+    const rows = readRuntimeRows(MAX_INSTANCES);
+    const instances = {};
+    let updatedAt = new Date(0).toISOString();
+    for (const row of rows) {
+        const record = rowToRecord(row);
+        instances[record.id] = record;
+        if (Date.parse(record.updatedAt) > Date.parse(updatedAt)) {
+            updatedAt = record.updatedAt;
+        }
+    }
+    return {
+        updatedAt: rows.length > 0 ? updatedAt : new Date().toISOString(),
+        instances,
+    };
 }
 export function upsertRuntimeInstanceFromHook(payload) {
+    ensureRuntimeStoreMigrated();
     const sourceClient = normalizeSourceClient(payload.source_client);
     const event = normalizeHookEvent(payload.event);
     const nowIso = new Date().toISOString();
@@ -240,8 +388,34 @@ export function upsertRuntimeInstanceFromHook(payload) {
         agentId,
         initiativeId,
     });
-    const store = readRuntimeInstances();
-    const existing = store.instances[id] ? normalizeRecord(store.instances[id]) : null;
+    const existingRow = getStateDb()
+        .prepare(`SELECT
+         id,
+         source_client,
+         display_name,
+         provider_logo,
+         state,
+         event,
+         run_id,
+         correlation_id,
+         initiative_id,
+         workstream_id,
+         task_id,
+         agent_id,
+         agent_name,
+         phase,
+         progress_pct,
+         current_task,
+         last_heartbeat_at,
+         last_event_at,
+         last_message,
+         metadata_json,
+         created_at,
+         updated_at
+       FROM runtime_instances
+       WHERE id = ?`)
+        .get(id);
+    const existing = existingRow ? rowToRecord(existingRow) : null;
     let state = existing?.state ?? "active";
     if (event === "session_stop")
         state = "stopped";
@@ -279,56 +453,36 @@ export function upsertRuntimeInstanceFromHook(payload) {
         createdAt: existing?.createdAt ?? eventAt,
         updatedAt: nowIso,
     };
-    store.instances[id] = record;
-    store.updatedAt = nowIso;
-    pruneStore(store);
-    writeRuntimeInstances(store);
+    const transaction = getStateDb().transaction((item) => {
+        writeRuntimeRecord(item);
+        pruneRuntimeStore();
+    });
+    transaction(record);
     return record;
 }
 export function applyRuntimeInstanceStaleness(options) {
+    ensureRuntimeStoreMigrated();
     const timeoutMs = Math.max(10_000, options?.timeoutMs ?? DEFAULT_RUNTIME_HEARTBEAT_TIMEOUT_MS);
     const nowMs = options?.nowMs ?? Date.now();
-    const store = readRuntimeInstances();
-    let changed = false;
-    for (const [id, rawRecord] of Object.entries(store.instances)) {
-        const record = normalizeRecord(rawRecord);
-        if (record.state !== "active") {
-            if (rawRecord !== record) {
-                store.instances[id] = record;
-                changed = true;
-            }
-            continue;
-        }
-        const heartbeatAt = record.lastHeartbeatAt ?? record.lastEventAt;
-        const heartbeatEpoch = Date.parse(heartbeatAt);
-        if (!Number.isFinite(heartbeatEpoch))
-            continue;
-        if (nowMs - heartbeatEpoch <= timeoutMs)
-            continue;
-        store.instances[id] = {
-            ...record,
-            state: "stale",
-            updatedAt: new Date(nowMs).toISOString(),
-        };
-        changed = true;
-    }
-    if (changed) {
-        store.updatedAt = new Date(nowMs).toISOString();
-        writeRuntimeInstances(store);
-    }
-    return store;
+    const cutoffIso = new Date(nowMs - timeoutMs).toISOString();
+    const updatedAt = new Date(nowMs).toISOString();
+    getStateDb()
+        .prepare(`UPDATE runtime_instances
+       SET state = 'stale',
+           updated_at = ?
+       WHERE state = 'active'
+         AND COALESCE(last_heartbeat_at, last_event_at) < ?`)
+        .run(updatedAt, cutoffIso);
+    return readRuntimeInstances();
 }
 export function listRuntimeInstances(options) {
     const timeoutMs = options?.timeoutMs ?? DEFAULT_RUNTIME_HEARTBEAT_TIMEOUT_MS;
     const nowMs = options?.nowMs ?? Date.now();
-    const store = applyRuntimeInstanceStaleness({ timeoutMs, nowMs });
-    const limit = Math.max(1, options?.limit ?? MAX_INSTANCES);
-    return Object.values(store.instances)
-        .map((record) => normalizeRecord(record))
-        .sort((a, b) => Date.parse(b.lastEventAt) - Date.parse(a.lastEventAt))
-        .slice(0, limit);
+    void applyRuntimeInstanceStaleness({ timeoutMs, nowMs });
+    return readRuntimeRows(options?.limit ?? MAX_INSTANCES).map(rowToRecord);
 }
 export function clearRuntimeInstances() {
+    getStateDb().prepare("DELETE FROM runtime_instances").run();
     clearStoreFileSync(runtimeFile());
 }
 export function resolveRuntimeHookToken() {

package/dist/stores/materialized-snapshot-store.d.ts

@@ -0,0 +1,18 @@
+export type MaterializedSnapshotEntry = {
+    cacheKey: string;
+    generation: number;
+    expiresAt: number;
+    updatedAt: string;
+    payload: Record<string, unknown>;
+};
+export declare function readMaterializedSnapshot(cacheKey: string, input?: {
+    allowStale?: boolean;
+    generation?: number;
+    nowMs?: number;
+}): Record<string, unknown> | null;
+export declare function writeMaterializedSnapshot(cacheKey: string, payload: Record<string, unknown>, input: {
+    generation: number;
+    ttlMs: number;
+    nowMs?: number;
+}): void;
+export declare function clearMaterializedSnapshotMemory(): void;

package/dist/stores/materialized-snapshot-store.js

@@ -0,0 +1,91 @@
+import { parseJsonSafe } from "./json-store.js";
+import { getStateDb } from "./sqlite-state.js";
+const MEMORY_CACHE_MAX = 160;
+const memoryCache = new Map();
+function setMemoryEntry(entry) {
+    memoryCache.set(entry.cacheKey, entry);
+    if (memoryCache.size <= MEMORY_CACHE_MAX)
+        return;
+    const oldestKey = memoryCache.keys().next().value;
+    if (oldestKey)
+        memoryCache.delete(oldestKey);
+}
+function rowToEntry(row) {
+    if (!row)
+        return null;
+    const payload = parseJsonSafe(row.payload_json);
+    if (!payload || typeof payload !== "object" || Array.isArray(payload))
+        return null;
+    return {
+        cacheKey: row.cache_key,
+        generation: Number(row.generation) || 0,
+        expiresAt: Number(row.expires_at) || 0,
+        updatedAt: row.updated_at,
+        payload,
+    };
+}
+export function readMaterializedSnapshot(cacheKey, input) {
+    const normalizedKey = cacheKey.trim();
+    if (!normalizedKey)
+        return null;
+    const allowStale = Boolean(input?.allowStale);
+    const generation = input?.generation ?? 0;
+    const nowMs = input?.nowMs ?? Date.now();
+    const cached = memoryCache.get(normalizedKey) ?? null;
+    if (cached) {
+        if (allowStale ||
+            (cached.generation === generation && cached.expiresAt > nowMs)) {
+            return cached.payload;
+        }
+        memoryCache.delete(normalizedKey);
+    }
+    const row = getStateDb()
+        .prepare(`SELECT cache_key, generation, expires_at, updated_at, payload_json
+       FROM materialized_snapshots
+       WHERE cache_key = ?`)
+        .get(normalizedKey);
+    const entry = rowToEntry(row);
+    if (!entry)
+        return null;
+    if (!allowStale && (entry.generation !== generation || entry.expiresAt <= nowMs)) {
+        return null;
+    }
+    setMemoryEntry(entry);
+    return entry.payload;
+}
+export function writeMaterializedSnapshot(cacheKey, payload, input) {
+    const normalizedKey = cacheKey.trim();
+    if (!normalizedKey)
+        return;
+    const nowMs = input.nowMs ?? Date.now();
+    const updatedAt = new Date(nowMs).toISOString();
+    const expiresAt = nowMs + Math.max(250, input.ttlMs);
+    const entry = {
+        cacheKey: normalizedKey,
+        generation: input.generation,
+        expiresAt,
+        updatedAt,
+        payload,
+    };
+    getStateDb()
+        .prepare(`INSERT INTO materialized_snapshots (
+         cache_key,
+         generation,
+         expires_at,
+         updated_at,
+         payload_json
+       ) VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(cache_key) DO UPDATE SET
+         generation = excluded.generation,
+         expires_at = excluded.expires_at,
+         updated_at = excluded.updated_at,
+         payload_json = excluded.payload_json`)
+        .run(normalizedKey, entry.generation, entry.expiresAt, entry.updatedAt, JSON.stringify(payload));
+    getStateDb()
+        .prepare("DELETE FROM materialized_snapshots WHERE expires_at <= ?")
+        .run(nowMs - 1);
+    setMemoryEntry(entry);
+}
+export function clearMaterializedSnapshotMemory() {
+    memoryCache.clear();
+}

package/dist/stores/sqlite-state.d.ts

@@ -0,0 +1,6 @@
+import type Database from "better-sqlite3";
+export declare function closeStateDb(): void;
+export declare function getStateDb(): Database.Database;
+export declare function readStateMeta<T>(key: string): T | null;
+export declare function writeStateMeta(key: string, value: unknown): void;
+export declare function deleteStateMeta(key: string): void;