@uemcp/server 1.1.0 → 1.2.0

package/README.md

@@ -44,6 +44,10 @@ The MCP tool surface currently exposes:
 - `redo`
 - `open_level`
 - `get_open_level_status`
+- `get_source_control_status`
+- `refresh_source_control_status`
+- `checkout_assets`
+- `get_source_control_job_status`
 
 ## Project Identity
 
@@ -101,9 +105,9 @@ This is intended to let an MCP client resolve the canonical Unreal project ident
 ### `wait_for_job`
 
 - Blocks server-side until an async job reaches a terminal state, then returns the payload the matching `get_*_status` tool would have returned under `status`
-- Replaces a client-side poll loop for `kind` `compile` (`trigger_live_compile` / `trigger_hot_reload`), `create_class`, `test_run`, and `pie`; `kind` is required because job ids are bare GUIDs
+- Replaces a client-side poll loop for `kind` `compile` (`trigger_live_compile` / `trigger_hot_reload`), `create_class`, `test_run`, `pie`, and `source_control` (`checkout_assets` / `refresh_source_control_status`); `kind` is required because job ids are bare GUIDs
 - `outcome` is `completed`, `timed_out` (last observed status still returned), or `unknown_job` (unknown/expired/cancelled id, returned on the first poll)
-- Per-kind default budgets (compile 120s, create_class 60s, pie 30s, test_run 300s), clamped to 600s; polls back off from 250ms (1s for test runs) and a transient bridge read timeout or dropped socket is retried rather than failing the wait
+- Per-kind default budgets (compile 120s, create_class 60s, pie 30s, source_control 60s, test_run 300s), clamped to 600s; polls back off from 250ms (1s for test runs) and a transient bridge read timeout or dropped socket is retried rather than failing the wait
 - For `test_run`, `status.results` is the first page — page the rest with `get_test_run_status` and `nextCursor`
 
 ### `build_target` / `generate_project_files` / `clean_build`
@@ -182,6 +186,18 @@ This is intended to let an MCP client resolve the canonical Unreal project ident
 - Actor paths do not survive a load: re-run `list_actors` against the new world rather than reusing paths from the old one
 - One load at a time per editor; a second request while one is running is refused with `open_level_in_progress` rather than queued
 
+### `get_source_control_status` / `refresh_source_control_status` / `checkout_assets` / `get_source_control_job_status`
+
+- The prerequisite for every asset write on a team project. Under Perforce or Git-LFS file locking a `.uasset` stays read-only until it is checked out, so a write that skips this fails later at save time — several tool calls away from its cause
+- `get_source_control_status` answers **inline**: it reads the provider's own state cache, which is a memory lookup rather than a server round trip. It reports the `provider` name, `enabled` (is source control configured at all), `available` (is it currently connected), and one entry per requested path with a `state` of `checked_out_by_me`, `checked_out_by_other` (plus `checkedOutBy` naming the holder), `marked_for_add`, `not_checked_out`, `not_in_depot`, or `unknown`
+- `enabled` is what separates "no source control configured" from "configured, and this file is simply not checked out". Those are never collapsed into one answer
+- A file the editor has never asked the server about reports `unknown`, **not** a guess. `refresh_source_control_status` is how it becomes a real answer. A path that resolves to no package on disk also reports `unknown`, but carries an `error` saying so — an unresolvable path never passes as a depot answer
+- `refresh_source_control_status` and `checkout_assets` talk to the source control server over the network, which runs far past the plugin's 5 s game-thread budget, so neither runs inline: each returns `state: 'accepted'` with a `sourceControlJobId`. Poll it with `get_source_control_job_status`, or wait with `wait_for_job` using `kind: 'source_control'`
+- The poll reports `successCount` / `failureCount` and one result per file with its post-operation `state`, so a checkout is confirmed without a second query. One asset the provider refuses does not abort the rest — it reports `ok: false` with its own `error`
+- Checkout only. Submitting is never done for you, and a checked-out asset stays checked out until a human submits or reverts it
+- A request against an editor with no provider configured is refused with `source_control_disabled`, and one against a configured-but-offline provider with `source_control_unavailable`. Neither degrades into a filesystem check
+- In a non-editor plugin build all four report `state: 'unsupported'` and schedule nothing
+
 ### `read_data_table` / `write_data_table_row`
 
 - A DataTable is where a project keeps its tuning data, and it is a binary `.uasset` — `find_assets` can locate one but nothing can read it off disk, so these are the only way in. `read_data_table` loads the asset and reports the row struct it is typed on, an ordered column list (`{ name, type }`, using the same type rendering `get_class_reflection` emits), and each row as a column-name-to-value map
@@ -192,7 +208,7 @@ This is intended to let an MCP client resolve the canonical Unreal project ident
 - Numeric and boolean values are range-checked **before** `ImportText` rather than after: the engine's importer takes `not-a-number` as `0` and reports success, and silent coercion is exactly the failure a tuning-data write cannot afford
 - The write runs inside a single `FScopedTransaction` (Ctrl+Z reverses it) and marks the package dirty **without saving** — compose with `save_dirty_packages`. `dryRun: true` validates everything and reports `state: 'validated'`, opening no transaction
 - Deleting a row that does not exist is **not** a failure: it reports `rowExisted: false` with an explanatory message, because the table is already in the requested state
-- A `.uasset` sits read-only on disk until it is checked out under Perforce or Git-LFS file locking. That case is detected before anything is mutated and reported as `source_control_checkout_required` rather than surfacing later as an unexplained save error
+- A `.uasset` sits read-only on disk until it is checked out under Perforce or Git-LFS file locking. That case is detected before anything is mutated rather than surfacing later as an unexplained save error. Where a provider is configured the answer comes from the provider itself — `source_control_checkout_required` for a file that is simply not checked out, `source_control_checked_out_by_other` naming the holder when someone else has it — and only where none is does it fall back to the on-disk read-only check. Fix either with `checkout_assets`
 - In a non-editor plugin build `read_data_table` fails with `unsupported` and `write_data_table_row` returns `state: 'unsupported'`
 
 ### `export_data_table` / `import_data_table`

package/dist/index.mjs

@@ -477,6 +477,27 @@ const BRIDGE_DATA_TABLE_WRITE_STATES = [
 const BRIDGE_DATA_TABLE_FORMATS = ["json", "csv"];
 const BRIDGE_DATA_TABLE_MAX_EXPORT_CHARS = 24576;
 const BRIDGE_DATA_TABLE_MAX_IMPORT_CHARS = 16384;
+const BRIDGE_GET_SOURCE_CONTROL_STATUS_REQUEST_TYPE = "get_source_control_status";
+const BRIDGE_REFRESH_SOURCE_CONTROL_STATUS_REQUEST_TYPE = "refresh_source_control_status";
+const BRIDGE_CHECKOUT_ASSETS_REQUEST_TYPE = "checkout_assets";
+const BRIDGE_GET_SOURCE_CONTROL_JOB_STATUS_REQUEST_TYPE = "get_source_control_job_status";
+const BRIDGE_SOURCE_CONTROL_FILE_STATES = [
+	"checked_out_by_me",
+	"checked_out_by_other",
+	"marked_for_add",
+	"not_checked_out",
+	"not_in_depot",
+	"unknown"
+];
+const BRIDGE_SOURCE_CONTROL_STATUS_STATES = ["reported", "unsupported"];
+const BRIDGE_SOURCE_CONTROL_JOB_ACCEPT_STATES = ["accepted", "unsupported"];
+const BRIDGE_SOURCE_CONTROL_JOB_STATES = [
+	"running",
+	"succeeded",
+	"failed",
+	"unknown_job"
+];
+const BRIDGE_SOURCE_CONTROL_OPERATIONS = ["checkout", "refresh"];
 const requestIdSchema = z.string().trim().min(1);
 const nonEmptyStringSchema = z.string().trim().min(1);
 const boundedStringSchema = z.string().trim().max(512);
@@ -595,6 +616,13 @@ const dataTableFormatSchema = z.enum(BRIDGE_DATA_TABLE_FORMATS);
 const dataTableValueMapSchema = z.record(z.string().trim().min(1).max(256), z.string().max(BRIDGE_DATA_TABLE_VALUE_MAX_CHARS)).refine((value) => Object.keys(value).length <= 200, { message: `A write carries at most ${String(200)} columns.` });
 const dataTableImportContentSchema = z.string().min(1).max(BRIDGE_DATA_TABLE_MAX_IMPORT_CHARS);
 const dataTableAssetNameSchema = z.string().trim().min(1).max(256).refine((value) => !value.includes("/") && !value.includes("."), { message: "An asset name must not contain a path separator; use destinationPath to move the asset." });
+const sourceControlAssetPathBatchSchema = z.array(assetPathSchema).min(1).max(64);
+const sourceControlFileStateSchema = z.enum(BRIDGE_SOURCE_CONTROL_FILE_STATES);
+const sourceControlStatusStateSchema = z.enum(BRIDGE_SOURCE_CONTROL_STATUS_STATES);
+const sourceControlJobAcceptStateSchema = z.enum(BRIDGE_SOURCE_CONTROL_JOB_ACCEPT_STATES);
+const sourceControlJobStateSchema = z.enum(BRIDGE_SOURCE_CONTROL_JOB_STATES);
+const sourceControlOperationSchema = z.enum(BRIDGE_SOURCE_CONTROL_OPERATIONS);
+const sourceControlJobIdSchema = z.string().trim().min(1);
 const vectorInputSchema = z.object({
 	x: z.number().default(0),
 	y: z.number().default(0),
@@ -1080,6 +1108,30 @@ const bridgeRenameDataTableRowRequestSchema = z.object({
 	type: z.literal(BRIDGE_RENAME_DATA_TABLE_ROW_REQUEST_TYPE),
 	version: z.literal(2)
 });
+const bridgeGetSourceControlStatusRequestSchema = z.object({
+	assetPaths: sourceControlAssetPathBatchSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_GET_SOURCE_CONTROL_STATUS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeRefreshSourceControlStatusRequestSchema = z.object({
+	assetPaths: sourceControlAssetPathBatchSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_REFRESH_SOURCE_CONTROL_STATUS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCheckoutAssetsRequestSchema = z.object({
+	assetPaths: sourceControlAssetPathBatchSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_CHECKOUT_ASSETS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeGetSourceControlJobStatusRequestSchema = z.object({
+	requestId: requestIdSchema,
+	sourceControlJobId: sourceControlJobIdSchema,
+	type: z.literal(BRIDGE_GET_SOURCE_CONTROL_JOB_STATUS_REQUEST_TYPE),
+	version: z.literal(2)
+});
 const bridgeGetAssetDependenciesRequestSchema = z.object({
 	assetPath: assetPathSchema,
 	categories: z.array(assetDependencyCategorySchema).max(BRIDGE_ASSET_DEPENDENCY_CATEGORIES.length).default(["package"]),
@@ -1943,6 +1995,90 @@ const bridgeRenameDataTableRowSuccessResponseSchema = z.object({
 	type: z.literal(BRIDGE_RENAME_DATA_TABLE_ROW_REQUEST_TYPE),
 	version: z.literal(2)
 }).refine(isLevelEditStateConsistent, levelEditStateRefinement);
+const bridgeSourceControlFileStateSchema = z.object({
+	assetPath: z.string(),
+	checkedOutBy: z.string().trim().min(1).optional(),
+	error: z.string().optional(),
+	index: z.number().int().min(0),
+	state: sourceControlFileStateSchema
+});
+const bridgeGetSourceControlStatusSuccessResponseSchema = z.object({
+	available: z.boolean(),
+	enabled: z.boolean(),
+	files: z.array(bridgeSourceControlFileStateSchema).max(64),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	provider: z.string().trim().min(1),
+	requestId: requestIdSchema,
+	state: sourceControlStatusStateSchema,
+	type: z.literal(BRIDGE_GET_SOURCE_CONTROL_STATUS_REQUEST_TYPE),
+	version: z.literal(2)
+}).refine((value) => value.state === "reported" || value.files.length === 0, {
+	message: "An unsupported get_source_control_status response must carry no file entries.",
+	path: ["files"]
+});
+const sourceControlJobAcceptFields = {
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	sourceControlJobId: sourceControlJobIdSchema.optional(),
+	state: sourceControlJobAcceptStateSchema,
+	version: z.literal(2)
+};
+const sourceControlJobAcceptRefinement = {
+	message: "A source control response must carry sourceControlJobId exactly when state is 'accepted'.",
+	path: ["sourceControlJobId"]
+};
+function isSourceControlJobAcceptConsistent(value) {
+	return value.state === "accepted" === (value.sourceControlJobId !== void 0);
+}
+const bridgeRefreshSourceControlStatusSuccessResponseSchema = z.object({
+	...sourceControlJobAcceptFields,
+	type: z.literal(BRIDGE_REFRESH_SOURCE_CONTROL_STATUS_REQUEST_TYPE)
+}).refine(isSourceControlJobAcceptConsistent, sourceControlJobAcceptRefinement);
+const bridgeCheckoutAssetsSuccessResponseSchema = z.object({
+	...sourceControlJobAcceptFields,
+	type: z.literal(BRIDGE_CHECKOUT_ASSETS_REQUEST_TYPE)
+}).refine(isSourceControlJobAcceptConsistent, sourceControlJobAcceptRefinement);
+const bridgeSourceControlJobItemResultSchema = z.object({
+	assetPath: z.string(),
+	error: z.string().optional(),
+	index: z.number().int().min(0),
+	ok: z.boolean(),
+	state: sourceControlFileStateSchema
+});
+const bridgeGetSourceControlJobStatusSuccessResponseSchema = z.object({
+	durationMs: z.number().int().min(0).optional(),
+	failureCount: z.number().int().min(0),
+	finishedAt: nonEmptyStringSchema.optional(),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	operation: sourceControlOperationSchema.optional(),
+	requestId: requestIdSchema,
+	results: z.array(bridgeSourceControlJobItemResultSchema).max(64),
+	sourceControlJobId: sourceControlJobIdSchema,
+	state: sourceControlJobStateSchema,
+	successCount: z.number().int().min(0),
+	type: z.literal(BRIDGE_GET_SOURCE_CONTROL_JOB_STATUS_REQUEST_TYPE),
+	version: z.literal(2)
+}).superRefine((value, ctx) => {
+	if (value.state === "succeeded" || value.state === "failed") return;
+	if (value.durationMs !== void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "durationMs must be absent until the job finishes",
+		path: ["durationMs"]
+	});
+	if (value.finishedAt !== void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "finishedAt must be absent until the job finishes",
+		path: ["finishedAt"]
+	});
+	if (value.results.length > 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "results must be empty until the job finishes",
+		path: ["results"]
+	});
+});
 const bridgeAssetDependencySchema = z.object({
 	category: assetDependencyCategorySchema,
 	isHard: z.boolean(),
@@ -2228,6 +2364,10 @@ const bridgeCreateDataTableResponseSchema = z.union([bridgeCreateDataTableSucces
 const bridgeRenameDataTableResponseSchema = z.union([bridgeRenameDataTableSuccessResponseSchema, bridgeErrorResponseSchema]);
 const bridgeDeleteDataTableResponseSchema = z.union([bridgeDeleteDataTableSuccessResponseSchema, bridgeErrorResponseSchema]);
 const bridgeRenameDataTableRowResponseSchema = z.union([bridgeRenameDataTableRowSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeGetSourceControlStatusResponseSchema = z.union([bridgeGetSourceControlStatusSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeRefreshSourceControlStatusResponseSchema = z.union([bridgeRefreshSourceControlStatusSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeCheckoutAssetsResponseSchema = z.union([bridgeCheckoutAssetsSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeGetSourceControlJobStatusResponseSchema = z.union([bridgeGetSourceControlJobStatusSuccessResponseSchema, bridgeErrorResponseSchema]);
 const bridgeFindAssetsResponseSchema = z.union([bridgeFindAssetsSuccessResponseSchema, bridgeErrorResponseSchema]);
 const bridgeGetAssetDependenciesResponseSchema = z.union([bridgeGetAssetDependenciesSuccessResponseSchema, bridgeErrorResponseSchema]);
 const bridgeFindBlueprintReferencesResponseSchema = z.union([bridgeFindBlueprintReferencesSuccessResponseSchema, bridgeErrorResponseSchema]);
@@ -2327,6 +2467,38 @@ function createBridgeRenameDataTableRowRequest(assetPath, rowName, newRowName, o
 		version: 2
 	});
 }
+function createBridgeGetSourceControlStatusRequest(assetPaths, requestId = randomUUID()) {
+	return bridgeGetSourceControlStatusRequestSchema.parse({
+		assetPaths,
+		requestId,
+		type: BRIDGE_GET_SOURCE_CONTROL_STATUS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeRefreshSourceControlStatusRequest(assetPaths, requestId = randomUUID()) {
+	return bridgeRefreshSourceControlStatusRequestSchema.parse({
+		assetPaths,
+		requestId,
+		type: BRIDGE_REFRESH_SOURCE_CONTROL_STATUS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeCheckoutAssetsRequest(assetPaths, requestId = randomUUID()) {
+	return bridgeCheckoutAssetsRequestSchema.parse({
+		assetPaths,
+		requestId,
+		type: BRIDGE_CHECKOUT_ASSETS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeGetSourceControlJobStatusRequest(sourceControlJobId, requestId = randomUUID()) {
+	return bridgeGetSourceControlJobStatusRequestSchema.parse({
+		requestId,
+		sourceControlJobId,
+		type: BRIDGE_GET_SOURCE_CONTROL_JOB_STATUS_REQUEST_TYPE,
+		version: 2
+	});
+}
 function createBridgeFindAssetsRequest(options = {}, requestId = randomUUID()) {
 	return bridgeFindAssetsRequestSchema.parse({
 		classNames: options.classNames,
@@ -2957,6 +3129,18 @@ async function sendBridgeOpenLevelRequest(request, options) {
 async function sendBridgeGetOpenLevelStatusRequest(request, options) {
 	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetOpenLevelStatusResponseSchema, request.requestId);
 }
+async function sendBridgeGetSourceControlStatusRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetSourceControlStatusResponseSchema, request.requestId);
+}
+async function sendBridgeRefreshSourceControlStatusRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeRefreshSourceControlStatusResponseSchema, request.requestId);
+}
+async function sendBridgeCheckoutAssetsRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeCheckoutAssetsResponseSchema, request.requestId);
+}
+async function sendBridgeGetSourceControlJobStatusRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetSourceControlJobStatusResponseSchema, request.requestId);
+}
 async function sendBridgeGetAssetDependenciesRequest(request, options) {
 	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetAssetDependenciesResponseSchema, request.requestId);
 }
@@ -5264,6 +5448,7 @@ const WAIT_FOR_JOB_KINDS = [
 	"compile",
 	"create_class",
 	"pie",
+	"source_control",
 	"test_run"
 ];
 const WAIT_FOR_JOB_MAX_TIMEOUT_MS = 6e5;
@@ -5271,6 +5456,7 @@ const WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS = {
 	compile: 12e4,
 	create_class: 6e4,
 	pie: 3e4,
+	source_control: 6e4,
 	test_run: 3e5
 };
 const WAIT_FOR_JOB_POLL_CADENCE_MS = {
@@ -5286,6 +5472,10 @@ const WAIT_FOR_JOB_POLL_CADENCE_MS = {
 		capMs: 2e3,
 		initialMs: 250
 	},
+	source_control: {
+		capMs: 2e3,
+		initialMs: 250
+	},
 	test_run: {
 		capMs: 5e3,
 		initialMs: 1e3
@@ -5393,7 +5583,7 @@ const waitForJobInputSchema = {
 	jobId: z.string().trim().min(1).max(512).describe("Job identifier to wait on: compileJobId (compile), createClassJobId (create_class), testRunId (test_run), or pieSessionId (pie)."),
 	kind: z.enum(WAIT_FOR_JOB_KINDS).describe("Which async job the id belongs to. Required — job ids are bare GUIDs and carry no type tag, so the kind cannot be inferred."),
 	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor owns the job."),
-	timeoutMs: z.number().int().min(1).optional().describe(`Wall-clock budget for the wait, clamped to ${String(WAIT_FOR_JOB_MAX_TIMEOUT_MS)}ms. Defaults per kind: compile ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.compile)}ms, create_class ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.create_class)}ms, pie ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.pie)}ms, test_run ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.test_run)}ms.`)
+	timeoutMs: z.number().int().min(1).optional().describe(`Wall-clock budget for the wait, clamped to ${String(WAIT_FOR_JOB_MAX_TIMEOUT_MS)}ms. Defaults per kind: compile ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.compile)}ms, create_class ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.create_class)}ms, pie ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.pie)}ms, source_control ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.source_control)}ms, test_run ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.test_run)}ms.`)
 };
 const getEditorStateInputSchema = { projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should report its state.") };
 const saveDirtyPackagesInputSchema = {
@@ -6208,6 +6398,22 @@ const getOpenLevelStatusInputSchema = {
 	openLevelJobId: bridgeGetOpenLevelStatusRequestSchema.shape.openLevelJobId.describe("openLevelJobId returned by open_level identifying the load job to poll."),
 	projectId: projectIdSchema
 };
+const getSourceControlStatusInputSchema = {
+	assetPaths: bridgeGetSourceControlStatusRequestSchema.shape.assetPaths.describe("Package names or object paths of the assets to report on (1-64), e.g. /Game/Data/DT_Weapons."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should query its source control provider.")
+};
+const refreshSourceControlStatusInputSchema = {
+	assetPaths: bridgeRefreshSourceControlStatusRequestSchema.shape.assetPaths.describe("Package names or object paths of the assets whose depot state should be re-read (1-64)."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should refresh its source control state.")
+};
+const checkoutAssetsInputSchema = {
+	assetPaths: bridgeCheckoutAssetsRequestSchema.shape.assetPaths.describe("Package names or object paths of the assets to check out (1-64), e.g. /Game/Data/DT_Weapons."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should check the assets out.")
+};
+const getSourceControlJobStatusInputSchema = {
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor owns the job."),
+	sourceControlJobId: bridgeGetSourceControlJobStatusRequestSchema.shape.sourceControlJobId.describe("sourceControlJobId returned by checkout_assets or refresh_source_control_status.")
+};
 const getAssetDependenciesInputSchema = {
 	assetPath: bridgeGetAssetDependenciesRequestSchema.shape.assetPath.describe("Package name or object path of the asset to inspect (e.g. /Game/BP/BP_Player or /Game/BP/BP_Player.BP_Player)."),
 	categories: bridgeGetAssetDependenciesRequestSchema.shape.categories.describe("Dependency categories to include: 'package' (default), 'searchable_name', 'manage'."),
@@ -6853,6 +7059,46 @@ function registerMcpTools(server, dependencies) {
 			projectId
 		}, dependencies));
 	});
+	server.registerTool("get_source_control_status", {
+		description: "Report the editor's source control provider and the per-file state of up to 64 assets. Answered from the provider's state cache, so it costs no network round trip and returns inline. enabled distinguishes 'no source control configured' from 'configured, and this file is simply not checked out'; per-file state is one of checked_out_by_me, checked_out_by_other (with checkedOutBy naming the holder), marked_for_add, not_checked_out, not_in_depot, unknown. A file the editor has never queried reports 'unknown' — call refresh_source_control_status to fetch its real state from the server. Call this before any asset write on a team project: under Perforce or Git-LFS file locking a .uasset stays read-only until checked out, and the write otherwise fails later at save time.",
+		inputSchema: getSourceControlStatusInputSchema,
+		title: "Get Source Control Status"
+	}, async ({ assetPaths, projectId }) => {
+		return toToolSuccess(await getSourceControlStatus({
+			assetPaths,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("refresh_source_control_status", {
+		description: "Re-read the depot state of up to 64 assets from the source control server, so a later get_source_control_status reports something better than 'unknown'. This is a network round trip to the provider and runs far past what a bridge request can wait for, so it only accepts the job: it returns state 'accepted' with a sourceControlJobId to poll with get_source_control_job_status (or wait_for_job with kind source_control).",
+		inputSchema: refreshSourceControlStatusInputSchema,
+		title: "Refresh Source Control Status"
+	}, async ({ assetPaths, projectId }) => {
+		return toToolSuccess(await refreshSourceControlStatus({
+			assetPaths,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("checkout_assets", {
+		description: "Check up to 64 assets out of source control so they become writable. This is a network round trip to the provider and runs far past what a bridge request can wait for, so it only accepts the job: it returns state 'accepted' with a sourceControlJobId to poll with get_source_control_job_status (or wait_for_job with kind source_control). The poll reports per-item results with successCount / failureCount — one asset the provider refuses does not abort the rest. This checks out only; it never submits, and a checked-out asset stays checked out until a human submits or reverts it.",
+		inputSchema: checkoutAssetsInputSchema,
+		title: "Checkout Assets"
+	}, async ({ assetPaths, projectId }) => {
+		return toToolSuccess(await checkoutAssets({
+			assetPaths,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("get_source_control_job_status", {
+		description: "Poll a source control job started by checkout_assets or refresh_source_control_status for a projectId; returns state (running, succeeded, failed, unknown_job), which operation it was, and once finished the per-file results with successCount / failureCount and timing. Poll until the state leaves 'running' before writing to any asset in the batch.",
+		inputSchema: getSourceControlJobStatusInputSchema,
+		title: "Get Source Control Job Status"
+	}, async ({ projectId, sourceControlJobId }) => {
+		return toToolSuccess(await getSourceControlJobStatus({
+			projectId,
+			sourceControlJobId
+		}, dependencies));
+	});
 	server.registerTool("find_assets", {
 		description: "Query a project's Unreal Asset Registry for assets by class and/or content path, without loading them; returns each match's name, class, package name, package path, and object path. Requires at least one of classNames or packagePaths — an unfiltered query would stall the editor enumerating every asset. Results are paged: pass the previous response nextCursor to fetch the next page (totalCount reports the full match count). scanning=true means the registry is still indexing, so an empty result does not prove the asset is absent.",
 		inputSchema: findAssetsInputSchema,
@@ -7345,6 +7591,91 @@ async function getOpenLevelStatus(input, dependencies) {
 	if (response.durationMs !== void 0) result.durationMs = response.durationMs;
 	return result;
 }
+async function getSourceControlStatus(input, dependencies) {
+	const normalizedProjectId = projectIdSchema.parse(input.projectId);
+	const entry = dependencies.registry.getProject(normalizedProjectId);
+	if (!entry) throw new Error(`No registered Unreal engine was found for projectId '${normalizedProjectId}'.`);
+	const response = await sendBridgeGetSourceControlStatusRequest(createBridgeGetSourceControlStatusRequest(input.assetPaths), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: BRIDGE_LOOPBACK_HOST,
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge get_source_control_status failed (${response.error.code}): ${response.error.message}`);
+	const result = {
+		available: response.available,
+		enabled: response.enabled,
+		files: response.files,
+		projectId: entry.projectId,
+		provider: response.provider,
+		state: response.state
+	};
+	if (response.message !== void 0) result.message = response.message;
+	return result;
+}
+async function refreshSourceControlStatus(input, dependencies) {
+	const normalizedProjectId = projectIdSchema.parse(input.projectId);
+	const entry = dependencies.registry.getProject(normalizedProjectId);
+	if (!entry) throw new Error(`No registered Unreal engine was found for projectId '${normalizedProjectId}'.`);
+	const request = createBridgeRefreshSourceControlStatusRequest(input.assetPaths);
+	const response = await sendBridgeRefreshSourceControlStatusRequest(request, {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: BRIDGE_LOOPBACK_HOST,
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge refresh_source_control_status failed (${response.error.code}): ${response.error.message}`);
+	return buildSourceControlJobAcceptResult(response, request.assetPaths, entry.projectId);
+}
+async function checkoutAssets(input, dependencies) {
+	const normalizedProjectId = projectIdSchema.parse(input.projectId);
+	const entry = dependencies.registry.getProject(normalizedProjectId);
+	if (!entry) throw new Error(`No registered Unreal engine was found for projectId '${normalizedProjectId}'.`);
+	const request = createBridgeCheckoutAssetsRequest(input.assetPaths);
+	const response = await sendBridgeCheckoutAssetsRequest(request, {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: BRIDGE_LOOPBACK_HOST,
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge checkout_assets failed (${response.error.code}): ${response.error.message}`);
+	return buildSourceControlJobAcceptResult(response, request.assetPaths, entry.projectId);
+}
+function buildSourceControlJobAcceptResult(response, assetPaths, projectId) {
+	const result = {
+		assetPaths,
+		projectId,
+		state: response.state
+	};
+	if (response.sourceControlJobId !== void 0) result.sourceControlJobId = response.sourceControlJobId;
+	if (response.message !== void 0) result.message = response.message;
+	return result;
+}
+async function getSourceControlJobStatus(input, dependencies) {
+	const normalizedProjectId = projectIdSchema.parse(input.projectId);
+	const entry = dependencies.registry.getProject(normalizedProjectId);
+	if (!entry) throw new Error(`No registered Unreal engine was found for projectId '${normalizedProjectId}'.`);
+	const response = await sendBridgeGetSourceControlJobStatusRequest(createBridgeGetSourceControlJobStatusRequest(input.sourceControlJobId), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: BRIDGE_LOOPBACK_HOST,
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge get_source_control_job_status failed (${response.error.code}): ${response.error.message}`);
+	const result = {
+		failureCount: response.failureCount,
+		projectId: entry.projectId,
+		results: response.results,
+		sourceControlJobId: response.sourceControlJobId,
+		state: response.state,
+		successCount: response.successCount
+	};
+	if (response.operation !== void 0) result.operation = response.operation;
+	if (response.message !== void 0) result.message = response.message;
+	if (response.finishedAt !== void 0) result.finishedAt = response.finishedAt;
+	if (response.durationMs !== void 0) result.durationMs = response.durationMs;
+	return result;
+}
 async function findAssets(input, dependencies) {
 	const normalizedProjectId = projectIdSchema.parse(input.projectId);
 	const entry = dependencies.registry.getProject(normalizedProjectId);
@@ -8678,6 +9009,10 @@ async function pollJobStatus(kind, jobId, projectId, dependencies) {
 			pieSessionId: jobId,
 			projectId
 		}, dependencies);
+		case "source_control": return await getSourceControlJobStatus({
+			projectId,
+			sourceControlJobId: jobId
+		}, dependencies);
 		case "test_run": return await getTestRunStatus({
 			projectId,
 			testRunId: jobId
@@ -8689,6 +9024,7 @@ function classifyJobStatus(kind, status) {
 		case "compile": return status.state === "compiling" ? "pending" : toTerminalOutcome(status.state === "unknown_job");
 		case "create_class": return status.state === "creating" ? "pending" : toTerminalOutcome(status.state === "unknown_job");
 		case "pie": return status.state === "starting" ? "pending" : "completed";
+		case "source_control": return status.state === "running" ? "pending" : toTerminalOutcome(status.state === "unknown_job");
 		case "test_run": return status.state === "running" ? "pending" : toTerminalOutcome(status.state === "unknown_run");
 	}
 }
@@ -8945,7 +9281,7 @@ function isMissingFileError(error) {
 //#endregion
 //#region src/server.ts
 const SERVER_NAME = "ue-mcp-server";
-const SERVER_VERSION = "1.1.0";
+const SERVER_VERSION = "1.2.0";
 const logger = createModuleLogger("bootstrap");
 const enginePingLogger = createModuleLogger("engine-ping");
 const httpApiLogger = createModuleLogger("http-api");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uemcp/server",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "MCP server for making Unreal Engine and C++ development easier",
   "type": "module",
   "main": "dist/index.mjs",