unity-open-mcp 0.1.0

package/dist/cli/ping-poller.js

@@ -0,0 +1,161 @@
+// M15 T6.1 — compile-aware bridge readiness polling, shared by `ping` and
+// `wait-for-ready`.
+//
+// Polling the bridge is its own concern: it must respect compile state (a 503
+// or `compiling: true` /ping is NOT readiness), tolerate transient network
+// errors during a domain reload, and fail fast on a dead-bridge signature.
+// Pulling it out of the command implementations keeps the command code thin
+// and lets the poll loop be unit-tested without touching the network.
+import { readInstanceLock, classifyInstance, } from "../instance-discovery.js";
+export const DEFAULT_WAIT_TIMEOUT_MS = 120_000;
+export const DEFAULT_POLL_INTERVAL_MS = 1_000;
+export const PING_FETCH_TIMEOUT_MS = 5_000;
+function defaultSleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Poll the bridge until it is ready (connected, not compiling) or the deadline
+ * passes. A 503 from /ping and `compiling: true` both keep the wait alive —
+ * "ready" means usable, not just listening. The poll fails fast on a
+ * dead-bridge signature (live PID, stale heartbeat) because /ping will never
+ * recover in that state.
+ *
+ * @param live           LiveClient pointed at the resolved bridge port.
+ * @param projectPath    Project path, used to read the instance lock for
+ *                       dead-bridge classification. Optional; when absent the
+ *                       dead-bridge shortcut is skipped.
+ * @param singlePoll     One /ping attempt. Returns `{ ok, status, body }`:
+ *                       `ok` true only when connected AND not compiling.
+ *                       Indirected so tests can stub the network hop.
+ * @param opts           Timing + clock injection.
+ */
+export async function pollUntilReady(live, projectPath, singlePoll, opts) {
+    const now = opts.now ?? Date.now;
+    const sleep = opts.sleep ?? defaultSleep;
+    const start = now();
+    const deadline = start + opts.timeoutMs;
+    let lastPing = null;
+    let sawCompiling = false;
+    let sawOffline = false;
+    while (true) {
+        const t = now();
+        if (t >= deadline) {
+            return {
+                ready: false,
+                status: "timeout",
+                lastPing,
+                elapsedMs: t - start,
+                reason: formatTimeoutReason(opts.timeoutMs, sawCompiling, sawOffline),
+            };
+        }
+        const result = await singlePoll(live);
+        if (result.body)
+            lastPing = result.body;
+        if (result.status === "compiling")
+            sawCompiling = true;
+        if (result.status === "offline" || result.status === "error") {
+            sawOffline = true;
+        }
+        if (result.status === "ready") {
+            return {
+                ready: true,
+                status: "ready",
+                lastPing: result.body ?? lastPing,
+                elapsedMs: now() - start,
+                reason: "Bridge is ready (connected, idle).",
+            };
+        }
+        // Dead-bridge signature: the Unity process is alive but the bridge's
+        // [InitializeOnLoad] never re-ran after a compile failure. /ping will not
+        // recover until the C# error is fixed, so waiting is pointless.
+        if (projectPath) {
+            let classification;
+            try {
+                classification = classifyInstance(readInstanceLock(projectPath));
+            }
+            catch {
+                classification = null;
+            }
+            if (classification === "dead_bridge") {
+                return {
+                    ready: false,
+                    status: "dead_bridge",
+                    lastPing,
+                    elapsedMs: now() - start,
+                    reason: "Bridge assembly failed to recompile — Unity is in a bad state " +
+                        "(safe mode / compile errors). Run 'unity-open-mcp run-tool " +
+                        "unity_open_mcp_read_compile_errors --json' to retrieve the " +
+                        "compiler errors, fix them, then re-run wait-for-ready.",
+                };
+            }
+        }
+        await sleep(Math.min(opts.intervalMs, Math.max(0, deadline - now())));
+    }
+}
+/**
+ * Single /ping attempt translated into a poll status. Centralizes the
+ * "connected AND not compiling" readiness rule so every command agrees on it.
+ *
+ * Implementation note: this calls `live.isLiveAvailable()` first to get the
+ * ping-cache population side effect + 503/compiling handling, then falls back
+ * to a direct route of `unity_open_mcp_ping`. The LiveClient's ping handler
+ * already returns the full body; we re-read it from the ping cache so a single
+ * network round-trip answers both "is it up?" and "what's its state?".
+ */
+export async function singlePing(live, fetchTimeoutMs = PING_FETCH_TIMEOUT_MS) {
+    // `isLiveAvailable` populates the ping cache and returns the connected flag.
+    // A 503 (compile in progress) returns true from isLiveAvailable but is NOT
+    // readiness — we still need the body to check `compiling`.
+    try {
+        const available = await live.isLiveAvailable();
+        if (!available) {
+            return { status: "offline", body: null };
+        }
+        // Reuse the populated ping cache rather than a second round-trip. The
+        // cache was just written by isLiveAvailable.
+        const pingResult = await live.route("unity_open_mcp_ping", {});
+        const body = extractPingBody(pingResult);
+        if (!body) {
+            // isLiveAvailable said true but the explicit ping didn't yield a body —
+            // treat as compiling/unknown and keep polling.
+            return { status: "compiling", body: null };
+        }
+        if (body.compiling === true) {
+            return { status: "compiling", body };
+        }
+        if (body.connected === false) {
+            return { status: "offline", body };
+        }
+        return { status: "ready", body };
+    }
+    catch {
+        return { status: "error", body: null };
+    }
+}
+/** Extract the typed ping body from a CallToolResult's first text content. */
+export function extractPingBody(result) {
+    const first = result.content[0];
+    if (!first || first.type !== "text" || typeof first.text !== "string") {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(first.text);
+        if (parsed && typeof parsed === "object") {
+            return parsed;
+        }
+    }
+    catch {
+        // fall through
+    }
+    return null;
+}
+function formatTimeoutReason(timeoutMs, sawCompiling, sawOffline) {
+    if (sawCompiling && !sawOffline) {
+        return `Bridge was still compiling after ${Math.round(timeoutMs / 1000)}s.`;
+    }
+    if (sawOffline && !sawCompiling) {
+        return `Bridge never became reachable within ${Math.round(timeoutMs / 1000)}s.`;
+    }
+    return `Bridge did not become ready within ${Math.round(timeoutMs / 1000)}s.`;
+}
+//# sourceMappingURL=ping-poller.js.map

package/dist/cli/ping-poller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ping-poller.js","sourceRoot":"","sources":["../../src/cli/ping-poller.ts"],"names":[],"mappings":"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"}

package/dist/compat.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The trio version this server belongs to. Resolved once at module load from
+ * package.json (same value the bridge package.json should carry). We do not
+ * re-read per call — package.json does not change while the process runs.
+ */
+export declare const SHARED_VERSION: string;
+/** When non-empty, the version check is suppressed entirely. */
+export declare function isVersionCheckSuppressed(): boolean;
+export interface CompatResult {
+    /** true when the pair is considered compatible (patch-only or equal). */
+    ok: boolean;
+    serverVersion: string;
+    bridgeVersion: string;
+    /** Human-readable guidance; present when not ok or when the pair differs at all. */
+    message: string;
+}
+/**
+ * Compare the running server's version against the bridge's reported version.
+ *
+ * Rule (pre-1.0): for `0.x`, the whole `0.minor` pair must match. Patch
+ * differences are compatible (warn only). After 1.0, the major digit must
+ * match. Unparseable bridge versions are treated as compatible with a warning
+ * (an ancient bridge that predates bridgeVersion reporting shouldn't be hard
+ * blocked) — this keeps the check forward-compatible with older installs.
+ *
+ * Always returns a structured result; the caller decides whether to print it.
+ * The result is advisory regardless — the connection proceeds either way.
+ */
+export declare function checkBridgeCompat(bridgeVersion: string, serverVersion?: string): CompatResult;
+/** True when the bridge version differs from the server at all. Used by callers
+ *  that only want to know whether to render a compat line. */
+export declare function versionsDiffer(bridgeVersion: string, serverVersion?: string): boolean;

package/dist/compat.js

@@ -0,0 +1,121 @@
+// Runtime version-compatibility check between the npm MCP server and the live
+// Unity bridge.
+//
+// The npm MCP server, the bridge Unity package, and the verify Unity package
+// ship as a tightly-coupled trio on ONE shared version (see <repo>/version.json
+// and docs/versioning.md). The bridge reports its version on /ping as
+// `bridgeVersion` (BridgeSession.BridgeVersion, which the sync script keeps
+// equal to the bridge package.json version). The server reads its own version
+// from its package.json at runtime (package-version.ts). This module compares
+// the two and produces an advisory result — we WARN and continue rather than
+// hard-failing, so a mixed pair never silently misbehaves but also never blocks
+// a user who knows what they are doing. The check is advisory by design.
+//
+// The matching rule follows the pre-1.0 semver convention used across the repo:
+// while the major version is 0, the MINOR digit is the breaking axis. So for
+// `0.x`, both sides must agree on the full `0.minor` pair to be considered
+// compatible; patch differences (0.5.0 vs 0.5.1) are compatible and only warn.
+// Once the project reaches 1.0, the major digit becomes the breaking axis (the
+// standard reading).
+//
+// Escape hatch: setting UNITY_OPEN_MCP_SKIP_VERSION_CHECK=1 in the environment
+// fully suppresses the warning. See docs/versioning.md.
+import { readPackageVersion } from "./package-version.js";
+/**
+ * The trio version this server belongs to. Resolved once at module load from
+ * package.json (same value the bridge package.json should carry). We do not
+ * re-read per call — package.json does not change while the process runs.
+ */
+export const SHARED_VERSION = readPackageVersion();
+/** When non-empty, the version check is suppressed entirely. */
+export function isVersionCheckSuppressed() {
+    return process.env.UNITY_OPEN_MCP_SKIP_VERSION_CHECK === "1";
+}
+/**
+ * Parse `X.Y.Z` (ignoring any prerelease/build metadata) into a tuple, or
+ * `undefined` when the string is not a recognizable version. Used by the
+ * comparison below; not a full semver implementation on purpose.
+ */
+function parseLoose(v) {
+    const m = /^(\d+)\.(\d+)\.(\d+)/.exec(v);
+    if (!m)
+        return undefined;
+    return [Number(m[1]), Number(m[2]), Number(m[3])];
+}
+/**
+ * Compare the running server's version against the bridge's reported version.
+ *
+ * Rule (pre-1.0): for `0.x`, the whole `0.minor` pair must match. Patch
+ * differences are compatible (warn only). After 1.0, the major digit must
+ * match. Unparseable bridge versions are treated as compatible with a warning
+ * (an ancient bridge that predates bridgeVersion reporting shouldn't be hard
+ * blocked) — this keeps the check forward-compatible with older installs.
+ *
+ * Always returns a structured result; the caller decides whether to print it.
+ * The result is advisory regardless — the connection proceeds either way.
+ */
+export function checkBridgeCompat(bridgeVersion, serverVersion = SHARED_VERSION) {
+    const server = parseLoose(serverVersion);
+    const bridge = parseLoose(bridgeVersion);
+    if (!bridge || !server) {
+        return {
+            ok: true,
+            serverVersion,
+            bridgeVersion,
+            message: `unity-open-mcp: could not compare versions ` +
+                `(server ${serverVersion}, bridge ${bridgeVersion}). ` +
+                `Continuing; if tools misbehave, align both to the same release.`,
+        };
+    }
+    const equal = serverVersion === bridgeVersion;
+    if (equal) {
+        return {
+            ok: true,
+            serverVersion,
+            bridgeVersion,
+            message: "",
+        };
+    }
+    // Determine the breaking axis. Pre-1.0 (major === 0 on either side) uses the
+    // minor digit as the breaking axis; otherwise the major digit. We take the
+    // max of both majors so a 0.x server talking to a 1.0 bridge is treated as
+    // a major mismatch (which it is).
+    const breakingAxis = server[0] === 0 || bridge[0] === 0 ? "minor" : "major";
+    const majorMismatch = server[0] !== bridge[0];
+    const minorMismatch = server[1] !== bridge[1];
+    const incompatible = breakingAxis === "major" ? majorMismatch : majorMismatch || minorMismatch;
+    if (!incompatible) {
+        // Patch-only difference — compatible, advisory only.
+        return {
+            ok: true,
+            serverVersion,
+            bridgeVersion,
+            message: `unity-open-mcp: version drift (server ${serverVersion}, bridge ${bridgeVersion}). ` +
+                `Compatible (patch difference only). To silence this, align both releases.`,
+        };
+    }
+    // Determine which side is older so the message can name the exact fix.
+    const serverNewer = server[0] > bridge[0] ||
+        (server[0] === bridge[0] && server[1] > bridge[1]) ||
+        (server[0] === bridge[0] && server[1] === bridge[1] && server[2] > bridge[2]);
+    const older = serverNewer ? "bridge" : "server";
+    const targetVersion = serverNewer ? serverVersion : bridgeVersion;
+    const fix = older === "bridge"
+        ? `In Unity: Window → Package Manager → update the bridge package ` +
+            `(tag bridge-v${targetVersion}).`
+        : `Run: npm i -g unity-open-mcp@${targetVersion}`;
+    return {
+        ok: false,
+        serverVersion,
+        bridgeVersion,
+        message: `unity-open-mcp: INCOMPATIBLE versions — server ${serverVersion}, bridge ${bridgeVersion}.\n` +
+            `  The ${older} is older. To fix: ${fix}\n` +
+            `  (Set UNITY_OPEN_MCP_SKIP_VERSION_CHECK=1 to suppress this warning.)`,
+    };
+}
+/** True when the bridge version differs from the server at all. Used by callers
+ *  that only want to know whether to render a compat line. */
+export function versionsDiffer(bridgeVersion, serverVersion = SHARED_VERSION) {
+    return bridgeVersion !== serverVersion;
+}
+//# sourceMappingURL=compat.js.map

package/dist/compat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compat.js","sourceRoot":"","sources":["../src/compat.ts"],"names":[],"mappings":"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"}

package/dist/compiler-errors.d.ts

@@ -0,0 +1,31 @@
+/** Maximum number of distinct errors we surface. Bounded so a giant wall of
+ *  errors can't blow up the tool response; the agent can fix-and-recheck. */
+export declare const MAX_COMPILER_ERRORS = 50;
+/** A single compiler diagnostic, parsed from a Unity diagnostic line. */
+export interface CompilerError {
+    /** The full original line, e.g.
+     *  `Assets/Foo.cs(10,14): error CS0246: ...`. */
+    raw: string;
+    /** Asset-relative file path, e.g. `Assets/Foo.cs`. Empty when the line had
+     *  no parseable locator. */
+    file: string;
+    /** 1-based line number, or 0 when unparseable. */
+    line: number;
+    /** Error code, e.g. `CS0246`. */
+    code: string;
+    /** The message after the code. */
+    message: string;
+}
+/**
+ * Extract CSxxxx diagnostics as structured records, deduped by raw line, in
+ * first-seen order, capped at MAX_COMPILER_ERRORS. Lines that don't match the
+ * full `path(line,col): error CSxxxx: message` shape (rare — Unity is
+ * consistent) still contribute via a best-effort record with empty file/line.
+ */
+export declare function extractStructuredCompilerErrors(output: string): CompilerError[];
+/**
+ * Legacy raw-substring extractor. Returns the matched `error CSxxxx: ...`
+ * substrings (without the leading asset locator), deduped, capped. Kept for
+ * the batch-spawn fallback path and its existing tests.
+ */
+export declare function extractCompilerErrors(output: string): string[];

package/dist/compiler-errors.js

@@ -0,0 +1,91 @@
+// C# compiler-error extraction, shared between the batch compile_check path
+// (batch-spawn.ts) and the offline read_compile_errors tool (unity-log.ts /
+// read-compile-errors.ts). Both consume raw Unity compiler output that looks
+// like:
+//
+//   Assets/Path.cs(line,col): error CSxxxx: message
+//
+// Unity formats every diagnostic this way regardless of where it is emitted —
+// stdout of a -batchmode Unity, the platform Editor.log, or the Editor
+// console. A single extractor therefore serves both the "second Unity we
+// spawned" and "the live Editor's log file" sources.
+//
+// The raw-line extractor (extractCompilerErrors) returns the matched
+// substrings as-is and is what batch-spawn uses for its best-effort fallback
+// when the batch entry point never printed JSON markers. The structured
+// extractor (extractStructuredCompilerErrors) additionally parses out the
+// leading asset locator (file, line, column) and the CS code, which is what
+// an agent needs to fix the offending file.
+/** Maximum number of distinct errors we surface. Bounded so a giant wall of
+ *  errors can't blow up the tool response; the agent can fix-and-recheck. */
+export const MAX_COMPILER_ERRORS = 50;
+// Match the full diagnostic line, capturing:
+//   group 1: asset locator — `path(line,col)` or `path(line,line)` (Unity
+//             sometimes emits a range). The path is everything up to the last
+//             `(` before `):`.
+//   group 2: file path (the part of the locator before the paren)
+//   group 3: line number
+//   group 4: CS error code (CSxxxx)
+//   group 5: message
+// `error CSxxxx:` may appear mid-line (Unity prints the asset locator first),
+// so we do not anchor to line start. Lines are matched on a single-line basis
+// (no [^\n]* prefix that would run across newlines).
+const COMPILER_ERROR_RE = /(([^()\r\n]+)\((\d+)[^\)]*\)):\s*error\s+(CS\d{4}):\s*([^\r\n]+)/g;
+// The raw-substring regex retained for the legacy extractCompilerErrors API
+// (batch-spawn). It matches the tail `error CSxxxx: ...` without the asset
+// locator; the structured extractor above supersedes it for new callers.
+const COMPILER_ERROR_TAIL_RE = /error\s+CS\d{4}:[^\n]+/g;
+/**
+ * Extract CSxxxx diagnostics as structured records, deduped by raw line, in
+ * first-seen order, capped at MAX_COMPILER_ERRORS. Lines that don't match the
+ * full `path(line,col): error CSxxxx: message` shape (rare — Unity is
+ * consistent) still contribute via a best-effort record with empty file/line.
+ */
+export function extractStructuredCompilerErrors(output) {
+    if (!output)
+        return [];
+    const seen = new Set();
+    const errors = [];
+    COMPILER_ERROR_RE.lastIndex = 0;
+    let m;
+    while ((m = COMPILER_ERROR_RE.exec(output)) !== null) {
+        const raw = m[0].trim();
+        if (!raw || seen.has(raw))
+            continue;
+        seen.add(raw);
+        errors.push({
+            raw,
+            file: (m[2] ?? "").trim(),
+            line: m[3] ? parseInt(m[3], 10) : 0,
+            code: m[4] ?? "",
+            message: (m[5] ?? "").trim(),
+        });
+        if (errors.length >= MAX_COMPILER_ERRORS)
+            break;
+    }
+    return errors;
+}
+/**
+ * Legacy raw-substring extractor. Returns the matched `error CSxxxx: ...`
+ * substrings (without the leading asset locator), deduped, capped. Kept for
+ * the batch-spawn fallback path and its existing tests.
+ */
+export function extractCompilerErrors(output) {
+    if (!output)
+        return [];
+    const seen = new Set();
+    const errors = [];
+    COMPILER_ERROR_TAIL_RE.lastIndex = 0;
+    let m;
+    while ((m = COMPILER_ERROR_TAIL_RE.exec(output)) !== null) {
+        const line = m[0].trim();
+        if (line && !seen.has(line)) {
+            seen.add(line);
+            errors.push(line);
+            if (errors.length >= MAX_COMPILER_ERRORS)
+                break;
+        }
+    }
+    return errors;
+}
+//# sourceMappingURL=compiler-errors.js.map

package/dist/compiler-errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler-errors.js","sourceRoot":"","sources":["../src/compiler-errors.ts"],"names":[],"mappings":"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"}

package/dist/compressible-router.d.ts

@@ -0,0 +1,18 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { LiveClient } from "./live-client.js";
+import type { AssetModel } from "./compression/asset-model.js";
+export declare function isCompressible(toolName: string): boolean;
+/** Session-scoped LRU for the last few AssetModels read by `read_asset`. */
+export declare class AssetModelCache {
+    private entries;
+    get(key: string): AssetModel | null;
+    set(key: string, model: AssetModel): void;
+    clear(): void;
+    get size(): number;
+}
+/**
+ * Route a compressible tool: try offline parser first for text-serialized
+ * assets, fall back to the live bridge for binary formats. Cache the model
+ * (read_asset only), apply the compression module, and return.
+ */
+export declare function routeCompressible(toolName: string, args: Record<string, unknown>, live: LiveClient, cache: AssetModelCache, projectPath: string): Promise<CallToolResult>;