@useorgx/openclaw-plugin 0.4.8 → 0.7.0

package/dist/services/instrumentation.js

@@ -0,0 +1,136 @@
+import { posthogCapture } from "../telemetry/posthog.js";
+export function instrumentPluginApi(input) {
+    const registerTool = input.api.registerTool.bind(input.api);
+    input.api.registerTool = (tool, options) => {
+        const toolName = tool.name;
+        const optional = Boolean(options?.optional);
+        registerTool({
+            ...tool,
+            execute: async (callId, params) => {
+                const startedAt = Date.now();
+                void posthogCapture({
+                    event: "openclaw_tool_called",
+                    distinctId: input.installationId,
+                    properties: {
+                        tool_name: toolName,
+                        tool_optional: optional,
+                        call_id: callId,
+                        plugin_version: input.pluginVersion,
+                    },
+                }).catch(() => {
+                    // best effort
+                });
+                try {
+                    const result = await tool.execute(callId, params);
+                    const durationMs = Date.now() - startedAt;
+                    void posthogCapture({
+                        event: "openclaw_tool_succeeded",
+                        distinctId: input.installationId,
+                        properties: {
+                            tool_name: toolName,
+                            tool_optional: optional,
+                            call_id: callId,
+                            duration_ms: durationMs,
+                            plugin_version: input.pluginVersion,
+                        },
+                    }).catch(() => {
+                        // best effort
+                    });
+                    return result;
+                }
+                catch (err) {
+                    const durationMs = Date.now() - startedAt;
+                    void posthogCapture({
+                        event: "openclaw_tool_failed",
+                        distinctId: input.installationId,
+                        properties: {
+                            tool_name: toolName,
+                            tool_optional: optional,
+                            call_id: callId,
+                            duration_ms: durationMs,
+                            plugin_version: input.pluginVersion,
+                            error: input.toErrorMessage(err),
+                        },
+                    }).catch(() => {
+                        // best effort
+                    });
+                    throw err;
+                }
+            },
+        }, options);
+    };
+    const registerService = input.api.registerService.bind(input.api);
+    input.api.registerService = (service) => {
+        registerService({
+            ...service,
+            start: async () => {
+                const startedAt = Date.now();
+                try {
+                    await service.start();
+                    const durationMs = Date.now() - startedAt;
+                    void posthogCapture({
+                        event: "openclaw_service_started",
+                        distinctId: input.installationId,
+                        properties: {
+                            service_id: service.id,
+                            duration_ms: durationMs,
+                            plugin_version: input.pluginVersion,
+                        },
+                    }).catch(() => {
+                        // best effort
+                    });
+                }
+                catch (err) {
+                    const durationMs = Date.now() - startedAt;
+                    void posthogCapture({
+                        event: "openclaw_service_start_failed",
+                        distinctId: input.installationId,
+                        properties: {
+                            service_id: service.id,
+                            duration_ms: durationMs,
+                            plugin_version: input.pluginVersion,
+                            error: input.toErrorMessage(err),
+                        },
+                    }).catch(() => {
+                        // best effort
+                    });
+                    throw err;
+                }
+            },
+            stop: async () => {
+                const startedAt = Date.now();
+                try {
+                    await service.stop();
+                    const durationMs = Date.now() - startedAt;
+                    void posthogCapture({
+                        event: "openclaw_service_stopped",
+                        distinctId: input.installationId,
+                        properties: {
+                            service_id: service.id,
+                            duration_ms: durationMs,
+                            plugin_version: input.pluginVersion,
+                        },
+                    }).catch(() => {
+                        // best effort
+                    });
+                }
+                catch (err) {
+                    const durationMs = Date.now() - startedAt;
+                    void posthogCapture({
+                        event: "openclaw_service_stop_failed",
+                        distinctId: input.installationId,
+                        properties: {
+                            service_id: service.id,
+                            duration_ms: durationMs,
+                            plugin_version: input.pluginVersion,
+                            error: input.toErrorMessage(err),
+                        },
+                    }).catch(() => {
+                        // best effort
+                    });
+                    throw err;
+                }
+            },
+        });
+    };
+}

package/dist/skill-pack-state.d.ts

@@ -1,15 +1,32 @@
 import type { SkillPack } from "./contracts/types.js";
 import type { OrgxSkillPackOverrides } from "./agent-suite.js";
+export type SkillPackPolicy = {
+    frozen: boolean;
+    pinnedChecksum: string | null;
+};
+export type SkillPackPolicyDiff = {
+    field: "policy.frozen" | "policy.pinnedChecksum";
+    before: boolean | string | null;
+    after: boolean | string | null;
+};
+export type SkillPackPolicyAuditEntry = {
+    id: string;
+    changedAt: string;
+    changedBy: string;
+    action: "policy.update" | "policy.rollback";
+    reason: string | null;
+    rollbackOfAuditId: string | null;
+    diff: SkillPackPolicyDiff[];
+    beforePolicy: SkillPackPolicy;
+    afterPolicy: SkillPackPolicy;
+};
 export type SkillPackState = {
     version: 1;
     updatedAt: string;
     lastCheckedAt: string | null;
     lastError: string | null;
     etag: string | null;
-    policy: {
-        frozen: boolean;
-        pinnedChecksum: string | null;
-    };
+    policy: SkillPackPolicy;
     pack: {
         name: string;
         version: string;
@@ -23,6 +40,9 @@ export type SkillPackState = {
         updated_at: string | null;
     } | null;
     overrides: OrgxSkillPackOverrides | null;
+    audit: {
+        entries: SkillPackPolicyAuditEntry[];
+    };
 };
 export declare function readSkillPackState(input?: {
     openclawDir?: string;
@@ -36,11 +56,22 @@ export declare function updateSkillPackPolicy(input: {
     pinnedChecksum?: string | null;
     pinToCurrent?: boolean;
     clearPin?: boolean;
+    changedBy?: string;
+    reason?: string;
+}): SkillPackState;
+export declare function rollbackSkillPackPolicy(input?: {
+    openclawDir?: string;
+    auditId?: string;
+    changedBy?: string;
+    reason?: string;
 }): SkillPackState;
 export declare function toOrgxSkillPackOverrides(input: {
     pack: SkillPack;
     etag: string | null;
-}): OrgxSkillPackOverrides;
+}): {
+    overrides: OrgxSkillPackOverrides;
+    validationErrors: string[];
+};
 export declare function refreshSkillPackState(input: {
     getSkillPack: (args: {
         name?: string;

package/dist/skill-pack-state.js

@@ -2,8 +2,10 @@ import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { writeFileAtomicSync } from "./fs-utils.js";
 import { getOpenClawDir } from "./paths.js";
+import { validateOpenClawSkillPackManifest } from "./contracts/skill-pack-schema.js";
 const STORE_VERSION = 1;
 const STATE_FILENAME = "orgx-skill-pack-state.json";
+const AUDIT_HISTORY_LIMIT = 50;
 function nowIso() {
     return new Date().toISOString();
 }
@@ -16,6 +18,94 @@ function coerceString(value) {
 function statePath(openclawDir) {
     return join(openclawDir, STATE_FILENAME);
 }
+function clonePolicy(input) {
+    return {
+        frozen: Boolean(input.frozen),
+        pinnedChecksum: coerceString(input.pinnedChecksum),
+    };
+}
+function normalizeChangedBy(input) {
+    if (typeof input !== "string")
+        return "unknown";
+    const value = input.trim();
+    return value.length > 0 ? value : "unknown";
+}
+function normalizeReason(input) {
+    return typeof input === "string" && input.trim().length > 0 ? input.trim() : null;
+}
+function nextAuditId() {
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function computePolicyDiff(before, after) {
+    const diff = [];
+    if (before.frozen !== after.frozen) {
+        diff.push({
+            field: "policy.frozen",
+            before: before.frozen,
+            after: after.frozen,
+        });
+    }
+    if (before.pinnedChecksum !== after.pinnedChecksum) {
+        diff.push({
+            field: "policy.pinnedChecksum",
+            before: before.pinnedChecksum,
+            after: after.pinnedChecksum,
+        });
+    }
+    return diff;
+}
+function appendPolicyAuditEntry(entries, entry) {
+    return [entry, ...entries].slice(0, AUDIT_HISTORY_LIMIT);
+}
+function parseAuditEntries(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const entries = [];
+    for (const candidate of raw) {
+        if (!isRecord(candidate))
+            continue;
+        const beforePolicyRaw = isRecord(candidate.beforePolicy) ? candidate.beforePolicy : null;
+        const afterPolicyRaw = isRecord(candidate.afterPolicy) ? candidate.afterPolicy : null;
+        if (!beforePolicyRaw || !afterPolicyRaw)
+            continue;
+        const diffRaw = Array.isArray(candidate.diff) ? candidate.diff : [];
+        const diff = [];
+        for (const diffEntry of diffRaw) {
+            if (!isRecord(diffEntry))
+                continue;
+            const field = diffEntry.field;
+            if (field !== "policy.frozen" && field !== "policy.pinnedChecksum")
+                continue;
+            diff.push({
+                field,
+                before: typeof diffEntry.before === "boolean" || diffEntry.before === null
+                    ? diffEntry.before
+                    : coerceString(diffEntry.before),
+                after: typeof diffEntry.after === "boolean" || diffEntry.after === null
+                    ? diffEntry.after
+                    : coerceString(diffEntry.after),
+            });
+        }
+        entries.push({
+            id: coerceString(candidate.id) ?? nextAuditId(),
+            changedAt: coerceString(candidate.changedAt) ?? nowIso(),
+            changedBy: normalizeChangedBy(candidate.changedBy),
+            action: candidate.action === "policy.rollback" ? "policy.rollback" : "policy.update",
+            reason: normalizeReason(candidate.reason),
+            rollbackOfAuditId: coerceString(candidate.rollbackOfAuditId),
+            diff,
+            beforePolicy: {
+                frozen: Boolean(beforePolicyRaw.frozen),
+                pinnedChecksum: coerceString(beforePolicyRaw.pinnedChecksum),
+            },
+            afterPolicy: {
+                frozen: Boolean(afterPolicyRaw.frozen),
+                pinnedChecksum: coerceString(afterPolicyRaw.pinnedChecksum),
+            },
+        });
+    }
+    return entries.slice(0, AUDIT_HISTORY_LIMIT);
+}
 export function readSkillPackState(input) {
     const openclawDir = input?.openclawDir ?? getOpenClawDir();
     const path = statePath(openclawDir);
@@ -29,6 +119,7 @@ export function readSkillPackState(input) {
         pack: null,
         remote: null,
         overrides: null,
+        audit: { entries: [] },
     };
     try {
         if (!existsSync(path))
@@ -43,6 +134,7 @@ export function readSkillPackState(input) {
         const pack = isRecord(parsed.pack) ? parsed.pack : null;
         const remote = isRecord(parsed.remote) ? parsed.remote : null;
         const overrides = isRecord(parsed.overrides) ? parsed.overrides : null;
+        const audit = isRecord(parsed.audit) ? parsed.audit : null;
         return {
             version: STORE_VERSION,
             updatedAt: coerceString(parsed.updatedAt) ?? nowIso(),
@@ -72,6 +164,9 @@ export function readSkillPackState(input) {
             overrides: overrides
                 ? overrides
                 : null,
+            audit: {
+                entries: parseAuditEntries(audit?.entries),
+            },
         };
     }
     catch {
@@ -88,7 +183,12 @@ export function writeSkillPackState(state, input) {
 }
 export function updateSkillPackPolicy(input) {
     const prev = readSkillPackState({ openclawDir: input.openclawDir });
+    const beforePolicy = clonePolicy(prev.policy);
     const nextPolicy = { ...prev.policy };
+    const activeChecksum = prev.pack?.checksum ?? null;
+    const remoteChecksum = prev.remote?.checksum ?? null;
+    const hasInactiveRemoteCandidate = Boolean(remoteChecksum && remoteChecksum !== activeChecksum);
+    const blockedByActivationValidation = hasInactiveRemoteCandidate && hasActivationValidationFailure(prev.lastError);
     if (typeof input.frozen === "boolean") {
         nextPolicy.frozen = input.frozen;
     }
@@ -96,10 +196,20 @@ export function updateSkillPackPolicy(input) {
         nextPolicy.pinnedChecksum = null;
     }
     else if (input.pinToCurrent) {
+        if (blockedByActivationValidation) {
+            throw new Error("Cannot pin_to_current: remote config failed eval/manifest checks and is not active.");
+        }
         nextPolicy.pinnedChecksum = prev.pack?.checksum ?? prev.remote?.checksum ?? null;
     }
     else if (typeof input.pinnedChecksum === "string") {
-        nextPolicy.pinnedChecksum = input.pinnedChecksum.trim() || null;
+        const requestedChecksum = input.pinnedChecksum.trim() || null;
+        if (requestedChecksum &&
+            remoteChecksum &&
+            requestedChecksum === remoteChecksum &&
+            blockedByActivationValidation) {
+            throw new Error("Cannot pin checksum to remote config: eval/manifest checks are failing for that candidate.");
+        }
+        nextPolicy.pinnedChecksum = requestedChecksum;
     }
     else if (input.pinnedChecksum === null) {
         nextPolicy.pinnedChecksum = null;
@@ -109,48 +219,155 @@ export function updateSkillPackPolicy(input) {
         updatedAt: nowIso(),
         policy: nextPolicy,
     };
+    const diff = computePolicyDiff(beforePolicy, next.policy);
+    if (diff.length > 0) {
+        const entry = {
+            id: nextAuditId(),
+            changedAt: next.updatedAt,
+            changedBy: normalizeChangedBy(input.changedBy),
+            action: "policy.update",
+            reason: normalizeReason(input.reason),
+            rollbackOfAuditId: null,
+            diff,
+            beforePolicy,
+            afterPolicy: clonePolicy(next.policy),
+        };
+        next.audit = {
+            entries: appendPolicyAuditEntry(prev.audit.entries, entry),
+        };
+    }
     writeSkillPackState(next, { openclawDir: input.openclawDir });
     return next;
 }
+export function rollbackSkillPackPolicy(input) {
+    const prev = readSkillPackState({ openclawDir: input?.openclawDir });
+    const normalizedAuditId = typeof input?.auditId === "string" && input.auditId.trim().length > 0
+        ? input.auditId.trim()
+        : null;
+    const target = normalizedAuditId
+        ? prev.audit.entries.find((entry) => entry.id === normalizedAuditId) ?? null
+        : prev.audit.entries[0] ?? null;
+    if (!target) {
+        throw new Error("No policy audit entry available for rollback");
+    }
+    const beforePolicy = clonePolicy(prev.policy);
+    const afterPolicy = clonePolicy(target.beforePolicy);
+    const diff = computePolicyDiff(beforePolicy, afterPolicy);
+    if (diff.length === 0) {
+        return prev;
+    }
+    const changedAt = nowIso();
+    const rollbackEntry = {
+        id: nextAuditId(),
+        changedAt,
+        changedBy: normalizeChangedBy(input?.changedBy),
+        action: "policy.rollback",
+        reason: normalizeReason(input?.reason) ?? `Rollback to audit ${target.id}`,
+        rollbackOfAuditId: target.id,
+        diff,
+        beforePolicy,
+        afterPolicy,
+    };
+    const next = {
+        ...prev,
+        updatedAt: changedAt,
+        policy: afterPolicy,
+        audit: {
+            entries: appendPolicyAuditEntry(prev.audit.entries, rollbackEntry),
+        },
+    };
+    writeSkillPackState(next, { openclawDir: input?.openclawDir });
+    return next;
+}
 function asRecord(value) {
     return isRecord(value) ? value : null;
 }
-function parseOpenclawSkillOverridesFromManifest(manifest) {
-    const root = manifest ?? {};
+function asBoolean(value) {
+    return typeof value === "boolean" ? value : null;
+}
+function asFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function normalizeStatus(value) {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim().toLowerCase().replace(/[\s-]+/g, "_");
+    return normalized.length > 0 ? normalized : null;
+}
+function hasActivationValidationFailure(lastError) {
+    if (!lastError)
+        return false;
+    const normalized = lastError.toLowerCase();
+    return (normalized.includes("eval framework checks did not pass") ||
+        normalized.includes("eval gate blocked activation") ||
+        normalized.includes("manifest validation errors"));
+}
+function evalGateErrorForPack(pack) {
+    const manifest = asRecord(pack.manifest);
+    if (!manifest) {
+        return "SkillPack eval framework checks did not pass: missing manifest object";
+    }
     const candidates = [
-        asRecord(root.openclaw_skills),
-        asRecord(root.openclawSkills),
-        asRecord(asRecord(root.openclaw)?.skills),
-    ].filter(Boolean);
-    const out = {};
+        { label: "eval_framework", value: asRecord(manifest.eval_framework) },
+        { label: "evalFramework", value: asRecord(manifest.evalFramework) },
+        { label: "evaluation_result", value: asRecord(manifest.evaluation_result) },
+        { label: "evaluationResult", value: asRecord(manifest.evaluationResult) },
+        { label: "evaluation", value: asRecord(manifest.evaluation) },
+        { label: "quality_gate", value: asRecord(manifest.quality_gate) },
+        { label: "qualityGate", value: asRecord(manifest.qualityGate) },
+    ];
     for (const candidate of candidates) {
-        for (const [k, v] of Object.entries(candidate)) {
-            if (typeof v !== "string")
-                continue;
-            const key = k.trim().toLowerCase();
-            if (!key)
-                continue;
-            out[key] = v;
+        if (!candidate.value)
+            continue;
+        const passed = asBoolean(candidate.value.passed) ??
+            asBoolean(candidate.value.ok) ??
+            asBoolean(candidate.value.success) ??
+            asBoolean(candidate.value.allowed);
+        if (passed != null) {
+            return passed
+                ? null
+                : `SkillPack eval framework checks did not pass: ${candidate.label}.passed=false`;
+        }
+        const status = normalizeStatus(candidate.value.status);
+        if (status) {
+            const passStatuses = new Set(["pass", "passed", "ok", "success", "approved", "green"]);
+            const failStatuses = new Set(["fail", "failed", "rejected", "error", "blocked", "red"]);
+            if (passStatuses.has(status))
+                return null;
+            if (failStatuses.has(status)) {
+                return `SkillPack eval framework checks did not pass: ${candidate.label}.status=${status}`;
+            }
+        }
+        const checksTotal = asFiniteNumber(candidate.value.checks_total) ??
+            asFiniteNumber(candidate.value.total_checks);
+        const checksPassed = asFiniteNumber(candidate.value.checks_passed) ??
+            asFiniteNumber(candidate.value.passed_checks);
+        if (checksTotal != null && checksPassed != null && checksTotal > 0) {
+            return checksPassed >= checksTotal
+                ? null
+                : `SkillPack eval framework checks did not pass: ${candidate.label}.checks=${checksPassed}/${checksTotal}`;
         }
     }
-    return out;
+    return "SkillPack eval framework checks did not pass: missing pass signal in manifest";
 }
 export function toOrgxSkillPackOverrides(input) {
-    const manifest = asRecord(input.pack.manifest) ?? {};
-    const rawOverrides = parseOpenclawSkillOverridesFromManifest(manifest);
+    const manifest = asRecord(input.pack.manifest);
+    const validation = validateOpenClawSkillPackManifest(manifest ?? {});
     const openclaw_skills = {};
-    for (const [k, v] of Object.entries(rawOverrides)) {
-        // Domains are normalized to lowercase keys in the manifest.
+    for (const [k, v] of Object.entries(validation.openclaw_skills)) {
         openclaw_skills[k] = v;
     }
     return {
-        source: "server",
-        name: input.pack.name,
-        version: input.pack.version,
-        checksum: input.pack.checksum,
-        etag: input.etag,
-        updated_at: input.pack.updated_at ?? null,
-        openclaw_skills,
+        overrides: {
+            source: "server",
+            name: input.pack.name,
+            version: input.pack.version,
+            checksum: input.pack.checksum,
+            etag: input.etag,
+            updated_at: input.pack.updated_at ?? null,
+            openclaw_skills,
+        },
+        validationErrors: validation.errors,
     };
 }
 export async function refreshSkillPackState(input) {
@@ -201,7 +418,33 @@ export async function refreshSkillPackState(input) {
             writeSkillPackState(next, { openclawDir: input.openclawDir });
             return { state: next, changed: false };
         }
-        const overrides = toOrgxSkillPackOverrides({ pack: result.pack, etag: result.etag ?? null });
+        const { overrides, validationErrors } = toOrgxSkillPackOverrides({
+            pack: result.pack,
+            etag: result.etag ?? null,
+        });
+        const evalGateError = evalGateErrorForPack(result.pack);
+        const activationErrors = [];
+        if (validationErrors.length > 0) {
+            activationErrors.push(`SkillPack manifest validation errors: ${validationErrors.join("; ")}`);
+        }
+        if (evalGateError) {
+            activationErrors.push(evalGateError);
+        }
+        const activationValidationError = activationErrors.length > 0 ? activationErrors.join(" | ") : null;
+        // Guardrail: never activate a config that fails eval/manifest validation.
+        // Keep it staged in `remote` + `lastError` so operators can inspect/fix it.
+        if (activationValidationError) {
+            const next = {
+                ...prev,
+                updatedAt: nowIso(),
+                lastCheckedAt: nowIso(),
+                lastError: activationValidationError,
+                etag: result.etag ?? prev.etag,
+                remote: remoteMeta,
+            };
+            writeSkillPackState(next, { openclawDir: input.openclawDir });
+            return { state: next, changed: false };
+        }
         const next = {
             version: STORE_VERSION,
             updatedAt: nowIso(),
@@ -217,6 +460,7 @@ export async function refreshSkillPackState(input) {
             },
             remote: remoteMeta,
             overrides,
+            audit: prev.audit,
         };
         writeSkillPackState(next, { openclawDir: input.openclawDir });
         return { state: next, changed: prev.pack?.checksum !== next.pack?.checksum };
@@ -225,7 +469,7 @@ export async function refreshSkillPackState(input) {
         ...prev,
         updatedAt: nowIso(),
         lastCheckedAt: nowIso(),
-        lastError: !result.ok ? result.error : prev.lastError,
+        lastError: result.ok === false ? result.error : prev.lastError,
     };
     writeSkillPackState(next, { openclawDir: input.openclawDir });
     return { state: next, changed: false };

package/dist/snapshot-store.js

@@ -1,6 +1,7 @@
-import { mkdirSync, readFileSync, chmodSync, existsSync, rmSync } from 'node:fs';
+import { existsSync, readFileSync } from "node:fs";
 import { getOrgxPluginConfigDir, getOrgxPluginConfigPath } from './paths.js';
 import { backupCorruptFileSync, writeJsonFileAtomicSync } from './fs-utils.js';
+import { clearStoreFileSync, ensureStoreDirSync, parseJsonSafe, } from "./stores/json-store.js";
 function snapshotDir() {
     return getOrgxPluginConfigDir();
 }
@@ -8,22 +9,7 @@ function snapshotFile() {
     return getOrgxPluginConfigPath('snapshot.json');
 }
 function ensureSnapshotDir() {
-    const dir = snapshotDir();
-    mkdirSync(dir, { recursive: true, mode: 0o700 });
-    try {
-        chmodSync(dir, 0o700);
-    }
-    catch {
-        // best effort
-    }
-}
-function parseJson(value) {
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return null;
-    }
+    ensureStoreDirSync(snapshotDir());
 }
 export function readPersistedSnapshot() {
     const file = snapshotFile();
@@ -31,7 +17,7 @@ export function readPersistedSnapshot() {
         if (!existsSync(file))
             return null;
         const raw = readFileSync(file, 'utf8');
-        const parsed = parseJson(raw);
+        const parsed = parseJsonSafe(raw);
         if (!parsed) {
             backupCorruptFileSync(file);
             return null;
@@ -57,11 +43,5 @@ export function writePersistedSnapshot(snapshot) {
     return record;
 }
 export function clearPersistedSnapshot() {
-    const file = snapshotFile();
-    try {
-        rmSync(file, { force: true });
-    }
-    catch {
-        // best effort
-    }
+    clearStoreFileSync(snapshotFile());
 }

package/dist/stores/json-store.d.ts

@@ -0,0 +1,11 @@
+import { parseJsonSafe } from "../json-utils.js";
+export declare function ensureStoreDirSync(dir: string): void;
+export { parseJsonSafe };
+export declare function readJsonFileOrDefault<T>(input: {
+    file: string;
+    fallback: () => T;
+    isValid?: (value: unknown) => value is T;
+    backupOnInvalid?: boolean;
+}): T;
+export declare function writeJsonStoreFileSync(file: string, data: unknown, mode?: number): void;
+export declare function clearStoreFileSync(file: string): void;