@ryanfw/prompt-orchestration-pipeline 0.10.0 → 0.12.0

package/src/core/status-initializer.js

@@ -0,0 +1,155 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+/**
+ * Initialize status snapshot from artifacts in the filesystem
+ * @param {Object} options - Options object
+ * @param {string} options.jobDir - Job directory path
+ * @param {Object} options.pipeline - Pipeline configuration object
+ * @returns {Promise<Function>} Function that applies artifact initialization to a snapshot
+ */
+export async function initializeStatusFromArtifacts({ jobDir, pipeline }) {
+  if (!jobDir || typeof jobDir !== "string") {
+    throw new Error("jobDir must be a non-empty string");
+  }
+
+  if (!pipeline || typeof pipeline !== "object") {
+    throw new Error("pipeline must be an object");
+  }
+
+  const artifactsDir = path.join(jobDir, "files", "artifacts");
+  let artifactFilenames = [];
+
+  try {
+    // Read artifacts directory
+    const entries = await fs.readdir(artifactsDir, { withFileTypes: true });
+
+    // Collect filenames for regular files only
+    artifactFilenames = entries
+      .filter((entry) => entry.isFile())
+      .map((entry) => entry.name);
+
+    console.log("[STATUS_INIT] Found artifacts in directory", {
+      artifactsDir,
+      artifactCount: artifactFilenames.length,
+      artifactNames: artifactFilenames,
+    });
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      // Directory doesn't exist, no artifacts to initialize
+      console.log(
+        "[STATUS_INIT] Artifacts directory does not exist, skipping initialization",
+        {
+          artifactsDir,
+        }
+      );
+    } else {
+      console.error("[STATUS_INIT] Failed to read artifacts directory", {
+        artifactsDir,
+        error: error.message,
+      });
+    }
+    // Return a no-op function for non-existent or unreadable directory
+    return (snapshot) => snapshot;
+  }
+
+  // Determine first task ID from pipeline
+  const firstTaskId = Array.isArray(pipeline.tasks) ? pipeline.tasks[0] : null;
+  console.log("[STATUS_INIT] Determined first task", {
+    firstTaskId,
+    hasTasks: Array.isArray(pipeline.tasks),
+    taskCount: pipeline.tasks?.length || 0,
+  });
+
+  // Return function that applies the artifact initialization to a snapshot
+  return function apply(snapshot) {
+    console.log("[STATUS_INIT] Applying artifact initialization to snapshot", {
+      existingArtifacts: snapshot.files?.artifacts?.length || 0,
+      newArtifacts: artifactFilenames.length,
+      firstTaskId,
+    });
+
+    // Ensure files object exists with proper structure
+    if (!snapshot.files || typeof snapshot.files !== "object") {
+      snapshot.files = { artifacts: [], logs: [], tmp: [] };
+    } else {
+      // Ensure each files array exists
+      for (const type of ["artifacts", "logs", "tmp"]) {
+        if (!Array.isArray(snapshot.files[type])) {
+          snapshot.files[type] = [];
+        }
+      }
+    }
+
+    // Add artifact filenames to root level (deduplicate)
+    const existingArtifacts = new Set(snapshot.files.artifacts || []);
+    for (const filename of artifactFilenames) {
+      if (!existingArtifacts.has(filename)) {
+        snapshot.files.artifacts.push(filename);
+        existingArtifacts.add(filename);
+      }
+    }
+
+    // Add artifact filenames to first task (if it exists)
+    if (firstTaskId) {
+      // Ensure tasks object exists
+      if (!snapshot.tasks || typeof snapshot.tasks !== "object") {
+        snapshot.tasks = {};
+      }
+
+      // Ensure first task exists
+      if (!snapshot.tasks[firstTaskId]) {
+        snapshot.tasks[firstTaskId] = {};
+      }
+
+      // Ensure task files object exists with proper structure
+      if (
+        !snapshot.tasks[firstTaskId].files ||
+        typeof snapshot.tasks[firstTaskId].files !== "object"
+      ) {
+        snapshot.tasks[firstTaskId].files = {
+          artifacts: [],
+          logs: [],
+          tmp: [],
+        };
+      } else {
+        // Ensure each task files array exists
+        for (const type of ["artifacts", "logs", "tmp"]) {
+          if (!Array.isArray(snapshot.tasks[firstTaskId].files[type])) {
+            snapshot.tasks[firstTaskId].files[type] = [];
+          }
+        }
+      }
+
+      // Add artifact filenames to first task (deduplicate)
+      const existingTaskArtifacts = new Set(
+        snapshot.tasks[firstTaskId].files.artifacts || []
+      );
+      for (const filename of artifactFilenames) {
+        if (!existingTaskArtifacts.has(filename)) {
+          snapshot.tasks[firstTaskId].files.artifacts.push(filename);
+          existingTaskArtifacts.add(filename);
+        }
+      }
+
+      console.log("[STATUS_INIT] Added artifacts to first task", {
+        firstTaskId,
+        taskArtifactCount: snapshot.tasks[firstTaskId].files.artifacts.length,
+        artifactNames: artifactFilenames,
+      });
+    }
+
+    console.log("[STATUS_INIT] Final snapshot state", {
+      rootArtifacts: snapshot.files.artifacts.length,
+      rootArtifactNames: snapshot.files.artifacts,
+      firstTaskArtifacts: firstTaskId
+        ? snapshot.tasks[firstTaskId].files.artifacts.length
+        : 0,
+      firstTaskArtifactNames: firstTaskId
+        ? snapshot.tasks[firstTaskId].files.artifacts
+        : [],
+    });
+
+    return snapshot;
+  };
+}

package/src/core/status-writer.js

@@ -208,6 +208,26 @@ export async function writeJobStatus(jobDir, updateFn) {
         logger.error("Failed to emit SSE event:", error);
       }
 
+      // Emit lifecycle_block event if update contains lifecycle block reason
+      if (snapshot.lifecycleBlockReason) {
+        try {
+          const lifecycleEventData = {
+            jobId,
+            taskId: snapshot.lifecycleBlockTaskId,
+            op: snapshot.lifecycleBlockOp,
+            reason: snapshot.lifecycleBlockReason,
+          };
+          await logger.sse("lifecycle_block", lifecycleEventData);
+          logger.log(
+            "lifecycle_block SSE event broadcasted successfully",
+            lifecycleEventData
+          );
+        } catch (error) {
+          // Don't fail the write if SSE emission fails
+          logger.error("Failed to emit lifecycle_block SSE event:", error);
+        }
+      }
+
       logger.groupEnd();
       resultSnapshot = snapshot;
     })
@@ -281,22 +301,71 @@ export async function updateTaskStatus(jobDir, taskId, taskUpdateFn) {
     throw new Error("taskUpdateFn must be a function");
   }
 
-  return writeJobStatus(jobDir, (snapshot) => {
-    // Ensure task exists
-    if (!snapshot.tasks[taskId]) {
-      snapshot.tasks[taskId] = {};
-    }
+  const jobId = path.basename(jobDir);
+  const logger = createJobLogger("StatusWriter", jobId);
 
-    const task = snapshot.tasks[taskId];
+  // Get or create the write queue for this job directory
+  const prev = writeQueues.get(jobDir) || Promise.resolve();
+  let resultSnapshot;
 
-    // Apply task updates
-    const result = taskUpdateFn(task);
-    if (result !== undefined) {
-      snapshot.tasks[taskId] = result;
-    }
+  const next = prev
+    .then(async () => {
+      logger.group("Task Status Update Operation");
+      logger.log(`Updating task ${taskId} for job: ${jobId}`);
 
-    return snapshot;
-  });
+      const statusPath = path.join(jobDir, "tasks-status.json");
+
+      // Read existing status or create default
+      const current = await readStatusFile(statusPath, jobId);
+      const validated = validateStatusSnapshot(current);
+
+      // Ensure task exists
+      if (!validated.tasks[taskId]) {
+        validated.tasks[taskId] = {};
+      }
+
+      const task = validated.tasks[taskId];
+
+      // Apply task updates
+      const result = taskUpdateFn(task);
+      if (result !== undefined) {
+        validated.tasks[taskId] = result;
+      }
+
+      validated.lastUpdated = new Date().toISOString();
+
+      // Atomic write
+      await atomicWrite(statusPath, validated);
+      logger.log("Task status file written successfully");
+
+      // Emit task:updated SSE event after successful write
+      try {
+        const eventData = {
+          jobId,
+          taskId,
+          task: validated.tasks[taskId],
+        };
+        await logger.sse("task:updated", eventData);
+        logger.log("task:updated SSE event broadcasted successfully");
+      } catch (error) {
+        // Don't fail the write if SSE emission fails
+        logger.error("Failed to emit task:updated SSE event:", error);
+      }
+
+      logger.groupEnd();
+      resultSnapshot = validated;
+    })
+    .catch((e) => {
+      throw e;
+    });
+
+  // Store the promise chain and set up cleanup
+  writeQueues.set(
+    jobDir,
+    next.finally(() => {})
+  );
+
+  return next.then(() => resultSnapshot);
 }
 
 /**
@@ -435,3 +504,156 @@ export async function resetJobToCleanSlate(
     return snapshot;
   });
 }
+
+/**
+ * Reset a single task to pending state without affecting other tasks
+ *
+ * @param {string} jobDir - Job directory path containing tasks-status.json
+ * @param {string} taskId - Task identifier to reset
+ * @param {Object} options - Reset options
+ * @param {boolean} [options.clearTokenUsage=true] - Whether to clear token usage arrays
+ * @returns {Promise<Object>} The updated status snapshot
+ */
+export async function resetSingleTask(
+  jobDir,
+  taskId,
+  { clearTokenUsage = true } = {}
+) {
+  if (!jobDir || typeof jobDir !== "string") {
+    throw new Error("jobDir must be a non-empty string");
+  }
+
+  if (!taskId || typeof taskId !== "string") {
+    throw new Error("taskId must be a non-empty string");
+  }
+
+  return writeJobStatus(jobDir, (snapshot) => {
+    // Ensure tasks object exists
+    if (!snapshot.tasks || typeof snapshot.tasks !== "object") {
+      snapshot.tasks = {};
+    }
+
+    // Ensure the target task exists
+    if (!snapshot.tasks[taskId]) {
+      snapshot.tasks[taskId] = {};
+    }
+
+    const task = snapshot.tasks[taskId];
+
+    // Reset only the target task state and metadata
+    task.state = TaskState.PENDING;
+    task.currentStage = null;
+
+    // Remove error-related fields
+    delete task.failedStage;
+    delete task.error;
+
+    // Reset counters
+    task.attempts = 0;
+    task.refinementAttempts = 0;
+
+    // Clear token usage if requested
+    if (clearTokenUsage) {
+      task.tokenUsage = [];
+    }
+
+    // Update lastUpdated timestamp
+    snapshot.lastUpdated = new Date().toISOString();
+
+    // Do not modify:
+    // - Any other tasks within snapshot.tasks
+    // - snapshot.files.artifacts|logs|tmp
+    // - Root-level fields other than lastUpdated
+
+    return snapshot;
+  });
+}
+
+/**
+ * Consolidated path jail security validation with generic error messages
+ * @param {string} filename - Filename to validate
+ * @returns {Object|null} Validation result or null if valid
+ */
+function validateFilePath(filename) {
+  // Check for path traversal patterns
+  if (filename.includes("..")) {
+    console.error("Path security: path traversal detected", { filename });
+    return {
+      allowed: false,
+      message: "Path validation failed",
+    };
+  }
+
+  // Check for absolute paths (POSIX, Windows, backslashes, ~)
+  if (
+    path.isAbsolute(filename) ||
+    /^[a-zA-Z]:/.test(filename) ||
+    filename.includes("\\") ||
+    filename.startsWith("~")
+  ) {
+    console.error("Path security: absolute path detected", { filename });
+    return {
+      allowed: false,
+      message: "Path validation failed",
+    };
+  }
+
+  // Check for empty filename
+  if (!filename || filename.trim() === "") {
+    console.error("Path security: empty filename detected");
+    return {
+      allowed: false,
+      message: "Path validation failed",
+    };
+  }
+
+  // Path is valid
+  return null;
+}
+
+/**
+ * Initialize job-level artifact index and copy artifacts to job directory
+ * @param {string} jobDir - Job directory path
+ * @param {Array} uploadArtifacts - Array of {filename, content} objects
+ * @returns {Promise<void>}
+ */
+export async function initializeJobArtifacts(jobDir, uploadArtifacts = []) {
+  if (!jobDir || typeof jobDir !== "string") {
+    throw new Error("jobDir must be a non-empty string");
+  }
+
+  if (!Array.isArray(uploadArtifacts)) {
+    throw new Error("uploadArtifacts must be an array");
+  }
+
+  if (uploadArtifacts.length === 0) {
+    return;
+  }
+
+  const jobFilesDir = path.join(jobDir, "files");
+  const jobArtifactsDir = path.join(jobFilesDir, "artifacts");
+
+  await fs.mkdir(jobFilesDir, { recursive: true });
+  await fs.mkdir(jobArtifactsDir, { recursive: true });
+
+  for (const artifact of uploadArtifacts) {
+    const { filename, content } = artifact || {};
+
+    if (!filename || typeof filename !== "string") {
+      continue; // Skip invalid entries rather than throwing
+    }
+
+    // Validate filename using the consolidated function
+    const validation = validateFilePath(filename);
+    if (validation) {
+      console.error("Path security: skipping invalid artifact", {
+        filename,
+        reason: validation.message,
+      });
+      continue; // Skip invalid filenames rather than throwing
+    }
+
+    const artifactPath = path.join(jobArtifactsDir, filename);
+    await fs.writeFile(artifactPath, content);
+  }
+}

package/src/pages/Code.jsx

@@ -86,7 +86,14 @@ export default function CodePage() {
   useEffect(() => {
     fetch("/api/llm/functions")
       .then((res) => res.json())
-      .then(setLlmFunctions)
+      .then(({ ok, data }) => {
+        if (!ok || typeof data !== "object" || data === null) {
+          throw new Error(
+            "Invalid /api/llm/functions response: expected { ok:true, data:Object }"
+          );
+        }
+        setLlmFunctions(data);
+      })
       .catch(console.error);
   }, []);
 

package/src/pages/PipelineDetail.jsx

@@ -1,6 +1,6 @@
-import React from "react";
+import React, { useState } from "react";
 import { data, useParams } from "react-router-dom";
-import { Box, Flex, Text } from "@radix-ui/themes";
+import { Box, Flex, Text, Button } from "@radix-ui/themes";
 import * as Tooltip from "@radix-ui/react-tooltip";
 import JobDetail from "../components/JobDetail.jsx";
 import { useJobDetailWithUpdates } from "../ui/client/hooks/useJobDetailWithUpdates.js";
@@ -8,9 +8,15 @@ import Layout from "../components/Layout.jsx";
 import PageSubheader from "../components/PageSubheader.jsx";
 import { statusBadge } from "../utils/ui.jsx";
 import { formatCurrency4, formatTokensCompact } from "../utils/formatters.js";
+import { rescanJob } from "../ui/client/api.js";
+import StopJobModal from "../components/ui/StopJobModal.jsx";
+import { stopJob } from "../ui/client/api.js";
 
 export default function PipelineDetail() {
   const { jobId } = useParams();
+  const [isRescanning, setIsRescanning] = useState(false);
+  const [isStopModalOpen, setIsStopModalOpen] = useState(false);
+  const [isStopping, setIsStopping] = useState(false);
 
   // Handle missing job ID (undefined/null)
   if (jobId === undefined || jobId === null) {
@@ -143,6 +149,12 @@ export default function PipelineDetail() {
     ...(job.name ? [{ label: job.name }] : []),
   ];
 
+  // Determine if job is currently running
+  const isRunning =
+    job?.status === "running" ||
+    (job?.tasks &&
+      Object.values(job.tasks).some((task) => task?.state === "running"));
+
   // Derive cost data from job object with safe fallbacks
   const totalCost = job?.totalCost || job?.costs?.summary?.totalCost || 0;
   const totalTokens = job?.totalTokens || job?.costs?.summary?.totalTokens || 0;
@@ -193,13 +205,75 @@ export default function PipelineDetail() {
       costIndicator
     );
 
-  // Right side content for PageSubheader: job ID, cost indicator, and status badge
+  const handleRescan = async () => {
+    setIsRescanning(true);
+    try {
+      const result = await rescanJob(jobId);
+      if (result.ok) {
+        const addedCount = result.added ? result.added.length : 0;
+        const removedCount = result.removed ? result.removed.length : 0;
+        let message = "Rescan complete.";
+        if (addedCount > 0 && removedCount > 0) {
+          message += ` Added ${addedCount} task${addedCount > 1 ? "s" : ""}: ${JSON.stringify(result.added)}. Removed ${removedCount} task${removedCount > 1 ? "s" : ""}: ${JSON.stringify(result.removed)}.`;
+        } else if (addedCount > 0) {
+          message += ` Added ${addedCount} task${addedCount > 1 ? "s" : ""}: ${JSON.stringify(result.added)}.`;
+        } else if (removedCount > 0) {
+          message += ` Removed ${removedCount} task${removedCount > 1 ? "s" : ""}: ${JSON.stringify(result.removed)}.`;
+        } else {
+          message += " No changes found.";
+        }
+        console.log(message);
+      }
+    } catch (err) {
+      console.error("Rescan failed:", err);
+      alert("Rescan failed: " + err.message);
+    } finally {
+      setIsRescanning(false);
+    }
+  };
+
+  const openStopModal = () => setIsStopModalOpen(true);
+  const closeStopModal = () => setIsStopModalOpen(false);
+
+  const handleStopConfirm = async () => {
+    setIsStopping(true);
+    try {
+      await stopJob(jobId);
+      closeStopModal();
+    } catch (error) {
+      console.warn("Failed to stop job:", error);
+      closeStopModal();
+    } finally {
+      setIsStopping(false);
+    }
+  };
+
+  // Right side content for PageSubheader: job ID, cost indicator, status badge, and Stop control
   const subheaderRightContent = (
     <Flex align="center" gap="3" className="shrink-0 flex-wrap">
       <Text size="2" color="gray">
         ID: {job.id || jobId}
       </Text>
       {costIndicatorWithTooltip}
+      {isRunning && (
+        <Button
+          size="1"
+          variant="solid"
+          color="red"
+          disabled={isStopping}
+          onClick={openStopModal}
+        >
+          {isStopping ? "Stopping..." : "Stop"}
+        </Button>
+      )}
+      <Button
+        size="1"
+        variant="soft"
+        disabled={isRescanning}
+        onClick={handleRescan}
+      >
+        {isRescanning ? "Rescanning..." : "Rescan"}
+      </Button>
       {statusBadge(job.status)}
     </Flex>
   );
@@ -215,6 +289,14 @@ export default function PipelineDetail() {
         )}
       </PageSubheader>
       <JobDetail job={job} pipeline={pipeline} />
+      <StopJobModal
+        isOpen={isStopModalOpen}
+        onClose={closeStopModal}
+        onConfirm={handleStopConfirm}
+        runningJobs={[{ id: job.id, name: job.name, progress: job.progress }]}
+        defaultJobId={job.id}
+        isSubmitting={isStopping}
+      />
     </Layout>
   );
 }

package/src/pages/PromptPipelineDashboard.jsx

@@ -7,24 +7,23 @@ import { Box, Flex, Text, Tabs } from "@radix-ui/themes";
 import { Progress } from "../components/ui/progress";
 import { useJobListWithUpdates } from "../ui/client/hooks/useJobListWithUpdates";
 import { adaptJobSummary } from "../ui/client/adapters/job-adapter";
-import { TaskState, JobStatus } from "../config/statuses.js";
 
 // Referenced components — leave these alone
 import JobTable from "../components/JobTable";
 import Layout from "../components/Layout.jsx";
 
-export default function PromptPipelineDashboard({ isConnected }) {
+export default function PromptPipelineDashboard() {
   const navigate = useNavigate();
   const hookResult = useJobListWithUpdates();
 
   if (
+    /* eslint-disable-next-line no-undef */
     process.env.NODE_ENV === "test" &&
     (hookResult === undefined ||
       hookResult === null ||
       typeof hookResult !== "object" ||
       Array.isArray(hookResult))
   ) {
-    // eslint-disable-next-line no-console
     console.error(
       "[PromptPipelineDashboard] useJobListWithUpdates returned unexpected value",
       {
@@ -39,7 +38,7 @@ export default function PromptPipelineDashboard({ isConnected }) {
     );
   }
 
-  const { data: apiJobs, loading, error, connectionStatus } = hookResult;
+  const { data: apiJobs, error } = hookResult;
 
   const jobs = useMemo(() => {
     const src = Array.isArray(apiJobs) ? apiJobs : [];
@@ -57,26 +56,26 @@ export default function PromptPipelineDashboard({ isConnected }) {
   // Shared ticker for live duration updates - removed useTicker
 
   const errorCount = useMemo(
-    () => jobs.filter((j) => j.status === TaskState.FAILED).length,
+    () => jobs.filter((j) => j.displayCategory === "errors").length,
     [jobs]
   );
   const currentCount = useMemo(
-    () => jobs.filter((j) => j.status === TaskState.RUNNING).length,
+    () => jobs.filter((j) => j.displayCategory === "current").length,
     [jobs]
   );
   const completedCount = useMemo(
-    () => jobs.filter((j) => j.status === JobStatus.COMPLETE).length,
+    () => jobs.filter((j) => j.displayCategory === "complete").length,
     [jobs]
   );
 
   const filteredJobs = useMemo(() => {
     switch (activeTab) {
       case "current":
-        return jobs.filter((j) => j.status === TaskState.RUNNING);
+        return jobs.filter((j) => j.displayCategory === "current");
       case "errors":
-        return jobs.filter((j) => j.status === TaskState.FAILED);
+        return jobs.filter((j) => j.displayCategory === "errors");
       case "complete":
-        return jobs.filter((j) => j.status === JobStatus.COMPLETE);
+        return jobs.filter((j) => j.displayCategory === "complete");
       default:
         return [];
     }
@@ -86,7 +85,7 @@ export default function PromptPipelineDashboard({ isConnected }) {
 
   // Aggregate progress for currently running jobs (for a subtle top progress bar)
   const runningJobs = useMemo(
-    () => jobs.filter((j) => j.status === TaskState.RUNNING),
+    () => jobs.filter((j) => j.displayCategory === "current"),
     [jobs]
   );
   const aggregateProgress = useMemo(() => {