@useorgx/openclaw-plugin 0.4.8 → 0.7.0

package/dist/http/helpers/artifact-fallback.js

@@ -0,0 +1,148 @@
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return value;
+}
+function flattenActivityMetadata(value) {
+    const record = asRecord(value);
+    if (!record)
+        return null;
+    const nested = asRecord(record.metadata);
+    if (!nested)
+        return record;
+    return { ...record, ...nested };
+}
+function metadataString(metadata, keys) {
+    if (!metadata)
+        return null;
+    for (const key of keys) {
+        const value = metadata[key];
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value.trim();
+        }
+    }
+    return null;
+}
+function metadataNumber(metadata, keys) {
+    if (!metadata)
+        return null;
+    for (const key of keys) {
+        const value = metadata[key];
+        if (typeof value === "number" && Number.isFinite(value))
+            return value;
+        if (typeof value === "string" && value.trim().length > 0) {
+            const parsed = Number(value.trim());
+            if (Number.isFinite(parsed))
+                return parsed;
+        }
+    }
+    return null;
+}
+function resolveArtifactIdFromActivityItem(item) {
+    const metadata = flattenActivityMetadata(item.metadata);
+    if (!metadata)
+        return null;
+    const rawId = metadataString(metadata, ["artifact_id", "artifactId", "work_artifact_id"]);
+    return rawId && rawId.length > 0 ? rawId : null;
+}
+function resolveArtifactHref(value) {
+    if (!value)
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    if (/^https?:\/\//i.test(trimmed))
+        return trimmed;
+    return `/orgx/api/live/filesystem/open?path=${encodeURIComponent(trimmed)}`;
+}
+export function createLocalArtifactDetailFallbackBuilder(deps) {
+    return (artifactId, warning) => {
+        let cursor = null;
+        const maxPages = 8;
+        for (let pageIndex = 0; pageIndex < maxPages; pageIndex += 1) {
+            const page = deps.listActivityPage({ limit: 500, cursor });
+            const activities = Array.isArray(page.activities) ? page.activities : [];
+            for (const item of activities) {
+                const matchId = resolveArtifactIdFromActivityItem(item);
+                if (!matchId || matchId !== artifactId)
+                    continue;
+                const metadata = flattenActivityMetadata(item.metadata) ?? {};
+                const rawPath = metadataString(metadata, [
+                    "url",
+                    "path",
+                    "file_path",
+                    "filepath",
+                    "artifact_path",
+                    "output_path",
+                    "external_url",
+                    "artifact_url",
+                ]) ?? null;
+                const artifactHref = resolveArtifactHref(rawPath);
+                const artifactType = metadataString(metadata, ["artifact_type", "artifactType", "type"]) ?? "report";
+                const artifactName = metadataString(metadata, ["artifact_name", "artifactName", "name", "title"]) ??
+                    item.title?.trim() ??
+                    `Artifact ${artifactId.slice(0, 8)}`;
+                const status = metadataString(metadata, ["artifact_status", "status", "state"]) ??
+                    (typeof metadata.event === "string" && metadata.event.includes("buffered")
+                        ? "buffered"
+                        : "draft");
+                const entityType = metadataString(metadata, ["entity_type", "entityType"]) ??
+                    (metadataString(metadata, ["initiative_id", "initiativeId"])
+                        ? "initiative"
+                        : "task");
+                const entityId = metadataString(metadata, [
+                    "entity_id",
+                    "entityId",
+                    "task_id",
+                    "taskId",
+                    "workstream_id",
+                    "workstreamId",
+                    "initiative_id",
+                    "initiativeId",
+                    "run_id",
+                    "runId",
+                ]) ?? "local";
+                const description = metadataString(metadata, ["description", "summary", "message"]) ??
+                    item.summary ??
+                    item.description ??
+                    null;
+                const version = Math.max(1, Math.round(metadataNumber(metadata, ["version", "artifact_version"]) ?? 1));
+                const createdAt = item.timestamp ?? new Date().toISOString();
+                const updatedAt = item.timestamp ?? createdAt;
+                return {
+                    artifact: {
+                        id: artifactId,
+                        name: artifactName,
+                        description,
+                        artifact_url: artifactHref ?? "",
+                        artifact_type: artifactType,
+                        status,
+                        version,
+                        entity_type: entityType,
+                        entity_id: entityId,
+                        metadata: {
+                            ...metadata,
+                            local_fallback: true,
+                            local_warning: warning,
+                            local_activity_event_id: item.id,
+                            local_activity_type: item.type,
+                            local_activity_timestamp: item.timestamp,
+                            local_source_path: rawPath,
+                        },
+                        created_at: createdAt,
+                        updated_at: updatedAt,
+                        catalog: null,
+                        cached_metadata: null,
+                    },
+                    relationships: [],
+                    localFallback: true,
+                    warning,
+                };
+            }
+            if (!page.nextCursor)
+                break;
+            cursor = page.nextCursor;
+        }
+        return null;
+    };
+}

package/dist/http/helpers/auto-continue-engine.d.ts

@@ -0,0 +1,486 @@
+import type { OrgXClient } from "../../api.js";
+import { type RuntimeHookPayload, type RuntimeInstanceRecord, type RuntimeSourceClient } from "../../runtime-instance-store.js";
+import { type MissionControlNode, type SliceScope } from "./mission-control.js";
+import type { KickoffContext, KickoffContextRequest } from "../../types.js";
+export interface CreateAutoContinueEngineDeps {
+    client: OrgXClient;
+    filename: string;
+    safeErrorMessage: (err: unknown) => string;
+    pidAlive: (pid: number) => boolean;
+    stopProcess: (pid: number) => Promise<{
+        stopped: boolean;
+        wasRunning: boolean;
+    }>;
+    resolveOrgxAgentForDomain: (domain: string) => {
+        id: string;
+        name: string;
+    };
+    checkSpawnGuardSafe: (input: {
+        domain: string;
+        taskId?: string | null;
+        initiativeId: string | null;
+        correlationId: string;
+        runId?: string | null;
+        targetLabel?: string | null;
+    }) => Promise<unknown | null>;
+    syncParentRollupsForTask: (input: {
+        initiativeId: string | null;
+        taskId: string | null;
+        workstreamId?: string | null;
+        milestoneId?: string | null;
+        correlationId?: string | null;
+    }) => Promise<void>;
+    emitActivitySafe: (input: {
+        initiativeId: string | null;
+        runId?: string | null;
+        correlationId?: string | null;
+        phase: "intent" | "execution" | "blocked" | "review" | "handoff" | "completed";
+        level?: "info" | "warn" | "error";
+        message: string;
+        progressPct?: number;
+        nextStep?: string;
+        metadata?: Record<string, unknown>;
+    }) => Promise<void>;
+    requestDecisionSafe: (input: {
+        initiativeId: string | null;
+        correlationId?: string | null;
+        title: string;
+        summary?: string | null;
+        urgency?: "low" | "medium" | "high" | "urgent";
+        options?: Array<string | Record<string, unknown>>;
+        blocking?: boolean;
+        decisionType?: string | null;
+        workstreamId?: string | null;
+        agentId?: string | null;
+        dueAt?: string | null;
+        sourceSystem?: string | null;
+        conflictSource?: string | null;
+        dedupeKey?: string | null;
+        recommendedAction?: string | null;
+        sourceRunId?: string | null;
+        sourceSessionId?: string | null;
+        sourceStreamId?: string | null;
+        sourceRef?: Record<string, unknown> | null;
+        evidenceRefs?: Array<Record<string, unknown>> | null;
+        metadata?: Record<string, unknown> | null;
+    }) => Promise<boolean | {
+        queued: boolean;
+        decisionIds?: string[];
+    }>;
+    registerArtifactSafe: (input: {
+        initiativeId: string;
+        runId: string;
+        agentId: string;
+        agentName?: string | null;
+        workstreamId: string;
+        fallbackMilestoneId?: string | null;
+        fallbackTaskIds?: string[] | null;
+        artifact: {
+            name: string;
+            artifact_type?: string | null;
+            confidence_score?: number | null;
+            description?: string | null;
+            url?: string | null;
+            milestone_id?: string | null;
+            task_ids?: string[] | null;
+        };
+        isMockWorker?: boolean;
+    }) => Promise<{
+        ok: boolean;
+        id: string | null;
+    }>;
+    applyAgentStatusUpdatesSafe: (input: {
+        initiativeId: string;
+        runId: string;
+        correlationId: string;
+        taskUpdates: Array<{
+            task_id: string;
+            status: string;
+            reason?: string | null;
+        }>;
+        milestoneUpdates: Array<{
+            milestone_id: string;
+            status: string;
+            reason?: string | null;
+        }>;
+        isMockWorker?: boolean;
+    }) => Promise<{
+        applied: number;
+        buffered: boolean;
+        taskUpdates: Array<{
+            taskId: string;
+            status: string;
+            reason: string | null;
+        }>;
+        milestoneUpdates: Array<{
+            milestoneId: string;
+            status: string;
+            reason: string | null;
+        }>;
+    }>;
+    upsertRuntimeInstanceFromHook: (payload: RuntimeHookPayload) => RuntimeInstanceRecord;
+    broadcastRuntimeSse: (event: string, payload: RuntimeInstanceRecord) => void;
+    clearSnapshotResponseCache: () => void;
+    resolveByokEnvOverrides: () => Record<string, string | undefined>;
+    randomUUID?: () => string;
+    fetchKickoffContextSafe?: (client: OrgXClient, payload: KickoffContextRequest) => Promise<KickoffContext | null>;
+    renderKickoffMessage?: (input: {
+        baseMessage: string;
+        kickoff: KickoffContext | null;
+        domain: string | null;
+        requiredSkills: string[];
+    }) => {
+        message: string;
+        contextHash: string | null;
+    };
+}
+export declare function createAutoContinueEngine(deps: CreateAutoContinueEngineDeps): {
+    autoContinueRuns: Map<string, {
+        initiativeId: string;
+        agentId: string;
+        agentName: string | null;
+        includeVerification: boolean;
+        allowedWorkstreamIds: string[] | null;
+        stopAfterSlice: boolean;
+        ignoreSpawnGuardRateLimit: boolean;
+        maxParallelSlices: number;
+        parallelMode: "iwmt";
+        scope: SliceScope;
+        tokenBudget: number | null;
+        tokensUsed: number;
+        status: "stopped" | "running" | "stopping";
+        stopReason: ("error" | "blocked" | "completed" | "stopped" | "budget_exhausted") | null;
+        stopRequested: boolean;
+        startedAt: string;
+        stoppedAt: string | null;
+        updatedAt: string;
+        lastError: string | null;
+        lastTaskId: string | null;
+        lastRunId: string | null;
+        activeSliceRunIds: string[];
+        activeTaskIds: string[];
+        laneByWorkstreamId: Record<string, {
+            workstreamId: string;
+            state: "idle" | "blocked" | "completed" | "running" | "rate_limited" | "waiting_dependency";
+            activeRunId: string | null;
+            activeTaskIds: string[];
+            blockedReason: string | null;
+            waitingOnWorkstreamIds: string[];
+            retryAt: string | null;
+            updatedAt: string;
+        }>;
+        blockedWorkstreamIds: string[];
+        activeTaskId: string | null;
+        activeRunId: string | null;
+        activeTaskTokenEstimate: number | null;
+    }>;
+    autoContinueSliceRuns: Map<string, {
+        runId: string;
+        initiativeId: string;
+        initiativeTitle: string | null;
+        workstreamId: string;
+        workstreamTitle: string | null;
+        agentId: string;
+        agentName: string | null;
+        domain: string;
+        requiredSkills: string[];
+        behaviorConfigId: string | null;
+        behaviorConfigVersion: string | null;
+        behaviorConfigHash: string | null;
+        behaviorPolicySource: string | null;
+        behaviorAutomationLevel: "auto" | "supervised" | "manual";
+        sourceClient: RuntimeSourceClient;
+        pid: number | null;
+        status: "error" | "blocked" | "completed" | "running";
+        startedAt: string;
+        finishedAt: string | null;
+        updatedAt: string;
+        tokenEstimate: number | null;
+        outputPath: string;
+        logPath: string;
+        taskIds: string[];
+        milestoneIds: string[];
+        scope: SliceScope;
+        scopeMilestoneIds: string[];
+        lastError: string | null;
+        isMockWorker: boolean;
+    }>;
+    localInitiativeStatusOverrides: Map<string, {
+        status: string;
+        updatedAt: string;
+    }>;
+    writeRuntimeEvent: (input: {
+        sourceClient: RuntimeSourceClient;
+        event: RuntimeHookPayload["event"];
+        runId: string;
+        initiativeId: string;
+        workstreamId: string | null;
+        taskId: string | null;
+        agentId: string | null;
+        agentName: string | null;
+        phase: string | null;
+        message?: string | null;
+        progressPct?: number | null;
+        metadata?: Record<string, unknown> | null;
+        timestamp?: string | null;
+    }) => RuntimeInstanceRecord;
+    autoContinueTickMs: number;
+    defaultAutoContinueTokenBudget: () => number | null;
+    defaultAutoContinueMaxParallelSlices: () => number;
+    setLocalInitiativeStatusOverride: (initiativeId: string, status: string) => void;
+    clearLocalInitiativeStatusOverride: (initiativeId: string) => void;
+    applyLocalInitiativeOverrides: (rows: Record<string, unknown>[]) => Record<string, unknown>[];
+    applyLocalInitiativeOverrideToGraph: <T extends {
+        initiative: {
+            id: string;
+            status: string;
+        };
+        nodes: MissionControlNode[];
+    }>(graph: T) => T;
+    updateInitiativeAutoContinueState: (input: {
+        initiativeId: string;
+        run: {
+            initiativeId: string;
+            agentId: string;
+            agentName: string | null;
+            includeVerification: boolean;
+            allowedWorkstreamIds: string[] | null;
+            stopAfterSlice: boolean;
+            ignoreSpawnGuardRateLimit: boolean;
+            maxParallelSlices: number;
+            parallelMode: "iwmt";
+            scope: SliceScope;
+            tokenBudget: number | null;
+            tokensUsed: number;
+            status: "stopped" | "running" | "stopping";
+            stopReason: ("error" | "blocked" | "completed" | "stopped" | "budget_exhausted") | null;
+            stopRequested: boolean;
+            startedAt: string;
+            stoppedAt: string | null;
+            updatedAt: string;
+            lastError: string | null;
+            lastTaskId: string | null;
+            lastRunId: string | null;
+            activeSliceRunIds: string[];
+            activeTaskIds: string[];
+            laneByWorkstreamId: Record<string, {
+                workstreamId: string;
+                state: "idle" | "blocked" | "completed" | "running" | "rate_limited" | "waiting_dependency";
+                activeRunId: string | null;
+                activeTaskIds: string[];
+                blockedReason: string | null;
+                waitingOnWorkstreamIds: string[];
+                retryAt: string | null;
+                updatedAt: string;
+            }>;
+            blockedWorkstreamIds: string[];
+            activeTaskId: string | null;
+            activeRunId: string | null;
+            activeTaskTokenEstimate: number | null;
+        };
+    }) => Promise<void>;
+    stopAutoContinueRun: (input: {
+        run: {
+            initiativeId: string;
+            agentId: string;
+            agentName: string | null;
+            includeVerification: boolean;
+            allowedWorkstreamIds: string[] | null;
+            stopAfterSlice: boolean;
+            ignoreSpawnGuardRateLimit: boolean;
+            maxParallelSlices: number;
+            parallelMode: "iwmt";
+            scope: SliceScope;
+            tokenBudget: number | null;
+            tokensUsed: number;
+            status: "stopped" | "running" | "stopping";
+            stopReason: ("error" | "blocked" | "completed" | "stopped" | "budget_exhausted") | null;
+            stopRequested: boolean;
+            startedAt: string;
+            stoppedAt: string | null;
+            updatedAt: string;
+            lastError: string | null;
+            lastTaskId: string | null;
+            lastRunId: string | null;
+            activeSliceRunIds: string[];
+            activeTaskIds: string[];
+            laneByWorkstreamId: Record<string, {
+                workstreamId: string;
+                state: "idle" | "blocked" | "completed" | "running" | "rate_limited" | "waiting_dependency";
+                activeRunId: string | null;
+                activeTaskIds: string[];
+                blockedReason: string | null;
+                waitingOnWorkstreamIds: string[];
+                retryAt: string | null;
+                updatedAt: string;
+            }>;
+            blockedWorkstreamIds: string[];
+            activeTaskId: string | null;
+            activeRunId: string | null;
+            activeTaskTokenEstimate: number | null;
+        };
+        reason: "error" | "blocked" | "completed" | "stopped" | "budget_exhausted";
+        error?: string | null;
+        decisionRequired?: boolean;
+        decisionIds?: string[];
+    }) => Promise<void>;
+    tickAutoContinueRun: (run: {
+        initiativeId: string;
+        agentId: string;
+        agentName: string | null;
+        includeVerification: boolean;
+        allowedWorkstreamIds: string[] | null;
+        stopAfterSlice: boolean;
+        ignoreSpawnGuardRateLimit: boolean;
+        maxParallelSlices: number;
+        parallelMode: "iwmt";
+        scope: SliceScope;
+        tokenBudget: number | null;
+        tokensUsed: number;
+        status: "stopped" | "running" | "stopping";
+        stopReason: ("error" | "blocked" | "completed" | "stopped" | "budget_exhausted") | null;
+        stopRequested: boolean;
+        startedAt: string;
+        stoppedAt: string | null;
+        updatedAt: string;
+        lastError: string | null;
+        lastTaskId: string | null;
+        lastRunId: string | null;
+        activeSliceRunIds: string[];
+        activeTaskIds: string[];
+        laneByWorkstreamId: Record<string, {
+            workstreamId: string;
+            state: "idle" | "blocked" | "completed" | "running" | "rate_limited" | "waiting_dependency";
+            activeRunId: string | null;
+            activeTaskIds: string[];
+            blockedReason: string | null;
+            waitingOnWorkstreamIds: string[];
+            retryAt: string | null;
+            updatedAt: string;
+        }>;
+        blockedWorkstreamIds: string[];
+        activeTaskId: string | null;
+        activeRunId: string | null;
+        activeTaskTokenEstimate: number | null;
+    }) => Promise<void>;
+    tickAllAutoContinue: () => Promise<void>;
+    isInitiativeActiveStatus: (status: string | null | undefined) => boolean;
+    runningAutoContinueForWorkstream: (initiativeId: string, workstreamId: string) => {
+        initiativeId: string;
+        agentId: string;
+        agentName: string | null;
+        includeVerification: boolean;
+        allowedWorkstreamIds: string[] | null;
+        stopAfterSlice: boolean;
+        ignoreSpawnGuardRateLimit: boolean;
+        maxParallelSlices: number;
+        parallelMode: "iwmt";
+        scope: SliceScope;
+        tokenBudget: number | null;
+        tokensUsed: number;
+        status: "stopped" | "running" | "stopping";
+        stopReason: ("error" | "blocked" | "completed" | "stopped" | "budget_exhausted") | null;
+        stopRequested: boolean;
+        startedAt: string;
+        stoppedAt: string | null;
+        updatedAt: string;
+        lastError: string | null;
+        lastTaskId: string | null;
+        lastRunId: string | null;
+        activeSliceRunIds: string[];
+        activeTaskIds: string[];
+        laneByWorkstreamId: Record<string, {
+            workstreamId: string;
+            state: "idle" | "blocked" | "completed" | "running" | "rate_limited" | "waiting_dependency";
+            activeRunId: string | null;
+            activeTaskIds: string[];
+            blockedReason: string | null;
+            waitingOnWorkstreamIds: string[];
+            retryAt: string | null;
+            updatedAt: string;
+        }>;
+        blockedWorkstreamIds: string[];
+        activeTaskId: string | null;
+        activeRunId: string | null;
+        activeTaskTokenEstimate: number | null;
+    } | null;
+    getAutoContinueLaneForWorkstream: (initiativeId: string, workstreamId: string) => {
+        workstreamId: string;
+        state: "idle" | "blocked" | "completed" | "running" | "rate_limited" | "waiting_dependency";
+        activeRunId: string | null;
+        activeTaskIds: string[];
+        blockedReason: string | null;
+        waitingOnWorkstreamIds: string[];
+        retryAt: string | null;
+        updatedAt: string;
+    } | null;
+    scheduleAutoFixForWorkstream: (input: {
+        initiativeId: string;
+        workstreamId: string;
+        runId?: string | null;
+        event?: string | null;
+        requestedByAgentId?: string | null;
+        requestedByAgentName?: string | null;
+        graceMs?: number | null;
+    }) => Promise<{
+        requestId: string;
+        initiativeId: string;
+        workstreamId: string;
+        runId: string | null;
+        sourceEvent: string | null;
+        graceMs: number;
+        scheduledAt: string;
+        dueAt: string;
+    }>;
+    startAutoContinueRun: (input: {
+        initiativeId: string;
+        agentId: string;
+        agentName?: string | null;
+        tokenBudget: unknown;
+        includeVerification: boolean;
+        allowedWorkstreamIds: string[] | null;
+        maxParallelSlices?: unknown;
+        parallelMode?: unknown;
+        stopAfterSlice?: boolean;
+        ignoreSpawnGuardRateLimit?: boolean;
+        scope?: SliceScope;
+    }) => Promise<{
+        initiativeId: string;
+        agentId: string;
+        agentName: string | null;
+        includeVerification: boolean;
+        allowedWorkstreamIds: string[] | null;
+        stopAfterSlice: boolean;
+        ignoreSpawnGuardRateLimit: boolean;
+        maxParallelSlices: number;
+        parallelMode: "iwmt";
+        scope: SliceScope;
+        tokenBudget: number | null;
+        tokensUsed: number;
+        status: "stopped" | "running" | "stopping";
+        stopReason: ("error" | "blocked" | "completed" | "stopped" | "budget_exhausted") | null;
+        stopRequested: boolean;
+        startedAt: string;
+        stoppedAt: string | null;
+        updatedAt: string;
+        lastError: string | null;
+        lastTaskId: string | null;
+        lastRunId: string | null;
+        activeSliceRunIds: string[];
+        activeTaskIds: string[];
+        laneByWorkstreamId: Record<string, {
+            workstreamId: string;
+            state: "idle" | "blocked" | "completed" | "running" | "rate_limited" | "waiting_dependency";
+            activeRunId: string | null;
+            activeTaskIds: string[];
+            blockedReason: string | null;
+            waitingOnWorkstreamIds: string[];
+            retryAt: string | null;
+            updatedAt: string;
+        }>;
+        blockedWorkstreamIds: string[];
+        activeTaskId: string | null;
+        activeRunId: string | null;
+        activeTaskTokenEstimate: number | null;
+    }>;
+};