@useorgx/openclaw-plugin 0.4.8 → 0.7.0

package/dist/http/routes/summary.js

@@ -0,0 +1,49 @@
+export function registerSummaryRoutes(router, deps) {
+    const sendDeprecated = (res, endpoint, replacement) => {
+        deps.sendJson(res, 410, {
+            error: `${endpoint} is deprecated`,
+            replacement,
+            required_scope: "workspace_id",
+        });
+    };
+    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 }) => {
+        sendDeprecated(res, "/orgx/api/agents", "/orgx/api/live/agents");
+    }, "Agent summary");
+    router.add("GET", "activity", ({ res }) => {
+        sendDeprecated(res, "/orgx/api/activity", "/orgx/api/live/snapshot");
+    }, "Activity summary");
+    router.add("GET", "initiatives", ({ res }) => {
+        sendDeprecated(res, "/orgx/api/initiatives", "/orgx/api/live/initiatives");
+    }, "Initiatives summary");
+    router.add("GET", "onboarding", async ({ res }) => {
+        deps.sendJson(res, 200, await deps.getOnboardingState());
+    }, "Legacy onboarding state endpoint");
+}

package/dist/http/routes/usage.d.ts

@@ -0,0 +1,24 @@
+import type { LiveActivityItem, UsageControlPlaneSummary } from "../../types.js";
+import type { Router } from "../router.js";
+type UsageClientLike = {
+    getUsageControlPlaneSummary: () => Promise<UsageControlPlaneSummary>;
+};
+type UsageRoutesDeps<TRes> = {
+    client: UsageClientLike;
+    listActivityPage: (input: {
+        limit: number;
+        runId?: string | null;
+        since?: string | null;
+        until?: string | null;
+        cursor?: string | null;
+    }) => {
+        activities: LiveActivityItem[];
+        nextCursor: string | null;
+        total: number;
+    };
+    sendJson: (res: TRes, status: number, payload: unknown) => void;
+    safeErrorMessage: (err: unknown) => string;
+    now?: () => Date;
+};
+export declare function registerUsageRoutes<TReq, TRes>(router: Router<Record<string, never>, TReq, TRes>, deps: UsageRoutesDeps<TRes>): void;
+export {};

package/dist/http/routes/usage.js

@@ -0,0 +1,362 @@
+const DAY_MS = 24 * 60 * 60_000;
+const MAX_ACTIVITY_PAGES = 12;
+const PAGE_LIMIT = 500;
+function clampInt(value, min, max) {
+    if (!Number.isFinite(value))
+        return min;
+    const rounded = Math.floor(value);
+    if (rounded < min)
+        return min;
+    if (rounded > max)
+        return max;
+    return rounded;
+}
+function toEpoch(value) {
+    if (!value)
+        return 0;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function toNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string") {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return null;
+}
+function normalizeText(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return value;
+}
+function pickMetadataNumber(metadata, keys) {
+    if (!metadata)
+        return null;
+    for (const key of keys) {
+        const parsed = toNumber(metadata[key]);
+        if (parsed !== null)
+            return parsed;
+    }
+    return null;
+}
+function pickMetadataString(metadata, keys) {
+    if (!metadata)
+        return null;
+    for (const key of keys) {
+        const normalized = normalizeText(metadata[key]);
+        if (normalized)
+            return normalized;
+    }
+    return null;
+}
+function roundInt(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.max(0, Math.round(value));
+}
+function addToBucket(map, key, runRef, tokens, minutes, costCents) {
+    const normalizedKey = key.trim() || "unknown";
+    const bucket = map.get(normalizedKey) ??
+        {
+            runs: new Set(),
+            tokens: 0,
+            minutes: 0,
+            costCents: 0,
+        };
+    bucket.runs.add(runRef);
+    bucket.tokens += tokens;
+    bucket.minutes += minutes;
+    bucket.costCents += costCents;
+    map.set(normalizedKey, bucket);
+}
+function mapToBreakdownBuckets(map, labelTransform) {
+    return Array.from(map.entries())
+        .map(([key, value]) => ({
+        key,
+        label: labelTransform ? labelTransform(key) : key,
+        runs: value.runs.size,
+        tokens: roundInt(value.tokens),
+        minutes: roundInt(value.minutes),
+        costCents: roundInt(value.costCents),
+    }))
+        .sort((a, b) => {
+        if (b.runs !== a.runs)
+            return b.runs - a.runs;
+        return b.tokens - a.tokens;
+    });
+}
+function startOfMonthUtc(now) {
+    return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1));
+}
+function startOfNextMonthUtc(now) {
+    return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() + 1, 1));
+}
+function capitalizeLabel(input) {
+    const normalized = input.trim();
+    if (!normalized)
+        return "Unknown";
+    return normalized
+        .split(/[\s_-]+/g)
+        .map((part) => part.length > 0 ? `${part[0].toUpperCase()}${part.slice(1).toLowerCase()}` : part)
+        .join(" ");
+}
+function buildLocalSummary(input) {
+    const periodStartIso = input.periodStart.toISOString();
+    const periodEndIso = input.periodEnd.toISOString();
+    const nowEpoch = input.now.getTime();
+    const startEpoch = input.periodStart.getTime();
+    const endEpoch = input.periodEnd.getTime();
+    const daysTotal = Math.max(1, Math.round((endEpoch - startEpoch) / DAY_MS));
+    const elapsedWindow = Math.max(0, nowEpoch - startEpoch);
+    const daysElapsed = clampInt(Math.floor(elapsedWindow / DAY_MS) + 1, 1, daysTotal);
+    const daysRemaining = Math.max(0, daysTotal - daysElapsed);
+    const runIds = new Set();
+    let totalTokens = 0;
+    let totalMinutes = 0;
+    let totalCostCents = 0;
+    let usedFallbackMinutes = false;
+    const sourceClientBuckets = new Map();
+    const providerBuckets = new Map();
+    const modelBuckets = new Map();
+    const executionTargetBuckets = new Map();
+    for (const item of input.activities) {
+        const timestampEpoch = toEpoch(item.timestamp);
+        if (!timestampEpoch || timestampEpoch < startEpoch || timestampEpoch >= endEpoch)
+            continue;
+        const metadata = asRecord(item.metadata);
+        const runId = normalizeText(item.runId) ??
+            pickMetadataString(metadata, ["run_id", "runId", "correlation_id", "correlationId"]) ??
+            item.id;
+        runIds.add(runId);
+        const rawTokens = pickMetadataNumber(metadata, [
+            "tokens_used",
+            "tokensUsed",
+            "total_tokens",
+            "totalTokens",
+            "auto_continue_tokens_used",
+        ]) ?? 0;
+        const rawMinutes = pickMetadataNumber(metadata, [
+            "duration_minutes",
+            "durationMinutes",
+            "elapsed_minutes",
+            "elapsedMinutes",
+            "minutes",
+        ]) ??
+            (() => {
+                const durationMs = pickMetadataNumber(metadata, ["duration_ms", "durationMs", "elapsed_ms"]);
+                return durationMs !== null ? durationMs / 60_000 : null;
+            })();
+        const minutes = rawMinutes !== null ? Math.max(0, rawMinutes) : 0;
+        if (rawMinutes === null)
+            usedFallbackMinutes = true;
+        const rawCostCents = pickMetadataNumber(metadata, ["cost_cents", "costCents"]) ??
+            (() => {
+                const costUsd = pickMetadataNumber(metadata, ["cost_usd", "costUsd"]);
+                return costUsd !== null ? costUsd * 100 : null;
+            })() ??
+            0;
+        const tokens = Math.max(0, rawTokens);
+        const costCents = Math.max(0, rawCostCents);
+        totalTokens += tokens;
+        totalMinutes += minutes;
+        totalCostCents += costCents;
+        const sourceClient = pickMetadataString(metadata, ["source_client", "sourceClient", "runtime_source", "runtimeSource"]) ??
+            normalizeText(item.runtimeClient) ??
+            "unknown";
+        const provider = pickMetadataString(metadata, ["provider", "runtime_provider", "runtimeProvider"]) ??
+            normalizeText(item.runtimeProvider) ??
+            "unknown";
+        const model = pickMetadataString(metadata, ["model", "model_id", "modelId"]) ?? "unknown";
+        const executionTarget = pickMetadataString(metadata, ["execution_target", "executionTarget", "executor"]) ??
+            "unknown";
+        addToBucket(sourceClientBuckets, sourceClient, runId, tokens, minutes, costCents);
+        addToBucket(providerBuckets, provider, runId, tokens, minutes, costCents);
+        addToBucket(modelBuckets, model, runId, tokens, minutes, costCents);
+        addToBucket(executionTargetBuckets, executionTarget, runId, tokens, minutes, costCents);
+    }
+    if (usedFallbackMinutes && runIds.size > 0 && totalMinutes === 0) {
+        totalMinutes = runIds.size * 4;
+        input.warnings.push("Agent minutes are estimated from run volume because duration telemetry was unavailable.");
+    }
+    const scale = daysElapsed > 0 ? daysTotal / daysElapsed : 1;
+    const predictedRuns = roundInt(runIds.size * scale);
+    const predictedMinutes = roundInt(totalMinutes * scale);
+    const predictedTokens = roundInt(totalTokens * scale);
+    const predictedCostCents = roundInt(totalCostCents * scale);
+    const confidence = Math.max(0.4, Math.min(0.95, daysElapsed / Math.max(daysTotal, 1)));
+    return {
+        generatedAt: new Date().toISOString(),
+        period: {
+            start: periodStartIso,
+            end: periodEndIso,
+            daysTotal,
+            daysElapsed,
+            daysRemaining,
+        },
+        plan: {
+            id: "local_estimate",
+            name: "Local Runtime Estimate",
+            allowsOverage: true,
+            includedBudgetCents: 0,
+            overageBudgetCents: 0,
+            agentRunsLimit: 0,
+            agentMinutesLimit: 0,
+            scaffoldsLimit: 0,
+        },
+        actual: {
+            agentRuns: runIds.size,
+            agentMinutes: roundInt(totalMinutes),
+            tokens: roundInt(totalTokens),
+            costCents: roundInt(totalCostCents),
+            scaffoldsUsed: 0,
+            scaffoldsRemaining: 0,
+        },
+        predicted: {
+            agentRuns: predictedRuns,
+            agentMinutes: predictedMinutes,
+            tokens: predictedTokens,
+            costCents: predictedCostCents,
+            confidence: Number(confidence.toFixed(2)),
+            method: "local_linear_projection",
+            remainingAgentRuns: Math.max(0, predictedRuns - runIds.size),
+            remainingAgentMinutes: Math.max(0, predictedMinutes - roundInt(totalMinutes)),
+            remainingTokens: Math.max(0, predictedTokens - roundInt(totalTokens)),
+            remainingCostCents: Math.max(0, predictedCostCents - roundInt(totalCostCents)),
+        },
+        utilization: {
+            runsPct: null,
+            minutesPct: null,
+            budgetPct: null,
+        },
+        headroom: {
+            agentRunsRemaining: 0,
+            agentMinutesRemaining: 0,
+            budgetRemainingCents: 0,
+        },
+        risk: "safe",
+        breakdown: {
+            sourceClient: mapToBreakdownBuckets(sourceClientBuckets, capitalizeLabel),
+            provider: mapToBreakdownBuckets(providerBuckets, capitalizeLabel),
+            model: mapToBreakdownBuckets(modelBuckets, (key) => key),
+            executionTarget: mapToBreakdownBuckets(executionTargetBuckets, capitalizeLabel),
+        },
+        velocity: {
+            windowDays: daysElapsed,
+            dailyAvgRuns: Number((runIds.size / Math.max(daysElapsed, 1)).toFixed(2)),
+            dailyAvgMinutes: Number((totalMinutes / Math.max(daysElapsed, 1)).toFixed(2)),
+            dailyAvgTokens: Number((totalTokens / Math.max(daysElapsed, 1)).toFixed(2)),
+            dailyAvgCostCents: Number((totalCostCents / Math.max(daysElapsed, 1)).toFixed(2)),
+        },
+    };
+}
+function collectLocalActivities(deps, input) {
+    const merged = [];
+    let cursor = null;
+    for (let page = 0; page < MAX_ACTIVITY_PAGES; page += 1) {
+        const result = deps.listActivityPage({
+            limit: PAGE_LIMIT,
+            since: input.sinceIso,
+            until: input.untilIso,
+            cursor,
+        });
+        if (Array.isArray(result.activities) && result.activities.length > 0) {
+            merged.push(...result.activities);
+        }
+        if (!result.nextCursor || result.nextCursor === cursor)
+            break;
+        cursor = result.nextCursor;
+    }
+    return merged;
+}
+async function resolveUsageSummary(deps) {
+    try {
+        const summary = await deps.client.getUsageControlPlaneSummary();
+        return {
+            summary,
+            source: "cloud",
+            warnings: [],
+        };
+    }
+    catch (err) {
+        const warnings = [
+            `Cloud usage endpoint unavailable (${deps.safeErrorMessage(err)}). Showing local estimate.`,
+        ];
+        const now = deps.now ? deps.now() : new Date();
+        const periodStart = startOfMonthUtc(now);
+        const periodEnd = startOfNextMonthUtc(now);
+        const activities = collectLocalActivities(deps, {
+            sinceIso: periodStart.toISOString(),
+            untilIso: periodEnd.toISOString(),
+        });
+        const summary = buildLocalSummary({
+            activities,
+            periodStart,
+            periodEnd,
+            now,
+            warnings,
+        });
+        return {
+            summary,
+            source: "local_estimate",
+            warnings,
+        };
+    }
+}
+export function registerUsageRoutes(router, deps) {
+    router.add("GET", "usage/control-plane/summary", async ({ res }) => {
+        const resolved = await resolveUsageSummary(deps);
+        deps.sendJson(res, 200, {
+            ...resolved.summary,
+            source: resolved.source,
+            warnings: resolved.warnings,
+        });
+    }, "Usage control-plane summary");
+    router.add("GET", "usage/unified", async ({ res }) => {
+        const resolved = await resolveUsageSummary(deps);
+        deps.sendJson(res, 200, {
+            generatedAt: resolved.summary.generatedAt,
+            period: resolved.summary.period,
+            plan: resolved.summary.plan,
+            actual: resolved.summary.actual,
+            predicted: resolved.summary.predicted,
+            headroom: resolved.summary.headroom,
+            utilization: resolved.summary.utilization,
+            risk: resolved.summary.risk,
+            breakdown: resolved.summary.breakdown,
+            velocity: resolved.summary.velocity,
+            source: resolved.source,
+            warnings: resolved.warnings,
+        });
+    }, "Usage unified summary");
+    router.add("GET", "usage/forecast", async ({ res }) => {
+        const resolved = await resolveUsageSummary(deps);
+        deps.sendJson(res, 200, {
+            generatedAt: resolved.summary.generatedAt,
+            period: resolved.summary.period,
+            predicted: resolved.summary.predicted,
+            risk: resolved.summary.risk,
+            headroom: resolved.summary.headroom,
+            utilization: resolved.summary.utilization,
+            source: resolved.source,
+            warnings: resolved.warnings,
+        });
+    }, "Usage forecast summary");
+    router.add("*", "usage/control-plane/summary", ({ res }) => {
+        deps.sendJson(res, 405, { ok: false, error: "Method not allowed" });
+    }, "Reject unsupported methods for usage/control-plane/summary");
+    router.add("*", "usage/unified", ({ res }) => {
+        deps.sendJson(res, 405, { ok: false, error: "Method not allowed" });
+    }, "Reject unsupported methods for usage/unified");
+    router.add("*", "usage/forecast", ({ res }) => {
+        deps.sendJson(res, 405, { ok: false, error: "Method not allowed" });
+    }, "Reject unsupported methods for usage/forecast");
+}

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,55 @@
+export function registerWorkArtifactsRoutes(router, deps) {
+    router.add("GET", "work-artifacts/by-entity", async ({ query, res }) => {
+        const qs = query.toString();
+        try {
+            const path = `/api/client/artifacts/by-entity${qs ? `?${qs}` : ""}`;
+            const data = await deps.rawRequest("GET", path);
+            deps.sendJson(res, 200, data);
+        }
+        catch (err) {
+            const warning = deps.safeErrorMessage(err);
+            try {
+                const fallbackPath = `/api/work-artifacts/by-entity${qs ? `?${qs}` : ""}`;
+                const fallback = await deps.rawRequest("GET", fallbackPath);
+                deps.sendJson(res, 200, fallback);
+            }
+            catch (fallbackErr) {
+                deps.sendJson(res, 502, {
+                    error: deps.safeErrorMessage(fallbackErr),
+                    warning,
+                });
+            }
+        }
+    }, "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/client/artifacts/${encodeURIComponent(artifactId)}`;
+            const data = await deps.rawRequest("GET", upstreamPath);
+            deps.sendJson(res, 200, data);
+        }
+        catch (err) {
+            const warning = deps.safeErrorMessage(err);
+            try {
+                const legacyPath = `/api/artifacts/${encodeURIComponent(artifactId)}`;
+                const legacyData = await deps.rawRequest("GET", legacyPath);
+                deps.sendJson(res, 200, legacyData);
+            }
+            catch (legacyErr) {
+                const legacyWarning = `${warning}; legacy route failed: ${deps.safeErrorMessage(legacyErr)}`;
+                const fallback = deps.buildLocalArtifactDetailFallback(artifactId, legacyWarning);
+                if (fallback) {
+                    deps.sendJson(res, 200, fallback);
+                }
+                else {
+                    deps.sendJson(res, 502, { error: legacyWarning });
+                }
+            }
+        }
+    }, "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";