@useorgx/openclaw-plugin 0.4.8 → 0.7.0

package/dist/http/routes/health.js

@@ -0,0 +1,49 @@
+export function registerHealthRoutes(router, deps) {
+    async function handleHealth(query, res) {
+        const probeRemote = deps.parseBooleanQuery(query.get("probe") ?? query.get("probe_remote"));
+        try {
+            if (deps.diagnostics?.getHealth) {
+                const health = await deps.diagnostics.getHealth({ probeRemote });
+                deps.sendJson(res, 200, health);
+                return;
+            }
+            const outbox = await deps.readOutboxSummary();
+            deps.sendJson(res, 200, {
+                ok: true,
+                status: "ok",
+                generatedAt: new Date().toISOString(),
+                checks: [],
+                plugin: {
+                    baseUrl: deps.baseUrl,
+                },
+                auth: {
+                    hasApiKey: deps.hasApiKey,
+                },
+                outbox: {
+                    pendingTotal: outbox.pendingTotal,
+                    pendingByQueue: outbox.pendingByQueue,
+                    oldestEventAt: outbox.oldestEventAt,
+                    newestEventAt: outbox.newestEventAt,
+                    replayStatus: "idle",
+                    lastReplayAttemptAt: null,
+                    lastReplaySuccessAt: null,
+                    lastReplayFailureAt: null,
+                    lastReplayError: null,
+                },
+                remote: {
+                    enabled: false,
+                    reachable: null,
+                    latencyMs: null,
+                    error: null,
+                },
+            });
+        }
+        catch (err) {
+            deps.sendJson(res, 500, {
+                error: deps.safeErrorMessage(err),
+            });
+        }
+    }
+    router.add("GET", "health", async ({ query, res }) => handleHealth(query, res), "Health summary");
+    router.add("HEAD", "health", async ({ query, res }) => handleHealth(query, res), "Health summary (HEAD)");
+}

package/dist/http/routes/live-legacy.d.ts

@@ -0,0 +1,115 @@
+import type { LiveActivityItem, SessionTreeResponse } from "../../types.js";
+import type { RuntimeInstanceRecord } from "../../runtime-instance-store.js";
+import type { AgentLaunchContext, RunLaunchContext } from "../../agent-context-store.js";
+import type { Router } from "../router.js";
+type LocalSnapshot = Awaited<ReturnType<typeof import("../../local-openclaw.js").loadLocalOpenClawSnapshot>>;
+type AgentContextBundle = {
+    agents: Record<string, AgentLaunchContext>;
+    runs?: Record<string, RunLaunchContext>;
+};
+type LocalLiveActivity = {
+    activities: LiveActivityItem[];
+    total: number;
+};
+type LiveActivityPage = {
+    activities: LiveActivityItem[];
+    cursor?: string | null;
+    nextCursor?: string | null;
+    prevCursor?: string | null;
+    hasMore?: boolean;
+};
+type LiveSessionsResponse = SessionTreeResponse;
+type LiveActivityResponse = {
+    activities: LiveActivityItem[];
+    total?: number;
+} & Record<string, unknown>;
+type RouteReqLike = {
+    on?: (event: string, listener: () => void) => void;
+};
+type RouteResLike = {
+    write?: (chunk: string | Buffer) => boolean | void;
+    writeHead: (statusCode: number, headers?: Record<string, string>) => unknown;
+    end: (chunk?: string | Buffer) => void;
+    writableEnded?: boolean;
+    on?: (event: string, listener: () => void) => void;
+    once?: (event: string, listener: () => void) => void;
+};
+type RegisterLiveLegacyRoutesDeps<TRes extends RouteResLike> = {
+    getLiveSessions: (input: {
+        initiative: string | null;
+        projectId: string | null;
+        limit: number | undefined;
+    }) => Promise<LiveSessionsResponse>;
+    getLiveActivity: (input: {
+        run: string | null;
+        since: string | null;
+        projectId: string | null;
+        limit: number | undefined;
+    }) => Promise<LiveActivityResponse>;
+    listInitiativeIdsForProject: (input: {
+        projectId: string;
+    }) => Promise<string[]>;
+    listRuntimeInstances: (input: {
+        limit: number;
+    }) => RuntimeInstanceRecord[];
+    injectRuntimeInstancesAsSessions: (input: SessionTreeResponse, instances: RuntimeInstanceRecord[]) => SessionTreeResponse;
+    enrichSessionsWithRuntime: (input: SessionTreeResponse, instances: RuntimeInstanceRecord[]) => SessionTreeResponse;
+    loadLocalOpenClawSnapshot: (limit: number) => Promise<LocalSnapshot>;
+    toLocalSessionTree: (snapshot: LocalSnapshot, limit?: number) => SessionTreeResponse;
+    readAgentContexts: () => AgentContextBundle;
+    applyAgentContextsToSessionTree: (input: SessionTreeResponse, contexts: {
+        agents: Record<string, AgentLaunchContext>;
+        runs: Record<string, RunLaunchContext>;
+    }) => SessionTreeResponse;
+    listActivityPage: (input: {
+        limit: number;
+        runId: string | null;
+        since: string | null;
+        until: string | null;
+        cursor: string | null;
+    }) => LiveActivityPage;
+    applyAgentContextsToActivity: (input: LiveActivityItem[], contexts: {
+        agents: Record<string, AgentLaunchContext>;
+        runs: Record<string, RunLaunchContext>;
+    }) => LiveActivityItem[];
+    appendActivityItems: (items: LiveActivityItem[]) => void;
+    activityWarmByKey: Map<string, number>;
+    activityWarmThrottleMs: number;
+    outboxReadAllItems: () => Promise<LiveActivityItem[]>;
+    toLocalLiveActivity: (snapshot: LocalSnapshot, limit?: number) => Promise<LocalLiveActivity>;
+    loadLocalTurnDetail: (input: {
+        turnId: string;
+        sessionKey: string | null;
+        runId: string | null;
+    }) => Promise<Record<string, unknown> | null>;
+    sendJson: (res: TRes, status: number, payload: unknown) => void;
+    safeErrorMessage: (err: unknown) => string;
+    sendHtml: (res: TRes, status: number, html: string) => void;
+    resolveFilesystemOpenPath: (rawPath: string) => string;
+    escapeHtml: (value: string) => string;
+    statSync: (path: string) => {
+        isDirectory: () => boolean;
+        isFile: () => boolean;
+        size: number;
+    };
+    readdirSync: (path: string) => string[];
+    existsSync: (path: string) => boolean;
+    resolvePath: (...segments: string[]) => string;
+    readFilePreview: (path: string, totalBytes: number) => {
+        previewBuffer: Buffer;
+        truncated: boolean;
+    };
+    filePreviewMaxBytes: number;
+    filePreviewMaxDirEntries: number;
+    securityHeaders: Record<string, string>;
+    corsHeaders: Record<string, string>;
+    config: {
+        baseUrl: string;
+        apiKey: string;
+        userId: string;
+    };
+    isUserScopedApiKey: (apiKey: string) => boolean;
+    streamIdleTimeoutMs: number;
+};
+export declare function registerLiveLegacyRoutes<TReq extends RouteReqLike, TRes extends RouteResLike>(router: Router<Record<string, never>, TReq, TRes>, deps: RegisterLiveLegacyRoutesDeps<TRes>): void;
+export {};

package/dist/http/routes/live-legacy.js

@@ -0,0 +1,112 @@
+export function registerLiveLegacyRoutes(router, deps) {
+    const sendDeprecated = (res, endpoint, replacement) => {
+        deps.sendJson(res, 410, {
+            error: `${endpoint} is deprecated`,
+            replacement,
+            required_scope: "workspace_id",
+        });
+    };
+    async function renderLiveSessions(query, res) {
+        sendDeprecated(res, "/orgx/api/live/sessions", "/orgx/api/live/snapshot");
+        void query;
+        return;
+    }
+    router.add("GET", "live/sessions", async ({ query, res }) => renderLiveSessions(query, res), "Legacy live sessions endpoint");
+    router.add("HEAD", "live/sessions", async ({ query, res }) => renderLiveSessions(query, res), "Legacy live sessions endpoint (HEAD)");
+    async function renderLiveActivityPage(query, res) {
+        sendDeprecated(res, "/orgx/api/live/activity/page", "/orgx/api/live/snapshot-v2");
+        void query;
+        return;
+    }
+    router.add("GET", "live/activity/page", async ({ query, res }) => renderLiveActivityPage(query, res), "Paginated live activity");
+    router.add("HEAD", "live/activity/page", async ({ query, res }) => renderLiveActivityPage(query, res), "Paginated live activity (HEAD)");
+    async function renderLiveActivity(query, res) {
+        sendDeprecated(res, "/orgx/api/live/activity", "/orgx/api/live/snapshot");
+        void query;
+        return;
+    }
+    router.add("GET", "live/activity", async ({ query, res }) => renderLiveActivity(query, res), "Legacy live activity endpoint");
+    router.add("HEAD", "live/activity", async ({ query, res }) => renderLiveActivity(query, res), "Legacy live activity endpoint (HEAD)");
+    async function renderLiveActivityDetail(query, res) {
+        sendDeprecated(res, "/orgx/api/live/activity/detail", "/orgx/api/live/snapshot-v2");
+        void query;
+        return;
+    }
+    router.add("GET", "live/activity/detail", async ({ query, res }) => renderLiveActivityDetail(query, res), "Detailed activity turn view");
+    router.add("HEAD", "live/activity/detail", async ({ query, res }) => renderLiveActivityDetail(query, res), "Detailed activity turn view (HEAD)");
+    router.add("GET", "live/filesystem/open", ({ query, res }) => {
+        const rawPath = query.get("path") ?? "";
+        if (!rawPath.trim()) {
+            deps.sendJson(res, 400, { error: "path is required" });
+            return;
+        }
+        const pathInput = rawPath.trim();
+        if (/^https?:\/\//i.test(pathInput)) {
+            res.writeHead(302, {
+                Location: pathInput,
+                ...deps.securityHeaders,
+                ...deps.corsHeaders,
+            });
+            res.end();
+            return;
+        }
+        const resolvedPath = deps.resolveFilesystemOpenPath(pathInput);
+        const escapedInput = deps.escapeHtml(pathInput);
+        const escapedResolved = deps.escapeHtml(resolvedPath);
+        const shellPath = resolvedPath.replaceAll("'", "'\\''");
+        if (!deps.existsSync(resolvedPath)) {
+            deps.sendHtml(res, 404, `<!doctype html><html><head><meta charset="utf-8"/><title>Path Not Found</title><style>body{margin:0;padding:24px;background:#080808;color:#e5e7eb;font:14px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,sans-serif}pre{background:#0f0f0f;border:1px solid rgba(255,255,255,.08);padding:12px;border-radius:10px;white-space:pre-wrap;word-break:break-word}a{color:#BFFF00}</style></head><body><h1 style="margin:0 0 8px;font-size:18px;">Path not found</h1><p style="margin:0 0 12px;color:#9ca3af;">The evidence path no longer exists.</p><pre>${escapedInput}</pre><p style="margin:12px 0 0;color:#9ca3af;">Resolved as:</p><pre>${escapedResolved}</pre></body></html>`);
+            return;
+        }
+        try {
+            const stats = deps.statSync(resolvedPath);
+            if (stats.isDirectory()) {
+                const entries = deps.readdirSync(resolvedPath);
+                const visibleEntries = entries.slice(0, deps.filePreviewMaxDirEntries);
+                const items = visibleEntries
+                    .map((name) => {
+                    const nextPath = deps.resolvePath(resolvedPath, name);
+                    const href = `/orgx/api/live/filesystem/open?path=${encodeURIComponent(nextPath)}`;
+                    return `<li style="margin:0 0 6px;"><a href="${href}" target="_blank" rel="noreferrer" style="color:#BFFF00;text-decoration:none;">${deps.escapeHtml(name)}</a></li>`;
+                })
+                    .join("");
+                const overflowNote = entries.length > visibleEntries.length
+                    ? `<p style="margin:12px 0 0;color:#9ca3af;">Showing ${visibleEntries.length} of ${entries.length} entries.</p>`
+                    : "";
+                deps.sendHtml(res, 200, `<!doctype html><html><head><meta charset="utf-8"/><title>Directory Preview</title><style>body{margin:0;padding:24px;background:#080808;color:#e5e7eb;font:14px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,sans-serif}pre,ul{background:#0f0f0f;border:1px solid rgba(255,255,255,.08);padding:12px;border-radius:10px}ul{list-style:none;margin:0;max-height:70vh;overflow:auto}pre{white-space:pre-wrap;word-break:break-word}code{color:#7dd3c0}</style></head><body><h1 style="margin:0 0 8px;font-size:18px;">Directory</h1><p style="margin:0 0 12px;color:#9ca3af;">${escapedResolved}</p><ul>${items || "<li style=\"color:#9ca3af;\">(empty)</li>"}</ul>${overflowNote}<p style="margin:12px 0 0;color:#9ca3af;">Tip: open in terminal with <code>ls -la '${deps.escapeHtml(shellPath)}'</code></p></body></html>`);
+                return;
+            }
+            if (!stats.isFile()) {
+                deps.sendHtml(res, 200, `<!doctype html><html><head><meta charset="utf-8"/><title>Unsupported Path</title><style>body{margin:0;padding:24px;background:#080808;color:#e5e7eb;font:14px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,sans-serif}pre{background:#0f0f0f;border:1px solid rgba(255,255,255,.08);padding:12px;border-radius:10px;white-space:pre-wrap;word-break:break-word}</style></head><body><h1 style="margin:0 0 8px;font-size:18px;">Unsupported path type</h1><p style="margin:0 0 12px;color:#9ca3af;">Only files and directories are previewable.</p><pre>${escapedResolved}</pre></body></html>`);
+                return;
+            }
+            const totalBytes = Number.isFinite(stats.size) ? Math.max(0, stats.size) : 0;
+            const { previewBuffer, truncated } = deps.readFilePreview(resolvedPath, totalBytes);
+            const isBinary = previewBuffer.includes(0);
+            const sizeLabel = `${totalBytes.toLocaleString()} bytes`;
+            if (isBinary) {
+                deps.sendHtml(res, 200, `<!doctype html><html><head><meta charset="utf-8"/><title>Binary File</title><style>body{margin:0;padding:24px;background:#080808;color:#e5e7eb;font:14px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,sans-serif}pre{background:#0f0f0f;border:1px solid rgba(255,255,255,.08);padding:12px;border-radius:10px;white-space:pre-wrap;word-break:break-word}code{color:#7dd3c0}</style></head><body><h1 style="margin:0 0 8px;font-size:18px;">Binary file</h1><p style="margin:0 0 12px;color:#9ca3af;">Cannot render binary content in browser preview.</p><pre>${escapedResolved}\n${deps.escapeHtml(sizeLabel)}</pre><p style="margin:12px 0 0;color:#9ca3af;">Inspect in terminal with <code>file '${deps.escapeHtml(shellPath)}'</code></p></body></html>`);
+                return;
+            }
+            const previewText = previewBuffer.toString("utf8");
+            const truncationNote = truncated
+                ? `<p style="margin:12px 0 0;color:#9ca3af;">Preview truncated to first ${deps.filePreviewMaxBytes.toLocaleString()} bytes.</p>`
+                : "";
+            deps.sendHtml(res, 200, `<!doctype html><html><head><meta charset="utf-8"/><title>File Preview</title><style>body{margin:0;padding:24px;background:#080808;color:#e5e7eb;font:14px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,sans-serif}pre{background:#0f0f0f;border:1px solid rgba(255,255,255,.08);padding:12px;border-radius:10px;white-space:pre;overflow:auto;max-height:75vh}code{color:#7dd3c0}</style></head><body><h1 style="margin:0 0 8px;font-size:18px;">File preview</h1><p style="margin:0 0 12px;color:#9ca3af;">${escapedResolved}</p><p style="margin:0 0 12px;color:#9ca3af;">${deps.escapeHtml(sizeLabel)}</p><pre>${deps.escapeHtml(previewText)}</pre>${truncationNote}<p style="margin:12px 0 0;color:#9ca3af;">Open in terminal with <code>cat '${deps.escapeHtml(shellPath)}'</code></p></body></html>`);
+        }
+        catch (err) {
+            deps.sendHtml(res, 500, `<!doctype html><html><head><meta charset="utf-8"/><title>Preview Error</title><style>body{margin:0;padding:24px;background:#080808;color:#e5e7eb;font:14px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,sans-serif}pre{background:#0f0f0f;border:1px solid rgba(255,255,255,.08);padding:12px;border-radius:10px;white-space:pre-wrap;word-break:break-word}</style></head><body><h1 style="margin:0 0 8px;font-size:18px;">Unable to preview path</h1><p style="margin:0 0 12px;color:#9ca3af;">${deps.escapeHtml(deps.safeErrorMessage(err))}</p><pre>${escapedResolved}</pre></body></html>`);
+        }
+    }, "Open filesystem evidence path");
+    router.add("*", "live/filesystem/open", ({ res }) => {
+        deps.sendJson(res, 405, { error: "Use GET /orgx/api/live/filesystem/open?path=..." });
+    }, "Reject unsupported methods for live/filesystem/open");
+    async function renderLiveStream(query, req, res) {
+        sendDeprecated(res, "/orgx/api/live/stream", "/orgx/api/live/snapshot-v2");
+        void query;
+        void req;
+        return;
+    }
+    router.add("GET", "live/stream", async ({ query, req, res }) => renderLiveStream(query, req, res), "Proxy live SSE stream");
+    router.add("HEAD", "live/stream", async ({ query, req, res }) => renderLiveStream(query, req, res), "Proxy live SSE stream (HEAD)");
+}

package/dist/http/routes/live-misc.d.ts

@@ -0,0 +1,81 @@
+import type { Router } from "../router.js";
+import type { Entity } from "../../types.js";
+type JsonRecord = Record<string, unknown>;
+type LiveInitiativesResponse = {
+    initiatives: unknown[];
+    total?: number;
+    pagination?: {
+        limit?: number;
+        offset?: number;
+        has_more?: boolean;
+    };
+};
+type LiveDecisionsResponse = {
+    decisions: Entity[];
+    total: number;
+};
+type HandoffsResponse = {
+    handoffs: unknown[];
+};
+type LocalSnapshot = Awaited<ReturnType<typeof import("../../local-openclaw.js").loadLocalOpenClawSnapshot>>;
+type RegisterLiveMiscRoutesDeps<TReq, TRes> = {
+    parseJsonRequest: (req: TReq) => Promise<JsonRecord>;
+    pickString: (input: Record<string, unknown>, keys: string[]) => string | null;
+    summarizeActivityHeadline: (input: {
+        text: string;
+        title: string | null;
+        type: string | null;
+    }) => Promise<{
+        headline: string;
+        source: string;
+        model: string | null;
+    }>;
+    getLiveAgents: (input: {
+        initiative: string | null;
+        projectId: string | null;
+        includeIdle: boolean | undefined;
+    }) => Promise<unknown>;
+    getLiveInitiatives: (input: {
+        id: string | null;
+        projectId: string | null;
+        limit: number | undefined;
+        offset: number | undefined;
+    }) => Promise<LiveInitiativesResponse>;
+    getLiveDecisions: (input: {
+        status: string;
+        projectId: string | null;
+        limit: number;
+    }) => Promise<LiveDecisionsResponse>;
+    getHandoffs: () => Promise<HandoffsResponse>;
+    listInitiativeIdsForProject: (input: {
+        projectId: string;
+    }) => Promise<string[]>;
+    loadLocalOpenClawSnapshot: (limit: number) => Promise<LocalSnapshot>;
+    toLocalLiveAgents: (snapshot: LocalSnapshot) => {
+        agents: Array<{
+            initiativeId: string | null;
+            status: string;
+        }>;
+    };
+    toLocalLiveInitiatives: (snapshot: LocalSnapshot) => {
+        initiatives: Array<{
+            id: string;
+            title: string;
+            status: string;
+            updatedAt: string | null;
+            sessionCount: number;
+            activeAgents: number;
+        }>;
+    };
+    localInitiativeStatusOverrides: Map<string, {
+        status: string;
+        updatedAt: string;
+    }>;
+    mapDecisionEntity: (entry: Entity) => {
+        waitingMinutes: number;
+    };
+    sendJson: (res: TRes, status: number, payload: unknown) => void;
+    safeErrorMessage: (err: unknown) => string;
+};
+export declare function registerLiveMiscRoutes<TReq, TRes>(router: Router<Record<string, never>, TReq, TRes>, deps: RegisterLiveMiscRoutesDeps<TReq, TRes>): void;
+export {};