dtu-github-actions 0.0.0 → 0.3.0

package/LICENSE

@@ -0,0 +1,110 @@
+# Functional Source License, Version 1.1, MIT Future License
+
+## Abbreviation
+
+FSL-1.1-MIT
+
+## Notice
+
+Copyright 2026 RedwoodJS Inc
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the MIT license that is effective on the second anniversary of the date we make
+the Software available. On or after that date, you may use the Software under
+the MIT license, in which case the following will apply:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/server/routes/actions/index.js

@@ -430,8 +430,39 @@ export function registerActionRoutes(app) {
             ...(req.query?.includeRecords ? { records } : {}),
         }));
     });
-    // 18. Generic Step Outputs Handler
+    // 18. Step Outputs Handler — capture outputs sent by the runner
     app.post("/_apis/distributedtask/hubs/:hub/plans/:planId/outputs", (req, res) => {
+        const planId = req.params.planId;
+        const payload = req.body || {};
+        // The runner posts step outputs as { stepId: { <name>: { value: <val> } } }
+        // Persist to the runner's log directory as outputs.json
+        const logDir = state.planToLogDir.get(planId);
+        if (logDir && payload && typeof payload === "object") {
+            try {
+                const outputsPath = path.join(logDir, "outputs.json");
+                // Merge with existing outputs
+                let existing = {};
+                try {
+                    existing = JSON.parse(fs.readFileSync(outputsPath, "utf-8"));
+                }
+                catch {
+                    /* no existing file */
+                }
+                // Flatten step outputs: { stepId: { name: { value: v } } } → { "stepId.name": v }
+                for (const [stepId, outputs] of Object.entries(payload)) {
+                    if (outputs && typeof outputs === "object") {
+                        for (const [name, meta] of Object.entries(outputs)) {
+                            const value = meta?.value ?? (typeof meta === "string" ? meta : "");
+                            existing[`${stepId}.${name}`] = value;
+                        }
+                    }
+                }
+                fs.writeFileSync(outputsPath, JSON.stringify(existing, null, 2));
+            }
+            catch {
+                /* best-effort */
+            }
+        }
         res.writeHead(200);
         res.end(JSON.stringify({ value: {} }));
     });
@@ -495,6 +526,8 @@ export function registerActionRoutes(app) {
         }
         const RUNNER_INTERNAL_RE = /^\[(?:RUNNER|WORKER) \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}Z (?:INFO|WARN|ERR)\s/;
         let content = "";
+        // Collect agent-ci-output lines for cross-job output passing
+        const outputEntries = [];
         for (const rawLine of lines) {
             const line = rawLine.trimEnd();
             if (!line) {
@@ -505,6 +538,15 @@ export function registerActionRoutes(app) {
             const stripped = line
                 .replace(/^\uFEFF?\d{4}-\d{2}-\d{2}T[\d:.]+Z\s*/, "")
                 .replace(/^\uFEFF/, "");
+            // Parse agent-ci-output lines: ::agent-ci-output::key=value
+            if (stripped.startsWith("::agent-ci-output::")) {
+                const kv = stripped.slice("::agent-ci-output::".length);
+                const eqIdx = kv.indexOf("=");
+                if (eqIdx > 0) {
+                    outputEntries.push([kv.slice(0, eqIdx), kv.slice(eqIdx + 1)]);
+                }
+                continue; // Don't include in regular step logs
+            }
             if (!stripped ||
                 stripped.startsWith("##[") ||
                 stripped.startsWith("[command]") ||
@@ -513,6 +555,26 @@ export function registerActionRoutes(app) {
             }
             content += stripped + "\n";
         }
+        // Persist captured outputs to outputs.json
+        if (outputEntries.length > 0) {
+            try {
+                const outputsPath = path.join(logDir, "outputs.json");
+                let existing = {};
+                try {
+                    existing = JSON.parse(fs.readFileSync(outputsPath, "utf-8"));
+                }
+                catch {
+                    /* no existing file */
+                }
+                for (const [key, value] of outputEntries) {
+                    existing[key] = value;
+                }
+                fs.writeFileSync(outputsPath, JSON.stringify(existing, null, 2));
+            }
+            catch {
+                /* best-effort */
+            }
+        }
         if (content) {
             try {
                 let stepName = state.recordToStepName.get(recordId);

package/dist/server/routes/dtu.js

@@ -23,13 +23,16 @@ export function registerDtuRoutes(app) {
                     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).
+                // Store the job for dispatch. Runner-targeted jobs go ONLY into runnerJobs
+                // to prevent other runners from stealing them via the generic pool fallback.
+                // Jobs without a runnerName go into the generic pool for any runner to pick up.
                 const runnerName = payload.runnerName;
-                state.jobs.set(jobId, jobPayload);
                 if (runnerName) {
                     state.runnerJobs.set(runnerName, jobPayload);
                 }
+                else {
+                    state.jobs.set(jobId, 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);

package/dist/server.test.js

@@ -136,6 +136,139 @@ describe("DTU Server", () => {
         const body = JSON.parse(pollRes.body.Body);
         expect(body.JobDisplayName).toBe("poll-job");
     });
+    it("should dispatch a job seeded AFTER polling begins (issue #47 race condition)", async () => {
+        const runnerName = "agent-ci-race-test";
+        // 1. Register the runner with the DTU (so sessionToRunner mapping exists)
+        await request("POST", "/_dtu/start-runner", {
+            runnerName,
+            logDir: "/tmp/agent-ci-race-test-logs",
+            timelineDir: "/tmp/agent-ci-race-test-logs",
+        });
+        // 2. Create a session as this runner
+        const sessionRes = await request("POST", "/_apis/distributedtask/pools/1/sessions", {
+            agent: { name: runnerName },
+        });
+        const sessionId = sessionRes.body.sessionId;
+        expect(sessionRes.status).toBe(200);
+        // 3. Start the long-poll — this will block for up to 20s waiting for a job.
+        //    The runner arrives BEFORE the job is seeded, exactly reproducing the race.
+        const pollPromise = request("GET", `/_apis/distributedtask/pools/1/messages?sessionId=${sessionId}`);
+        // 4. Give the event loop a tick so the poll handler registers in pendingPolls
+        await new Promise((r) => setTimeout(r, 50));
+        // 5. Now seed a job targeted at this runner — the seed handler should
+        //    find the pending poll and dispatch immediately.
+        const seedRes = await request("POST", "/_dtu/seed", {
+            id: 999,
+            name: "race-test-job",
+            runnerName,
+        });
+        expect(seedRes.status).toBe(201);
+        // 6. The poll should resolve almost instantly with the job (200),
+        //    NOT after the 20s timeout (204).
+        const pollRes = await pollPromise;
+        expect(pollRes.status).toBe(200);
+        expect(pollRes.body.MessageType).toBe("PipelineAgentJobRequest");
+        const body = JSON.parse(pollRes.body.Body);
+        expect(body.JobDisplayName).toBe("race-test-job");
+    }, 10_000);
+    it("should dispatch jobs to 8 concurrent runners seeded after polling (--all mode stress)", async () => {
+        const RUNNER_COUNT = 8;
+        const runners = [];
+        // 1. Register and create sessions for all runners
+        for (let i = 0; i < RUNNER_COUNT; i++) {
+            const name = `agent-ci-stress-${i + 1}`;
+            await request("POST", "/_dtu/start-runner", {
+                runnerName: name,
+                logDir: `/tmp/agent-ci-stress-${i + 1}-logs`,
+                timelineDir: `/tmp/agent-ci-stress-${i + 1}-logs`,
+            });
+            const sessionRes = await request("POST", "/_apis/distributedtask/pools/1/sessions", {
+                agent: { name },
+            });
+            runners.push({ name, sessionId: sessionRes.body.sessionId });
+        }
+        // 2. Start all polls concurrently — all runners are waiting before any job is seeded
+        const pollPromises = runners.map((r) => request("GET", `/_apis/distributedtask/pools/1/messages?sessionId=${r.sessionId}`));
+        // 3. Let the polls register in pendingPolls
+        await new Promise((r) => setTimeout(r, 100));
+        // 4. Seed all jobs with staggered timing (simulating concurrent executeLocalJob calls)
+        for (let i = 0; i < RUNNER_COUNT; i++) {
+            await request("POST", "/_dtu/seed", {
+                id: 2000 + i,
+                name: `stress-job-${i + 1}`,
+                runnerName: runners[i].name,
+            });
+            // Small stagger like real concurrent CLI calls
+            if (i < RUNNER_COUNT - 1) {
+                await new Promise((r) => setTimeout(r, 5));
+            }
+        }
+        // 5. ALL polls should resolve with 200 (their specific job), not 204
+        const pollResults = await Promise.all(pollPromises);
+        for (let i = 0; i < RUNNER_COUNT; i++) {
+            expect(pollResults[i].status).toBe(200);
+            expect(pollResults[i].body.MessageType).toBe("PipelineAgentJobRequest");
+            const body = JSON.parse(pollResults[i].body.Body);
+            expect(body.JobDisplayName).toBe(`stress-job-${i + 1}`);
+        }
+    }, 15_000);
+    it("should NOT let runner B steal runner A's job from the generic pool (issue #47)", async () => {
+        // This reproduces the core race in --all mode:
+        // 1. Job for runner A is seeded
+        // 2. Runner B creates a session and polls BEFORE its own job is seeded
+        // 3. BUG: Runner B falls through to the generic state.jobs pool and steals A's job
+        // 4. Runner B's actual job arrives later, but A's real runner never gets its job
+        const runnerA = "agent-ci-runner-A";
+        const runnerB = "agent-ci-runner-B";
+        // Register both runners
+        await request("POST", "/_dtu/start-runner", {
+            runnerName: runnerA,
+            logDir: "/tmp/agent-ci-A-logs",
+            timelineDir: "/tmp/agent-ci-A-logs",
+        });
+        await request("POST", "/_dtu/start-runner", {
+            runnerName: runnerB,
+            logDir: "/tmp/agent-ci-B-logs",
+            timelineDir: "/tmp/agent-ci-B-logs",
+        });
+        // Seed runner A's job
+        await request("POST", "/_dtu/seed", {
+            id: 3001,
+            name: "job-for-A",
+            runnerName: runnerA,
+        });
+        // Runner B creates a session and polls — its job hasn't been seeded yet.
+        const sessionB = await request("POST", "/_apis/distributedtask/pools/1/sessions", {
+            agent: { name: runnerB },
+        });
+        const pollBPromise = request("GET", `/_apis/distributedtask/pools/1/messages?sessionId=${sessionB.body.sessionId}`);
+        // Wait 200ms — if B stole A's job, the poll would have resolved instantly.
+        let pollBResolved = false;
+        pollBPromise.then(() => {
+            pollBResolved = true;
+        });
+        await new Promise((r) => setTimeout(r, 200));
+        expect(pollBResolved).toBe(false); // B should still be long-polling, NOT holding A's job
+        // Now seed runner B's actual job — this unblocks B's long-poll via notify-on-seed
+        await request("POST", "/_dtu/seed", {
+            id: 3002,
+            name: "job-for-B",
+            runnerName: runnerB,
+        });
+        // B should now receive its own job
+        const pollB = await pollBPromise;
+        expect(pollB.status).toBe(200);
+        const bodyB = JSON.parse(pollB.body.Body);
+        expect(bodyB.JobDisplayName).toBe("job-for-B");
+        // Runner A should still get its own job (not stolen)
+        const sessionA = await request("POST", "/_apis/distributedtask/pools/1/sessions", {
+            agent: { name: runnerA },
+        });
+        const pollA = await request("GET", `/_apis/distributedtask/pools/1/messages?sessionId=${sessionA.body.sessionId}`);
+        expect(pollA.status).toBe(200);
+        const bodyA = JSON.parse(pollA.body.Body);
+        expect(bodyA.JobDisplayName).toBe("job-for-A");
+    }, 10_000);
     it("should log unhandled requests to 404.log", async () => {
         const logDir = path.dirname(getDtuLogPath());
         const logFile = path.join(logDir, "404.log");

package/package.json

@@ -1,10 +1,15 @@
 {
   "name": "dtu-github-actions",
-  "version": "0.0.0",
+  "version": "0.3.0",
   "description": "Digital Twin Universe - GitHub Actions Mock and Simulation",
   "keywords": [],
   "license": "FSL-1.1-MIT",
   "author": "",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/redwoodjs/agent-ci.git",
+    "directory": "packages/dtu-github-actions"
+  },
   "files": [
     "dist",
     "README.md"
@@ -18,13 +23,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "dev": "(pnpm dlx kill-port 8910 || true) && tsx src/server/start.ts",
-    "simulate": "tsx src/simulate.ts",
-    "build": "tsgo",
-    "typecheck": "tsgo",
-    "test": "vitest run"
-  },
   "dependencies": {
     "body-parser": "^2.2.2",
     "jsonc-parser": "^3.3.1",
@@ -39,5 +37,12 @@
     "execa": "^9.6.1",
     "tsx": "^4.19.2",
     "vitest": "^4.0.18"
+  },
+  "scripts": {
+    "dev": "(pnpm dlx kill-port 8910 || true) && tsx src/server/start.ts",
+    "simulate": "tsx src/simulate.ts",
+    "build": "tsgo",
+    "typecheck": "tsgo",
+    "test": "vitest run"
   }
-}
+}