@mcut/mcp-server 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,187 @@
+Apache License
+Version 2.0, January 2004
+https://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the
+copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other
+entities that control, are controlled by, or are under common control with
+that entity. For the purposes of this definition, "control" means (i) the
+power, direct or indirect, to cause the direction or management of such
+entity, whether by contract or otherwise, or (ii) ownership of fifty percent
+(50%) or more of the outstanding shares, or (iii) beneficial ownership of
+such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications,
+including but not limited to software source code, documentation source, and
+configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation
+or translation of a Source form, including but not limited to compiled object
+code, generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form,
+made available under the License, as indicated by a copyright notice that is
+included in or attached to the work (an example is provided in the Appendix
+below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form,
+that is based on (or derived from) the Work and for which the editorial
+revisions, annotations, elaborations, or other modifications represent, as a
+whole, an original work of authorship. For the purposes of this License,
+Derivative Works shall not include works that remain separable from, or
+merely link (or bind by name) to the interfaces of, the Work and Derivative
+Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original
+version of the Work and any modifications or additions to that Work or
+Derivative Works thereof, that is intentionally submitted to Licensor for
+inclusion in the Work by the copyright owner or by an individual or Legal
+Entity authorized to submit on behalf of the copyright owner. For the
+purposes of this definition, "submitted" means any form of electronic,
+verbal, or written communication sent to the Licensor or its representatives,
+including but not limited to communication on electronic mailing lists,
+source code control systems, and issue tracking systems that are managed by,
+or on behalf of, the Licensor for the purpose of discussing and improving the
+Work, but excluding communication that is conspicuously marked or otherwise
+designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on
+behalf of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this
+License, each Contributor hereby grants to You a perpetual, worldwide,
+non-exclusive, no-charge, royalty-free, irrevocable copyright license to
+reproduce, prepare Derivative Works of, publicly display, publicly perform,
+sublicense, and distribute the Work and such Derivative Works in Source or
+Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this
+License, each Contributor hereby grants to You a perpetual, worldwide,
+non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this
+section) patent license to make, have made, use, offer to sell, sell, import,
+and otherwise transfer the Work, where such license applies only to those
+patent claims licensable by such Contributor that are necessarily infringed
+by their Contribution(s) alone or by combination of their Contribution(s)
+with the Work to which such Contribution(s) was submitted. If You institute
+patent litigation against any entity (including a cross-claim or counterclaim
+in a lawsuit) alleging that the Work or a Contribution incorporated within
+the Work constitutes direct or contributory patent infringement, then any
+patent licenses granted to You under this License for that Work shall
+terminate as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or
+Derivative Works thereof in any medium, with or without modifications, and in
+Source or Object form, provided that You meet the following conditions:
+
+(a) You must give any other recipients of the Work or Derivative Works a
+copy of this License; and
+
+(b) You must cause any modified files to carry prominent notices stating that
+You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works that You
+distribute, all copyright, patent, trademark, and attribution notices from
+the Source form of the Work, excluding those notices that do not pertain to
+any part of the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its distribution,
+then any Derivative Works that You distribute must include a readable copy of
+the attribution notices contained within such NOTICE file, excluding those
+notices that do not pertain to any part of the Derivative Works, in at least
+one of the following places: within a NOTICE text file distributed as part of
+the Derivative Works; within the Source form or documentation, if provided
+along with the Derivative Works; or, within a display generated by the
+Derivative Works, if and wherever such third-party notices normally appear.
+The contents of the NOTICE file are for informational purposes only and do
+not modify the License. You may add Your own attribution notices within
+Derivative Works that You distribute, alongside or as an addendum to the
+NOTICE text from the Work, provided that such additional attribution notices
+cannot be construed as modifying the License.
+
+You may add Your own copyright statement to Your modifications and may
+provide additional or different license terms and conditions for use,
+reproduction, or distribution of Your modifications, or for any such
+Derivative Works as a whole, provided Your use, reproduction, and
+distribution of the Work otherwise complies with the conditions stated in
+this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any
+Contribution intentionally submitted for inclusion in the Work by You to the
+Licensor shall be under the terms and conditions of this License, without any
+additional terms or conditions. Notwithstanding the above, nothing herein
+shall supersede or modify the terms of any separate license agreement you may
+have executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names,
+trademarks, service marks, or product names of the Licensor, except as
+required for reasonable and customary use in describing the origin of the
+Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in
+writing, Licensor provides the Work (and each Contributor provides its
+Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied, including, without limitation, any warranties
+or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any risks
+associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in
+tort (including negligence), contract, or otherwise, unless required by
+applicable law (such as deliberate and grossly negligent acts) or agreed to
+in writing, shall any Contributor be liable to You for damages, including any
+direct, indirect, special, incidental, or consequential damages of any
+character arising as a result of this License or out of the use or inability
+to use the Work (including but not limited to damages for loss of goodwill,
+work stoppage, computer failure or malfunction, or any and all other
+commercial damages or losses), even if such Contributor has been advised of
+the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work
+or Derivative Works thereof, You may choose to offer, and charge a fee for,
+acceptance of support, warranty, indemnity, or other liability obligations
+and/or rights consistent with this License. However, in accepting such
+obligations, You may act only on Your own behalf and on Your sole
+responsibility, not on behalf of any other Contributor, and only if You agree
+to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets "[]" replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same "printed page" as the copyright notice for easier identification
+within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,11 @@
+# @mcut/mcp-server
+
+MCP server and local browser bridge for mcut.
+
+```sh
+bunx @mcut/mcp-server
+```
+
+This package exposes mcut commands and editor operators as Model Context
+Protocol tools. It also includes local bridge commands for connecting MCP
+clients to a live browser editor session.

package/dist/bridge-cli.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/bridge-cli.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+import { n as createMcutMcpServerForTarget } from "./server-DyDMot4v.js";
+import { a as parseLiveBridgePort, i as createHttpBridgeTarget, r as LiveMcutBridge, t as DEFAULT_BRIDGE_PORT } from "./live-bridge-ky67GOTs.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+//#region src/bridge-cli.ts
+/**
+* Local bridge entry point:
+*
+*   mcut-bridge start
+*   mcut-bridge get-summary
+*   mcut-bridge get-transcript
+*   mcut-bridge dispatch addTrack --json '{"name":"B-roll"}'
+*   mcut-bridge mcp
+*/
+function usage() {
+	return [
+		"Usage:",
+		"  mcut-bridge start [--port 44737] [--editor-url http://localhost:3000/editor] [--allow-origin https://mcut.com]",
+		"  mcut-bridge status [--port 44737]",
+		"  mcut-bridge url [--editor-url http://localhost:3000/editor] [--port 44737]",
+		"  mcut-bridge get-summary [--port 44737]",
+		"  mcut-bridge get-project [--port 44737]",
+		"  mcut-bridge get-media-context [--port 44737]",
+		"  mcut-bridge get-transcript [--json '{\"includeWords\":true}'] [--port 44737]",
+		"  mcut-bridge search-transcript <query> [--port 44737]",
+		"  mcut-bridge ensure-transcript [--json '{\"elementId\":\"e-...\",\"replace\":false}'] [--port 44737]",
+		"  mcut-bridge list-actions [--port 44737]",
+		"  mcut-bridge action <actionId> [--json '{...}'] [--port 44737]",
+		"  mcut-bridge dispatch <commandName> [--json '{...}'] [--port 44737]",
+		"  mcut-bridge operator <operatorId> [--json '{...}'] [--port 44737]",
+		"  mcut-bridge undo [--port 44737]",
+		"  mcut-bridge redo [--port 44737]",
+		"  mcut-bridge mcp [--port 44737]"
+	].join("\n");
+}
+function parseJson(value) {
+	if (!value) return {};
+	return JSON.parse(value);
+}
+function parseArgs(argv) {
+	const command = argv[0] ?? "help";
+	const rest = [];
+	let port = DEFAULT_BRIDGE_PORT;
+	let json = {};
+	let editorUrl = "http://localhost:3000/editor";
+	const allowedOrigins = [];
+	for (let i = 1; i < argv.length; i++) {
+		const arg = argv[i];
+		if (!arg) continue;
+		if (arg === "--port") port = parseLiveBridgePort(argv[++i]) ?? 44737;
+		else if (arg === "--json") json = parseJson(argv[++i]);
+		else if (arg === "--editor-url") editorUrl = argv[++i] ?? editorUrl;
+		else if (arg === "--allow-origin") {
+			const origin = argv[++i];
+			if (origin) allowedOrigins.push(origin);
+		} else rest.push(arg);
+	}
+	return {
+		command,
+		rest,
+		port,
+		json,
+		editorUrl,
+		allowedOrigins
+	};
+}
+async function rpc(port, type, payload = {}) {
+	const response = await fetch(`http://127.0.0.1:${port}/rpc`, {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			"x-mcut-bridge-client": "cli"
+		},
+		body: JSON.stringify({
+			type,
+			payload
+		})
+	});
+	const json = await response.json();
+	if (!response.ok || !json.ok) throw new Error(json.error ?? `mcut bridge request failed (${response.status})`);
+	return json.result;
+}
+async function status(port) {
+	const response = await fetch(`http://127.0.0.1:${port}/status`);
+	const json = await response.json();
+	if (!response.ok || !json.ok) throw new Error(json.error ?? "mcut bridge is not running.");
+	return json.result;
+}
+function editorUrl(base, port) {
+	const url = new URL(base);
+	url.searchParams.set("mcpBridge", String(port));
+	return url.toString();
+}
+function originOf(value) {
+	try {
+		return new URL(value).origin;
+	} catch {
+		return null;
+	}
+}
+function print(value) {
+	if (typeof value === "string") {
+		console.log(value);
+		return;
+	}
+	console.log(JSON.stringify(value, null, 2));
+}
+async function main() {
+	const args = parseArgs(process.argv.slice(2));
+	switch (args.command) {
+		case "help":
+		case "--help":
+		case "-h":
+			console.log(usage());
+			return;
+		case "start": {
+			const editorOrigin = originOf(args.editorUrl);
+			const port = await new LiveMcutBridge({
+				token: null,
+				allowedOrigins: [...args.allowedOrigins, ...editorOrigin ? [editorOrigin] : []]
+			}).listen(args.port);
+			console.error(`mcut bridge ready — ws://127.0.0.1:${port}/mcut-mcp`);
+			console.error(`Editor URL: ${editorUrl(args.editorUrl, port)}`);
+			console.error("Leave this process running while agents edit the browser project.");
+			await new Promise(() => {});
+			return;
+		}
+		case "status":
+			print(await status(args.port));
+			return;
+		case "url":
+			console.log(editorUrl(args.editorUrl, args.port));
+			return;
+		case "get-summary":
+			print(await rpc(args.port, "get_summary"));
+			return;
+		case "get-project":
+			print(await rpc(args.port, "get_project"));
+			return;
+		case "get-media-context":
+			print(await rpc(args.port, "get_media_context"));
+			return;
+		case "get-transcript":
+			print(await rpc(args.port, "get_transcript", args.json));
+			return;
+		case "search-transcript": {
+			const query = args.rest.join(" ").trim();
+			if (!query) throw new Error("search-transcript requires a query.");
+			print(await rpc(args.port, "search_transcript", { query }));
+			return;
+		}
+		case "ensure-transcript":
+			print(await rpc(args.port, "ensure_transcript", args.json));
+			return;
+		case "list-actions":
+			print(await rpc(args.port, "list_actions"));
+			return;
+		case "action": {
+			const actionId = args.rest[0];
+			if (!actionId) throw new Error("action requires an action id.");
+			print(await rpc(args.port, "run_action", {
+				actionId,
+				input: args.json
+			}));
+			return;
+		}
+		case "dispatch": {
+			const commandName = args.rest[0];
+			if (!commandName) throw new Error("dispatch requires a command name.");
+			print(await rpc(args.port, "dispatch_command", {
+				commandName,
+				input: args.json
+			}));
+			return;
+		}
+		case "operator": {
+			const operatorId = args.rest[0];
+			if (!operatorId) throw new Error("operator requires an operator id.");
+			print(await rpc(args.port, "run_operator", {
+				operatorId,
+				input: args.json
+			}));
+			return;
+		}
+		case "undo":
+			print(await rpc(args.port, "undo"));
+			return;
+		case "redo":
+			print(await rpc(args.port, "redo"));
+			return;
+		case "mcp":
+			await createMcutMcpServerForTarget({
+				target: createHttpBridgeTarget(args.port),
+				name: "mcut-bridge"
+			}).connect(new StdioServerTransport());
+			return;
+		default: throw new Error(`Unknown mcut-bridge command "${args.command}".\n\n${usage()}`);
+	}
+}
+main().catch((error) => {
+	console.error(error instanceof Error ? error.message : String(error));
+	process.exit(1);
+});
+//#endregion
+export {};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/cli.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { t as createMcutMcpServer } from "./server-DyDMot4v.js";
+import { EditorEngine, parseProject } from "@mcut/timeline";
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+//#region src/cli.ts
+/**
+* Stdio entry point:
+*
+*   bunx @mcut/mcp-server [path/to/project.json]
+*
+* The project file (default `project.mcut.json`, or $MCUT_PROJECT) is created
+* when missing and rewritten after every successful edit.
+*/
+const projectPath = process.argv[2] ?? process.env.MCUT_PROJECT ?? "project.mcut.json";
+async function loadEngine() {
+	if (!existsSync(projectPath)) return new EditorEngine();
+	return new EditorEngine({ project: parseProject(JSON.parse(await readFile(projectPath, "utf8"))) });
+}
+const engine = await loadEngine();
+await createMcutMcpServer({
+	engine,
+	onChange: async () => {
+		await writeFile(projectPath, `${JSON.stringify(engine.toJSON(), null, 2)}\n`, "utf8");
+	}
+}).connect(new StdioServerTransport());
+console.error(`mcut MCP server ready — project: ${projectPath}`);
+//#endregion
+export {};

package/dist/index.d.ts

@@ -0,0 +1,83 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { EditorOperatorRegistry } from "@mcut/editor";
+import { EditorEngine, ProjectTranscriptOptions } from "@mcut/timeline";
+
+//#region src/server.d.ts
+interface McutMcpTarget {
+  getSummary(): string | Promise<string>;
+  getProject(): unknown | Promise<unknown>;
+  getMediaContext?(): unknown | Promise<unknown>;
+  getTranscript?(options?: ProjectTranscriptOptions): unknown | Promise<unknown>;
+  searchTranscript?(query: string): unknown | Promise<unknown>;
+  ensureTranscript?(input: unknown): unknown | Promise<unknown>;
+  listActions(): unknown | Promise<unknown>;
+  listOperators(): unknown | Promise<unknown>;
+  runAction(actionId: string, input: unknown): unknown | Promise<unknown>;
+  undo(): boolean | Promise<boolean>;
+  redo(): boolean | Promise<boolean>;
+  runOperator(operatorId: string, input: unknown): unknown | Promise<unknown>;
+  dispatchCommand(commandName: string, input: unknown): unknown | Promise<unknown>;
+}
+interface McutMcpServerOptions {
+  engine: EditorEngine;
+  /** Called after every successful edit — persist the project here. */
+  onChange?: () => void | Promise<void>;
+  /** Defaults to the core operator set. */
+  operators?: EditorOperatorRegistry;
+  name?: string;
+  version?: string;
+}
+interface McutMcpServerForTargetOptions {
+  target: McutMcpTarget;
+  /** Defaults to the core operator set. Used for tool schema generation. */
+  operators?: EditorOperatorRegistry;
+  name?: string;
+  version?: string;
+}
+declare const operatorToolName: (id: string) => string;
+/**
+ * Build the server around an existing engine. The caller owns the transport:
+ * `await createMcutMcpServer({ engine }).connect(new StdioServerTransport())`.
+ */
+declare function createMcutMcpServer(options: McutMcpServerOptions): Server;
+/** Build the same MCP tool surface around any target, including a live browser tab. */
+declare function createMcutMcpServerForTarget(options: McutMcpServerForTargetOptions): Server;
+//#endregion
+//#region src/live-bridge.d.ts
+declare const DEFAULT_BRIDGE_PORT = 44737;
+interface LiveBridgeOptions {
+  token?: string | null;
+  allowedOrigins?: string[];
+  requestTimeoutMs?: number;
+  transcriptionTimeoutMs?: number;
+}
+declare class LiveBridgeError extends Error {
+  readonly code: string;
+  constructor(code: string, message: string);
+}
+declare class LiveMcutBridge {
+  readonly token: string | null;
+  readonly requestTimeoutMs: number;
+  readonly transcriptionTimeoutMs: number;
+  private readonly server;
+  private readonly wss;
+  private readonly pending;
+  private socket;
+  private nextId;
+  private tabInfo;
+  constructor(options?: LiveBridgeOptions);
+  listen(port?: number): Promise<number>;
+  close(): void;
+  isConnected(): boolean;
+  getTabInfo(): unknown;
+  rpc(type: string, payload?: unknown): Promise<unknown>;
+  request(type: string, payload?: unknown): Promise<unknown>;
+  createTarget(): McutMcpTarget;
+  private attach;
+  private receive;
+  private handleHttp;
+}
+declare function parseLiveBridgePort(value: string | undefined): number | undefined;
+declare function createHttpBridgeTarget(port?: number): McutMcpTarget;
+//#endregion
+export { DEFAULT_BRIDGE_PORT, LiveBridgeError, type LiveBridgeOptions, LiveMcutBridge, type McutMcpServerForTargetOptions, type McutMcpServerOptions, type McutMcpTarget, createHttpBridgeTarget, createMcutMcpServer, createMcutMcpServerForTarget, operatorToolName, parseLiveBridgePort };

package/dist/index.js

@@ -0,0 +1,3 @@
+import { n as createMcutMcpServerForTarget, r as operatorToolName, t as createMcutMcpServer } from "./server-DyDMot4v.js";
+import { a as parseLiveBridgePort, i as createHttpBridgeTarget, n as LiveBridgeError, r as LiveMcutBridge, t as DEFAULT_BRIDGE_PORT } from "./live-bridge-ky67GOTs.js";
+export { DEFAULT_BRIDGE_PORT, LiveBridgeError, LiveMcutBridge, createHttpBridgeTarget, createMcutMcpServer, createMcutMcpServerForTarget, operatorToolName, parseLiveBridgePort };

package/dist/live-bridge-ky67GOTs.js

@@ -0,0 +1,300 @@
+import { createServer } from "node:http";
+import { randomBytes } from "node:crypto";
+import { WebSocket, WebSocketServer } from "ws";
+//#region src/live-bridge.ts
+const DEFAULT_BRIDGE_PORT = 44737;
+var LiveBridgeError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "LiveBridgeError";
+		this.code = code;
+	}
+};
+function parsePort(value) {
+	if (!value) return null;
+	const port = Number(value);
+	return Number.isInteger(port) && port >= 0 && port <= 65535 ? port : null;
+}
+function isAllowedOrigin(origin, allowedOrigins) {
+	if (!origin) return true;
+	let parsed;
+	try {
+		parsed = new URL(origin);
+	} catch {
+		return false;
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return false;
+	if (allowedOrigins.includes(origin)) return true;
+	return parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1";
+}
+function tokenFrom(req) {
+	const host = req.headers.host ?? "127.0.0.1";
+	return new URL(req.url ?? "/", `http://${host}`).searchParams.get("token");
+}
+function hasCliHeader(req) {
+	return req.headers["x-mcut-bridge-client"] === "cli";
+}
+function sendJson(res, status, value) {
+	res.writeHead(status, {
+		"content-type": "application/json; charset=utf-8",
+		"cache-control": "no-store"
+	});
+	res.end(`${JSON.stringify(value)}\n`);
+}
+async function readJson(req) {
+	const chunks = [];
+	for await (const chunk of req) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+	if (chunks.length === 0) return {};
+	return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+function messageError(error) {
+	const prefix = error.code ? `${error.name ?? "Error"} (${error.code})` : error.name ?? "Error";
+	return new LiveBridgeError(error.code ?? "browser-error", `${prefix}: ${error.message ?? "Unknown error"}`);
+}
+var LiveMcutBridge = class {
+	token;
+	requestTimeoutMs;
+	transcriptionTimeoutMs;
+	server = createServer((req, res) => void this.handleHttp(req, res));
+	wss;
+	pending = /* @__PURE__ */ new Map();
+	socket = null;
+	nextId = 1;
+	tabInfo = null;
+	constructor(options = {}) {
+		this.token = options.token === void 0 ? randomBytes(32).toString("hex") : options.token;
+		this.requestTimeoutMs = options.requestTimeoutMs ?? 3e4;
+		this.transcriptionTimeoutMs = options.transcriptionTimeoutMs ?? 10 * 6e4;
+		const allowedOrigins = options.allowedOrigins ?? [];
+		const verifyClient = ({ origin, req }) => (this.token === null || tokenFrom(req) === this.token) && isAllowedOrigin(origin, allowedOrigins);
+		this.wss = new WebSocketServer({
+			server: this.server,
+			path: "/mcut-mcp",
+			verifyClient
+		});
+		this.wss.on("connection", (socket) => this.attach(socket));
+	}
+	async listen(port = 0) {
+		await new Promise((resolve, reject) => {
+			this.server.once("error", reject);
+			this.server.listen(port, "127.0.0.1", () => {
+				this.server.off("error", reject);
+				resolve();
+			});
+		});
+		const address = this.server.address();
+		if (!address || typeof address === "string") throw new LiveBridgeError("invalid-listener", "Could not determine live bridge port.");
+		return address.port;
+	}
+	close() {
+		this.socket?.close();
+		this.wss.close();
+		this.server.close();
+		for (const [id, pending] of this.pending) {
+			clearTimeout(pending.timer);
+			pending.reject(new LiveBridgeError("bridge-closed", `Live bridge closed before response ${id}.`));
+		}
+		this.pending.clear();
+	}
+	isConnected() {
+		return this.socket?.readyState === WebSocket.OPEN;
+	}
+	getTabInfo() {
+		return this.tabInfo;
+	}
+	async rpc(type, payload = {}) {
+		switch (type) {
+			case "status": return {
+				connected: this.isConnected(),
+				tab: this.tabInfo
+			};
+			default: return await this.request(type, payload);
+		}
+	}
+	async request(type, payload = {}) {
+		const socket = this.socket;
+		if (!socket || socket.readyState !== WebSocket.OPEN) throw new LiveBridgeError("browser-not-connected", "No mcut editor tab is connected. Open the live editor URL printed by the MCP server.");
+		const timeoutMs = type === "ensure_transcript" ? this.transcriptionTimeoutMs : this.requestTimeoutMs;
+		const id = String(this.nextId++);
+		const body = JSON.stringify({
+			id,
+			type,
+			payload
+		});
+		return await new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.pending.delete(id);
+				reject(new LiveBridgeError("request-timeout", `Timed out waiting for browser response to ${type}.`));
+			}, timeoutMs);
+			this.pending.set(id, {
+				resolve,
+				reject,
+				timer
+			});
+			socket.send(body, (error) => {
+				if (!error) return;
+				clearTimeout(timer);
+				this.pending.delete(id);
+				reject(error);
+			});
+		});
+	}
+	createTarget() {
+		return {
+			getSummary: async () => String(await this.request("get_summary")),
+			getProject: () => this.request("get_project"),
+			getMediaContext: () => this.request("get_media_context"),
+			getTranscript: (options) => this.request("get_transcript", options ?? {}),
+			searchTranscript: (query) => this.request("search_transcript", { query }),
+			ensureTranscript: (input) => this.request("ensure_transcript", input ?? {}),
+			listActions: () => this.request("list_actions"),
+			listOperators: () => this.request("list_operators"),
+			undo: async () => Boolean(await this.request("undo")),
+			redo: async () => Boolean(await this.request("redo")),
+			runAction: (actionId, input) => this.request("run_action", {
+				actionId,
+				input: input ?? {}
+			}),
+			runOperator: (operatorId, input) => this.request("run_operator", {
+				operatorId,
+				input: input ?? {}
+			}),
+			dispatchCommand: (commandName, input) => this.request("dispatch_command", {
+				commandName,
+				input: input ?? {}
+			})
+		};
+	}
+	attach(socket) {
+		this.socket?.close(1012, "Another mcut editor tab connected.");
+		this.socket = socket;
+		this.tabInfo = null;
+		socket.on("message", (raw) => this.receive(raw.toString()));
+		socket.on("close", () => {
+			if (this.socket === socket) {
+				this.socket = null;
+				this.tabInfo = null;
+			}
+			for (const [id, pending] of this.pending) {
+				clearTimeout(pending.timer);
+				pending.reject(new LiveBridgeError("browser-disconnected", `Browser disconnected before response ${id}.`));
+			}
+			this.pending.clear();
+		});
+	}
+	receive(raw) {
+		let message;
+		try {
+			message = JSON.parse(raw);
+		} catch {
+			return;
+		}
+		if (!message.id && message.type === "hello") {
+			this.tabInfo = message.payload ?? null;
+			return;
+		}
+		if (!message.id) return;
+		const pending = this.pending.get(message.id);
+		if (!pending) return;
+		clearTimeout(pending.timer);
+		this.pending.delete(message.id);
+		if (message.ok === false) {
+			pending.reject(messageError(message.error ?? {}));
+			return;
+		}
+		pending.resolve(message.result);
+	}
+	async handleHttp(req, res) {
+		if (req.method === "GET" && req.url === "/status") {
+			sendJson(res, 200, {
+				ok: true,
+				result: await this.rpc("status")
+			});
+			return;
+		}
+		if (req.method !== "POST" || req.url !== "/rpc") {
+			sendJson(res, 404, {
+				ok: false,
+				error: "Not found."
+			});
+			return;
+		}
+		if (req.headers.origin || !hasCliHeader(req)) {
+			sendJson(res, 403, {
+				ok: false,
+				error: "Bridge RPC is only available to local CLI clients."
+			});
+			return;
+		}
+		try {
+			const body = await readJson(req);
+			if (typeof body.type !== "string") {
+				sendJson(res, 400, {
+					ok: false,
+					error: "RPC request requires a string type."
+				});
+				return;
+			}
+			sendJson(res, 200, {
+				ok: true,
+				result: await this.rpc(body.type, body.payload ?? {})
+			});
+		} catch (error) {
+			sendJson(res, 500, {
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+	}
+};
+function parseLiveBridgePort(value) {
+	if (value === void 0) return void 0;
+	const port = parsePort(value);
+	if (port === null) throw new LiveBridgeError("invalid-port", `Invalid port: ${value}`);
+	return port;
+}
+function createHttpBridgeTarget(port = DEFAULT_BRIDGE_PORT) {
+	const rpc = async (type, payload = {}) => {
+		const response = await fetch(`http://127.0.0.1:${port}/rpc`, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				"x-mcut-bridge-client": "cli"
+			},
+			body: JSON.stringify({
+				type,
+				payload
+			})
+		});
+		const json = await response.json();
+		if (!response.ok || !json.ok) throw new LiveBridgeError("bridge-rpc-failed", json.error ?? `Bridge RPC failed (${response.status}).`);
+		return json.result;
+	};
+	return {
+		getSummary: async () => String(await rpc("get_summary")),
+		getProject: () => rpc("get_project"),
+		getMediaContext: () => rpc("get_media_context"),
+		getTranscript: (options) => rpc("get_transcript", options ?? {}),
+		searchTranscript: (query) => rpc("search_transcript", { query }),
+		ensureTranscript: (input) => rpc("ensure_transcript", input ?? {}),
+		listActions: () => rpc("list_actions"),
+		listOperators: () => rpc("list_operators"),
+		undo: async () => Boolean(await rpc("undo")),
+		redo: async () => Boolean(await rpc("redo")),
+		runAction: (actionId, input) => rpc("run_action", {
+			actionId,
+			input: input ?? {}
+		}),
+		runOperator: (operatorId, input) => rpc("run_operator", {
+			operatorId,
+			input: input ?? {}
+		}),
+		dispatchCommand: (commandName, input) => rpc("dispatch_command", {
+			commandName,
+			input: input ?? {}
+		})
+	};
+}
+//#endregion
+export { parseLiveBridgePort as a, createHttpBridgeTarget as i, LiveBridgeError as n, LiveMcutBridge as r, DEFAULT_BRIDGE_PORT as t };

package/dist/live-cli.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/live-cli.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+import { n as createMcutMcpServerForTarget } from "./server-DyDMot4v.js";
+import { a as parseLiveBridgePort, r as LiveMcutBridge } from "./live-bridge-ky67GOTs.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+//#region src/live-cli.ts
+/**
+* Live browser entry point:
+*
+*   mcut-mcp-live [--port 54319] [--editor-url http://localhost:3000/editor]
+*
+* Starts an MCP server over stdio and a localhost WebSocket bridge. Open the
+* printed editor URL so the browser tab becomes the source of truth.
+*/
+function readArgs(argv) {
+	const args = { editorUrl: "http://localhost:3000/editor" };
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "--port") args.port = parseLiveBridgePort(argv[++i]);
+		else if (arg === "--token") args.token = argv[++i];
+		else if (arg === "--editor-url") args.editorUrl = argv[++i] ?? args.editorUrl;
+		else if (arg === "--help" || arg === "-h") {
+			console.error([
+				"Usage: mcut-mcp-live [--port 54319] [--editor-url http://localhost:3000/editor]",
+				"",
+				"Starts a stdio MCP server that forwards mcut tools to a live browser editor tab."
+			].join("\n"));
+			process.exit(0);
+		}
+	}
+	return args;
+}
+function editorBridgeUrl(editorUrl, port, token) {
+	const url = new URL(editorUrl);
+	url.searchParams.set("mcpBridge", String(port));
+	url.searchParams.set("mcpToken", token);
+	return url.toString();
+}
+const args = readArgs(process.argv.slice(2));
+const bridge = new LiveMcutBridge({ token: args.token });
+const port = await bridge.listen(args.port);
+console.error([
+	`mcut live MCP server ready — bridge: ws://127.0.0.1:${port}/mcut-mcp`,
+	`Open editor: ${editorBridgeUrl(args.editorUrl, port, bridge.token ?? "")}`,
+	"",
+	"MCP client config:",
+	JSON.stringify({ mcpServers: { "mcut-live": {
+		command: "bunx",
+		args: [
+			"-p",
+			"@mcut/mcp-server",
+			"mcut-mcp-live",
+			"--port",
+			String(port),
+			"--token",
+			bridge.token ?? "",
+			"--editor-url",
+			args.editorUrl
+		]
+	} } }, null, 2)
+].join("\n"));
+const server = createMcutMcpServerForTarget({
+	target: bridge.createTarget(),
+	name: "mcut-live"
+});
+process.on("SIGINT", () => {
+	bridge.close();
+	process.exit(130);
+});
+process.on("SIGTERM", () => {
+	bridge.close();
+	process.exit(143);
+});
+await server.connect(new StdioServerTransport());
+//#endregion
+export {};

package/dist/server-DyDMot4v.js

@@ -0,0 +1,340 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { OperatorError, createEditorOperatorRegistry, registerCoreOperators } from "@mcut/editor";
+import { CommandError, ProjectFormatError, getProjectCaptions, getProjectMediaContext, getProjectTranscript, listCommands, summarizeProject } from "@mcut/timeline";
+import { searchCaptions } from "@mcut/transcription";
+import { z } from "zod";
+//#region src/server.ts
+/**
+* mcut as an MCP server: every registered editor command becomes an MCP tool,
+* straight from the zod command registry — plus user-level operators from
+* @mcut/editor and a handful of static tools (summary, project, undo/redo).
+*
+* The target can be a local EditorEngine or a live browser tab. Export stays
+* in the browser (WebCodecs); MCP edits the project document/state.
+*/
+const operatorToolName = (id) => `operator_${id.replace(/[^A-Za-z0-9_-]/g, "_")}`;
+const toInputSchema = (schema) => z.toJSONSchema(schema, {
+	io: "input",
+	unrepresentable: "any"
+});
+const STATIC_TOOLS = [
+	{
+		name: "get_summary",
+		description: "A compact textual rendering of the current project: tracks (topmost first), elements with ids/timing/keyframes/effects/transitions, and assets. Read this before editing, then use get_media_context/get_transcript for video metadata and transcript details.",
+		inputSchema: {
+			type: "object",
+			properties: {},
+			additionalProperties: false
+		}
+	},
+	{
+		name: "get_project",
+		description: "The full project document as JSON (the serializable source of truth).",
+		inputSchema: {
+			type: "object",
+			properties: {},
+			additionalProperties: false
+		}
+	},
+	{
+		name: "get_media_context",
+		description: "Agent-friendly project/video metadata: project dimensions/fps/duration, playback, selection, assets, tracks, elements, clip source ranges, markers, and transcript availability. Use this before content-aware edits.",
+		inputSchema: {
+			type: "object",
+			properties: {},
+			additionalProperties: false
+		}
+	},
+	{
+		name: "get_transcript",
+		description: "Read the current transcript derived from caption elements. This never starts transcription. If no transcript exists and speech context is needed, call ensure_transcript in live bridge mode.",
+		inputSchema: {
+			type: "object",
+			properties: { includeWords: {
+				type: "boolean",
+				description: "Include absolute word timings for precise speech-boundary edits."
+			} },
+			additionalProperties: false
+		}
+	},
+	{
+		name: "search_transcript",
+		description: "Search the caption-derived transcript and return timeline times for matches. Use this to locate spoken words/phrases before cutting or annotating.",
+		inputSchema: {
+			type: "object",
+			properties: { query: { type: "string" } },
+			required: ["query"],
+			additionalProperties: false
+		}
+	},
+	{
+		name: "ensure_transcript",
+		description: "Live bridge only: if the target clip has no caption transcript, transcribe it with local Whisper in the connected browser, then apply word-timed captions to the timeline. Explicit tool only; get_transcript never auto-transcribes.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				elementId: {
+					type: "string",
+					description: "Optional video/audio element id. Defaults to selected media, then first video, then first audio."
+				},
+				replace: {
+					type: "boolean",
+					description: "When true, replace captions overlapping the target clip. Defaults to false."
+				},
+				language: {
+					type: "string",
+					description: "Optional language hint for Whisper."
+				}
+			},
+			additionalProperties: false
+		}
+	},
+	{
+		name: "list_operators",
+		description: "List user-level editor operators available to agents. Prefer these for UI-parity actions; use raw command tools for low-level document edits.",
+		inputSchema: {
+			type: "object",
+			properties: {},
+			additionalProperties: false
+		}
+	},
+	{
+		name: "list_actions",
+		description: "List browser editor actions available in the live editor, including menu/palette/hotkey actions. Use this in live bridge mode when you need exact UI parity.",
+		inputSchema: {
+			type: "object",
+			properties: {},
+			additionalProperties: false
+		}
+	},
+	{
+		name: "run_action",
+		description: "Run a browser editor action by id in the live editor. These are the same actions used by menus, hotkeys, and the command palette.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				actionId: { type: "string" },
+				input: {
+					type: "object",
+					additionalProperties: true
+				}
+			},
+			required: ["actionId"],
+			additionalProperties: false
+		}
+	},
+	{
+		name: "undo",
+		description: "Undo the most recent edit.",
+		inputSchema: {
+			type: "object",
+			properties: {},
+			additionalProperties: false
+		}
+	},
+	{
+		name: "redo",
+		description: "Redo the most recently undone edit.",
+		inputSchema: {
+			type: "object",
+			properties: {},
+			additionalProperties: false
+		}
+	}
+];
+const text = (value) => ({ content: [{
+	type: "text",
+	text: value
+}] });
+const failure = (value) => ({
+	...text(value),
+	isError: true
+});
+function viewState(engine) {
+	const playback = engine.playback.state;
+	const selection = engine.selection.elementIds;
+	return `Playhead: ${(playback.currentTimeMs / 1e3).toFixed(2)}s (${playback.isPlaying ? "playing" : "paused"}) · Selection: ${selection.length > 0 ? selection.join(", ") : "none"}`;
+}
+function summarizeEngine(engine) {
+	return `${summarizeProject(engine.project)}\n${viewState(engine)}`;
+}
+function transcriptOptions(args) {
+	return { includeWords: (args ?? {}).includeWords === true };
+}
+function transcriptQuery(args) {
+	const input = args ?? {};
+	const query = typeof input.query === "string" ? input.query.trim() : "";
+	return query.length > 0 ? query : null;
+}
+function searchProjectTranscript(project, query) {
+	const captionRefs = getProjectCaptions(project);
+	const captions = captionRefs.map((ref) => ref.caption);
+	const byId = new Map(captionRefs.map((ref) => [ref.caption.id, ref]));
+	const matches = searchCaptions(captions, query).map((match) => {
+		const ref = byId.get(match.captionId);
+		const text = ref?.caption.text ?? "";
+		return {
+			...match,
+			text: text.slice(match.startChar, match.endChar),
+			captionText: text,
+			trackId: ref?.trackId,
+			trackName: ref?.trackName,
+			startMs: match.timeMs,
+			endMs: match.endTimeMs
+		};
+	});
+	return {
+		query,
+		count: matches.length,
+		matches
+	};
+}
+function createEngineTarget(engine, operators, onChange) {
+	return {
+		getSummary: () => summarizeEngine(engine),
+		getProject: () => engine.toJSON(),
+		getMediaContext: () => getProjectMediaContext(engine.project, {
+			playback: engine.playback.state,
+			selection: engine.selection
+		}),
+		getTranscript: (options) => getProjectTranscript(engine.project, options),
+		searchTranscript: (query) => searchProjectTranscript(engine.project, query),
+		ensureTranscript: async () => {
+			throw new Error("ensure_transcript requires a live browser bridge connected to an editor tab.");
+		},
+		listActions: () => [],
+		listOperators: () => operators.listAvailable({ engine }).map((operator) => ({
+			id: operator.id,
+			label: operator.label,
+			category: operator.category,
+			enabled: operator.enabled,
+			disabledReason: operator.disabledReason,
+			tool: operatorToolName(operator.id),
+			description: operator.description
+		})),
+		undo: async () => {
+			const applied = engine.undo();
+			if (applied) await onChange();
+			return applied;
+		},
+		redo: async () => {
+			const applied = engine.redo();
+			if (applied) await onChange();
+			return applied;
+		},
+		runAction: async (actionId) => {
+			throw new Error(`Browser action "${actionId}" is only available through a live browser bridge.`);
+		},
+		runOperator: async (operatorId, input) => {
+			const result = await operators.run(operatorId, { engine }, input ?? {});
+			await onChange();
+			return result;
+		},
+		dispatchCommand: async (commandName, input) => {
+			engine.dispatch({
+				type: commandName,
+				...input ?? {}
+			});
+			await onChange();
+		}
+	};
+}
+/**
+* Build the server around an existing engine. The caller owns the transport:
+* `await createMcutMcpServer({ engine }).connect(new StdioServerTransport())`.
+*/
+function createMcutMcpServer(options) {
+	const operators = options.operators ?? registerCoreOperators(createEditorOperatorRegistry());
+	return createMcutMcpServerForTarget({
+		target: createEngineTarget(options.engine, operators, options.onChange ?? (() => {})),
+		operators,
+		name: options.name,
+		version: options.version
+	});
+}
+/** Build the same MCP tool surface around any target, including a live browser tab. */
+function createMcutMcpServerForTarget(options) {
+	const { target } = options;
+	const operators = options.operators ?? registerCoreOperators(createEditorOperatorRegistry());
+	const commandTools = listCommands().map((command) => ({
+		name: command.type,
+		description: command.description,
+		inputSchema: toInputSchema(command.payloadSchema)
+	}));
+	const operatorIdsByTool = /* @__PURE__ */ new Map();
+	const operatorTools = operators.list().map((operator) => {
+		const name = operatorToolName(operator.id);
+		operatorIdsByTool.set(name, operator.id);
+		return {
+			name,
+			description: `Editor operator "${operator.id}": ${operator.description}`,
+			inputSchema: toInputSchema(operator.inputSchema)
+		};
+	});
+	const server = new Server({
+		name: options.name ?? "mcut",
+		version: options.version ?? "0.1.0"
+	}, { capabilities: { tools: {} } });
+	server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [
+		...STATIC_TOOLS,
+		...operatorTools,
+		...commandTools
+	] }));
+	server.setRequestHandler(CallToolRequestSchema, async (request) => {
+		const { name, arguments: args } = request.params;
+		try {
+			switch (name) {
+				case "get_summary": return text(await target.getSummary());
+				case "get_project": return text(JSON.stringify(await target.getProject(), null, 2));
+				case "get_media_context":
+					if (!target.getMediaContext) return failure("get_media_context is not available on this target.");
+					return text(JSON.stringify(await target.getMediaContext(), null, 2));
+				case "get_transcript":
+					if (!target.getTranscript) return failure("get_transcript is not available on this target.");
+					return text(JSON.stringify(await target.getTranscript(transcriptOptions(args)), null, 2));
+				case "search_transcript": {
+					if (!target.searchTranscript) return failure("search_transcript is not available on this target.");
+					const query = transcriptQuery(args);
+					if (!query) return failure("search_transcript requires a non-empty query string.");
+					return text(JSON.stringify(await target.searchTranscript(query), null, 2));
+				}
+				case "ensure_transcript": {
+					if (!target.ensureTranscript) return failure("ensure_transcript is not available on this target.");
+					const result = await target.ensureTranscript(args ?? {});
+					return text(`OK: transcript ensured.${result === void 0 ? "" : `\n\nResult:\n${JSON.stringify(result, null, 2)}`}\n\n${await target.getSummary()}`);
+				}
+				case "list_operators": return text(JSON.stringify(await target.listOperators(), null, 2));
+				case "list_actions": return text(JSON.stringify(await target.listActions(), null, 2));
+				case "run_action": {
+					const input = args ?? {};
+					if (typeof input.actionId !== "string") return failure("run_action requires an actionId string.");
+					const result = await target.runAction(input.actionId, input.input ?? {});
+					const suffix = result === void 0 ? "" : `\n\nResult:\n${JSON.stringify(result, null, 2)}`;
+					return text(`OK: action ${input.actionId} applied.${suffix}\n\n${await target.getSummary()}`);
+				}
+				case "undo":
+					if (!await target.undo()) return failure("Nothing to undo.");
+					return text(`Undone.\n\n${await target.getSummary()}`);
+				case "redo":
+					if (!await target.redo()) return failure("Nothing to redo.");
+					return text(`Redone.\n\n${await target.getSummary()}`);
+				default: {
+					const operatorId = operatorIdsByTool.get(name);
+					if (operatorId) {
+						const result = await target.runOperator(operatorId, args ?? {});
+						return text(`OK: operator ${operatorId} applied.${result === void 0 ? "" : `\n\nResult:\n${JSON.stringify(result, null, 2)}`}\n\n${await target.getSummary()}`);
+					}
+					await target.dispatchCommand(name, args ?? {});
+					return text(`OK: ${name} applied.\n\n${await target.getSummary()}`);
+				}
+			}
+		} catch (error) {
+			if (error instanceof CommandError || error instanceof ProjectFormatError || error instanceof OperatorError) return failure(`${error.name} (${error.code}): ${error.message}`);
+			return failure(error instanceof Error ? error.message : String(error));
+		}
+	});
+	return server;
+}
+//#endregion
+export { createMcutMcpServerForTarget as n, operatorToolName as r, createMcutMcpServer as t };

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@mcut/mcp-server",
+  "version": "0.1.0-alpha.0",
+  "description": "mcut as an MCP server: every editor command and operator becomes a tool any MCP client can call",
+  "license": "Apache-2.0",
+  "type": "module",
+  "bin": {
+    "mcut-bridge": "./dist/bridge-cli.js",
+    "mcut-mcp": "./dist/cli.js",
+    "mcut-mcp-live": "./dist/live-cli.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch --no-clean",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mattppal/mcut.git",
+    "directory": "packages/mcp-server"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@mcut/editor": "0.1.0-alpha.0",
+    "@mcut/timeline": "0.1.0-alpha.0",
+    "@mcut/transcription": "0.1.0-alpha.0",
+    "@modelcontextprotocol/sdk": "^1.21.0",
+    "ws": "8.18.3",
+    "zod": "4.4.3"
+  },
+  "devDependencies": {
+    "@types/ws": "8.18.1"
+  },
+  "author": "Matt Palmer",
+  "homepage": "https://github.com/mattppal/mcut/tree/main/packages/mcp-server#readme",
+  "bugs": {
+    "url": "https://github.com/mattppal/mcut/issues"
+  },
+  "keywords": [
+    "mcut",
+    "video",
+    "video-editing",
+    "timeline",
+    "typescript",
+    "mcp",
+    "model-context-protocol",
+    "agents"
+  ],
+  "engines": {
+    "node": ">=20.11"
+  }
+}