@skyramp/mcp 0.4.3 → 0.4.4-rc.2

package/build/utils/findUp.js

@@ -0,0 +1,59 @@
+import * as fs from "fs";
+import * as path from "path";
+import { logger } from "./logger.js";
+/** Deeper than any real checkout; a bound so a walk can never run away. */
+const MAX_LEVELS = 64;
+/**
+ * The first `<dir>/<candidate>` that exists, checking `from` and then each
+ * ancestor, or undefined.
+ *
+ * With `stopAtRepoRoot`, only the directories up to the nearest one holding
+ * `.git` (a directory or a file, so worktrees count) are searched, and a `from`
+ * outside any checkout searches nothing: a parent directory is not the
+ * repository's to answer for. The walk never passes the filesystem root or
+ * MAX_LEVELS.
+ */
+export function findUp(from, candidates, { stopAtRepoRoot = false } = {}) {
+    const dirs = ancestors(from);
+    if (stopAtRepoRoot) {
+        const root = dirs.findIndex((dir) => fs.existsSync(path.join(dir, ".git")));
+        if (root === -1)
+            return undefined;
+        dirs.length = root + 1;
+    }
+    for (const dir of dirs) {
+        for (const candidate of candidates) {
+            const found = path.join(dir, candidate);
+            if (fs.existsSync(found))
+                return found;
+        }
+    }
+    return undefined;
+}
+/** `from` and each ancestor, nearest first, up to the filesystem root. */
+function ancestors(from) {
+    const dirs = [path.resolve(from)];
+    while (dirs.length < MAX_LEVELS) {
+        const parent = path.dirname(dirs[dirs.length - 1]);
+        if (parent === dirs[dirs.length - 1])
+            break;
+        dirs.push(parent);
+    }
+    return dirs;
+}
+/** The package's manifest as Node would find it from `from`: the nearest
+ *  `node_modules/<pkg>/package.json` walking UP from there. Node's own lookup
+ *  never reads NODE_PATH for this, and neither does this one. A manifest that
+ *  does not parse is logged and treated as absent. */
+export function installedManifest(pkg, from, options) {
+    const manifest = findUp(from, [path.join("node_modules", pkg, "package.json")], options);
+    if (!manifest)
+        return undefined;
+    try {
+        return JSON.parse(fs.readFileSync(manifest, "utf8"));
+    }
+    catch (error) {
+        logger.warning(`Could not read ${manifest}`, { error: String(error) });
+        return undefined;
+    }
+}

package/build/utils/initAgent.d.ts

@@ -16,9 +16,9 @@ export declare function ensureSkyrampMdInstalled(): Promise<void>;
  *   Previously both images were always pulled regardless.
  * - Parallel pulls: missing images are pulled concurrently via Promise.all, halving
  *   wall-clock time when both need to be downloaded.
- * - Arch-aware: pull platform is detected from process.arch (linux/arm64 on Apple Silicon,
- *   linux/amd64 otherwise) with an automatic amd64 fallback if no arm64 manifest exists
- *   (e.g. skyramp/executor is amd64-only; skyramp/worker supports both).
+ * - Arch-aware: the worker's pull platform is detected from process.arch (linux/arm64 on
+ *   Apple Silicon, linux/amd64 otherwise) with an automatic amd64 fallback if no arm64
+ *   manifest exists. The executor is always pulled as amd64, the platform it runs as.
  * - No FFI overhead: direct Dockerode calls replace the Go shared-library bridge,
  *   removing the cost of loading the .so and marshalling output through a C string.
  * - Cleaner error propagation: structured errors from Dockerode replace parsing a

package/build/utils/initAgent.js

@@ -4,7 +4,8 @@ import path from "path";
 import { logger } from "./logger.js";
 import { SKYRAMP_MD_CONTENT } from "./skyrampMdContent.js";
 import { EXECUTOR_DOCKER_IMAGE, WORKER_DOCKER_IMAGE } from "./versions.js";
-import { dockerImageExistsLocally, pullDockerImage } from "./docker.js";
+import { dockerDaemonOsType, dockerImageExistsLocally, getDockerPlatform, isPlatformUnavailableError, pullDockerImage, } from "./docker.js";
+import { resolveExecutorImage } from "../services/FleetExecutionService.js";
 // Global skill discovery paths (resolved relative to os.homedir()).
 const SKILL_INSTALL_PATHS = [
     {
@@ -83,9 +84,9 @@ export async function ensureSkyrampMdInstalled() {
  *   Previously both images were always pulled regardless.
  * - Parallel pulls: missing images are pulled concurrently via Promise.all, halving
  *   wall-clock time when both need to be downloaded.
- * - Arch-aware: pull platform is detected from process.arch (linux/arm64 on Apple Silicon,
- *   linux/amd64 otherwise) with an automatic amd64 fallback if no arm64 manifest exists
- *   (e.g. skyramp/executor is amd64-only; skyramp/worker supports both).
+ * - Arch-aware: the worker's pull platform is detected from process.arch (linux/arm64 on
+ *   Apple Silicon, linux/amd64 otherwise) with an automatic amd64 fallback if no arm64
+ *   manifest exists. The executor is always pulled as amd64, the platform it runs as.
  * - No FFI overhead: direct Dockerode calls replace the Go shared-library bridge,
  *   removing the cost of loading the .so and marshalling output through a C string.
  * - Cleaner error propagation: structured errors from Dockerode replace parsing a
@@ -99,33 +100,64 @@ export async function initCheck() {
         await ensureSkyrampMdInstalled();
         logger.info("Skyramp skill files installed/refreshed");
     }
-    // Check each image independently and pull only what is missing
-    const [hasExecutor, hasWorker] = await Promise.all([
-        dockerImageExistsLocally(EXECUTOR_DOCKER_IMAGE),
-        dockerImageExistsLocally(WORKER_DOCKER_IMAGE),
-    ]);
+    // Two executors can be in use: skyramp_execute_test always runs the released constant,
+    // and skyramp_execute_fleet runs SKYRAMP_EXECUTOR_IMAGE when it is set. Fetch both, or a
+    // normal test run pays for the pull the override displaced.
+    const fleetExecutor = resolveExecutorImage();
+    // Every image is pulled for the daemon's own OS: a released executor is one tag carrying
+    // both, and the tag names no platform. Both run paths start the executor as amd64, so it
+    // is pulled as amd64 on every host -- an arm64 copy would not be the one the run starts.
+    const daemonOs = await dockerDaemonOsType();
+    const executorPlatform = daemonOs === "windows" ? "windows/amd64" : "linux/amd64";
+    const workerPlatform = daemonOs === "windows" ? "windows/amd64" : getDockerPlatform();
+    const executors = [...new Set([EXECUTOR_DOCKER_IMAGE, fleetExecutor])];
+    // An executor image without this daemon's OS -- an older release, or a single-OS
+    // SKYRAMP_EXECUTOR_IMAGE -- has nothing to pull here. That is a fact about the image,
+    // not a broken environment, so its pull is optional.
+    const wanted = [
+        ...executors.map((image) => ({
+            what: "executor",
+            image,
+            platform: executorPlatform,
+            optional: true,
+        })),
+        {
+            what: "worker",
+            image: WORKER_DOCKER_IMAGE,
+            platform: workerPlatform,
+            optional: false,
+        },
+    ];
+    // Presence is checked for all of them at once; only the pulls that follow are conditional.
+    const present = await Promise.all(wanted.map((w) => dockerImageExistsLocally(w.image)));
     const pulls = [];
-    if (!hasExecutor) {
-        logger.info("Pulling missing executor image", {
-            image: EXECUTOR_DOCKER_IMAGE,
-            platform: "linux/amd64",
-        });
-        pulls.push(pullDockerImage(EXECUTOR_DOCKER_IMAGE, "linux/amd64"));
-    }
-    if (!hasWorker) {
-        logger.info("Pulling missing worker image", { image: WORKER_DOCKER_IMAGE });
-        pulls.push(pullDockerImage(WORKER_DOCKER_IMAGE));
+    wanted.forEach(({ what, image, platform, optional }, i) => {
+        if (present[i])
+            return;
+        logger.info(`Pulling missing ${what} image`, { image, platform });
+        const pull = pullDockerImage(image, platform);
+        // Only an image with nothing for this platform is tolerated, and only when optional.
+        // Any other failure -- the network, a rate limit, a full disk -- fails init so it is
+        // retried, instead of being reported as a missing variant.
+        pulls.push(optional
+            ? pull.catch((err) => {
+                if (!isPlatformUnavailableError(err))
+                    throw err;
+                logger.warning("Executor image has no variant for this daemon's platform: fleet runs " +
+                    "need an executor built for it (a release that carries it, or " +
+                    "SKYRAMP_EXECUTOR_IMAGE)", { image, platform, error: err.message });
+            })
+            : pull);
+    });
+    if (pulls.length > 0) {
+        await Promise.all(pulls);
+        logger.info("Skyramp init completed");
     }
-    if (pulls.length === 0) {
+    else {
         logger.info("Skyramp images already present locally, skipping pull", {
-            executor: EXECUTOR_DOCKER_IMAGE,
-            worker: WORKER_DOCKER_IMAGE,
+            images: wanted.map((w) => w.image),
         });
     }
-    else {
-        await Promise.all(pulls);
-        logger.info("Skyramp init completed");
-    }
 }
 let initInFlight = false;
 let initCompleted = false;

package/build/utils/language-helper.js

@@ -36,7 +36,7 @@ npx playwright test <test-file>.spec.${extension} --reporter=list
  *  a mock is deployed rather than run as a test — it needs no SDK. */
 const SDK_DECLARATION = {
     python: "Declare `skyramp` in the same development manifest.",
-    javascript: `If @skyramp/skyramp is not already declared, add ${npmSdkSpec} as a devDependency. If it is declared, leave its version alone and report the mismatch if the verifier refuses it.`,
+    javascript: `If @skyramp/skyramp is not already declared, add ${npmSdkSpec} as a devDependency. If it is declared, keep its version unless skyramp_execute_test refuses the run for an older SDK.`,
     java: "Declare `dev.skyramp:skyramp-library` with test scope. An existing manifest resolves the version through its own dependency management; a manifest you created has none, so give a concrete version there.",
 };
 /** The SDK line for a language, or nothing when the language has none. */

package/build/utils/progress.d.ts

@@ -1,16 +1,15 @@
-import { ServerRequest, ServerNotification } from "@modelcontextprotocol/sdk/types.js";
-import { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import { ServerContext } from "@modelcontextprotocol/server";
 /**
  * Reports incremental progress for a long-running tool call. No-ops when the
  * client did not supply a progress token.
  */
 export type ProgressReporter = (progress: number, total: number, message: string) => Promise<void>;
 /**
- * Build a progress reporter bound to a tool handler's `extra`. Sends
+ * Build a progress reporter bound to a tool handler's context. Sends
  * `notifications/progress` only when the client provided a `progressToken`,
  * otherwise silently no-ops.
  *
  * Consolidates the identical closure that previously lived inline in multiple
  * progress-emitting tools (analyzeChanges, startTraceCollection).
  */
-export declare function makeProgressReporter(extra: RequestHandlerExtra<ServerRequest, ServerNotification>): ProgressReporter;
+export declare function makeProgressReporter(ctx: ServerContext): ProgressReporter;

package/build/utils/progress.js

@@ -1,21 +1,21 @@
 /**
- * Build a progress reporter bound to a tool handler's `extra`. Sends
+ * Build a progress reporter bound to a tool handler's context. Sends
  * `notifications/progress` only when the client provided a `progressToken`,
  * otherwise silently no-ops.
  *
  * Consolidates the identical closure that previously lived inline in multiple
  * progress-emitting tools (analyzeChanges, startTraceCollection).
  */
-export function makeProgressReporter(extra) {
+export function makeProgressReporter(ctx) {
     return async (progress, total, message) => {
-        const progressToken = extra._meta?.progressToken;
+        const progressToken = ctx.mcpReq._meta?.progressToken;
         if (progressToken !== undefined) {
             try {
                 const notification = {
                     method: "notifications/progress",
                     params: { progressToken, progress, total, message },
                 };
-                await extra.sendNotification(notification);
+                await ctx.mcpReq.notify(notification);
             }
             catch {
                 // Progress is best-effort; a disconnected client should not fail the tool.

package/build/utils/repoSdkVersion.d.ts

@@ -0,0 +1,16 @@
+import { SdkEcosystem } from "./testDependencyPolicy.js";
+/**
+ * The Skyramp SDK version the repository that owns `testFile` runs, as far as it
+ * can be read without its toolchain: the installed npm package, else the exact
+ * pin in the nearest manifest. Undefined when neither says. Both lookups stop at
+ * the repository root.
+ */
+export declare function repoSkyrampSdkVersion(testFile: string, ecosystem: SdkEcosystem): string | undefined;
+/**
+ * SKYR-4548: the refusal for a host run whose repository uses an older Skyramp
+ * SDK than the one that generated the test, or undefined when the run may go
+ * ahead. Such a run fails at import, which reads as a broken test. No readable
+ * version means no refusal: a missing SDK is an import error that
+ * fix-test-import-errors owns.
+ */
+export declare function staleSdkRefusal(testFile: string, language: string, serverVersion?: string): string | undefined;

package/build/utils/repoSdkVersion.js

@@ -0,0 +1,88 @@
+import * as fs from "fs";
+import * as path from "path";
+import semver from "semver";
+import { ProgrammingLanguage } from "../types/TestTypes.js";
+import { findUp, installedManifest } from "./findUp.js";
+import { logger } from "./logger.js";
+import { SKYRAMP_SDK_VERSION } from "./skyrampSdkVersion.js";
+import { manifestNames, pinnedSkyrampSdkVersion, SKYRAMP_SDK_PACKAGE, } from "./testDependencyPolicy.js";
+const ECOSYSTEM = {
+    [ProgrammingLanguage.TYPESCRIPT]: "javascript",
+    [ProgrammingLanguage.JAVASCRIPT]: "javascript",
+    [ProgrammingLanguage.PYTHON]: "python",
+    [ProgrammingLanguage.JAVA]: "java",
+};
+/** The one edit that moves the repository onto the SDK that generated the
+ *  test, and that skyramp_verify_test_dependencies accepts. */
+const PIN_EDIT = {
+    javascript: (v) => `Declare ${SKYRAMP_SDK_PACKAGE.javascript} under devDependencies only (move it out of dependencies if it is there), at exactly "${SKYRAMP_SDK_PACKAGE.javascript}": "${v}" with no range operator`,
+    python: (v) => `Change only the requirement to ${SKYRAMP_SDK_PACKAGE.python}==${v}`,
+    java: (v) => `Change only the ${SKYRAMP_SDK_PACKAGE.java} version to ${v}`,
+};
+/**
+ * The Skyramp SDK version the repository that owns `testFile` runs, as far as it
+ * can be read without its toolchain: the installed npm package, else the exact
+ * pin in the nearest manifest. Undefined when neither says. Both lookups stop at
+ * the repository root.
+ */
+export function repoSkyrampSdkVersion(testFile, ecosystem) {
+    const from = path.dirname(path.resolve(testFile));
+    if (ecosystem === "javascript") {
+        const version = installedManifest(SKYRAMP_SDK_PACKAGE.javascript, from, {
+            stopAtRepoRoot: true,
+        })?.version;
+        if (typeof version === "string")
+            return version;
+    }
+    const names = manifestNames(ecosystem);
+    const nearest = findUp(from, names, { stopAtRepoRoot: true });
+    if (!nearest)
+        return undefined;
+    for (const name of names) {
+        const manifest = path.join(path.dirname(nearest), name);
+        if (!fs.existsSync(manifest))
+            continue;
+        try {
+            const pinned = pinnedSkyrampSdkVersion(name, fs.readFileSync(manifest, "utf8"));
+            if (pinned)
+                return pinned;
+        }
+        catch (error) {
+            logger.warning(`Could not read the Skyramp SDK version in ${manifest}`, {
+                error: String(error),
+            });
+        }
+    }
+    return undefined;
+}
+/**
+ * SKYR-4548: the refusal for a host run whose repository uses an older Skyramp
+ * SDK than the one that generated the test, or undefined when the run may go
+ * ahead. Such a run fails at import, which reads as a broken test. No readable
+ * version means no refusal: a missing SDK is an import error that
+ * fix-test-import-errors owns.
+ */
+export function staleSdkRefusal(testFile, language, serverVersion = SKYRAMP_SDK_VERSION) {
+    const ecosystem = ECOSYSTEM[language];
+    if (!ecosystem)
+        return undefined;
+    const repoVersion = repoSkyrampSdkVersion(testFile, ecosystem);
+    if (!isOlderRelease(repoVersion, serverVersion))
+        return undefined;
+    return (`Not executed: this repository uses Skyramp SDK ${repoVersion}, but the test was generated by ${serverVersion}. ` +
+        `${PIN_EDIT[ecosystem](serverVersion)}, update the lockfile if the repository commits one, reinstall, ` +
+        `run skyramp_verify_test_dependencies, and call this tool again. Report the SDK change as an issuesFound entry with category config.`);
+}
+/** True when `repo` is an older release than `server`. Pre-release tags are
+ *  ignored (1.3.47-rc.1 is 1.3.47), and a version semver cannot read is never
+ *  older: the gate must not refuse a run on a guess. */
+function isOlderRelease(repo, server) {
+    const a = repo ? semver.parse(repo) : null;
+    const b = semver.parse(server);
+    if (!a || !b) {
+        if (repo)
+            logger.warning(`Cannot compare Skyramp SDK ${repo} to ${server}`);
+        return false;
+    }
+    return a.compareMain(b) < 0;
+}

package/build/utils/testDependencyPolicy.d.ts

@@ -7,3 +7,23 @@ export interface TestDependencyVerification {
     violations: string[];
 }
 export declare function verifyTestDependencyChanges(repositoryPath: string): Promise<TestDependencyVerification>;
+/** The Skyramp SDK's name in each ecosystem. All three are released in lockstep
+ *  with the npm SDK this server imports, so SKYRAMP_SDK_VERSION is the version
+ *  that generated a test in any of them. */
+export declare const SKYRAMP_SDK_PACKAGE: {
+    readonly javascript: "@skyramp/skyramp";
+    readonly python: "skyramp";
+    readonly java: "dev.skyramp:skyramp-library";
+};
+export type SdkEcosystem = keyof typeof SKYRAMP_SDK_PACKAGE;
+/** The manifest file names an ecosystem declares its dependencies in. */
+export declare function manifestNames(ecosystem: SdkEcosystem): readonly string[];
+/**
+ * The exact Skyramp SDK version a manifest pins where the change verifier lets
+ * the agent raise it, or undefined: the SDK is absent, declared as a range,
+ * resolved elsewhere (a Maven property or BOM, a Gradle catalog), or pinned in
+ * a place the verifier refuses to change (`dependencies`, requirements.txt, a
+ * Maven block without test scope, a Gradle `implementation` line). A refusal
+ * over such a pin would have no fix the agent may make.
+ */
+export declare function pinnedSkyrampSdkVersion(fileName: string, raw: string): string | undefined;

package/build/utils/testDependencyPolicy.js

@@ -4,6 +4,7 @@ import * as path from "path";
 import { parse as parseToml } from "smol-toml";
 import { promisify } from "util";
 import fg from "fast-glob";
+import semver from "semver";
 import { canonicalJson as canonical, isPlainObject as isObject, } from "./canonicalJson.js";
 import { listChangedFiles } from "./reportVerification.js";
 import { contentAtHead } from "./utils-verify/head.js";
@@ -278,18 +279,77 @@ function verifyPackageJson(file, beforeRaw, afterRaw, violations) {
         canonical(beforeDev) !== canonical(afterDev));
 }
 /** The SDK the tests were generated by is the one this server imports, so the
- *  repository must declare exactly that version. Only the npm spelling carries
- *  a version: the Python and Java manifests declare the SDK without one, so
- *  neither is checked here.
+ *  repository must declare exactly that version. Only a changed npm entry is
+ *  checked here: the guidance declares the Python and Java SDK without a
+ *  version. A pin a repository already has is read by pinnedSkyrampSdkVersion.
  *
  *  The specifier must be the bare version. A range is refused, including
  *  `^1.2.3`: it permits 1.3.0, so a clean install elsewhere can resolve an SDK
  *  that did not write these tests, which is the whole thing this prevents. */
 function declaresServerSdkVersion(name, specifier) {
-    if (name !== "@skyramp/skyramp")
+    if (name !== SKYRAMP_SDK_PACKAGE.javascript)
         return true;
     return specifier.trim() === SKYRAMP_SDK_VERSION;
 }
+/** The Skyramp SDK's name in each ecosystem. All three are released in lockstep
+ *  with the npm SDK this server imports, so SKYRAMP_SDK_VERSION is the version
+ *  that generated a test in any of them. */
+export const SKYRAMP_SDK_PACKAGE = {
+    javascript: "@skyramp/skyramp",
+    python: "skyramp",
+    java: "dev.skyramp:skyramp-library",
+};
+/** The manifest file names an ecosystem declares its dependencies in. */
+export function manifestNames(ecosystem) {
+    return DEPENDENCY_FILES[ecosystem].manifests;
+}
+/**
+ * The exact Skyramp SDK version a manifest pins where the change verifier lets
+ * the agent raise it, or undefined: the SDK is absent, declared as a range,
+ * resolved elsewhere (a Maven property or BOM, a Gradle catalog), or pinned in
+ * a place the verifier refuses to change (`dependencies`, requirements.txt, a
+ * Maven block without test scope, a Gradle `implementation` line). A refusal
+ * over such a pin would have no fix the agent may make.
+ */
+export function pinnedSkyrampSdkVersion(fileName, raw) {
+    switch (fileName) {
+        case "package.json":
+            return exactVersion(stringMap(JSON.parse(raw).devDependencies)[SKYRAMP_SDK_PACKAGE.javascript]);
+        case "requirements-dev.txt":
+            return pep440Pin(requirementsMap(raw).dependencies[SKYRAMP_SDK_PACKAGE.python]);
+        case "pyproject.toml": {
+            // Poetry reads a bare version as an exact pin; PEP 735 carries `==`.
+            const spec = pythonDevView(raw).dependencies[SKYRAMP_SDK_PACKAGE.python];
+            return pep440Pin(spec) ?? exactVersion(spec);
+        }
+        case "pom.xml": {
+            const blocks = mavenView(raw.replace(/<!--[\s\S]*?-->/g, ""))
+                .dependencies[SKYRAMP_SDK_PACKAGE.java];
+            return blocks?.length === 1 && !mavenDependency(blocks[0]).error
+                ? exactVersion(singleXmlTag(blocks[0], "version"))
+                : undefined;
+        }
+        case "build.gradle":
+        case "build.gradle.kts": {
+            const lines = gradleView(raw).dependencies[SKYRAMP_SDK_PACKAGE.java];
+            if (lines?.length !== 1)
+                return undefined;
+            const [configuration, value] = lines[0].split("\0");
+            return configuration === "testImplementation" ||
+                configuration === "testRuntimeOnly"
+                ? exactVersion(value.split(":")[2])
+                : undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+function exactVersion(spec) {
+    return (spec && semver.valid(spec.trim())) || undefined;
+}
+function pep440Pin(requirement) {
+    return exactVersion(/==\s*([^,;\s]+)/.exec(requirement ?? "")?.[1]);
+}
 function verifyPyproject(file, beforeRaw, afterRaw, violations) {
     const before = pythonDevView(beforeRaw);
     const after = pythonDevView(afterRaw);

package/build/utils/utils-verify/typecheck.js

@@ -1,5 +1,5 @@
 import * as path from "path";
-import { readFileSync } from "fs";
+import { installedManifest } from "../findUp.js";
 import { fileURLToPath } from "url";
 let tsModule;
 /** The compiler, loaded on first use and once per process. Loaded statically it
@@ -64,6 +64,8 @@ function executorPeerPackages(mcpRoot) {
         return peers;
     peers = [];
     for (const pkg of EXECUTOR_PROVIDED_PACKAGES) {
+        // Nearest `node_modules/<pkg>` walking UP: `npm install @skyramp/mcp`,
+        // testbot's default, hoists the MCP's dependencies BESIDE it, not under it.
         const manifest = installedManifest(pkg, mcpRoot);
         if (manifest)
             peers.push(...Object.keys(manifest.peerDependencies ?? {}));
@@ -74,23 +76,6 @@ function executorPeerPackages(mcpRoot) {
     peersByRoot.set(mcpRoot, peers);
     return peers;
 }
-/** The package's manifest as Node would find it from `from`: the nearest
- *  `node_modules/<pkg>` walking UP from there. The MCP's dependencies are not
- *  always nested under its own root — `npm install @skyramp/mcp`, testbot's
- *  default, hoists them BESIDE `@skyramp/mcp` — and a read at one fixed path
- *  found nothing on that layout, left the peer list empty, and brought the two
- *  Playwright identities back exactly where customers run. */
-function installedManifest(pkg, from) {
-    for (let dir = from;; dir = path.dirname(dir)) {
-        try {
-            return JSON.parse(readFileSync(path.join(dir, "node_modules", pkg, "package.json"), "utf8"));
-        }
-        catch {
-            if (path.dirname(dir) === dir)
-                return undefined;
-        }
-    }
-}
 const isPackageOrSubpath = (specifier, packages) => packages.some((p) => specifier === p || specifier.startsWith(`${p}/`));
 function executorProvides(specifier) {
     return isPackageOrSubpath(specifier, EXECUTOR_PROVIDED_PACKAGES);

package/build/utils/utils.d.ts

@@ -1,4 +1,4 @@
-import { CallToolResult, ReadResourceResult } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolResult, ReadResourceResult } from "@modelcontextprotocol/server";
 export declare function toolError(message: string): CallToolResult;
 /**
  * Build a successful tool result whose payload is delivered on BOTH MCP result

package/build/utils/versions.d.ts

@@ -1,4 +1,4 @@
-export declare const SKYRAMP_IMAGE_VERSION = "v1.3.47";
-export declare const EXECUTOR_DOCKER_IMAGE = "skyramp/executor:v1.3.47";
-export declare const WORKER_DOCKER_IMAGE = "skyramp/worker:v1.3.47";
+export declare const SKYRAMP_IMAGE_VERSION = "v1.3.50";
+export declare const EXECUTOR_DOCKER_IMAGE = "skyramp/executor:v1.3.50";
+export declare const WORKER_DOCKER_IMAGE = "skyramp/worker:v1.3.50";
 export declare const WORKER_CONTROL_PORT = 35142;

package/build/utils/versions.js

@@ -1,4 +1,4 @@
-export const SKYRAMP_IMAGE_VERSION = "v1.3.47";
+export const SKYRAMP_IMAGE_VERSION = "v1.3.50";
 export const EXECUTOR_DOCKER_IMAGE = `skyramp/executor:${SKYRAMP_IMAGE_VERSION}`;
 export const WORKER_DOCKER_IMAGE = `skyramp/worker:${SKYRAMP_IMAGE_VERSION}`;
 // Control port the Skyramp worker listens on (SDK `CONTAINER_PORT`).