@skyramp/mcp 0.4.1 → 0.4.2-rc.2

package/build/utils/branchDiff.js

@@ -11,7 +11,12 @@ export function parseDiffEntries(rawDiff) {
             // An unreadable header still ENDS the previous block, or its `/dev/null`
             // and `@@` lines are credited to the entry before it.
             if (path === undefined) {
-                entries.push({ path: "", isNew: false, isDeleted: false, hasHunks: false });
+                entries.push({
+                    path: "",
+                    isNew: false,
+                    isDeleted: false,
+                    hasHunks: false,
+                });
                 continue;
             }
             entries.push({ path, isNew: false, isDeleted: false, hasHunks: false });
@@ -29,7 +34,8 @@ export function parseDiffEntries(rawDiff) {
         // A binary block has no `--- `/`+++ ` lines; git folds both into this one.
         else if (line.startsWith("Binary files /dev/null and "))
             current.isNew = true;
-        else if (line.startsWith("Binary files ") && line.endsWith(" and /dev/null differ"))
+        else if (line.startsWith("Binary files ") &&
+            line.endsWith(" and /dev/null differ"))
             current.isDeleted = true;
         // Unquoted like the new-path side, or one rename's two halves disagree.
         else if (line.startsWith("rename from "))
@@ -47,7 +53,9 @@ export function diffBlocksByPath(rawDiff) {
         // ANY `diff ` header ends a block, not just `diff --git`: a combined diff
         // writes `diff --cc`, and its lines would otherwise append to the file before.
         if (line.startsWith("diff ")) {
-            const path = line.startsWith("diff --git ") ? parseDiffHeaderPath(line) : undefined;
+            const path = line.startsWith("diff --git ")
+                ? parseDiffHeaderPath(line)
+                : undefined;
             if (path === undefined) {
                 current = undefined;
                 continue;
@@ -91,13 +99,21 @@ function parseDiffHeaderPath(line) {
  *  really contains a backslash. */
 export function unquoteIfQuoted(value) {
     const trimmed = value.trim();
-    return trimmed.startsWith('"') && trimmed.endsWith('"') ? unquoteGitPath(trimmed) : trimmed;
+    return trimmed.startsWith('"') && trimmed.endsWith('"')
+        ? unquoteGitPath(trimmed)
+        : trimmed;
 }
 /** Undo git's C-style quoting. A non-ASCII character arrives as one `\NNN` escape
  *  per UTF-8 BYTE, so the bytes are decoded once at the end. */
 export function unquoteGitPath(value) {
     const trimmed = value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value;
-    const simple = { n: "\n", t: "\t", r: "\r", '"': '"', "\\": "\\" };
+    const simple = {
+        n: "\n",
+        t: "\t",
+        r: "\r",
+        '"': '"',
+        "\\": "\\",
+    };
     const bytes = [];
     for (let i = 0; i < trimmed.length; i++) {
         if (trimmed[i] !== "\\") {
@@ -105,7 +121,9 @@ export function unquoteGitPath(value) {
             continue;
         }
         const next = trimmed[++i];
-        if (next !== undefined && /[0-7]/.test(next) && /^[0-7]{3}$/.test(trimmed.slice(i, i + 3))) {
+        if (next !== undefined &&
+            /[0-7]/.test(next) &&
+            /^[0-7]{3}$/.test(trimmed.slice(i, i + 3))) {
             bytes.push(parseInt(trimmed.slice(i, i + 3), 8));
             i += 2;
             continue;
@@ -126,10 +144,14 @@ export function parseNewAndDeletedFiles(rawDiff) {
         .filter((path) => path !== undefined);
     // An unreadable header yields `""`, which would read as a file nobody added.
     return {
-        newFiles: entries.filter((entry) => entry.isNew && entry.path).map((entry) => entry.path),
+        newFiles: entries
+            .filter((entry) => entry.isNew && entry.path)
+            .map((entry) => entry.path),
         // Keyed by the NEW path, so the OLD one is added here: it moved, not died.
         deletedFiles: [
-            ...entries.filter((entry) => entry.isDeleted && entry.path).map((entry) => entry.path),
+            ...entries
+                .filter((entry) => entry.isDeleted && entry.path)
+                .map((entry) => entry.path),
             ...renamedFromPaths,
         ].filter(Boolean),
     };
@@ -172,13 +194,20 @@ function addedPaths(raw) {
  *  failure. */
 async function tryNameStatus(git, ref, includeUncommitted) {
     try {
-        const raw = await git.diff([includeUncommitted ? ref : `${ref}...HEAD`, "--name-status"]);
+        const raw = await git.diff([
+            includeUncommitted ? ref : `${ref}...HEAD`,
+            "--name-status",
+        ]);
         const files = parseNameStatus(raw);
         return {
-            changedFiles: files.filter((file) => !file.deleted).map((file) => file.path),
+            changedFiles: files
+                .filter((file) => !file.deleted)
+                .map((file) => file.path),
             // `--name-status` marks an added path `A`; the header parser never runs here.
             newFiles: addedPaths(raw),
-            deletedFiles: files.filter((file) => file.deleted).map((file) => file.path),
+            deletedFiles: files
+                .filter((file) => file.deleted)
+                .map((file) => file.path),
         };
     }
     catch {
@@ -342,7 +371,13 @@ namesOnly = false) {
                     baseBranch: ref,
                     changedFiles: result.changedFiles.length,
                 });
-                return { currentBranch, baseBranch: ref, diffContent: "", diffStat: "", ...result };
+                return {
+                    currentBranch,
+                    baseBranch: ref,
+                    diffContent: "",
+                    diffStat: "",
+                    ...result,
+                };
             }
             logger.debug(`Name-status against ${ref} failed, trying next candidate`);
         }

package/build/utils/canonicalJson.js

@@ -12,6 +12,8 @@ export function isPlainObject(value) {
  *  those reads as equal. */
 export function canonicalJson(value) {
     return JSON.stringify(value, (_key, entry) => isPlainObject(entry)
-        ? Object.fromEntries(Object.keys(entry).sort().map((key) => [key, entry[key]]))
+        ? Object.fromEntries(Object.keys(entry)
+            .sort()
+            .map((key) => [key, entry[key]]))
         : entry);
 }

package/build/utils/connectionErrors.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The one place a connection-level failure is spelled. Three callers match these
+ * and each reads them for its own purpose — a transient MCP error, an executor
+ * retry, and the drift prompt's "the application was unreachable" verdict — so
+ * they are kept here rather than written out three times and drifting apart.
+ */
+/** Refused, reset, or the socket dropped mid-request. */
+export declare const CONNECTION_DROPPED: RegExp;
+/** The application never answered in time. */
+export declare const CONNECTION_TIMED_OUT: RegExp;

package/build/utils/connectionErrors.js

@@ -0,0 +1,10 @@
+/**
+ * The one place a connection-level failure is spelled. Three callers match these
+ * and each reads them for its own purpose — a transient MCP error, an executor
+ * retry, and the drift prompt's "the application was unreachable" verdict — so
+ * they are kept here rather than written out three times and drifting apart.
+ */
+/** Refused, reset, or the socket dropped mid-request. */
+export const CONNECTION_DROPPED = /\bECONNREFUSED\b|\bECONNRESET\b|\bconnection refused\b|\bconnection reset\b|\bsocket hang up\b/i;
+/** The application never answered in time. */
+export const CONNECTION_TIMED_OUT = /\bETIMEDOUT\b|\bDEADLINE_EXCEEDED\b|\bconnect(?:ion)? timed? ?out\b/i;

package/build/utils/dartRouteExtractor.js

@@ -20,8 +20,19 @@ import { collectFiles } from "./fileWalk.js";
 const MAX_CANDIDATE_FILES = 200;
 const MAX_WALK_DEPTH = 10;
 const SKIP_DIRS = new Set([
-    "build", ".dart_tool", ".git", ".idea", "android", "ios", "macos", "linux",
-    "windows", "web", "node_modules", "test", ".pub-cache",
+    "build",
+    ".dart_tool",
+    ".git",
+    ".idea",
+    "android",
+    "ios",
+    "macos",
+    "linux",
+    "windows",
+    "web",
+    "node_modules",
+    "test",
+    ".pub-cache",
 ]);
 /**
  * A `GoRoute(` through its `path:` string literal. The lazy `[\s\S]*?` scans
@@ -36,11 +47,29 @@ const SCREEN_WIDGET_REGEX = /\b([A-Z][A-Za-z0-9_]*)\s*\(/g;
 const IMPORT_REGEX = /^\s*import\s+['"]([^'"]+)['"]/gm;
 /** Identifiers that are never a screen: Flutter and go_router internals. */
 const NON_SCREEN_IDENTIFIERS = new Set([
-    "BuildContext", "GoRouterState", "GoRoute", "GoRouter", "ShellRoute",
-    "StatefulShellRoute", "ShellRouteBase", "MaterialPage", "CupertinoPage",
-    "CustomTransitionPage", "FadeTransitionPage", "Page", "Widget", "Key",
-    "ValueKey", "LocalKey", "Future", "Animation", "Duration",
-    "MaterialApp", "CupertinoApp", "Scaffold", "AppBar",
+    "BuildContext",
+    "GoRouterState",
+    "GoRoute",
+    "GoRouter",
+    "ShellRoute",
+    "StatefulShellRoute",
+    "ShellRouteBase",
+    "MaterialPage",
+    "CupertinoPage",
+    "CustomTransitionPage",
+    "FadeTransitionPage",
+    "Page",
+    "Widget",
+    "Key",
+    "ValueKey",
+    "LocalKey",
+    "Future",
+    "Animation",
+    "Duration",
+    "MaterialApp",
+    "CupertinoApp",
+    "Scaffold",
+    "AppBar",
 ]);
 export function extractDartRoutes(repositoryPath) {
     const routes = [];

package/build/utils/fixAttempts.d.ts

@@ -0,0 +1,26 @@
+export declare const MAX_FIX_ATTEMPTS_ENV = "SKYRAMP_MAX_FIX_ATTEMPTS";
+export declare const DEFAULT_MAX_FIX_ATTEMPTS = 3;
+export declare const MIN_MAX_FIX_ATTEMPTS = 1;
+export declare const MAX_MAX_FIX_ATTEMPTS = 10;
+/**
+ * Parse a prompt or resource argument for the cap. A number, or a string that is
+ * a whole decimal integer, in range, is returned; anything else — another type,
+ * `8abc`, `1e1`, `0`, `12` — reads as unset, so both entry points fall through to
+ * the environment and the default the same way instead of one of them rejecting
+ * the call. Range is applied here too, so a zod `.min/.max` on the result never
+ * sees a value it would refuse.
+ */
+export declare function parseMaxFixAttemptsArg(raw: unknown, source?: string): number | undefined;
+/**
+ * Resolve the cap from an explicit request, the environment, and the default.
+ * Pure apart from the warning log: `env` is injectable for tests and defaults
+ * to `process.env`.
+ */
+export declare function resolveMaxFixAttempts(requested?: number, env?: NodeJS.ProcessEnv): number;
+export declare function setMaxFixAttempts(value: number): void;
+/** The cap the current prompt render resolved, else the environment, else the
+ *  default. Only a seed for the per-run pin: the execute tool reads the pinned
+ *  value first and enforces nothing when there is no run state at all. */
+export declare function getMaxFixAttempts(): number;
+/** Test seam. */
+export declare function resetMaxFixAttemptsForTests(): void;

package/build/utils/fixAttempts.js

@@ -0,0 +1,109 @@
+/**
+ * The per-file execution attempt cap for the testbot fix-and-rerun loop
+ * (SKYR-4460).
+ *
+ * One number, resolved in one place: how many final-phase ("after")
+ * `skyramp_execute_test` runs a single test file may receive — the first run
+ * plus the fix-and-rerun iterations that follow a fixable failure.
+ *
+ * How the number travels: the testbot prompt resolves it (URI/prompt argument,
+ * then `SKYRAMP_MAX_FIX_ATTEMPTS`, then the default), states it in the rendered
+ * text, and records it here for the process. The first `skyramp_execute_test`
+ * call of the run with run state (the `stateFile` argument, else the run's own
+ * file) pins the recorded value at the state ROOT (`maxFixAttempts`, run-wide
+ * across every repository section, carried through later root rewrites), and
+ * every later call enforces the pinned value — so a later prompt render cannot
+ * change a run's cap, and the tool always enforces the number its prompt
+ * stated. Only a call with no run at all has nothing to count against and
+ * enforces nothing.
+ *
+ * Precedence: the value the caller passed, then the environment, then the
+ * default. A value outside [MIN, MAX] or not a whole number is treated as unset
+ * at each step, and a non-empty rejected spelling is logged so an operator who
+ * set `0` or `20` can see it was not applied.
+ */
+import { logger } from "./logger.js";
+export const MAX_FIX_ATTEMPTS_ENV = "SKYRAMP_MAX_FIX_ATTEMPTS";
+export const DEFAULT_MAX_FIX_ATTEMPTS = 3;
+export const MIN_MAX_FIX_ATTEMPTS = 1;
+export const MAX_MAX_FIX_ATTEMPTS = 10;
+function inRange(value) {
+    return (Number.isInteger(value) &&
+        value >= MIN_MAX_FIX_ATTEMPTS &&
+        value <= MAX_MAX_FIX_ATTEMPTS);
+}
+function warnIgnored(source, raw) {
+    logger.warning("Ignoring unusable maxFixAttempts value", {
+        source,
+        raw: String(raw),
+        accepted: `a whole number from ${MIN_MAX_FIX_ATTEMPTS} to ${MAX_MAX_FIX_ATTEMPTS}`,
+    });
+}
+/** Parse a string spelling: the whole string must be a plain decimal integer.
+ *  `parseInt` would read `8abc` as 8 and `1e3` as 1, so it is not used. */
+function parseSpelling(raw) {
+    const text = raw.trim();
+    if (!/^\+?(?:0|[1-9]\d*)$/.test(text))
+        return undefined;
+    const value = Number(text);
+    return inRange(value) ? value : undefined;
+}
+/**
+ * Parse a prompt or resource argument for the cap. A number, or a string that is
+ * a whole decimal integer, in range, is returned; anything else — another type,
+ * `8abc`, `1e1`, `0`, `12` — reads as unset, so both entry points fall through to
+ * the environment and the default the same way instead of one of them rejecting
+ * the call. Range is applied here too, so a zod `.min/.max` on the result never
+ * sees a value it would refuse.
+ */
+export function parseMaxFixAttemptsArg(raw, source = "argument") {
+    if (typeof raw === "number") {
+        if (inRange(raw))
+            return raw;
+        warnIgnored(source, raw);
+        return undefined;
+    }
+    if (typeof raw === "string") {
+        if (raw.trim() === "")
+            return undefined;
+        const value = parseSpelling(raw);
+        if (value === undefined)
+            warnIgnored(source, raw);
+        return value;
+    }
+    return undefined;
+}
+/**
+ * Resolve the cap from an explicit request, the environment, and the default.
+ * Pure apart from the warning log: `env` is injectable for tests and defaults
+ * to `process.env`.
+ */
+export function resolveMaxFixAttempts(requested, env = process.env) {
+    if (requested !== undefined) {
+        if (inRange(requested))
+            return requested;
+        warnIgnored("argument", requested);
+    }
+    const fromEnv = parseMaxFixAttemptsArg(env[MAX_FIX_ATTEMPTS_ENV], MAX_FIX_ATTEMPTS_ENV);
+    if (fromEnv !== undefined)
+        return fromEnv;
+    return DEFAULT_MAX_FIX_ATTEMPTS;
+}
+// Process-wide: what the most recent prompt render resolved. It seeds the pin a
+// run's first execute call writes into the state file; after that the state
+// wins (see the header). Set, not set-if-unset, for the same reason
+// setPrimaryRepository is: one server can render a second run.
+let _maxFixAttempts;
+export function setMaxFixAttempts(value) {
+    _maxFixAttempts = resolveMaxFixAttempts(value);
+}
+/** The cap the current prompt render resolved, else the environment, else the
+ *  default. Only a seed for the per-run pin: the execute tool reads the pinned
+ *  value first and enforces nothing when there is no run state at all. */
+export function getMaxFixAttempts() {
+    return _maxFixAttempts ?? resolveMaxFixAttempts();
+}
+/** Test seam. */
+export function resetMaxFixAttemptsForTests() {
+    _maxFixAttempts = undefined;
+}

package/build/utils/frontendSelectors.js

@@ -55,10 +55,29 @@ const GET_BY_TEST_ID_RE = /getByTestId\(\s*[`'"]([A-Za-z][\w:-]{2,})[`'"]/gi;
  */
 const GENERIC_DATA_ATTR_RE = /\b(data-[a-z][a-z0-9]*(?:-[a-z0-9]+)*)\s*=\s*\{?\s*[`'"]([A-Za-z][\w:-]{2,})[`'"]/gi;
 const STATE_DATA_ATTRS = new Set([
-    "data-state", "data-theme", "data-orientation", "data-side", "data-align", "data-value",
-    "data-index", "data-slot", "data-disabled", "data-checked", "data-active", "data-open",
-    "data-loading", "data-size", "data-variant", "data-selected", "data-highlighted",
-    "data-focus", "data-hover", "data-pressed", "data-expanded", "data-placeholder", "data-status",
+    "data-state",
+    "data-theme",
+    "data-orientation",
+    "data-side",
+    "data-align",
+    "data-value",
+    "data-index",
+    "data-slot",
+    "data-disabled",
+    "data-checked",
+    "data-active",
+    "data-open",
+    "data-loading",
+    "data-size",
+    "data-variant",
+    "data-selected",
+    "data-highlighted",
+    "data-focus",
+    "data-hover",
+    "data-pressed",
+    "data-expanded",
+    "data-placeholder",
+    "data-status",
 ]);
 /**
  * Identifying `data-*` attributes on one source line: the trusted test-facing set (any

package/build/utils/generatedTestRecord.d.ts

@@ -0,0 +1,19 @@
+import { TestType } from "../types/TestTypes.js";
+/**
+ * Record a file a generation tool just wrote, keyed by canonical path.
+ *
+ * The generator is the only place the written paths are known. Without this the
+ * report has to fall back to the agent's own `fileName`, which is a BASENAME, so
+ * two specs of one name in different directories answer for each other. A path
+ * recorded here is the server's own, and it is the same key
+ * `persistTestExecutionResult` writes an execution under — so "was this file
+ * run" is a lookup rather than a match.
+ *
+ * Deliberately not `assertionOutcomes`, which also holds a per-file record: that
+ * one is written only when assertion enhancement is on for the test type, so it
+ * is not a list of what was generated.
+ *
+ * Best-effort, like the assertion baseline beside it: no run state means no
+ * record, and the report falls back to the checks that read the report itself.
+ */
+export declare function persistGeneratedTest(testFile: string, testType: TestType, explicitStateFile?: string): Promise<void>;

package/build/utils/generatedTestRecord.js

@@ -0,0 +1,61 @@
+import { StateManager, resolveRunStatePath } from "./AnalysisStateManager.js";
+import { canonicalTestPath } from "../tools/code-refactor/assertion-state.js";
+import { runSerialized } from "./runSerialized.js";
+import { stateFileKey } from "./testExecutionRecord.js";
+import { logger } from "./logger.js";
+/**
+ * Record a file a generation tool just wrote, keyed by canonical path.
+ *
+ * The generator is the only place the written paths are known. Without this the
+ * report has to fall back to the agent's own `fileName`, which is a BASENAME, so
+ * two specs of one name in different directories answer for each other. A path
+ * recorded here is the server's own, and it is the same key
+ * `persistTestExecutionResult` writes an execution under — so "was this file
+ * run" is a lookup rather than a match.
+ *
+ * Deliberately not `assertionOutcomes`, which also holds a per-file record: that
+ * one is written only when assertion enhancement is on for the test type, so it
+ * is not a list of what was generated.
+ *
+ * Best-effort, like the assertion baseline beside it: no run state means no
+ * record, and the report falls back to the checks that read the report itself.
+ */
+export async function persistGeneratedTest(testFile, testType, explicitStateFile) {
+    const stateFile = resolveRunStatePath(explicitStateFile);
+    if (!stateFile)
+        return;
+    try {
+        const manager = StateManager.fromStatePath(stateFile);
+        // One queue per state FILE, shared with every other tool that writes it.
+        // The testbot prompt asks the independent generation tools to run in
+        // parallel, and each call reads the whole payload and writes it back:
+        // unserialized, two generators read the same `generatedTests` and the
+        // second write drops the first one's key, which loses a file the report is
+        // supposed to account for. Keyed on the file rather than on the spelling,
+        // so a run pointed at the state file by a different path still waits.
+        await runSerialized(stateFileKey(stateFile), async () => {
+            // Read INSIDE the critical section: a snapshot taken before the queue
+            // would be the stale one this serialization exists to prevent.
+            const data = await manager.readData();
+            if (!data)
+                return;
+            const key = canonicalTestPath(testFile);
+            const record = {
+                testType,
+                generatedAt: Date.now(),
+            };
+            // Last write wins for one path: a file written twice is still one file
+            // owing one run, and the later timestamp is the one a run has to beat.
+            await manager.appendData({
+                ...data,
+                generatedTests: { ...data.generatedTests, [key]: record },
+            });
+        });
+    }
+    catch (error) {
+        logger.warning("Could not record a generated test file in run state", {
+            testFile,
+            detail: error instanceof Error ? error.message : String(error),
+        });
+    }
+}

package/build/utils/gitStaging.js

@@ -37,8 +37,13 @@ export function detectGitRoot(filePath) {
     if (!path.isAbsolute(filePath))
         return undefined;
     try {
-        const dir = fs.statSync(filePath).isDirectory() ? filePath : path.dirname(filePath);
-        const stdout = execFileSync("git", ["rev-parse", "--show-toplevel"], { cwd: dir, encoding: "utf8" });
+        const dir = fs.statSync(filePath).isDirectory()
+            ? filePath
+            : path.dirname(filePath);
+        const stdout = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+            cwd: dir,
+            encoding: "utf8",
+        });
         return stdout.trim() || undefined;
     }
     catch {

package/build/utils/initAgent.js

@@ -7,9 +7,21 @@ import { EXECUTOR_DOCKER_IMAGE, WORKER_DOCKER_IMAGE } from "./versions.js";
 import { dockerImageExistsLocally, pullDockerImage } from "./docker.js";
 // Global skill discovery paths (resolved relative to os.homedir()).
 const SKILL_INSTALL_PATHS = [
-    { relPath: path.join(".claude", "skills", "skyramp", "SKILLS.md"), description: "Claude Code native skill (~/.claude)", userLevel: true },
-    { relPath: path.join(".cursor", "skills", "skyramp", "SKILLS.md"), description: "Cursor native skill (~/.cursor)", userLevel: true },
-    { relPath: path.join(".github", "skills", "skyramp.md"), description: "Copilot global skill (~/.github/skills)", userLevel: true },
+    {
+        relPath: path.join(".claude", "skills", "skyramp", "SKILLS.md"),
+        description: "Claude Code native skill (~/.claude)",
+        userLevel: true,
+    },
+    {
+        relPath: path.join(".cursor", "skills", "skyramp", "SKILLS.md"),
+        description: "Cursor native skill (~/.cursor)",
+        userLevel: true,
+    },
+    {
+        relPath: path.join(".github", "skills", "skyramp.md"),
+        description: "Copilot global skill (~/.github/skills)",
+        userLevel: true,
+    },
 ];
 async function pathExists(filePath) {
     try {
@@ -46,10 +58,15 @@ export async function ensureSkyrampMdInstalled() {
             if (existing === SKYRAMP_MD_CONTENT)
                 continue;
             await fs.writeFile(targetPath, SKYRAMP_MD_CONTENT);
-            logger.info(existing ? `Refreshed Skyramp skill file (${description})` : `Installed Skyramp skill file (${description})`, { targetPath });
+            logger.info(existing
+                ? `Refreshed Skyramp skill file (${description})`
+                : `Installed Skyramp skill file (${description})`, { targetPath });
         }
         catch (err) {
-            logger.error(`Failed to install Skyramp skill file (${description})`, { targetPath, error: err });
+            logger.error(`Failed to install Skyramp skill file (${description})`, {
+                targetPath,
+                error: err,
+            });
         }
     }
 }
@@ -89,7 +106,10 @@ export async function initCheck() {
     ]);
     const pulls = [];
     if (!hasExecutor) {
-        logger.info("Pulling missing executor image", { image: EXECUTOR_DOCKER_IMAGE, platform: "linux/amd64" });
+        logger.info("Pulling missing executor image", {
+            image: EXECUTOR_DOCKER_IMAGE,
+            platform: "linux/amd64",
+        });
         pulls.push(pullDockerImage(EXECUTOR_DOCKER_IMAGE, "linux/amd64"));
     }
     if (!hasWorker) {