dtu-github-actions 0.0.0

package/dist/server/routes/cache.test.js

@@ -0,0 +1,229 @@
+import { describe, it, expect, beforeEach, beforeAll, afterAll } from "vitest";
+import { state } from "../store.js";
+import { bootstrapAndReturnApp } from "../index.js";
+import { config } from "../../config.js";
+import fs from "node:fs";
+import path from "node:path";
+const CACHE_DIR = config.DTU_CACHE_DIR;
+let PORT;
+/** Helper: run the full reserve → upload → commit cycle and return the cacheId. */
+async function createCache(baseUrl, key, version, content) {
+    // Reserve
+    let res = await fetch(`${baseUrl}/_apis/artifactcache/caches`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ key, version }),
+    });
+    expect(res.status).toBe(201);
+    const { cacheId } = await res.json();
+    // Upload
+    res = await fetch(`${baseUrl}/_apis/artifactcache/caches/${cacheId}`, {
+        method: "PATCH",
+        headers: {
+            "Content-Type": "application/octet-stream",
+            "Content-Range": `bytes 0-${content.length - 1}/*`,
+        },
+        body: content,
+    });
+    expect(res.status).toBe(200);
+    // Commit
+    res = await fetch(`${baseUrl}/_apis/artifactcache/caches/${cacheId}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ size: content.length }),
+    });
+    expect(res.status).toBe(200);
+    return cacheId;
+}
+describe("DTU Cache API", () => {
+    let server;
+    beforeAll(async () => {
+        state.reset();
+        const app = await bootstrapAndReturnApp();
+        return new Promise((resolve) => {
+            server = app.listen(0, () => {
+                const address = server.server?.address();
+                PORT = address.port;
+                resolve();
+            });
+        });
+    });
+    beforeEach(() => {
+        state.reset();
+        // Clean up any test cache files
+        if (fs.existsSync(CACHE_DIR)) {
+            for (const file of fs.readdirSync(CACHE_DIR)) {
+                if (file.startsWith("cache_") || file.startsWith("temp_")) {
+                    try {
+                        fs.unlinkSync(path.join(CACHE_DIR, file));
+                    }
+                    catch { }
+                }
+            }
+        }
+    });
+    afterAll(async () => {
+        await new Promise((resolve) => {
+            if (server && server.server) {
+                server.server.close(() => resolve());
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+    it("should handle full cache lifecycle", async () => {
+        const baseUrl = `http://localhost:${PORT}`;
+        // 1. Check miss
+        let res = await fetch(`${baseUrl}/_apis/artifactcache/caches?keys=my-key&version=1`);
+        expect(res.status).toBe(204);
+        // 2. Reserve → Upload → Commit
+        const cacheId = await createCache(baseUrl, "my-key", "1", "hello world!");
+        // 3. Check hit
+        res = await fetch(`${baseUrl}/_apis/artifactcache/caches?keys=my-key&version=1`);
+        expect(res.status).toBe(200);
+        const hitData = await res.json();
+        expect(hitData.result).toBe("hit");
+        expect(hitData.archiveLocation).toBe(`${baseUrl}/_apis/artifactcache/artifacts/${cacheId}`);
+        // 4. Download cache
+        res = await fetch(hitData.archiveLocation);
+        expect(res.status).toBe(200);
+        const text = await res.text();
+        expect(text).toBe("hello world!");
+    });
+    it("should evict stale cache entries when the archive file is missing", async () => {
+        const baseUrl = `http://localhost:${PORT}`;
+        // Create a cache normally
+        const cacheId = await createCache(baseUrl, "stale-key", "1", "data");
+        // Verify hit
+        let res = await fetch(`${baseUrl}/_apis/artifactcache/caches?keys=stale-key&version=1`);
+        expect(res.status).toBe(200);
+        // Delete the archive file behind the scenes (simulates OS cleanup / file loss)
+        const archivePath = path.join(CACHE_DIR, `cache_${cacheId}.tar.gz`);
+        expect(fs.existsSync(archivePath)).toBe(true);
+        fs.unlinkSync(archivePath);
+        // Now the cache check should evict the stale entry and return a miss
+        res = await fetch(`${baseUrl}/_apis/artifactcache/caches?keys=stale-key&version=1`);
+        expect(res.status).toBe(204);
+        // Verify the entry was removed from state
+        expect(state.caches.has("stale-key")).toBe(false);
+    });
+    it("should construct archiveLocation dynamically from the request host", async () => {
+        const baseUrl = `http://localhost:${PORT}`;
+        // Create a cache
+        const cacheId = await createCache(baseUrl, "url-key", "1", "content");
+        // Manually overwrite the stored archiveLocation with a stale host
+        const entry = state.caches.get("url-key");
+        entry.archiveLocation = `http://stale-host:9999/_apis/artifactcache/artifacts/${cacheId}`;
+        // The cache check should return a URL based on the current request, not the stale one
+        const res = await fetch(`${baseUrl}/_apis/artifactcache/caches?keys=url-key&version=1`);
+        expect(res.status).toBe(200);
+        const data = await res.json();
+        expect(data.archiveLocation).toBe(`${baseUrl}/_apis/artifactcache/artifacts/${cacheId}`);
+        expect(data.archiveLocation).not.toContain("stale-host");
+    });
+    it("should reject reservation when cache key+version already exists (immutable)", async () => {
+        const baseUrl = `http://localhost:${PORT}`;
+        // Create a cache
+        await createCache(baseUrl, "immutable-key", "1", "first");
+        // Try to reserve the same key+version again
+        const res = await fetch(`${baseUrl}/_apis/artifactcache/caches`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ key: "immutable-key", version: "1" }),
+        });
+        expect(res.status).toBe(409);
+        // But a different version should succeed
+        const res2 = await fetch(`${baseUrl}/_apis/artifactcache/caches`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ key: "immutable-key", version: "2" }),
+        });
+        expect(res2.status).toBe(201);
+    });
+    it("should delete old archive file when overwriting a cache key", async () => {
+        const baseUrl = `http://localhost:${PORT}`;
+        // Create initial cache
+        const oldCacheId = await createCache(baseUrl, "overwrite-key", "1", "old data");
+        const oldPath = path.join(CACHE_DIR, `cache_${oldCacheId}.tar.gz`);
+        expect(fs.existsSync(oldPath)).toBe(true);
+        // Force-clear the immutable guard so we can overwrite
+        // (in practice this happens when key is the same but version differs)
+        state.caches.delete("overwrite-key");
+        // Create a new cache with the same key
+        const newCacheId = await createCache(baseUrl, "overwrite-key", "1", "new data");
+        const newPath = path.join(CACHE_DIR, `cache_${newCacheId}.tar.gz`);
+        // Old file should be deleted, new file should exist
+        // Note: the old file was already deleted since we cleared the entry,
+        // so let's test the real scenario by directly manipulating state
+        expect(fs.existsSync(newPath)).toBe(true);
+    });
+    it("should clean up old archive when committing with a pre-existing key", async () => {
+        const baseUrl = `http://localhost:${PORT}`;
+        // Manually seed a fake old cache entry with a real file
+        const fakeOldId = 111111;
+        const fakeOldPath = path.join(CACHE_DIR, `cache_${fakeOldId}.tar.gz`);
+        fs.writeFileSync(fakeOldPath, "old content");
+        state.caches.set("cleanup-key", {
+            version: "1",
+            archiveLocation: `http://localhost:${PORT}/_apis/artifactcache/artifacts/${fakeOldId}`,
+            size: 11,
+        });
+        expect(fs.existsSync(fakeOldPath)).toBe(true);
+        // Now reserve + upload + commit a NEW cache for the same key but different version
+        // (The immutable guard only blocks same key+version, not same key+different version)
+        const newCacheId = await createCache(baseUrl, "cleanup-key", "2", "new content");
+        // Old file should be deleted
+        expect(fs.existsSync(fakeOldPath)).toBe(false);
+        // New file should exist
+        expect(fs.existsSync(path.join(CACHE_DIR, `cache_${newCacheId}.tar.gz`))).toBe(true);
+    });
+    it("should clear caches on state.reset()", () => {
+        // Seed some cache entries
+        state.caches.set("key-a", { version: "1", archiveLocation: "http://x/artifacts/1", size: 10 });
+        state.caches.set("key-b", { version: "2", archiveLocation: "http://x/artifacts/2", size: 20 });
+        state.pendingCaches.set(999, { tempPath: "/tmp/x", key: "key-c", version: "1" });
+        expect(state.caches.size).toBe(2);
+        expect(state.pendingCaches.size).toBe(1);
+        state.reset();
+        expect(state.caches.size).toBe(0);
+        expect(state.pendingCaches.size).toBe(0);
+    });
+    it("should return 204 for version mismatch even if key exists", async () => {
+        const baseUrl = `http://localhost:${PORT}`;
+        await createCache(baseUrl, "version-key", "1", "v1 data");
+        // Check with different version — should miss
+        const res = await fetch(`${baseUrl}/_apis/artifactcache/caches?keys=version-key&version=2`);
+        expect(res.status).toBe(204);
+    });
+    it("should return 404 for download of non-existent cache ID", async () => {
+        const baseUrl = `http://localhost:${PORT}`;
+        const res = await fetch(`${baseUrl}/_apis/artifactcache/artifacts/999999`);
+        expect(res.status).toBe(404);
+    });
+    it("should reject a second reservation while the first is still pending (parallel jobs race)", async () => {
+        const baseUrl = `http://localhost:${PORT}`;
+        // First job reserves — should succeed
+        const res1 = await fetch(`${baseUrl}/_apis/artifactcache/caches`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ key: "race-key", version: "1" }),
+        });
+        expect(res1.status).toBe(201);
+        // Second job reserves the same key+version while first is still pending (not yet committed)
+        const res2 = await fetch(`${baseUrl}/_apis/artifactcache/caches`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ key: "race-key", version: "1" }),
+        });
+        // Should be rejected — another job already has an in-flight reservation
+        expect(res2.status).toBe(409);
+        // Third parallel job also rejected
+        const res3 = await fetch(`${baseUrl}/_apis/artifactcache/caches`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ key: "race-key", version: "1" }),
+        });
+        expect(res3.status).toBe(409);
+    });
+});

package/dist/server/routes/dtu.d.ts

@@ -0,0 +1,3 @@
+import { Polka } from "polka";
+export declare function getBaseUrl(req: any): string;
+export declare function registerDtuRoutes(app: Polka): void;

package/dist/server/routes/dtu.js

@@ -0,0 +1,141 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import { state } from "../store.js";
+import { createJobResponse } from "./actions/generators.js";
+// Base URL extractor middleware (to handle localhost vs host.docker.internal properly)
+// NOTE: strip \r\n from the Host header — HTTP/1.1 runners can include a trailing \r
+// which, if embedded in a signed URL, causes Node.js to throw
+// "Parse Error: Invalid header value char" when the toolkit uses that URL in a header.
+export function getBaseUrl(req) {
+    const host = (req.headers.host || "localhost").replace(/[\r\n]/g, "").trim();
+    const protocol = (req.headers["x-forwarded-proto"] || "http").replace(/[\r\n]/g, "").trim();
+    return `${protocol}://${host}`;
+}
+export function registerDtuRoutes(app) {
+    // 1. Internal Seeding Endpoint
+    app.post("/_dtu/seed", (req, res) => {
+        try {
+            const payload = req.body;
+            const jobId = payload.id?.toString();
+            if (jobId) {
+                const mappedSteps = (payload.steps || []).map((step) => ({
+                    ...step,
+                    Id: crypto.randomUUID(),
+                }));
+                const jobPayload = { ...payload, steps: mappedSteps };
+                // Store job both in the generic map AND keyed by runner name for per-runner dispatch.
+                // The runnerName is passed in the body (from local-job.ts which spreads the Job object).
+                const runnerName = payload.runnerName;
+                state.jobs.set(jobId, jobPayload);
+                if (runnerName) {
+                    state.runnerJobs.set(runnerName, jobPayload);
+                }
+                console.log(`[DTU] Seeded job: ${jobId}${runnerName ? ` for runner ${runnerName}` : ""}`);
+                // Notify only the pending poll that belongs to this runner (if any already waiting).
+                const baseUrl = getBaseUrl(req);
+                let notified = false;
+                for (const [sessionId, { res: pollRes, baseUrl: runnerBaseUrl }] of state.pendingPolls) {
+                    const sessRunner = state.sessionToRunner.get(sessionId);
+                    // Only dispatch to the runner this job was seeded for (or any runner if no runnerName)
+                    if (runnerName && sessRunner !== runnerName) {
+                        continue;
+                    }
+                    console.log(`[DTU] Notifying session ${sessionId} of new job ${jobId}`);
+                    const planId = crypto.randomUUID();
+                    // Map this planId to this runner's log directory
+                    if (sessRunner) {
+                        const logDir = state.runnerLogs.get(sessRunner);
+                        if (logDir) {
+                            state.planToLogDir.set(planId, logDir);
+                        }
+                    }
+                    const jobResponse = createJobResponse(jobId, jobPayload, runnerBaseUrl || baseUrl, planId);
+                    // Map timelineId → runner's timeline dir (CLI logs dir)
+                    try {
+                        const jobBody = JSON.parse(jobResponse.Body);
+                        const timelineId = jobBody?.Timeline?.Id;
+                        const tDir = sessRunner ? state.runnerTimelineDirs.get(sessRunner) : undefined;
+                        if (timelineId && tDir) {
+                            state.timelineToLogDir.set(timelineId, tDir);
+                        }
+                    }
+                    catch {
+                        /* best-effort */
+                    }
+                    pollRes.writeHead(200, { "Content-Type": "application/json" });
+                    pollRes.end(JSON.stringify(jobResponse));
+                    state.pendingPolls.delete(sessionId);
+                    // Remove from runnerJobs since it was dispatched
+                    if (sessRunner) {
+                        state.runnerJobs.delete(sessRunner);
+                    }
+                    state.jobs.delete(jobId);
+                    notified = true;
+                    break;
+                }
+                if (!notified) {
+                    console.log(`[DTU] No pending poll for job ${jobId} (runner: ${runnerName || "any"}) - job queued`);
+                }
+                res.writeHead(201, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ status: "ok", jobId }));
+            }
+            else {
+                res.writeHead(400);
+                res.end(JSON.stringify({ error: "Missing job ID" }));
+            }
+        }
+        catch (err) {
+            console.error("[DTU] Seed error", err);
+            res.writeHead(400);
+            res.end(JSON.stringify({ error: "Invalid JSON" }));
+        }
+    });
+    // POST /_dtu/start-runner
+    // Called by localJob.ts when spawning a runner container
+    app.post("/_dtu/start-runner", (req, res) => {
+        try {
+            const { runnerName, logDir, timelineDir, virtualCachePatterns } = req.body;
+            if (runnerName && logDir) {
+                fs.mkdirSync(logDir, { recursive: true });
+                // Register this runner mapping so we can route logs later
+                state.runnerLogs.set(runnerName, logDir);
+                // Also store the timeline dir (CLI's logs dir) for this runner
+                if (timelineDir) {
+                    state.runnerTimelineDirs.set(runnerName, timelineDir);
+                }
+                // Register virtual cache key patterns (e.g. "pnpm") so bind-mounted paths
+                // skip the tar archive entirely.
+                if (Array.isArray(virtualCachePatterns)) {
+                    for (const pattern of virtualCachePatterns) {
+                        if (typeof pattern === "string" && pattern.length > 0) {
+                            state.virtualCachePatterns.add(pattern);
+                        }
+                    }
+                }
+                console.log(`[DTU] Registered runner ${runnerName} with logs at ${logDir}${timelineDir ? `, timeline at ${timelineDir}` : ""}${virtualCachePatterns?.length
+                    ? `, virtual cache patterns: ${virtualCachePatterns.join(", ")}`
+                    : ""}`);
+            }
+        }
+        catch (e) {
+            console.warn("[DTU] start-runner parse error:", e);
+        }
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true }));
+    });
+    // Debug: Dump State
+    app.get("/_dtu/dump", (req, res) => {
+        const dump = {
+            jobs: Object.fromEntries(state.jobs),
+            logs: Object.fromEntries(state.logs),
+            runnerLogs: Object.fromEntries(state.runnerLogs),
+            runnerTimelineDirs: Object.fromEntries(state.runnerTimelineDirs),
+            sessionToRunner: Object.fromEntries(state.sessionToRunner),
+            planToLogDir: Object.fromEntries(state.planToLogDir),
+            recordToStepName: Object.fromEntries(state.recordToStepName),
+            timelineToLogDir: Object.fromEntries(state.timelineToLogDir),
+        };
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(dump));
+    });
+}

package/dist/server/routes/github.d.ts

@@ -0,0 +1,2 @@
+import { Polka } from "polka";
+export declare function registerGithubRoutes(app: Polka): void;

package/dist/server/routes/github.js

@@ -0,0 +1,109 @@
+import { execSync } from "node:child_process";
+import { state } from "../store.js";
+import { getBaseUrl } from "./dtu.js";
+const EMPTY_TARBALL = execSync("tar czf - -T /dev/null");
+export function registerGithubRoutes(app) {
+    // 2. GitHub REST API Mirror - Job Detail
+    app.get("/repos/:owner/:repo/actions/jobs/:id", (req, res) => {
+        const jobId = req.params.id;
+        const job = state.jobs.get(jobId);
+        if (job) {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(job));
+        }
+        else {
+            console.warn(`[DTU] Job not found: ${jobId}`);
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ message: "Not Found (DTU Mock)" }));
+        }
+    });
+    // 3. GitHub App Token Exchange Mock (App Level)
+    app.post("/app/installations/:id/access_tokens", (req, res) => {
+        const installationId = req.params.id;
+        console.log(`[DTU] Token exchange for installation: ${installationId}`);
+        const response = {
+            token: `ghs_mock_token_${installationId}_${Math.random().toString(36).substring(7)}`,
+            expires_at: new Date(Date.now() + 3600 * 1000).toISOString(),
+            permissions: {
+                actions: "read",
+                metadata: "read",
+            },
+            repository_selection: "selected",
+        };
+        res.writeHead(201, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(response));
+    });
+    // 4. GitHub Installation Lookup Mock (Repo Level)
+    app.get("/repos/:owner/:repo/installation", (req, res) => {
+        const owner = req.params.owner;
+        const repo = req.params.repo;
+        console.log(`[DTU] Fetching installation for ${owner}/${repo}`);
+        const baseUrl = getBaseUrl(req);
+        const response = {
+            id: 12345678,
+            account: {
+                login: owner,
+                type: "User",
+            },
+            repository_selection: "all",
+            access_tokens_url: `${baseUrl}/app/installations/12345678/access_tokens`,
+        };
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(response));
+    });
+    // 5. GitHub Runner Registration Token Mock
+    // Supports both v3 and bare api calls through polling
+    app.post("/repos/:owner/:repo/actions/runners/registration-token", (req, res) => {
+        const owner = req.params.owner;
+        const repo = req.params.repo;
+        console.log(`[DTU] Generating registration token for ${owner}/${repo}`);
+        const response = {
+            token: `ghr_mock_registration_token_${Math.random().toString(36).substring(7)}`,
+            expires_at: new Date(Date.now() + 3600 * 1000).toISOString(),
+        };
+        res.writeHead(201, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(response));
+    });
+    app.post("/api/v3/repos/:owner/:repo/actions/runners/registration-token", (req, res) => {
+        const owner = req.params.owner;
+        const repo = req.params.repo;
+        console.log(`[DTU] Generating registration token for ${owner}/${repo} (v3)`);
+        const response = {
+            token: `ghr_mock_registration_token_${Math.random().toString(36).substring(7)}`,
+            expires_at: new Date(Date.now() + 3600 * 1000).toISOString(),
+        };
+        res.writeHead(201, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(response));
+    });
+    // 6. Global Runner Registration Mock (Discovery/Handshake)
+    const globalRunnerRegistrationHandler = (req, res) => {
+        console.log(`[DTU] Handling global runner registration (${req.url})`);
+        const token = `ghr_mock_tenant_token_${Math.random().toString(36).substring(7)}`;
+        const expiresAt = new Date(Date.now() + 3600 * 1000).toISOString();
+        const baseUrl = getBaseUrl(req);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+            token: token,
+            token_schema: "OAuthAccessToken",
+            authorization_url: `${baseUrl}/auth/authorize`,
+            client_id: "mock-client-id",
+            tenant_id: "mock-tenant-id",
+            expiration: expiresAt,
+            url: baseUrl,
+        }));
+    };
+    app.post("/actions/runner-registration", globalRunnerRegistrationHandler);
+    app.post("/api/v3/actions/runner-registration", globalRunnerRegistrationHandler);
+    // 7. Tarball route — actions/checkout downloads repos via this endpoint.
+    // Return an empty tar.gz since the workspace is already bind-mounted.
+    const tarballHandler = (req, res) => {
+        console.log(`[DTU] Serving empty tarball for ${req.url}`);
+        res.writeHead(200, {
+            "Content-Type": "application/gzip",
+            "Content-Length": String(EMPTY_TARBALL.length),
+        });
+        res.end(EMPTY_TARBALL);
+    };
+    app.get("/repos/:owner/:repo/tarball/:ref", tarballHandler);
+    app.get("/_apis/repos/:owner/:repo/tarball/:ref", tarballHandler);
+}

package/dist/server/start.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/start.js

@@ -0,0 +1,22 @@
+import { config } from "../config.js";
+import { bootstrapAndReturnApp } from "./index.js";
+import { getDtuLogPath, setWorkingDirectory, DTU_ROOT } from "./logger.js";
+import path from "node:path";
+let workingDir = process.env.AGENT_CI_WORKING_DIR;
+if (workingDir) {
+    if (!path.isAbsolute(workingDir)) {
+        workingDir = path.resolve(DTU_ROOT, workingDir);
+    }
+    setWorkingDirectory(workingDir);
+}
+bootstrapAndReturnApp()
+    .then((app) => {
+    app.listen(config.DTU_PORT, "0.0.0.0", () => {
+        console.log(`[DTU] OA-RUN-1 Mock GitHub API server running at http://0.0.0.0:${config.DTU_PORT}`);
+        console.log(`[DTU] Logging to ${getDtuLogPath()}`);
+    });
+})
+    .catch((err) => {
+    console.error("[DTU] Failed to start:", err);
+    process.exit(1);
+});

package/dist/server/store.d.ts

@@ -0,0 +1,44 @@
+import http from "node:http";
+/** Override the cache directory at runtime (e.g. for ephemeral per-repo DTU instances). */
+export declare function setCacheDir(dir: string): void;
+export declare const state: {
+    jobs: Map<string, any>;
+    runnerJobs: Map<string, any>;
+    sessions: Map<string, any>;
+    messageQueues: Map<string, any[]>;
+    pendingPolls: Map<string, {
+        res: http.ServerResponse<http.IncomingMessage>;
+        baseUrl: string;
+    }>;
+    logs: Map<string, string[]>;
+    runnerLogs: Map<string, string>;
+    runnerTimelineDirs: Map<string, string>;
+    sessionToRunner: Map<string, string>;
+    recordToStepName: Map<string, string>;
+    planToLogDir: Map<string, string>;
+    timelineToLogDir: Map<string, string>;
+    currentInProgressStep: Map<string, string>;
+    virtualCachePatterns: Set<string>;
+    caches: Map<string, {
+        version: string;
+        archiveLocation: string;
+        size: number;
+    }>;
+    pendingCaches: Map<number, {
+        tempPath: string;
+        key: string;
+        version: string;
+    }>;
+    artifacts: Map<string, {
+        containerId: number;
+        files: Map<string, string>;
+    }>;
+    pendingArtifacts: Map<number, {
+        name: string;
+        files: Map<string, string>;
+    }>;
+    isVirtualCacheKey(key: string): boolean;
+    loadCachesFromDisk(): void;
+    saveCachesToDisk(): void;
+    reset(): void;
+};

package/dist/server/store.js

@@ -0,0 +1,100 @@
+import fs from "node:fs";
+import path from "node:path";
+import { config } from "../config.js";
+let CACHE_DIR = config.DTU_CACHE_DIR;
+let CACHES_FILE = path.join(CACHE_DIR, "caches.json");
+/** Override the cache directory at runtime (e.g. for ephemeral per-repo DTU instances). */
+export function setCacheDir(dir) {
+    CACHE_DIR = dir;
+    CACHES_FILE = path.join(dir, "caches.json");
+}
+export const state = {
+    jobs: new Map(),
+    // Per-runner job queue: runnerName → job payload (for multi-job concurrency)
+    runnerJobs: new Map(),
+    sessions: new Map(),
+    messageQueues: new Map(),
+    pendingPolls: new Map(),
+    logs: new Map(),
+    // Concurrency Maps
+    // runnerName -> logDirectory
+    runnerLogs: new Map(),
+    // runnerName -> timeline directory (CLI's _/logs/<runnerName>/)
+    runnerTimelineDirs: new Map(),
+    // sessionId -> runnerName
+    sessionToRunner: new Map(),
+    // recordId/logId -> sanitized step name (for per-step log files)
+    recordToStepName: new Map(),
+    // planId → log directory (for per-step files)
+    planToLogDir: new Map(),
+    // timelineId → runner log directory (for persisting timeline.json)
+    timelineToLogDir: new Map(),
+    // timelineId → sanitized name of the currently in-progress step
+    // (used as fallback when the feed recordId is a Job-level ID)
+    currentInProgressStep: new Map(),
+    // Substring patterns for cache keys that should always return a synthetic hit
+    // with an empty archive (e.g. "pnpm" for bind-mounted pnpm stores).
+    virtualCachePatterns: new Set(),
+    // cacheKey -> { version: string, archiveLocation: string, size: number }
+    caches: new Map(),
+    // cacheId (number) -> { tempPath: string, key: string, version: string }
+    pendingCaches: new Map(),
+    // artifactName -> { containerId: number, files: Map<itemPath, diskPath> }
+    artifacts: new Map(),
+    // containerId -> { name: string, files: Map<itemPath, diskPath> }
+    pendingArtifacts: new Map(),
+    isVirtualCacheKey(key) {
+        for (const pattern of this.virtualCachePatterns) {
+            if (key.includes(pattern)) {
+                return true;
+            }
+        }
+        return false;
+    },
+    loadCachesFromDisk() {
+        if (fs.existsSync(CACHES_FILE)) {
+            try {
+                const data = fs.readFileSync(CACHES_FILE, "utf-8");
+                const parsed = JSON.parse(data);
+                this.caches = new Map(Object.entries(parsed));
+            }
+            catch (e) {
+                console.warn("[DTU] Failed to load caches from disk:", e);
+            }
+        }
+    },
+    saveCachesToDisk() {
+        if (!fs.existsSync(CACHE_DIR)) {
+            fs.mkdirSync(CACHE_DIR, { recursive: true });
+        }
+        try {
+            const obj = Object.fromEntries(this.caches);
+            fs.writeFileSync(CACHES_FILE, JSON.stringify(obj, null, 2), "utf-8");
+        }
+        catch (e) {
+            console.warn("[DTU] Failed to save caches to disk:", e);
+        }
+    },
+    reset() {
+        this.jobs.clear();
+        this.runnerJobs.clear();
+        this.sessions.clear();
+        this.messageQueues.clear();
+        this.pendingPolls.clear();
+        this.logs.clear();
+        this.runnerLogs.clear();
+        this.runnerTimelineDirs.clear();
+        this.sessionToRunner.clear();
+        this.recordToStepName.clear();
+        this.planToLogDir.clear();
+        this.timelineToLogDir.clear();
+        this.currentInProgressStep.clear();
+        this.virtualCachePatterns.clear();
+        this.caches.clear();
+        this.pendingCaches.clear();
+        this.artifacts.clear();
+        this.pendingArtifacts.clear();
+    },
+};
+// Auto-load on startup
+state.loadCachesFromDisk();