unity-open-mcp 0.1.0

package/dist/resources/index.js

@@ -0,0 +1,40 @@
+export const healthSummary = {
+    uri: "unity-open-mcp://health/summary",
+    name: "Health summary",
+    mimeType: "application/json",
+    description: "Cached verify health summary (error/warn/info counts) from the last scan or gate validation.",
+};
+export const healthBaseline = {
+    uri: "unity-open-mcp://health/baseline",
+    name: "Health baseline",
+    mimeType: "application/json",
+    description: "Baseline JSON file summary (schemaVersion, platformProfile, severity counts) read from disk.",
+};
+export const bridgeStatus = {
+    uri: "unity-open-mcp://bridge/status",
+    name: "Bridge status",
+    mimeType: "application/json",
+    description: "Cached snapshot of the last successful bridge /ping response (connection, compile, play mode).",
+};
+// M18 Plan 2 / T18.2.3 — tool-groups capability resource. Static catalog
+// (group ids, descriptions, default-enabled flags) discoverable before the
+// first domain tool call. For compiled-state availability and the per-tool
+// roster, call unity_open_mcp_capabilities (which embeds the full
+// toolGroups block). For session activation state, call
+// unity_open_mcp_manage_tools(action="list_groups").
+export const toolGroups = {
+    uri: "unity-open-mcp://tool-groups",
+    name: "Tool groups",
+    mimeType: "application/json",
+    description: "Tool-group catalog (ids, descriptions, default-enabled flags). " +
+        "Call unity_open_mcp_manage_tools to activate a group before using " +
+        "its tools; call unity_open_mcp_capabilities for compiled-state " +
+        "availability and the per-tool roster.",
+};
+export const ALL_RESOURCES = [
+    healthSummary,
+    healthBaseline,
+    bridgeStatus,
+    toolGroups,
+];
+//# sourceMappingURL=index.js.map

package/dist/resources/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/resources/index.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,aAAa,GAAa;IACrC,GAAG,EAAE,iCAAiC;IACtC,IAAI,EAAE,gBAAgB;IACtB,QAAQ,EAAE,kBAAkB;IAC5B,WAAW,EACT,8FAA8F;CACjG,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAAa;IACtC,GAAG,EAAE,kCAAkC;IACvC,IAAI,EAAE,iBAAiB;IACvB,QAAQ,EAAE,kBAAkB;IAC5B,WAAW,EACT,8FAA8F;CACjG,CAAC;AAEF,MAAM,CAAC,MAAM,YAAY,GAAa;IACpC,GAAG,EAAE,gCAAgC;IACrC,IAAI,EAAE,eAAe;IACrB,QAAQ,EAAE,kBAAkB;IAC5B,WAAW,EACT,gGAAgG;CACnG,CAAC;AAEF,yEAAyE;AACzE,2EAA2E;AAC3E,2EAA2E;AAC3E,kEAAkE;AAClE,wDAAwD;AACxD,qDAAqD;AACrD,MAAM,CAAC,MAAM,UAAU,GAAa;IAClC,GAAG,EAAE,8BAA8B;IACnC,IAAI,EAAE,aAAa;IACnB,QAAQ,EAAE,kBAAkB;IAC5B,WAAW,EACT,iEAAiE;QACjE,oEAAoE;QACpE,iEAAiE;QACjE,uCAAuC;CAC1C,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAe;IACvC,aAAa;IACb,cAAc;IACd,YAAY;IACZ,UAAU;CACX,CAAC"}

package/dist/results.d.ts

@@ -0,0 +1,14 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+export interface ErrorResultInput {
+    /** Stable machine-readable code (e.g. `bridge_error`, `batch_not_supported`). */
+    code: string;
+    /** Human-readable explanation. */
+    message: string;
+    /**
+     * Optional custom body. When provided (non-nullish), it replaces the default
+     * `{ error: { code, message } }` envelope. Use this when a caller needs to
+     * surface richer structured data (e.g. HTTP status + body from the bridge).
+     */
+    detail?: unknown;
+}
+export declare function makeErrorResult(input: ErrorResultInput): CallToolResult;

package/dist/results.js

@@ -0,0 +1,22 @@
+// Shared CallToolResult error factory.
+//
+// This used to live as three near-identical private helpers in batch-spawn.ts,
+// compressible-router.ts, and live-client.ts — with two different positional
+// argument orders (the compressible-router copy had `message, code` while the
+// others used `code, message`). That made it easy to swap the arguments by
+// mistake at any call site. The single named-argument factory below removes the
+// ambiguity: code, message, and the optional `detail` override are named.
+//
+// Wire shape is unchanged. When `detail` is omitted (or nullish), the result
+// body is `{ error: { code, message } }` — exactly what every downstream parser
+// (and every existing test asserting `body.error.code`) expects. When `detail`
+// is supplied, it replaces the error envelope entirely (callers that build a
+// richer custom body rely on this).
+export function makeErrorResult(input) {
+    const body = input.detail ?? { error: { code: input.code, message: input.message } };
+    return {
+        content: [{ type: "text", text: JSON.stringify(body) }],
+        isError: true,
+    };
+}
+//# sourceMappingURL=results.js.map

package/dist/results.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"results.js","sourceRoot":"","sources":["../src/results.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,EAAE;AACF,+EAA+E;AAC/E,6EAA6E;AAC7E,8EAA8E;AAC9E,2EAA2E;AAC3E,gFAAgF;AAChF,0EAA0E;AAC1E,EAAE;AACF,6EAA6E;AAC7E,gFAAgF;AAChF,+EAA+E;AAC/E,6EAA6E;AAC7E,oCAAoC;AAiBpC,MAAM,UAAU,eAAe,CAAC,KAAuB;IACrD,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,IAAI,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC;IACrF,OAAO;QACL,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;QACvD,OAAO,EAAE,IAAI;KACd,CAAC;AACJ,CAAC"}

package/dist/router.d.ts

@@ -0,0 +1,5 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+export type { CallToolResult };
+export interface Router {
+    route(toolName: string, args: Record<string, unknown>): Promise<CallToolResult>;
+}

package/dist/router.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=router.js.map

package/dist/router.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.js","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":""}

package/dist/routers.d.ts

@@ -0,0 +1,44 @@
+import { LiveClient } from "./live-client.js";
+import { BatchSpawn } from "./batch-spawn.js";
+import { ToolRouter } from "./tool-router.js";
+import { PingCache } from "./ping-cache.js";
+import { ResourceRouter } from "./resource-router.js";
+import { BridgeEventStream } from "./event-stream.js";
+import { ToolSessionState } from "./tool-session-state.js";
+export interface ResolvedEnv {
+    projectPath: string;
+    port: number;
+    authToken: string | undefined;
+}
+/**
+ * Resolve the project path / port / auth token from explicit overrides (CLI
+ * flags) or the process env (MCP server). Throws when no project path is set —
+ * callers print a friendly message and exit non-zero.
+ *
+ * Mirrors the precedence in index.ts#getEnv:
+ *   projectPath: override > UNITY_PROJECT_PATH
+ *   port:        override > UNITY_OPEN_MCP_BRIDGE_PORT > lock file > hash
+ *   authToken:   discovered from the same lock as the port (no token with an
+ *                explicit port override)
+ */
+export declare function resolveEnv(projectPathOverride?: string, portOverride?: number): ResolvedEnv;
+export declare class ResolveEnvError extends Error {
+}
+export interface RouterStack {
+    live: LiveClient;
+    batch: BatchSpawn;
+    router: ToolRouter;
+    pingCache: PingCache;
+    resourceRouter: ResourceRouter;
+    eventStream: BridgeEventStream;
+    sessionState: ToolSessionState;
+    projectPath: string;
+    port: number;
+    authToken: string | undefined;
+}
+/**
+ * Build the full router stack from resolved env. The CLI uses this directly;
+ * the stdio server wraps the result in an MCP Server (see createServer in
+ * index.ts).
+ */
+export declare function buildRouterStack(env: ResolvedEnv): RouterStack;

package/dist/routers.js

@@ -0,0 +1,73 @@
+// M15 T6.1 — Shared router-stack construction.
+//
+// `index.ts` (stdio server) and `src/cli/` (thin CLI) both need the same
+// LiveClient + BatchSpawn + ToolRouter wiring. Centralizing it here means a
+// CLI command sees the exact same routing decisions an MCP client would — the
+// acceptance criterion "run-tool returns the same JSON the MCP server would"
+// holds by construction.
+import { LiveClient } from "./live-client.js";
+import { BatchSpawn } from "./batch-spawn.js";
+import { ToolRouter } from "./tool-router.js";
+import { PingCache } from "./ping-cache.js";
+import { ResourceRouter } from "./resource-router.js";
+import { BridgeEventStream } from "./event-stream.js";
+import { resolvePort, resolveAuthToken } from "./instance-discovery.js";
+import { ToolSessionState } from "./tool-session-state.js";
+/**
+ * Resolve the project path / port / auth token from explicit overrides (CLI
+ * flags) or the process env (MCP server). Throws when no project path is set —
+ * callers print a friendly message and exit non-zero.
+ *
+ * Mirrors the precedence in index.ts#getEnv:
+ *   projectPath: override > UNITY_PROJECT_PATH
+ *   port:        override > UNITY_OPEN_MCP_BRIDGE_PORT > lock file > hash
+ *   authToken:   discovered from the same lock as the port (no token with an
+ *                explicit port override)
+ */
+export function resolveEnv(projectPathOverride, portOverride) {
+    const projectPath = projectPathOverride ?? process.env.UNITY_PROJECT_PATH;
+    if (!projectPath) {
+        throw new ResolveEnvError("UNITY_PROJECT_PATH environment variable is required " +
+            "(or pass --project <path>).");
+    }
+    const rawEnvPort = process.env.UNITY_OPEN_MCP_BRIDGE_PORT;
+    const envPort = rawEnvPort ? parseInt(rawEnvPort, 10) : undefined;
+    const effectiveEnvPort = rawEnvPort && Number.isInteger(envPort) ? envPort : undefined;
+    const port = resolvePort(projectPath, portOverride ?? effectiveEnvPort);
+    const authToken = resolveAuthToken(projectPath, portOverride ?? effectiveEnvPort);
+    return { projectPath, port, authToken };
+}
+export class ResolveEnvError extends Error {
+}
+/**
+ * Build the full router stack from resolved env. The CLI uses this directly;
+ * the stdio server wraps the result in an MCP Server (see createServer in
+ * index.ts).
+ */
+export function buildRouterStack(env) {
+    const pingCache = new PingCache();
+    const live = new LiveClient(env.port, pingCache, env.authToken, env.projectPath);
+    const batch = new BatchSpawn();
+    const eventStream = new BridgeEventStream(`http://127.0.0.1:${env.port}`, undefined, env.authToken);
+    const sessionState = new ToolSessionState();
+    const router = new ToolRouter(live, batch, env.projectPath, eventStream, sessionState);
+    const resourceRouter = new ResourceRouter({
+        live,
+        pingCache,
+        projectPath: env.projectPath,
+        port: env.port,
+    });
+    return {
+        live,
+        batch,
+        router,
+        pingCache,
+        resourceRouter,
+        eventStream,
+        sessionState,
+        projectPath: env.projectPath,
+        port: env.port,
+        authToken: env.authToken,
+    };
+}
+//# sourceMappingURL=routers.js.map

package/dist/routers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routers.js","sourceRoot":"","sources":["../src/routers.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,EAAE;AACF,yEAAyE;AACzE,4EAA4E;AAC5E,8EAA8E;AAC9E,6EAA6E;AAC7E,yBAAyB;AAEzB,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAQ3D;;;;;;;;;;GAUG;AACH,MAAM,UAAU,UAAU,CACxB,mBAA4B,EAC5B,YAAqB;IAErB,MAAM,WAAW,GAAG,mBAAmB,IAAI,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC;IAC1E,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,MAAM,IAAI,eAAe,CACvB,sDAAsD;YACpD,6BAA6B,CAChC,CAAC;IACJ,CAAC;IAED,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAC;IAC1D,MAAM,OAAO,GAAG,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAClE,MAAM,gBAAgB,GACpB,UAAU,IAAI,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;IAEhE,MAAM,IAAI,GAAG,WAAW,CACtB,WAAW,EACX,YAAY,IAAI,gBAAgB,CACjC,CAAC;IACF,MAAM,SAAS,GAAG,gBAAgB,CAChC,WAAW,EACX,YAAY,IAAI,gBAAgB,CACjC,CAAC;IAEF,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;AAC1C,CAAC;AAED,MAAM,OAAO,eAAgB,SAAQ,KAAK;CAAG;AAkB7C;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,GAAgB;IAC/C,MAAM,SAAS,GAAG,IAAI,SAAS,EAAE,CAAC;IAClC,MAAM,IAAI,GAAG,IAAI,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,CAAC,SAAS,EAAE,GAAG,CAAC,WAAW,CAAC,CAAC;IACjF,MAAM,KAAK,GAAG,IAAI,UAAU,EAAE,CAAC;IAC/B,MAAM,WAAW,GAAG,IAAI,iBAAiB,CACvC,oBAAoB,GAAG,CAAC,IAAI,EAAE,EAC9B,SAAS,EACT,GAAG,CAAC,SAAS,CACd,CAAC;IACF,MAAM,YAAY,GAAG,IAAI,gBAAgB,EAAE,CAAC;IAC5C,MAAM,MAAM,GAAG,IAAI,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,CAAC,WAAW,EAAE,WAAW,EAAE,YAAY,CAAC,CAAC;IACvF,MAAM,cAAc,GAAG,IAAI,cAAc,CAAC;QACxC,IAAI;QACJ,SAAS;QACT,WAAW,EAAE,GAAG,CAAC,WAAW;QAC5B,IAAI,EAAE,GAAG,CAAC,IAAI;KACf,CAAC,CAAC;IACH,OAAO;QACL,IAAI;QACJ,KAAK;QACL,MAAM;QACN,SAAS;QACT,cAAc;QACd,WAAW;QACX,YAAY;QACZ,WAAW,EAAE,GAAG,CAAC,WAAW;QAC5B,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,SAAS,EAAE,GAAG,CAAC,SAAS;KACzB,CAAC;AACJ,CAAC"}

package/dist/schema-defaults.d.ts

@@ -0,0 +1,10 @@
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+/**
+ * Returns a copy of `args` with missing top-level scalar defaults filled in
+ * from the given tool's input schema. Object/array defaults are ignored (they
+ * require deep merge and no tool currently uses them).
+ *
+ * The original `args` object is never mutated. Existing caller-supplied values
+ * are preserved verbatim, including `undefined`/`null`.
+ */
+export declare function withSchemaDefaults(tool: Tool, args: Record<string, unknown>): Record<string, unknown>;

package/dist/schema-defaults.js

@@ -0,0 +1,43 @@
+// Schema-default injection.
+//
+// MCP JSON-Schema documents advertise per-property `default` values (e.g.
+// `run_tests` documents `timeout_ms` default 60000). Those defaults are advisory:
+// an MCP client MAY echo them, but many send args verbatim and omit the field
+// entirely. When that happens, every downstream layer (the TS HTTP fetch, the
+// C# bridge, the Unity-side dispatch) independently falls back to its own
+// hardcoded default — historically 30000 — which silently contradicts the
+// documented value and produced the "tool times out at 30s" bug for
+// run_tests (whose schema default is 60000).
+//
+// To make the schema the single source of truth, the CallTool handler fills in
+// any missing top-level argument whose property declares a scalar `default`
+// before dispatching. This keeps client-supplied values authoritative and only
+// ever adds missing fields.
+function isScalarDefault(value) {
+    return (typeof value === "number" ||
+        typeof value === "boolean" ||
+        typeof value === "string");
+}
+/**
+ * Returns a copy of `args` with missing top-level scalar defaults filled in
+ * from the given tool's input schema. Object/array defaults are ignored (they
+ * require deep merge and no tool currently uses them).
+ *
+ * The original `args` object is never mutated. Existing caller-supplied values
+ * are preserved verbatim, including `undefined`/`null`.
+ */
+export function withSchemaDefaults(tool, args) {
+    const properties = tool.inputSchema?.properties;
+    if (!properties)
+        return { ...args };
+    const out = { ...args };
+    for (const [key, schema] of Object.entries(properties)) {
+        if (key in out)
+            continue;
+        const def = schema?.default;
+        if (isScalarDefault(def))
+            out[key] = def;
+    }
+    return out;
+}
+//# sourceMappingURL=schema-defaults.js.map

package/dist/schema-defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-defaults.js","sourceRoot":"","sources":["../src/schema-defaults.ts"],"names":[],"mappings":"AAAA,4BAA4B;AAC5B,EAAE;AACF,0EAA0E;AAC1E,kFAAkF;AAClF,8EAA8E;AAC9E,8EAA8E;AAC9E,0EAA0E;AAC1E,0EAA0E;AAC1E,oEAAoE;AACpE,6CAA6C;AAC7C,EAAE;AACF,+EAA+E;AAC/E,4EAA4E;AAC5E,+EAA+E;AAC/E,4BAA4B;AAY5B,SAAS,eAAe,CAAC,KAAc;IACrC,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,OAAO,KAAK,KAAK,SAAS;QAC1B,OAAO,KAAK,KAAK,QAAQ,CAC1B,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB,CAChC,IAAU,EACV,IAA6B;IAE7B,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,EAAE,UAExB,CAAC;IACd,IAAI,CAAC,UAAU;QAAE,OAAO,EAAE,GAAG,IAAI,EAAE,CAAC;IAEpC,MAAM,GAAG,GAA4B,EAAE,GAAG,IAAI,EAAE,CAAC;IACjD,KAAK,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC;QACvD,IAAI,GAAG,IAAI,GAAG;YAAE,SAAS;QACzB,MAAM,GAAG,GAAG,MAAM,EAAE,OAAO,CAAC;QAC5B,IAAI,eAAe,CAAC,GAAG,CAAC;YAAE,GAAG,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;IAC3C,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/skill/client-paths.d.ts

@@ -0,0 +1,33 @@
+export interface ClientPathEntry {
+    relativePath: string;
+}
+export interface ClientPathsManifest {
+    skillId: string;
+    templateRelativePath: string;
+    clients: Record<string, ClientPathEntry>;
+    mcpClientMapping: Record<string, string[]>;
+}
+/**
+ * Bundled fallback mirroring `skills/client-paths.json`. A unit test
+ * asserts this stays in sync with the on-disk manifest so the two
+ * never drift silently.
+ */
+export declare const BUNDLED_MANIFEST: ClientPathsManifest;
+/**
+ * Load the client-paths manifest. Resolution is cached after the
+ * first call (the manifest is immutable for the lifetime of the
+ * process).
+ */
+export declare function loadClientPathsManifest(): ClientPathsManifest;
+/**
+ * Project-relative skill path for a client key
+ * (`cursor` / `claude` / `opencode` / `agents`). Throws for unknown
+ * keys so callers fail loudly instead of writing to a wrong path.
+ */
+export declare function clientSkillRelativePath(clientKey: string): string;
+/**
+ * All known client keys from the manifest — used to derive the
+ * `unity_open_mcp_generate_skill` `clients` enum and the allowlist in
+ * the tool router.
+ */
+export declare function knownClientKeys(): string[];

package/dist/skill/client-paths.js

@@ -0,0 +1,131 @@
+// Skill client-path manifest — single source of truth.
+//
+// The checked-in manifest lives at the toolkit root:
+//   `skills/client-paths.json`
+// This module is the ONLY consumer on the mcp-server side. The Hub
+// wizard (`hub/src-tauri/src/config/mcp_config.rs`) reads the same
+// file directly from the toolkit root. To add or rename a client,
+// edit `skills/client-paths.json` — do not hand-maintain duplicate
+// constants here or in Rust.
+//
+// Resolution strategy:
+//   1. `UNITY_OPEN_MCP_TOOLKIT_ROOT` env var (when the Hub or a
+//      launcher pins the toolkit root explicitly).
+//   2. Walk up from this module's location looking for
+//      `skills/client-paths.json` (covers `mcp-server/src/` in dev
+//      and `mcp-server/dist/` in a built checkout).
+//   3. Bundled fallback constant (kept in sync with the manifest by
+//      a unit test) so the skill generator still works in a
+//      standalone `mcp-server/` install that lacks the toolkit tree.
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const MANIFEST_REL = "skills/client-paths.json";
+/**
+ * Bundled fallback mirroring `skills/client-paths.json`. A unit test
+ * asserts this stays in sync with the on-disk manifest so the two
+ * never drift silently.
+ */
+export const BUNDLED_MANIFEST = {
+    skillId: "unity-open-mcp",
+    templateRelativePath: "skills/unity-open-mcp/SKILL.md",
+    clients: {
+        cursor: { relativePath: ".cursor/skills/unity-open-mcp/SKILL.md" },
+        claude: { relativePath: ".claude/skills/unity-open-mcp/SKILL.md" },
+        opencode: { relativePath: ".opencode/skills/unity-open-mcp/SKILL.md" },
+        agents: { relativePath: ".agents/skills/unity-open-mcp/SKILL.md" },
+    },
+    mcpClientMapping: {
+        cursor: ["cursor"],
+        "claude-desktop": ["claude"],
+        "claude-code": ["claude"],
+        "opencode-global": ["opencode"],
+        "opencode-project": ["opencode"],
+        "zcode-global": ["agents"],
+        "zcode-project": ["agents"],
+        manual: ["cursor", "claude", "opencode", "agents"],
+    },
+};
+function hereDir() {
+    // Works under both `node --experimental-strip-types` (src) and the
+    // compiled `dist/` output.
+    if (typeof __dirname !== "undefined")
+        return __dirname;
+    return dirname(fileURLToPath(import.meta.url));
+}
+function tryReadManifest(path) {
+    try {
+        const raw = readFileSync(path, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.skillId === "string" &&
+            typeof parsed.templateRelativePath === "string" &&
+            parsed.clients &&
+            typeof parsed.clients === "object" &&
+            parsed.mcpClientMapping &&
+            typeof parsed.mcpClientMapping === "object") {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveManifest() {
+    // 1. Explicit env override.
+    const envRoot = process.env.UNITY_OPEN_MCP_TOOLKIT_ROOT?.trim();
+    if (envRoot) {
+        const fromEnv = tryReadManifest(join(envRoot, MANIFEST_REL));
+        if (fromEnv)
+            return fromEnv;
+    }
+    // 2. Walk up from this module's directory looking for the toolkit
+    //    root (i.e. a parent dir containing `skills/client-paths.json`).
+    let dir = hereDir();
+    for (let i = 0; i < 8; i++) {
+        const candidate = join(dir, MANIFEST_REL);
+        const m = tryReadManifest(candidate);
+        if (m)
+            return m;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    // 3. Bundled fallback (validated against the manifest by tests).
+    return BUNDLED_MANIFEST;
+}
+let cached = null;
+/**
+ * Load the client-paths manifest. Resolution is cached after the
+ * first call (the manifest is immutable for the lifetime of the
+ * process).
+ */
+export function loadClientPathsManifest() {
+    if (cached)
+        return cached;
+    cached = resolveManifest();
+    return cached;
+}
+/**
+ * Project-relative skill path for a client key
+ * (`cursor` / `claude` / `opencode` / `agents`). Throws for unknown
+ * keys so callers fail loudly instead of writing to a wrong path.
+ */
+export function clientSkillRelativePath(clientKey) {
+    const manifest = loadClientPathsManifest();
+    const entry = manifest.clients[clientKey];
+    if (!entry) {
+        throw new Error(`Unknown skill client key "${clientKey}". Known keys: ${Object.keys(manifest.clients).join(", ")}.`);
+    }
+    return entry.relativePath;
+}
+/**
+ * All known client keys from the manifest — used to derive the
+ * `unity_open_mcp_generate_skill` `clients` enum and the allowlist in
+ * the tool router.
+ */
+export function knownClientKeys() {
+    return Object.keys(loadClientPathsManifest().clients);
+}
+//# sourceMappingURL=client-paths.js.map

package/dist/skill/client-paths.js.map

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

package/dist/skill/generate-skill.d.ts

@@ -0,0 +1,38 @@
+import type { CapabilitiesResult } from "../capabilities/build-capabilities.js";
+export interface PackageEntry {
+    id: string;
+    version: string;
+}
+export interface TypeEntry {
+    name: string;
+    namespace: string;
+    filePath: string;
+}
+export interface ProjectState {
+    projectName: string;
+    unityVersion: string;
+    packages: PackageEntry[];
+    bridgeVersion: string | null;
+    verifyVersion: string | null;
+    monoBehaviours: TypeEntry[];
+    scriptableObjects: TypeEntry[];
+}
+export interface SkillWriteTarget {
+    client: string;
+    relativePath: string;
+    absolutePath: string;
+    written: boolean;
+    existed: boolean;
+}
+export interface GenerateSkillResult {
+    skill: string;
+    project: ProjectState;
+    written: SkillWriteTarget[];
+}
+export declare function readProjectState(projectRoot: string): Promise<ProjectState>;
+export declare function generateSkillMarkdown(state: ProjectState, caps: CapabilitiesResult): string;
+export declare function writeSkillToClients(projectRoot: string, content: string, clients: string[]): Promise<SkillWriteTarget[]>;
+export declare function generateSkill(projectRoot: string, caps: CapabilitiesResult, options?: {
+    write?: boolean;
+    clients?: string[];
+}): Promise<GenerateSkillResult>;