@ryanfw/prompt-orchestration-pipeline 1.3.3 → 1.3.4

package/src/ui/server/__tests__/router-root-isolation.test.ts

@@ -0,0 +1,204 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+
+import { resetPATHS } from "../config-bridge-node";
+import { createRouter } from "../router";
+
+const ORIGINAL_PO_ROOT = process.env["PO_ROOT"];
+
+const tempRoots: string[] = [];
+
+async function makeTempRoot(prefix: string): Promise<string> {
+  const root = await Bun.$`mktemp -d ${path.join(os.tmpdir(), `${prefix}-XXXXXX`)}`.text();
+  const trimmed = root.trim();
+  tempRoots.push(trimmed);
+  return trimmed;
+}
+
+beforeEach(() => {
+  resetPATHS();
+});
+
+afterEach(async () => {
+  if (ORIGINAL_PO_ROOT === undefined) {
+    delete process.env["PO_ROOT"];
+  } else {
+    process.env["PO_ROOT"] = ORIGINAL_PO_ROOT;
+  }
+  resetPATHS();
+  await Promise.all(tempRoots.splice(0).map((root) => Bun.$`rm -rf ${root}`));
+});
+
+describe("router root isolation (AC-5)", () => {
+  it("handleTaskFile reads from the threaded root, ignoring PO_ROOT=/B", async () => {
+    const rootA = await makeTempRoot("router-iso-A");
+    const rootB = await makeTempRoot("router-iso-B");
+    process.env["PO_ROOT"] = rootB;
+
+    const jobDir = path.join(rootA, "pipeline-data", "current", "job-1");
+    await mkdir(path.join(jobDir, "files", "artifacts"), { recursive: true });
+    await writeFile(path.join(jobDir, "files", "artifacts", "out.json"), '{"source":"A"}\n');
+    await writeFile(
+      path.join(jobDir, "tasks-status.json"),
+      JSON.stringify({
+        id: "job-1",
+        tasks: {
+          research: {
+            files: { artifacts: ["out.json"], logs: [], tmp: [] },
+          },
+        },
+      }),
+    );
+
+    const router = createRouter({ dataDir: rootA });
+    const response = await router.handle(
+      new Request("http://localhost/api/jobs/job-1/tasks/research/file?type=artifacts&filename=out.json", {
+        headers: { Host: "localhost" },
+      }),
+    );
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toMatchObject({
+      ok: true,
+      data: '{"source":"A"}\n',
+      mime: "application/json",
+    });
+  });
+
+  it("handleTaskFileList reads from the threaded root, ignoring PO_ROOT=/B", async () => {
+    const rootA = await makeTempRoot("router-iso-A");
+    const rootB = await makeTempRoot("router-iso-B");
+    process.env["PO_ROOT"] = rootB;
+
+    const jobDir = path.join(rootA, "pipeline-data", "current", "job-1");
+    await mkdir(jobDir, { recursive: true });
+    await writeFile(
+      path.join(jobDir, "tasks-status.json"),
+      JSON.stringify({
+        id: "job-1",
+        tasks: {
+          research: {
+            files: { artifacts: ["listed.json"], logs: [], tmp: [] },
+          },
+        },
+      }),
+    );
+
+    const router = createRouter({ dataDir: rootA });
+    const response = await router.handle(
+      new Request("http://localhost/api/jobs/job-1/tasks/research/files?type=artifacts", {
+        headers: { Host: "localhost" },
+      }),
+    );
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toEqual({ ok: true, data: ["listed.json"] });
+  });
+
+  it("handleSchemaFile reads from the threaded root, ignoring PO_ROOT=/B", async () => {
+    const rootA = await makeTempRoot("router-iso-A");
+    const rootB = await makeTempRoot("router-iso-B");
+    process.env["PO_ROOT"] = rootB;
+
+    await mkdir(path.join(rootA, "pipeline-config", "slug-1", "schemas"), { recursive: true });
+    await writeFile(path.join(rootA, "pipeline-config", "slug-1", "schemas", "task.schema.json"), '{"$schema":"http://example"}\n');
+
+    const router = createRouter({ dataDir: rootA });
+    const response = await router.handle(
+      new Request("http://localhost/api/pipelines/slug-1/schemas/task.schema.json", {
+        headers: { Host: "localhost" },
+      }),
+    );
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toEqual({ ok: true, data: '{"$schema":"http://example"}\n' });
+  });
+
+  it("handleTaskAnalysis reads from the threaded root, ignoring PO_ROOT=/B", async () => {
+    const rootA = await makeTempRoot("router-iso-A");
+    const rootB = await makeTempRoot("router-iso-B");
+    process.env["PO_ROOT"] = rootB;
+
+    await mkdir(path.join(rootA, "pipeline-config", "slug-1", "tasks"), { recursive: true });
+    await writeFile(
+      path.join(rootA, "pipeline-config", "slug-1", "tasks", "research.analysis.json"),
+      JSON.stringify({ taskId: "research", steps: 3 }),
+    );
+
+    const router = createRouter({ dataDir: rootA });
+    const response = await router.handle(
+      new Request("http://localhost/api/pipelines/slug-1/tasks/research/analysis", {
+        headers: { Host: "localhost" },
+      }),
+    );
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toEqual({ ok: true, data: { taskId: "research", steps: 3 } });
+  });
+
+  it("handleCreatePipeline writes under the threaded root, ignoring PO_ROOT=/B", async () => {
+    const rootA = await makeTempRoot("router-iso-A");
+    const rootB = await makeTempRoot("router-iso-B");
+    process.env["PO_ROOT"] = rootB;
+
+    const router = createRouter({ dataDir: rootA });
+    const response = await router.handle(
+      new Request("http://localhost/api/pipelines", {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Host: "localhost" },
+        body: JSON.stringify({ name: "Isolation Test Pipeline", description: "x" }),
+      }),
+    );
+
+    expect(response.status).toBe(201);
+    const body = (await response.json()) as { ok: boolean; data: { slug: string; name: string } };
+    expect(body.ok).toBe(true);
+    const slug = body.data.slug;
+    expect(slug.length).toBeGreaterThan(0);
+
+    const pipelinePath = path.join(rootA, "pipeline-config", slug, "pipeline.json");
+    const pipelineText = await Bun.file(pipelinePath).text();
+    const pipeline = JSON.parse(pipelineText) as { name: string; slug: string };
+    expect(pipeline).toMatchObject({ name: "Isolation Test Pipeline", slug });
+
+    const registryPath = path.join(rootA, "pipeline-config", "registry.json");
+    const registry = JSON.parse(await Bun.file(registryPath).text()) as {
+      pipelines: Record<string, { name: string; description: string; configDir: string; tasksDir: string }>;
+    };
+    expect(registry.pipelines[slug]?.configDir).toBe(path.join("pipeline-config", slug));
+    expect(registry.pipelines[slug]?.tasksDir).toBe(path.join("pipeline-config", slug, "tasks"));
+    expect(registry.pipelines[slug]?.name).toBe("Isolation Test Pipeline");
+    expect(registry.pipelines[slug]?.description).toBe("x");
+
+    const bRootExists = await Bun.file(path.join(rootB, "pipeline-config", "registry.json")).exists();
+    expect(bRootExists).toBe(false);
+  });
+
+  it("handleTaskSave writes under the threaded root, ignoring PO_ROOT=/B", async () => {
+    const rootA = await makeTempRoot("router-iso-A");
+    const rootB = await makeTempRoot("router-iso-B");
+    process.env["PO_ROOT"] = rootB;
+
+    const router = createRouter({ dataDir: rootA });
+    const response = await router.handle(
+      new Request("http://localhost/api/tasks/create", {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Host: "localhost" },
+        body: JSON.stringify({ slug: "saved-slug", taskId: "research", content: "# research notes\n" }),
+      }),
+    );
+
+    expect(response.status).toBe(201);
+    await expect(response.json()).resolves.toEqual({ ok: true, data: { slug: "saved-slug", taskId: "research" } });
+
+    const savedPath = path.join(rootA, "pipeline-config", "saved-slug", "tasks", "research.md");
+    const savedText = await Bun.file(savedPath).text();
+    expect(savedText).toBe("# research notes\n");
+
+    const bRootExists = await Bun.file(path.join(rootB, "pipeline-config", "saved-slug", "tasks", "research.md")).exists();
+    expect(bRootExists).toBe(false);
+  });
+});

package/src/ui/server/__tests__/router-threading.test.ts

@@ -0,0 +1,148 @@
+import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
+
+// ─── Capture-args table: populated by mocked handlers so each test can assert
+//     the last argument the router passed.
+const capturedArgs: Record<string, unknown[] | undefined> = {};
+
+mock.module("../endpoints/file-endpoints", () => ({
+  handleTaskFile: mock((...args: unknown[]) => {
+    capturedArgs.handleTaskFile = args;
+    return Promise.resolve(new Response("{}", { headers: { "Content-Type": "application/json" } }));
+  }),
+  handleTaskFileList: mock((...args: unknown[]) => {
+    capturedArgs.handleTaskFileList = args;
+    return Promise.resolve(new Response("{}", { headers: { "Content-Type": "application/json" } }));
+  }),
+}));
+
+mock.module("../endpoints/schema-file-endpoint", () => ({
+  handleSchemaFile: mock((...args: unknown[]) => {
+    capturedArgs.handleSchemaFile = args;
+    return Promise.resolve(new Response("{}", { headers: { "Content-Type": "application/json" } }));
+  }),
+}));
+
+mock.module("../endpoints/task-analysis-endpoint", () => ({
+  handleTaskAnalysis: mock((...args: unknown[]) => {
+    capturedArgs.handleTaskAnalysis = args;
+    return Promise.resolve(new Response("{}", { headers: { "Content-Type": "application/json" } }));
+  }),
+}));
+
+mock.module("../endpoints/pipeline-analysis-endpoint", () => ({
+  handlePipelineAnalysis: mock((...args: unknown[]) => {
+    capturedArgs.handlePipelineAnalysis = args;
+    return Promise.resolve(new Response("{}", { headers: { "Content-Type": "application/json" } }));
+  }),
+}));
+
+mock.module("../endpoints/create-pipeline-endpoint", () => ({
+  handleCreatePipeline: mock((...args: unknown[]) => {
+    capturedArgs.handleCreatePipeline = args;
+    return Promise.resolve(new Response("{}", { headers: { "Content-Type": "application/json" } }));
+  }),
+}));
+
+mock.module("../endpoints/task-save-endpoint", () => ({
+  handleTaskSave: mock((...args: unknown[]) => {
+    capturedArgs.handleTaskSave = args;
+    return Promise.resolve(new Response("{}", { headers: { "Content-Type": "application/json" } }));
+  }),
+}));
+
+// ─── Import the module under test (after mock.module calls) ───────────────────
+import { createRouter } from "../router";
+
+// ─── Env capture/restore per ~/.agents/rules/unit-testing.md §6 ───────────────
+const ORIGINAL_PO_ROOT = process.env["PO_ROOT"];
+
+beforeEach(() => {
+  process.env["PO_ROOT"] = "/B";
+  for (const key of Object.keys(capturedArgs)) delete capturedArgs[key];
+});
+
+afterEach(() => {
+  if (ORIGINAL_PO_ROOT === undefined) {
+    delete process.env["PO_ROOT"];
+  } else {
+    process.env["PO_ROOT"] = ORIGINAL_PO_ROOT;
+  }
+});
+
+describe("router threads resolved root to six handlers (AC-5)", () => {
+  it("passes options.dataDir as the last argument to handleTaskFile", async () => {
+    const router = createRouter({ dataDir: "/A" });
+    await router.handle(
+      new Request("http://localhost/api/jobs/job-1/tasks/task-1/file?type=artifacts&filename=out.txt", {
+        headers: { Host: "localhost" },
+      }),
+    );
+    expect(capturedArgs.handleTaskFile?.at(-1)).toBe("/A");
+  });
+
+  it("passes options.dataDir as the last argument to handleTaskFileList", async () => {
+    const router = createRouter({ dataDir: "/A" });
+    await router.handle(
+      new Request("http://localhost/api/jobs/job-1/tasks/task-1/files?type=artifacts", {
+        headers: { Host: "localhost" },
+      }),
+    );
+    expect(capturedArgs.handleTaskFileList?.at(-1)).toBe("/A");
+  });
+
+  it("passes options.dataDir as the last argument to handleSchemaFile", async () => {
+    const router = createRouter({ dataDir: "/A" });
+    await router.handle(
+      new Request("http://localhost/api/pipelines/slug-1/schemas/task.schema.json", {
+        headers: { Host: "localhost" },
+      }),
+    );
+    expect(capturedArgs.handleSchemaFile?.at(-1)).toBe("/A");
+  });
+
+  it("passes options.dataDir as the last argument to handleTaskAnalysis", async () => {
+    const router = createRouter({ dataDir: "/A" });
+    await router.handle(
+      new Request("http://localhost/api/pipelines/slug-1/tasks/task-1/analysis", {
+        headers: { Host: "localhost" },
+      }),
+    );
+    expect(capturedArgs.handleTaskAnalysis?.at(-1)).toBe("/A");
+  });
+
+  it("passes options.dataDir as the last argument to handlePipelineAnalysis", async () => {
+    const router = createRouter({ dataDir: "/A" });
+    await router.handle(
+      new Request("http://localhost/api/pipelines/slug-1/analyze", {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Host: "localhost" },
+        body: "{}",
+      }),
+    );
+    expect(capturedArgs.handlePipelineAnalysis?.at(-1)).toBe("/A");
+  });
+
+  it("passes options.dataDir as the last argument to handleCreatePipeline", async () => {
+    const router = createRouter({ dataDir: "/A" });
+    await router.handle(
+      new Request("http://localhost/api/pipelines", {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Host: "localhost" },
+        body: "{}",
+      }),
+    );
+    expect(capturedArgs.handleCreatePipeline?.at(-1)).toBe("/A");
+  });
+
+  it("passes options.dataDir as the last argument to handleTaskSave", async () => {
+    const router = createRouter({ dataDir: "/A" });
+    await router.handle(
+      new Request("http://localhost/api/tasks/create", {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Host: "localhost" },
+        body: "{}",
+      }),
+    );
+    expect(capturedArgs.handleTaskSave?.at(-1)).toBe("/A");
+  });
+});

package/src/ui/server/__tests__/router.test.ts

@@ -70,6 +70,50 @@ describe("router", () => {
     expect(response.status).toBe(202);
     expect(body).toMatchObject({ ok: true, jobId: "gate-job", action: "reject", spawned: false });
   });
+
+  it("serves the embedded index.html for / when distDir is missing (AC-10)", async () => {
+    const root = await makeTempRoot();
+    process.env["PO_ROOT"] = root;
+    initPATHS(root);
+    const router = createRouter({ dataDir: root, distDir: path.join(root, "no-such-dist") });
+
+    const response = await router.handle(new Request("http://localhost/", { headers: { Host: "localhost" } }));
+    expect(response.status).toBe(200);
+    expect(response.headers.get("Content-Type")).toBe("text/html");
+  });
+
+  it("serves the embedded index.html for an unknown SPA route when distDir is missing (AC-11)", async () => {
+    const root = await makeTempRoot();
+    process.env["PO_ROOT"] = root;
+    initPATHS(root);
+    const router = createRouter({ dataDir: root, distDir: path.join(root, "no-such-dist") });
+
+    const response = await router.handle(new Request("http://localhost/jobs/client-route", { headers: { Host: "localhost" } }));
+    expect(response.status).toBe(200);
+    expect(response.headers.get("Content-Type")).toBe("text/html");
+  });
+
+  it("serves an exact embedded /assets/... entry with its generated MIME when distDir is missing (AC-12)", async () => {
+    const { embeddedAssets } = await import("../embedded-assets");
+    const assetsKey = Object.keys(embeddedAssets).find((k) => k.startsWith("/assets/"));
+    if (!assetsKey) {
+      throw new Error("expected at least one /assets/... key in embeddedAssets");
+    }
+    const entry = embeddedAssets[assetsKey];
+    if (!entry) {
+      throw new Error(`expected embeddedAssets to have entry for ${assetsKey}`);
+    }
+    const expectedMime = entry.mime;
+
+    const root = await makeTempRoot();
+    process.env["PO_ROOT"] = root;
+    initPATHS(root);
+    const router = createRouter({ dataDir: root, distDir: path.join(root, "no-such-dist") });
+
+    const response = await router.handle(new Request(`http://localhost${assetsKey}`, { headers: { Host: "localhost" } }));
+    expect(response.status).toBe(200);
+    expect(response.headers.get("Content-Type")).toBe(expectedMime);
+  });
 });
 
 describe("router CORS and hardening", () => {
@@ -261,3 +305,63 @@ describe("router CORS and hardening", () => {
     expect(response.status).not.toBe(403);
   });
 });
+
+describe("router static-asset containment (AC-7)", () => {
+  it("does not serve a file outside distDir via an encoded-dotdot escape", async () => {
+    const root = await makeTempRoot();
+    process.env["PO_ROOT"] = root;
+    initPATHS(root);
+    await mkdir(path.join(root, "dist"), { recursive: true });
+    await writeFile(path.join(root, "dist", "index.html"), "<html>spa</html>");
+    await writeFile(path.join(root, "secret.txt"), "AC7-SENTINEL");
+
+    const router = createRouter({ dataDir: root, distDir: path.join(root, "dist") });
+
+    const response = await router.handle(new Request("http://localhost/%2e%2fsecret.txt", { headers: { Host: "localhost" } }));
+    const body = await response.text();
+    expect(body).not.toContain("AC7-SENTINEL");
+  });
+
+  it("does not serve an absolute-path escape after percent-decode", async () => {
+    const root = await makeTempRoot();
+    process.env["PO_ROOT"] = root;
+    initPATHS(root);
+    await mkdir(path.join(root, "dist"), { recursive: true });
+    await writeFile(path.join(root, "dist", "index.html"), "<html>spa</html>");
+
+    const router = createRouter({ dataDir: root, distDir: path.join(root, "dist") });
+
+    const response = await router.handle(new Request("http://localhost/%2fetc%2fpasswd", { headers: { Host: "localhost" } }));
+    const body = await response.text();
+    expect(body).not.toContain("root:");
+  });
+
+  it("serves a real in-distDir disk asset", async () => {
+    const root = await makeTempRoot();
+    process.env["PO_ROOT"] = root;
+    initPATHS(root);
+    await mkdir(path.join(root, "dist", "assets"), { recursive: true });
+    await writeFile(path.join(root, "dist", "assets", "app.js"), "console.log('app');");
+
+    const router = createRouter({ dataDir: root, distDir: path.join(root, "dist") });
+
+    const response = await router.handle(new Request("http://localhost/assets/app.js", { headers: { Host: "localhost" } }));
+    expect(response.status).toBe(200);
+    expect(response.headers.get("Content-Type")).toBe("application/javascript");
+    await expect(response.text()).resolves.toBe("console.log('app');");
+  });
+
+  it("falls back to index.html for a contained but nonexistent client route", async () => {
+    const root = await makeTempRoot();
+    process.env["PO_ROOT"] = root;
+    initPATHS(root);
+    await mkdir(path.join(root, "dist"), { recursive: true });
+    await writeFile(path.join(root, "dist", "index.html"), "<html>spa-shell</html>");
+
+    const router = createRouter({ dataDir: root, distDir: path.join(root, "dist") });
+
+    const response = await router.handle(new Request("http://localhost/jobs/abc", { headers: { Host: "localhost" } }));
+    expect(response.status).toBe(200);
+    await expect(response.text()).resolves.toBe("<html>spa-shell</html>");
+  });
+});

package/src/ui/server/__tests__/sse-broadcast.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it, vi } from "vitest";
 
+import { SseEvent } from "../../../config/sse-events";
 import { broadcastStateUpdate } from "../sse-broadcast";
 import { sseRegistry } from "../sse-registry";
 
@@ -20,6 +21,7 @@ describe("sse-broadcast", () => {
       "state:change",
       expect.objectContaining({ jobId: "job-1", lifecycle: "current" }),
     );
+    spy.mockRestore();
   });
 
   it("falls back to summary and never throws", () => {
@@ -29,4 +31,46 @@ describe("sse-broadcast", () => {
     expect(() => broadcastStateUpdate({ recentChanges: [], changeCount: 2 })).not.toThrow();
     spy.mockRestore();
   });
+
+  it("emits state:summary with changeCount when no parseable job path exists", () => {
+    const spy = vi.spyOn(sseRegistry, "broadcast").mockImplementation(() => undefined);
+    broadcastStateUpdate({
+      recentChanges: [
+        {
+          path: "some/other/path/tasks-status.json",
+          type: "modified",
+          timestamp: "2024-01-01T00:00:00.000Z",
+        },
+      ],
+      changeCount: 5,
+    });
+    expect(spy).toHaveBeenCalledWith("state:summary", { changeCount: 5 });
+    const call = spy.mock.calls[0] as unknown as [string, unknown];
+    const [type, data] = call;
+    expect(SseEvent.safeParse({ type, data }).success).toBe(true);
+    spy.mockRestore();
+  });
+
+  it("emits state:change whose payload SseEvent.parse accepts", () => {
+    const spy = vi.spyOn(sseRegistry, "broadcast").mockImplementation(() => undefined);
+    broadcastStateUpdate({
+      recentChanges: [
+        {
+          path: "pipeline-data/complete/job-7/tasks-status.json",
+          type: "modified",
+          timestamp: "2024-01-01T00:00:00.000Z",
+        },
+      ],
+      changeCount: 1,
+    });
+    const call = spy.mock.calls[0] as unknown as [string, unknown];
+    const [type, data] = call;
+    const parsed = SseEvent.safeParse({ type, data });
+    expect(parsed.success).toBe(true);
+    if (parsed.success) {
+      expect(parsed.data.type).toBe("state:change");
+      expect(parsed.data.data.jobId).toBe("job-7");
+    }
+    spy.mockRestore();
+  });
 });

package/src/ui/server/__tests__/sse-enhancer.test.ts

@@ -1,5 +1,6 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
+import { SseEvent } from "../../../config/sse-events";
 import { createSSEEnhancer } from "../sse-enhancer";
 
 describe("sse-enhancer", () => {
@@ -84,4 +85,42 @@ describe("sse-enhancer", () => {
     expect(broadcast.mock.calls[0]?.[0]).toBe("job:created");
     expect(payload.status).toBe("failed");
   });
+
+  it("emits a job:updated event whose payload SseEvent.parse accepts and carries jobId", async () => {
+    const readJobFn = vi.fn(async () => ({
+      ok: true as const,
+      jobId: "j1",
+      location: "current",
+      path: "/tmp/j1/tasks-status.json",
+      data: {
+        title: "Job 1",
+        createdAt: "2024-01-01T00:00:00.000Z",
+        updatedAt: "2024-01-01T00:00:00.000Z",
+        tasks: { a: { state: "done", files: {} } },
+      },
+    }));
+    const broadcast = vi.fn();
+    const enhancer = createSSEEnhancer({
+      readJobFn,
+      sseRegistry: { addClient() {}, removeClient() {}, broadcast, getClientCount() { return 0; }, closeAll() {} },
+      debounceMs: 100,
+    });
+
+    enhancer.handleJobChange({ jobId: "j1" });
+    vi.advanceTimersByTime(100);
+    await Promise.resolve();
+    enhancer.handleJobChange({ jobId: "j1" });
+    vi.advanceTimersByTime(100);
+    await Promise.resolve();
+
+    const updatedCall = broadcast.mock.calls.find((call) => call[0] === "job:updated");
+    expect(updatedCall).toBeDefined();
+    const [type, data] = updatedCall as [string, unknown];
+    const parsed = SseEvent.safeParse({ type, data });
+    expect(parsed.success).toBe(true);
+    if (parsed.success) {
+      expect(parsed.data.type).toBe("job:updated");
+      expect(parsed.data.data.jobId).toBe("j1");
+    }
+  });
 });

package/src/ui/server/config-bridge-node.ts

@@ -11,6 +11,8 @@ import {
   validateTaskState,
 } from "./config-bridge";
 
+import { resolvePipelinePaths as resolvePipelinePathsCore } from "../../config/paths";
+
 export type { ErrorEnvelope } from "./config-bridge";
 
 export interface ResolvedPaths {
@@ -20,30 +22,14 @@ export interface ResolvedPaths {
   rejected: string;
 }
 
-const DEFAULT_ROOT = process.env["PO_ROOT"] ?? process.cwd();
-
 let cachedPaths: ResolvedPaths | null = null;
 
 export const Constants = {
   ...UniversalConstants,
-  RETRY_CONFIG: {
-    ...UniversalConstants.RETRY_CONFIG,
-    DELAY_MS: process.env["NODE_ENV"] === "test" ? 10 : UniversalConstants.RETRY_CONFIG.DELAY_MS,
-  },
 } as const;
 
-function toRoot(root?: string): string {
-  return path.resolve(root ?? DEFAULT_ROOT);
-}
-
-export function resolvePipelinePaths(root?: string): ResolvedPaths {
-  const base = toRoot(root);
-  return {
-    current: path.join(base, "pipeline-data", "current"),
-    complete: path.join(base, "pipeline-data", "complete"),
-    pending: path.join(base, "pipeline-data", "pending"),
-    rejected: path.join(base, "pipeline-data", "rejected"),
-  };
+export function resolvePipelinePaths(root: string): ResolvedPaths {
+  return resolvePipelinePathsCore(root);
 }
 
 export function initPATHS(root: string): void {
@@ -54,13 +40,11 @@ export function resetPATHS(): void {
   cachedPaths = null;
 }
 
-export function getPATHS(root?: string): ResolvedPaths {
-  if (root) {
-    initPATHS(root);
-  } else if (!cachedPaths) {
-    cachedPaths = resolvePipelinePaths();
+export function getPATHS(): ResolvedPaths {
+  if (!cachedPaths) {
+    throw new Error("initPATHS(root) must be called before getPATHS()");
   }
-  return cachedPaths!;
+  return cachedPaths;
 }
 
 export function getJobPath(jobId: string, location: keyof ResolvedPaths = "current"): string {
@@ -109,8 +93,6 @@ export {
   validateTaskState,
 };
 
-export const PATHS = getPATHS();
-
 export function asErrorEnvelope(error: unknown, fallbackCode = Constants.ERROR_CODES.FS_ERROR): ErrorEnvelope {
   return createErrorResponse(
     fallbackCode,