@useorgx/openclaw-plugin 0.4.8 → 0.7.0

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/local-agent-telemetry.d.ts

@@ -0,0 +1,13 @@
+import type { AgentRunRecord } from "../agent-run-store.js";
+import type { AgentState } from "../types.js";
+export declare function buildLocalAgentMirrorsFromSnapshot(input: {
+    agents: AgentState[] | null | undefined;
+}): AgentState[];
+/**
+ * Derive live local agent states from active OpenClaw runs so sync can mirror
+ * local runtime telemetry into OrgX.
+ */
+export declare function buildLocalSyncAgentsFromRuns(input: {
+    runs: Record<string, AgentRunRecord>;
+    mirrors?: AgentState[] | null;
+}): AgentState[];

package/dist/sync/local-agent-telemetry.js

@@ -0,0 +1,128 @@
+const KNOWN_DOMAINS = [
+    "engineering",
+    "product",
+    "design",
+    "marketing",
+    "sales",
+    "operations",
+    "orchestration",
+];
+const IDLE_MIRROR_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+function inferDomainFromAgentId(agentId) {
+    const normalized = agentId.trim().toLowerCase();
+    for (const domain of KNOWN_DOMAINS) {
+        if (normalized.includes(domain))
+            return domain;
+    }
+    return "operations";
+}
+function inferNameFromAgentId(agentId) {
+    const cleaned = agentId
+        .trim()
+        .replace(/[_-]+/g, " ")
+        .replace(/\s+/g, " ");
+    if (!cleaned)
+        return "Local Agent";
+    return cleaned
+        .split(" ")
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function toEpoch(value) {
+    const epoch = Date.parse(value);
+    return Number.isFinite(epoch) ? epoch : 0;
+}
+function normalizeMirror(input) {
+    const id = typeof input.id === "string" ? input.id.trim() : "";
+    if (!id)
+        return null;
+    const status = input.status === "active" || input.status === "throttled" ? input.status : "idle";
+    const name = typeof input.name === "string" && input.name.trim().length > 0
+        ? input.name.trim()
+        : inferNameFromAgentId(id);
+    const domain = typeof input.domain === "string" && input.domain.trim().length > 0
+        ? input.domain.trim()
+        : inferDomainFromAgentId(id);
+    return {
+        id,
+        name,
+        domain,
+        status,
+        currentTask: input.currentTask,
+        lastActive: input.lastActive,
+    };
+}
+export function buildLocalAgentMirrorsFromSnapshot(input) {
+    const latestByAgent = new Map();
+    for (const source of input.agents ?? []) {
+        const normalized = normalizeMirror(source);
+        if (!normalized)
+            continue;
+        const previous = latestByAgent.get(normalized.id);
+        if (!previous ||
+            toEpoch(normalized.lastActive ?? "") >= toEpoch(previous.lastActive ?? "")) {
+            latestByAgent.set(normalized.id, normalized);
+        }
+    }
+    return Array.from(latestByAgent.values()).sort((a, b) => a.id.localeCompare(b.id));
+}
+/**
+ * Derive live local agent states from active OpenClaw runs so sync can mirror
+ * local runtime telemetry into OrgX.
+ */
+export function buildLocalSyncAgentsFromRuns(input) {
+    const latestRunningByAgent = new Map();
+    const latestStoppedByAgent = new Map();
+    const mergedByAgent = new Map();
+    const now = Date.now();
+    for (const mirror of buildLocalAgentMirrorsFromSnapshot({ agents: input.mirrors })) {
+        mergedByAgent.set(mirror.id, mirror);
+    }
+    for (const run of Object.values(input.runs ?? {})) {
+        if (!run)
+            continue;
+        const agentId = run.agentId?.trim();
+        if (!agentId)
+            continue;
+        const isRunning = run.status === "running";
+        const index = isRunning ? latestRunningByAgent : latestStoppedByAgent;
+        const runTimestamp = isRunning ? toEpoch(run.startedAt) : toEpoch(run.stoppedAt ?? run.startedAt);
+        const previous = index.get(agentId);
+        const previousTimestamp = previous
+            ? toEpoch(previous.status === "running" ? previous.startedAt : previous.stoppedAt ?? previous.startedAt)
+            : 0;
+        if (!previous || runTimestamp >= previousTimestamp) {
+            index.set(agentId, run);
+        }
+    }
+    for (const [agentId, run] of latestRunningByAgent) {
+        mergedByAgent.set(agentId, {
+            id: agentId,
+            name: inferNameFromAgentId(agentId),
+            domain: inferDomainFromAgentId(agentId),
+            status: "active",
+            currentTask: run.taskId ?? undefined,
+            lastActive: run.startedAt,
+        });
+    }
+    for (const [agentId, run] of latestStoppedByAgent) {
+        if (latestRunningByAgent.has(agentId))
+            continue;
+        const lastActive = run.stoppedAt ?? run.startedAt;
+        const idleAgeMs = now - toEpoch(lastActive);
+        if (!Number.isFinite(idleAgeMs) || idleAgeMs < 0 || idleAgeMs > IDLE_MIRROR_MAX_AGE_MS) {
+            continue;
+        }
+        const existing = mergedByAgent.get(agentId);
+        if (existing && toEpoch(existing.lastActive ?? "") > toEpoch(lastActive))
+            continue;
+        mergedByAgent.set(agentId, {
+            id: agentId,
+            name: existing?.name ?? inferNameFromAgentId(agentId),
+            domain: existing?.domain ?? inferDomainFromAgentId(agentId),
+            status: "idle",
+            lastActive,
+        });
+    }
+    return Array.from(mergedByAgent.values()).sort((a, b) => a.id.localeCompare(b.id));
+}

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 {};