@useorgx/openclaw-plugin 0.4.1 → 0.4.3

package/dist/index.js

@@ -21,6 +21,7 @@ import { clearPersistedApiKey, loadAuthStore, resolveInstallationId, saveAuthSto
 import { clearPersistedSnapshot, readPersistedSnapshot, writePersistedSnapshot, } from "./snapshot-store.js";
 import { appendToOutbox, readOutbox, readOutboxSummary, replaceOutbox, } from "./outbox.js";
 import { extractProgressOutboxMessage } from "./reporting/outbox-replay.js";
+import { ensureGatewayWatchdog } from "./gateway-watchdog.js";
 export { OrgXClient } from "./api.js";
 const DEFAULT_BASE_URL = "https://www.useorgx.com";
 const DEFAULT_DOCS_URL = "https://orgx.mintlify.site/guides/openclaw-plugin-setup";
@@ -1077,6 +1078,12 @@ export default function register(api) {
         id: "orgx-sync",
         start: async () => {
             syncServiceRunning = true;
+            const watchdog = ensureGatewayWatchdog(api.log ?? {});
+            if (watchdog.started) {
+                api.log?.info?.("[orgx] Gateway watchdog started", {
+                    pid: watchdog.pid,
+                });
+            }
             api.log?.info?.("[orgx] Starting sync service", {
                 interval: config.syncIntervalMs,
             });

package/dist/openclaw-settings.d.ts

@@ -0,0 +1,17 @@
+export type OpenClawProvider = "anthropic" | "openrouter" | "openai";
+export interface OpenClawSettingsSnapshot {
+    path: string;
+    raw: Record<string, unknown> | null;
+}
+export interface OpenClawProviderModelStats {
+    provider: OpenClawProvider;
+    total: number;
+    sonnetCount: number;
+}
+export declare function readOpenClawSettingsSnapshot(): OpenClawSettingsSnapshot;
+export declare function listOpenClawConfiguredModelKeys(raw: Record<string, unknown> | null): string[];
+export declare function classifyProviderFromModelKey(modelKey: string): OpenClawProvider | null;
+export declare function summarizeOpenClawProviderModels(raw: Record<string, unknown> | null): Record<OpenClawProvider, OpenClawProviderModelStats>;
+export declare function resolvePreferredOpenClawProvider(raw: Record<string, unknown> | null): OpenClawProvider | null;
+export declare function readOpenClawPrimaryModel(raw: Record<string, unknown> | null): string | null;
+export declare function readOpenClawGatewayPort(raw: Record<string, unknown> | null): number;

package/dist/openclaw-settings.js

@@ -0,0 +1,118 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getOpenClawDir } from "./paths.js";
+function readObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function parseJsonObject(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function readOpenClawSettingsSnapshot() {
+    const path = join(getOpenClawDir(), "openclaw.json");
+    if (!existsSync(path)) {
+        return { path, raw: null };
+    }
+    try {
+        const rawText = readFileSync(path, "utf8");
+        return { path, raw: parseJsonObject(rawText) };
+    }
+    catch {
+        return { path, raw: null };
+    }
+}
+export function listOpenClawConfiguredModelKeys(raw) {
+    if (!raw)
+        return [];
+    const agents = readObject(raw.agents);
+    const defaults = readObject(agents.defaults);
+    const models = readObject(defaults.models);
+    const keys = Object.keys(models)
+        .map((key) => key.trim())
+        .filter((key) => key.length > 0);
+    keys.sort((a, b) => a.localeCompare(b));
+    return keys;
+}
+export function classifyProviderFromModelKey(modelKey) {
+    const normalized = modelKey.trim().toLowerCase();
+    if (!normalized)
+        return null;
+    if (normalized.startsWith("openrouter/"))
+        return "openrouter";
+    if (normalized.startsWith("anthropic/") || normalized.startsWith("claude/")) {
+        return "anthropic";
+    }
+    if (normalized.startsWith("openai/") ||
+        normalized.startsWith("openai-") ||
+        normalized.startsWith("gpt")) {
+        return "openai";
+    }
+    return null;
+}
+export function summarizeOpenClawProviderModels(raw) {
+    const summary = {
+        anthropic: { provider: "anthropic", total: 0, sonnetCount: 0 },
+        openrouter: { provider: "openrouter", total: 0, sonnetCount: 0 },
+        openai: { provider: "openai", total: 0, sonnetCount: 0 },
+    };
+    for (const key of listOpenClawConfiguredModelKeys(raw)) {
+        const provider = classifyProviderFromModelKey(key);
+        if (!provider)
+            continue;
+        const bucket = summary[provider];
+        bucket.total += 1;
+        if (key.toLowerCase().includes("sonnet")) {
+            bucket.sonnetCount += 1;
+        }
+    }
+    return summary;
+}
+export function resolvePreferredOpenClawProvider(raw) {
+    const summary = summarizeOpenClawProviderModels(raw);
+    const order = ["openrouter", "anthropic", "openai"];
+    for (const provider of order) {
+        if (summary[provider].sonnetCount > 0) {
+            return provider;
+        }
+    }
+    for (const provider of order) {
+        if (summary[provider].total > 0) {
+            return provider;
+        }
+    }
+    return null;
+}
+export function readOpenClawPrimaryModel(raw) {
+    if (!raw)
+        return null;
+    const agents = readObject(raw.agents);
+    const defaults = readObject(agents.defaults);
+    const model = readObject(defaults.model);
+    const primary = typeof model.primary === "string" ? model.primary.trim() : "";
+    return primary || null;
+}
+export function readOpenClawGatewayPort(raw) {
+    if (!raw)
+        return 18789;
+    const gateway = readObject(raw.gateway);
+    const port = gateway.port;
+    if (typeof port === "number" && Number.isFinite(port) && port > 0) {
+        return Math.floor(port);
+    }
+    if (typeof port === "string") {
+        const parsed = Number.parseInt(port, 10);
+        if (Number.isFinite(parsed) && parsed > 0) {
+            return parsed;
+        }
+    }
+    return 18789;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@useorgx/openclaw-plugin",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "OrgX plugin for OpenClaw — agent orchestration, quality gates, model routing, and live dashboard",
   "type": "module",
   "main": "./dist/index.js",