@useorgx/openclaw-plugin 0.7.20 → 0.7.23

package/dist/index.js

@@ -219,7 +219,7 @@ export default function register(api) {
         // best effort
     });
     if (!config.apiKey) {
-        api.log?.warn?.("[orgx] No API key. Set plugins.entries.orgx.config.apiKey, ORGX_API_KEY env, or ~/Code/orgx/orgx/.env.local");
+        api.log?.warn?.("[orgx] No API key. Set plugins.entries.openclaw-plugin.config.apiKey (or plugins.entries.orgx.config.apiKey for legacy setups), ORGX_API_KEY env, or ~/Code/orgx/orgx/.env.local");
     }
     hydrateCachedSnapshot();
     const client = new OrgXClient(config.apiKey, config.baseUrl, config.userId);
@@ -381,7 +381,11 @@ export default function register(api) {
     // ---------------------------------------------------------------------------
     let syncTimer = null;
     let syncInFlight = null;
+    let backgroundSyncInFlight = null;
+    let backgroundSyncQueued = false;
     let syncServiceRunning = false;
+    let lastBackgroundSyncAt = 0;
+    let lastBackgroundSyncError = null;
     let localAgentMirrors = [];
     let outboxReplayState = {
         status: "idle",
@@ -513,7 +517,10 @@ export default function register(api) {
             sync: {
                 serviceRunning: syncServiceRunning,
                 inFlight: syncInFlight !== null,
+                backgroundInFlight: backgroundSyncInFlight !== null,
                 lastSnapshotAt: lastSnapshotAt > 0 ? new Date(lastSnapshotAt).toISOString() : null,
+                lastBackgroundSyncAt: lastBackgroundSyncAt > 0 ? new Date(lastBackgroundSyncAt).toISOString() : null,
+                lastBackgroundSyncError,
             },
             outbox: {
                 pendingTotal: outbox.pendingTotal,
@@ -867,6 +874,158 @@ export default function register(api) {
             outboxReplayState = next;
         },
     });
+    async function syncSnapshotAndLocalTelemetry() {
+        let snapshotError = null;
+        try {
+            const snapshot = await client.getOrgSnapshot();
+            updateCachedSnapshot(snapshot);
+            localAgentMirrors = buildLocalAgentMirrorsFromSnapshot({
+                agents: snapshot.agents,
+            });
+        }
+        catch (err) {
+            if (isAuthFailure(err)) {
+                throw err;
+            }
+            snapshotError = toErrorMessage(err);
+            api.log?.warn?.("[orgx] Snapshot sync failed (continuing)", {
+                error: snapshotError,
+            });
+        }
+        const localAgents = buildLocalSyncAgentsFromRuns({
+            ...readAgentRuns(),
+            mirrors: localAgentMirrors,
+        });
+        if (localAgents.length > 0) {
+            try {
+                await client.syncMemory({ agents: localAgents });
+            }
+            catch (err) {
+                if (isAuthFailure(err)) {
+                    throw err;
+                }
+                api.log?.warn?.("[orgx] Local agent telemetry sync failed (continuing)", {
+                    error: toErrorMessage(err),
+                    count: localAgents.length,
+                });
+            }
+        }
+        return { snapshotError };
+    }
+    async function refreshSkillPackCache() {
+        try {
+            const refreshed = await refreshSkillPackState({
+                getSkillPack: (args) => client.getSkillPack(args),
+            });
+            if (refreshed.changed) {
+                void posthogCapture({
+                    event: "openclaw_skill_pack_updated",
+                    distinctId: config.installationId,
+                    properties: {
+                        plugin_version: config.pluginVersion,
+                        skill_pack_name: refreshed.state.pack?.name ?? null,
+                        skill_pack_version: refreshed.state.pack?.version ?? null,
+                        skill_pack_checksum: refreshed.state.pack?.checksum ?? null,
+                    },
+                }).catch(() => {
+                    // best effort
+                });
+            }
+        }
+        catch {
+            // best effort
+        }
+    }
+    function maybeAutoInstallAgentSuite() {
+        try {
+            if (config.autoInstallAgentSuiteOnConnect === false) {
+                return;
+            }
+            const state = readSkillPackState();
+            const updateAvailable = Boolean(state.remote?.checksum &&
+                state.pack?.checksum &&
+                state.remote.checksum !== state.pack.checksum);
+            const plan = computeOrgxAgentSuitePlan({
+                packVersion: config.pluginVersion || "0.0.0",
+                skillPack: state.overrides,
+                skillPackRemote: state.remote,
+                skillPackPolicy: state.policy,
+                skillPackUpdateAvailable: updateAvailable,
+            });
+            const hasConflicts = (plan.workspaceFiles ?? []).some((f) => f.action === "conflict");
+            const hasWork = Boolean(plan.openclawConfigWouldUpdate) ||
+                (plan.workspaceFiles ?? []).some((f) => f.action !== "noop");
+            if (!hasWork || hasConflicts) {
+                return;
+            }
+            const applied = applyOrgxAgentSuitePlan({
+                plan,
+                dryRun: false,
+                skillPack: state.overrides,
+            });
+            void applied;
+            void posthogCapture({
+                event: "openclaw_agent_suite_auto_install",
+                distinctId: config.installationId,
+                properties: {
+                    plugin_version: (config.pluginVersion ?? "").trim() || null,
+                    skill_pack_source: plan.skillPack?.source ?? null,
+                    skill_pack_checksum: plan.skillPack?.checksum ?? null,
+                    skill_pack_version: plan.skillPack?.version ?? null,
+                    openclaw_config_updated: Boolean(plan.openclawConfigWouldUpdate),
+                },
+            }).catch(() => {
+                // best effort
+            });
+        }
+        catch (err) {
+            api.log?.debug?.("[orgx] Agent suite auto-provision skipped/failed (best effort)", {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    async function runCriticalSyncPass() {
+        const { snapshotError } = await syncSnapshotAndLocalTelemetry();
+        updateOnboardingState({
+            status: "connected",
+            hasApiKey: true,
+            connectionVerified: snapshotError === null,
+            lastError: snapshotError,
+            nextAction: "open_dashboard",
+        });
+        await flushOutboxQueues();
+    }
+    async function runBackgroundSyncPass() {
+        await reconcileStoppedAgentRuns();
+        await refreshSkillPackCache();
+        maybeAutoInstallAgentSuite();
+    }
+    function scheduleBackgroundSyncPass() {
+        if (!config.apiKey)
+            return;
+        if (backgroundSyncInFlight) {
+            backgroundSyncQueued = true;
+            return;
+        }
+        backgroundSyncInFlight = (async () => {
+            do {
+                backgroundSyncQueued = false;
+                try {
+                    await runBackgroundSyncPass();
+                    lastBackgroundSyncAt = Date.now();
+                    lastBackgroundSyncError = null;
+                }
+                catch (err) {
+                    lastBackgroundSyncError = toErrorMessage(err);
+                    api.log?.warn?.("[orgx] Background sync tasks failed (continuing)", {
+                        error: lastBackgroundSyncError,
+                    });
+                }
+            } while (backgroundSyncQueued && Boolean(config.apiKey));
+        })().finally(() => {
+            backgroundSyncInFlight = null;
+        });
+    }
     async function doSync() {
         if (syncInFlight) {
             return syncInFlight;
@@ -885,120 +1044,8 @@ export default function register(api) {
                 return;
             }
             try {
-                await reconcileStoppedAgentRuns();
-                let snapshotError = null;
-                try {
-                    const snapshot = await client.getOrgSnapshot();
-                    updateCachedSnapshot(snapshot);
-                    localAgentMirrors = buildLocalAgentMirrorsFromSnapshot({
-                        agents: snapshot.agents,
-                    });
-                }
-                catch (err) {
-                    if (isAuthFailure(err)) {
-                        throw err;
-                    }
-                    snapshotError = toErrorMessage(err);
-                    api.log?.warn?.("[orgx] Snapshot sync failed (continuing)", {
-                        error: snapshotError,
-                    });
-                }
-                const localAgents = buildLocalSyncAgentsFromRuns({
-                    ...readAgentRuns(),
-                    mirrors: localAgentMirrors,
-                });
-                if (localAgents.length > 0) {
-                    try {
-                        await client.syncMemory({ agents: localAgents });
-                    }
-                    catch (err) {
-                        if (isAuthFailure(err)) {
-                            throw err;
-                        }
-                        api.log?.warn?.("[orgx] Local agent telemetry sync failed (continuing)", {
-                            error: toErrorMessage(err),
-                            count: localAgents.length,
-                        });
-                    }
-                }
-                // Best-effort: poll the canonical OrgX SkillPack so the dashboard/install path
-                // can apply it without blocking on an on-demand fetch.
-                try {
-                    const refreshed = await refreshSkillPackState({
-                        getSkillPack: (args) => client.getSkillPack(args),
-                    });
-                    if (refreshed.changed) {
-                        void posthogCapture({
-                            event: "openclaw_skill_pack_updated",
-                            distinctId: config.installationId,
-                            properties: {
-                                plugin_version: config.pluginVersion,
-                                skill_pack_name: refreshed.state.pack?.name ?? null,
-                                skill_pack_version: refreshed.state.pack?.version ?? null,
-                                skill_pack_checksum: refreshed.state.pack?.checksum ?? null,
-                            },
-                        }).catch(() => {
-                            // best effort
-                        });
-                    }
-                }
-                catch {
-                    // best effort
-                }
-                // Best-effort: provision/update the OrgX agent suite after we've verified a working connection.
-                // This makes domain agents available immediately for launches without requiring a manual install.
-                try {
-                    if (config.autoInstallAgentSuiteOnConnect !== false) {
-                        const state = readSkillPackState();
-                        const updateAvailable = Boolean(state.remote?.checksum &&
-                            state.pack?.checksum &&
-                            state.remote.checksum !== state.pack.checksum);
-                        const plan = computeOrgxAgentSuitePlan({
-                            packVersion: config.pluginVersion || "0.0.0",
-                            skillPack: state.overrides,
-                            skillPackRemote: state.remote,
-                            skillPackPolicy: state.policy,
-                            skillPackUpdateAvailable: updateAvailable,
-                        });
-                        const hasConflicts = (plan.workspaceFiles ?? []).some((f) => f.action === "conflict");
-                        const hasWork = Boolean(plan.openclawConfigWouldUpdate) ||
-                            (plan.workspaceFiles ?? []).some((f) => f.action !== "noop");
-                        if (hasWork && !hasConflicts) {
-                            const applied = applyOrgxAgentSuitePlan({
-                                plan,
-                                dryRun: false,
-                                skillPack: state.overrides,
-                            });
-                            void applied;
-                            void posthogCapture({
-                                event: "openclaw_agent_suite_auto_install",
-                                distinctId: config.installationId,
-                                properties: {
-                                    plugin_version: (config.pluginVersion ?? "").trim() || null,
-                                    skill_pack_source: plan.skillPack?.source ?? null,
-                                    skill_pack_checksum: plan.skillPack?.checksum ?? null,
-                                    skill_pack_version: plan.skillPack?.version ?? null,
-                                    openclaw_config_updated: Boolean(plan.openclawConfigWouldUpdate),
-                                },
-                            }).catch(() => {
-                                // best effort
-                            });
-                        }
-                    }
-                }
-                catch (err) {
-                    api.log?.debug?.("[orgx] Agent suite auto-provision skipped/failed (best effort)", {
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
-                updateOnboardingState({
-                    status: "connected",
-                    hasApiKey: true,
-                    connectionVerified: snapshotError === null,
-                    lastError: snapshotError,
-                    nextAction: "open_dashboard",
-                });
-                await flushOutboxQueues();
+                await runCriticalSyncPass();
+                scheduleBackgroundSyncPass();
                 api.log?.debug?.("[orgx] Sync OK");
             }
             catch (err) {
@@ -1042,6 +1089,7 @@ export default function register(api) {
             await doSync();
             scheduleNextSync();
         }, config.syncIntervalMs);
+        syncTimer.unref?.();
     }
     async function startPairing(input) {
         updateOnboardingState({
@@ -1136,11 +1184,12 @@ export default function register(api) {
             pollIntervalMs: started.data.pollIntervalMs,
         };
         const state = updateOnboardingState({
-            status: "awaiting_browser_auth",
-            hasApiKey: false,
-            connectionVerified: false,
+            status: config.apiKey ? "connected" : "awaiting_browser_auth",
+            hasApiKey: Boolean(config.apiKey),
+            connectionVerified: Boolean(config.apiKey),
+            workspaceName: onboardingState.workspaceName,
             lastError: null,
-            nextAction: "wait_for_browser",
+            nextAction: config.apiKey ? "reconnect" : "wait_for_browser",
             connectUrl: started.data.connectUrl,
             pairingId: started.data.pairingId,
             expiresAt: started.data.expiresAt,
@@ -1171,11 +1220,16 @@ export default function register(api) {
         const status = polled.data.status;
         if (status === "pending" || status === "authorized") {
             return updateOnboardingState({
-                status: "pairing",
-                hasApiKey: false,
-                connectionVerified: false,
+                status: config.apiKey ? "connected" : "pairing",
+                hasApiKey: Boolean(config.apiKey),
+                connectionVerified: Boolean(config.apiKey),
+                workspaceName: onboardingState.workspaceName,
                 lastError: null,
-                nextAction: "wait_for_browser",
+                nextAction: config.apiKey ? "reconnect" : "wait_for_browser",
+                connectUrl: activePairing.connectUrl,
+                pairingId: activePairing.pairingId,
+                expiresAt: activePairing.expiresAt,
+                pollIntervalMs: activePairing.pollIntervalMs,
             });
         }
         if (status === "ready") {
@@ -1236,6 +1290,24 @@ export default function register(api) {
             nextAction: "retry",
         });
     }
+    async function cancelPairingOnboarding() {
+        if (!activePairing) {
+            return { ...onboardingState };
+        }
+        await fetchOrgxJson("POST", `/api/plugin/openclaw/pairings/${encodeURIComponent(activePairing.pairingId)}/cancel`, {
+            pollToken: activePairing.pollToken,
+            reason: "user_cancelled",
+        });
+        clearPairingState();
+        return updateOnboardingState({
+            status: config.apiKey ? "connected" : "idle",
+            hasApiKey: Boolean(config.apiKey),
+            connectionVerified: Boolean(config.apiKey),
+            workspaceName: onboardingState.workspaceName,
+            lastError: null,
+            nextAction: config.apiKey ? "open_dashboard" : "connect",
+        });
+    }
     async function submitManualKey(input) {
         const nextKey = input.apiKey.trim();
         if (!nextKey) {
@@ -1281,6 +1353,9 @@ export default function register(api) {
         client.setCredentials({ apiKey: "", userId: "" });
         cachedSnapshot = null;
         lastSnapshotAt = 0;
+        lastBackgroundSyncAt = 0;
+        lastBackgroundSyncError = null;
+        backgroundSyncQueued = false;
         return updateOnboardingState({
             status: "idle",
             hasApiKey: false,
@@ -1394,6 +1469,7 @@ export default function register(api) {
         startPairing,
         getStatus: getPairingStatus,
         submitManualKey,
+        cancelPairing: cancelPairingOnboarding,
         disconnect: disconnectOnboarding,
     }, {
         getHealth: async (input = {}) => buildHealthReport({ probeRemote: input.probeRemote === true }),

package/dist/outbox.d.ts

@@ -9,9 +9,7 @@ export interface OutboxEvent {
     type: "progress" | "decision" | "artifact" | "changeset" | "retro" | "outcome";
     timestamp: string;
     payload: Record<string, unknown>;
-    /** Converted to a LiveActivityItem for dashboard display. */
     activityItem: LiveActivityItem;
-    /** Internal replay diagnostics for bounded retry/dead-letter handling. */
     replayFailures?: number;
     lastReplayError?: string | null;
     lastReplayAt?: string | null;