@useorgx/openclaw-plugin 0.4.6 → 0.4.9

package/dist/http/router.d.ts

@@ -0,0 +1,23 @@
+import type { SharedState } from "./shared-state.js";
+export type RouteMethod = "GET" | "HEAD" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "*";
+export interface RouteContext<TState = SharedState, TReq = unknown, TRes = unknown> {
+    req: TReq;
+    res: TRes;
+    path: string;
+    query: URLSearchParams;
+    body: unknown;
+    state: TState;
+}
+export type RouteHandler<TState = SharedState, TReq = unknown, TRes = unknown> = (ctx: RouteContext<TState, TReq, TRes>) => Promise<void> | void;
+export interface RouteDefinition<TState = SharedState, TReq = unknown, TRes = unknown> {
+    method: RouteMethod;
+    pattern: string;
+    handler: RouteHandler<TState, TReq, TRes>;
+    description?: string;
+}
+export interface Router<TState = SharedState, TReq = unknown, TRes = unknown> {
+    add: (method: RouteMethod, pattern: string, handler: RouteHandler<TState, TReq, TRes>, description?: string) => void;
+    match: (method: string, path: string) => RouteDefinition<TState, TReq, TRes> | undefined;
+    routes: () => readonly RouteDefinition<TState, TReq, TRes>[];
+}
+export declare function createRouter<TState = SharedState, TReq = unknown, TRes = unknown>(): Router<TState, TReq, TRes>;

package/dist/http/router.js

@@ -0,0 +1,23 @@
+function isPatternMatch(pattern, path) {
+    if (pattern.endsWith("/*")) {
+        return path.startsWith(pattern.slice(0, -1));
+    }
+    return pattern === path;
+}
+export function createRouter() {
+    const entries = [];
+    function add(method, pattern, handler, description) {
+        entries.push({ method, pattern, handler, description });
+    }
+    function match(method, path) {
+        const normalizedMethod = method.toUpperCase();
+        return entries.find((route) => {
+            const methodMatches = route.method === "*" || route.method === normalizedMethod;
+            return methodMatches && isPatternMatch(route.pattern, path);
+        });
+    }
+    function routes() {
+        return entries;
+    }
+    return { add, match, routes };
+}

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

@@ -0,0 +1,79 @@
+import type { Router } from "../router.js";
+type JsonRecord = Record<string, unknown>;
+type SpawnGuardResult = {
+    allowed: boolean;
+    retryable: boolean;
+    blockedReason: string | null;
+    spawnGuardResult: unknown | null;
+};
+type DispatchExecutionPolicy = {
+    domain: string | null;
+    requiredSkills: string[];
+};
+type DispatchResolution = {
+    executionPolicy: DispatchExecutionPolicy;
+    taskTitle: string | null;
+    workstreamTitle: string | null;
+};
+type BillingStatus = {
+    plan?: string;
+};
+type AgentRunRecord = {
+    runId: string;
+    agentId: string;
+    pid: number | null;
+    message: string | null;
+    provider: string | null;
+    model: string | null;
+    initiativeId: string | null;
+    initiativeTitle: string | null;
+    workstreamId: string | null;
+    taskId: string | null;
+};
+type RegisterAgentControlRoutesDeps<TReq, TRes> = {
+    parseJsonRequest: (req: TReq) => Promise<JsonRecord>;
+    pickString: (record: Record<string, unknown>, keys: string[]) => string | null;
+    parseBooleanQuery: (value: string | null) => boolean | null;
+    randomUUID: () => string;
+    normalizeOpenClawProvider: (value: string | null) => string | null;
+    resolveAutoOpenClawProvider: () => string | null;
+    modelImpliesByok: (model: string | null) => boolean;
+    listAgents: () => Promise<Array<Record<string, unknown>>>;
+    fetchBillingStatusSafe: (client: any) => Promise<BillingStatus | null>;
+    client: any;
+    resolveDispatchExecutionPolicy: (input: any) => Promise<DispatchResolution>;
+    fetchKickoffContextSafe: (client: any, payload: any) => Promise<unknown>;
+    renderKickoffMessage: (input: any) => {
+        message: string;
+        contextHash: string | null;
+    };
+    posthogCapture: (input: any) => Promise<void>;
+    telemetryDistinctId: string;
+    pluginVersion: string | null;
+    enforceSpawnGuardForDispatch: (input: any) => Promise<SpawnGuardResult>;
+    extractSpawnGuardModelTier: (value: any) => string | null;
+    buildPolicyEnforcedMessage: (input: any) => string;
+    syncParentRollupsForTask: (input: any) => Promise<void>;
+    emitActivitySafe: (input: any) => Promise<void>;
+    configureOpenClawProviderRouting: (input: any) => Promise<{
+        provider: string;
+        model: string;
+    }>;
+    upsertAgentContext: (input: any) => unknown;
+    upsertRunContext: (input: any) => unknown;
+    spawnAgentTurn: (input: any) => {
+        pid: number | null;
+    };
+    upsertAgentRun: (input: any) => unknown;
+    getAgentRun: (runId: string) => AgentRunRecord | null | any;
+    stopProcess: (pid: number) => Promise<{
+        stopped: boolean;
+        wasRunning: boolean;
+    }>;
+    markAgentRunStopped: (runId: string) => unknown;
+    writeRuntimeEvent: (input: any) => void;
+    sendJson: (res: TRes, status: number, payload: unknown) => void;
+    safeErrorMessage: (err: unknown) => string;
+};
+export declare function registerAgentControlRoutes<TReq, TRes>(router: Router<Record<string, never>, TReq, TRes>, deps: RegisterAgentControlRoutesDeps<TReq, TRes>): void;
+export {};