@useorgx/openclaw-plugin 0.4.6 → 0.4.9

package/dist/http/routes/summary.js

@@ -0,0 +1,42 @@
+export function registerSummaryRoutes(router, deps) {
+    router.add("HEAD", "status", async ({ res }) => {
+        let snapshot = deps.getSnapshot();
+        if (!snapshot) {
+            try {
+                snapshot = await deps.getOrgSnapshot();
+            }
+            catch {
+                // use null snapshot
+            }
+        }
+        deps.writeHead(res, snapshot ? 200 : 503, {
+            ...deps.securityHeaders,
+            ...deps.corsHeaders,
+        });
+        deps.end(res);
+    }, "Status probe (HEAD)");
+    router.add("GET", "status", async ({ res }) => {
+        let snapshot = deps.getSnapshot();
+        if (!snapshot) {
+            try {
+                snapshot = await deps.getOrgSnapshot();
+            }
+            catch {
+                // use null snapshot
+            }
+        }
+        deps.sendJson(res, 200, deps.formatStatus(snapshot));
+    }, "Status snapshot");
+    router.add("GET", "agents", ({ res }) => {
+        deps.sendJson(res, 200, deps.formatAgents(deps.getSnapshot()));
+    }, "Agent summary");
+    router.add("GET", "activity", ({ res }) => {
+        deps.sendJson(res, 200, deps.formatActivity(deps.getSnapshot()));
+    }, "Activity summary");
+    router.add("GET", "initiatives", ({ res }) => {
+        deps.sendJson(res, 200, deps.formatInitiatives(deps.getSnapshot()));
+    }, "Initiatives summary");
+    router.add("GET", "onboarding", async ({ res }) => {
+        deps.sendJson(res, 200, await deps.getOnboardingState());
+    }, "Legacy onboarding state endpoint");
+}

package/dist/http/routes/work-artifacts.d.ts

@@ -0,0 +1,9 @@
+import type { Router } from "../router.js";
+type RegisterWorkArtifactsRoutesDeps<TRes> = {
+    rawRequest: (method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE", path: string, body?: unknown) => Promise<unknown>;
+    buildLocalArtifactDetailFallback: (artifactId: string, warning: string) => Record<string, unknown> | null;
+    sendJson: (res: TRes, status: number, payload: unknown) => void;
+    safeErrorMessage: (err: unknown) => string;
+};
+export declare function registerWorkArtifactsRoutes<TReq, TRes>(router: Router<Record<string, never>, TReq, TRes>, deps: RegisterWorkArtifactsRoutesDeps<TRes>): void;
+export {};

package/dist/http/routes/work-artifacts.js

@@ -0,0 +1,36 @@
+export function registerWorkArtifactsRoutes(router, deps) {
+    router.add("GET", "work-artifacts/by-entity", async ({ query, res }) => {
+        try {
+            const qs = query.toString();
+            const path = `/api/work-artifacts/by-entity${qs ? `?${qs}` : ""}`;
+            const data = await deps.rawRequest("GET", path);
+            deps.sendJson(res, 200, data);
+        }
+        catch (err) {
+            deps.sendJson(res, 502, { error: deps.safeErrorMessage(err) });
+        }
+    }, "Work artifacts by entity");
+    router.add("GET", "artifacts/*", async ({ path, res }) => {
+        const artifactDetailMatch = path.match(/^artifacts\/([^/]+)$/);
+        if (!artifactDetailMatch) {
+            deps.sendJson(res, 404, { error: "Unknown API endpoint" });
+            return;
+        }
+        const artifactId = decodeURIComponent(artifactDetailMatch[1]);
+        try {
+            const upstreamPath = `/api/artifacts/${encodeURIComponent(artifactId)}`;
+            const data = await deps.rawRequest("GET", upstreamPath);
+            deps.sendJson(res, 200, data);
+        }
+        catch (err) {
+            const warning = deps.safeErrorMessage(err);
+            const fallback = deps.buildLocalArtifactDetailFallback(artifactId, warning);
+            if (fallback) {
+                deps.sendJson(res, 200, fallback);
+            }
+            else {
+                deps.sendJson(res, 502, { error: warning });
+            }
+        }
+    }, "Artifact detail");
+}

package/dist/http/shared-state.d.ts

@@ -0,0 +1,16 @@
+import type { OutboxAdapter } from "../adapters/outbox.js";
+import type { OrgXClient } from "../api.js";
+import type { OrgXConfig, OrgSnapshot } from "../types.js";
+/**
+ * SharedState is the dependency bag used by extracted HTTP route modules.
+ * Start intentionally small and widen as route groups are migrated.
+ */
+export interface SharedState {
+    client: OrgXClient;
+    config: OrgXConfig;
+    outbox: OutboxAdapter;
+    getCachedSnapshot: () => OrgSnapshot | null;
+    doSync: () => Promise<void>;
+    tickAllAutoContinue: () => Promise<void>;
+    [key: string]: unknown;
+}

package/dist/http/shared-state.js

@@ -0,0 +1 @@
+export {};

package/dist/http-handler.d.ts

@@ -1,88 +1 @@
-/**
- * HTTP Handler — Serves the React dashboard SPA and API proxy endpoints.
- *
- * Registered at the `/orgx` prefix. Handles:
- *   /orgx/live           → dashboard SPA (index.html)
- *   /orgx/live/assets/*  → static assets (JS, CSS, images)
- *   /orgx/api/status     → org status summary
- *   /orgx/api/agents     → agent states
- *   /orgx/api/activity   → activity feed
- *   /orgx/api/initiatives → initiative data
- *   /orgx/api/health     → plugin diagnostics + outbox/sync status
- *   /orgx/api/onboarding → onboarding / config state
- *   /orgx/api/agent-suite/status → suite provisioning plan (OpenClaw-local)
- *   /orgx/api/agent-suite/install → install/update suite (OpenClaw-local)
- *   /orgx/api/delegation/preflight → delegation preflight
- *   /orgx/api/runs/:id/checkpoints → list/create checkpoints
- *   /orgx/api/runs/:id/checkpoints/:checkpointId/restore → restore checkpoint
- *   /orgx/api/runs/:id/actions/:action → run control action
- */
-import type { OrgXClient } from "./api.js";
-import type { OnboardingState, OrgXConfig, OrgSnapshot } from "./types.js";
-import { type OutboxAdapter } from "./adapters/outbox.js";
-type OpenClawAdapter = {
-    listAgents?: () => Promise<Array<Record<string, unknown>>>;
-    spawnAgentTurn?: (input: {
-        agentId: string;
-        sessionId: string;
-        message: string;
-        thinking?: string | null;
-    }) => {
-        pid: number | null;
-    };
-    stopDetachedProcess?: (pid: number) => Promise<{
-        stopped: boolean;
-        wasRunning: boolean;
-    }>;
-    isPidAlive?: (pid: number) => boolean;
-};
-interface PluginRequest {
-    method?: string;
-    url?: string;
-    headers: Record<string, string | string[] | undefined>;
-    body?: unknown;
-    on?: (event: string, listener: (...args: unknown[]) => void) => void;
-    once?: (event: string, listener: (...args: unknown[]) => void) => void;
-}
-interface PluginResponse {
-    writeHead(status: number, headers?: Record<string, string>): void;
-    end(body?: string | Buffer): void;
-    write?(chunk: string | Buffer): boolean | void;
-    on?: (event: string, listener: (...args: unknown[]) => void) => void;
-    once?: (event: string, listener: (...args: unknown[]) => void) => void;
-    writableEnded?: boolean;
-}
-interface OnboardingController {
-    getState: () => OnboardingState;
-    startPairing: (input: {
-        openclawVersion?: string;
-        platform?: string;
-        deviceName?: string;
-    }) => Promise<{
-        pairingId: string;
-        connectUrl: string;
-        expiresAt: string;
-        pollIntervalMs: number;
-        state: OnboardingState;
-    }>;
-    getStatus: () => Promise<OnboardingState>;
-    submitManualKey: (input: {
-        apiKey: string;
-        userId?: string;
-    }) => Promise<OnboardingState>;
-    disconnect: () => Promise<OnboardingState>;
-}
-interface DiagnosticsProvider {
-    getHealth?: (input?: {
-        probeRemote?: boolean;
-    }) => Promise<unknown>;
-}
-export declare function createHttpHandler(config: OrgXConfig & {
-    dashboardEnabled?: boolean;
-    pluginVersion?: string;
-    installationId?: string | null;
-}, client: OrgXClient, getSnapshot: () => OrgSnapshot | null, onboarding: OnboardingController, diagnostics?: DiagnosticsProvider, adapters?: {
-    outbox?: OutboxAdapter;
-    openclaw?: OpenClawAdapter;
-}): (req: PluginRequest, res: PluginResponse) => Promise<boolean>;
-export {};
+export { createHttpHandler } from "./http/index.js";