@ryanfw/prompt-orchestration-pipeline 1.3.0 → 1.3.2

package/src/ui/server/endpoints/__tests__/upload-endpoints.test.ts

@@ -99,4 +99,81 @@ describe("handleSeedUploadDirect", () => {
       await rm(dataDir, { recursive: true, force: true });
     }
   });
+
+  it("AC-12: unsafe artifact path returns 400 and does not create the escape target", async () => {
+    const dataDir = await mkdtemp(path.join(tmpdir(), "upload-unsafe-"));
+    try {
+      const seedObject = { name: "demo", pipeline: "x" };
+      const response = await handleSeedUploadDirect(seedObject, dataDir, [
+        { filename: "../../../../tmp/PWNED.txt", content: new TextEncoder().encode("pwned") },
+      ]);
+      expect(response.status).toBe(400);
+
+      const escapeTarget = "/tmp/PWNED.txt";
+      expect(await pathExists(escapeTarget)).toBe(false);
+    } finally {
+      await rm(dataDir, { recursive: true, force: true });
+    }
+  });
+
+  it("AC-13: mixed safe and unsafe paths return 400 with no partial writes", async () => {
+    const dataDir = await mkdtemp(path.join(tmpdir(), "upload-mixed-"));
+    try {
+      const seedObject = { name: "demo", pipeline: "x" };
+      const artifacts = [
+        { filename: "safe.md", content: new TextEncoder().encode("safe") },
+        { filename: "../../tmp/escape.txt", content: new TextEncoder().encode("escape") },
+      ];
+
+      const response = await handleSeedUploadDirect(seedObject, dataDir, artifacts);
+      expect(response.status).toBe(400);
+
+      const stagingRoot = path.join(dataDir, "pipeline-data", "staging");
+      expect(await pathExists(stagingRoot)).toBe(false);
+    } finally {
+      await rm(dataDir, { recursive: true, force: true });
+    }
+  });
+
+  it("rejects root-normalizing artifact paths without partial writes", async () => {
+    const dataDir = await mkdtemp(path.join(tmpdir(), "upload-root-target-"));
+    try {
+      const seedObject = { name: "demo", pipeline: "x" };
+      const artifacts = [
+        { filename: "safe.md", content: new TextEncoder().encode("safe") },
+        { filename: "dir/..", content: new TextEncoder().encode("root") },
+      ];
+
+      const response = await handleSeedUploadDirect(seedObject, dataDir, artifacts);
+      expect(response.status).toBe(400);
+
+      const stagingRoot = path.join(dataDir, "pipeline-data", "staging");
+      expect(await pathExists(stagingRoot)).toBe(false);
+    } finally {
+      await rm(dataDir, { recursive: true, force: true });
+    }
+  });
+
+  it("AC-14: all-safe artifact paths with nesting return 201 and files present", async () => {
+    const dataDir = await mkdtemp(path.join(tmpdir(), "upload-safe-"));
+    try {
+      const seedObject = { name: "demo", pipeline: "x" };
+      const artifacts = [
+        { filename: "out.json", content: new TextEncoder().encode("{}") },
+        { filename: "data/foo.json", content: new TextEncoder().encode('{"a":1}') },
+      ];
+
+      const response = await handleSeedUploadDirect(seedObject, dataDir, artifacts);
+      expect(response.status).toBe(201);
+
+      const body = (await response.json()) as { data: { jobId: string } };
+      const jobId = body.data.jobId;
+      const stagingJobDir = path.join(dataDir, "pipeline-data", "staging", jobId);
+
+      expect(await pathExists(path.join(stagingJobDir, "out.json"))).toBe(true);
+      expect(await pathExists(path.join(stagingJobDir, "data/foo.json"))).toBe(true);
+    } finally {
+      await rm(dataDir, { recursive: true, force: true });
+    }
+  });
 });

package/src/ui/server/endpoints/gate-endpoints.ts

@@ -7,7 +7,8 @@ import { getJobDirectoryPath, getPipelineDataDir } from "../../../config/paths";
 import { getOrchestratorConfig } from "../../../core/config";
 import { releaseJobSlot } from "../../../core/job-concurrency";
 import { appendRunEvent } from "../../../core/run-events";
-import { readJobStatus, writeJobStatus } from "../../../core/status-writer";
+import { readJobStatus, writeJobStatus, StatusCorruptError } from "../../../core/status-writer";
+import { assertStatusParseable, statusCorruptResponse } from "../utils/status-corruption";
 import {
   acquireConcurrencySlot,
   isProcessAlive,
@@ -58,6 +59,13 @@ export async function handleGateDecision(
     return sendJson(404, createErrorResponse(Constants.ERROR_CODES.JOB_NOT_FOUND, `job "${jobId}" was not found`));
   }
 
+  try {
+    await assertStatusParseable(statusPath);
+  } catch (err) {
+    if (err instanceof StatusCorruptError) return statusCorruptResponse(err);
+    throw err;
+  }
+
   const snapshot = await readJobStatus(jobDir);
   if (!snapshot) {
     return sendJson(500, createErrorResponse("status_unavailable", `job "${jobId}" status could not be read`));
@@ -108,6 +116,14 @@ export async function handleGateDecision(
       slotAcquired = false;
     }
   } catch (error) {
+    if (error instanceof StatusCorruptError) {
+      if (slotAcquired) {
+        const orchestrator = getOrchestratorConfig();
+        await releaseJobSlot(getPipelineDataDir(dataDir), jobId, orchestrator.lockFileTimeout);
+        slotAcquired = false;
+      }
+      return statusCorruptResponse(error);
+    }
     if (slotAcquired) {
       const orchestrator = getOrchestratorConfig();
       await releaseJobSlot(getPipelineDataDir(dataDir), jobId, orchestrator.lockFileTimeout);

package/src/ui/server/endpoints/job-control-endpoints.ts

@@ -19,8 +19,10 @@ import {
   resetJobToCleanSlate,
   resetSingleTask,
   writeJobStatus,
+  StatusCorruptError,
   type StatusSnapshot,
 } from "../../../core/status-writer";
+import { assertKnownJobStatusesParseable, statusCorruptResponse } from "../utils/status-corruption";
 import {
   materializeNormalizedPipelineDefinition,
 } from "../../../core/pipeline-definition";
@@ -454,6 +456,18 @@ export async function resolveJobLifecycle(
   return null;
 }
 
+async function resolveJobLifecycleByStatusPresence(
+  dataDir: string,
+  jobId: string,
+): Promise<"current" | "complete" | null> {
+  for (const location of READ_LOCATIONS) {
+    const statusPath = path.join(dataDir, "pipeline-data", location, jobId, "tasks-status.json");
+    if (await Bun.file(statusPath).exists()) return location;
+  }
+
+  return null;
+}
+
 export function isRestartInProgress(jobId: string): boolean {
   return restartingJobs.has(jobId);
 }
@@ -500,6 +514,9 @@ export async function handleJobRestart(
   }
 
   try {
+    try { await assertKnownJobStatusesParseable(dataDir, jobId); }
+    catch (err) { if (err instanceof StatusCorruptError) return statusCorruptResponse(err); throw err; }
+
     // Parse optional request body
     let fromTask: string | undefined;
     let singleTask: boolean | undefined;
@@ -579,6 +596,12 @@ export async function handleJobRestart(
       });
       spawned = true;
     } catch (err) {
+      if (err instanceof StatusCorruptError) {
+        if (!spawned) {
+          await releaseJobSlot(getPipelineDataDir(dataDir), jobId, getOrchestratorRuntimeConfig().lockFileTimeout);
+        }
+        return statusCorruptResponse(err);
+      }
       if (!spawned) {
         await releaseJobSlot(getPipelineDataDir(dataDir), jobId, getOrchestratorRuntimeConfig().lockFileTimeout);
       }
@@ -601,7 +624,7 @@ export async function handleJobStop(
   }
 
   try {
-    const lifecycle = await resolveJobLifecycle(dataDir, jobId);
+    const lifecycle = await resolveJobLifecycleByStatusPresence(dataDir, jobId);
     if (!lifecycle) {
       return sendJson(404, createErrorResponse(Constants.ERROR_CODES.JOB_NOT_FOUND, `job "${jobId}" was not found`));
     }
@@ -624,10 +647,14 @@ export async function handleJobStop(
       await cleanupRunnerPid(jobDir);
     }
 
+    try { await assertKnownJobStatusesParseable(dataDir, jobId); }
+    catch (err) { if (err instanceof StatusCorruptError) return statusCorruptResponse(err); throw err; }
+
     let resetTask: string | null = null;
 
     // Reset running task and clear root-level fields in a single atomic write.
-    await writeJobStatus(jobDir, (snapshot) => {
+    try {
+      await writeJobStatus(jobDir, (snapshot) => {
       if (snapshot.current && snapshot.tasks[snapshot.current]?.state === "running") {
         resetTask = snapshot.current;
       } else {
@@ -667,6 +694,10 @@ export async function handleJobStop(
       snapshot.currentStage = null;
       snapshot.progress = getProgressPercent(snapshot);
     });
+    } catch (err) {
+      if (err instanceof StatusCorruptError) return statusCorruptResponse(err);
+      throw err;
+    }
 
     return sendJson(202, {
       ok: true,
@@ -703,6 +734,9 @@ export async function handleTaskStart(
   }
 
   try {
+    try { await assertKnownJobStatusesParseable(dataDir, jobId); }
+    catch (err) { if (err instanceof StatusCorruptError) return statusCorruptResponse(err); throw err; }
+
     const lifecycle = await resolveJobLifecycle(dataDir, jobId);
     if (!lifecycle) {
       return sendJson(404, createErrorResponse(Constants.ERROR_CODES.JOB_NOT_FOUND, `job "${jobId}" was not found`));

package/src/ui/server/endpoints/upload-endpoints.ts

@@ -3,6 +3,9 @@ import path from "node:path";
 
 import { parseMultipartFormData, sendJson } from "../utils/http-utils";
 import { extractSeedZip } from "../zip-utils";
+import { createErrorResponse } from "../config-bridge";
+import { Constants } from "../config-bridge-node";
+import { resolveWithin } from "../utils/path-containment";
 
 export interface SeedUploadResult {
   seedObject: Record<string, unknown>;
@@ -40,10 +43,17 @@ export async function handleSeedUploadDirect(
   // current/{jobId}/files/artifacts/ during promotion.
   if (artifacts.length > 0) {
     const stagingJobDir = path.join(pipelineData, "staging", jobId);
+
+    for (const artifact of artifacts) {
+      if (resolveWithin(stagingJobDir, artifact.filename) === null) {
+        return sendJson(400, createErrorResponse(Constants.ERROR_CODES.BAD_REQUEST, `unsafe artifact path: ${artifact.filename}`));
+      }
+    }
+
     for (const artifact of artifacts) {
-      const artifactPath = path.join(stagingJobDir, artifact.filename);
-      await mkdir(path.dirname(artifactPath), { recursive: true });
-      await Bun.write(artifactPath, artifact.content);
+      const resolved = resolveWithin(stagingJobDir, artifact.filename)!;
+      await mkdir(path.dirname(resolved), { recursive: true });
+      await Bun.write(resolved, artifact.content);
     }
   }
 

package/src/ui/server/utils/http-utils.ts

@@ -10,6 +10,11 @@ function badRequest(message: string): Error {
   return new Error(message);
 }
 
+function normalizeContentType(contentType: string): string {
+  const mediaType = contentType.split(";", 1)[0]?.trim();
+  return mediaType || "application/octet-stream";
+}
+
 export function sendJson(statusCode: number, data: unknown): Response {
   return new Response(JSON.stringify(data), {
     status: statusCode,
@@ -57,7 +62,7 @@ export async function parseMultipartFormData(
       } else {
         files.push({
           filename: value.name,
-          contentType: value.type || "application/octet-stream",
+          contentType: normalizeContentType(value.type),
           content: new Uint8Array(await value.arrayBuffer()),
         });
       }

package/src/ui/server/utils/path-containment.ts

@@ -0,0 +1,18 @@
+import path from "node:path";
+
+/**
+ * Resolve a relative path under rootDir and return null when it escapes or
+ * resolves to rootDir itself.
+ * POSIX-oriented for Bun on macOS/Linux; revalidate Windows separators and
+ * case-insensitive filesystem behavior before reusing this on other boundaries.
+ */
+export function resolveWithin(rootDir: string, relativePath: unknown): string | null {
+  if (typeof relativePath !== "string" || relativePath.length === 0) return null;
+  if (relativePath.includes("\0")) return null;
+  if (path.isAbsolute(relativePath)) return null;
+  const root = path.resolve(rootDir);
+  const resolved = path.resolve(root, relativePath);
+  if (resolved === root) return null;
+  if (!resolved.startsWith(root + path.sep)) return null;
+  return resolved;
+}

package/src/ui/server/utils/status-corruption.ts

@@ -0,0 +1,27 @@
+import path from "node:path";
+
+import { createErrorResponse } from "../config-bridge";
+import { Constants } from "../config-bridge-node";
+import { getJobDirectoryPath } from "../../../config/paths";
+import { StatusCorruptError } from "../../../core/status-writer";
+import { sendJson } from "./http-utils";
+
+export async function assertStatusParseable(statusPath: string): Promise<void> {
+  try {
+    JSON.parse(await Bun.file(statusPath).text());
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") return;
+    if (err instanceof SyntaxError) throw new StatusCorruptError(statusPath, { cause: err });
+    throw err;
+  }
+}
+
+export async function assertKnownJobStatusesParseable(dataDir: string, jobId: string): Promise<void> {
+  for (const location of ["current", "complete"] as const) {
+    await assertStatusParseable(path.join(getJobDirectoryPath(dataDir, jobId, location), "tasks-status.json"));
+  }
+}
+
+export function statusCorruptResponse(err: StatusCorruptError): Response {
+  return sendJson(409, createErrorResponse(Constants.ERROR_CODES.STATUS_CORRUPT, err.message, err.statusPath));
+}