dtu-github-actions 0.7.0 → 0.7.1

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

@@ -173,11 +173,15 @@ export function createJobResponse(jobId, payload, baseUrl, planId) {
         "build.repository.name": { Value: repoFullName, IsSecret: false },
         "build.repository.uri": { Value: `https://github.com/${repoFullName}`, IsSecret: false },
     };
-    // Merge all step-level env: vars into the job Variables.
+    // Merge job-level env: into Variables first, then step-level env: (step wins on conflict).
     // The runner exports every Variable as a process env var for all steps, so this is the
-    // reliable mechanism to get DB_HOST=mysql, DB_PORT=3306 etc. into the step subprocess.
-    // (Step-scoped env would require full template compilation; job-level Variables are sufficient
-    //  for DB credentials / CI flags that are consistent across steps.)
+    // reliable mechanism to get AGENT_CI_LOCAL, DB_HOST, DB_PORT etc. into the step subprocess
+    // and into the runner's expression engine (${{ env.AGENT_CI_LOCAL }}).
+    if (payload.env && typeof payload.env === "object") {
+        for (const [key, val] of Object.entries(payload.env)) {
+            Variables[key] = { Value: String(val), IsSecret: false };
+        }
+    }
     for (const step of payload.steps || []) {
         if (step.Env && typeof step.Env === "object") {
             for (const [key, val] of Object.entries(step.Env)) {
@@ -214,14 +218,15 @@ export function createJobResponse(jobId, payload, baseUrl, planId) {
             },
         };
     }
-    // Collect env vars from all steps (job-level env context seen by the runner's expression engine).
-    // Step-level `env:` blocks in the workflow YAML need to be exposed via ContextData.env so the
-    // runner can evaluate them. We merge all step envs — slightly broader than per-step scoping but
-    // correct for typical use (DB_HOST, DB_PORT, CI flags etc.).
-    const mergedStepEnv = {};
+    // Collect env vars from job-level and all steps (seen by the runner's expression engine).
+    // Job-level env is applied first, then step-level env wins on conflict.
+    const mergedEnv = {};
+    if (payload.env && typeof payload.env === "object") {
+        Object.assign(mergedEnv, payload.env);
+    }
     for (const step of payload.steps || []) {
         if (step.Env) {
-            Object.assign(mergedStepEnv, step.Env);
+            Object.assign(mergedEnv, step.Env);
         }
     }
     const ContextData = {
@@ -230,9 +235,9 @@ export function createJobResponse(jobId, payload, baseUrl, planId) {
         needs: { t: 2, d: [] }, // Empty needs context
         strategy: { t: 2, d: [] }, // Empty strategy context
         matrix: { t: 2, d: [] }, // Empty matrix context
-        // env context: merged from all step-level env: blocks so the runner's expression engine
-        // can substitute ${{ env.DB_HOST }} etc. during step execution.
-        ...(Object.keys(mergedStepEnv).length > 0 ? { env: toContextData(mergedStepEnv) } : {}),
+        // env context: merged from job-level + step-level env: blocks so the runner's expression
+        // engine can substitute ${{ env.AGENT_CI_LOCAL }}, ${{ env.DB_HOST }} etc.
+        ...(Object.keys(mergedEnv).length > 0 ? { env: toContextData(mergedEnv) } : {}),
     };
     const generatedJobId = crypto.randomUUID();
     const mockToken = createMockJwt(planId, generatedJobId);
@@ -303,7 +308,7 @@ export function createJobResponse(jobId, payload, baseUrl, planId) {
         // EnvironmentVariables is IList<TemplateToken> in the runner — each element is a MappingToken.
         // The runner evaluates each MappingToken and merges into Global.EnvironmentVariables (last wins),
         // which then populates ExpressionValues["env"] → subprocess env vars.
-        EnvironmentVariables: Object.keys(mergedStepEnv).length > 0 ? [toTemplateTokenMapping(mergedStepEnv)] : [],
+        EnvironmentVariables: Object.keys(mergedEnv).length > 0 ? [toTemplateTokenMapping(mergedEnv)] : [],
     };
     return {
         MessageId: 1,

package/dist/server/routes/actions/generators.test.d.ts

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

package/dist/server/routes/actions/generators.test.js

@@ -0,0 +1,71 @@
+import { describe, it, expect } from "vitest";
+import { createJobResponse } from "./generators.js";
+describe("createJobResponse", () => {
+    const basePayload = {
+        id: "1",
+        name: "test-job",
+        githubRepo: "owner/repo",
+        steps: [],
+    };
+    it("propagates job-level env into Variables", () => {
+        const payload = {
+            ...basePayload,
+            env: { AGENT_CI_LOCAL: "true", MY_VAR: "hello" },
+        };
+        const response = createJobResponse("1", payload, "http://localhost:3000", "plan-1");
+        const body = JSON.parse(response.Body);
+        const vars = body.Variables;
+        expect(vars.AGENT_CI_LOCAL).toEqual({ Value: "true", IsSecret: false });
+        expect(vars.MY_VAR).toEqual({ Value: "hello", IsSecret: false });
+    });
+    it("propagates job-level env into ContextData.env", () => {
+        const payload = {
+            ...basePayload,
+            env: { AGENT_CI_LOCAL: "true" },
+        };
+        const response = createJobResponse("1", payload, "http://localhost:3000", "plan-1");
+        const body = JSON.parse(response.Body);
+        // ContextData.env should be a ContextData object with type 2 (mapping)
+        expect(body.ContextData.env).toBeDefined();
+        expect(body.ContextData.env.t).toBe(2);
+        const entries = body.ContextData.env.d;
+        const localEntry = entries.find((e) => e.k === "AGENT_CI_LOCAL");
+        expect(localEntry).toBeDefined();
+        expect(localEntry.v).toEqual({ t: 0, s: "true" });
+    });
+    it("propagates job-level env into EnvironmentVariables", () => {
+        const payload = {
+            ...basePayload,
+            env: { AGENT_CI_LOCAL: "true" },
+        };
+        const response = createJobResponse("1", payload, "http://localhost:3000", "plan-1");
+        const body = JSON.parse(response.Body);
+        expect(body.EnvironmentVariables).toHaveLength(1);
+        const mapping = body.EnvironmentVariables[0];
+        expect(mapping.type).toBe(2);
+        const entry = mapping.map.find((e) => e.Key === "AGENT_CI_LOCAL");
+        expect(entry).toBeDefined();
+        expect(entry.Value).toBe("true");
+    });
+    it("step-level env overrides job-level env on conflict", () => {
+        const payload = {
+            ...basePayload,
+            env: { SHARED: "from-job" },
+            steps: [{ name: "step1", run: "echo hi", Env: { SHARED: "from-step" } }],
+        };
+        const response = createJobResponse("1", payload, "http://localhost:3000", "plan-1");
+        const body = JSON.parse(response.Body);
+        // Variables should have the step-level value (last-write wins)
+        expect(body.Variables.SHARED).toEqual({ Value: "from-step", IsSecret: false });
+        // ContextData.env should also have the step-level value
+        const entries = body.ContextData.env.d;
+        const entry = entries.find((e) => e.k === "SHARED");
+        expect(entry.v).toEqual({ t: 0, s: "from-step" });
+    });
+    it("omits env from ContextData when no env is provided", () => {
+        const response = createJobResponse("1", basePayload, "http://localhost:3000", "plan-1");
+        const body = JSON.parse(response.Body);
+        expect(body.ContextData.env).toBeUndefined();
+        expect(body.EnvironmentVariables).toEqual([]);
+    });
+});

package/dist/server.test.js

@@ -439,6 +439,51 @@ describe("Artifact v4 upload/download", () => {
         expect(res.body.lockedUntil).toBeDefined();
         expect(new Date(res.body.lockedUntil).getTime()).toBeGreaterThan(Date.now());
     });
+    it("should let runner B steal runner A's job when seeded WITHOUT runnerName (generic pool bug)", async () => {
+        // REPRODUCTION for issue #103:
+        // When local-job.ts seeds a job without setting runnerName, the job lands
+        // in the generic state.jobs pool. If another runner (from a different
+        // concurrent workflow) polls before runner A, it steals the job — causing
+        // runner A to hang forever waiting for a job that will never arrive.
+        const runnerA = "agent-ci-repro-A";
+        const runnerB = "agent-ci-repro-B";
+        // Register both runners
+        await request("POST", "/_dtu/start-runner", {
+            runnerName: runnerA,
+            logDir: "/tmp/agent-ci-repro-A-logs",
+            timelineDir: "/tmp/agent-ci-repro-A-logs",
+        });
+        await request("POST", "/_dtu/start-runner", {
+            runnerName: runnerB,
+            logDir: "/tmp/agent-ci-repro-B-logs",
+            timelineDir: "/tmp/agent-ci-repro-B-logs",
+        });
+        // Seed a job intended for runner A, but WITHOUT runnerName (the bug).
+        // This goes into the generic state.jobs pool.
+        await request("POST", "/_dtu/seed", {
+            id: 4001,
+            name: "job-intended-for-A",
+            // BUG: no runnerName — job lands in generic pool
+        });
+        // Runner B creates a session and polls — it shouldn't get A's job,
+        // but because the job is in the generic pool, B steals it.
+        const sessionB = await request("POST", "/_apis/distributedtask/pools/1/sessions", {
+            agent: { name: runnerB },
+        });
+        const pollB = await request("GET", `/_apis/distributedtask/pools/1/messages?sessionId=${sessionB.body.sessionId}`);
+        // BUG CONFIRMED: runner B stole the job from the generic pool
+        expect(pollB.status).toBe(200);
+        const bodyB = JSON.parse(pollB.body.Body);
+        expect(bodyB.JobDisplayName).toBe("job-intended-for-A");
+        // Now runner A creates a session and polls — the job is gone
+        await request("POST", "/_apis/distributedtask/pools/1/sessions", {
+            agent: { name: runnerA },
+        });
+        // Runner A's poll will hang (long-poll timeout) because its job was stolen.
+        // We verify by checking state: no jobs remain for A.
+        const aHasJob = state.runnerJobs.has(runnerA) || state.jobs.size > 0;
+        expect(aHasJob).toBe(false); // A's job is gone — it will hang forever
+    }, 10_000);
     it("should handle job request finish (PATCH with result + finishTime)", async () => {
         const finishTime = new Date().toISOString();
         const res = await request("PATCH", "/_apis/distributedtask/jobrequests", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dtu-github-actions",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Digital Twin Universe - GitHub Actions Mock and Simulation",
   "keywords": [
     "ci",