@useorgx/openclaw-plugin 0.4.8 → 0.7.0

package/dist/http/helpers/autopilot-operations.js

@@ -0,0 +1,554 @@
+import { appendToOutbox } from "../../outbox.js";
+import { registerArtifact } from "../../artifacts/register-artifact.js";
+export function createAutopilotOperations(deps) {
+    async function registerArtifactSafe(input) {
+        const now = new Date().toISOString();
+        const name = typeof input.artifact.name === "string" && input.artifact.name.trim().length > 0
+            ? input.artifact.name.trim()
+            : "";
+        if (!name)
+            return { ok: false, id: null };
+        const artifactType = typeof input.artifact.artifact_type === "string" && input.artifact.artifact_type.trim().length > 0
+            ? input.artifact.artifact_type.trim()
+            : "other";
+        const confidenceScore = typeof input.artifact.confidence_score === "number" &&
+            Number.isFinite(input.artifact.confidence_score) &&
+            input.artifact.confidence_score >= 0 &&
+            input.artifact.confidence_score <= 1
+            ? input.artifact.confidence_score
+            : null;
+        const artifactId = deps.randomUUID();
+        const milestoneId = (typeof input.artifact.milestone_id === "string" &&
+            input.artifact.milestone_id.trim().length > 0
+            ? input.artifact.milestone_id.trim()
+            : null) ??
+            (typeof input.fallbackMilestoneId === "string" &&
+                input.fallbackMilestoneId.trim().length > 0
+                ? input.fallbackMilestoneId.trim()
+                : null);
+        const taskIds = (Array.isArray(input.artifact.task_ids) && input.artifact.task_ids.length > 0
+            ? input.artifact.task_ids
+            : Array.isArray(input.fallbackTaskIds)
+                ? input.fallbackTaskIds
+                : [])
+            .filter((taskId) => typeof taskId === "string")
+            .map((taskId) => taskId.trim())
+            .filter(Boolean);
+        const verificationSteps = Array.isArray(input.artifact.verification_steps)
+            ? input.artifact.verification_steps
+                .filter((step) => typeof step === "string")
+                .map((step) => step.trim())
+                .filter(Boolean)
+            : [];
+        const descriptionParts = [];
+        if (typeof input.artifact.description === "string" && input.artifact.description.trim()) {
+            descriptionParts.push(input.artifact.description.trim());
+        }
+        if (verificationSteps.length > 0) {
+            descriptionParts.push(`Verification:\n${verificationSteps.map((step) => `- ${step}`).join("\n")}`);
+        }
+        const description = descriptionParts.length > 0 ? descriptionParts.join("\n\n") : undefined;
+        const hasUuidAgent = typeof input.agentId === "string" &&
+            /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(input.agentId);
+        const createdByType = hasUuidAgent ? "agent" : "human";
+        const createdById = hasUuidAgent ? input.agentId : null;
+        try {
+            const entityType = milestoneId ? "milestone" : "initiative";
+            const entityId = milestoneId ?? input.initiativeId;
+            const result = await registerArtifact(deps.client, deps.client.getBaseUrl(), {
+                artifact_id: artifactId,
+                entity_type: entityType,
+                entity_id: entityId,
+                name,
+                artifact_type: artifactType,
+                confidence_score: confidenceScore,
+                created_by_type: createdByType,
+                created_by_id: createdById,
+                description,
+                external_url: input.artifact.url ?? null,
+                preview_markdown: null,
+                status: "draft",
+                metadata: {
+                    source: "autopilot_slice",
+                    artifact_id: artifactId,
+                    run_id: input.runId,
+                    initiative_id: input.initiativeId,
+                    workstream_id: input.workstreamId,
+                    milestone_id: milestoneId,
+                    task_ids: taskIds.length > 0 ? taskIds : null,
+                    confidence_score: confidenceScore,
+                },
+                // Make persistence validation opt-in to avoid adding latency to every slice by default.
+                validate_persistence: process.env.ORGX_VALIDATE_ARTIFACT_PERSISTENCE === "1",
+            });
+            if (result.ok) {
+                try {
+                    await deps.emitActivitySafe({
+                        initiativeId: input.initiativeId,
+                        runId: input.runId,
+                        correlationId: input.runId,
+                        phase: "handoff",
+                        level: "info",
+                        message: `Artifact registered: ${name}`,
+                        progressPct: 100,
+                        metadata: {
+                            event: "artifact_registered",
+                            artifact_id: result.artifact_id ?? artifactId,
+                            artifact_type: artifactType,
+                            confidence_score: confidenceScore,
+                            initiative_id: input.initiativeId,
+                            workstream_id: input.workstreamId,
+                            milestone_id: milestoneId,
+                            task_ids: taskIds,
+                            agent_id: input.agentId,
+                            agent_name: input.agentName ?? null,
+                            executor_agent_id: input.agentId,
+                            executor_agent_name: input.agentName ?? null,
+                            source_run_id: input.runId,
+                            ...(input.isMockWorker ? { mock: true } : {}),
+                        },
+                    });
+                }
+                catch {
+                    // best effort
+                }
+            }
+            return { ok: result.ok, id: result.artifact_id };
+        }
+        catch (err) {
+            try {
+                await appendToOutbox(input.initiativeId, {
+                    id: deps.randomUUID(),
+                    type: "artifact",
+                    timestamp: now,
+                    payload: {
+                        artifact_id: artifactId,
+                        entity_type: milestoneId ? "milestone" : "initiative",
+                        entity_id: milestoneId ?? input.initiativeId,
+                        name,
+                        artifact_type: artifactType,
+                        confidence_score: confidenceScore,
+                        created_by_type: createdByType,
+                        created_by_id: createdById,
+                        description,
+                        url: input.artifact.url ?? undefined,
+                        run_id: input.runId,
+                    },
+                    activityItem: {
+                        id: deps.randomUUID(),
+                        type: "artifact_created",
+                        title: name,
+                        description: description ?? null,
+                        agentId: input.agentId,
+                        agentName: input.agentName ?? null,
+                        requesterAgentId: input.agentId,
+                        requesterAgentName: input.agentName ?? null,
+                        executorAgentId: input.agentId,
+                        executorAgentName: input.agentName ?? null,
+                        runId: input.runId,
+                        initiativeId: input.initiativeId,
+                        timestamp: now,
+                        phase: "handoff",
+                        summary: input.artifact.url ?? null,
+                        metadata: {
+                            source: "openclaw_local_fallback",
+                            event: "autopilot_slice_artifact_buffered",
+                            artifact_type: artifactType,
+                            confidence_score: confidenceScore,
+                            artifact_id: artifactId,
+                            url: input.artifact.url ?? null,
+                            error: deps.safeErrorMessage(err),
+                            ...(input.isMockWorker ? { mock: true } : {}),
+                        },
+                    },
+                });
+            }
+            catch {
+                // best effort
+            }
+            return { ok: false, id: null };
+        }
+    }
+    async function applyAgentStatusUpdatesSafe(input) {
+        const normalizeTaskStatus = (raw) => {
+            const normalized = raw.trim().toLowerCase().replace(/\s+/g, "_");
+            if (!normalized)
+                return null;
+            if (normalized === "done")
+                return "done";
+            if (normalized === "todo")
+                return "todo";
+            if (normalized === "blocked")
+                return "blocked";
+            if (normalized === "in_progress")
+                return "in_progress";
+            // Common synonyms from LMs.
+            if (normalized === "completed" || normalized === "complete" || normalized === "finished") {
+                return "done";
+            }
+            if (normalized === "inprogress" || normalized === "running" || normalized === "working") {
+                return "in_progress";
+            }
+            if (normalized === "not_started" || normalized === "planned" || normalized === "pending") {
+                return "todo";
+            }
+            return null;
+        };
+        const normalizeMilestoneStatus = (raw) => {
+            const normalized = raw.trim().toLowerCase().replace(/\s+/g, "_");
+            if (!normalized)
+                return null;
+            if (normalized === "planned")
+                return "planned";
+            if (normalized === "in_progress")
+                return "in_progress";
+            if (normalized === "completed")
+                return "completed";
+            if (normalized === "at_risk")
+                return "at_risk";
+            if (normalized === "cancelled")
+                return "cancelled";
+            // Common synonyms from LMs.
+            if (normalized === "done" || normalized === "complete" || normalized === "finished") {
+                return "completed";
+            }
+            if (normalized === "inprogress" || normalized === "running" || normalized === "working") {
+                return "in_progress";
+            }
+            if (normalized === "todo" || normalized === "not_started" || normalized === "pending") {
+                return "planned";
+            }
+            if (normalized === "blocked" || normalized === "stuck") {
+                return "at_risk";
+            }
+            return null;
+        };
+        const operations = [];
+        const normalizedTaskUpdates = [];
+        const normalizedMilestoneUpdates = [];
+        for (const update of input.taskUpdates) {
+            const taskId = (update?.task_id ?? "").trim();
+            const status = normalizeTaskStatus(update?.status ?? "");
+            if (!taskId || !status)
+                continue;
+            normalizedTaskUpdates.push({
+                taskId,
+                status,
+                reason: typeof update?.reason === "string" && update.reason.trim().length > 0 ? update.reason.trim() : null,
+            });
+            operations.push({ op: "task.update", task_id: taskId, status });
+        }
+        for (const update of input.milestoneUpdates) {
+            const milestoneId = (update?.milestone_id ?? "").trim();
+            const status = normalizeMilestoneStatus(update?.status ?? "");
+            if (!milestoneId || !status)
+                continue;
+            normalizedMilestoneUpdates.push({
+                milestoneId,
+                status,
+                reason: typeof update?.reason === "string" && update.reason.trim().length > 0
+                    ? update.reason.trim()
+                    : null,
+            });
+            operations.push({ op: "milestone.update", milestone_id: milestoneId, status });
+        }
+        if (operations.length === 0) {
+            return {
+                applied: 0,
+                buffered: false,
+                taskUpdates: [],
+                milestoneUpdates: [],
+            };
+        }
+        const normalizedAgentId = typeof input.agentId === "string" && input.agentId.trim().length > 0
+            ? input.agentId.trim()
+            : null;
+        const normalizedAgentName = typeof input.agentName === "string" && input.agentName.trim().length > 0
+            ? input.agentName.trim()
+            : null;
+        const runIdForApply = input.runId?.trim() ?? "";
+        const correlationIdForApply = input.correlationId?.trim() ?? "";
+        const applyPayloadBase = {
+            initiative_id: input.initiativeId,
+            source_client: "openclaw",
+            idempotency_key: deps.idempotencyKey([
+                "openclaw",
+                "autopilot",
+                "slice_status",
+                input.initiativeId,
+                input.correlationId,
+            ]),
+            operations: operations,
+        };
+        try {
+            await deps.client.applyChangeset({
+                ...applyPayloadBase,
+                run_id: runIdForApply || undefined,
+                correlation_id: correlationIdForApply || undefined,
+            });
+            return {
+                applied: operations.length,
+                buffered: false,
+                taskUpdates: normalizedTaskUpdates,
+                milestoneUpdates: normalizedMilestoneUpdates,
+            };
+        }
+        catch (err) {
+            const errMsg = deps.safeErrorMessage(err);
+            // Common local-path case: run_id is only known locally. Retry with
+            // correlation_id-only semantics so OrgX can attach deterministically.
+            if (runIdForApply &&
+                /^404\b/.test(errMsg) &&
+                /\brun\b/i.test(errMsg) &&
+                /not found/i.test(errMsg)) {
+                try {
+                    await deps.client.applyChangeset({
+                        ...applyPayloadBase,
+                        run_id: undefined,
+                        correlation_id: correlationIdForApply || `openclaw_run_${runIdForApply.replace(/-/g, "").slice(0, 24)}`,
+                    });
+                    return {
+                        applied: operations.length,
+                        buffered: false,
+                        taskUpdates: normalizedTaskUpdates,
+                        milestoneUpdates: normalizedMilestoneUpdates,
+                    };
+                }
+                catch {
+                    // Fall through to local outbox buffering.
+                }
+            }
+            const timestamp = new Date().toISOString();
+            try {
+                await appendToOutbox(input.initiativeId, {
+                    id: deps.randomUUID(),
+                    type: "changeset",
+                    timestamp,
+                    payload: {
+                        initiative_id: input.initiativeId,
+                        correlation_id: input.correlationId,
+                        source_client: "openclaw",
+                        idempotency_key: deps.idempotencyKey([
+                            "openclaw",
+                            "autopilot",
+                            "slice_status",
+                            input.initiativeId,
+                            input.correlationId,
+                            "outbox",
+                        ]),
+                        operations,
+                    },
+                    activityItem: {
+                        id: deps.randomUUID(),
+                        type: "run_started",
+                        title: `Buffered status updates for slice ${input.runId}`,
+                        description: null,
+                        agentId: normalizedAgentId,
+                        agentName: normalizedAgentName,
+                        requesterAgentId: normalizedAgentId,
+                        requesterAgentName: normalizedAgentName,
+                        executorAgentId: normalizedAgentId,
+                        executorAgentName: normalizedAgentName,
+                        runId: input.runId,
+                        initiativeId: input.initiativeId,
+                        timestamp,
+                        phase: "review",
+                        summary: `Will apply ${operations.length} status update(s) when connected.`,
+                        metadata: {
+                            source: "openclaw_local_fallback",
+                            event: "autopilot_slice_status_updates_buffered",
+                            error: errMsg,
+                            run_id: input.runId,
+                            correlation_id: input.correlationId,
+                            output_path: typeof input.outputPath === "string" && input.outputPath.trim().length > 0
+                                ? input.outputPath.trim()
+                                : null,
+                            log_path: typeof input.logPath === "string" && input.logPath.trim().length > 0
+                                ? input.logPath.trim()
+                                : null,
+                            task_update_count: normalizedTaskUpdates.length,
+                            milestone_update_count: normalizedMilestoneUpdates.length,
+                            task_updates: normalizedTaskUpdates.map((entry) => ({
+                                task_id: entry.taskId,
+                                status: entry.status,
+                                reason: entry.reason,
+                            })),
+                            milestone_updates: normalizedMilestoneUpdates.map((entry) => ({
+                                milestone_id: entry.milestoneId,
+                                status: entry.status,
+                                reason: entry.reason,
+                            })),
+                            ...(normalizedAgentId ? { agent_id: normalizedAgentId } : {}),
+                            ...(normalizedAgentName ? { agent_name: normalizedAgentName } : {}),
+                            ...(input.isMockWorker ? { mock: true } : {}),
+                        },
+                    },
+                });
+            }
+            catch {
+                // best effort
+            }
+            return {
+                applied: operations.length,
+                buffered: true,
+                taskUpdates: normalizedTaskUpdates,
+                milestoneUpdates: normalizedMilestoneUpdates,
+            };
+        }
+    }
+    async function resolveAgentDisplayName(agentId, fallbackName) {
+        const normalizedAgentId = agentId.trim();
+        if (!normalizedAgentId)
+            return null;
+        const normalizedFallback = typeof fallbackName === "string" && fallbackName.trim().length > 0
+            ? fallbackName.trim()
+            : null;
+        return normalizedFallback ?? normalizedAgentId;
+    }
+    async function dispatchFallbackWorkstreamTurn(input) {
+        const now = new Date().toISOString();
+        const sessionId = deps.randomUUID();
+        const taskId = input.taskId?.trim() || null;
+        const taskTitle = input.taskTitle?.trim() || null;
+        const policyResolution = await deps.resolveDispatchExecutionPolicy({
+            initiativeId: input.initiativeId,
+            initiativeTitle: input.initiativeTitle,
+            workstreamId: input.workstreamId,
+            workstreamTitle: input.workstreamTitle,
+            taskId,
+            taskTitle,
+            message: "Continue this workstream from the latest context. Identify and execute the next concrete task.",
+        });
+        const executionPolicy = policyResolution.executionPolicy;
+        const resolvedWorkstreamTitle = policyResolution.workstreamTitle ?? input.workstreamTitle;
+        const resolvedTaskTitle = policyResolution.taskTitle ?? taskTitle;
+        const guard = await deps.enforceSpawnGuardForDispatch({
+            sourceEventPrefix: "next_up_fallback",
+            initiativeId: input.initiativeId,
+            correlationId: sessionId,
+            runId: sessionId,
+            executionPolicy,
+            agentId: input.agentId,
+            taskId,
+            taskTitle: resolvedTaskTitle,
+            workstreamId: input.workstreamId,
+            workstreamTitle: resolvedWorkstreamTitle,
+        });
+        if (!guard.allowed) {
+            return {
+                sessionId: null,
+                pid: null,
+                blockedReason: guard.blockedReason,
+                retryable: guard.retryable,
+                executionPolicy,
+                spawnGuardResult: guard.spawnGuardResult,
+            };
+        }
+        const baseMessage = [
+            `Initiative: ${input.initiativeTitle}`,
+            `Workstream: ${resolvedWorkstreamTitle}`,
+            taskId ? `Task: ${resolvedTaskTitle ?? taskId}` : null,
+            "",
+            "Continue this workstream from the latest context.",
+            "Identify and execute the next concrete task, then provide a concise progress summary.",
+        ]
+            .filter((line) => Boolean(line))
+            .join("\n");
+        const message = deps.buildPolicyEnforcedMessage({
+            baseMessage,
+            executionPolicy,
+            spawnGuardResult: guard.spawnGuardResult,
+        });
+        if (taskId) {
+            try {
+                await deps.client.updateEntity("task", taskId, { status: "in_progress" });
+            }
+            catch {
+                // best effort
+            }
+            try {
+                await deps.syncParentRollupsForTask({
+                    initiativeId: input.initiativeId,
+                    taskId,
+                    workstreamId: input.workstreamId,
+                    correlationId: sessionId,
+                });
+            }
+            catch {
+                // best effort
+            }
+        }
+        await deps.emitActivitySafe({
+            initiativeId: input.initiativeId,
+            runId: sessionId,
+            correlationId: sessionId,
+            phase: "execution",
+            level: "info",
+            message: `Next Up dispatched ${resolvedWorkstreamTitle}.`,
+            metadata: {
+                event: "next_up_manual_dispatch_started",
+                agent_id: input.agentId,
+                agent_name: input.agentName ?? input.agentId,
+                requested_by_agent_id: input.agentId,
+                requested_by_agent_name: input.agentName ?? input.agentId,
+                session_id: sessionId,
+                workstream_id: input.workstreamId,
+                workstream_title: resolvedWorkstreamTitle,
+                task_id: taskId,
+                task_title: resolvedTaskTitle,
+                domain: executionPolicy.domain,
+                required_skills: executionPolicy.requiredSkills,
+                spawn_guard_model_tier: deps.extractSpawnGuardModelTier(guard.spawnGuardResult),
+                fallback: true,
+            },
+        });
+        deps.upsertAgentContext({
+            agentId: input.agentId,
+            initiativeId: input.initiativeId,
+            initiativeTitle: input.initiativeTitle,
+            workstreamId: input.workstreamId,
+            taskId,
+        });
+        deps.upsertRunContext({
+            runId: sessionId,
+            agentId: input.agentId,
+            initiativeId: input.initiativeId,
+            initiativeTitle: input.initiativeTitle,
+            workstreamId: input.workstreamId,
+            taskId,
+        });
+        const spawned = deps.spawnAgentTurn({
+            agentId: input.agentId,
+            sessionId,
+            message,
+        });
+        deps.upsertAgentRun({
+            runId: sessionId,
+            agentId: input.agentId,
+            pid: spawned.pid,
+            message,
+            provider: null,
+            model: null,
+            initiativeId: input.initiativeId,
+            initiativeTitle: input.initiativeTitle,
+            workstreamId: input.workstreamId,
+            taskId,
+            startedAt: now,
+            status: "running",
+        });
+        return {
+            sessionId,
+            pid: spawned.pid,
+            blockedReason: null,
+            retryable: false,
+            executionPolicy,
+            spawnGuardResult: guard.spawnGuardResult,
+        };
+    }
+    return {
+        registerArtifactSafe,
+        applyAgentStatusUpdatesSafe,
+        resolveAgentDisplayName,
+        dispatchFallbackWorkstreamTurn,
+    };
+}

package/dist/http/helpers/autopilot-runtime.d.ts

@@ -0,0 +1,43 @@
+import { type ChildProcess } from "node:child_process";
+import type { RuntimeHookPayload, RuntimeInstanceRecord } from "../../runtime-instance-store.js";
+import type { RuntimeSourceClient } from "../../runtime-instance-store.js";
+import type { CodexBinInfo } from "./autopilot-slice-utils.js";
+type CreateAutopilotRuntimeDeps = {
+    filename: string;
+    autoContinueSliceChildren: Map<string, ChildProcess>;
+    resolveByokEnvOverrides: () => Record<string, string | undefined>;
+    safeErrorMessage: (err: unknown) => string;
+    resolveCodexBinInfo: () => CodexBinInfo;
+    upsertRuntimeInstanceFromHook: (payload: RuntimeHookPayload) => RuntimeInstanceRecord;
+    broadcastRuntimeSse: (event: string, payload: RuntimeInstanceRecord) => void;
+    clearSnapshotResponseCache: () => void;
+};
+export declare function createAutopilotRuntime(deps: CreateAutopilotRuntimeDeps): {
+    spawnCodexSliceWorker: (input: {
+        runId: string;
+        prompt: string;
+        cwd: string;
+        logPath: string;
+        outputPath: string;
+        outputSchemaPath?: string;
+        env: Record<string, string | undefined>;
+    }) => {
+        pid: number | null;
+    };
+    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;
+};
+export {};