cozyclay 1.10.0 → 2.0.2

package/mcp/live-hub.mjs

@@ -7,98 +7,19 @@ import { mcpToolCategory } from "../src/execution-telemetry.js";
 import { WebSocket, WebSocketServer } from "ws";
 
 export const DEFAULT_COMMAND_TIMEOUT_MS = 5_000;
-/** A per-call override may extend a command, never past this ceiling: a hub
- * that waits longer than this can no longer tell a slow editor from a dead one. */
+/** A per-call override may extend a non-motion command, never past this ceiling. */
 export const MAX_COMMAND_TIMEOUT_MS = 300_000;
 export const DEFAULT_HEARTBEAT_MS = 15_000;
 export const RUN_WORKFLOW_TIMEOUT_MS = 180_000;
 export const LOAD_MOTION_TIMEOUT_MS = 30_000;
 export const IMPORT_ASSET_TIMEOUT_MS = 30_000;
 export const CAPTURE_FRAME_TIMEOUT_MS = 30_000;
-export const MOTION_JOB_TTL_MS = 10 * 60_000;
-export const MOTION_JOB_POLL_INTERVAL_MS = 0;
-export const MAX_ACTIVE_MOTION_JOBS = 2;
-export const MAX_ACTIVE_MOTION_JOBS_PER_WORKSPACE = 1;
-
-const terminalMotionStatuses = new Set(["completed", "failed", "cancelled", "expired"]);
-
-/** MCP-internal job retention for push-only motion work. Its clock is injected
- * so expiry is deterministic without a polling loop or timing-based test. */
-export class MotionJobRegistry {
-	constructor({ clock = () => Date.now(), ttlMs = MOTION_JOB_TTL_MS } = {}) {
-		this.clock = clock;
-		this.ttlMs = ttlMs;
-		this.jobs = new Map();
-	}
-
-	create(workspaceId) {
-		this.cleanup();
-		const active = [...this.jobs.values()].filter((job) => !terminalMotionStatuses.has(job.status));
-		if (active.length >= MAX_ACTIVE_MOTION_JOBS) throw new Error(`Motion job capacity reached (${MAX_ACTIVE_MOTION_JOBS} active globally).`);
-		if (active.filter((job) => job.workspaceId === workspaceId).length >= MAX_ACTIVE_MOTION_JOBS_PER_WORKSPACE) {
-			throw new Error(`This workspace already has an active motion job.`);
-		}
-		const now = this.clock();
-		const job = {
-			taskId: randomUUID(), workspaceId, status: "queued", createdAt: now,
-			lastUpdatedAt: now, ttlMs: this.ttlMs, pollIntervalMs: MOTION_JOB_POLL_INTERVAL_MS,
-			cancel: null, expiresAt: null, outcome: null,
-			deliveredWorkspaceIds: new Set(),
-			installationStates: new Map(),
-		};
-		this.jobs.set(job.taskId, job);
-		return job;
-	}
-
-	task(job) {
-		return {
-			taskId: job.taskId, status: job.status, createdAt: job.createdAt,
-			lastUpdatedAt: job.lastUpdatedAt, ttlMs: job.ttlMs, pollIntervalMs: job.pollIntervalMs,
-		};
-	}
-
-	transition(job, status, outcome = null) {
-		this.cleanup();
-		job.status = status;
-		job.lastUpdatedAt = this.clock();
-		job.outcome = outcome;
-		job.expiresAt = terminalMotionStatuses.has(status) ? job.lastUpdatedAt + job.ttlMs : null;
-		if (job.expiresAt !== null) {
-			const timer = setTimeout(() => this.cleanup(), job.ttlMs);
-			timer.unref?.();
-		}
-		return this.task(job);
-	}
-
-	cancel(taskId, workspaceId) {
-		this.cleanup();
-		const job = this.jobs.get(taskId);
-		if (!job || job.workspaceId !== workspaceId || terminalMotionStatuses.has(job.status)) return null;
-		job.cancel?.();
-		return this.transition(job, "cancelled", { message: "Generation cancelled before editor delivery." });
-	}
-
-	forWorkspace(workspaceId) {
-		this.cleanup();
-		return [...this.jobs.values()].filter((job) =>
-			job.workspaceId === workspaceId && terminalMotionStatuses.has(job.status) && job.status !== "expired" && !job.deliveredWorkspaceIds.has(workspaceId));
-	}
-
-	cleanup() {
-		const now = this.clock();
-		for (const job of this.jobs.values()) {
-			if (job.expiresAt === null || now < job.expiresAt) continue;
-			if (job.status === "expired") {
-				this.jobs.delete(job.taskId);
-				continue;
-			}
-			job.status = "expired";
-			job.lastUpdatedAt = now;
-			job.outcome = { message: "Motion job outcome expired before this workspace reconnected." };
-			job.expiresAt = now + job.ttlMs;
-		}
-	}
-}
+export const STUDIO_COMMAND_TIMEOUT_MS = 30_000;
+const studioCommands = new Set([
+	"inspect_studio", "operate_studio", "arrange_objects", "arrange_characters", "patch_elements",
+	"frame_shot", "verify_result", "undo_edit", "read_studio_context", "resolve_studio_image",
+	"capture_framing_png", "reconcile_studio_command", "run_action",
+]);
 
 const mutationCommands = new Set([
 	"set_camera",
@@ -114,8 +35,8 @@ const mutationCommands = new Set([
 	"set_prompt_blocks",
 	"load_motion",
 	"load_scenes",
-	"operate_studio", "arrange_objects", "arrange_characters", "patch_elements", "frame_shot", "undo_edit",
-	"commit_motion_candidate", "import_asset",
+	"operate_studio", "arrange_objects", "arrange_characters", "patch_elements", "frame_shot", "undo_edit", "run_action",
+	"import_asset",
 ]);
 
 export class LiveMutationUncertainError extends Error {
@@ -217,8 +138,7 @@ export class LiveHub {
 	}
 
 	static commandTimeoutMs(name) {
-		if (name === "load_motion" || name === "prepare_motion_install") return LOAD_MOTION_TIMEOUT_MS;
-		if (name === "verify_motion_candidate" || name === "repair_motion_candidate") return 60_000;
+		if (name === "load_motion") return LOAD_MOTION_TIMEOUT_MS;
 		// A 32 MiB mesh as a data URL will not decode, store and stand in 5 s.
 		if (name === "import_asset") return IMPORT_ASSET_TIMEOUT_MS;
 		// Close two-person shots (OTS) raycast two skinned rigs over a full-frame
@@ -226,6 +146,7 @@ export class LiveHub {
 		if (name === "capture_frame") return CAPTURE_FRAME_TIMEOUT_MS;
 		// A workflow run captures a frame and may generate an image upstream.
 		if (name === "run_workflow") return RUN_WORKFLOW_TIMEOUT_MS;
+		if (studioCommands.has(name)) return STUDIO_COMMAND_TIMEOUT_MS;
 		return DEFAULT_COMMAND_TIMEOUT_MS;
 	}
 
@@ -284,6 +205,7 @@ export class LiveHub {
 		let appliedEmitted = false;
 		let failure = null;
 		let description;
+		let studioContext;
 		let mutation;
 		let acknowledgedMutation = false;
 		const emitApplied = () => {
@@ -294,14 +216,30 @@ export class LiveHub {
 		const observer = {
 			hub: this, handle,
 			before(command) {
-				if (!LiveHub.commandMayMutate(command) || command === "load_motion") return false;
+				if (!LiveHub.commandMayMutate(command) || command === "load_motion" || command === "run_action") return false;
 				mutation = { name: command, before: mutationState(command, description), acknowledged: false };
 				description = undefined;
 				return mutation.before === undefined;
 			},
 			baseline(value) { if (mutation) mutation.before = mutationState(mutation.name, value); },
 			receipt(command, value) {
-				if (command === "describe") {
+				if (command === "inspect_studio") {
+					studioContext = value?.context;
+				} else if (command === "run_action") {
+					// The bus attests application itself. No legacy describe diff or
+					// post-ack read may turn an admitted refusal into uncertainty.
+					if (value?.ok === false) {
+						failure = value.mutated === "unknown" || value.code === "UNCERTAIN_APPLY" ? "uncertain" : "failed";
+					} else if (value?.ok === true) {
+						acknowledgedMutation = true;
+						// A journal replay has already reached its after revision; it
+						// does not count as another application on this invocation.
+						if (studioContext && ((value.authored && value.revision.after > studioContext.revision.scene) ||
+							(value.nextHost && ["workspaceId", "documentEpoch", "sceneId", "sceneEpoch"].some(key => value.nextHost[key] !== studioContext.host[key])))) applied = true;
+						if (value.output?.rolledBack === true || value.output?.failed?.length > 0) failure = "failed";
+					}
+					studioContext = undefined;
+				} else if (command === "describe") {
 					if (mutation?.acknowledged && !mutation.rolledBack) {
 						const after = mutationState(mutation.name, value);
 						if (mutation.before !== undefined && after !== undefined && !isDeepStrictEqual(mutation.before, after)) applied = true;
@@ -336,6 +274,7 @@ export class LiveHub {
 			emitApplied();
 			// Never retain scene data with an asynchronous motion job.
 			description = undefined;
+			studioContext = undefined;
 			mutation = null;
 		});
 		emit("mcp:tool_requested", { request_id: requestId, tool_category: category });
@@ -389,6 +328,8 @@ export class LiveHub {
 		if (!socket || socket.readyState !== WebSocket.OPEN) throw hubError("STALE_HANDLE", `Unknown or stale live workspace handle "${handle}".`);
 
 		const id = randomUUID();
+		// The caller's per-call deadline (a controller frame's timeoutMs, or a
+		// command's declared one), capped at the ceiling; else the name's default.
 		const bound = Number.isFinite(timeoutMs) && timeoutMs > 0
 			? Math.min(timeoutMs, MAX_COMMAND_TIMEOUT_MS)
 			: LiveHub.commandTimeoutMs(name);
@@ -401,7 +342,8 @@ export class LiveHub {
 					: hubError("TIMEOUT", message);
 				reject(error);
 			}, bound);
-			this.pending.set(id, { name, socket, resolve, reject, timer });
+			// Each waiting frame keeps the deadline it runs under.
+			this.pending.set(id, { name, socket, resolve, reject, timer, timeoutMs: bound });
 			try {
 				socket.send(JSON.stringify({ type: "cmd", id, name, args }));
 			} catch (error) {

package/mcp/mesh-file.mjs

@@ -0,0 +1,48 @@
+import { constants as fsConstants } from "node:fs";
+import { open as openFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, join, resolve } from "node:path";
+
+import { ASSET_MAX_SOURCE_BYTES } from "../src/scene-assets.js";
+import { classifyMeshBytes, meshMimeForKind } from "../src/mesh-sniff.js";
+
+export function normalizeMeshPath(raw, { home = homedir() } = {}) {
+	if (typeof raw !== "string" || !raw.trim()) throw new Error("A file path is required.");
+	let path = raw.trim();
+	if (path.startsWith("file:")) {
+		try {
+			const url = new URL(path);
+			if (url.protocol === "file:") path = decodeURIComponent(url.pathname);
+		} catch {
+			path = path.replace(/^file:\/\//, "");
+		}
+	}
+	if (path === "~") path = home;
+	else if (path.startsWith("~/")) path = join(home, path.slice(2));
+	return resolve(path);
+}
+
+export async function readMeshFromPath(raw) {
+	const path = normalizeMeshPath(raw);
+	let file;
+	try {
+		file = await openFile(path, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
+	} catch (error) {
+		throw new Error(`Could not read that file: ${error.message}`);
+	}
+	try {
+		const stat = await file.stat();
+		if (stat.isDirectory()) throw new Error("That path is a directory, not a 3D model.");
+		if (stat.size > ASSET_MAX_SOURCE_BYTES) {
+			throw new Error(`That model is too large to import — larger than ${Math.round(ASSET_MAX_SOURCE_BYTES / (1024 * 1024))} MB`);
+		}
+		const bytes = await file.readFile();
+		const kind = classifyMeshBytes(bytes);
+		if (kind === "fbx-old") throw new Error("That FBX file is too old to import");
+		const mimeType = meshMimeForKind(kind);
+		if (!kind || !mimeType) throw new Error("That file is not a 3D model");
+		return { path, name: basename(path), bytes, kind, mimeType };
+	} finally {
+		await file.close().catch(() => {});
+	}
+}

package/mcp/server.mjs

@@ -48,7 +48,7 @@ import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
 import { ErrorCode, InitializeRequestSchema, LATEST_PROTOCOL_VERSION, McpError } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 
-import { LiveMutationUncertainError, MotionJobRegistry, startLiveHub } from "./live-hub.mjs";
+import { startLiveHub } from "./live-hub.mjs";
 import {
 	cleanupCaptureArtifacts,
 	createToolHandlers,
@@ -61,7 +61,6 @@ import {
 
 /* ------------------------------ process ---------------------------------- */
 
-const motionJobs = new MotionJobRegistry();
 sweepCaptureArtifacts();
 process.once("exit", cleanupCaptureArtifacts);
 for (const signal of ["SIGINT", "SIGTERM"]) process.once(signal, () => { cleanupCaptureArtifacts(); process.exit(128 + (signal === "SIGINT" ? 2 : 15)); });
@@ -71,73 +70,6 @@ const projectRootPromise = realpath(configuredProjectRoot).then((root) => {
 	return root;
 });
 
-/* ----------------------------- motion jobs ------------------------------- */
-
-const motionJobEvent = (job) => ({
-	...motionJobs.task(job),
-	...(job.outcome === null ? {} : { outcome: job.outcome }),
-});
-
-const sendMotionJobEvent = (job) => {
-	try {
-		if (liveHub?.sendEvent(job.workspaceId, "motion_job", motionJobEvent(job)) > 0) {
-			job.deliveredWorkspaceIds.add(job.workspaceId);
-		}
-	} catch (error) {
-		console.error(`[motion_job] lifecycle event delivery failed: ${error instanceof Error ? error.message : String(error)}`);
-	}
-};
-
-const publishMotionJob = async (job) => {
-	if (job.deliveredWorkspaceIds.has(job.workspaceId)) return;
-	const outcome = job.outcome;
-	if (!liveHub || job.status !== "completed" || typeof outcome?.motionUrl !== "string") {
-		sendMotionJobEvent(job);
-		return;
-	}
-	const installationState = job.installationStates.get(job.workspaceId);
-	if (installationState === "installing") return;
-	if (installationState === "installed") {
-		sendMotionJobEvent(job);
-		return;
-	}
-	const handle = liveHub.handleForWorkspaceId(job.workspaceId);
-	if (!handle) return;
-	job.installationStates.set(job.workspaceId, "installing");
-	try {
-		await liveHub.command("load_motion", {
-			url: outcome.motionUrl,
-			prompt: outcome.prompt ?? "",
-			blocks: outcome.blocks ?? [],
-			drop: outcome.drop ?? null,
-			characterId: outcome.targetCharacterId,
-		}, handle);
-	} catch (error) {
-		const uncertain = error instanceof LiveMutationUncertainError;
-		job.installationStates.set(job.workspaceId, uncertain ? "uncertain" : "failed");
-		motionJobs.transition(job, "failed", {
-			message: uncertain
-				? "The editor connection was lost while installing the completed take. Installation may have applied, so it will not be retried."
-				: `The editor rejected the completed take: ${error instanceof Error ? error.message : String(error)}`,
-		});
-		sendMotionJobEvent(job);
-		return;
-	}
-	job.installationStates.set(job.workspaceId, "installed");
-	// Generation already succeeded. Application is a separate, acknowledged
-	// editor mutation; rejected or uncertain installation never reaches here.
-	job.motionRequest?.apply();
-	sendMotionJobEvent(job);
-};
-
-const cancelMotionJob = ({ workspaceId, payload }) => {
-	if (typeof payload.taskId !== "string") return;
-	const task = motionJobs.cancel(payload.taskId, workspaceId);
-	if (!task) return;
-	const job = motionJobs.jobs.get(task.taskId);
-	if (job) void publishMotionJob(job);
-};
-
 /* ------------------------------- server ---------------------------------- */
 
 /** Tool registrations are counted as they happen so the HTTP status page can
@@ -152,7 +84,9 @@ const server = new McpServer(
 			"vocabulary (shot size, angle, lens) and render it into an AI image/video prompt. " +
 			"Call describe_scene first to see the current state. Coordinates are metres: x is right, " +
 			"z is toward the camera's default position, y is height above the floor. Rotations are " +
-			"degrees of yaw. Save with save_project to a .cclayproject file the CozyClay studio opens.",
+			"degrees of yaw. Save with save_project to a .cclayproject file the CozyClay studio opens. " +
+			"With an editor connected, studio_commands lists every command it registers and studio_run runs one " +
+			"through the editor's own command bus, answering its receipt.",
 	},
 );
 server.server.setRequestHandler(InitializeRequestSchema, async (request) => {
@@ -213,7 +147,7 @@ const serveRegistryTool = (name, args, workspaceHandle) => {
 // The tools themselves live in tool-handlers.mjs so an in-process agent can run
 // them without an MCP server; registration order is the registry's order, which
 // is the order tools/list reports.
-for (const handler of createToolHandlers({ projectRootPromise, motionJobs, publishMotionJob })) registerTool(handler);
+for (const handler of createToolHandlers({ projectRootPromise })) registerTool(handler);
 
 /* -------------------------------- start ---------------------------------- */
 
@@ -234,12 +168,7 @@ const configureLiveHub = (hub, token) => {
 	// only place its token exists.
 	publishLiveEndpoint({ port: hub.port, token, owner: "mcp" });
 	hub.server?.once("close", () => removeLiveEndpoint(hub.port));
-	hub.onEvent = ({ workspaceId, name, payload }) => {
-		if (name === "motion_job_cancel") cancelMotionJob({ workspaceId, payload });
-	};
-	hub.onWorkspaceConnected = ({ workspaceId }) => {
-		for (const job of motionJobs.forWorkspace(workspaceId)) void publishMotionJob(job);
-	};
+
 };
 
 // stdio is the default because that is how an MCP client launches a local