creavit-studio-mcp 1.0.0

package/README.md

@@ -0,0 +1,195 @@
+# Creavit Studio MCP Server
+
+Lets AI coding agents — Claude Code, Codex, Cursor, or anything else that speaks
+[MCP](https://modelcontextprotocol.io) — drive the Creavit Studio desktop app:
+open projects, change settings, add zoom ranges, start recordings, export video,
+and **see the canvas** to verify the result.
+
+macOS only (Creavit Studio is a macOS app). Requires Node 18+.
+
+## Install
+
+### Claude Code
+
+```bash
+claude mcp add creavit-studio -- npx -y creavit-studio-mcp
+```
+
+Or, if you have the app repo checked out, `.mcp.json` in `desktop/` already
+configures it — just open Claude Code there.
+
+### Cursor
+
+`~/.cursor/mcp.json` (global) or `.cursor/mcp.json` (per project):
+
+```json
+{
+  "mcpServers": {
+    "creavit-studio": {
+      "command": "npx",
+      "args": ["-y", "creavit-studio-mcp"]
+    }
+  }
+}
+```
+
+### Codex CLI
+
+`~/.codex/config.toml`:
+
+```toml
+[mcp_servers.creavit-studio]
+command = "npx"
+args = ["-y", "creavit-studio-mcp"]
+```
+
+### Verify
+
+```bash
+npx creavit-studio-mcp --doctor
+```
+
+```
+creavit-studio v1.0.0
+
+✓ 34 MCP tools defined
+✓ Offline project reading available (.crvt files readable without the app)
+✓ Connected to the app (v3.0.5, pid 61068)
+  Open windows: 2
+  Agent-connected renderers: main, editor
+✓ 41 bridge commands available
+
+Everything looks good.
+```
+
+## How it works
+
+```
+Agent (Claude Code / Codex / Cursor)
+  │  MCP over stdio (JSON-RPC)
+  ▼
+creavit-studio-mcp
+  │  HTTP + bearer token, bound to 127.0.0.1 only
+  ▼
+Creavit Studio main process   (agent bridge)
+  │  IPC
+  ▼
+Renderer windows (editor / recorder) → the real app state
+```
+
+On startup the app picks a random port, generates a fresh token, and writes an
+endpoint descriptor:
+
+```
+~/Library/Application Support/creavit-studio/agent-bridge.json   (mode 0600)
+```
+
+The MCP server discovers the app through that file. Restarting the app does
+**not** require restarting the MCP server — the endpoint is re-read on every
+request.
+
+The app must be running for most tools. Project inspection tools read `.crvt`
+files directly and work with the app closed.
+
+## Tools
+
+**App** — `creavit_app_info`, `creavit_app_window`, `creavit_app_mode`,
+`creavit_permissions`, `creavit_events`
+
+**Projects** — `creavit_project_list`, `creavit_project_summary`,
+`creavit_project_manifest`, `creavit_project_open`, `creavit_project_save`,
+`creavit_project_reveal`
+
+> The first three work with the app closed.
+
+**Editor** — `creavit_editor_state`, `creavit_editor_get_settings`,
+`creavit_editor_set_settings`, `creavit_editor_list_zooms`,
+`creavit_editor_add_zoom`, `creavit_editor_update_zoom`,
+`creavit_editor_remove_zoom`, `creavit_editor_segments`,
+`creavit_editor_set_segments`, `creavit_editor_seek`,
+`creavit_editor_playback`, `creavit_editor_screenshot`,
+`creavit_editor_export`, `creavit_editor_history`
+
+**Recording** — `creavit_devices_list`, `creavit_recording_status`,
+`creavit_recording_start`, `creavit_recording_stop`
+
+**Escape hatches** — `creavit_capabilities`, `creavit_call`, `creavit_ipc`,
+`creavit_eval`, `creavit_logs`
+
+The typed tools cannot cover the whole app. `creavit_capabilities` lists
+**every** command and editor action the app exposes; `creavit_call` invokes any
+of them; `creavit_ipc` reaches all ~110 raw IPC channels. New app features
+become reachable through these without changing the MCP server.
+
+## Typical flow
+
+```
+creavit_app_info              is the app running, which windows are open
+creavit_project_list          see available projects
+creavit_project_summary       understand the target project
+creavit_project_open          open it in the editor
+creavit_editor_state          poll until duration > 0 (loading takes seconds)
+creavit_editor_screenshot     see the current look
+creavit_editor_set_settings   change something
+creavit_editor_screenshot     VERIFY the result
+creavit_project_save          persist
+```
+
+Two things worth knowing:
+
+- **Wait for the load.** After `creavit_project_open`, poll `creavit_editor_state`
+  until `duration > 0`. Settings written before loading finishes get overwritten.
+- **`padding`, `radius`, `shadowSize` are derived values.** Reads and writes are
+  transparently redirected to `basePadding` / `baseRadius` / `baseShadowSize`,
+  and `creavit_editor_set_settings` returns a `verified` block showing what was
+  actually stored. Check it rather than assuming a write landed.
+
+## Security
+
+- Binds to `127.0.0.1` only; requests carrying an `Origin` header are rejected,
+  so no web page can reach it.
+- Every request requires a bearer token, regenerated on each app launch.
+- The endpoint file is written with `0600` permissions.
+- Arbitrary code execution (`creavit_eval`) is **off by default**.
+
+### Environment variables
+
+Set on the **app**, not the MCP server:
+
+| Variable | Effect |
+|---|---|
+| `CREAVIT_AGENT_BRIDGE=0` | Disable the bridge entirely |
+| `CREAVIT_AGENT_BRIDGE_PORT` | Pin a fixed port (default: pick a free one) |
+| `CREAVIT_AGENT_BRIDGE_EVAL=1` | Enable the `creavit_eval` tool |
+
+Set on the **MCP server**:
+
+| Variable | Effect |
+|---|---|
+| `CREAVIT_AGENT_BRIDGE_ENDPOINT` | Explicit path to the endpoint descriptor |
+
+## Troubleshooting
+
+**"Creavit Studio is not running"** — start the app. If it is running, check
+that the bridge came up: its log line is `[AgentBridge] Ready → http://127.0.0.1:<port>`.
+
+**"The 'editor' window is not open"** — editor tools need a project open. Call
+`creavit_project_open` first.
+
+**Agent says a tool does not exist** — MCP clients cache the tool list at
+connect time. Restart the agent session after upgrading the server.
+
+**Settings do not seem to apply** — check the `verified` field in the
+`creavit_editor_set_settings` response, and make sure the project finished
+loading (`creavit_editor_state` → `duration > 0`).
+
+## Extending
+
+The MCP server is a thin, typed façade. To add a capability:
+
+1. **Main-process work** → add a command in `electron/agentBridge/commands/*.cjs`.
+2. **Needs renderer state** → add an action to the relevant host composable in
+   `composables/agent/`, then publish it via `proxy("<action>")` in
+   `electron/agentBridge/commands/editorCommands.cjs`.
+3. **Want a typed MCP tool** → add it in `mcp/src/tools/*.mjs`. Optional —
+   anything registered on the bridge is already reachable via `creavit_call`.

package/bin/creavit-mcp.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+// Creavit Studio MCP sunucusu.
+// Claude Code / Codex / Cursor gibi MCP istemcilerinin uygulamayı sürebilmesi
+// için stdio üzerinden çalışır.
+//
+// Teşhis: `npx creavit-studio-mcp --doctor`
+
+import { startRpcServer, log } from "../src/rpcServer.mjs";
+import { listTools, callTool } from "../src/tools/index.mjs";
+import { health, listBridgeCommands } from "../src/bridgeClient.mjs";
+import { canReadOffline } from "../src/crvtReader.mjs";
+import { SERVER_NAME, SERVER_VERSION } from "../src/protocol.mjs";
+
+async function doctor() {
+	console.log(`${SERVER_NAME} v${SERVER_VERSION}\n`);
+
+	const tools = await listTools();
+	console.log(`✓ ${tools.length} MCP tools defined`);
+	console.log(
+		canReadOffline()
+			? "✓ Offline project reading available (.crvt files readable without the app)"
+			: "! Offline project reading unavailable — install the `yauzl` dependency",
+	);
+
+	try {
+		const info = await health();
+		console.log(`✓ Connected to the app (v${info.appVersion}, pid ${info.pid})`);
+		console.log(`  Open windows: ${info.windows}`);
+		console.log(
+			`  Agent-connected renderers: ${
+				info.rendererHosts?.map((h) => h.role).join(", ") || "none"
+			}`,
+		);
+		const { commands } = await listBridgeCommands();
+		console.log(`✓ ${commands.length} bridge commands available`);
+		console.log("\nEverything looks good.");
+	} catch (error) {
+		console.log(`✗ Could not connect to the app: ${error.message}`);
+		console.log("\n  Start Creavit Studio, then run this again.");
+		console.log("  Project inspection tools work without the app.");
+		process.exitCode = 1;
+	}
+}
+
+if (process.argv.includes("--doctor")) {
+	await doctor();
+} else if (process.argv.includes("--list-tools")) {
+	console.log(JSON.stringify(await listTools(), null, 2));
+} else if (process.argv.includes("--version")) {
+	console.log(SERVER_VERSION);
+} else if (process.argv.includes("--help")) {
+	console.log(
+		`${SERVER_NAME} v${SERVER_VERSION}\n\n` +
+			"MCP server that lets AI agents drive the Creavit Studio desktop app.\n\n" +
+			"Usage:\n" +
+			"  creavit-studio-mcp              Run as an MCP server over stdio (what MCP clients do)\n" +
+			"  creavit-studio-mcp --doctor     Check the connection to the app\n" +
+			"  creavit-studio-mcp --list-tools Print tool schemas as JSON\n" +
+			"  creavit-studio-mcp --version    Print the version\n",
+	);
+} else {
+	startRpcServer({ listTools, callTool });
+	log(`${SERVER_NAME} v${SERVER_VERSION} — ${(await listTools()).length} tools`);
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+	"name": "creavit-studio-mcp",
+	"version": "1.0.0",
+	"description": "MCP server that lets AI coding agents (Claude Code, Codex, Cursor) drive the Creavit Studio screen recording app",
+	"keywords": [
+		"mcp",
+		"model-context-protocol",
+		"creavit-studio",
+		"screen-recording",
+		"claude",
+		"cursor",
+		"codex"
+	],
+	"license": "MIT",
+	"type": "module",
+	"bin": {
+		"creavit-studio-mcp": "bin/creavit-mcp.mjs"
+	},
+	"main": "./src/tools/index.mjs",
+	"files": [
+		"bin",
+		"src",
+		"README.md"
+	],
+	"engines": {
+		"node": ">=18"
+	},
+	"os": [
+		"darwin"
+	],
+	"dependencies": {
+		"yauzl": "^3.2.0"
+	},
+	"scripts": {
+		"doctor": "node bin/creavit-mcp.mjs --doctor",
+		"tools": "node bin/creavit-mcp.mjs --list-tools",
+		"prepublishOnly": "node bin/creavit-mcp.mjs --list-tools > /dev/null"
+	}
+}

package/src/bridgeClient.mjs

@@ -0,0 +1,133 @@
+// MCP sunucusu — çalışan uygulamaya bağlanan HTTP istemcisi.
+// Endpoint dosyası her uygulama açılışında yenilendiği için her istekten önce
+// tazelik kontrolü yapılır; böylece uygulama yeniden başlatıldığında MCP
+// sunucusunu da yeniden başlatmak gerekmez.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { ENDPOINT_FILENAME, APP_NOT_RUNNING_HINT } from "./protocol.mjs";
+
+const DEFAULT_ENDPOINT_DIRS = [
+	path.join(os.homedir(), "Library", "Application Support", "creavit-studio"),
+	path.join(os.homedir(), "Library", "Application Support", "Creavit Studio"),
+];
+
+export class BridgeUnavailableError extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "BridgeUnavailableError";
+	}
+}
+
+function endpointCandidates() {
+	const fromEnv = process.env.CREAVIT_AGENT_BRIDGE_ENDPOINT;
+	const dirs = fromEnv ? [path.dirname(fromEnv)] : DEFAULT_ENDPOINT_DIRS;
+	const files = fromEnv ? [fromEnv] : dirs.map((d) => path.join(d, ENDPOINT_FILENAME));
+	return files;
+}
+
+function readEndpoint() {
+	for (const file of endpointCandidates()) {
+		try {
+			if (!fs.existsSync(file)) continue;
+			const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+			if (parsed?.port && parsed?.token) return { ...parsed, file };
+		} catch (_) {}
+	}
+	return null;
+}
+
+let cached = null;
+
+function currentEndpoint() {
+	const fresh = readEndpoint();
+	if (!fresh) {
+		cached = null;
+		throw new BridgeUnavailableError(APP_NOT_RUNNING_HINT);
+	}
+	// Port ya da token değiştiyse uygulama yeniden başlamış demektir.
+	if (!cached || cached.port !== fresh.port || cached.token !== fresh.token) {
+		cached = fresh;
+	}
+	return cached;
+}
+
+/**
+ * Köprüye istek at.
+ * @param {string} route   "/rpc" | "/health" | "/commands" | "/events?since=1"
+ * @param {object} [options] { method, body, timeoutMs }
+ */
+async function request(route, { method = "GET", body, timeoutMs = 120_000 } = {}) {
+	const endpoint = currentEndpoint();
+	const url = `http://${endpoint.host || "127.0.0.1"}:${endpoint.port}${route}`;
+
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+
+	let response;
+	try {
+		response = await fetch(url, {
+			method,
+			signal: controller.signal,
+			headers: {
+				Authorization: `Bearer ${endpoint.token}`,
+				...(body ? { "Content-Type": "application/json" } : {}),
+			},
+			body: body ? JSON.stringify(body) : undefined,
+		});
+	} catch (error) {
+		cached = null;
+		if (error?.name === "AbortError") {
+			throw new Error(`Bridge did not respond within ${timeoutMs}ms: ${route}`);
+		}
+		throw new BridgeUnavailableError(
+			`${APP_NOT_RUNNING_HINT}\n(connection error: ${error?.message || error})`,
+		);
+	} finally {
+		clearTimeout(timer);
+	}
+
+	const text = await response.text();
+	let payload;
+	try {
+		payload = text ? JSON.parse(text) : {};
+	} catch (_) {
+		throw new Error(`Invalid response from bridge (${response.status}): ${text.slice(0, 200)}`);
+	}
+
+	if (!response.ok || payload?.ok === false) {
+		const err = payload?.error || {};
+		const error = new Error(err.message || `Bridge error (${response.status})`);
+		error.code = err.code || String(response.status);
+		error.details = err.details || null;
+		throw error;
+	}
+
+	return payload.result;
+}
+
+export async function callCommand(command, params, timeoutMs) {
+	return request("/rpc", {
+		method: "POST",
+		body: { command, params: params || {}, timeoutMs },
+		timeoutMs: timeoutMs || 120_000,
+	});
+}
+
+export async function health() {
+	return request("/health", { timeoutMs: 5_000 });
+}
+
+export async function listBridgeCommands() {
+	return request("/commands", { timeoutMs: 10_000 });
+}
+
+export async function isAppRunning() {
+	try {
+		await health();
+		return true;
+	} catch (_) {
+		return false;
+	}
+}

package/src/crvtReader.mjs

@@ -0,0 +1,108 @@
+// MCP sunucusu — .crvt projelerini uygulama olmadan okuma.
+// .crvt bir ZIP'tir; manifest.json'u doğrudan okuruz. Böylece proje listeleme
+// ve inceleme araçları Creavit Studio kapalıyken de çalışır.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+
+// yauzl paketin kendi bağımlılığıdır; depo içinden çalışırken üstteki
+// node_modules'tan da çözülür. Bulunamazsa salt-okunur araçlar köprüye düşer.
+let yauzl = null;
+try {
+	yauzl = require("yauzl");
+} catch (_) {}
+
+export const canReadOffline = () => Boolean(yauzl);
+
+export function defaultProjectsDir() {
+	return path.join(os.homedir(), "Downloads", "Creavit Studio");
+}
+
+export function readManifestOffline(zipPath) {
+	if (!yauzl) {
+		return Promise.reject(new Error("yauzl is not installed — offline reading is unavailable"));
+	}
+
+	return new Promise((resolve, reject) => {
+		yauzl.open(zipPath, { lazyEntries: true }, (err, zipfile) => {
+			if (err) return reject(err);
+
+			let found = false;
+			zipfile.on("entry", (entry) => {
+				if (entry.fileName !== "manifest.json") {
+					zipfile.readEntry();
+					return;
+				}
+				found = true;
+				zipfile.openReadStream(entry, (streamErr, stream) => {
+					if (streamErr) return reject(streamErr);
+					const chunks = [];
+					stream.on("data", (c) => chunks.push(c));
+					stream.on("end", () => {
+						try {
+							resolve(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+						} catch (parseErr) {
+							reject(new Error(`Could not parse manifest.json: ${parseErr.message}`));
+						}
+						zipfile.close();
+					});
+					stream.on("error", reject);
+				});
+			});
+			zipfile.on("end", () => {
+				if (!found) reject(new Error("manifest.json not found — not a valid .crvt file"));
+			});
+			zipfile.on("error", reject);
+			zipfile.readEntry();
+		});
+	});
+}
+
+export async function listProjectsOffline({ dir, limit } = {}) {
+	const root = dir || defaultProjectsDir();
+	if (!fs.existsSync(root)) return { dir: root, projects: [], source: "offline" };
+
+	const files = fs
+		.readdirSync(root)
+		.filter((f) => f.toLowerCase().endsWith(".crvt"))
+		.map((f) => {
+			const filePath = path.join(root, f);
+			const stat = fs.statSync(filePath);
+			return {
+				fileName: f,
+				filePath,
+				sizeBytes: stat.size,
+				modifiedAt: stat.mtime.toISOString(),
+			};
+		})
+		.sort((a, b) => b.modifiedAt.localeCompare(a.modifiedAt))
+		.slice(0, Number(limit) > 0 ? Number(limit) : 100);
+
+	const projects = await Promise.all(
+		files.map(async (file) => {
+			try {
+				const manifest = await readManifestOffline(file.filePath);
+				// Manifest v2'de süre klip başına tutulur.
+				const durationMs =
+					(manifest?.clips || []).reduce((acc, c) => acc + (Number(c?.durationMs) || 0), 0) ||
+					null;
+				return {
+					...file,
+					name: manifest?.name || file.fileName.replace(/\.crvt$/i, ""),
+					durationMs,
+					durationSeconds: durationMs ? Number((durationMs / 1000).toFixed(2)) : null,
+					createdAt: manifest?.createdAt ?? null,
+					clipCount: (manifest?.clips || []).length,
+				};
+			} catch (_) {
+				return { ...file, name: file.fileName.replace(/\.crvt$/i, ""), manifestError: true };
+			}
+		}),
+	);
+
+	return { dir: root, projects, source: "offline" };
+}

package/src/manifestSummary.mjs

@@ -0,0 +1,88 @@
+// .crvt manifest özeti (v2 şeması).
+//
+// Gerçek manifest şekli:
+//   { version, createdAt, name, projectSettings:{resolution,fps},
+//     playerSettings:{...}, clips:[{id,name,durationMs,media,segments,mouse}] }
+//
+// İki varyant var: taze kayıttan çıkan "hafif" manifest (playerSettings'te
+// sadece birkaç anahtar) ve editörde kaydedilmiş "tam" manifest. Özet ikisini
+// de aynı biçimde raporlar, eksik alanlar null kalır.
+//
+// Bu dosya MCP paketinin tek özet kaynağıdır — Electron köprüsü ham manifest
+// döndürür, özetleme daima burada yapılır. Böylece mcp/ tek başına dağıtılabilir.
+
+function sum(list, pick) {
+	return (list || []).reduce((acc, item) => acc + (Number(pick(item)) || 0), 0);
+}
+
+export function summarizeManifest(manifest, filePath) {
+	const ps = manifest?.playerSettings || {};
+	const clips = Array.isArray(manifest?.clips) ? manifest.clips : [];
+	const totalDurationMs = sum(clips, (c) => c.durationMs);
+
+	// Editörde kaydedilmiş manifest'te tüm ayar anahtarları bulunur; hafif
+	// manifest'te yoktur. Ajanın hangi durumda olduğunu bilmesi gerekiyor.
+	const isEdited = "zoomRanges" in ps || "cameraSettings" in ps;
+
+	return {
+		filePath,
+		name: manifest?.name || null,
+		manifestVersion: manifest?.version ?? null,
+		createdAt: manifest?.createdAt || null,
+		edited: isEdited,
+		durationMs: totalDurationMs || null,
+		durationSeconds: totalDurationMs ? Number((totalDurationMs / 1000).toFixed(2)) : null,
+		output: {
+			resolution: manifest?.projectSettings?.resolution || ps.canvasSize || null,
+			fps: manifest?.projectSettings?.fps ?? null,
+			cropRatio: ps.cropRatio ?? null,
+		},
+		look: {
+			backgroundType: ps.backgroundType ?? null,
+			backgroundColor: ps.backgroundColor ?? null,
+			backgroundImage: ps.backgroundImage || null,
+			backgroundBlur: ps.backgroundBlur ?? null,
+			padding: ps.padding ?? ps.basePadding ?? null,
+			radius: ps.radius ?? ps.baseRadius ?? null,
+			shadowSize: ps.shadowSize ?? ps.baseShadowSize ?? null,
+		},
+		clips: clips.map((clip) => ({
+			id: clip.id ?? null,
+			name: clip.name ?? null,
+			durationMs: clip.durationMs ?? null,
+			segmentCount: (clip.segments || []).length,
+			hasMouseData: Boolean(clip.mouse),
+			media: clip.media
+				? Object.fromEntries(
+						Object.entries(clip.media).map(([k, v]) => [
+							k,
+							typeof v === "string" ? v : v?.entry || v?.path || true,
+						]),
+					)
+				: null,
+		})),
+		counts: {
+			clips: clips.length,
+			segments: sum(clips, (c) => (c.segments || []).length),
+			zoomRanges: (ps.zoomRanges || []).length,
+			animation3DRanges: (ps.animation3DRanges || []).length,
+			codeSnippets: (ps.codeSnippets || []).length,
+			stepSegments: (ps.stepSegments || []).length,
+			layoutRanges: (manifest?.layoutRanges || []).length,
+			titleCards: (manifest?.titleCards || []).length,
+			soundEffectSegments: (manifest?.soundEffectSegments || []).length,
+			shortcutSegments: (manifest?.shortcutSegments || []).length,
+		},
+		effects: {
+			camera: ps.cameraSettings ? Boolean(ps.cameraSettings.visible) : null,
+			crtMonitor: ps.crtMonitorEffectEnabled ?? null,
+			cursorAnimation: ps.cursorAnimationEnabled ?? null,
+			velocityBlur: ps.velocityBlurEnabled ?? null,
+			ultrathink: ps.ultrathinkEnabled ?? null,
+			cursorTheme: ps.selectedCursorTheme ?? null,
+		},
+		note: isEdited
+			? "This project has been saved from the editor — all player settings are present in the manifest."
+			: "This is a fresh recording: only basic settings exist. Opening it in the editor and saving writes the full settings.",
+	};
+}

package/src/protocol.mjs

@@ -0,0 +1,24 @@
+// MCP sunucusu — köprü protokolü sabitleri.
+// electron/agentBridge/protocol.cjs ile eşleşmeli.
+
+export const BRIDGE_PROTOCOL_VERSION = 1;
+export const ENDPOINT_FILENAME = "agent-bridge.json";
+
+export const MCP_PROTOCOL_VERSION = "2024-11-05";
+export const SERVER_NAME = "creavit-studio";
+export const SERVER_VERSION = "1.0.0";
+
+export const JSONRPC_ERRORS = {
+	PARSE_ERROR: -32700,
+	INVALID_REQUEST: -32600,
+	METHOD_NOT_FOUND: -32601,
+	INVALID_PARAMS: -32602,
+	INTERNAL_ERROR: -32603,
+};
+
+// Uygulama kapalıyken ajana ne yapması gerektiğini net söyle.
+export const APP_NOT_RUNNING_HINT =
+	"Creavit Studio is not running, or its agent bridge is disabled. Start the app " +
+	"(Creavit Studio.app, or `npm run electron:dev` in the repo). The bridge may also " +
+	"have been turned off with CREAVIT_AGENT_BRIDGE=0. Tools that work without the app: " +
+	"creavit_project_list, creavit_project_summary, creavit_project_manifest.";