@useorgx/openclaw-plugin 0.4.6 → 0.4.9

package/dist/json-utils.d.ts

@@ -0,0 +1 @@
+export declare function parseJsonSafe<T>(value: string): T | null;

package/dist/json-utils.js

@@ -0,0 +1,8 @@
+export function parseJsonSafe(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/local-openclaw.js

@@ -580,6 +580,10 @@ function turnToActivity(turn, session, cachedSummary, index) {
         description: modelAlias,
         agentId: session.agentId,
         agentName: session.agentName,
+        requesterAgentId: session.agentId ?? null,
+        requesterAgentName: session.agentName ?? null,
+        executorAgentId: session.agentId ?? null,
+        executorAgentName: session.agentName ?? null,
         runId: session.sessionId ?? session.key,
         initiativeId: session.agentId ? `agent:${session.agentId}` : null,
         timestamp: turn.timestamp,
@@ -747,6 +751,10 @@ function makeSessionSummaryItem(session) {
         description: modelAlias ? `Local session (${modelAlias})` : "Local session",
         agentId: session.agentId,
         agentName: session.agentName,
+        requesterAgentId: session.agentId ?? null,
+        requesterAgentName: session.agentName ?? null,
+        executorAgentId: session.agentId ?? null,
+        executorAgentName: session.agentName ?? null,
         runId: session.sessionId ?? session.key,
         initiativeId: session.agentId ? `agent:${session.agentId}` : null,
         timestamp: session.updatedAt ?? new Date().toISOString(),

package/dist/mcp-client-setup.js

@@ -5,22 +5,6 @@ import { randomUUID } from "node:crypto";
 import { writeFileAtomicSync, writeJsonFileAtomicSync } from "./fs-utils.js";
 const ORGX_LOCAL_MCP_KEY = "orgx-openclaw";
 const ORGX_HOSTED_MCP_URL = "https://mcp.useorgx.com/mcp";
-const ORGX_LOCAL_MCP_SCOPES = [
-    "engineering",
-    "product",
-    "design",
-    "marketing",
-    "sales",
-    "operations",
-    "orchestration",
-];
-function scopedMcpServerKey(scope) {
-    return `${ORGX_LOCAL_MCP_KEY}-${scope}`;
-}
-function scopedMcpUrl(localMcpUrl, scope) {
-    const base = localMcpUrl.replace(/\/+$/, "");
-    return `${base}/${scope}`;
-}
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -59,6 +43,20 @@ function backupFileSync(path, mode) {
         return null;
     }
 }
+function removeLegacyScopedMcpServers(servers) {
+    const next = { ...servers };
+    let updated = false;
+    const scopedPrefix = `${ORGX_LOCAL_MCP_KEY}-`;
+    for (const key of Object.keys(next)) {
+        if (key === ORGX_LOCAL_MCP_KEY)
+            continue;
+        if (!key.startsWith(scopedPrefix))
+            continue;
+        delete next[key];
+        updated = true;
+    }
+    return { updated, next };
+}
 export function patchClaudeMcpConfig(input) {
     const currentServers = isRecord(input.current.mcpServers) ? input.current.mcpServers : {};
     const existingOrgx = isRecord(currentServers.orgx) ? currentServers.orgx : {};
@@ -88,41 +86,20 @@ export function patchClaudeMcpConfig(input) {
             ? existing.description
             : "OrgX platform via local OpenClaw plugin (no OAuth)",
     };
-    const updatedScopes = [];
-    const scopedEntries = {};
-    for (const scope of ORGX_LOCAL_MCP_SCOPES) {
-        const key = scopedMcpServerKey(scope);
-        const expectedUrl = scopedMcpUrl(input.localMcpUrl, scope);
-        const existingScoped = isRecord(currentServers[key]) ? currentServers[key] : {};
-        const priorUrl = typeof existingScoped.url === "string" ? existingScoped.url : "";
-        const priorType = typeof existingScoped.type === "string" ? existingScoped.type : "";
-        const nextScoped = {
-            ...existingScoped,
-            type: "http",
-            url: expectedUrl,
-            description: typeof existingScoped.description === "string" && existingScoped.description.trim().length > 0
-                ? existingScoped.description
-                : `OrgX platform via local OpenClaw plugin (${scope} scope)`,
-        };
-        scopedEntries[key] = nextScoped;
-        if (priorUrl !== expectedUrl || priorType !== "http") {
-            updatedScopes.push(scope);
-        }
-    }
-    const nextServers = {
+    const mergedServers = {
         ...currentServers,
         ...(shouldSetHostedOrgx ? { orgx: nextOrgxEntry } : {}),
         [ORGX_LOCAL_MCP_KEY]: nextEntry,
-        ...scopedEntries,
     };
+    const scopedCleanup = removeLegacyScopedMcpServers(mergedServers);
     const next = {
         ...input.current,
-        mcpServers: nextServers,
+        mcpServers: scopedCleanup.next,
     };
     const updatedLocal = priorUrl !== input.localMcpUrl || priorType !== "http";
     const updatedHosted = shouldSetHostedOrgx &&
         (existingOrgxUrl !== ORGX_HOSTED_MCP_URL || existingOrgxType !== "http");
-    const updated = updatedLocal || updatedHosted || updatedScopes.length > 0;
+    const updated = updatedLocal || updatedHosted || scopedCleanup.updated;
     return { updated, next };
 }
 export function patchCursorMcpConfig(input) {
@@ -133,30 +110,16 @@ export function patchCursorMcpConfig(input) {
         ...existing,
         url: input.localMcpUrl,
     };
-    const scopedEntries = {};
-    let updatedScopes = false;
-    for (const scope of ORGX_LOCAL_MCP_SCOPES) {
-        const key = scopedMcpServerKey(scope);
-        const expectedUrl = scopedMcpUrl(input.localMcpUrl, scope);
-        const existingScoped = isRecord(currentServers[key]) ? currentServers[key] : {};
-        const priorScopedUrl = typeof existingScoped.url === "string" ? existingScoped.url : "";
-        scopedEntries[key] = {
-            ...existingScoped,
-            url: expectedUrl,
-        };
-        if (priorScopedUrl !== expectedUrl)
-            updatedScopes = true;
-    }
-    const nextServers = {
+    const mergedServers = {
         ...currentServers,
         [ORGX_LOCAL_MCP_KEY]: nextEntry,
-        ...scopedEntries,
     };
+    const scopedCleanup = removeLegacyScopedMcpServers(mergedServers);
     const next = {
         ...input.current,
-        mcpServers: nextServers,
+        mcpServers: scopedCleanup.next,
     };
-    const updated = priorUrl !== input.localMcpUrl || updatedScopes;
+    const updated = priorUrl !== input.localMcpUrl || scopedCleanup.updated;
     return { updated, next };
 }
 function upsertCodexMcpServerSection(input) {
@@ -173,7 +136,9 @@ function upsertCodexMcpServerSection(input) {
     }
     const urlLine = `url = "${input.url}"`;
     if (headerIndex === -1) {
-        const suffix = ["", `[mcp_servers.\"${input.key}\"]`, urlLine, ""].join("\n");
+        const needsQuote = /[^A-Za-z0-9_]/.test(input.key);
+        const keyLiteral = needsQuote ? `"${input.key}"` : input.key;
+        const suffix = ["", `[mcp_servers.${keyLiteral}]`, urlLine, ""].join("\n");
         const normalized = currentText.endsWith("\n") ? currentText : `${currentText}\n`;
         return { updated: true, next: `${normalized}${suffix}` };
     }
@@ -221,29 +186,52 @@ function upsertCodexMcpServerSection(input) {
     }
     return { updated, next: `${lines.join("\n")}\n` };
 }
-export function patchCodexConfigToml(input) {
-    let current = input.current;
-    let updatedHosted = false;
-    // If the hosted OrgX entry is missing entirely, add a sensible default. This is
-    // a no-op if the user already has `orgx` pointed at staging or another URL.
-    const hostedHeaderRegex = /^\[mcp_servers\.(?:"orgx"|orgx)\]\s*$/;
-    {
-        const lines = current.split(/\r?\n/);
-        const hasHosted = lines.some((line) => hostedHeaderRegex.test(line.trim()));
-        if (!hasHosted) {
-            const hostedUrlLine = `url = "${ORGX_HOSTED_MCP_URL}"`;
-            const suffix = [
-                ...(current.trim().length === 0 ? [] : [""]),
-                "[mcp_servers.orgx]",
-                hostedUrlLine,
-                "",
-            ].join("\n");
-            const normalized = current.endsWith("\n") ? current : `${current}\n`;
-            current = `${normalized}${suffix}`;
-            updatedHosted = true;
+function removeCodexLegacyScopedMcpSections(input) {
+    const lines = input.current.split(/\r?\n/);
+    const scopedPrefix = `${input.baseKey}-`;
+    let updated = false;
+    let index = 0;
+    while (index < lines.length) {
+        const trimmed = lines[index].trim();
+        const headerMatch = trimmed.match(/^\[mcp_servers\.(?:"([^"]+)"|([A-Za-z0-9_]+))\]\s*$/);
+        if (!headerMatch) {
+            index += 1;
+            continue;
+        }
+        const key = (headerMatch[1] ?? headerMatch[2] ?? "").trim();
+        const isLegacyScoped = key !== input.baseKey &&
+            key.startsWith(scopedPrefix);
+        if (!isLegacyScoped) {
+            index += 1;
+            continue;
         }
+        let sectionEnd = lines.length;
+        for (let i = index + 1; i < lines.length; i += 1) {
+            if (lines[i].trim().startsWith("[")) {
+                sectionEnd = i;
+                break;
+            }
+        }
+        const start = index > 0 && lines[index - 1].trim() === "" ? index - 1 : index;
+        lines.splice(start, sectionEnd - start);
+        updated = true;
+        index = Math.max(0, start);
     }
+    return { updated, next: `${lines.join("\n")}\n` };
+}
+export function patchCodexConfigToml(input) {
+    let current = input.current;
     let updated = false;
+    // Ensure the hosted OrgX entry uses a direct `url` (streamable HTTP) so that
+    // `codex mcp login orgx` can perform OAuth.  Route through upsertCodexMcpServerSection
+    // so stale stdio-transport fields (command/args) are stripped automatically.
+    const hosted = upsertCodexMcpServerSection({
+        current,
+        key: "orgx",
+        url: ORGX_HOSTED_MCP_URL,
+    });
+    updated = updated || hosted.updated;
+    current = hosted.next;
     const base = upsertCodexMcpServerSection({
         current,
         key: ORGX_LOCAL_MCP_KEY,
@@ -251,16 +239,13 @@ export function patchCodexConfigToml(input) {
     });
     updated = updated || base.updated;
     current = base.next;
-    for (const scope of ORGX_LOCAL_MCP_SCOPES) {
-        const next = upsertCodexMcpServerSection({
-            current,
-            key: scopedMcpServerKey(scope),
-            url: scopedMcpUrl(input.localMcpUrl, scope),
-        });
-        updated = updated || next.updated;
-        current = next.next;
-    }
-    return { updated: updatedHosted || updated, next: current };
+    const removedScoped = removeCodexLegacyScopedMcpSections({
+        current,
+        baseKey: ORGX_LOCAL_MCP_KEY,
+    });
+    updated = updated || removedScoped.updated;
+    current = removedScoped.next;
+    return { updated, next: current };
 }
 export async function autoConfigureDetectedMcpClients(input) {
     const logger = input.logger ?? {};

package/dist/next-up-queue-store.js

@@ -1,6 +1,7 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, } from "node:fs";
+import { existsSync, readFileSync, } from "node:fs";
 import { getOrgxPluginConfigDir, getOrgxPluginConfigPath } from "./paths.js";
 import { backupCorruptFileSync, writeJsonFileAtomicSync } from "./fs-utils.js";
+import { ensureStoreDirSync, parseJsonSafe, } from "./stores/json-store.js";
 const MAX_PINS = 240;
 function storeDir() {
     return getOrgxPluginConfigDir();
@@ -9,22 +10,7 @@ function storeFile() {
     return getOrgxPluginConfigPath("next-up-queue.json");
 }
 function ensureStoreDir() {
-    const dir = storeDir();
-    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(storeDir());
 }
 function normalizeNullableString(value) {
     if (typeof value !== "string")
@@ -49,7 +35,7 @@ export function readNextUpQueuePins() {
             return { version: 1, updatedAt: new Date().toISOString(), pins: [] };
         }
         const raw = readFileSync(file, "utf8");
-        const parsed = parseJson(raw);
+        const parsed = parseJsonSafe(raw);
         if (!parsed || typeof parsed !== "object") {
             backupCorruptFileSync(file);
             return { version: 1, updatedAt: new Date().toISOString(), pins: [] };

package/dist/runtime-instance-store.js

@@ -1,7 +1,8 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
+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 { clearStoreFileSync, ensureStoreDirSync, parseJsonSafe, } from "./stores/json-store.js";
 const MAX_INSTANCES = 600;
 export const DEFAULT_RUNTIME_HEARTBEAT_TIMEOUT_MS = 90_000;
 function runtimeDir() {
@@ -14,33 +15,12 @@ function hookTokenFile() {
     return getOrgxPluginConfigPath("runtime-hook-token.txt");
 }
 function ensureRuntimeDir() {
-    const dir = runtimeDir();
-    mkdirSync(dir, { recursive: true, mode: 0o700 });
-    try {
-        chmodSync(dir, 0o700);
-    }
-    catch {
-        // best effort
-    }
+    ensureStoreDirSync(runtimeDir());
 }
 function writeHookTokenFile(token) {
     ensureRuntimeDir();
     const file = hookTokenFile();
     writeFileSync(file, `${token}\n`, { encoding: "utf8", mode: 0o600 });
-    try {
-        chmodSync(file, 0o600);
-    }
-    catch {
-        // best effort
-    }
-}
-function parseJson(value) {
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return null;
-    }
 }
 function normalizeNullableString(value) {
     if (typeof value !== "string")
@@ -85,7 +65,7 @@ function normalizeHookEvent(value) {
 }
 function toProviderLogo(sourceClient) {
     if (sourceClient === "codex")
-        return "codex";
+        return "openai";
     if (sourceClient === "claude-code")
         return "anthropic";
     if (sourceClient === "openclaw")
@@ -97,9 +77,9 @@ function toProviderLogo(sourceClient) {
 function normalizeProviderLogo(value, sourceClient) {
     const normalized = normalizeNullableString(value)?.toLowerCase();
     if (normalized === "codex")
-        return "codex";
+        return sourceClient === "codex" ? "openai" : "codex";
     if (normalized === "openai")
-        return sourceClient === "codex" ? "codex" : "openai";
+        return "openai";
     if (normalized === "anthropic")
         return "anthropic";
     if (normalized === "openclaw")
@@ -201,7 +181,7 @@ export function readRuntimeInstances() {
             return { updatedAt: new Date().toISOString(), instances: {} };
         }
         const raw = readFileSync(file, "utf8");
-        const parsed = parseJson(raw);
+        const parsed = parseJsonSafe(raw);
         if (!parsed || typeof parsed !== "object") {
             backupCorruptFileSync(file);
             return { updatedAt: new Date().toISOString(), instances: {} };
@@ -349,13 +329,7 @@ export function listRuntimeInstances(options) {
         .slice(0, limit);
 }
 export function clearRuntimeInstances() {
-    const file = runtimeFile();
-    try {
-        rmSync(file, { force: true });
-    }
-    catch {
-        // best effort
-    }
+    clearStoreFileSync(runtimeFile());
 }
 export function resolveRuntimeHookToken() {
     const envToken = normalizeNullableString(process.env.ORGX_HOOK_TOKEN);

package/dist/services/background.d.ts

@@ -0,0 +1,23 @@
+export interface RegisterServiceApi {
+    registerService: (service: {
+        id: string;
+        start: () => Promise<void>;
+        stop: () => Promise<void>;
+    }) => void;
+    log?: {
+        info?: (msg: string, meta?: Record<string, unknown>) => void;
+    };
+}
+export interface RegisterSyncServiceDeps {
+    api: RegisterServiceApi;
+    syncIntervalMs: number;
+    ensureGatewayWatchdog: (logger: Record<string, unknown>) => {
+        started: boolean;
+        pid?: number | null;
+    };
+    doSync: () => Promise<void>;
+    scheduleNextSync: () => void;
+    setSyncServiceRunning: (running: boolean) => void;
+    clearSyncTimer: () => void;
+}
+export declare function registerSyncService(deps: RegisterSyncServiceDeps): void;

package/dist/services/background.js

@@ -0,0 +1,23 @@
+export function registerSyncService(deps) {
+    deps.api.registerService({
+        id: "orgx-sync",
+        start: async () => {
+            deps.setSyncServiceRunning(true);
+            const watchdog = deps.ensureGatewayWatchdog((deps.api.log ?? {}));
+            if (watchdog.started) {
+                deps.api.log?.info?.("[orgx] Gateway watchdog started", {
+                    pid: watchdog.pid,
+                });
+            }
+            deps.api.log?.info?.("[orgx] Starting sync service", {
+                interval: deps.syncIntervalMs,
+            });
+            await deps.doSync();
+            deps.scheduleNextSync();
+        },
+        stop: async () => {
+            deps.setSyncServiceRunning(false);
+            deps.clearSyncTimer();
+        },
+    });
+}

package/dist/services/instrumentation.d.ts

@@ -0,0 +1,29 @@
+type ToolLike = {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    execute: (callId: string, params?: unknown) => Promise<{
+        content: Array<{
+            type: "text";
+            text: string;
+        }>;
+    }>;
+};
+type ServiceLike = {
+    id: string;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+};
+type ApiLike = {
+    registerTool: (tool: ToolLike, options?: {
+        optional?: boolean;
+    }) => void;
+    registerService: (service: ServiceLike) => void;
+};
+export declare function instrumentPluginApi(input: {
+    api: ApiLike;
+    installationId: string;
+    pluginVersion: string;
+    toErrorMessage: (err: unknown) => string;
+}): void;
+export {};

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/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;