@useorgx/openclaw-plugin 0.4.8 → 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/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")
@@ -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;

package/dist/stores/json-store.js

@@ -0,0 +1,42 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, } from "node:fs";
+import { backupCorruptFileSync, writeJsonFileAtomicSync } from "../fs-utils.js";
+import { parseJsonSafe } from "../json-utils.js";
+export function ensureStoreDirSync(dir) {
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    try {
+        chmodSync(dir, 0o700);
+    }
+    catch {
+        // best effort
+    }
+}
+export { parseJsonSafe };
+export function readJsonFileOrDefault(input) {
+    const { file, fallback, isValid, backupOnInvalid = true, } = input;
+    if (!existsSync(file))
+        return fallback();
+    try {
+        const raw = readFileSync(file, "utf8");
+        const parsed = parseJsonSafe(raw);
+        const valid = parsed !== null && (isValid ? isValid(parsed) : true);
+        if (valid)
+            return parsed;
+        if (backupOnInvalid)
+            backupCorruptFileSync(file);
+        return fallback();
+    }
+    catch {
+        return fallback();
+    }
+}
+export function writeJsonStoreFileSync(file, data, mode = 0o600) {
+    writeJsonFileAtomicSync(file, data, mode);
+}
+export function clearStoreFileSync(file) {
+    try {
+        rmSync(file, { force: true });
+    }
+    catch {
+        // best effort
+    }
+}

package/dist/sync/outbox-replay.d.ts

@@ -0,0 +1,55 @@
+import type { OrgXClient } from "../api.js";
+import type { OutboxEvent } from "../outbox.js";
+import type { ReportingPhase, ReportingSourceClient } from "../types.js";
+export type ReplayStatus = "idle" | "running" | "success" | "error";
+export type OutboxReplayState = {
+    status: ReplayStatus;
+    lastReplayAttemptAt: string | null;
+    lastReplaySuccessAt: string | null;
+    lastReplayFailureAt: string | null;
+    lastReplayError: string | null;
+};
+interface ReportingContextInput {
+    initiative_id?: unknown;
+    run_id?: unknown;
+    correlation_id?: unknown;
+    source_client?: unknown;
+    initiativeId?: unknown;
+    runId?: unknown;
+    correlationId?: unknown;
+    sourceClient?: unknown;
+}
+type ReplayContext = {
+    initiativeId: string;
+    runId?: string;
+    correlationId?: string;
+    sourceClient?: ReportingSourceClient;
+};
+export interface CreateOutboxReplayerDeps {
+    client: OrgXClient;
+    logger: {
+        info?: (msg: string, meta?: Record<string, unknown>) => void;
+        warn?: (msg: string, meta?: Record<string, unknown>) => void;
+    };
+    toErrorMessage: (err: unknown) => string;
+    stableHash: (value: string) => string;
+    resolveReportingContext: (input: ReportingContextInput) => {
+        ok: true;
+        value: ReplayContext;
+    } | {
+        ok: false;
+        error: string;
+    };
+    pickStringField: (input: Record<string, unknown>, ...keys: string[]) => string | null;
+    pickStringArrayField: (input: Record<string, unknown>, ...keys: string[]) => string[] | undefined;
+    toReportingPhase: (phase: string, progressPct?: number) => ReportingPhase;
+    parseRetroEntityType: (value: string | null) => "initiative" | "task" | "milestone" | "workstream" | null | undefined;
+    isUuid: (value: string | undefined) => value is string;
+    readOutboxReplayState: () => OutboxReplayState;
+    writeOutboxReplayState: (next: OutboxReplayState) => void;
+}
+export declare function createOutboxReplayer(deps: CreateOutboxReplayerDeps): {
+    replayOutboxEvent: (event: OutboxEvent) => Promise<void>;
+    flushOutboxQueues: () => Promise<void>;
+};
+export {};