jules-orchestrator-kit 0.29.0 → 0.31.0

package/src/ops/transaction.mjs

@@ -0,0 +1,278 @@
+import {
+  readFileSync,
+  mkdirSync,
+  existsSync,
+  unlinkSync,
+  renameSync,
+  openSync,
+  writeSync,
+  fsyncSync,
+  closeSync,
+} from "node:fs";
+import { join, dirname, resolve, relative, isAbsolute } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { createOperationReceipt } from "./receipts.mjs";
+import { withVfsMutex } from "../state.mjs";
+
+/**
+ * @typedef {import("../ux/capabilities.mjs").TerminalSessionOptions} TerminalSessionOptions
+ */
+
+/**
+ * Calculate file SHA-256 hash.
+ * @param {string} filePath
+ * @returns {string | null}
+ */
+function getFileHash(filePath) {
+  if (!existsSync(filePath)) return null;
+  try {
+    const data = readFileSync(filePath);
+    return "sha256:" + createHash("sha256").update(data).digest("hex");
+  } catch {
+    return null;
+  }
+}
+
+function resolveWithinRoot(root, candidate, label) {
+  if (typeof candidate !== "string" || !candidate || candidate.includes("\0")) {
+    throw new Error(`Invalid ${label} path`);
+  }
+  const targetPath = resolve(root, candidate);
+  const rel = relative(resolve(root), targetPath);
+  if (rel === ".." || rel.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) || isAbsolute(rel)) {
+    throw new Error(`${label} path escapes repository root: ${candidate}`);
+  }
+  return targetPath;
+}
+
+function atomicWriteFile(filePath, content) {
+  const tmpPath = `${filePath}.${randomUUID()}.tmp`;
+  let fd;
+  try {
+    fd = openSync(tmpPath, "wx", 0o600);
+    writeSync(fd, content, "utf-8");
+    fsyncSync(fd);
+    closeSync(fd);
+    fd = undefined;
+    renameSync(tmpPath, filePath);
+  } catch (err) {
+    if (fd !== undefined) {
+      try { closeSync(fd); } catch (_) {}
+    }
+    try { unlinkSync(tmpPath); } catch (_) {}
+    throw err;
+  }
+}
+
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw signal.reason || new Error("Action plan application aborted");
+  }
+}
+
+/**
+ * Verify preconditions of an ActionPlan against target repository state.
+ * @param {import("../ux/capabilities.mjs").ActionPlan} plan
+ * @param {string} root
+ */
+export function verifyPreconditions(plan, root) {
+  for (const cond of plan.preconditions || []) {
+    if (cond.kind === "file-hash") {
+      const targetPath = resolveWithinRoot(root, cond.target, "Precondition target");
+      const actualHash = getFileHash(targetPath);
+      if (actualHash !== cond.expected) {
+        throw new Error(
+          `Precondition failed [file-hash]: ${cond.target} expected ${cond.expected}, received ${actualHash}`
+        );
+      }
+    } else if (cond.kind === "lock-free") {
+      const lockTarget = String(cond.target || "");
+      const lockBase = resolveWithinRoot(root, join(".agent", "state", "locks", lockTarget), "Lock target");
+      const lockPaths = [`${lockBase}.json`, `${lockBase}.lock`];
+      if (lockPaths.some((lockPath) => existsSync(lockPath))) {
+        throw new Error(`Precondition failed [lock-free]: Lock ${cond.target} is active.`);
+      }
+    }
+  }
+}
+
+/**
+ * Execute an ActionPlan within a transactional boundaries (atomic apply + rollback).
+ * @param {any} plan
+ * @param {Object} options
+ * @param {string} options.root
+ * @param {AbortSignal} [options.signal]
+ * @returns {Promise<import("./receipts.mjs").OperationReceipt>}
+ */
+export async function applyActionPlan(plan, options = {}) {
+  const root = resolve(options.root || process.cwd());
+  const mutexDir = join(root, ".agent", "state", ".action-plan.mutex");
+  mkdirSync(dirname(mutexDir), { recursive: true });
+  return withVfsMutex(mutexDir, () => applyActionPlanLocked(plan, { ...options, root }));
+}
+
+async function applyActionPlanLocked(plan, options) {
+  const root = options.root;
+  const startTime = Date.now();
+  throwIfAborted(options.signal);
+
+  // 1. Verify Preconditions
+  verifyPreconditions(plan, root);
+
+  // 2. Prepare Intent Journaling
+  if (!plan || typeof plan.id !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(plan.id)) {
+    throw new Error("Invalid action plan id");
+  }
+  const journalDir = join(root, ".agent", "state", "journal");
+  if (!existsSync(journalDir)) {
+    mkdirSync(journalDir, { recursive: true });
+  }
+  const journalPath = join(journalDir, `${plan.id}.intent.json`);
+  atomicWriteFile(journalPath, JSON.stringify({ plan, startedAt: new Date().toISOString() }, null, 2));
+
+  /** @type {Array<{ path: string, originalContent: string | null, operation?: string, fromPath?: string, sourceContent?: string }>} */
+  const rollbackStack = [];
+  const mutationsApplied = [];
+  const effectsExecuted = [];
+
+  try {
+    // 3. Apply File Mutations
+    for (const mutation of plan.fileMutations || []) {
+      throwIfAborted(options.signal);
+      const targetPath = resolveWithinRoot(root, mutation.path, "Mutation target");
+
+      if (mutation.operation === "move") {
+        const sourcePath = resolveWithinRoot(root, mutation.fromPath, "Move source");
+        if (sourcePath === targetPath) {
+          throw new Error(`Move source and target are identical: ${mutation.path}`);
+        }
+        if (!existsSync(sourcePath)) {
+          throw new Error(`Move source does not exist: ${mutation.fromPath}`);
+        }
+        if (existsSync(targetPath)) {
+          throw new Error(`Move target already exists: ${mutation.path}`);
+        }
+        const sourceContent = readFileSync(sourcePath, "utf-8");
+        const sourceHash = "sha256:" + createHash("sha256").update(sourceContent).digest("hex");
+        mkdirSync(dirname(targetPath), { recursive: true });
+        rollbackStack.push({
+          path: targetPath,
+          originalContent: null,
+          operation: "move",
+          fromPath: sourcePath,
+          sourceContent,
+        });
+        renameSync(sourcePath, targetPath);
+        mutationsApplied.push({ path: mutation.path, operation: "move", hashBefore: sourceHash });
+        continue;
+      }
+
+      if (!["delete", "create", "replace"].includes(mutation.operation)) {
+        throw new Error(`Unsupported file mutation operation: ${mutation.operation}`);
+      }
+
+      const parentDir = dirname(targetPath);
+      if (!existsSync(parentDir)) {
+        mkdirSync(parentDir, { recursive: true });
+      }
+
+      const existingContent = existsSync(targetPath) ? readFileSync(targetPath, "utf-8") : null;
+      const hashBefore = existingContent !== null
+        ? "sha256:" + createHash("sha256").update(existingContent).digest("hex")
+        : undefined;
+
+      if (mutation.operation === "create" && existingContent !== null) {
+        throw new Error(`Create target already exists: ${mutation.path}`);
+      }
+      rollbackStack.push({ path: targetPath, originalContent: existingContent, operation: mutation.operation });
+
+      if (mutation.operation === "delete") {
+        if (existsSync(targetPath)) {
+          unlinkSync(targetPath);
+        }
+        mutationsApplied.push({ path: mutation.path, operation: "delete", hashBefore });
+      } else {
+        const newContent = mutation.newContent ?? "";
+        atomicWriteFile(targetPath, newContent);
+
+        const hashAfter = "sha256:" + createHash("sha256").update(newContent).digest("hex");
+        mutationsApplied.push({ path: mutation.path, operation: mutation.operation, hashBefore, hashAfter });
+      }
+    }
+
+    // 4. Execute Command Effects
+    for (const effect of plan.commandEffects || []) {
+      throwIfAborted(options.signal);
+      const execPath = effect.executable;
+      const args = Array.isArray(effect.args) ? effect.args : [];
+      const cwd = effect.cwd ? resolveWithinRoot(root, effect.cwd, "Command working directory") : root;
+
+      try {
+        execFileSync(execPath, args, {
+          cwd,
+          timeout: effect.timeoutMs || 30000,
+          env: process.env,
+        });
+        effectsExecuted.push({ executable: execPath, args, exitCode: 0 });
+      } catch (err) {
+        const exitCode = typeof err.status === "number" ? err.status : 1;
+        effectsExecuted.push({ executable: execPath, args, exitCode });
+        throw new Error(`Command effect failed (${execPath} ${args.join(" ")}): exit code ${exitCode}`);
+      }
+    }
+
+    // 5. Clean up Journal & Record Success Receipt
+    if (existsSync(journalPath)) {
+      unlinkSync(journalPath);
+    }
+
+    const receipt = createOperationReceipt(root, {
+      actionPlanId: plan.id,
+      kind: plan.kind,
+      title: plan.title,
+      repository: plan.repository || "local",
+      status: "success",
+      durationMs: Date.now() - startTime,
+      mutationsApplied,
+      effectsExecuted,
+    });
+
+    return receipt;
+  } catch (err) {
+    // Execute Rollback Stack in reverse order
+    for (let i = rollbackStack.length - 1; i >= 0; i--) {
+      const mutation = rollbackStack[i];
+      try {
+        if (mutation.operation === "move") {
+          if (existsSync(mutation.path) && !existsSync(mutation.fromPath)) {
+            renameSync(mutation.path, mutation.fromPath);
+          }
+        } else if (mutation.originalContent === null) {
+          if (existsSync(mutation.path)) unlinkSync(mutation.path);
+        } else {
+          atomicWriteFile(mutation.path, mutation.originalContent);
+        }
+      } catch {
+        // Best-effort rollback
+      }
+    }
+
+    if (existsSync(journalPath)) {
+      try { unlinkSync(journalPath); } catch (_) {}
+    }
+
+    const failedReceipt = createOperationReceipt(root, {
+      actionPlanId: plan.id,
+      kind: plan.kind,
+      title: plan.title,
+      repository: plan.repository || "local",
+      status: "rolled-back",
+      durationMs: Date.now() - startTime,
+      mutationsApplied,
+      effectsExecuted,
+    });
+
+    throw new Error(`Action plan execution failed and was rolled back: ${err.message}. Receipt: ${failedReceipt.receiptId}`);
+  }
+}

package/src/provider.mjs

@@ -1,4 +1,5 @@
 import { spawnSync } from "node:child_process";
+import { redactSecrets } from "./security.mjs";
 
 export const JULES_PRESET = {
   name: "jules",
@@ -73,7 +74,7 @@ export class ProviderSchemaError extends Error {
 export function parseRetryAfter(header) {
   if (!header) return null;
   const seconds = Number(header);
-  if (!isNaN(seconds)) {
+  if (Number.isFinite(seconds)) {
     return Math.max(0, Math.round(seconds * 1000));
   }
   const dateMs = Date.parse(header);
@@ -110,12 +111,20 @@ export function createProvider(spec = "jules", config = {}) {
   }
   const providerSpec = typeof spec === "string"
     ? (spec === "claude-code" ? CLAUDE_PRESET : spec === "codex" ? CODEX_PRESET : JULES_PRESET)
-    : spec;
+    : spec || JULES_PRESET;
+
+  if (!providerSpec || typeof providerSpec !== "object") {
+    throw new TypeError("Provider specification must be a string or object");
+  }
 
   return {
     name: providerSpec.name || "custom-provider",
 
-    async dispatch(task, ctx = {}) {
+    async dispatch(task = {}, ctx = {}) {
+      if (!task || typeof task !== "object") {
+        throw new TypeError("Provider task must be an object");
+      }
+      if (!ctx || typeof ctx !== "object") ctx = {};
       const rawToken = process.env.JULES_API_KEY || (ctx.allowLegacyKey ? process.env.GEMINI_API_KEY : "") || "";
       if (!rawToken && !ctx.dryRun && providerSpec.name === "jules") {
         throw new MissingApiKeyError();
@@ -195,7 +204,8 @@ export function createProvider(spec = "jules", config = {}) {
           body = JSON.stringify(bodyObj);
         }
 
-        const timeoutMs = ctx.timeoutMs || config.timeoutMs || providerSpec.timeoutMs || 120_000;
+        const requestedTimeout = Number(ctx.timeoutMs ?? config.timeoutMs ?? providerSpec.timeoutMs ?? 120_000);
+        const timeoutMs = Number.isFinite(requestedTimeout) && requestedTimeout > 0 ? requestedTimeout : 120_000;
         let res;
         try {
           res = await fetch(url, {
@@ -216,7 +226,7 @@ export function createProvider(spec = "jules", config = {}) {
         if (!res.ok) {
           const text = await res.text();
           const cleanText = text.slice(0, 500);
-          const sanitizedText = rawToken ? cleanText.split(rawToken).join("[REDACTED]") : cleanText;
+          const sanitizedText = redactSecrets(rawToken ? cleanText.split(rawToken).join("[REDACTED]") : cleanText);
           const retryAfterHeader = res.headers ? res.headers.get("retry-after") : null;
           const retryAfterMs = parseRetryAfter(retryAfterHeader);
 
@@ -282,7 +292,7 @@ export function createProvider(spec = "jules", config = {}) {
           throw new Error(`Provider Exec Failed: ${res.error.message}`);
         }
         if (res.status !== 0) {
-          const stderr = (res.stderr || "").slice(0, 500);
+          const stderr = redactSecrets((res.stderr || "").slice(0, 500));
           throw new Error(`Provider Exec Exit ${res.status}: ${stderr}`);
         }
 
@@ -301,6 +311,124 @@ export function createProvider(spec = "jules", config = {}) {
       if (providerSpec.type === "exec" && !providerSpec.command) return false;
       return true;
     },
+
+    async resume(sessionId, prompt = "", ctx = {}, task = null) {
+      if (!sessionId || typeof sessionId !== "string") {
+        throw new TypeError("resume() requires a valid sessionId string");
+      }
+      if (!ctx || typeof ctx !== "object") ctx = {};
+
+      const rawToken = process.env.JULES_API_KEY || (ctx.allowLegacyKey ? process.env.GEMINI_API_KEY : "") || "";
+      if (!rawToken && !ctx.dryRun && providerSpec.name === "jules") {
+        throw new MissingApiKeyError();
+      }
+
+      if (ctx.dryRun) {
+        return {
+          id: sessionId,
+          status: "pending",
+          resumed: true,
+          provider: providerSpec.name,
+          prompt: redactSecrets(prompt),
+        };
+      }
+
+      if (providerSpec.type === "http") {
+        const sendMessageUrlTemplate = providerSpec.sendMessageUrl || `${providerSpec.url}/${sessionId}:sendMessage`;
+        const urlData = { sessionId, token: rawToken, ...ctx };
+        const url = interpolateString(sendMessageUrlTemplate, urlData);
+
+        const headers = {};
+        for (const [k, v] of Object.entries(providerSpec.headers || {})) {
+          const val = interpolateString(v, urlData);
+          if (val.includes("\r") || val.includes("\n")) {
+            throw new Error(`CRITICAL: Header injection attempt detected in header "${k}"`);
+          }
+          headers[k] = val;
+        }
+
+        const bodyObj = { prompt: prompt };
+        const body = JSON.stringify(bodyObj);
+
+        const requestedTimeout = Number(ctx.timeoutMs ?? config.timeoutMs ?? providerSpec.timeoutMs ?? 120_000);
+        const timeoutMs = Number.isFinite(requestedTimeout) && requestedTimeout > 0 ? requestedTimeout : 120_000;
+        let res;
+        try {
+          res = await fetch(url, {
+            method: "POST",
+            headers,
+            body,
+            signal: AbortSignal.timeout(timeoutMs),
+          });
+        } catch (err) {
+          if (err.name === "TimeoutError" || err.name === "AbortError" || err.code === "ABORT_ERR") {
+            throw new ProviderUnavailableError(`Provider HTTP Timeout (${timeoutMs}ms): ${err.message}`, {
+              status: 504,
+            });
+          }
+          throw err;
+        }
+
+        if (!res.ok) {
+          const text = await res.text();
+          const cleanText = text.slice(0, 500);
+          const sanitizedText = redactSecrets(rawToken ? cleanText.split(rawToken).join("[REDACTED]") : cleanText);
+
+          // Fail-soft fallback: if remote session is closed/expired (400 or 404) and task object is available, fall back to cold dispatch
+          if ((res.status === 400 || res.status === 404) && task && typeof task === "object") {
+            const fallbackRes = await this.dispatch(task, { ...ctx, warmResumptionFailed: true });
+            return {
+              ...fallbackRes,
+              _warmFallback: true,
+              _warmErrorStatus: res.status,
+            };
+          }
+
+          const retryAfterHeader = res.headers ? res.headers.get("retry-after") : null;
+          const retryAfterMs = parseRetryAfter(retryAfterHeader);
+
+          if (res.status === 429) {
+            throw new ProviderRateLimitError(`Provider HTTP Error (429): ${sanitizedText}`, {
+              retryAfterMs: retryAfterMs ?? 60000,
+              status: 429,
+            });
+          }
+
+          if (res.status >= 500 && res.status < 600) {
+            throw new ProviderUnavailableError(`Provider HTTP Error (${res.status}): ${sanitizedText}`, {
+              status: res.status,
+              retryAfterMs: retryAfterMs ?? undefined,
+            });
+          }
+
+          const err = new Error(`Provider HTTP Error (${res.status}): ${sanitizedText}`);
+          err.status = res.status;
+          throw err;
+        }
+
+        let json;
+        try {
+          json = await res.json();
+        } catch (err) {
+          throw new ProviderSchemaError(`Provider Payload Error: Invalid JSON response: ${err.message}`, {
+            status: res.status,
+          });
+        }
+
+        return {
+          id: json.id || json.name || sessionId,
+          status: json.state || "active",
+          resumed: true,
+          raw: json,
+        };
+      }
+
+      if (providerSpec.type === "exec") {
+        return this.dispatch({ ...(task || {}), prompt }, ctx);
+      }
+
+      throw new Error(`Unsupported provider type: ${providerSpec.type}`);
+    },
   };
 }
 
@@ -332,7 +460,35 @@ export function createFailoverProvider(providers = ["jules"], config = {}) {
             err.status === 429;
 
           if (i === providerList.length - 1 || !isRecoverable) {
-            err._failoverErrors = errors;
+            if (err && typeof err === "object") {
+              err._failoverErrors = errors;
+            }
+            throw err;
+          }
+        }
+      }
+    },
+
+    async resume(sessionId, prompt, ctx = {}, task = null) {
+      const errors = [];
+      for (let i = 0; i < providerList.length; i++) {
+        const provider = providerList[i];
+        if (typeof provider.resume !== "function") continue;
+        try {
+          const res = await provider.resume(sessionId, prompt, ctx, task);
+          return { ...res, _routedProvider: provider.name, _failoverAttempts: i };
+        } catch (err) {
+          errors.push({ provider: provider.name, error: err });
+          const isRecoverable =
+            err instanceof ProviderRateLimitError ||
+            err instanceof ProviderUnavailableError ||
+            (err.status && err.status >= 500 && err.status < 600) ||
+            err.status === 429;
+
+          if (i === providerList.length - 1 || !isRecoverable) {
+            if (err && typeof err === "object") {
+              err._failoverErrors = errors;
+            }
             throw err;
           }
         }
@@ -340,7 +496,7 @@ export function createFailoverProvider(providers = ["jules"], config = {}) {
     },
 
     validate() {
-      return providerList.every((p) => p.validate());
+      return providerList.every((p) => typeof p.validate !== "function" || p.validate());
     },
   };
 }

package/src/security.mjs

@@ -1,4 +1,4 @@
-import { openSync, writeSync, fsyncSync, closeSync, renameSync, realpathSync, existsSync, lstatSync } from "node:fs";
+import { openSync, writeSync, fsyncSync, closeSync, renameSync, realpathSync, existsSync, lstatSync, unlinkSync } from "node:fs";
 import { dirname, join, basename } from "node:path";
 import { randomBytes } from "node:crypto";
 import { normalizePath } from "./config.mjs";
@@ -13,7 +13,7 @@ export const HIGH_CONFIDENCE_PATTERNS = [
 
   /\bAKIA[0-9A-Z]{16}\b/g,
   /\bASIA[0-9A-Z]{16}\b/g,
-  /\baws_secret_access_key\s*=\s*['"]?[A-Za-z0-9\/+=]{40}['"]?/g,
+  /\baws_secret_access_key\s*=\s*['"]?[A-Za-z0-9\/+=]{40}['"]?/gi,
 
   /-----BEGIN (?:RSA|DSA|EC|OPENSSH|PRIVATE)(?:\s+PRIVATE)? KEY-----[\s\S]*?-----END (?:RSA|DSA|EC|OPENSSH|PRIVATE)(?:\s+PRIVATE)? KEY-----/g,
   /PuTTY-User-Key-File-[0-9]:[^\n]+/g,
@@ -61,18 +61,26 @@ export function safeAtomicWrite(filePath, content, options = {}) {
   const dir = dirname(filePath);
   const tempFile = join(dir, `.tmp-${basename(filePath)}-${randomBytes(6).toString("hex")}`);
 
-  const fd = openSync(tempFile, "wx", mode);
+  let fd;
   try {
+    fd = openSync(tempFile, "wx", mode);
     writeSync(fd, content, null, encoding);
     if (options.sync !== false) {
       fsyncSync(fd);
     }
-  } finally {
     closeSync(fd);
+    fd = undefined;
+    renameSync(tempFile, filePath);
+    return true;
+  } catch (err) {
+    if (fd !== undefined) {
+      try { closeSync(fd); } catch (_) {}
+    }
+    try {
+      if (existsSync(tempFile)) unlinkSync(tempFile);
+    } catch (_) {}
+    throw err;
   }
-
-  renameSync(tempFile, filePath);
-  return true;
 }
 
 export function shannonEntropy(str) {

package/src/stack-detector.mjs

@@ -119,7 +119,10 @@ export function detectPolyglotStack(projectRoot = process.cwd()) {
     return { ...container, stack: "make", testCmd: "make test", buildCmd: "make build", triggerFile: "Makefile" };
   }
 
-  // 5. Python / Elixir / Ruby / Java
+  // 5. Python / Django / Elixir / Ruby / Java
+  if (existsSync(join(projectRoot, "manage.py"))) {
+    return { ...container, stack: "django", testCmd: "python manage.py test --keepdb", buildCmd: "python manage.py check", triggerFile: "manage.py" };
+  }
   if (existsSync(join(projectRoot, "pyproject.toml")) || existsSync(join(projectRoot, "requirements.txt")) || existsSync(join(projectRoot, "setup.py"))) {
     const triggerFile = existsSync(join(projectRoot, "pyproject.toml")) ? "pyproject.toml" : existsSync(join(projectRoot, "requirements.txt")) ? "requirements.txt" : "setup.py";
     return { ...container, stack: "python", testCmd: "pytest", buildCmd: "python3 -m compileall -q .", triggerFile };
@@ -138,14 +141,21 @@ export function detectPolyglotStack(projectRoot = process.cwd()) {
     return { ...container, stack: "gradle", testCmd: "./gradlew test", buildCmd: "./gradlew assemble", triggerFile };
   }
 
-  // 6. JS / TS Runtimes
+  // 6. JS / TS Runtimes & ORMs (Prisma, Drizzle)
+  let setupCmd = "";
+  if (existsSync(join(projectRoot, "prisma", "schema.prisma"))) {
+    setupCmd = "npx prisma db push --schema=prisma/schema.prisma";
+  } else if (existsSync(join(projectRoot, "drizzle.config.ts")) || existsSync(join(projectRoot, "drizzle.config.js"))) {
+    setupCmd = "npx drizzle-kit push";
+  }
+
   if (existsSync(join(projectRoot, "bunfig.toml")) || existsSync(join(projectRoot, "bun.lockb"))) {
     const triggerFile = existsSync(join(projectRoot, "bunfig.toml")) ? "bunfig.toml" : "bun.lockb";
-    return { ...container, stack: "bun", testCmd: "bun test", buildCmd: "bun run build", triggerFile };
+    return { ...container, stack: "bun", setupCmd, testCmd: "bun test", buildCmd: "bun run build", triggerFile };
   }
   if (existsSync(join(projectRoot, "deno.json")) || existsSync(join(projectRoot, "deno.jsonc"))) {
     const triggerFile = existsSync(join(projectRoot, "deno.json")) ? "deno.json" : "deno.jsonc";
-    return { ...container, stack: "deno", testCmd: "deno test", buildCmd: "deno task build", triggerFile };
+    return { ...container, stack: "deno", setupCmd, testCmd: "deno test", buildCmd: "deno task build", triggerFile };
   }
   if (existsSync(join(projectRoot, "package.json"))) {
     let testScript = "npm test";
@@ -161,7 +171,7 @@ export function detectPolyglotStack(projectRoot = process.cwd()) {
       testScript = "npm test";
       buildScript = "npm run build";
     }
-    return { ...container, stack: "node", testCmd: testScript, buildCmd: buildScript, triggerFile: "package.json" };
+    return { ...container, stack: "node", setupCmd, testCmd: testScript, buildCmd: buildScript, triggerFile: "package.json" };
   }
 
   // 7. .NET / C# / F# / PHP / Python root file extension fallback