@useorgx/openclaw-plugin 0.4.9 → 0.7.0

package/dist/http/routes/realtime-orchestrator.d.ts

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

package/dist/http/routes/realtime-orchestrator.js

@@ -0,0 +1,74 @@
+function parseStatusCodeFromError(message) {
+    const normalized = message.trim();
+    const match = normalized.match(/^(\d{3})\b/);
+    if (!match)
+        return 500;
+    const value = Number(match[1]);
+    if (!Number.isFinite(value))
+        return 500;
+    if (value < 400 || value > 599)
+        return 500;
+    return value;
+}
+export function registerRealtimeOrchestratorRoutes(router, deps) {
+    router.add("POST", "realtime/session", async ({ req, res }) => {
+        try {
+            const payload = await deps.parseJsonRequest(req);
+            const upstream = await deps.rawRequest("POST", "/api/client/orchestrator/realtime/session", payload);
+            deps.sendJson(res, 200, upstream);
+        }
+        catch (err) {
+            const message = deps.safeErrorMessage(err);
+            deps.sendJson(res, parseStatusCodeFromError(message), { ok: false, error: message });
+        }
+    }, "Create an ephemeral GPT realtime session for orchestrator voice control");
+    router.add("POST", "orchestrator/commands/preview", async ({ req, res }) => {
+        try {
+            const payload = await deps.parseJsonRequest(req);
+            const upstream = await deps.rawRequest("POST", "/api/client/orchestrator/commands/preview", payload);
+            deps.sendJson(res, 200, upstream);
+        }
+        catch (err) {
+            const message = deps.safeErrorMessage(err);
+            deps.sendJson(res, parseStatusCodeFromError(message), { ok: false, error: message });
+        }
+    }, "Preview inferred orchestrator actions from natural language input");
+    router.add("POST", "orchestrator/commands/apply", async ({ req, res }) => {
+        try {
+            const payload = await deps.parseJsonRequest(req);
+            const upstream = await deps.rawRequest("POST", "/api/client/orchestrator/commands/apply", payload);
+            deps.sendJson(res, 200, upstream);
+        }
+        catch (err) {
+            const message = deps.safeErrorMessage(err);
+            deps.sendJson(res, parseStatusCodeFromError(message), { ok: false, error: message });
+        }
+    }, "Apply confirmed orchestrator actions");
+    router.add("GET", "orchestrator/commands/*", async ({ path, res }) => {
+        const match = path.match(/^orchestrator\/commands\/([^/]+)$/);
+        if (!match) {
+            deps.sendJson(res, 404, { ok: false, error: "Unknown API endpoint" });
+            return;
+        }
+        let commandId = "";
+        try {
+            commandId = decodeURIComponent(match[1] ?? "").trim();
+        }
+        catch {
+            deps.sendJson(res, 400, { ok: false, error: "invalid command id encoding" });
+            return;
+        }
+        if (!commandId) {
+            deps.sendJson(res, 400, { ok: false, error: "command id is required" });
+            return;
+        }
+        try {
+            const upstream = await deps.rawRequest("GET", `/api/client/orchestrator/commands/${encodeURIComponent(commandId)}`);
+            deps.sendJson(res, 200, upstream);
+        }
+        catch (err) {
+            const message = deps.safeErrorMessage(err);
+            deps.sendJson(res, parseStatusCodeFromError(message), { ok: false, error: message });
+        }
+    }, "Read orchestrator command status");
+}

package/dist/http/routes/run-control.d.ts

@@ -1,6 +1,6 @@
 import type { Router } from "../router.js";
 type JsonRecord = Record<string, unknown>;
-type RunAction = "pause" | "resume" | "cancel" | "rollback";
+type RunAction = "pause" | "resume" | "cancel" | "rollback" | "complete";
 type RegisterRunControlRoutesDeps<TReq, TRes> = {
     parseJsonRequest: (req: TReq) => Promise<JsonRecord>;
     pickString: (input: Record<string, unknown>, keys: string[]) => string | null;
@@ -13,10 +13,13 @@ type RegisterRunControlRoutesDeps<TReq, TRes> = {
         checkpointId: string;
         reason?: string;
     }) => Promise<unknown>;
-    runAction: (runId: string, action: RunAction, input: {
+    runAction: (runId: string, action: Exclude<RunAction, "complete">, input: {
         checkpointId?: string;
         reason?: string;
     }) => Promise<unknown>;
+    markRunCompleted: (runId: string, input: {
+        reason?: string;
+    }) => Promise<unknown>;
     sendJson: (res: TRes, status: number, payload: unknown) => void;
     safeErrorMessage: (err: unknown) => string;
 };

package/dist/http/routes/run-control.js

@@ -70,6 +70,13 @@ export function registerRunControlRoutes(router, deps) {
                 const payload = await deps.parseJsonRequest(req);
                 const checkpointId = deps.pickString(payload, ["checkpointId", "checkpoint_id"]);
                 const reason = deps.pickString(payload, ["reason"]);
+                if (action === "complete") {
+                    const data = await deps.markRunCompleted(runId, {
+                        reason: reason ?? undefined,
+                    });
+                    deps.sendJson(res, 200, data);
+                    return;
+                }
                 const data = await deps.runAction(runId, action, {
                     checkpointId: checkpointId ?? undefined,
                     reason: reason ?? undefined,
@@ -77,6 +84,9 @@ export function registerRunControlRoutes(router, deps) {
                 deps.sendJson(res, 200, data);
             }
             catch (err) {
+                const actionLabel = runActionMatch ? runActionMatch[2] : "unknown";
+                const runLabel = runActionMatch ? runActionMatch[1] : "unknown";
+                console.error(`[run-control] ${actionLabel} failed for run ${runLabel}:`, err);
                 deps.sendJson(res, 500, { error: deps.safeErrorMessage(err) });
             }
             return;

package/dist/http/routes/sentinels-catalog.d.ts

@@ -0,0 +1,7 @@
+import type { Router } from "../router.js";
+type SentinelsCatalogDeps<TRes> = {
+    sendJson: (res: TRes, status: number, payload: unknown) => void;
+    safeErrorMessage: (err: unknown) => string;
+};
+export declare function registerSentinelsCatalogRoutes<TReq, TRes>(router: Router<Record<string, never>, TReq, TRes>, deps: SentinelsCatalogDeps<TRes>): void;
+export {};

package/dist/http/routes/sentinels-catalog.js

@@ -0,0 +1,24 @@
+import { listBuiltInSentinels } from "../helpers/sentinel-catalog.js";
+export function registerSentinelsCatalogRoutes(router, deps) {
+    async function handle(res, domain) {
+        try {
+            const sentinels = listBuiltInSentinels({ domain });
+            deps.sendJson(res, 200, {
+                generatedAt: new Date().toISOString(),
+                domain: domain ?? null,
+                sentinels,
+            });
+        }
+        catch (err) {
+            deps.sendJson(res, 500, {
+                error: deps.safeErrorMessage(err),
+            });
+        }
+    }
+    router.add("GET", "sentinels/catalog", async ({ query, res }) => {
+        return handle(res, query?.get("domain") ?? undefined);
+    }, "Sentinel catalog");
+    router.add("HEAD", "sentinels/catalog", async ({ query, res }) => {
+        return handle(res, query?.get("domain") ?? undefined);
+    }, "Sentinel catalog (HEAD)");
+}

package/dist/http/routes/summary.js

@@ -1,4 +1,11 @@
 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) {
@@ -28,13 +35,13 @@ export function registerSummaryRoutes(router, deps) {
         deps.sendJson(res, 200, deps.formatStatus(snapshot));
     }, "Status snapshot");
     router.add("GET", "agents", ({ res }) => {
-        deps.sendJson(res, 200, deps.formatAgents(deps.getSnapshot()));
+        sendDeprecated(res, "/orgx/api/agents", "/orgx/api/live/agents");
     }, "Agent summary");
     router.add("GET", "activity", ({ res }) => {
-        deps.sendJson(res, 200, deps.formatActivity(deps.getSnapshot()));
+        sendDeprecated(res, "/orgx/api/activity", "/orgx/api/live/snapshot");
     }, "Activity summary");
     router.add("GET", "initiatives", ({ res }) => {
-        deps.sendJson(res, 200, deps.formatInitiatives(deps.getSnapshot()));
+        sendDeprecated(res, "/orgx/api/initiatives", "/orgx/api/live/initiatives");
     }, "Initiatives summary");
     router.add("GET", "onboarding", async ({ res }) => {
         deps.sendJson(res, 200, await deps.getOnboardingState());

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.js

@@ -1,13 +1,24 @@
 export function registerWorkArtifactsRoutes(router, deps) {
     router.add("GET", "work-artifacts/by-entity", async ({ query, res }) => {
+        const qs = query.toString();
         try {
-            const qs = query.toString();
-            const path = `/api/work-artifacts/by-entity${qs ? `?${qs}` : ""}`;
+            const path = `/api/client/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) });
+            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 }) => {
@@ -18,18 +29,26 @@ export function registerWorkArtifactsRoutes(router, deps) {
         }
         const artifactId = decodeURIComponent(artifactDetailMatch[1]);
         try {
-            const upstreamPath = `/api/artifacts/${encodeURIComponent(artifactId)}`;
+            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);
-            const fallback = deps.buildLocalArtifactDetailFallback(artifactId, warning);
-            if (fallback) {
-                deps.sendJson(res, 200, fallback);
+            try {
+                const legacyPath = `/api/artifacts/${encodeURIComponent(artifactId)}`;
+                const legacyData = await deps.rawRequest("GET", legacyPath);
+                deps.sendJson(res, 200, legacyData);
             }
-            else {
-                deps.sendJson(res, 502, { error: warning });
+            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");